Merge pull request #982 from zaferdace/beta

Scriptwonder · web-flow · commit 11dd3e234839 · 2026-03-25T12:59:01.000-04:00
feat: add set_import_settings action to manage_texture tool
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/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
