@mflrevan/ucp 0.4.4 → 0.4.6

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

@@ -0,0 +1,326 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UCP.Bridge
+{
+    public static class HierarchyController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("object/create", HandleCreate);
+            router.Register("object/delete", HandleDelete);
+            router.Register("object/reparent", HandleReparent);
+            router.Register("object/instantiate", HandleInstantiate);
+            router.Register("object/add-component", HandleAddComponent);
+            router.Register("object/remove-component", HandleRemoveComponent);
+        }
+
+        private static object HandleCreate(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var name = "GameObject";
+            if (p != null && p.TryGetValue("name", out var nameObj) && nameObj != null)
+                name = nameObj.ToString();
+
+            var go = new GameObject(name);
+            Undo.RegisterCreatedObjectUndo(go, "UCP Create GameObject");
+
+            // Optional parent
+            if (p != null && p.TryGetValue("parent", out var parentObj))
+            {
+                int parentId = Convert.ToInt32(parentObj);
+                var parent = FindGameObject(parentId);
+                go.transform.SetParent(parent.transform, false);
+            }
+
+            // Optional position
+            if (p != null && p.TryGetValue("position", out var posObj) && posObj is List<object> pos && pos.Count >= 3)
+            {
+                go.transform.localPosition = new Vector3(
+                    Convert.ToSingle(pos[0]),
+                    Convert.ToSingle(pos[1]),
+                    Convert.ToSingle(pos[2]));
+            }
+
+            // Optional rotation (euler angles)
+            if (p != null && p.TryGetValue("rotation", out var rotObj) && rotObj is List<object> rot && rot.Count >= 3)
+            {
+                go.transform.localEulerAngles = new Vector3(
+                    Convert.ToSingle(rot[0]),
+                    Convert.ToSingle(rot[1]),
+                    Convert.ToSingle(rot[2]));
+            }
+
+            EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+            SceneChangeTracker.RecordGameObjectChange(go, "GameObject");
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["instanceId"] = go.GetInstanceID(),
+                ["name"] = go.name
+            };
+        }
+
+        private static object HandleDelete(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);
+            var go = FindGameObject(instanceId);
+            string name = go.name;
+            var scene = go.scene;
+
+            Undo.DestroyObjectImmediate(go);
+            EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+            SceneChangeTracker.RecordDeletedObject(scene, instanceId, name, "GameObject");
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["deleted"] = name,
+                ["instanceId"] = instanceId
+            };
+        }
+
+        private static object HandleReparent(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);
+            var go = FindGameObject(instanceId);
+
+            Undo.SetTransformParent(go.transform, null, "UCP Reparent");
+
+            if (p.TryGetValue("parent", out var parentObj) && parentObj != null)
+            {
+                int parentId = Convert.ToInt32(parentObj);
+                var parent = FindGameObject(parentId);
+                Undo.SetTransformParent(go.transform, parent.transform, "UCP Reparent");
+            }
+            // else: parent = null means move to root
+
+            // Optional sibling index
+            if (p.TryGetValue("siblingIndex", out var sibObj))
+            {
+                go.transform.SetSiblingIndex(Convert.ToInt32(sibObj));
+            }
+
+            EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+            SceneChangeTracker.RecordGameObjectChange(go, "Transform");
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["instanceId"] = instanceId,
+                ["name"] = go.name,
+                ["parent"] = go.transform.parent != null ? go.transform.parent.gameObject.name : null
+            };
+        }
+
+        private static object HandleInstantiate(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null)
+                throw new ArgumentException("Missing parameters");
+
+            GameObject source = null;
+
+            // Instantiate from prefab asset path
+            if (p.TryGetValue("prefab", out var prefabObj) && prefabObj != null)
+            {
+                string prefabPath = prefabObj.ToString();
+                var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
+                if (prefab == null)
+                    throw new ArgumentException($"Prefab not found: {prefabPath}");
+                source = prefab;
+            }
+            // Instantiate from existing scene object (clone)
+            else if (p.TryGetValue("sourceId", out var srcObj))
+            {
+                int srcId = Convert.ToInt32(srcObj);
+                source = FindGameObject(srcId);
+            }
+            else
+            {
+                throw new ArgumentException("Must provide 'prefab' (asset path) or 'sourceId' (instanceId)");
+            }
+
+            var instance = (GameObject)PrefabUtility.InstantiatePrefab(source);
+            if (instance == null)
+            {
+                // Fallback for non-prefab objects (e.g. cloning scene objects)
+                instance = UnityEngine.Object.Instantiate(source);
+            }
+
+            Undo.RegisterCreatedObjectUndo(instance, "UCP Instantiate");
+
+            // Optional parent
+            if (p.TryGetValue("parent", out var parentObj) && parentObj != null)
+            {
+                int parentId = Convert.ToInt32(parentObj);
+                var parent = FindGameObject(parentId);
+                instance.transform.SetParent(parent.transform, false);
+            }
+
+            // Optional name override
+            if (p.TryGetValue("name", out var nameObj) && nameObj != null)
+            {
+                instance.name = nameObj.ToString();
+            }
+
+            // Optional position
+            if (p.TryGetValue("position", out var posObj) && posObj is List<object> pos && pos.Count >= 3)
+            {
+                instance.transform.localPosition = new Vector3(
+                    Convert.ToSingle(pos[0]),
+                    Convert.ToSingle(pos[1]),
+                    Convert.ToSingle(pos[2]));
+            }
+
+            EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+            SceneChangeTracker.RecordGameObjectChange(instance, "GameObject");
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["instanceId"] = instance.GetInstanceID(),
+                ["name"] = instance.name
+            };
+        }
+
+        private static object HandleAddComponent(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");
+            if (!p.TryGetValue("type", out var typeObj) || typeObj == null)
+                throw new ArgumentException("Missing 'type' parameter");
+
+            int instanceId = Convert.ToInt32(idObj);
+            var go = FindGameObject(instanceId);
+            string typeName = typeObj.ToString();
+
+            // Resolve component type
+            Type compType = ResolveComponentType(typeName);
+            if (compType == null)
+                throw new ArgumentException($"Component type not found: {typeName}");
+
+            var comp = Undo.AddComponent(go, compType);
+            EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+            SceneChangeTracker.RecordGameObjectChange(go, comp.GetType().Name);
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["instanceId"] = instanceId,
+                ["component"] = comp.GetType().Name,
+                ["componentFullType"] = comp.GetType().FullName
+            };
+        }
+
+        private static object HandleRemoveComponent(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");
+            if (!p.TryGetValue("type", out var typeObj) || typeObj == null)
+                throw new ArgumentException("Missing 'type' parameter");
+
+            int instanceId = Convert.ToInt32(idObj);
+            var go = FindGameObject(instanceId);
+            string typeName = typeObj.ToString();
+
+            Component target = null;
+            foreach (var c in go.GetComponents<Component>())
+            {
+                if (c == null) continue;
+                if (c.GetType().Name == typeName || c.GetType().FullName == typeName)
+                {
+                    target = c;
+                    break;
+                }
+            }
+
+            if (target == null)
+                throw new ArgumentException($"Component '{typeName}' not found on '{go.name}'");
+            if (target is Transform)
+                throw new ArgumentException("Cannot remove Transform component");
+
+            Undo.DestroyObjectImmediate(target);
+            EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+            SceneChangeTracker.RecordGameObjectChange(go, typeName);
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["instanceId"] = instanceId,
+                ["removed"] = typeName
+            };
+        }
+
+        private static Type ResolveComponentType(string typeName)
+        {
+            // Try exact match first
+            var type = Type.GetType(typeName);
+            if (type != null && typeof(Component).IsAssignableFrom(type))
+                return type;
+
+            // Search Unity assemblies
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                foreach (var t in assembly.GetTypes())
+                {
+                    if (!typeof(Component).IsAssignableFrom(t)) continue;
+                    if (t.Name == typeName || t.FullName == typeName)
+                        return t;
+                }
+            }
+
+            // Common Unity types fallback
+            var unityType = Type.GetType($"UnityEngine.{typeName}, UnityEngine.CoreModule");
+            if (unityType != null && typeof(Component).IsAssignableFrom(unityType))
+                return unityType;
+
+            return null;
+        }
+
+        private static GameObject FindGameObject(int instanceId)
+        {
+            var obj = UnityObjectCompat.ResolveByInstanceId<GameObject>(instanceId);
+            if (obj != null) return obj;
+
+            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, instanceId);
+                    if (found != null) return found;
+                }
+            }
+
+            throw new ArgumentException($"GameObject not found: {instanceId}");
+        }
+
+        private static GameObject FindInHierarchy(GameObject go, int instanceId)
+        {
+            if (go.GetInstanceID() == 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;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8d90db77ca2967941a28a26f7af1adfe

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

@@ -0,0 +1,209 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace UCP.Bridge
+{
+    public static class ImporterController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("asset/reimport", HandleReimport);
+            router.Register("asset/import-settings/read", HandleRead);
+            router.Register("asset/import-settings/write", HandleWrite);
+            router.Register("asset/import-settings/write-batch", HandleWriteBatch);
+        }
+
+        private static object HandleReimport(string paramsJson)
+        {
+            var parameters = ParseParameters(paramsJson);
+            var requestedPath = RequirePath(parameters);
+            return AssetImportSupport.Reimport(requestedPath);
+        }
+
+        private static object HandleRead(string paramsJson)
+        {
+            var parameters = ParseParameters(paramsJson);
+            var requestedPath = RequirePath(parameters);
+            var importer = AssetImportSupport.ResolveImporter(requestedPath);
+            var serializedObject = new SerializedObject(importer);
+            var fields = new List<object>();
+
+            try
+            {
+                if (TryGetOptionalString(parameters, "field", out var fieldName))
+                {
+                    var property = serializedObject.FindProperty(fieldName);
+                    if (property == null)
+                        throw new ArgumentException($"Field '{fieldName}' not found on {importer.GetType().Name}");
+
+                    fields.Add(SerializedPropertyControllerSupport.Describe(property));
+                }
+                else
+                {
+                    var iterator = serializedObject.GetIterator();
+                    if (iterator.NextVisible(true))
+                    {
+                        do
+                        {
+                            fields.Add(SerializedPropertyControllerSupport.Describe(iterator));
+                        }
+                        while (iterator.NextVisible(false));
+                    }
+                }
+
+                return CreateImporterPayload(requestedPath, importer, fields);
+            }
+            finally
+            {
+                serializedObject.Dispose();
+            }
+        }
+
+        private static object HandleWrite(string paramsJson)
+        {
+            var parameters = ParseParameters(paramsJson);
+            var requestedPath = RequirePath(parameters);
+            if (!parameters.TryGetValue("field", out var fieldObject) || fieldObject == null)
+                throw new ArgumentException("Missing 'field' parameter");
+            if (!parameters.ContainsKey("value"))
+                throw new ArgumentException("Missing 'value' parameter");
+
+            var importer = AssetImportSupport.ResolveImporter(requestedPath);
+            var fieldName = fieldObject.ToString();
+            var noReimport = TryGetOptionalBool(parameters, "noReimport");
+            var serializedObject = new SerializedObject(importer);
+
+            try
+            {
+                Undo.RecordObject(importer, $"UCP Importer Write {fieldName}");
+                SerializedPropertyControllerSupport.WriteFieldValue(
+                    serializedObject,
+                    importer.GetType().Name,
+                    fieldName,
+                    parameters["value"]);
+                serializedObject.ApplyModifiedProperties();
+
+                return new Dictionary<string, object>
+                {
+                    ["status"] = "ok",
+                    ["path"] = requestedPath,
+                    ["assetPath"] = AssetImportSupport.GetPrimaryAssetPath(requestedPath),
+                    ["importerType"] = importer.GetType().Name,
+                    ["field"] = fieldName,
+                    ["reimport"] = AssetImportSupport.SaveImporterSettings(requestedPath, importer, noReimport)
+                };
+            }
+            finally
+            {
+                serializedObject.Dispose();
+            }
+        }
+
+        private static object HandleWriteBatch(string paramsJson)
+        {
+            var parameters = ParseParameters(paramsJson);
+            var requestedPath = RequirePath(parameters);
+            if (!parameters.TryGetValue("values", out var valuesObject) || !(valuesObject is Dictionary<string, object> values))
+                throw new ArgumentException("Missing 'values' parameter");
+
+            var importer = AssetImportSupport.ResolveImporter(requestedPath);
+            var noReimport = TryGetOptionalBool(parameters, "noReimport");
+            var serializedObject = new SerializedObject(importer);
+            var fields = new List<object>();
+
+            try
+            {
+                Undo.RecordObject(importer, $"UCP Importer Batch Write {importer.name}");
+
+                foreach (var entry in values)
+                {
+                    SerializedPropertyControllerSupport.WriteFieldValue(
+                        serializedObject,
+                        importer.GetType().Name,
+                        entry.Key,
+                        entry.Value);
+                    fields.Add(entry.Key);
+                }
+
+                serializedObject.ApplyModifiedProperties();
+
+                return new Dictionary<string, object>
+                {
+                    ["status"] = "ok",
+                    ["path"] = requestedPath,
+                    ["assetPath"] = AssetImportSupport.GetPrimaryAssetPath(requestedPath),
+                    ["importerType"] = importer.GetType().Name,
+                    ["fields"] = fields,
+                    ["reimport"] = AssetImportSupport.SaveImporterSettings(requestedPath, importer, noReimport)
+                };
+            }
+            finally
+            {
+                serializedObject.Dispose();
+            }
+        }
+
+        private static Dictionary<string, object> CreateImporterPayload(
+            string requestedPath,
+            AssetImporter importer,
+            List<object> fields)
+        {
+            var assetPath = AssetImportSupport.GetPrimaryAssetPath(requestedPath);
+            var mainAsset = AssetDatabase.LoadMainAssetAtPath(assetPath);
+
+            var payload = new Dictionary<string, object>
+            {
+                ["path"] = requestedPath,
+                ["assetPath"] = assetPath,
+                ["metaPath"] = assetPath + ".meta",
+                ["importerType"] = importer.GetType().Name,
+                ["fields"] = fields
+            };
+
+            if (mainAsset != null)
+            {
+                payload["assetName"] = mainAsset.name;
+                payload["assetType"] = mainAsset.GetType().Name;
+            }
+
+            return payload;
+        }
+
+        private static Dictionary<string, object> ParseParameters(string paramsJson)
+        {
+            return MiniJson.Deserialize(paramsJson) as Dictionary<string, object>
+                ?? throw new ArgumentException("Invalid parameters");
+        }
+
+        private static string RequirePath(Dictionary<string, object> parameters)
+        {
+            if (!parameters.TryGetValue("path", out var pathObject) || pathObject == null)
+                throw new ArgumentException("Missing 'path' parameter");
+
+            return pathObject.ToString();
+        }
+
+        private static bool TryGetOptionalString(
+            Dictionary<string, object> parameters,
+            string key,
+            out string value)
+        {
+            if (parameters.TryGetValue(key, out var valueObject) && valueObject != null)
+            {
+                value = valueObject.ToString();
+                return true;
+            }
+
+            value = null;
+            return false;
+        }
+
+        private static bool TryGetOptionalBool(Dictionary<string, object> parameters, string key)
+        {
+            return parameters.TryGetValue(key, out var valueObject)
+                && valueObject != null
+                && Convert.ToBoolean(valueObject);
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6c9bb0fa5d494cab8f4055d53d9e2812