546 lines
21 KiB
C#
546 lines
21 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text.RegularExpressions;
|
|
using Codely.Newtonsoft.Json.Linq;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using UnityTcp.Editor.Helpers;
|
|
|
|
namespace UnityTcp.Editor.Tools
|
|
{
|
|
/// <summary>
|
|
/// Handles CRUD operations for shader files within the Unity project.
|
|
/// </summary>
|
|
public static class ManageShader
|
|
{
|
|
/// <summary>
|
|
/// Main handler for shader management actions.
|
|
/// </summary>
|
|
public static object HandleCommand(JObject @params)
|
|
{
|
|
// Extract parameters
|
|
string action = @params["action"]?.ToString().ToLower();
|
|
string name = @params["name"]?.ToString();
|
|
string path = @params["path"]?.ToString(); // Relative to Assets/
|
|
string contents = null;
|
|
|
|
// --- Validate client_state_rev for write operations ---
|
|
var writeActions = new[] { "ensure_material_shader_for_srp", "create", "update", "delete" };
|
|
if (writeActions.Contains(action))
|
|
{
|
|
var revConflict = StateComposer.ValidateClientRevisionFromParams(@params);
|
|
if (revConflict != null) return revConflict;
|
|
}
|
|
|
|
// Check if we have base64 encoded contents
|
|
bool contentsEncoded = @params["contentsEncoded"]?.ToObject<bool>() ?? false;
|
|
if (contentsEncoded && @params["encodedContents"] != null)
|
|
{
|
|
try
|
|
{
|
|
contents = DecodeBase64(@params["encodedContents"].ToString());
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return Response.Error($"Failed to decode shader contents: {e.Message}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
contents = @params["contents"]?.ToString();
|
|
}
|
|
|
|
// Validate required parameters
|
|
if (string.IsNullOrEmpty(action))
|
|
{
|
|
return Response.Error("Action parameter is required.");
|
|
}
|
|
|
|
// Skip name validation for SRP operations
|
|
if (action != "detect_render_pipeline" && action != "ensure_material_shader_for_srp")
|
|
{
|
|
if (string.IsNullOrEmpty(name))
|
|
{
|
|
return Response.Error("Name parameter is required.");
|
|
}
|
|
// Basic name validation (alphanumeric, underscores, cannot start with number)
|
|
if (!Regex.IsMatch(name, @"^[a-zA-Z_][a-zA-Z0-9_]*$"))
|
|
{
|
|
return Response.Error(
|
|
$"Invalid shader name: '{name}'. Use only letters, numbers, underscores, and don't start with a number."
|
|
);
|
|
}
|
|
}
|
|
|
|
// Ensure path is relative to Assets/, removing any leading "Assets/"
|
|
// Set default directory to "Shaders" if path is not provided
|
|
string relativeDir = path ?? "Shaders"; // Default to "Shaders" if path is null
|
|
if (!string.IsNullOrEmpty(relativeDir))
|
|
{
|
|
relativeDir = relativeDir.Replace('\\', '/').Trim('/');
|
|
if (relativeDir.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
relativeDir = relativeDir.Substring("Assets/".Length).TrimStart('/');
|
|
}
|
|
}
|
|
// Handle empty string case explicitly after processing
|
|
if (string.IsNullOrEmpty(relativeDir))
|
|
{
|
|
relativeDir = "Shaders"; // Ensure default if path was provided as "" or only "/" or "Assets/"
|
|
}
|
|
|
|
// Construct paths
|
|
string shaderFileName = $"{name}.shader";
|
|
string fullPathDir = Path.Combine(Application.dataPath, relativeDir);
|
|
string fullPath = Path.Combine(fullPathDir, shaderFileName);
|
|
string relativePath = Path.Combine("Assets", relativeDir, shaderFileName)
|
|
.Replace('\\', '/'); // Ensure "Assets/" prefix and forward slashes
|
|
|
|
// Ensure the target directory exists for create/update
|
|
if (action == "create" || action == "update")
|
|
{
|
|
try
|
|
{
|
|
if (!Directory.Exists(fullPathDir))
|
|
{
|
|
Directory.CreateDirectory(fullPathDir);
|
|
// Refresh AssetDatabase to recognize new folders
|
|
AssetDatabase.Refresh();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return Response.Error(
|
|
$"Could not create directory '{fullPathDir}': {e.Message}"
|
|
);
|
|
}
|
|
}
|
|
|
|
// Route to specific action handlers
|
|
switch (action)
|
|
{
|
|
// SRP operations (don't require name validation)
|
|
case "detect_render_pipeline":
|
|
return DetectRenderPipeline();
|
|
case "ensure_material_shader_for_srp":
|
|
return EnsureMaterialShaderForSRP(@params);
|
|
|
|
// Regular shader file operations
|
|
case "create":
|
|
return CreateShader(fullPath, relativePath, name, contents);
|
|
case "read":
|
|
return ReadShader(fullPath, relativePath);
|
|
case "update":
|
|
return UpdateShader(fullPath, relativePath, name, contents);
|
|
case "delete":
|
|
return DeleteShader(fullPath, relativePath);
|
|
default:
|
|
return Response.Error(
|
|
$"Unknown action: '{action}'. Valid actions are: detect_render_pipeline, ensure_material_shader_for_srp, create, read, update, delete."
|
|
);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Decode base64 string to normal text
|
|
/// </summary>
|
|
private static string DecodeBase64(string encoded)
|
|
{
|
|
byte[] data = Convert.FromBase64String(encoded);
|
|
return System.Text.Encoding.UTF8.GetString(data);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encode text to base64 string
|
|
/// </summary>
|
|
private static string EncodeBase64(string text)
|
|
{
|
|
byte[] data = System.Text.Encoding.UTF8.GetBytes(text);
|
|
return Convert.ToBase64String(data);
|
|
}
|
|
|
|
private static object CreateShader(
|
|
string fullPath,
|
|
string relativePath,
|
|
string name,
|
|
string contents
|
|
)
|
|
{
|
|
// Check if shader already exists
|
|
if (File.Exists(fullPath))
|
|
{
|
|
return Response.Error(
|
|
$"Shader already exists at '{relativePath}'. Use 'update' action to modify."
|
|
);
|
|
}
|
|
|
|
// Add validation for shader name conflicts in Unity
|
|
if (Shader.Find(name) != null)
|
|
{
|
|
return Response.Error(
|
|
$"A shader with name '{name}' already exists in the project. Choose a different name."
|
|
);
|
|
}
|
|
|
|
// Generate default content if none provided
|
|
if (string.IsNullOrEmpty(contents))
|
|
{
|
|
contents = GenerateDefaultShaderContent(name);
|
|
}
|
|
|
|
try
|
|
{
|
|
File.WriteAllText(fullPath, contents, new System.Text.UTF8Encoding(false));
|
|
AssetDatabase.ImportAsset(relativePath);
|
|
AssetDatabase.Refresh(); // Ensure Unity recognizes the new shader
|
|
return Response.Success(
|
|
$"Shader '{name}.shader' created successfully at '{relativePath}'.",
|
|
new { path = relativePath }
|
|
);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return Response.Error($"Failed to create shader '{relativePath}': {e.Message}");
|
|
}
|
|
}
|
|
|
|
private static object ReadShader(string fullPath, string relativePath)
|
|
{
|
|
if (!File.Exists(fullPath))
|
|
{
|
|
return Response.Error($"Shader not found at '{relativePath}'.");
|
|
}
|
|
|
|
try
|
|
{
|
|
string contents = File.ReadAllText(fullPath);
|
|
|
|
// Return both normal and encoded contents for larger files
|
|
//TODO: Consider a threshold for large files
|
|
bool isLarge = contents.Length > 10000; // If content is large, include encoded version
|
|
var responseData = new
|
|
{
|
|
path = relativePath,
|
|
contents = contents,
|
|
// For large files, also include base64-encoded version
|
|
encodedContents = isLarge ? EncodeBase64(contents) : null,
|
|
contentsEncoded = isLarge,
|
|
};
|
|
|
|
return Response.Success(
|
|
$"Shader '{Path.GetFileName(relativePath)}' read successfully.",
|
|
responseData
|
|
);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return Response.Error($"Failed to read shader '{relativePath}': {e.Message}");
|
|
}
|
|
}
|
|
|
|
private static object UpdateShader(
|
|
string fullPath,
|
|
string relativePath,
|
|
string name,
|
|
string contents
|
|
)
|
|
{
|
|
if (!File.Exists(fullPath))
|
|
{
|
|
return Response.Error(
|
|
$"Shader not found at '{relativePath}'. Use 'create' action to add a new shader."
|
|
);
|
|
}
|
|
if (string.IsNullOrEmpty(contents))
|
|
{
|
|
return Response.Error("Content is required for the 'update' action.");
|
|
}
|
|
|
|
try
|
|
{
|
|
File.WriteAllText(fullPath, contents, new System.Text.UTF8Encoding(false));
|
|
AssetDatabase.ImportAsset(relativePath);
|
|
AssetDatabase.Refresh();
|
|
return Response.Success(
|
|
$"Shader '{Path.GetFileName(relativePath)}' updated successfully.",
|
|
new { path = relativePath }
|
|
);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return Response.Error($"Failed to update shader '{relativePath}': {e.Message}");
|
|
}
|
|
}
|
|
|
|
private static object DeleteShader(string fullPath, string relativePath)
|
|
{
|
|
if (!File.Exists(fullPath))
|
|
{
|
|
return Response.Error($"Shader not found at '{relativePath}'.");
|
|
}
|
|
|
|
try
|
|
{
|
|
// Delete the asset through Unity's AssetDatabase first
|
|
bool success = AssetDatabase.DeleteAsset(relativePath);
|
|
if (!success)
|
|
{
|
|
return Response.Error($"Failed to delete shader through Unity's AssetDatabase: '{relativePath}'");
|
|
}
|
|
|
|
// If the file still exists (rare case), try direct deletion
|
|
if (File.Exists(fullPath))
|
|
{
|
|
File.Delete(fullPath);
|
|
}
|
|
|
|
return Response.Success($"Shader '{Path.GetFileName(relativePath)}' deleted successfully.");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return Response.Error($"Failed to delete shader '{relativePath}': {e.Message}");
|
|
}
|
|
}
|
|
|
|
//This is a CGProgram template
|
|
//TODO: making a HLSL template as well?
|
|
private static string GenerateDefaultShaderContent(string name)
|
|
{
|
|
return @"Shader """ + name + @"""
|
|
{
|
|
Properties
|
|
{
|
|
_MainTex (""Texture"", 2D) = ""white"" {}
|
|
}
|
|
SubShader
|
|
{
|
|
Tags { ""RenderType""=""Opaque"" }
|
|
LOD 100
|
|
|
|
Pass
|
|
{
|
|
CGPROGRAM
|
|
#pragma vertex vert
|
|
#pragma fragment frag
|
|
#include ""UnityCG.cginc""
|
|
|
|
struct appdata
|
|
{
|
|
float4 vertex : POSITION;
|
|
float2 uv : TEXCOORD0;
|
|
};
|
|
|
|
struct v2f
|
|
{
|
|
float2 uv : TEXCOORD0;
|
|
float4 vertex : SV_POSITION;
|
|
};
|
|
|
|
sampler2D _MainTex;
|
|
float4 _MainTex_ST;
|
|
|
|
v2f vert (appdata v)
|
|
{
|
|
v2f o;
|
|
o.vertex = UnityObjectToClipPos(v.vertex);
|
|
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
|
|
return o;
|
|
}
|
|
|
|
fixed4 frag (v2f i) : SV_Target
|
|
{
|
|
fixed4 col = tex2D(_MainTex, i.uv);
|
|
return col;
|
|
}
|
|
ENDCG
|
|
}
|
|
}
|
|
}";
|
|
}
|
|
// --- SRP/Shader Safety Methods ---
|
|
|
|
/// <summary>
|
|
/// Detects the current render pipeline in use.
|
|
/// </summary>
|
|
private static object DetectRenderPipeline()
|
|
{
|
|
try
|
|
{
|
|
string srp = "builtin";
|
|
var currentRP = UnityEngine.Rendering.GraphicsSettings.currentRenderPipeline;
|
|
|
|
if (currentRP != null)
|
|
{
|
|
string rpName = currentRP.GetType().Name.ToLowerInvariant();
|
|
string rpFullName = currentRP.GetType().FullName.ToLowerInvariant();
|
|
|
|
if (rpName.Contains("urp") || rpName.Contains("universal") ||
|
|
rpFullName.Contains("universal"))
|
|
{
|
|
srp = "urp";
|
|
}
|
|
else if (rpName.Contains("hdrp") || rpName.Contains("highdefinition") ||
|
|
rpFullName.Contains("highdefinition"))
|
|
{
|
|
srp = "hdrp";
|
|
}
|
|
}
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
message = $"Current render pipeline: {srp}",
|
|
data = new
|
|
{
|
|
srp = srp,
|
|
rpAssetName = currentRP?.name,
|
|
rpTypeName = currentRP?.GetType().FullName
|
|
},
|
|
state_delta = StateComposer.CreateEditorDelta(isUpdating: false)
|
|
};
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return Response.Error($"Failed to detect render pipeline: {e.Message}");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ensures a material uses the appropriate shader for the current SRP. Idempotent.
|
|
/// Supports both "material" (legacy) and "material_path"/"material_guid"
|
|
/// as described in the Unity-Tools-Spec.
|
|
/// </summary>
|
|
private static object EnsureMaterialShaderForSRP(JObject @params)
|
|
{
|
|
try
|
|
{
|
|
var writeCheck = WriteGuard.CheckWriteAllowed("ensure_material_shader_for_srp");
|
|
if (writeCheck != null) return writeCheck;
|
|
|
|
// Accept multiple parameter shapes.
|
|
// Primary spec uses "material_path" / "material_guid",
|
|
// but we still accept legacy "material" for backwards compatibility.
|
|
string materialPath = @params["material_path"]?.ToString();
|
|
|
|
// Legacy fallback: allow "material" if material_path is not provided
|
|
if (string.IsNullOrEmpty(materialPath))
|
|
{
|
|
materialPath = @params["material"]?.ToString();
|
|
}
|
|
|
|
// Resolve from GUID if path not provided
|
|
if (string.IsNullOrEmpty(materialPath))
|
|
{
|
|
var guid = @params["material_guid"]?.ToString();
|
|
if (!string.IsNullOrEmpty(guid))
|
|
{
|
|
materialPath = AssetDatabase.GUIDToAssetPath(guid);
|
|
}
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(materialPath))
|
|
return Response.Error("Either material_path or material_guid is required for ensure_material_shader_for_srp action");
|
|
|
|
// Validate path format (mirror TS-side validation)
|
|
if (!materialPath.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase))
|
|
return Response.Error("material_path must start with \"Assets/\"");
|
|
|
|
JObject shaderMapping = @params["shader_for_srp"] as JObject;
|
|
if (shaderMapping == null)
|
|
return Response.Error("shader_for_srp is required for ensure_material_shader_for_srp action");
|
|
|
|
if (!shaderMapping.ContainsKey("builtin") ||
|
|
string.IsNullOrWhiteSpace(shaderMapping["builtin"]?.ToString()))
|
|
{
|
|
return Response.Error("shader_for_srp.builtin is required as fallback shader");
|
|
}
|
|
|
|
// Load material
|
|
Material material = AssetDatabase.LoadAssetAtPath<Material>(materialPath);
|
|
if (material == null)
|
|
return Response.Error($"Material not found at: {materialPath}");
|
|
|
|
// Detect current SRP
|
|
string currentSrp = "builtin";
|
|
var currentRP = UnityEngine.Rendering.GraphicsSettings.currentRenderPipeline;
|
|
if (currentRP != null)
|
|
{
|
|
string rpName = currentRP.GetType().Name.ToLowerInvariant();
|
|
if (rpName.Contains("urp") || rpName.Contains("universal"))
|
|
currentSrp = "urp";
|
|
else if (rpName.Contains("hdrp") || rpName.Contains("highdefinition"))
|
|
currentSrp = "hdrp";
|
|
}
|
|
|
|
// Get appropriate shader name
|
|
string targetShaderName = null;
|
|
if (currentSrp == "urp" && shaderMapping.ContainsKey("urp"))
|
|
targetShaderName = shaderMapping["urp"]?.ToString();
|
|
else if (currentSrp == "hdrp" && shaderMapping.ContainsKey("hdrp"))
|
|
targetShaderName = shaderMapping["hdrp"]?.ToString();
|
|
else if (shaderMapping.ContainsKey("builtin"))
|
|
targetShaderName = shaderMapping["builtin"]?.ToString(); // Fallback
|
|
|
|
if (string.IsNullOrEmpty(targetShaderName))
|
|
return Response.Error($"No shader mapping provided for current SRP: {currentSrp}");
|
|
|
|
// Find shader
|
|
Shader targetShader = Shader.Find(targetShaderName);
|
|
if (targetShader == null)
|
|
return Response.Error($"Shader not found: {targetShaderName}");
|
|
|
|
// Check if material already uses this shader (idempotent)
|
|
if (material.shader == targetShader)
|
|
{
|
|
return new
|
|
{
|
|
success = true,
|
|
message = $"Material already uses appropriate shader for {currentSrp}.",
|
|
data = new
|
|
{
|
|
material = materialPath,
|
|
currentSrp = currentSrp,
|
|
shader = targetShaderName,
|
|
alreadyCorrect = true
|
|
},
|
|
state_delta = StateComposer.CreateAssetDelta(new[] {
|
|
new { path = materialPath, imported = false, hasMeta = true }
|
|
})
|
|
};
|
|
}
|
|
|
|
// Cache old shader name BEFORE switching
|
|
string oldShaderName = material.shader?.name ?? "None";
|
|
|
|
// Switch shader
|
|
material.shader = targetShader;
|
|
EditorUtility.SetDirty(material);
|
|
AssetDatabase.SaveAssets();
|
|
StateComposer.IncrementRevision();
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
message = $"Material shader switched for {currentSrp}.",
|
|
data = new
|
|
{
|
|
material = materialPath,
|
|
currentSrp = currentSrp,
|
|
oldShader = oldShaderName,
|
|
newShader = targetShaderName,
|
|
alreadyCorrect = false
|
|
},
|
|
state_delta = StateComposer.CreateAssetDelta(new[] {
|
|
new { path = materialPath, imported = false, hasMeta = true }
|
|
})
|
|
};
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return Response.Error($"Failed to ensure material shader for SRP: {e.Message}");
|
|
}
|
|
}
|
|
}
|
|
}
|