Merge pull request #93 from OpenCommissioning/development

Development

Author: Preliy

Documentation/Images/SnapPoint.png

@@ -0,0 +1,81 @@
+using System.Collections.Generic;
+using System.Linq;
+using OC.SnapingTool;
+using UnityEditor;
+using UnityEngine;
+
+namespace OC.SnappingTool
+{
+    [CustomEditor(typeof(SnappingHandles)), CanEditMultipleObjects]
+    public class SnappingHandlesEditor : UnityEditor.Editor
+    {
+        
+        private SnapPoint[] _allPoints;
+        private bool _hotkey;
+        private bool _focused;
+
+        private void OnSceneGUI()
+        {
+            HandleHotkeyEvent();
+            var handle = (SnappingHandles)target;
+
+            if (!_hotkey) return;
+            foreach (var snapPoint in handle.GetComponentsInChildren<SnapPoint>())
+            {
+                if (snapPoint.SnapType is SnapPoint.Type.Slot or SnapPoint.Type.None) continue;
+                var newTargetPosition =Handles.PositionHandle(snapPoint.transform.position, snapPoint.transform.rotation);
+                if (snapPoint.transform.position == newTargetPosition) continue;
+
+                Undo.RecordObject(snapPoint.Parent.transform, "Move SnapPoint Parent");
+                Undo.RecordObject(snapPoint.transform, "Move SnapPoint");
+
+                _allPoints = FindObjectsOfType<SnapPoint>();
+                var handleSize = HandleUtility.GetHandleSize(newTargetPosition);
+                var targetPoint = GetSnapPoint(newTargetPosition, snapPoint, _allPoints.ToList(), handleSize);
+
+                if (targetPoint)
+                {
+                    snapPoint.SetGlobalMatrix(targetPoint.transform.GetMatrix() * Matrix4x4.TRS(Vector3.zero,
+                        Quaternion.AngleAxis(180, Vector3.up), Vector3.one));
+                }
+                else
+                {
+                    var matrix = Matrix4x4.TRS(newTargetPosition, snapPoint.transform.rotation, Vector3.one);
+                    snapPoint.SetGlobalMatrix(matrix);
+                }
+            }
+        }
+
+        private static SnapPoint GetSnapPoint(Vector3 position, SnapPoint dragged, List<SnapPoint> points, float radius)
+        {
+            var distance = radius;
+            var index = -1;
+
+            for (var i = 0; i < points.Count; i++)
+            {
+                if (points[i].Parent == dragged.Parent) continue;
+                if (points[i].GroupId != dragged.GroupId) continue;
+                if (points[i].SnapType == SnapPoint.Type.Plug) continue;
+                var dist = Vector3.Distance(position, points[i].transform.position);
+                if (dist < distance)
+                {
+                    distance = dist;
+                    index = i;
+                }
+                else continue;
+            }
+
+            return index < 0 ? null : points[index];
+        }
+
+        private void HandleHotkeyEvent()
+        {
+            var e = Event.current;
+            if (e.keyCode == KeyCode.S)
+            {
+                if (e.type == EventType.KeyDown) _hotkey = Tools.hidden = true;
+                else if (e.type == EventType.KeyUp) _hotkey = Tools.hidden = false;
+            }
+        }
+    }
+}

Documentation/Images/SnapPoint.png.meta

@@ -1041,6 +1041,42 @@ You can call this function from the Material Flow component’s context menu in
 
 ![BoundBoxColliderSize_Inspector.png](Documentation/Images/BoundBoxColliderSize_Inspector.png)
 
+
+# Snapping Tool
+
+The Snapping Tool included in the package allows to snap GameObjects to other GameObjects on defined snap points. This functionality is used to align GameObjects in a scene with precision.
+
+## Usage
+
+### SnapPoint Class
+The `SnapPoint` class is used to define snapping points on a game object. It is visualized by a blue sphere gizmo.
+
+![SnapPoint Component](Documentation/Images/SnapPoint.png)
+
+- **Group Id**: Only SnapPoints with the same *Group Id* can snap to each other
+- **Parent**: The *Parent* property must be set to the GameObject that should move with the snapping points.
+- **Type**: Possible Types: *Plug* or *Slot*. Snap Points of *Plug* type can be dragged and snap to *Slot* Snap Points. *Slot* Snap Points can not be dragged.
+- **Draw Gizmos**, **Gizmos Color**, **Gizmos Radius**: controls the Gizmos
+
+### SnappingHandles Object
+Provides visual handles for all `SnapPoint` components in the GameObjects children.
+When the scene window is active and the GameObject containing the `SnappingHandles` component is selected, press the **S-Key** to display the handles. These handles can be used to drag the GameObject and snap it to other snap points if they are within proximity.
+
+![SnappingHandles Component](Documentation/Images/SnappingHandles.png)
+
+## Workflow
+
+1. Attach the `SnapPoint` class to a GameObject to define a snap point.
+2. Ensure that the *Parent* property of each `SnapPoint` is set to the GameObject that should be moved when dragging the SnapPoint.
+3. Attach the `SnappingHandles` object to the GameObject that should be moved.
+4. In the scene window, select the GameObject with the `SnappingHandles` component.
+5. Press the **S-Key** to display the snapping handles.
+6. Use the handles to drag the GameObject and snap it to other `SnapPoints`.
+
+![Snapping in action](Documentation/Images/snapping.gif)
+
+
+
 # Contributing
 
 We welcome contributions from everyone and appreciate your effort to improve this project.