@mflrevan/ucp 0.4.3 → 0.4.5

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

@@ -0,0 +1,355 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace UCP.Bridge
+{
+    public static class AssetImportSupport
+    {
+        private static string s_lastReimportedPathForTests;
+
+        public static string LastReimportedPathForTests => s_lastReimportedPathForTests;
+
+        public static void ClearTestState()
+        {
+            s_lastReimportedPathForTests = null;
+        }
+
+        public static bool SupportsAutomaticReimport(string requestedPath)
+        {
+            var assetPath = GetPrimaryAssetPath(requestedPath);
+            return !string.IsNullOrEmpty(assetPath) && IsProjectAssetPath(assetPath);
+        }
+
+        public static string GetPrimaryAssetPath(string requestedPath)
+        {
+            var normalized = NormalizePath(requestedPath);
+            if (string.IsNullOrEmpty(normalized))
+                return normalized;
+
+            if (normalized.EndsWith(".meta", StringComparison.OrdinalIgnoreCase))
+                normalized = normalized.Substring(0, normalized.Length - 5);
+
+            return normalized;
+        }
+
+        public static AssetImporter ResolveImporter(string requestedPath)
+        {
+            var assetPath = GetPrimaryAssetPath(requestedPath);
+            if (string.IsNullOrEmpty(assetPath))
+                throw new ArgumentException("Missing 'path' parameter");
+
+            var importer = AssetImporter.GetAtPath(assetPath);
+            if (importer == null)
+                throw new ArgumentException($"No asset importer found for: {requestedPath}");
+
+            return importer;
+        }
+
+        public static Dictionary<string, object> ReimportOrDescribe(string requestedPath, bool noReimport)
+        {
+            if (noReimport)
+                return CreateReimportResult(requestedPath, GetPrimaryAssetPath(requestedPath), false, true, "Skipped by request");
+
+            if (!SupportsAutomaticReimport(requestedPath))
+                return CreateReimportResult(
+                    requestedPath,
+                    GetPrimaryAssetPath(requestedPath),
+                    false,
+                    true,
+                    "Path is outside Unity-managed Assets/ or Packages/");
+
+            return Reimport(requestedPath);
+        }
+
+        public static Dictionary<string, object> Reimport(string requestedPath, bool forceSynchronous = true)
+        {
+            var assetPath = GetPrimaryAssetPath(requestedPath);
+            if (string.IsNullOrEmpty(assetPath))
+                throw new ArgumentException("Missing 'path' parameter");
+            if (!IsProjectAssetPath(assetPath))
+                throw new ArgumentException($"Path is not under Assets/ or Packages/: {requestedPath}");
+
+            var options = ImportAssetOptions.ForceUpdate;
+            if (forceSynchronous)
+                options |= ImportAssetOptions.ForceSynchronousImport;
+
+            AssetDatabase.ImportAsset(assetPath, options);
+            RecordReimport(assetPath);
+            return CreateReimportResult(requestedPath, assetPath, true, false, null);
+        }
+
+        public static Dictionary<string, object> SaveImporterSettings(string requestedPath, AssetImporter importer, bool noReimport)
+        {
+            if (importer == null)
+                throw new ArgumentNullException(nameof(importer));
+
+            var assetPath = GetPrimaryAssetPath(requestedPath);
+            if (string.IsNullOrEmpty(assetPath))
+                throw new ArgumentException("Missing 'path' parameter");
+
+            EditorUtility.SetDirty(importer);
+
+            if (noReimport)
+            {
+                AssetDatabase.WriteImportSettingsIfDirty(assetPath);
+                return CreateReimportResult(requestedPath, assetPath, false, true, "Skipped by request");
+            }
+
+            importer.SaveAndReimport();
+            RecordReimport(assetPath);
+            return CreateReimportResult(requestedPath, assetPath, true, false, null);
+        }
+
+        private static bool IsProjectAssetPath(string assetPath)
+        {
+            return assetPath.Equals("Assets", StringComparison.OrdinalIgnoreCase)
+                || assetPath.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase)
+                || assetPath.Equals("Packages", StringComparison.OrdinalIgnoreCase)
+                || assetPath.StartsWith("Packages/", StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static string NormalizePath(string path)
+        {
+            return path?.Trim().Replace('\\', '/');
+        }
+
+        private static void RecordReimport(string assetPath)
+        {
+            s_lastReimportedPathForTests = assetPath;
+        }
+
+        private static Dictionary<string, object> CreateReimportResult(
+            string requestedPath,
+            string assetPath,
+            bool reimported,
+            bool skipped,
+            string reason)
+        {
+            var importer = !string.IsNullOrEmpty(assetPath)
+                ? AssetImporter.GetAtPath(assetPath)
+                : null;
+
+            var result = new Dictionary<string, object>
+            {
+                ["requestedPath"] = requestedPath,
+                ["assetPath"] = assetPath,
+                ["reimported"] = reimported,
+                ["skipped"] = skipped
+            };
+
+            if (!string.IsNullOrEmpty(reason))
+                result["reason"] = reason;
+
+            if (importer != null)
+                result["importerType"] = importer.GetType().Name;
+
+            return result;
+        }
+    }
+
+    internal static class SerializedPropertyControllerSupport
+    {
+        public static Dictionary<string, object> Describe(SerializedProperty property)
+        {
+            return new Dictionary<string, object>
+            {
+                ["name"] = property.name,
+                ["propertyPath"] = property.propertyPath,
+                ["displayName"] = property.displayName,
+                ["type"] = property.propertyType.ToString(),
+                ["value"] = ReadValue(property)
+            };
+        }
+
+        public static object ReadValue(SerializedProperty property)
+        {
+            switch (property.propertyType)
+            {
+                case SerializedPropertyType.Integer:
+                    return property.intValue;
+                case SerializedPropertyType.Boolean:
+                    return property.boolValue;
+                case SerializedPropertyType.Float:
+                    return (double)property.floatValue;
+                case SerializedPropertyType.String:
+                    return property.stringValue;
+                case SerializedPropertyType.Color:
+                    var color = property.colorValue;
+                    return new List<object> { (double)color.r, (double)color.g, (double)color.b, (double)color.a };
+                case SerializedPropertyType.ObjectReference:
+                    return ObjectReferenceResolver.Serialize(property.objectReferenceValue);
+                case SerializedPropertyType.Enum:
+                    return property.enumValueIndex < property.enumDisplayNames.Length
+                        ? property.enumDisplayNames[property.enumValueIndex]
+                        : property.enumValueIndex.ToString();
+                case SerializedPropertyType.Vector2:
+                    var vector2 = property.vector2Value;
+                    return new List<object> { (double)vector2.x, (double)vector2.y };
+                case SerializedPropertyType.Vector3:
+                    var vector3 = property.vector3Value;
+                    return new List<object> { (double)vector3.x, (double)vector3.y, (double)vector3.z };
+                case SerializedPropertyType.Vector4:
+                    var vector4 = property.vector4Value;
+                    return new List<object> { (double)vector4.x, (double)vector4.y, (double)vector4.z, (double)vector4.w };
+                case SerializedPropertyType.Quaternion:
+                    var quaternion = property.quaternionValue;
+                    return new List<object> { (double)quaternion.x, (double)quaternion.y, (double)quaternion.z, (double)quaternion.w };
+                case SerializedPropertyType.Rect:
+                    var rect = property.rectValue;
+                    return new Dictionary<string, object>
+                    {
+                        ["x"] = (double)rect.x,
+                        ["y"] = (double)rect.y,
+                        ["width"] = (double)rect.width,
+                        ["height"] = (double)rect.height
+                    };
+                case SerializedPropertyType.Bounds:
+                    var bounds = property.boundsValue;
+                    return new Dictionary<string, object>
+                    {
+                        ["center"] = new List<object> { (double)bounds.center.x, (double)bounds.center.y, (double)bounds.center.z },
+                        ["size"] = new List<object> { (double)bounds.size.x, (double)bounds.size.y, (double)bounds.size.z }
+                    };
+                case SerializedPropertyType.ArraySize:
+                    return property.intValue;
+                case SerializedPropertyType.LayerMask:
+                    return property.intValue;
+                case SerializedPropertyType.Generic:
+                    if (property.isArray)
+                    {
+                        var items = new List<object>();
+                        for (var index = 0; index < property.arraySize; index++)
+                            items.Add(ReadValue(property.GetArrayElementAtIndex(index)));
+                        return items;
+                    }
+                    return $"<{property.propertyType}>";
+                default:
+                    return $"<{property.propertyType}>";
+            }
+        }
+
+        public static void WriteFieldValue(SerializedObject serializedObject, string ownerName, string fieldName, object value)
+        {
+            var property = serializedObject.FindProperty(fieldName);
+            if (property == null)
+                throw new ArgumentException($"Field '{fieldName}' not found on {ownerName}");
+
+            WriteValue(property, value);
+        }
+
+        public static void WriteValue(SerializedProperty property, object value)
+        {
+            switch (property.propertyType)
+            {
+                case SerializedPropertyType.Integer:
+                    property.intValue = Convert.ToInt32(value);
+                    break;
+                case SerializedPropertyType.Boolean:
+                    property.boolValue = Convert.ToBoolean(value);
+                    break;
+                case SerializedPropertyType.Float:
+                    property.floatValue = Convert.ToSingle(value);
+                    break;
+                case SerializedPropertyType.String:
+                    property.stringValue = value?.ToString() ?? string.Empty;
+                    break;
+                case SerializedPropertyType.Color:
+                    if (value is List<object> colorArray && colorArray.Count >= 3)
+                    {
+                        property.colorValue = new Color(
+                            Convert.ToSingle(colorArray[0]),
+                            Convert.ToSingle(colorArray[1]),
+                            Convert.ToSingle(colorArray[2]),
+                            colorArray.Count >= 4 ? Convert.ToSingle(colorArray[3]) : 1f);
+                        break;
+                    }
+                    throw new ArgumentException($"Expected an array for '{property.displayName}'");
+                case SerializedPropertyType.Enum:
+                    if (value is string enumString)
+                    {
+                        var enumIndex = Array.IndexOf(property.enumDisplayNames, enumString);
+                        if (enumIndex >= 0)
+                        {
+                            property.enumValueIndex = enumIndex;
+                            break;
+                        }
+
+                        if (int.TryParse(enumString, out var parsedEnumIndex))
+                        {
+                            property.enumValueIndex = parsedEnumIndex;
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        property.enumValueIndex = Convert.ToInt32(value);
+                        break;
+                    }
+
+                    throw new ArgumentException($"Enum value '{value}' is not valid for '{property.displayName}'");
+                case SerializedPropertyType.Vector2:
+                    if (value is List<object> vector2 && vector2.Count >= 2)
+                    {
+                        property.vector2Value = new Vector2(
+                            Convert.ToSingle(vector2[0]),
+                            Convert.ToSingle(vector2[1]));
+                        break;
+                    }
+                    throw new ArgumentException($"Expected a 2-item array for '{property.displayName}'");
+                case SerializedPropertyType.Vector3:
+                    if (value is List<object> vector3 && vector3.Count >= 3)
+                    {
+                        property.vector3Value = new Vector3(
+                            Convert.ToSingle(vector3[0]),
+                            Convert.ToSingle(vector3[1]),
+                            Convert.ToSingle(vector3[2]));
+                        break;
+                    }
+                    throw new ArgumentException($"Expected a 3-item array for '{property.displayName}'");
+                case SerializedPropertyType.Vector4:
+                    if (value is List<object> vector4 && vector4.Count >= 4)
+                    {
+                        property.vector4Value = new Vector4(
+                            Convert.ToSingle(vector4[0]),
+                            Convert.ToSingle(vector4[1]),
+                            Convert.ToSingle(vector4[2]),
+                            Convert.ToSingle(vector4[3]));
+                        break;
+                    }
+                    throw new ArgumentException($"Expected a 4-item array for '{property.displayName}'");
+                case SerializedPropertyType.Quaternion:
+                    if (value is List<object> quaternion && quaternion.Count >= 4)
+                    {
+                        property.quaternionValue = new Quaternion(
+                            Convert.ToSingle(quaternion[0]),
+                            Convert.ToSingle(quaternion[1]),
+                            Convert.ToSingle(quaternion[2]),
+                            Convert.ToSingle(quaternion[3]));
+                        break;
+                    }
+                    throw new ArgumentException($"Expected a 4-item array for '{property.displayName}'");
+                case SerializedPropertyType.ObjectReference:
+                    property.objectReferenceValue = ObjectReferenceResolver.Resolve(value, property.displayName);
+                    if (value != null && property.objectReferenceValue == null)
+                        throw new ArgumentException($"Unable to assign object reference to '{property.displayName}'");
+                    break;
+                case SerializedPropertyType.LayerMask:
+                    property.intValue = Convert.ToInt32(value);
+                    break;
+                case SerializedPropertyType.Generic:
+                    if (property.isArray && value is List<object> items)
+                    {
+                        property.arraySize = items.Count;
+                        for (var index = 0; index < items.Count; index++)
+                            WriteValue(property.GetArrayElementAtIndex(index), items[index]);
+                        break;
+                    }
+                    throw new ArgumentException($"Cannot write property of type {property.propertyType}");
+                default:
+                    throw new ArgumentException($"Cannot write property of type {property.propertyType}");
+            }
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4b7911d9ec664bfaa8ea0dc432513a47

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

@@ -0,0 +1,233 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+using UnityEngine;
+
+namespace UCP.Bridge
+{
+    public static class BuildController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("build/targets", HandleTargets);
+            router.Register("build/active-target", HandleActiveTarget);
+            router.Register("build/set-target", HandleSetTarget);
+            router.Register("build/scenes", HandleScenes);
+            router.Register("build/set-scenes", HandleSetScenes);
+            router.Register("build/start", HandleStart);
+            router.Register("build/defines", HandleDefines);
+            router.Register("build/set-defines", HandleSetDefines);
+        }
+
+        private static object HandleTargets(string paramsJson)
+        {
+            var targets = new List<object>();
+            foreach (BuildTarget bt in Enum.GetValues(typeof(BuildTarget)))
+            {
+                if ((int)bt < 0) continue;
+                var group = BuildPipeline.GetBuildTargetGroup(bt);
+                if (group == BuildTargetGroup.Unknown) continue;
+
+                bool isInstalled = BuildPipeline.IsBuildTargetSupported(group, bt);
+                targets.Add(new Dictionary<string, object>
+                {
+                    ["name"] = bt.ToString(),
+                    ["group"] = group.ToString(),
+                    ["installed"] = isInstalled,
+                    ["isActive"] = bt == EditorUserBuildSettings.activeBuildTarget
+                });
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["targets"] = targets,
+                ["active"] = EditorUserBuildSettings.activeBuildTarget.ToString(),
+                ["activeGroup"] = EditorUserBuildSettings.selectedBuildTargetGroup.ToString()
+            };
+        }
+
+        private static object HandleActiveTarget(string paramsJson)
+        {
+            return new Dictionary<string, object>
+            {
+                ["target"] = EditorUserBuildSettings.activeBuildTarget.ToString(),
+                ["group"] = EditorUserBuildSettings.selectedBuildTargetGroup.ToString()
+            };
+        }
+
+        private static object HandleSetTarget(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("target", out var targetObj))
+                throw new ArgumentException("Missing 'target' parameter");
+
+            string targetStr = targetObj.ToString();
+            if (!Enum.TryParse<BuildTarget>(targetStr, true, out var target))
+                throw new ArgumentException($"Unknown build target: {targetStr}");
+
+            var group = BuildPipeline.GetBuildTargetGroup(target);
+            bool success = EditorUserBuildSettings.SwitchActiveBuildTarget(group, target);
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = success ? "ok" : "failed",
+                ["target"] = target.ToString(),
+                ["group"] = group.ToString()
+            };
+        }
+
+        private static object HandleScenes(string paramsJson)
+        {
+            var scenes = new List<object>();
+            foreach (var scene in EditorBuildSettings.scenes)
+            {
+                scenes.Add(new Dictionary<string, object>
+                {
+                    ["path"] = scene.path,
+                    ["enabled"] = scene.enabled,
+                    ["guid"] = scene.guid.ToString()
+                });
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["scenes"] = scenes
+            };
+        }
+
+        private static object HandleSetScenes(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("scenes", out var scenesObj))
+                throw new ArgumentException("Missing 'scenes' parameter");
+
+            var sceneList = scenesObj as List<object>;
+            if (sceneList == null)
+                throw new ArgumentException("'scenes' must be an array");
+
+            var editorScenes = new List<EditorBuildSettingsScene>();
+            foreach (var s in sceneList)
+            {
+                if (s is Dictionary<string, object> sd)
+                {
+                    string path = sd.TryGetValue("path", out var pv) ? pv.ToString() : "";
+                    bool enabled = !sd.TryGetValue("enabled", out var ev) || Convert.ToBoolean(ev);
+                    editorScenes.Add(new EditorBuildSettingsScene(path, enabled));
+                }
+                else if (s is string path)
+                {
+                    editorScenes.Add(new EditorBuildSettingsScene(path, true));
+                }
+            }
+
+            EditorBuildSettings.scenes = editorScenes.ToArray();
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["count"] = editorScenes.Count
+            };
+        }
+
+        private static object HandleStart(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+
+            string outputPath = null;
+            if (p != null && p.TryGetValue("output", out var outObj) && outObj != null)
+                outputPath = outObj.ToString();
+
+            BuildOptions options = BuildOptions.None;
+            if (p != null && p.TryGetValue("development", out var devObj) && Convert.ToBoolean(devObj))
+                options |= BuildOptions.Development;
+
+            // Use build settings scenes
+            var scenes = EditorBuildSettings.scenes
+                .Where(s => s.enabled)
+                .Select(s => s.path)
+                .ToArray();
+
+            if (scenes.Length == 0)
+                throw new ArgumentException("No scenes enabled in build settings");
+
+            if (string.IsNullOrEmpty(outputPath))
+                outputPath = "Builds/" + EditorUserBuildSettings.activeBuildTarget.ToString() + "/Build";
+
+            var buildOptions = new BuildPlayerOptions
+            {
+                scenes = scenes,
+                locationPathName = outputPath,
+                target = EditorUserBuildSettings.activeBuildTarget,
+                options = options
+            };
+
+            var report = BuildPipeline.BuildPlayer(buildOptions);
+
+            var steps = new List<object>();
+            foreach (var step in report.steps)
+            {
+                steps.Add(new Dictionary<string, object>
+                {
+                    ["name"] = step.name,
+                    ["duration"] = step.duration.TotalSeconds
+                });
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["result"] = report.summary.result.ToString(),
+                ["totalTime"] = report.summary.totalTime.TotalSeconds,
+                ["totalSize"] = report.summary.totalSize,
+                ["totalErrors"] = report.summary.totalErrors,
+                ["totalWarnings"] = report.summary.totalWarnings,
+                ["outputPath"] = report.summary.outputPath,
+                ["steps"] = steps
+            };
+        }
+
+        private static object HandleDefines(string paramsJson)
+        {
+            var group = EditorUserBuildSettings.selectedBuildTargetGroup;
+            var namedTarget = NamedBuildTarget.FromBuildTargetGroup(group);
+            string defines = PlayerSettings.GetScriptingDefineSymbols(namedTarget);
+
+            return new Dictionary<string, object>
+            {
+                ["group"] = group.ToString(),
+                ["defines"] = defines,
+                ["list"] = defines.Split(';')
+                    .Where(s => !string.IsNullOrWhiteSpace(s))
+                    .Select(s => (object)s.Trim())
+                    .ToList()
+            };
+        }
+
+        private static object HandleSetDefines(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("defines", out var defObj))
+                throw new ArgumentException("Missing 'defines' parameter");
+
+            var group = EditorUserBuildSettings.selectedBuildTargetGroup;
+            string defines;
+
+            if (defObj is List<object> defList)
+                defines = string.Join(";", defList.Select(d => d.ToString()));
+            else
+                defines = defObj.ToString();
+
+            var namedTarget = NamedBuildTarget.FromBuildTargetGroup(group);
+            PlayerSettings.SetScriptingDefineSymbols(namedTarget, defines);
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["group"] = group.ToString(),
+                ["defines"] = defines
+            };
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 276774f304b6ff34c9be1bc41685e2f9

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

@@ -0,0 +1,26 @@
+using UnityEditor;
+using UnityEditor.Compilation;
+
+namespace UCP.Bridge
+{
+    public static class CompilationController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("compile", HandleCompile);
+            router.Register("refresh-assets", HandleRefresh);
+        }
+
+        private static object HandleCompile(string paramsJson)
+        {
+            CompilationPipeline.RequestScriptCompilation();
+            return new { status = "ok", message = "Compilation requested" };
+        }
+
+        private static object HandleRefresh(string paramsJson)
+        {
+            AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
+            return new { status = "ok", message = "Asset database refreshed" };
+        }
+    }
+}

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

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

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

@@ -0,0 +1,31 @@
+using UnityEditor;
+
+namespace UCP.Bridge
+{
+    public static class EditorController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("editor/status", HandleStatus);
+            router.Register("editor/quit", HandleQuit);
+        }
+
+        private static object HandleStatus(string paramsJson)
+        {
+            return new
+            {
+                compiling = EditorApplication.isCompiling,
+                updating = EditorApplication.isUpdating,
+                playing = EditorApplication.isPlaying,
+                willChangePlaymode = EditorApplication.isPlayingOrWillChangePlaymode,
+                timeSinceStartup = EditorApplication.timeSinceStartup
+            };
+        }
+
+        private static object HandleQuit(string paramsJson)
+        {
+            EditorApplication.delayCall += () => EditorApplication.Exit(0);
+            return new { status = "ok", message = "Unity editor shutdown requested" };
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4dfae33b6e324de8b6502bbf8e3e44cd