Merge branch 'CoplayDev:beta' into beta

Scriptwonder · web-flow · commit 23dd9d4416e4 · 2026-03-25T13:01:10.000-04:00
diff --git a/MCPForUnity/Editor/Tools/ManageTexture.cs b/MCPForUnity/Editor/Tools/ManageTexture.cs
@@ -27,7 +27,8 @@ public static class ManageTexture
             "create_sprite",
             "apply_pattern",
             "apply_gradient",
-            "apply_noise"
+            "apply_noise",
+            "set_import_settings"
         };
 
         private static ErrorResponse ValidateDimensions(int width, int height, List<string> warnings)
@@ -78,6 +79,8 @@ public static object HandleCommand(JObject @params)
                         return ApplyGradient(@params);
                     case "apply_noise":
                         return ApplyNoise(@params);
+                    case "set_import_settings":
+                        return SetImportSettings(@params);
                     default:
                         return new ErrorResponse($"Unknown action: '{action}'");
                 }
@@ -254,20 +257,36 @@ private static object ModifyTexture(JObject @params)
 
             try
             {
-                Texture2D texture = AssetDatabase.LoadAssetAtPath<Texture2D>(fullPath);
-                if (texture == null)
-                    return new ErrorResponse($"Failed to load texture at path: {fullPath}");
+                var setPixelsToken = @params["setPixels"] as JObject;
+                bool hasImportSettings = HasImportSettingsParams(@params);
 
-                // Make the texture readable
-                string absolutePath = GetAbsolutePath(fullPath);
-                byte[] fileData = File.ReadAllBytes(absolutePath);
-                Texture2D editableTexture = new Texture2D(texture.width, texture.height, TextureFormat.RGBA32, false);
-                editableTexture.LoadImage(fileData);
+                // Validate import settings before any writes
+                if (hasImportSettings)
+                {
+                    var validationError = ValidateImportSettingsParams(@params);
+                    if (validationError != null) return validationError;
+                }
 
-                // Apply modifications
-                var setPixelsToken = @params["setPixels"] as JObject;
+                // Fast path: only import settings, no pixel changes
+                if (setPixelsToken == null && hasImportSettings)
+                {
+                    var error = ApplyImportSettingsParams(fullPath, @params);
+                    if (error != null) return error;
+                    return new SuccessResponse($"Texture modified: {fullPath}");
+                }
+
+                // Pixel modification path
                 if (setPixelsToken != null)
                 {
+                    Texture2D texture = AssetDatabase.LoadAssetAtPath<Texture2D>(fullPath);
+                    if (texture == null)
+                        return new ErrorResponse($"Failed to load texture at path: {fullPath}");
+
+                    string absolutePath = GetAbsolutePath(fullPath);
+                    byte[] fileData = File.ReadAllBytes(absolutePath);
+                    Texture2D editableTexture = new Texture2D(texture.width, texture.height, TextureFormat.RGBA32, false);
+                    editableTexture.LoadImage(fileData);
+
                     int x = setPixelsToken["x"]?.ToObject<int>() ?? 0;
                     int y = setPixelsToken["y"]?.ToObject<int>() ?? 0;
                     int w = setPixelsToken["width"]?.ToObject<int>() ?? 1;
@@ -307,22 +326,25 @@ private static object ModifyTexture(JObject @params)
                         UnityEngine.Object.DestroyImmediate(editableTexture);
                         return new ErrorResponse("setPixels requires 'color' or 'pixels'.");
                     }
-                }
 
-                editableTexture.Apply();
+                    editableTexture.Apply();
 
-                // Save back to disk
-                byte[] imageData = TextureOps.EncodeTexture(editableTexture, fullPath);
-                if (imageData == null || imageData.Length == 0)
-                {
+                    byte[] imageData = TextureOps.EncodeTexture(editableTexture, fullPath);
+                    if (imageData == null || imageData.Length == 0)
+                    {
+                        UnityEngine.Object.DestroyImmediate(editableTexture);
+                        return new ErrorResponse($"Failed to encode texture for '{fullPath}'");
+                    }
+                    File.WriteAllBytes(absolutePath, imageData);
+                    AssetDatabase.ImportAsset(fullPath, ImportAssetOptions.ForceUpdate);
                     UnityEngine.Object.DestroyImmediate(editableTexture);
-                    return new ErrorResponse($"Failed to encode texture for '{fullPath}'");
                 }
-                File.WriteAllBytes(absolutePath, imageData);
 
-                AssetDatabase.ImportAsset(fullPath, ImportAssetOptions.ForceUpdate);
-
-                UnityEngine.Object.DestroyImmediate(editableTexture);
+                if (hasImportSettings)
+                {
+                    var importError = ApplyImportSettingsParams(fullPath, @params);
+                    if (importError != null) return importError;
+                }
 
                 return new SuccessResponse($"Texture modified: {fullPath}");
             }
@@ -703,6 +725,85 @@ private static void ApplyPerlinNoise(Texture2D texture, List<Color32> palette, f
             }
         }
 
+        private static bool HasImportSettingsParams(JObject @params)
+        {
+            JToken importSettingsToken = @params["import_settings"] ?? @params["importSettings"];
+            JToken asSpriteToken = @params["as_sprite"] ?? @params["spriteSettings"];
+
+            bool hasImportSettings = importSettingsToken is JObject importObject && importObject.HasValues;
+            bool hasSpriteSettings = (asSpriteToken is JObject spriteObject && spriteObject.HasValues)
+                || (asSpriteToken?.Type == JTokenType.Boolean && asSpriteToken.ToObject<bool>());
+
+            return hasImportSettings || hasSpriteSettings;
+        }
+
+        private static object ValidateImportSettingsParams(JObject @params)
+        {
+            JToken importSettingsToken = @params["import_settings"] ?? @params["importSettings"];
+            JToken asSpriteToken = @params["as_sprite"] ?? @params["spriteSettings"];
+
+            if (importSettingsToken != null && asSpriteToken != null)
+            {
+                return new ErrorResponse("Cannot specify both 'import_settings' and 'as_sprite'.");
+            }
+            return null;
+        }
+
+        private static object ApplyImportSettingsParams(string fullPath, JObject @params)
+        {
+            JToken importSettingsToken = @params["import_settings"] ?? @params["importSettings"];
+            JToken asSpriteToken = @params["as_sprite"] ?? @params["spriteSettings"];
+
+            if (importSettingsToken != null && asSpriteToken != null)
+            {
+                return new ErrorResponse(
+                    "Cannot specify both 'import_settings' and 'as_sprite'. " +
+                    "Use 'import_settings' with textureType='Sprite' instead.");
+            }
+
+            if (importSettingsToken != null)
+            {
+                ConfigureTextureImporter(fullPath, importSettingsToken);
+            }
+            else if (asSpriteToken != null &&
+                     (asSpriteToken.Type == JTokenType.Boolean ? asSpriteToken.ToObject<bool>() : true))
+            {
+                ConfigureAsSprite(fullPath, asSpriteToken.Type == JTokenType.Object ? asSpriteToken : null);
+            }
+
+            return null;
+        }
+
+        private static object SetImportSettings(JObject @params)
+        {
+            var toolParams = new MCPForUnity.Editor.Helpers.ToolParams(@params);
+            var pathResult = toolParams.GetRequired("path", "'path' is required for set_import_settings.");
+            if (!pathResult.IsSuccess)
+                return new ErrorResponse(pathResult.ErrorMessage);
+            string path = pathResult.Value;
+
+            string fullPath = AssetPathUtility.SanitizeAssetPath(path);
+            if (!AssetExists(fullPath))
+                return new ErrorResponse($"Texture not found at path: {fullPath}");
+
+            try
+            {
+                if (!HasImportSettingsParams(@params))
+                {
+                    return new ErrorResponse("Either 'import_settings' or 'as_sprite' is required.");
+                }
+
+                var error = ApplyImportSettingsParams(fullPath, @params);
+                if (error != null) return error;
+
+                return new SuccessResponse($"Import settings updated for: {fullPath}", new { path = fullPath });
+            }
+            catch (Exception e)
+            {
+                return new ErrorResponse($"Failed to set import settings: {e.Message}");
+            }
+        }
+
         private static void ConfigureAsSprite(string path, JToken spriteSettings)
         {
             TextureImporter importer = AssetImporter.GetAtPath(path) as TextureImporter;
diff --git a/MCPForUnity/package.json b/MCPForUnity/package.json
@@ -1,6 +1,6 @@
 {
   "name": "com.coplaydev.unity-mcp",
-  "version": "9.6.3-beta.5",
+  "version": "9.6.3-beta.6",
   "displayName": "MCP for Unity",
   "description": "A bridge that connects AI assistants to Unity via the MCP (Model Context Protocol). Allows AI clients like Claude Code, Cursor, and VSCode to directly control your Unity Editor for enhanced development workflows.\n\nFeatures automated setup wizard, cross-platform support, and seamless integration with popular AI development tools.\n\nJoin Our Discord: https://discord.gg/y4p8KfzrN4",
   "unity": "2021.3",
diff --git a/Server/src/cli/commands/texture.py b/Server/src/cli/commands/texture.py
@@ -481,29 +481,113 @@ def sprite(path: str, width: int, height: int, image_path: Optional[str], color:
         print_success(f"Created sprite: {path}")
 
 
+def _build_import_settings_from_flags(
+    texture_type: Optional[str],
+    sprite_mode: Optional[str],
+    sprite_ppu: Optional[float],
+    max_size: Optional[str],
+    compression: Optional[str],
+    generate_mipmaps: Optional[bool],
+    srgb: Optional[bool],
+    readable: Optional[bool],
+) -> dict[str, Any]:
+    """Build importSettings dict from CLI flags. Returns empty dict if no flags set."""
+    import_settings: dict[str, Any] = {}
+    if texture_type:
+        import_settings["textureType"] = _TEXTURE_TYPES[texture_type]
+    if sprite_mode:
+        import_settings["spriteImportMode"] = _SPRITE_MODES[sprite_mode]
+    if sprite_ppu is not None:
+        import_settings["spritePixelsPerUnit"] = sprite_ppu
+    if max_size:
+        import_settings["maxTextureSize"] = int(max_size)
+    if compression:
+        import_settings["textureCompression"] = _COMPRESSIONS[compression]
+    if generate_mipmaps is not None:
+        import_settings["mipmapEnabled"] = generate_mipmaps
+    if srgb is not None:
+        import_settings["sRGBTexture"] = srgb
+    if readable is not None:
+        import_settings["isReadable"] = readable
+    return import_settings
+
+
+def _apply_import_flags_to_params(
+    params: dict[str, Any],
+    texture_type: Optional[str],
+    sprite_mode: Optional[str],
+    sprite_ppu: Optional[float],
+    max_size: Optional[str],
+    compression: Optional[str],
+    generate_mipmaps: Optional[bool],
+    srgb: Optional[bool],
+    readable: Optional[bool],
+    as_sprite: bool,
+) -> bool:
+    """Validate and apply import-setting flags to params dict. Returns True if any import setting present."""
+    has_other_flags = any(v is not None for v in (
+        texture_type, sprite_mode, sprite_ppu, max_size, compression, generate_mipmaps, srgb, readable))
+
+    if as_sprite:
+        if has_other_flags:
+            print_error("--as-sprite cannot be combined with other import-setting flags")
+            sys.exit(1)
+        params["spriteSettings"] = {"pivot": [0.5, 0.5], "pixelsPerUnit": 100}
+        return True
+
+    if has_other_flags:
+        import_settings = _build_import_settings_from_flags(
+            texture_type, sprite_mode, sprite_ppu, max_size, compression,
+            generate_mipmaps, srgb, readable)
+        if import_settings:
+            params["importSettings"] = import_settings
+        return True
+
+    return False
+
+
 @texture.command("modify")
 @click.argument("path")
-@click.option("--set-pixels", required=True, help="Modification args as JSON")
+@click.option("--set-pixels", default=None, help="Modification args as JSON")
+@click.option("--texture-type", type=click.Choice(list(_TEXTURE_TYPES.keys())), help="Texture type")
+@click.option("--sprite-mode", type=click.Choice(list(_SPRITE_MODES.keys())), help="Sprite import mode")
+@click.option("--sprite-ppu", type=float, help="Sprite pixels per unit")
+@click.option("--max-size", type=click.Choice(["32", "64", "128", "256", "512", "1024", "2048", "4096", "8192", "16384"]), help="Max texture size")
+@click.option("--compression", type=click.Choice(list(_COMPRESSIONS.keys())), help="Compression quality")
+@click.option("--generate-mipmaps/--no-mipmaps", default=None, help="Generate mipmaps")
+@click.option("--srgb/--linear", default=None, help="sRGB color texture")
+@click.option("--readable/--no-readable", default=None, help="Read/Write enabled")
+@click.option("--as-sprite", is_flag=True, help="Shorthand: set texture type to Sprite with defaults")
 @handle_unity_errors
-def modify(path: str, set_pixels: str):
+def modify(path: str, set_pixels: Optional[str], texture_type: Optional[str], sprite_mode: Optional[str],
+           sprite_ppu: Optional[float], max_size: Optional[str], compression: Optional[str],
+           generate_mipmaps: Optional[bool], srgb: Optional[bool], readable: Optional[bool],
+           as_sprite: bool):
     """Modify an existing texture.
 
     \b
     Examples:
         unity-mcp texture modify Assets/Tex.png --set-pixels '{"x":0,"y":0,"width":10,"height":10,"color":[255,0,0]}'
         unity-mcp texture modify Assets/Tex.png --set-pixels '{"x":0,"y":0,"width":2,"height":2,"pixels":[[255,0,0,255],[0,255,0,255],[0,0,255,255],[255,255,0,255]]}'
+        unity-mcp texture modify Assets/UI/icon.png --as-sprite
+        unity-mcp texture modify Assets/UI/bg.png --texture-type sprite --max-size 2048
     """
     config = get_config()
 
-    params: dict[str, Any] = {
-        "action": "modify",
-        "path": path,
-    }
+    params: dict[str, Any] = {"action": "modify", "path": path}
 
-    try:
-        params["setPixels"] = _normalize_set_pixels(set_pixels)
-    except ValueError as e:
-        print_error(str(e))
+    has_import = _apply_import_flags_to_params(
+        params, texture_type, sprite_mode, sprite_ppu, max_size,
+        compression, generate_mipmaps, srgb, readable, as_sprite)
+
+    if set_pixels is not None:
+        try:
+            params["setPixels"] = _normalize_set_pixels(set_pixels)
+        except ValueError as e:
+            print_error(str(e))
+            sys.exit(1)
+    elif not has_import:
+        print_error("At least one of --set-pixels or an import-setting flag must be provided")
         sys.exit(1)
 
     result = run_command("manage_texture", params, config)
@@ -538,3 +622,46 @@ def delete(path: str, force: bool):
     click.echo(format_output(result, config.format))
     if result.get("success"):
         print_success(f"Deleted texture: {path}")
+
+
+@texture.command("set-import-settings")
+@click.argument("path")
+@click.option("--texture-type", type=click.Choice(list(_TEXTURE_TYPES.keys())), help="Texture type")
+@click.option("--sprite-mode", type=click.Choice(list(_SPRITE_MODES.keys())), help="Sprite import mode")
+@click.option("--sprite-ppu", type=float, help="Sprite pixels per unit")
+@click.option("--max-size", type=click.Choice(["32", "64", "128", "256", "512", "1024", "2048", "4096", "8192", "16384"]), help="Max texture size")
+@click.option("--compression", type=click.Choice(list(_COMPRESSIONS.keys())), help="Compression quality")
+@click.option("--generate-mipmaps/--no-mipmaps", default=None, help="Generate mipmaps")
+@click.option("--srgb/--linear", default=None, help="sRGB color texture")
+@click.option("--readable/--no-readable", default=None, help="Read/Write enabled")
+@click.option("--as-sprite", is_flag=True, help="Shorthand: set texture type to Sprite with defaults")
+@handle_unity_errors
+def set_import_settings(path: str, texture_type: Optional[str], sprite_mode: Optional[str],
+                        sprite_ppu: Optional[float], max_size: Optional[str],
+                        compression: Optional[str], generate_mipmaps: Optional[bool],
+                        srgb: Optional[bool], readable: Optional[bool], as_sprite: bool):
+    """Change import settings on an existing texture.
+
+    \b
+    Examples:
+        unity-mcp texture set-import-settings Assets/UI/icon.png --texture-type sprite
+        unity-mcp texture set-import-settings Assets/UI/icon.png --as-sprite
+        unity-mcp texture set-import-settings Assets/UI/icon.png --texture-type sprite --sprite-mode single --sprite-ppu 100
+        unity-mcp texture set-import-settings Assets/UI/bg.png --max-size 2048 --compression high_quality
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {"action": "set_import_settings", "path": path}
+
+    has_import = _apply_import_flags_to_params(
+        params, texture_type, sprite_mode, sprite_ppu, max_size,
+        compression, generate_mipmaps, srgb, readable, as_sprite)
+
+    if not has_import:
+        print_error("At least one import setting must be specified")
+        sys.exit(1)
+
+    result = run_command("manage_texture", params, config)
+    click.echo(format_output(result, config.format))
+    if result.get("success"):
+        print_success(f"Import settings updated: {path}")
diff --git a/Server/src/services/tools/manage_texture.py b/Server/src/services/tools/manage_texture.py
@@ -378,7 +378,8 @@ def _normalize_import_settings(value: Any) -> tuple[dict | None, str | None]:
     description=(
         "Procedural texture generation for Unity. Creates textures with solid fills, "
         "patterns (checkerboard, stripes, dots, grid, brick), gradients, and noise. "
-        "Actions: create, modify, delete, create_sprite, apply_pattern, apply_gradient, apply_noise"
+        "Actions: create, modify, delete, create_sprite, apply_pattern, apply_gradient, apply_noise, "
+        "set_import_settings"
     ),
     annotations=ToolAnnotations(
         title="Manage Texture",
@@ -394,7 +395,8 @@ async def manage_texture(
         "create_sprite",
         "apply_pattern",
         "apply_gradient",
-        "apply_noise"
+        "apply_noise",
+        "set_import_settings"
     ], "Action to perform."],
 
     # Required for most actions

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "com.coplaydev.unity-mcp",`
`3`		`- "version": "9.6.3-beta.5",`
	`3`	`+ "version": "9.6.3-beta.6",`
`4`	`4`	`"displayName": "MCP for Unity",`
`5`	`5`	`"description": "A bridge that connects AI assistants to Unity via the MCP (Model Context Protocol). Allows AI clients like Claude Code, Cursor, and VSCode to directly control your Unity Editor for enhanced development workflows.\n\nFeatures automated setup wizard, cross-platform support, and seamless integration with popular AI development tools.\n\nJoin Our Discord: https://discord.gg/y4p8KfzrN4",`
`6`	`6`	`"unity": "2021.3",`