@mflrevan/ucp 0.1.1 → 0.2.3

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

@@ -0,0 +1,295 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UCP.Bridge
+{
+    public static class MaterialController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("material/get-properties", HandleGetProperties);
+            router.Register("material/get-property", HandleGetProperty);
+            router.Register("material/set-property", HandleSetProperty);
+            router.Register("material/get-keywords", HandleGetKeywords);
+            router.Register("material/set-keyword", HandleSetKeyword);
+            router.Register("material/set-shader", HandleSetShader);
+        }
+
+        private static object HandleGetProperties(string paramsJson)
+        {
+            var mat = ResolveMaterial(paramsJson);
+            var shader = mat.shader;
+            int count = shader.GetPropertyCount();
+
+            var properties = new List<object>();
+            for (int i = 0; i < count; i++)
+            {
+                var propName = shader.GetPropertyName(i);
+                var propType = shader.GetPropertyType(i);
+                var propDesc = shader.GetPropertyDescription(i);
+
+                var propInfo = new Dictionary<string, object>
+                {
+                    ["name"] = propName,
+                    ["type"] = propType.ToString(),
+                    ["description"] = propDesc,
+                    ["value"] = ReadMaterialValue(mat, propName, propType)
+                };
+
+                properties.Add(propInfo);
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["material"] = mat.name,
+                ["shader"] = shader.name,
+                ["properties"] = properties
+            };
+        }
+
+        private static object HandleGetProperty(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("property", out var propObj))
+                throw new ArgumentException("Missing 'property' parameter");
+
+            var mat = ResolveMaterial(paramsJson);
+            string propName = propObj.ToString();
+            var shader = mat.shader;
+
+            int propIdx = shader.FindPropertyIndex(propName);
+            if (propIdx < 0)
+                throw new ArgumentException($"Property '{propName}' not found on shader {shader.name}");
+
+            var propType = shader.GetPropertyType(propIdx);
+
+            return new Dictionary<string, object>
+            {
+                ["material"] = mat.name,
+                ["property"] = propName,
+                ["type"] = propType.ToString(),
+                ["value"] = ReadMaterialValue(mat, propName, propType)
+            };
+        }
+
+        private static object HandleSetProperty(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("property", out var propObj))
+                throw new ArgumentException("Missing 'property' parameter");
+            if (!p.ContainsKey("value"))
+                throw new ArgumentException("Missing 'value' parameter");
+
+            var mat = ResolveMaterial(paramsJson);
+            string propName = propObj.ToString();
+            var shader = mat.shader;
+
+            int propIdx = shader.FindPropertyIndex(propName);
+            if (propIdx < 0)
+                throw new ArgumentException($"Property '{propName}' not found on shader {shader.name}");
+
+            var propType = shader.GetPropertyType(propIdx);
+            Undo.RecordObject(mat, $"UCP Set Material {propName}");
+            WriteMaterialValue(mat, propName, propType, p["value"]);
+            EditorUtility.SetDirty(mat);
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["material"] = mat.name,
+                ["property"] = propName
+            };
+        }
+
+        private static object HandleGetKeywords(string paramsJson)
+        {
+            var mat = ResolveMaterial(paramsJson);
+            var keywords = new List<object>();
+            foreach (var kw in mat.enabledKeywords)
+                keywords.Add(kw.name);
+
+            return new Dictionary<string, object>
+            {
+                ["material"] = mat.name,
+                ["keywords"] = keywords
+            };
+        }
+
+        private static object HandleSetKeyword(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("keyword", out var kwObj))
+                throw new ArgumentException("Missing 'keyword' parameter");
+            if (!p.TryGetValue("enabled", out var enObj))
+                throw new ArgumentException("Missing 'enabled' parameter");
+
+            var mat = ResolveMaterial(paramsJson);
+            string keyword = kwObj.ToString();
+            bool enabled = Convert.ToBoolean(enObj);
+
+            Undo.RecordObject(mat, $"UCP Set Keyword {keyword}");
+            if (enabled)
+                mat.EnableKeyword(keyword);
+            else
+                mat.DisableKeyword(keyword);
+            EditorUtility.SetDirty(mat);
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["material"] = mat.name,
+                ["keyword"] = keyword,
+                ["enabled"] = enabled
+            };
+        }
+
+        private static object HandleSetShader(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("shader", out var shaderObj))
+                throw new ArgumentException("Missing 'shader' parameter");
+
+            var mat = ResolveMaterial(paramsJson);
+            string shaderName = shaderObj.ToString();
+            var shader = Shader.Find(shaderName);
+            if (shader == null)
+                throw new ArgumentException($"Shader not found: {shaderName}");
+
+            Undo.RecordObject(mat, "UCP Set Shader");
+            mat.shader = shader;
+            EditorUtility.SetDirty(mat);
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["material"] = mat.name,
+                ["shader"] = shaderName
+            };
+        }
+
+        // ---- Helper methods ----
+
+        private static Material ResolveMaterial(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null)
+                throw new ArgumentException("Invalid parameters");
+
+            // Resolve by asset path
+            if (p.TryGetValue("path", out var pathObj) && pathObj != null)
+            {
+                string path = pathObj.ToString();
+                var mat = AssetDatabase.LoadAssetAtPath<Material>(path);
+                if (mat == null)
+                    throw new ArgumentException($"Material not found at: {path}");
+                return mat;
+            }
+
+            // Resolve by instanceId (scene object's renderer material)
+            if (p.TryGetValue("instanceId", out var idObj))
+            {
+                int instanceId = Convert.ToInt32(idObj);
+                var obj = EditorUtility.InstanceIDToObject(instanceId);
+
+                if (obj is Material directMat)
+                    return directMat;
+
+                if (obj is GameObject go)
+                {
+                    var renderer = go.GetComponent<Renderer>();
+                    if (renderer != null && renderer.sharedMaterial != null)
+                        return renderer.sharedMaterial;
+                }
+
+                throw new ArgumentException($"No material found for instance {instanceId}");
+            }
+
+            throw new ArgumentException("Provide 'path' or 'instanceId' to identify the material");
+        }
+
+        private static object ReadMaterialValue(Material mat, string propName, UnityEngine.Rendering.ShaderPropertyType propType)
+        {
+            switch (propType)
+            {
+                case ShaderPropertyType.Color:
+                    var c = mat.GetColor(propName);
+                    return new List<object> { (double)c.r, (double)c.g, (double)c.b, (double)c.a };
+                case ShaderPropertyType.Vector:
+                    var v = mat.GetVector(propName);
+                    return new List<object> { (double)v.x, (double)v.y, (double)v.z, (double)v.w };
+                case ShaderPropertyType.Float:
+                case ShaderPropertyType.Range:
+                    return (double)mat.GetFloat(propName);
+                case ShaderPropertyType.Texture:
+                    var tex = mat.GetTexture(propName);
+                    if (tex != null)
+                    {
+                        var texPath = AssetDatabase.GetAssetPath(tex);
+                        return new Dictionary<string, object>
+                        {
+                            ["name"] = tex.name,
+                            ["path"] = texPath,
+                            ["instanceId"] = tex.GetInstanceID()
+                        };
+                    }
+                    return null;
+                case ShaderPropertyType.Int:
+                    return mat.GetInteger(propName);
+                default:
+                    return null;
+            }
+        }
+
+        private static void WriteMaterialValue(Material mat, string propName, ShaderPropertyType propType, object value)
+        {
+            switch (propType)
+            {
+                case ShaderPropertyType.Color:
+                    if (value is List<object> ca && ca.Count >= 3)
+                        mat.SetColor(propName, new Color(
+                            Convert.ToSingle(ca[0]),
+                            Convert.ToSingle(ca[1]),
+                            Convert.ToSingle(ca[2]),
+                            ca.Count >= 4 ? Convert.ToSingle(ca[3]) : 1f));
+                    break;
+                case ShaderPropertyType.Vector:
+                    if (value is List<object> va && va.Count >= 4)
+                        mat.SetVector(propName, new Vector4(
+                            Convert.ToSingle(va[0]),
+                            Convert.ToSingle(va[1]),
+                            Convert.ToSingle(va[2]),
+                            Convert.ToSingle(va[3])));
+                    break;
+                case ShaderPropertyType.Float:
+                case ShaderPropertyType.Range:
+                    mat.SetFloat(propName, Convert.ToSingle(value));
+                    break;
+                case ShaderPropertyType.Int:
+                    mat.SetInteger(propName, Convert.ToInt32(value));
+                    break;
+                case ShaderPropertyType.Texture:
+                    if (value == null)
+                    {
+                        mat.SetTexture(propName, null);
+                    }
+                    else if (value is Dictionary<string, object> texDict)
+                    {
+                        if (texDict.TryGetValue("path", out var tp))
+                        {
+                            var tex = AssetDatabase.LoadAssetAtPath<Texture>(tp.ToString());
+                            mat.SetTexture(propName, tex);
+                        }
+                        else if (texDict.TryGetValue("instanceId", out var tid))
+                        {
+                            var tex = EditorUtility.InstanceIDToObject(Convert.ToInt32(tid)) as Texture;
+                            mat.SetTexture(propName, tex);
+                        }
+                    }
+                    break;
+            }
+        }
+    }
+}

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

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

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

@@ -0,0 +1,38 @@
+using UnityEditor;
+
+namespace UCP.Bridge
+{
+    public static class PlayModeController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("play", HandlePlay);
+            router.Register("stop", HandleStop);
+            router.Register("pause", HandlePause);
+        }
+
+        private static object HandlePlay(string paramsJson)
+        {
+            if (EditorApplication.isPlaying)
+                return new { status = "already_playing" };
+
+            EditorApplication.isPlaying = true;
+            return new { status = "ok" };
+        }
+
+        private static object HandleStop(string paramsJson)
+        {
+            if (!EditorApplication.isPlaying)
+                return new { status = "already_stopped" };
+
+            EditorApplication.isPlaying = false;
+            return new { status = "ok" };
+        }
+
+        private static object HandlePause(string paramsJson)
+        {
+            EditorApplication.isPaused = !EditorApplication.isPaused;
+            return new { status = "ok", paused = EditorApplication.isPaused };
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 647b22516c825e84da0f1815a6e0fa30

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

@@ -0,0 +1,242 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace UCP.Bridge
+{
+    public static class PrefabController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("prefab/status", HandleStatus);
+            router.Register("prefab/apply", HandleApply);
+            router.Register("prefab/revert", HandleRevert);
+            router.Register("prefab/unpack", HandleUnpack);
+            router.Register("prefab/create", HandleCreate);
+            router.Register("prefab/overrides", HandleOverrides);
+        }
+
+        private static object HandleStatus(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");
+
+            var go = EditorUtility.InstanceIDToObject(Convert.ToInt32(idObj)) as GameObject;
+            if (go == null)
+                throw new ArgumentException($"GameObject not found: {idObj}");
+
+            bool isPrefab = PrefabUtility.IsPartOfAnyPrefab(go);
+            bool isInstance = PrefabUtility.IsPartOfPrefabInstance(go);
+            bool isRoot = PrefabUtility.IsOutermostPrefabInstanceRoot(go);
+            bool hasOverrides = PrefabUtility.HasPrefabInstanceAnyOverrides(go, false);
+
+            var result = new Dictionary<string, object>
+            {
+                ["name"] = go.name,
+                ["isPrefab"] = isPrefab,
+                ["isInstance"] = isInstance,
+                ["isRoot"] = isRoot,
+                ["hasOverrides"] = hasOverrides
+            };
+
+            if (isInstance)
+            {
+                var source = PrefabUtility.GetCorrespondingObjectFromSource(go);
+                if (source != null)
+                {
+                    result["sourcePath"] = AssetDatabase.GetAssetPath(source);
+                    result["sourceName"] = source.name;
+                }
+            }
+
+            return result;
+        }
+
+        private static object HandleApply(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");
+
+            var go = EditorUtility.InstanceIDToObject(Convert.ToInt32(idObj)) as GameObject;
+            if (go == null)
+                throw new ArgumentException($"GameObject not found: {idObj}");
+
+            if (!PrefabUtility.IsPartOfPrefabInstance(go))
+                throw new ArgumentException("Object is not a prefab instance");
+
+            string assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(go);
+            PrefabUtility.ApplyPrefabInstance(go, InteractionMode.AutomatedAction);
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["assetPath"] = assetPath
+            };
+        }
+
+        private static object HandleRevert(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");
+
+            var go = EditorUtility.InstanceIDToObject(Convert.ToInt32(idObj)) as GameObject;
+            if (go == null)
+                throw new ArgumentException($"GameObject not found: {idObj}");
+
+            if (!PrefabUtility.IsPartOfPrefabInstance(go))
+                throw new ArgumentException("Object is not a prefab instance");
+
+            PrefabUtility.RevertPrefabInstance(go, InteractionMode.AutomatedAction);
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["name"] = go.name
+            };
+        }
+
+        private static object HandleUnpack(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");
+
+            bool completely = false;
+            if (p.TryGetValue("completely", out var compObj))
+                completely = Convert.ToBoolean(compObj);
+
+            var go = EditorUtility.InstanceIDToObject(Convert.ToInt32(idObj)) as GameObject;
+            if (go == null)
+                throw new ArgumentException($"GameObject not found: {idObj}");
+
+            if (!PrefabUtility.IsPartOfPrefabInstance(go))
+                throw new ArgumentException("Object is not a prefab instance");
+
+            var mode = completely
+                ? PrefabUnpackMode.Completely
+                : PrefabUnpackMode.OutermostRoot;
+
+            PrefabUtility.UnpackPrefabInstance(go, mode, InteractionMode.AutomatedAction);
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["name"] = go.name,
+                ["mode"] = mode.ToString()
+            };
+        }
+
+        private static object HandleCreate(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("path", out var pathObj))
+                throw new ArgumentException("Missing 'path' parameter");
+
+            var go = EditorUtility.InstanceIDToObject(Convert.ToInt32(idObj)) as GameObject;
+            if (go == null)
+                throw new ArgumentException($"GameObject not found: {idObj}");
+
+            string savePath = pathObj.ToString();
+
+            // Ensure directory exists
+            string dir = System.IO.Path.GetDirectoryName(savePath);
+            if (!string.IsNullOrEmpty(dir) && !AssetDatabase.IsValidFolder(dir))
+            {
+                CreateFoldersRecursive(dir);
+            }
+
+            bool success;
+            var prefab = PrefabUtility.SaveAsPrefabAsset(go, savePath, out success);
+
+            if (!success || prefab == null)
+                throw new InvalidOperationException($"Failed to create prefab at {savePath}");
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["path"] = savePath,
+                ["name"] = prefab.name,
+                ["instanceId"] = prefab.GetInstanceID()
+            };
+        }
+
+        private static object HandleOverrides(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");
+
+            var go = EditorUtility.InstanceIDToObject(Convert.ToInt32(idObj)) as GameObject;
+            if (go == null)
+                throw new ArgumentException($"GameObject not found: {idObj}");
+
+            if (!PrefabUtility.IsPartOfPrefabInstance(go))
+                throw new ArgumentException("Object is not a prefab instance");
+
+            var modifications = PrefabUtility.GetPropertyModifications(go);
+            var overrides = new List<object>();
+
+            if (modifications != null)
+            {
+                foreach (var mod in modifications)
+                {
+                    overrides.Add(new Dictionary<string, object>
+                    {
+                        ["target"] = mod.target?.GetType().Name ?? "null",
+                        ["propertyPath"] = mod.propertyPath,
+                        ["value"] = mod.value ?? ""
+                    });
+                }
+            }
+
+            var addedComponents = PrefabUtility.GetAddedComponents(go);
+            var added = new List<object>();
+            foreach (var ac in addedComponents)
+            {
+                added.Add(new Dictionary<string, object>
+                {
+                    ["component"] = ac.instanceComponent.GetType().Name,
+                    ["instanceId"] = ac.instanceComponent.GetInstanceID()
+                });
+            }
+
+            var removedComponents = PrefabUtility.GetRemovedComponents(go);
+            var removed = new List<object>();
+            foreach (var rc in removedComponents)
+            {
+                removed.Add(new Dictionary<string, object>
+                {
+                    ["component"] = rc.assetComponent.GetType().Name
+                });
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["name"] = go.name,
+                ["propertyModifications"] = overrides,
+                ["addedComponents"] = added,
+                ["removedComponents"] = removed
+            };
+        }
+
+        private static void CreateFoldersRecursive(string path)
+        {
+            var parts = path.Replace("\\", "/").Split('/');
+            string current = parts[0];
+            for (int i = 1; i < parts.Length; i++)
+            {
+                string next = current + "/" + parts[i];
+                if (!AssetDatabase.IsValidFolder(next))
+                    AssetDatabase.CreateFolder(current, parts[i]);
+                current = next;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 14f389b8e0d407c4da00f07435f44e39