Merge pull request #103 from OpenCommissioning/development

Development

Author: Preliy

Editor/Scripts/MaterialUtils.cs

@@ -8,13 +8,14 @@ namespace OC.Editor
 {
     public class MaterialUtils : EditorWindow
     {
+        private const string PREFS_MATERIAL_LAST = "PREFS_MaterialUtils_MATERIAL_LAST";
+        
         private ObjectField _objectField;
         private ObjectField _materialField;
         private GameObject _target;
         private Material _material;
 
-        
-        [MenuItem("Open Commissioning/Material Utils")]
+        [MenuItem("Open Commissioning/Tools/Material Utils")]
         public static void ShowMaterialManager()
         {
             var window = GetWindow<MaterialUtils>();
@@ -38,22 +39,45 @@ private void CreateGUI()
             rootVisualElement.Add(_objectField); 
             rootVisualElement.Add(_materialField); 
 
-            rootVisualElement.Add(new Button(ApplyMaterial)
+            rootVisualElement.Add(new Button(OnButtonClick)
             {
                 text = "Set for all"
             });
 
-            _objectField.RegisterCallback<ChangeEvent<Object>>((evt) =>
+            _objectField.RegisterCallback<ChangeEvent<Object>>(evt =>
             {
                 _target = (GameObject)evt.newValue;
             });
 
-            _materialField.RegisterCallback<ChangeEvent<Object>>((evt) =>
+            _materialField.RegisterCallback<ChangeEvent<Object>>(evt =>
             {
                 _material = (Material)evt.newValue;
             });
 
             OnSelectionChange();
+
+            _materialField.SetValueWithoutNotify(LoadMaterialFromPrefs());
+        }
+
+        private void OnDisable()
+        {
+            SafeMaterialPrefs(_material);
+        }
+
+        private Material LoadMaterialFromPrefs()
+        {
+            var id = PlayerPrefs.GetString(PREFS_MATERIAL_LAST);
+            return string.IsNullOrEmpty(id) ? null : AssetDatabase.LoadAssetAtPath<Material>(id);
+        }
+
+        private void SafeMaterialPrefs(Material material)
+        {
+            if (material == null) return;
+            var path = AssetDatabase.GetAssetPath(material);
+            if (string.IsNullOrEmpty(path)) return;
+            
+            PlayerPrefs.SetString(PREFS_MATERIAL_LAST, path);
+            PlayerPrefs.Save();
         }
 
         private void OnSelectionChange()
@@ -65,31 +89,51 @@ private void OnSelectionChange()
             }
         }
 
-        private void ApplyMaterial()
+        private void OnButtonClick() => ApplyMaterial(_target, _material);
+
+        private void ApplyMaterial(GameObject root, Material material)
         {
-            if (_target == null) return;
-            if (_material == null) return;
+            if (root == null) return;
+            if (material == null) return;
             var counter = 0;
 
-            var renderes = _target.GetComponentsInChildren<Renderer>();
-            foreach (var renderer in renderes)
+            var renderers = _target.GetComponentsInChildren<Renderer>(includeInactive: false);
+            if (renderers == null || renderers.Length == 0) return;
+
+            Undo.SetCurrentGroupName("Assign Material To Children");
+            var group = Undo.GetCurrentGroup();
+            
+            foreach (var renderer in renderers)
             {
-                Material[] materials = new Material[renderer.materials.Length];
-                if (renderer.materials.Length > 1)
+                if (renderer == null) continue;
+                Undo.RecordObject(renderer, "Assign Material To Children");
+                
+                var sharedMaterials = new Material[renderer.sharedMaterials.Length];
+
+                switch (sharedMaterials.Length)
                 {
-                    for (var i = 0; i < materials.Length; i++)
+                    case 0:
+                        continue;
+                    case 1:
+                        renderer.sharedMaterial = _material;
+                        counter++;
+                        break;
+                    case > 1:
                     {
-                        materials[i] = _material;
-                    }
+                        for (var i = 0; i < sharedMaterials.Length; i++)
+                        {
+                            sharedMaterials[i] = _material;
+                        }
 
-                    renderer.materials = materials;
-                    counter++;
+                        renderer.sharedMaterials = sharedMaterials;
+                        counter++;
+                        break;
+                    }
                 }
-                
-                renderer.material = _material;
             }
 
-            Debug.Log($"Materials Utils: {counter} materials are changed");
+            Undo.CollapseUndoOperations(group);
+            Debug.Log($"Material Utils: {counter} materials are changed");
         }
     }
 }

Runtime/Scripts/Common/Utils.cs

@@ -114,7 +114,10 @@ public static bool TryBoundBoxColliderSize(GameObject gameObject, out BoxCollide
                 boxCollider = gameObject.GetComponent<BoxCollider>();
                 if (boxCollider == null)
                 {
-                    throw new NullReferenceException("BoxCollider is null");
+#if UNITY_EDITOR
+                    boxCollider = UnityEditor.Undo.AddComponent<BoxCollider>(gameObject);
+#endif
+                    if (boxCollider == null) throw new NullReferenceException("BoxCollider is null");
                 }
 #if UNITY_EDITOR
                 UnityEditor.Undo.RecordObject(boxCollider, "Set Box Collider Bound Size");
@@ -123,6 +126,8 @@ public static bool TryBoundBoxColliderSize(GameObject gameObject, out BoxCollide
                 boxCollider.center = bounds.center;
                 boxCollider.size = bounds.size;
 
+                Debug.Log($"BoxCollider size for {gameObject.name} is {boxCollider.size}", gameObject);
+                
 #if UNITY_EDITOR
 
                 UnityEditor.EditorUtility.SetDirty(gameObject);
@@ -145,15 +150,23 @@ public static bool TryBoundBoxColliderSize(GameObject gameObject, out BoxCollide
         public static Bounds GetLocalBoundsForChildrenMeshes(GameObject gameObject)
         {
             var transform = gameObject.transform;
-            var localBounds = new Bounds(Vector3.zero, Vector3.zero);
             var filters = gameObject.GetComponentsInChildren<MeshFilter>();
+            var localBounds = new List<Bounds>();
+            
             foreach (var meshFilter in filters)
             {
                 var matrix = transform.localToWorldMatrix.inverse * meshFilter.transform.localToWorldMatrix;
                 var axisAlignedBounds = GeometryUtility.CalculateBounds(meshFilter.sharedMesh.vertices, matrix);
-                localBounds.Encapsulate(axisAlignedBounds);
+                localBounds.Add(axisAlignedBounds);
+            }
+
+            var result = localBounds[0];
+            for (var i = 1; i < localBounds.Count; i++)
+            {
+                result.Encapsulate(localBounds[i]);
             }
-            return localBounds;
+            
+            return result;
         }
     }
 }

Runtime/Scripts/MaterialFlow/GripperBase.cs

@@ -13,7 +13,6 @@ public abstract class GripperBase : Detector, IPayloadBuffer, ICustomInspector
     {
         public IPropertyReadOnly<bool> IsActive => _isActive;
         public IPropertyReadOnly<bool> IsPicked => _isPicked;
-
         public IReadOnlyList<Payload> Buffer => _buffer;
 
         [SerializeField]
@@ -68,6 +67,30 @@ private void Start()
             _initColliderCenter = _collider.center;
         }
 
+        public void Pick(bool pick)
+        {
+            if (pick)
+            {
+                Pick();
+            }
+            else
+            {
+                Place();
+            }
+        }
+
+        public void Place(bool place)
+        {
+            if (place)
+            {
+                Place();
+            }
+            else
+            {
+                Pick();
+            }
+        }
+
         public void Pick()
         {
             if (_isActive.Value) return;