using System;
using System.Collections.Generic;
using System.IO;
using Newtonsoft.Json.Linq;
using UnityEditor;
using UnityEngine;
using MCPForUnity.Editor.Helpers;
namespace MCPForUnity.Editor.Tools
{
/// <summary>
/// Handles procedural texture generation operations.
/// Supports patterns (checkerboard, stripes, dots, grid, brick),
/// gradients, noise, and direct pixel manipulation.
/// </summary>
[McpForUnityTool("manage_texture", AutoRegister = false)]
public static class ManageTexture
{
private const int MaxTextureDimension = 1024;
private const int MaxTexturePixels = 1024 * 1024;
private const int MaxNoiseWork = 4000000;
private static readonly List<string> ValidActions = new List<string>
{
"create",
"modify",
"delete",
"create_sprite",
"apply_pattern",
"apply_gradient",
"apply_noise"
};
private static ErrorResponse ValidateDimensions(int width, int height, List<string> warnings)
{
if (width <= 0 || height <= 0)
return new ErrorResponse($"Invalid dimensions: {width}x{height}. Must be positive.");
if (width > MaxTextureDimension || height > MaxTextureDimension)
warnings.Add($"Dimensions exceed recommended max {MaxTextureDimension} per side (got {width}x{height}).");
long totalPixels = (long)width * height;
if (totalPixels > MaxTexturePixels)
warnings.Add($"Total pixels exceed recommended max {MaxTexturePixels} (got {width}x{height}).");
return null;
}
public static object HandleCommand(JObject @params)
{
string action = @params["action"]?.ToString()?.ToLowerInvariant();
if (string.IsNullOrEmpty(action))
{
return new ErrorResponse("Action parameter is required.");
}
if (!ValidActions.Contains(action))
{
string validActionsList = string.Join(", ", ValidActions);
return new ErrorResponse(
$"Unknown action: '{action}'. Valid actions are: {validActionsList}"
);
}
string path = @params["path"]?.ToString();
try
{
switch (action)
{
case "create":
case "create_sprite":
return CreateTexture(@params, action == "create_sprite");
case "modify":
return ModifyTexture(@params);
case "delete":
return DeleteTexture(path);
case "apply_pattern":
return ApplyPattern(@params);
case "apply_gradient":
return ApplyGradient(@params);
case "apply_noise":
return ApplyNoise(@params);
default:
return new ErrorResponse($"Unknown action: '{action}'");
}
}
catch (Exception e)
{
McpLog.Error($"[ManageTexture] Action '{action}' failed: {e}");
return new ErrorResponse($"Internal error processing action '{action}': {e.Message}");
}
}
// --- Action Implementations ---
private static object CreateTexture(JObject @params, bool asSprite)
{
string path = @params["path"]?.ToString();
if (string.IsNullOrEmpty(path))
return new ErrorResponse("'path' is required for create.");
string imagePath = @params["imagePath"]?.ToString();
bool hasImage = !string.IsNullOrEmpty(imagePath);
int width = @params["width"]?.ToObject<int>() ?? 64;
int height = @params["height"]?.ToObject<int>() ?? 64;
List<string> warnings = new List<string>();
// Validate dimensions
if (!hasImage)
{
var dimensionError = ValidateDimensions(width, height, warnings);
if (dimensionError != null)
return dimensionError;
}
string fullPath = AssetPathUtility.SanitizeAssetPath(path);
EnsureDirectoryExists(fullPath);
try
{
var fillColorToken = @params["fillColor"];
var patternToken = @params["pattern"];
var pixelsToken = @params["pixels"];
if (hasImage && (fillColorToken != null || patternToken != null || pixelsToken != null))
{
return new ErrorResponse("imagePath cannot be combined with fillColor, pattern, or pixels.");
}
int patternSize = 8;
if (!hasImage && patternToken != null)
{
patternSize = @params["patternSize"]?.ToObject<int>() ?? 8;
if (patternSize <= 0)
return new ErrorResponse("patternSize must be greater than 0.");
}
Texture2D texture;
if (hasImage)
{
string resolvedImagePath = ResolveImagePath(imagePath);
if (!File.Exists(resolvedImagePath))
return new ErrorResponse($"Image file not found at '{imagePath}'.");
byte[] imageBytes = File.ReadAllBytes(resolvedImagePath);
texture = new Texture2D(2, 2, TextureFormat.RGBA32, false);
if (!texture.LoadImage(imageBytes))
{
UnityEngine.Object.DestroyImmediate(texture);
return new ErrorResponse($"Failed to load image from '{imagePath}'.");
}
width = texture.width;
height = texture.height;
var imageDimensionError = ValidateDimensions(width, height, warnings);
if (imageDimensionError != null)
{
UnityEngine.Object.DestroyImmediate(texture);
return imageDimensionError;
}
}
else
{
texture = new Texture2D(width, height, TextureFormat.RGBA32, false);
// Check for fill color
if (fillColorToken != null && fillColorToken.Type == JTokenType.Array)
{
Color32 fillColor = TextureOps.ParseColor32(fillColorToken as JArray);
TextureOps.FillTexture(texture, fillColor);
}
// Check for pattern
if (patternToken != null)
{
string pattern = patternToken.ToString();
var palette = TextureOps.ParsePalette(@params["palette"] as JArray);
ApplyPatternToTexture(texture, pattern, palette, patternSize);
}
// Check for direct pixel data
if (pixelsToken != null)
{
TextureOps.ApplyPixelData(texture, pixelsToken, width, height);
}
// If nothing specified, create transparent texture
if (fillColorToken == null && patternToken == null && pixelsToken == null)
{
TextureOps.FillTexture(texture, new Color32(0, 0, 0, 0));
}
}
texture.Apply();
// Save to disk
byte[] imageData = TextureOps.EncodeTexture(texture, fullPath);
if (imageData == null || imageData.Length == 0)
{
UnityEngine.Object.DestroyImmediate(texture);
return new ErrorResponse($"Failed to encode texture for '{fullPath}'");
}
File.WriteAllBytes(GetAbsolutePath(fullPath), imageData);
AssetDatabase.ImportAsset(fullPath, ImportAssetOptions.ForceUpdate);
// Configure texture importer settings if provided
JToken importSettingsToken = @params["importSettings"];
JToken spriteSettingsToken = @params["spriteSettings"];
if (importSettingsToken != null)
{
ConfigureTextureImporter(fullPath, importSettingsToken);
}
else if (asSprite || spriteSettingsToken != null)
{
// Legacy sprite configuration
ConfigureAsSprite(fullPath, spriteSettingsToken);
}
// Clean up memory
UnityEngine.Object.DestroyImmediate(texture);
foreach (var warning in warnings)
{
McpLog.Warn($"[ManageTexture] {warning}");
}
return new SuccessResponse(
$"Texture created at '{fullPath}' ({width}x{height})" + (asSprite ? " as sprite" : ""),
new
{
path = fullPath,
width,
height,
asSprite = asSprite || spriteSettingsToken != null || (importSettingsToken?["textureType"]?.ToString() == "Sprite"),
warnings = warnings.Count > 0 ? warnings : null
}
);
}
catch (Exception e)
{
return new ErrorResponse($"Failed to create texture: {e.Message}");
}
}
private static object ModifyTexture(JObject @params)
{
string path = @params["path"]?.ToString();
if (string.IsNullOrEmpty(path))
return new ErrorResponse("'path' is required for modify.");
string fullPath = AssetPathUtility.SanitizeAssetPath(path);
if (!AssetExists(fullPath))
return new ErrorResponse($"Texture not found at path: {fullPath}");
try
{
Texture2D texture = AssetDatabase.LoadAssetAtPath<Texture2D>(fullPath);
if (texture == null)
return new ErrorResponse($"Failed to load texture at path: {fullPath}");
// 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);
// Apply modifications
var setPixelsToken = @params["setPixels"] as JObject;
if (setPixelsToken != null)
{
int x = setPixelsToken["x"]?.ToObject<int>() ?? 0;
int y = setPixelsToken["y"]?.ToObject<int>() ?? 0;
int w = setPixelsToken["width"]?.ToObject<int>() ?? 1;
int h = setPixelsToken["height"]?.ToObject<int>() ?? 1;
if (w <= 0 || h <= 0)
{
UnityEngine.Object.DestroyImmediate(editableTexture);
return new ErrorResponse("setPixels width and height must be positive.");
}
var pixelsToken = setPixelsToken["pixels"];
var colorToken = setPixelsToken["color"];
if (pixelsToken != null)
{
TextureOps.ApplyPixelDataToRegion(editableTexture, pixelsToken, x, y, w, h);
}
else if (colorToken != null)
{
Color32 color = TextureOps.ParseColor32(colorToken as JArray);
int startX = Mathf.Max(0, x);
int startY = Mathf.Max(0, y);
int endX = Mathf.Min(x + w, editableTexture.width);
int endY = Mathf.Min(y + h, editableTexture.height);
for (int py = startY; py < endY; py++)
{
for (int px = startX; px < endX; px++)
{
editableTexture.SetPixel(px, py, color);
}
}
}
else
{
UnityEngine.Object.DestroyImmediate(editableTexture);
return new ErrorResponse("setPixels requires 'color' or 'pixels'.");
}
}
editableTexture.Apply();
// Save back to disk
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 SuccessResponse($"Texture modified: {fullPath}");
}
catch (Exception e)
{
return new ErrorResponse($"Failed to modify texture: {e.Message}");
}
}
private static object DeleteTexture(string path)
{
if (string.IsNullOrEmpty(path))
return new ErrorResponse("'path' is required for delete.");
string fullPath = AssetPathUtility.SanitizeAssetPath(path);
if (!AssetExists(fullPath))
return new ErrorResponse($"Texture not found at path: {fullPath}");
try
{
bool success = AssetDatabase.DeleteAsset(fullPath);
if (success)
return new SuccessResponse($"Texture deleted: {fullPath}");
else
return new ErrorResponse($"Failed to delete texture: {fullPath}");
}
catch (Exception e)
{
return new ErrorResponse($"Error deleting texture: {e.Message}");
}
}
private static object ApplyPattern(JObject @params)
{
// Reuse CreateTexture with pattern
return CreateTexture(@params, false);
}
private static object ApplyGradient(JObject @params)
{
string path = @params["path"]?.ToString();
if (string.IsNullOrEmpty(path))
return new ErrorResponse("'path' is required for apply_gradient.");
int width = @params["width"]?.ToObject<int>() ?? 64;
int height = @params["height"]?.ToObject<int>() ?? 64;
List<string> warnings = new List<string>();
var dimensionError = ValidateDimensions(width, height, warnings);
if (dimensionError != null)
return dimensionError;
string gradientType = @params["gradientType"]?.ToString() ?? "linear";
float angle = @params["gradientAngle"]?.ToObject<float>() ?? 0f;
var palette = TextureOps.ParsePalette(@params["palette"] as JArray);
if (palette == null || palette.Count < 2)
{
// Default gradient palette
palette = new List<Color32> { new Color32(0, 0, 0, 255), new Color32(255, 255, 255, 255) };
}
string fullPath = AssetPathUtility.SanitizeAssetPath(path);
EnsureDirectoryExists(fullPath);
Texture2D texture = null;
try
{
texture = new Texture2D(width, height, TextureFormat.RGBA32, false);
if (gradientType == "radial")
{
ApplyRadialGradient(texture, palette);
}
else
{
ApplyLinearGradient(texture, palette, angle);
}
texture.Apply();
byte[] imageData = TextureOps.EncodeTexture(texture, fullPath);
if (imageData == null || imageData.Length == 0)
{
return new ErrorResponse($"Failed to encode texture for '{fullPath}'");
}
File.WriteAllBytes(GetAbsolutePath(fullPath), imageData);
AssetDatabase.ImportAsset(fullPath, ImportAssetOptions.ForceUpdate);
// Configure as sprite if requested
JToken spriteSettingsToken = @params["spriteSettings"];
if (spriteSettingsToken != null)
{
ConfigureAsSprite(fullPath, spriteSettingsToken);
}
foreach (var warning in warnings)
{
McpLog.Warn($"[ManageTexture] {warning}");
}
return new SuccessResponse(
$"Gradient texture created at '{fullPath}' ({width}x{height})",
new
{
path = fullPath,
width,
height,
gradientType,
warnings = warnings.Count > 0 ? warnings : null
}
);
}
catch (Exception e)
{
return new ErrorResponse($"Failed to create gradient texture: {e.Message}");
}
finally
{
if (texture != null)
UnityEngine.Object.DestroyImmediate(texture);
}
}
private static object ApplyNoise(JObject @params)
{
string path = @params["path"]?.ToString();
if (string.IsNullOrEmpty(path))
return new ErrorResponse("'path' is required for apply_noise.");
int width = @params["width"]?.ToObject<int>() ?? 64;
int height = @params["height"]?.ToObject<int>() ?? 64;
List<string> warnings = new List<string>();
var dimensionError = ValidateDimensions(width, height, warnings);
if (dimensionError != null)
return dimensionError;
float scale = @params["noiseScale"]?.ToObject<float>() ?? 0.1f;
int octaves = @params["octaves"]?.ToObject<int>() ?? 1;
if (octaves <= 0)
return new ErrorResponse("octaves must be greater than 0.");
long noiseWork = (long)width * height * octaves;
if (noiseWork > MaxNoiseWork)
warnings.Add($"Noise workload exceeds recommended max {MaxNoiseWork} (got {width}x{height}x{octaves}).");
var palette = TextureOps.ParsePalette(@params["palette"] as JArray);
if (palette == null || palette.Count < 2)
{
palette = new List<Color32> { new Color32(0, 0, 0, 255), new Color32(255, 255, 255, 255) };
}
string fullPath = AssetPathUtility.SanitizeAssetPath(path);
EnsureDirectoryExists(fullPath);
Texture2D texture = new Texture2D(width, height, TextureFormat.RGBA32, false);
try
{
ApplyPerlinNoise(texture, palette, scale, octaves);
texture.Apply();
byte[] imageData = TextureOps.EncodeTexture(texture, fullPath);
if (imageData == null || imageData.Length == 0)
{
return new ErrorResponse($"Failed to encode texture for '{fullPath}'");
}
File.WriteAllBytes(GetAbsolutePath(fullPath), imageData);
AssetDatabase.ImportAsset(fullPath, ImportAssetOptions.ForceUpdate);
// Configure as sprite if requested
JToken spriteSettingsToken = @params["spriteSettings"];
if (spriteSettingsToken != null)
{
ConfigureAsSprite(fullPath, spriteSettingsToken);
}
foreach (var warning in warnings)
{
McpLog.Warn($"[ManageTexture] {warning}");
}
return new SuccessResponse(
$"Noise texture created at '{fullPath}' ({width}x{height})",
new
{
path = fullPath,
width,
height,
noiseScale = scale,
octaves,
warnings = warnings.Count > 0 ? warnings : null
}
);
}
catch (Exception e)
{
return new ErrorResponse($"Failed to create noise texture: {e.Message}");
}
finally
{
if (texture != null)
UnityEngine.Object.DestroyImmediate(texture);
}
}
// --- Pattern Helpers ---
private static void ApplyPatternToTexture(Texture2D texture, string pattern, List<Color32> palette, int patternSize)
{
if (palette == null || palette.Count == 0)
{
palette = new List<Color32> { new Color32(255, 255, 255, 255), new Color32(0, 0, 0, 255) };
}
int width = texture.width;
int height = texture.height;
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
Color32 color = GetPatternColor(x, y, pattern, palette, patternSize, width, height);
texture.SetPixel(x, y, color);
}
}
}
private static Color32 GetPatternColor(int x, int y, string pattern, List<Color32> palette, int size, int width, int height)
{
int colorIndex = 0;
switch (pattern.ToLower())
{
case "checkerboard":
colorIndex = ((x / size) + (y / size)) % 2;
break;
case "stripes":
case "stripes_v":
colorIndex = (x / size) % palette.Count;
break;
case "stripes_h":
colorIndex = (y / size) % palette.Count;
break;
case "stripes_diag":
colorIndex = ((x + y) / size) % palette.Count;
break;
case "dots":
int cx = (x % (size * 2)) - size;
int cy = (y % (size * 2)) - size;
bool inDot = (cx * cx + cy * cy) < (size * size / 4);
colorIndex = inDot ? 1 : 0;
break;
case "grid":
bool onGridLine = (x % size == 0) || (y % size == 0);
colorIndex = onGridLine ? 1 : 0;
break;
case "brick":
int row = y / size;
int offset = (row % 2) * (size / 2);
bool onBorder = ((x + offset) % size == 0) || (y % size == 0);
colorIndex = onBorder ? 1 : 0;
break;
default:
colorIndex = 0;
break;
}
return palette[Mathf.Clamp(colorIndex, 0, palette.Count - 1)];
}
// --- Gradient Helpers ---
private static void ApplyLinearGradient(Texture2D texture, List<Color32> palette, float angle)
{
int width = texture.width;
int height = texture.height;
float radians = angle * Mathf.Deg2Rad;
Vector2 dir = new Vector2(Mathf.Cos(radians), Mathf.Sin(radians));
float denomX = Mathf.Max(1, width - 1);
float denomY = Mathf.Max(1, height - 1);
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
float nx = x / denomX;
float ny = y / denomY;
float t = Vector2.Dot(new Vector2(nx, ny), dir);
t = Mathf.Clamp01((t + 1f) / 2f);
Color32 color = LerpPalette(palette, t);
texture.SetPixel(x, y, color);
}
}
}
private static void ApplyRadialGradient(Texture2D texture, List<Color32> palette)
{
int width = texture.width;
int height = texture.height;
float cx = width / 2f;
float cy = height / 2f;
float maxDist = Mathf.Sqrt(cx * cx + cy * cy);
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
float dx = x - cx;
float dy = y - cy;
float dist = Mathf.Sqrt(dx * dx + dy * dy);
float t = Mathf.Clamp01(dist / maxDist);
Color32 color = LerpPalette(palette, t);
texture.SetPixel(x, y, color);
}
}
}
private static Color32 LerpPalette(List<Color32> palette, float t)
{
if (palette.Count == 1) return palette[0];
if (t <= 0) return palette[0];
if (t >= 1) return palette[palette.Count - 1];
float scaledT = t * (palette.Count - 1);
int index = Mathf.FloorToInt(scaledT);
float localT = scaledT - index;
if (index >= palette.Count - 1)
return palette[palette.Count - 1];
Color c1 = palette[index];
Color c2 = palette[index + 1];
return Color.Lerp(c1, c2, localT);
}
// --- Noise Helpers ---
private static void ApplyPerlinNoise(Texture2D texture, List<Color32> palette, float scale, int octaves)
{
int width = texture.width;
int height = texture.height;
// Random offset to ensure different patterns
float offsetX = UnityEngine.Random.Range(0f, 1000f);
float offsetY = UnityEngine.Random.Range(0f, 1000f);
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
float noiseValue = 0f;
float amplitude = 1f;
float frequency = 1f;
float maxValue = 0f;
for (int o = 0; o < octaves; o++)
{
float sampleX = (x + offsetX) * scale * frequency;
float sampleY = (y + offsetY) * scale * frequency;
noiseValue += Mathf.PerlinNoise(sampleX, sampleY) * amplitude;
maxValue += amplitude;
amplitude *= 0.5f;
frequency *= 2f;
}
float t = Mathf.Clamp01(noiseValue / maxValue);
Color32 color = LerpPalette(palette, t);
texture.SetPixel(x, y, color);
}
}
}
private static void ConfigureAsSprite(string path, JToken spriteSettings)
{
TextureImporter importer = AssetImporter.GetAtPath(path) as TextureImporter;
if (importer == null)
{
McpLog.Warn($"[ManageTexture] Could not get TextureImporter for {path}");
return;
}
importer.textureType = TextureImporterType.Sprite;
importer.spriteImportMode = SpriteImportMode.Single;
if (spriteSettings != null && spriteSettings.Type == JTokenType.Object)
{
var settings = spriteSettings as JObject;
// Pivot
var pivotToken = settings["pivot"];
if (pivotToken is JArray pivotArray && pivotArray.Count >= 2)
{
importer.spritePivot = new Vector2(
pivotArray[0].ToObject<float>(),
pivotArray[1].ToObject<float>()
);
}
// Pixels per unit
var ppuToken = settings["pixelsPerUnit"];
if (ppuToken != null)
{
importer.spritePixelsPerUnit = ppuToken.ToObject<float>();
}
}
importer.SaveAndReimport();
}
private static void ConfigureTextureImporter(string path, JToken importSettings)
{
TextureImporter importer = AssetImporter.GetAtPath(path) as TextureImporter;
if (importer == null)
{
McpLog.Warn($"[ManageTexture] Could not get TextureImporter for {path}");
return;
}
if (importSettings == null || importSettings.Type != JTokenType.Object)
{
return;
}
var settings = importSettings as JObject;
// Texture Type
var textureTypeToken = settings["textureType"];
if (textureTypeToken != null)
{
string typeStr = textureTypeToken.ToString();
if (TryParseEnum<TextureImporterType>(typeStr, out var textureType))
{
importer.textureType = textureType;
}
}
// Texture Shape
var textureShapeToken = settings["textureShape"];
if (textureShapeToken != null)
{
string shapeStr = textureShapeToken.ToString();
if (TryParseEnum<TextureImporterShape>(shapeStr, out var textureShape))
{
importer.textureShape = textureShape;
}
}
// sRGB
var srgbToken = settings["sRGBTexture"];
if (srgbToken != null)
{
importer.sRGBTexture = srgbToken.ToObject<bool>();
}
// Alpha Source
var alphaSourceToken = settings["alphaSource"];
if (alphaSourceToken != null)
{
string alphaStr = alphaSourceToken.ToString();
if (TryParseEnum<TextureImporterAlphaSource>(alphaStr, out var alphaSource))
{
importer.alphaSource = alphaSource;
}
}
// Alpha Is Transparency
var alphaTransToken = settings["alphaIsTransparency"];
if (alphaTransToken != null)
{
importer.alphaIsTransparency = alphaTransToken.ToObject<bool>();
}
// Readable
var readableToken = settings["isReadable"];
if (readableToken != null)
{
importer.isReadable = readableToken.ToObject<bool>();
}
// Mipmaps
var mipmapToken = settings["mipmapEnabled"];
if (mipmapToken != null)
{
importer.mipmapEnabled = mipmapToken.ToObject<bool>();
}
// Mipmap Filter
var mipmapFilterToken = settings["mipmapFilter"];
if (mipmapFilterToken != null)
{
string filterStr = mipmapFilterToken.ToString();
if (TryParseEnum<TextureImporterMipFilter>(filterStr, out var mipmapFilter))
{
importer.mipmapFilter = mipmapFilter;
}
}
// Wrap Mode
var wrapModeToken = settings["wrapMode"];
if (wrapModeToken != null)
{
string wrapStr = wrapModeToken.ToString();
if (TryParseEnum<TextureWrapMode>(wrapStr, out var wrapMode))
{
importer.wrapMode = wrapMode;
}
}
// Wrap Mode U
var wrapModeUToken = settings["wrapModeU"];
if (wrapModeUToken != null)
{
string wrapStr = wrapModeUToken.ToString();
if (TryParseEnum<TextureWrapMode>(wrapStr, out var wrapMode))
{
importer.wrapModeU = wrapMode;
}
}
// Wrap Mode V
var wrapModeVToken = settings["wrapModeV"];
if (wrapModeVToken != null)
{
string wrapStr = wrapModeVToken.ToString();
if (TryParseEnum<TextureWrapMode>(wrapStr, out var wrapMode))
{
importer.wrapModeV = wrapMode;
}
}
// Filter Mode
var filterModeToken = settings["filterMode"];
if (filterModeToken != null)
{
string filterStr = filterModeToken.ToString();
if (TryParseEnum<FilterMode>(filterStr, out var filterMode))
{
importer.filterMode = filterMode;
}
}
// Aniso Level
var anisoToken = settings["anisoLevel"];
if (anisoToken != null)
{
importer.anisoLevel = anisoToken.ToObject<int>();
}
// Max Texture Size
var maxSizeToken = settings["maxTextureSize"];
if (maxSizeToken != null)
{
importer.maxTextureSize = maxSizeToken.ToObject<int>();
}
// Compression
var compressionToken = settings["textureCompression"];
if (compressionToken != null)
{
string compStr = compressionToken.ToString();
if (TryParseEnum<TextureImporterCompression>(compStr, out var compression))
{
importer.textureCompression = compression;
}
}
// Crunched Compression
var crunchedToken = settings["crunchedCompression"];
if (crunchedToken != null)
{
importer.crunchedCompression = crunchedToken.ToObject<bool>();
}
// Compression Quality
var qualityToken = settings["compressionQuality"];
if (qualityToken != null)
{
importer.compressionQuality = qualityToken.ToObject<int>();
}
// --- Sprite-specific settings ---
// Sprite Import Mode
var spriteModeToken = settings["spriteImportMode"];
if (spriteModeToken != null)
{
string modeStr = spriteModeToken.ToString();
if (TryParseEnum<SpriteImportMode>(modeStr, out var spriteMode))
{
importer.spriteImportMode = spriteMode;
}
}
// Sprite Pixels Per Unit
var ppuToken = settings["spritePixelsPerUnit"];
if (ppuToken != null)
{
importer.spritePixelsPerUnit = ppuToken.ToObject<float>();
}
// Sprite Pivot
var pivotToken = settings["spritePivot"];
if (pivotToken is JArray pivotArray && pivotArray.Count >= 2)
{
importer.spritePivot = new Vector2(
pivotArray[0].ToObject<float>(),
pivotArray[1].ToObject<float>()
);
}
// Apply sprite settings using TextureImporterSettings helper
TextureImporterSettings importerSettings = new TextureImporterSettings();
importer.ReadTextureSettings(importerSettings);
bool settingsChanged = false;
// Sprite Mesh Type
var meshTypeToken = settings["spriteMeshType"];
if (meshTypeToken != null)
{
string meshStr = meshTypeToken.ToString();
if (TryParseEnum<SpriteMeshType>(meshStr, out var meshType))
{
importerSettings.spriteMeshType = meshType;
settingsChanged = true;
}
}
// Sprite Extrude
var extrudeToken = settings["spriteExtrude"];
if (extrudeToken != null)
{
importerSettings.spriteExtrude = (uint)extrudeToken.ToObject<int>();
settingsChanged = true;
}
if (settingsChanged)
{
importer.SetTextureSettings(importerSettings);
}
importer.SaveAndReimport();
}
private static bool TryParseEnum<T>(string value, out T result) where T : struct
{
// Try exact match first
if (Enum.TryParse<T>(value, true, out result))
{
return true;
}
// Try without common prefixes/suffixes
string cleanValue = value.Replace("_", "").Replace("-", "");
if (Enum.TryParse<T>(cleanValue, true, out result))
{
return true;
}
result = default;
return false;
}
private static bool AssetExists(string path)
{
return !string.IsNullOrEmpty(AssetDatabase.AssetPathToGUID(path));
}
private static void EnsureDirectoryExists(string assetPath)
{
string directory = Path.GetDirectoryName(assetPath);
if (!string.IsNullOrEmpty(directory) && !Directory.Exists(GetAbsolutePath(directory)))
{
Directory.CreateDirectory(GetAbsolutePath(directory));
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
}
}
private static string GetAbsolutePath(string assetPath)
{
return Path.Combine(Directory.GetCurrentDirectory(), assetPath);
}
private static string ResolveImagePath(string imagePath)
{
if (Path.IsPathRooted(imagePath))
return imagePath;
return Path.Combine(Directory.GetCurrentDirectory(), imagePath);
}
}
}
