From d984fdad504c85fa52dac9b6763641c227ae82dd Mon Sep 17 00:00:00 2001 From: Viktor Gaponenko Date: Wed, 12 Nov 2025 18:58:47 +0100 Subject: [PATCH] fix: snapping tool --- Documentation/Tools.meta | 3 + Documentation/Tools/SnappingTool.md | 73 +++++++++ Documentation/Tools/SnappingTool.md.meta | 3 + Editor/Scripts/SceneInteractionTool.cs | 2 +- .../{SnappingTool.meta => Snapping.meta} | 0 Editor/Scripts/Snapping/SnappingTool.cs | 148 ++++++++++++++++++ Editor/Scripts/Snapping/SnappingTool.cs.meta | 3 + .../SnappingTool/SnappingHandlesEditor.cs | 81 ---------- .../SnappingHandlesEditor.cs.meta | 3 - README.md | 33 +--- Runtime/Scripts/Common/Math.cs | 24 ++- .../Scripts/SnapingTool/SnappingHandles.cs | 9 -- Runtime/Scripts/SnapingTool/SnappingObject.cs | 46 ++++++ ...Handles.cs.meta => SnappingObject.cs.meta} | 0 .../{SnapPoint.cs => SnappingPoint.cs} | 58 ++----- ...napPoint.cs.meta => SnappingPoint.cs.meta} | 0 Samples/Demo/0.1 Devices.unity | 13 +- 17 files changed, 321 insertions(+), 178 deletions(-) create mode 100644 Documentation/Tools.meta create mode 100644 Documentation/Tools/SnappingTool.md create mode 100644 Documentation/Tools/SnappingTool.md.meta rename Editor/Scripts/{SnappingTool.meta => Snapping.meta} (100%) create mode 100644 Editor/Scripts/Snapping/SnappingTool.cs create mode 100644 Editor/Scripts/Snapping/SnappingTool.cs.meta delete mode 100644 Editor/Scripts/SnappingTool/SnappingHandlesEditor.cs delete mode 100644 Editor/Scripts/SnappingTool/SnappingHandlesEditor.cs.meta delete mode 100644 Runtime/Scripts/SnapingTool/SnappingHandles.cs create mode 100644 Runtime/Scripts/SnapingTool/SnappingObject.cs rename Runtime/Scripts/SnapingTool/{SnappingHandles.cs.meta => SnappingObject.cs.meta} (100%) rename Runtime/Scripts/SnapingTool/{SnapPoint.cs => SnappingPoint.cs} (50%) rename Runtime/Scripts/SnapingTool/{SnapPoint.cs.meta => SnappingPoint.cs.meta} (100%) diff --git a/Documentation/Tools.meta b/Documentation/Tools.meta new file mode 100644 index 0000000..e34a936 --- /dev/null +++ b/Documentation/Tools.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: 4bd42a82738945d68318b54b59f1befd +timeCreated: 1762969351 \ No newline at end of file diff --git a/Documentation/Tools/SnappingTool.md b/Documentation/Tools/SnappingTool.md new file mode 100644 index 0000000..c70b188 --- /dev/null +++ b/Documentation/Tools/SnappingTool.md @@ -0,0 +1,73 @@ +# Snapping Tool (Unity Editor) + +A lightweight editor tool for snapping modular objects together via **SnappingPoints**. + +--- + +## Overview +The **Snapping Tool** helps align modular objects in the Unity SceneView by snapping compatible points together with visual feedback. + +- Toggle tool with **`S`** key. +- Drag **SnappingPoints** to nearby compatible points. +- Bezier lines show possible snap targets (white = near, green = snap-ready). +- Release **LMB** to snap and align automatically. + +--- + +## Setup + +1. **Add Components** +![SnapPoint.png](../Images/SnapPoint.png) + - Attach `SnappingObject` to your modular prefab or GameObject. + - Add one or more `SnappingPoint` children. + - Set each point’s: + - **SnapType:** `Plug`, `Slot`, or `None` + - **GroupId:** to match compatible types + - **Parent:** assigned automatically (used to prevent self-snapping) + +2. **Activate Tool** + - Select a `SnappingObject` in the scene. + - Press **`S`** to toggle the **Snapping Tool**. + - If no object is selected, pressing `S` restores your previous tool. + +3. **Use** + - Drag a `Plug` point in SceneView. + - Hover near a compatible `Slot` (white line = search range, green line = snap range). + - Release mouse to snap and align the objects. + +![snapping.gif](../Images/snapping.gif) + +--- + +## Snap Rules + +A `Plug` point will snap to a `Slot` when: +- They have the **same GroupId**. +- They belong to **different parents**. +- The target point’s **SnapType** is not `Plug`. + +--- + +## Constants + +| Constant | Default | Description | +|-----------|----------|-------------| +| `RADIUS_SNAP` | 0.3 | Snap threshold | +| `RADIUS_SEARCH` | 1.0 | Search radius | +| `SNAP_TANGENT_LENGTH` | 1.0 | Bezier curve tangent scale | + +--- + +## Tips +- Only **Plugs** can be dragged to snap. +- Keep `GroupId`s consistent between matching parts. +- Make sure your project includes `Transform.GetMatrix/SetMatrix(ignoreScale: true)` helpers. + +--- + +**Shortcut:** `S` +**Namespace:** `OC.Editor` +**Tool Name:** *Snapping* +**Icon:** `d_Cubemap Icon` + +--- diff --git a/Documentation/Tools/SnappingTool.md.meta b/Documentation/Tools/SnappingTool.md.meta new file mode 100644 index 0000000..e84bd82 --- /dev/null +++ b/Documentation/Tools/SnappingTool.md.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: 20ab24ae805b4bb49a77728cce182b56 +timeCreated: 1762969368 \ No newline at end of file diff --git a/Editor/Scripts/SceneInteractionTool.cs b/Editor/Scripts/SceneInteractionTool.cs index 572c190..0118495 100644 --- a/Editor/Scripts/SceneInteractionTool.cs +++ b/Editor/Scripts/SceneInteractionTool.cs @@ -8,7 +8,7 @@ using UnityEngine; using UnityEngine.EventSystems; -namespace OC +namespace OC.Editor { [EditorTool("Scene Interaction")] [Icon(ICON)] diff --git a/Editor/Scripts/SnappingTool.meta b/Editor/Scripts/Snapping.meta similarity index 100% rename from Editor/Scripts/SnappingTool.meta rename to Editor/Scripts/Snapping.meta diff --git a/Editor/Scripts/Snapping/SnappingTool.cs b/Editor/Scripts/Snapping/SnappingTool.cs new file mode 100644 index 0000000..15bfa02 --- /dev/null +++ b/Editor/Scripts/Snapping/SnappingTool.cs @@ -0,0 +1,148 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEditor; +using UnityEditor.EditorTools; +using UnityEditor.ShortcutManagement; +using UnityEngine; + +namespace OC.Editor +{ + [EditorTool("Snapping", typeof(SnappingObject))] + [Icon(ICON)] + public class SnappingTool : EditorTool + { + private const string ICON = "d_Cubemap Icon"; + private const float RADIUS_SNAP = 0.3f; + private const float RADIUS_SEARCH = 1f; + private const float SNAP_TANGENT_LENGTH = 1f; + private List _sceneSnappingPoints; + private SnappingPoint _nearestSnappingPoint; + private int _selectedPointIndex; + + [Shortcut("Snapping Tool", typeof(SceneView), KeyCode.S)] + private static void SnappingToolShortcut() + { + if (Selection.GetFiltered(SelectionMode.TopLevel).Length > 0) + { + ToolManager.SetActiveTool(typeof(SnappingTool)); + } + else + { + ToolManager.RestorePreviousTool(); + } + } + + public override void OnActivated() + { + _sceneSnappingPoints = FindObjectsOfType().ToList(); + } + + public override void OnWillBeDeactivated() + { + _sceneSnappingPoints?.Clear(); + } + + public override void OnToolGUI(EditorWindow window) + { + var snappingObject = target as SnappingObject; + if (snappingObject == null) return; + + if (GUIUtility.hotControl == 0) + { + _selectedPointIndex = -1; + _nearestSnappingPoint = null; + } + + if (_selectedPointIndex > -1 && _nearestSnappingPoint != null) + { + var handleSize = HandleUtility.GetHandleSize(snappingObject.Points[_selectedPointIndex].transform.position); + var distance = Vector3.Distance(snappingObject.Points[_selectedPointIndex].transform.position, _nearestSnappingPoint.transform.position); + var scaledDistance = distance * handleSize; + + if (scaledDistance < RADIUS_SNAP) + { + DrawHandleBezier(snappingObject.Points[_selectedPointIndex].transform, _nearestSnappingPoint.transform, Color.green); + } + else if (scaledDistance < RADIUS_SEARCH) + { + DrawHandleBezier(snappingObject.Points[_selectedPointIndex].transform, _nearestSnappingPoint.transform, Color.white); + } + + var e = Event.current; + if (e.type == EventType.MouseUp && e.button == 0) + { + if (scaledDistance > RADIUS_SNAP) return; + var targetMatrix = Matrix4x4.TRS( + _nearestSnappingPoint.transform.position, + _nearestSnappingPoint.transform.rotation * Quaternion.AngleAxis(180, Vector3.up), + Vector3.one); + SetSnappingObjectMatrix(snappingObject, snappingObject.Points[_selectedPointIndex], targetMatrix); + e.Use(); + + //Reset state + _selectedPointIndex = -1; + _nearestSnappingPoint = null; + GUIUtility.hotControl = 0; + } + } + + for (var i = 0; i < snappingObject.Points.Count; i++) + { + var point = snappingObject.Points[i]; + if (point.SnapType is SnappingPoint.Type.Slot or SnappingPoint.Type.None) continue; + + EditorGUI.BeginChangeCheck(); + var targetPosition = Handles.PositionHandle(point.transform.position, point.transform.rotation); + var targetMatrix = Matrix4x4.TRS(targetPosition, point.transform.rotation, Vector3.one); + + if (EditorGUI.EndChangeCheck()) + { + _selectedPointIndex = i; + if (TryFindNearestSnappingPoint(point, RADIUS_SEARCH * HandleUtility.GetHandleSize(point.transform.position), out var snappingPoint)) + { + _nearestSnappingPoint = snappingPoint; + } + + SetSnappingObjectMatrix(snappingObject, point, targetMatrix); + } + } + } + + private void DrawHandleBezier(Transform from, Transform to, Color color) + { + var distance = Vector3.Distance(from.position, to.position); + var tangent = distance * 0.3f * SNAP_TANGENT_LENGTH; + var fromTangent = from.position + from.forward * tangent; + var toTangent = to.position + to.forward * tangent; + Handles.DrawBezier(from.position, to.position, fromTangent, toTangent, color, null, 5); + } + + private bool TryFindNearestSnappingPoint(SnappingPoint dragged, float radius, out SnappingPoint nearestSnappingPoint) + { + var distance = radius; + nearestSnappingPoint = null; + + foreach (var snappingPoint in _sceneSnappingPoints) + { + if (snappingPoint.Parent == dragged.Parent) continue; + if (snappingPoint.GroupId != dragged.GroupId) continue; + if (snappingPoint.SnapType == SnappingPoint.Type.Plug) continue; + var d = Vector3.Distance(snappingPoint.transform.position, dragged.transform.position); + if (!(d < distance)) continue; + distance = d; + nearestSnappingPoint = snappingPoint; + } + + return nearestSnappingPoint != null; + } + + private void SetSnappingObjectMatrix(SnappingObject snappingObject, SnappingPoint point, Matrix4x4 worldMatrix) + { + if (snappingObject == null) return; + var root = snappingObject.transform.GetMatrix(ignoreScale: true); + var offset = point.transform.GetMatrix(ignoreScale: true).inverse * root; + snappingObject.transform.SetMatrix(worldMatrix * offset); + Undo.RecordObject(snappingObject.transform, "Move SnappingObject"); + } + } +} \ No newline at end of file diff --git a/Editor/Scripts/Snapping/SnappingTool.cs.meta b/Editor/Scripts/Snapping/SnappingTool.cs.meta new file mode 100644 index 0000000..19036e9 --- /dev/null +++ b/Editor/Scripts/Snapping/SnappingTool.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: bea0d912b3ae401db6e8dc1d348cc765 +timeCreated: 1762338017 \ No newline at end of file diff --git a/Editor/Scripts/SnappingTool/SnappingHandlesEditor.cs b/Editor/Scripts/SnappingTool/SnappingHandlesEditor.cs deleted file mode 100644 index 2c18058..0000000 --- a/Editor/Scripts/SnappingTool/SnappingHandlesEditor.cs +++ /dev/null @@ -1,81 +0,0 @@ -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()) - { - 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(); - 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 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; - } - } - } -} \ No newline at end of file diff --git a/Editor/Scripts/SnappingTool/SnappingHandlesEditor.cs.meta b/Editor/Scripts/SnappingTool/SnappingHandlesEditor.cs.meta deleted file mode 100644 index 980cfa9..0000000 --- a/Editor/Scripts/SnappingTool/SnappingHandlesEditor.cs.meta +++ /dev/null @@ -1,3 +0,0 @@ -fileFormatVersion: 2 -guid: 1dcdf81140594ccf868187d6d5d0601f -timeCreated: 1749546627 \ No newline at end of file diff --git a/README.md b/README.md index fa3be90..05b3d85 100644 --- a/README.md +++ b/README.md @@ -1042,41 +1042,10 @@ 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`. +# [SnappingTool](Documentation/Tools/SnappingTool.md) ![Snapping in action](Documentation/Images/snapping.gif) - - # Contributing We welcome contributions from everyone and appreciate your effort to improve this project. diff --git a/Runtime/Scripts/Common/Math.cs b/Runtime/Scripts/Common/Math.cs index b9445f9..e5a7c0e 100644 --- a/Runtime/Scripts/Common/Math.cs +++ b/Runtime/Scripts/Common/Math.cs @@ -77,14 +77,30 @@ public static Vector3 GetClosestPointOnFiniteLine(Vector3 point, Vector3 p0, Vec return p0 + direction * project; } - public static Matrix4x4 GetMatrix(this Transform transform) + public static Matrix4x4 GetMatrix(this Transform transform, bool local = false, bool ignoreScale = false) { - return Matrix4x4.TRS(transform.position, transform.rotation, transform.localScale); + if (local) + { + var scale = ignoreScale ? Vector3.one : transform.localScale; + return Matrix4x4.TRS(transform.localPosition, transform.localRotation, scale); + } + else + { + var scale = ignoreScale ? Vector3.one : transform.lossyScale; + return Matrix4x4.TRS(transform.position, transform.rotation, scale); + } } - public static void SetMatrix(this Transform transform, Matrix4x4 matrix) + public static void SetMatrix(this Transform transform, Matrix4x4 matrix, bool local = false) { - transform.SetPositionAndRotation(matrix.GetPosition(), matrix.rotation); + if (local) + { + transform.SetLocalPositionAndRotation(matrix.GetPosition(), matrix.rotation); + } + else + { + transform.SetPositionAndRotation(matrix.GetPosition(), matrix.rotation); + } } public static Vector3 RotatePointAroundPivot(Vector3 point, Vector3 pivot, Vector3 angles) diff --git a/Runtime/Scripts/SnapingTool/SnappingHandles.cs b/Runtime/Scripts/SnapingTool/SnappingHandles.cs deleted file mode 100644 index c36a97d..0000000 --- a/Runtime/Scripts/SnapingTool/SnappingHandles.cs +++ /dev/null @@ -1,9 +0,0 @@ -using UnityEngine; - -namespace OC .SnappingTool -{ - public class SnappingHandles : MonoBehaviour - { - - } -} diff --git a/Runtime/Scripts/SnapingTool/SnappingObject.cs b/Runtime/Scripts/SnapingTool/SnappingObject.cs new file mode 100644 index 0000000..fb474bb --- /dev/null +++ b/Runtime/Scripts/SnapingTool/SnappingObject.cs @@ -0,0 +1,46 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; + +namespace OC +{ + [SelectionBase] + [ExecuteAlways] + public class SnappingObject : MonoBehaviour + { + public List Points => _points; + + [Header("References")] + [SerializeField] + private List _points; + + [Header("Gizmos")] + [SerializeField] + private bool _drawGizmos = true; + [SerializeField] + private float _gizmosRadius = 0.05f; + + private void OnValidate() + { + Refresh(); + } + + private void OnTransformChildrenChanged() + { + Refresh(); + } + + private void Refresh() + { + _points = GetComponentsInChildren().ToList(); + } + + private void OnDrawGizmos() + { + foreach (var point in Points) + { + point.DrawGizmos = _drawGizmos; + } + } + } +} diff --git a/Runtime/Scripts/SnapingTool/SnappingHandles.cs.meta b/Runtime/Scripts/SnapingTool/SnappingObject.cs.meta similarity index 100% rename from Runtime/Scripts/SnapingTool/SnappingHandles.cs.meta rename to Runtime/Scripts/SnapingTool/SnappingObject.cs.meta diff --git a/Runtime/Scripts/SnapingTool/SnapPoint.cs b/Runtime/Scripts/SnapingTool/SnappingPoint.cs similarity index 50% rename from Runtime/Scripts/SnapingTool/SnapPoint.cs rename to Runtime/Scripts/SnapingTool/SnappingPoint.cs index f784cec..77f4434 100644 --- a/Runtime/Scripts/SnapingTool/SnapPoint.cs +++ b/Runtime/Scripts/SnapingTool/SnappingPoint.cs @@ -1,65 +1,45 @@ using System; using UnityEngine; -using UnityEngine.Serialization; -namespace OC.SnapingTool +namespace OC { [ExecuteInEditMode] - public class SnapPoint : MonoBehaviour + public class SnappingPoint : MonoBehaviour { public int GroupId => _groupId; public GameObject Parent => _parent; - public Type SnapType => _type; + public Type SnapType => _type; + + public bool DrawGizmos + { + get => _drawGizmos; + set => _drawGizmos = value; + } + + public Color GizmosColor + { + get => _gizmosColor; + set => _gizmosColor = value; + } + [SerializeField] private int _groupId; - [SerializeField] private GameObject _parent; - - [FormerlySerializedAs("_snapType")] [SerializeField] private Type _type = Type.All; - [SerializeField] private bool _drawGizmos = true; - [SerializeField] private Color _gizmosColor = Color.blue; - [SerializeField] private float _gizmosRadius = 0.05f; - private Matrix4x4 _offset; - - private void SetOffset() - { - var parent = _parent.transform.GetMatrix(); - var point = transform.GetMatrix(); - _offset = parent.inverse * point; - } - - public void SetGlobalMatrix(Matrix4x4 matrix) - { - var result = matrix * _offset.inverse; - _parent.transform.SetMatrix(result); - } - - private void OnValidate() - { - //if (_parent == null) _parent = gameObject.transform.parent != null ? gameObject.transform.parent.gameObject : gameObject; - SetOffset(); - } - private void Reset() { _parent = gameObject.transform.parent != null ? gameObject.transform.parent.gameObject : gameObject; } - private void Update() - { - SetOffset(); - } - private void OnDrawGizmos() { if (!_drawGizmos) return; @@ -67,12 +47,6 @@ private void OnDrawGizmos() Gizmos.DrawSphere(transform.position, _gizmosRadius); } - public void SnapToPoint(Transform point) - { - var parentOffset = _parent.transform.position - transform.position; - _parent.transform.position = point.position + parentOffset; - } - [Flags] public enum Type { diff --git a/Runtime/Scripts/SnapingTool/SnapPoint.cs.meta b/Runtime/Scripts/SnapingTool/SnappingPoint.cs.meta similarity index 100% rename from Runtime/Scripts/SnapingTool/SnapPoint.cs.meta rename to Runtime/Scripts/SnapingTool/SnappingPoint.cs.meta diff --git a/Samples/Demo/0.1 Devices.unity b/Samples/Demo/0.1 Devices.unity index 0a35105..08f25f8 100644 --- a/Samples/Demo/0.1 Devices.unity +++ b/Samples/Demo/0.1 Devices.unity @@ -797,8 +797,8 @@ MonoBehaviour: _connected: _value: 0 _name: Cylinder_1 - _scenePath: MAIN.Devices.++Cylinders.Cylinder_1 - _clientPath: MAIN.Devices.`++Cylinders`.Cylinder_1 + _scenePath: MAIN.Devices.Cylinders.Cylinder_1 + _clientPath: MAIN.Devices.Cylinders.Cylinder_1 _type: FB_Cylinder _parent: {fileID: 0} _attributes: [] @@ -3949,8 +3949,8 @@ MonoBehaviour: _connected: _value: 0 _name: Cylinder_3 - _scenePath: MAIN.Devices.++Cylinders.Cylinder_3 - _clientPath: MAIN.Devices.`++Cylinders`.Cylinder_3 + _scenePath: MAIN.Devices.Cylinders.Cylinder_3 + _clientPath: MAIN.Devices.Cylinders.Cylinder_3 _type: FB_Cylinder _parent: {fileID: 0} _attributes: [] @@ -4928,6 +4928,7 @@ MonoBehaviour: m_EditorClassIdentifier: _productDataDirectories: - Name: RFID + Path: --- !u!1 &1571801102 GameObject: m_ObjectHideFlags: 0 @@ -5393,8 +5394,8 @@ MonoBehaviour: _connected: _value: 0 _name: Cylinder_2 - _scenePath: MAIN.Devices.++Cylinders.Cylinder_2 - _clientPath: MAIN.Devices.`++Cylinders`.Cylinder_2 + _scenePath: MAIN.Devices.Cylinders.Cylinder_2 + _clientPath: MAIN.Devices.Cylinders.Cylinder_2 _type: FB_Cylinder _parent: {fileID: 0} _attributes: []