@mflrevan/ucp 0.5.1 → 0.6.0

package/bridge/com.ucp.bridge/Editor/Controllers/SnapshotController.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using UnityEngine;
 using UnityEngine.SceneManagement;
 
@@ -10,6 +11,8 @@ namespace UCP.Bridge
         public static void Register(CommandRouter router)
         {
             router.Register("snapshot", HandleSnapshot);
+            router.Register("scene/query", HandleSceneQuery);
+            router.Register("object/get-children", HandleGetChildren);
             router.Register("objects/list", HandleListObjects);
             router.Register("objects/components", HandleGetComponents);
             router.Register("objects/transform", HandleGetTransform);
@@ -83,7 +86,7 @@ namespace UCP.Bridge
 
             var entry = new Dictionary<string, object>
             {
-                ["instanceId"] = go.GetInstanceID(),
+                ["instanceId"] = go.GetId(),
                 ["name"] = go.name,
                 ["active"] = go.activeSelf,
                 ["tag"] = go.tag,
@@ -120,20 +123,84 @@ namespace UCP.Bridge
             return new Dictionary<string, object> { ["objects"] = objects };
         }
 
-        private static void ListObjectsRecursive(GameObject go, List<object> list, int depth, int maxDepth)
+        private static object HandleSceneQuery(string paramsJson)
         {
-            list.Add(new Dictionary<string, object>
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("query", out var queryObj) || queryObj == null)
+                throw new ArgumentException("Missing 'query' parameter");
+
+            var query = ParseSceneQuery(queryObj.ToString());
+            var fields = ParseFields(p.TryGetValue("fields", out var fieldsObj) ? fieldsObj?.ToString() : null);
+            var maxDepth = 32;
+            if (p.TryGetValue("depth", out var depthObj) && depthObj != null)
+                maxDepth = Math.Max(0, Convert.ToInt32(depthObj));
+
+            var scene = SceneManager.GetActiveScene();
+            var results = new List<object>();
+            foreach (var root in scene.GetRootGameObjects())
+                QueryHierarchy(root, query, fields, results, 0, maxDepth);
+
+            return new Dictionary<string, object>
+            {
+                ["scene"] = scene.path,
+                ["sceneName"] = scene.name,
+                ["query"] = query.Raw,
+                ["count"] = results.Count,
+                ["objects"] = results
+            };
+        }
+
+        private static object HandleGetChildren(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("instanceId", out var idObj))
+                throw new ArgumentException("Missing 'instanceId' parameter");
+
+            int instanceId = Convert.ToInt32(idObj);
+            int maxDepth = 1;
+            if (p.TryGetValue("depth", out var depthObj))
+                maxDepth = Math.Max(1, Convert.ToInt32(depthObj));
+
+            var go = FindByInstanceId(instanceId);
+            if (go == null)
+                throw new Exception($"GameObject not found: {instanceId}");
+
+            var children = new List<object>();
+            int objectCount = 0;
+            int componentCount = 0;
+
+            for (int i = 0; i < go.transform.childCount; i++)
             {
-                ["instanceId"] = go.GetInstanceID(),
+                children.Add(SerializeGameObjectTree(
+                    go.transform.GetChild(i).gameObject,
+                    1,
+                    maxDepth,
+                    ref objectCount,
+                    ref componentCount));
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["instanceId"] = instanceId,
                 ["name"] = go.name,
                 ["active"] = go.activeSelf,
                 ["tag"] = go.tag,
                 ["layer"] = go.layer,
                 ["layerName"] = LayerMask.LayerToName(go.layer),
                 ["childCount"] = go.transform.childCount,
-                ["components"] = GetComponentTypes(go),
-                ["depth"] = depth
-            });
+                ["requestedDepth"] = maxDepth,
+                ["children"] = children,
+                ["stats"] = new Dictionary<string, object>
+                {
+                    ["objectCount"] = objectCount,
+                    ["componentCount"] = componentCount
+                }
+            };
+        }
+
+        private static void ListObjectsRecursive(GameObject go, List<object> list, int depth, int maxDepth)
+        {
+            list.Add(CreateGameObjectEntry(go, depth));
 
             if (depth < maxDepth)
             {
@@ -142,6 +209,140 @@ namespace UCP.Bridge
             }
         }
 
+        private static void QueryHierarchy(
+            GameObject go,
+            SceneQuery query,
+            HashSet<string> fields,
+            List<object> results,
+            int depth,
+            int maxDepth)
+        {
+            if (MatchesQuery(go, query))
+                results.Add(ProjectGameObject(go, fields, depth));
+
+            if (depth >= maxDepth)
+                return;
+
+            for (int i = 0; i < go.transform.childCount; i++)
+                QueryHierarchy(go.transform.GetChild(i).gameObject, query, fields, results, depth + 1, maxDepth);
+        }
+
+        private static Dictionary<string, object> ProjectGameObject(GameObject go, HashSet<string> fields, int depth)
+        {
+            var entry = new Dictionary<string, object>();
+            AddField(entry, fields, "instanceId", go.GetId());
+            AddField(entry, fields, "name", go.name);
+            AddField(entry, fields, "active", go.activeSelf);
+            AddField(entry, fields, "activeInHierarchy", go.activeInHierarchy);
+            AddField(entry, fields, "tag", go.tag);
+            AddField(entry, fields, "layer", go.layer);
+            AddField(entry, fields, "layerName", LayerMask.LayerToName(go.layer));
+            AddField(entry, fields, "depth", depth);
+            AddField(entry, fields, "childCount", go.transform.childCount);
+            AddField(entry, fields, "components", GetComponentTypes(go));
+            return entry;
+        }
+
+        private static void AddField(Dictionary<string, object> entry, HashSet<string> fields, string key, object value)
+        {
+            if (fields.Contains(key))
+                entry[key] = value;
+        }
+
+        private static HashSet<string> ParseFields(string raw)
+        {
+            var source = string.IsNullOrEmpty(raw) ? "instanceId,name,active,components" : raw;
+            return new HashSet<string>(
+                source.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+                    .Select(field => field.Trim()),
+                StringComparer.OrdinalIgnoreCase);
+        }
+
+        private static SceneQuery ParseSceneQuery(string raw)
+        {
+            var query = new SceneQuery { Raw = raw ?? string.Empty };
+            foreach (var token in SplitQuery(query.Raw))
+            {
+                var index = token.IndexOf('=');
+                if (index <= 0)
+                    throw new ArgumentException($"Unsupported query token '{token}'. Use key=value.");
+
+                var key = token.Substring(0, index).Trim().ToLowerInvariant();
+                var value = token.Substring(index + 1).Trim().Trim('"');
+                switch (key)
+                {
+                    case "name":
+                        query.Name = value;
+                        break;
+                    case "component":
+                    case "components":
+                        query.Component = value;
+                        break;
+                    case "active":
+                        query.Active = Convert.ToBoolean(value);
+                        break;
+                    case "tag":
+                        query.Tag = value;
+                        break;
+                    case "layer":
+                        query.Layer = value;
+                        break;
+                    default:
+                        throw new ArgumentException($"Unsupported scene query key '{key}'");
+                }
+            }
+
+            return query;
+        }
+
+        private static IEnumerable<string> SplitQuery(string raw)
+        {
+            return (raw ?? string.Empty)
+                .Replace(" AND ", " and ")
+                .Split(new[] { " and ", "," }, StringSplitOptions.RemoveEmptyEntries)
+                .Select(token => token.Trim())
+                .Where(token => token.Length > 0);
+        }
+
+        private static bool MatchesQuery(GameObject go, SceneQuery query)
+        {
+            if (!string.IsNullOrEmpty(query.Name)
+                && !go.name.Contains(query.Name, StringComparison.OrdinalIgnoreCase))
+                return false;
+            if (!string.IsNullOrEmpty(query.Component) && !HasComponent(go, query.Component))
+                return false;
+            if (query.Active.HasValue && go.activeSelf != query.Active.Value)
+                return false;
+            if (!string.IsNullOrEmpty(query.Tag) && !string.Equals(go.tag, query.Tag, StringComparison.OrdinalIgnoreCase))
+                return false;
+            if (!string.IsNullOrEmpty(query.Layer) && !LayerMatches(go.layer, query.Layer))
+                return false;
+
+            return true;
+        }
+
+        private static bool HasComponent(GameObject go, string componentName)
+        {
+            foreach (var component in go.GetComponents<Component>())
+            {
+                if (component == null)
+                    continue;
+                var type = component.GetType();
+                if (type.Name.Equals(componentName, StringComparison.OrdinalIgnoreCase)
+                    || (type.FullName != null && type.FullName.Equals(componentName, StringComparison.OrdinalIgnoreCase)))
+                    return true;
+            }
+
+            return false;
+        }
+
+        private static bool LayerMatches(int layer, string expected)
+        {
+            if (int.TryParse(expected, out var parsed))
+                return layer == parsed;
+            return string.Equals(LayerMask.LayerToName(layer), expected, StringComparison.OrdinalIgnoreCase);
+        }
+
         private static object HandleGetComponents(string paramsJson)
         {
             var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
@@ -202,8 +403,92 @@ namespace UCP.Bridge
 
         private static GameObject FindByInstanceId(int id)
         {
-            var obj = UnityObjectCompat.ResolveByInstanceId(id);
-            return obj as GameObject;
+            var direct = UnityObjectCompat.ResolveByInstanceId<GameObject>(id);
+            if (direct != null)
+                return direct;
+
+            for (int i = 0; i < SceneManager.sceneCount; i++)
+            {
+                var scene = SceneManager.GetSceneAt(i);
+                if (!scene.isLoaded)
+                    continue;
+
+                foreach (var root in scene.GetRootGameObjects())
+                {
+                    var found = FindInHierarchy(root, id);
+                    if (found != null)
+                        return found;
+                }
+            }
+
+            return null;
+        }
+
+        private static GameObject FindInHierarchy(GameObject go, int instanceId)
+        {
+            if (go.GetId() == instanceId)
+                return go;
+
+            for (int i = 0; i < go.transform.childCount; i++)
+            {
+                var found = FindInHierarchy(go.transform.GetChild(i).gameObject, instanceId);
+                if (found != null)
+                    return found;
+            }
+
+            return null;
+        }
+
+        private static Dictionary<string, object> SerializeGameObjectTree(
+            GameObject go,
+            int depth,
+            int maxDepth,
+            ref int objectCount,
+            ref int componentCount)
+        {
+            objectCount++;
+
+            var entry = CreateGameObjectEntry(go, depth, ref componentCount);
+            if (depth < maxDepth)
+            {
+                var children = new List<object>();
+                for (int i = 0; i < go.transform.childCount; i++)
+                {
+                    children.Add(SerializeGameObjectTree(
+                        go.transform.GetChild(i).gameObject,
+                        depth + 1,
+                        maxDepth,
+                        ref objectCount,
+                        ref componentCount));
+                }
+
+                if (children.Count > 0)
+                    entry["children"] = children;
+            }
+
+            return entry;
+        }
+
+        private static Dictionary<string, object> CreateGameObjectEntry(GameObject go, int depth)
+        {
+            int ignored = 0;
+            return CreateGameObjectEntry(go, depth, ref ignored);
+        }
+
+        private static Dictionary<string, object> CreateGameObjectEntry(GameObject go, int depth, ref int componentCount)
+        {
+            return new Dictionary<string, object>
+            {
+                ["instanceId"] = go.GetId(),
+                ["name"] = go.name,
+                ["active"] = go.activeSelf,
+                ["tag"] = go.tag,
+                ["layer"] = go.layer,
+                ["layerName"] = LayerMask.LayerToName(go.layer),
+                ["childCount"] = go.transform.childCount,
+                ["components"] = GetComponentTypes(go, ref componentCount),
+                ["depth"] = depth
+            };
         }
 
         private static List<object> GetComponentTypes(GameObject go)
@@ -223,5 +508,15 @@ namespace UCP.Bridge
             }
             return componentTypes;
         }
+
+        private sealed class SceneQuery
+        {
+            public string Raw;
+            public string Name;
+            public string Component;
+            public bool? Active;
+            public string Tag;
+            public string Layer;
+        }
     }
 }

package/bridge/com.ucp.bridge/Editor/Controllers/SpatialController.cs

@@ -0,0 +1,322 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UCP.Bridge
+{
+    /// <summary>
+    /// Spatial reasoning primitives so an agent can answer geometric questions about a scene
+    /// instead of inferring them from raw transforms: raycast, overlap, world bounds, drop-to-
+    /// surface (ground), and nearest-object search.
+    ///
+    /// Physics queries hit colliders only — objects without a Collider are invisible to
+    /// raycast/overlap/ground. 'bounds' and 'nearest' fall back to renderer bounds and so also
+    /// see render-only objects.
+    /// </summary>
+    public static class SpatialController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("physics/raycast", HandleRaycast);
+            router.Register("physics/overlap", HandleOverlap);
+            router.Register("object/bounds", HandleBounds);
+            router.Register("spatial/ground", HandleGround);
+            router.Register("spatial/nearest", HandleNearest);
+        }
+
+        private static object HandleRaycast(string paramsJson)
+        {
+            // Collider positions in the edit-mode physics scene can lag transform edits made via
+            // earlier RPCs; sync so queries see the current state.
+            Physics.SyncTransforms();
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var origin = RequireVec3(p, "origin");
+            var direction = RequireVec3(p, "direction");
+            if (direction.sqrMagnitude < 1e-8f)
+                throw new ArgumentException("'direction' must not be the zero vector");
+
+            var maxDistance = ReadFloat(p, "maxDistance", Mathf.Infinity);
+            var layerMask = ReadLayerMask(p);
+            var queryTriggers = ReadBool(p, "queryTriggers", false)
+                ? QueryTriggerInteraction.Collide
+                : QueryTriggerInteraction.Ignore;
+
+            if (Physics.Raycast(new Ray(origin, direction.normalized), out var hit, maxDistance, layerMask, queryTriggers))
+            {
+                return new Dictionary<string, object>
+                {
+                    ["status"] = "ok",
+                    ["hit"] = true,
+                    ["point"] = ObjectLocator.Vec3(hit.point),
+                    ["normal"] = ObjectLocator.Vec3(hit.normal),
+                    ["distance"] = hit.distance,
+                    ["instanceId"] = hit.collider.gameObject.GetId(),
+                    ["gameObject"] = hit.collider.gameObject.name,
+                    ["collider"] = hit.collider.GetType().Name
+                };
+            }
+
+            return new Dictionary<string, object> { ["status"] = "ok", ["hit"] = false };
+        }
+
+        private static object HandleOverlap(string paramsJson)
+        {
+            Physics.SyncTransforms();
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var shape = (ReadString(p, "shape") ?? "sphere").ToLowerInvariant();
+            var center = RequireVec3(p, "center");
+            var layerMask = ReadLayerMask(p);
+            var queryTriggers = ReadBool(p, "queryTriggers", false)
+                ? QueryTriggerInteraction.Collide
+                : QueryTriggerInteraction.Ignore;
+
+            Collider[] hits;
+            switch (shape)
+            {
+                case "sphere":
+                    hits = Physics.OverlapSphere(center, ReadFloat(p, "radius", 1f), layerMask, queryTriggers);
+                    break;
+                case "box":
+                    var half = ReadVec3Optional(p, "halfExtents") ?? Vector3.one * 0.5f;
+                    hits = Physics.OverlapBox(center, half, Quaternion.identity, layerMask, queryTriggers);
+                    break;
+                case "capsule":
+                    var end = ReadVec3Optional(p, "end") ?? center;
+                    hits = Physics.OverlapCapsule(center, end, ReadFloat(p, "radius", 1f), layerMask, queryTriggers);
+                    break;
+                default:
+                    throw new ArgumentException("'shape' must be 'sphere', 'box', or 'capsule'");
+            }
+
+            var list = new List<object>();
+            foreach (var c in hits)
+            {
+                if (c == null) continue;
+                list.Add(new Dictionary<string, object>
+                {
+                    ["instanceId"] = c.gameObject.GetId(),
+                    ["gameObject"] = c.gameObject.name,
+                    ["collider"] = c.GetType().Name,
+                    ["distance"] = Vector3.Distance(center, c.bounds.center)
+                });
+            }
+
+            return new Dictionary<string, object> { ["status"] = "ok", ["count"] = list.Count, ["hits"] = list };
+        }
+
+        private static object HandleBounds(string paramsJson)
+        {
+            // Collider bounds lag transform edits in edit mode; sync before reading them.
+            Physics.SyncTransforms();
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var go = ObjectLocator.Resolve(p);
+            var includeChildren = ReadBool(p, "includeChildren", true);
+
+            if (!ObjectLocator.TryComputeWorldBounds(go, includeChildren, out var bounds))
+            {
+                // No renderers/colliders: fall back to a zero-size box at the transform.
+                bounds = new Bounds(go.transform.position, Vector3.zero);
+                return new Dictionary<string, object>
+                {
+                    ["status"] = "ok",
+                    ["instanceId"] = go.GetId(),
+                    ["name"] = go.name,
+                    ["empty"] = true,
+                    ["center"] = ObjectLocator.Vec3(bounds.center),
+                    ["extents"] = ObjectLocator.Vec3(bounds.extents),
+                    ["size"] = ObjectLocator.Vec3(bounds.size),
+                    ["min"] = ObjectLocator.Vec3(bounds.min),
+                    ["max"] = ObjectLocator.Vec3(bounds.max)
+                };
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["instanceId"] = go.GetId(),
+                ["name"] = go.name,
+                ["empty"] = false,
+                ["center"] = ObjectLocator.Vec3(bounds.center),
+                ["extents"] = ObjectLocator.Vec3(bounds.extents),
+                ["size"] = ObjectLocator.Vec3(bounds.size),
+                ["min"] = ObjectLocator.Vec3(bounds.min),
+                ["max"] = ObjectLocator.Vec3(bounds.max)
+            };
+        }
+
+        private static object HandleGround(string paramsJson)
+        {
+            Physics.SyncTransforms();
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var direction = (ReadVec3Optional(p, "direction") ?? Vector3.down).normalized;
+            var maxDistance = ReadFloat(p, "maxDistance", 1000f);
+            var layerMask = ReadLayerMask(p);
+            var apply = ReadBool(p, "apply", true);
+
+            // Two modes: drop an object onto the surface, or just probe a point.
+            GameObject go = null;
+            Vector3 origin;
+            if (p != null && (p.ContainsKey("instanceId") || p.ContainsKey("id") || p.ContainsKey("path") || p.ContainsKey("name")))
+            {
+                go = ObjectLocator.Resolve(p);
+                origin = go.transform.position;
+            }
+            else
+            {
+                origin = RequireVec3(p, "point");
+            }
+
+            // Offset the ray start slightly against the cast direction so an object already
+            // resting on / overlapping the surface still registers a hit.
+            var start = origin - direction * 0.01f;
+            if (!Physics.Raycast(start, direction, out var hit, maxDistance, layerMask, QueryTriggerInteraction.Ignore))
+                return new Dictionary<string, object> { ["status"] = "ok", ["hit"] = false };
+
+            var result = new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["hit"] = true,
+                ["point"] = ObjectLocator.Vec3(hit.point),
+                ["normal"] = ObjectLocator.Vec3(hit.normal),
+                ["distance"] = hit.distance,
+                ["surface"] = hit.collider.gameObject.name,
+                ["surfaceId"] = hit.collider.gameObject.GetId()
+            };
+
+            if (go != null && apply)
+            {
+                // Rest the object's pivot on the surface, raised by the half-height of its
+                // bounds along the up axis so it sits on rather than through the surface.
+                var lift = 0f;
+                if (ObjectLocator.TryComputeWorldBounds(go, true, out var bounds))
+                {
+                    var pivotToBottom = go.transform.position.y - bounds.min.y;
+                    lift = Mathf.Max(pivotToBottom, 0f);
+                }
+                Undo.RecordObject(go.transform, "UCP Ground");
+                go.transform.position = hit.point + Vector3.up * lift;
+                EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+                SceneChangeTracker.RecordGameObjectChange(go, "Transform");
+                result["movedId"] = go.GetId();
+                result["restPosition"] = ObjectLocator.Vec3(go.transform.position);
+            }
+
+            return result;
+        }
+
+        private static object HandleNearest(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+
+            Vector3 from;
+            GameObject self = null;
+            if (p != null && (p.ContainsKey("instanceId") || p.ContainsKey("id") || p.ContainsKey("path") || p.ContainsKey("name")))
+            {
+                self = ObjectLocator.Resolve(p);
+                from = self.transform.position;
+            }
+            else
+            {
+                from = RequireVec3(p, "point");
+            }
+
+            var max = (int)ReadFloat(p, "max", 5f);
+            var componentFilter = ReadString(p, "component");
+            var tagFilter = ReadString(p, "tag");
+
+            var candidates = new List<(GameObject go, float dist)>();
+            for (var i = 0; i < SceneManager.sceneCount; i++)
+            {
+                var scene = SceneManager.GetSceneAt(i);
+                if (!scene.isLoaded) continue;
+                foreach (var root in scene.GetRootGameObjects())
+                    CollectNearest(root, from, self, componentFilter, tagFilter, candidates);
+            }
+
+            candidates.Sort((a, b) => a.dist.CompareTo(b.dist));
+            var list = new List<object>();
+            for (var i = 0; i < candidates.Count && i < max; i++)
+            {
+                var (go, dist) = candidates[i];
+                list.Add(new Dictionary<string, object>
+                {
+                    ["instanceId"] = go.GetId(),
+                    ["name"] = go.name,
+                    ["distance"] = dist,
+                    ["position"] = ObjectLocator.Vec3(go.transform.position)
+                });
+            }
+
+            return new Dictionary<string, object> { ["status"] = "ok", ["count"] = list.Count, ["objects"] = list };
+        }
+
+        private static void CollectNearest(GameObject go, Vector3 from, GameObject self,
+            string componentFilter, string tagFilter, List<(GameObject, float)> outList)
+        {
+            var include = go != self;
+            if (include && !string.IsNullOrEmpty(componentFilter) && go.GetComponent(componentFilter) == null)
+                include = false;
+            if (include && !string.IsNullOrEmpty(tagFilter) && !go.CompareTag(tagFilter))
+                include = false;
+            if (include)
+                outList.Add((go, Vector3.Distance(from, go.transform.position)));
+
+            foreach (Transform child in go.transform)
+                CollectNearest(child.gameObject, from, self, componentFilter, tagFilter, outList);
+        }
+
+        // --- param helpers -------------------------------------------------
+
+        private static Vector3 RequireVec3(Dictionary<string, object> p, string key)
+        {
+            var v = ReadVec3Optional(p, key);
+            if (!v.HasValue) throw new ArgumentException($"Missing '{key}' ([x,y,z]) parameter");
+            return v.Value;
+        }
+
+        private static Vector3? ReadVec3Optional(Dictionary<string, object> p, string key)
+        {
+            if (p == null || !p.TryGetValue(key, out var v) || v == null) return null;
+            if (v is not List<object> list || list.Count < 3)
+                throw new ArgumentException($"'{key}' must be an array of three numbers");
+            return new Vector3(Convert.ToSingle(list[0]), Convert.ToSingle(list[1]), Convert.ToSingle(list[2]));
+        }
+
+        private static float ReadFloat(Dictionary<string, object> p, string key, float dflt)
+        {
+            if (p != null && p.TryGetValue(key, out var v) && v != null) return Convert.ToSingle(v);
+            return dflt;
+        }
+
+        private static bool ReadBool(Dictionary<string, object> p, string key, bool dflt)
+        {
+            if (p != null && p.TryGetValue(key, out var v) && v is bool b) return b;
+            return dflt;
+        }
+
+        private static string ReadString(Dictionary<string, object> p, string key)
+        {
+            if (p != null && p.TryGetValue(key, out var v) && v != null) return v.ToString();
+            return null;
+        }
+
+        private static int ReadLayerMask(Dictionary<string, object> p)
+        {
+            // Accept an explicit int mask, or a single layer name, else everything.
+            if (p != null && p.TryGetValue("layerMask", out var v) && v != null)
+            {
+                if (v is string s)
+                {
+                    var layer = LayerMask.NameToLayer(s);
+                    if (layer < 0) throw new ArgumentException($"Unknown layer name '{s}'");
+                    return 1 << layer;
+                }
+                return Convert.ToInt32(v);
+            }
+            return ~0;
+        }
+    }
+}

package/bridge/com.ucp.bridge/Editor/Controllers/SpatialController.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2a3b4c5d6e7f8091a2b3c4d5e6f70819