[Add] Synaptic AI Pro

https://assetstore.unity.com/packages/tools/generative-ai/synaptic-ai-pro-natural-language-control-for-unity-336030

Assets/Synaptic AI Pro/Editor/ShaderPipelineManager.cs

@@ -0,0 +1,223 @@
+using UnityEngine;
+using SynapticAIPro;
+using UnityEditor;
+using UnityEngine.Rendering;
+using System.IO;
+using System.Linq;
+
+namespace Synaptic.Editor
+{
+    /// <summary>
+    /// Automatically manages shader files based on the current render pipeline.
+    /// Disables shaders for pipelines that are not installed to prevent compilation errors.
+    /// </summary>
+    [InitializeOnLoad]
+    public static class ShaderPipelineManager
+    {
+        public enum RenderPipelineType
+        {
+            BuiltIn,
+            URP,
+            HDRP
+        }
+
+        private const string SHADER_BASE_PATH = "Assets/Synaptic AI Pro/Shaders";
+        private const string BUILTIN_FOLDER = "BuiltIn";
+        private const string URP_FOLDER = "URP";
+        private const string HDRP_FOLDER = "HDRP";
+        private const string DISABLED_EXTENSION = ".disabled";
+
+        private static readonly string[] PIPELINE_FOLDERS = { BUILTIN_FOLDER, URP_FOLDER, HDRP_FOLDER };
+
+        static ShaderPipelineManager()
+        {
+            // Delay execution to ensure Unity is fully initialized
+            EditorApplication.delayCall += OnEditorInitialized;
+        }
+
+        private static void OnEditorInitialized()
+        {
+            EditorApplication.delayCall -= OnEditorInitialized;
+
+            // Check and update shaders on editor load
+            UpdateShadersForCurrentPipeline();
+
+            // Subscribe to pipeline changes
+            RenderPipelineManager.activeRenderPipelineTypeChanged += OnPipelineChanged;
+        }
+
+        private static void OnPipelineChanged()
+        {
+            SynLog.Info("[Synaptic] Render pipeline changed, updating shaders...");
+            UpdateShadersForCurrentPipeline();
+        }
+
+        /// <summary>
+        /// Detects the currently active render pipeline.
+        /// </summary>
+        public static RenderPipelineType DetectCurrentPipeline()
+        {
+            var pipelineAsset = GraphicsSettings.currentRenderPipeline;
+
+            if (pipelineAsset == null)
+            {
+                return RenderPipelineType.BuiltIn;
+            }
+
+            var typeName = pipelineAsset.GetType().FullName;
+
+            if (typeName.Contains("Universal") || typeName.Contains("URP"))
+            {
+                return RenderPipelineType.URP;
+            }
+
+            if (typeName.Contains("HighDefinition") || typeName.Contains("HDRenderPipeline") || typeName.Contains("HDRP"))
+            {
+                return RenderPipelineType.HDRP;
+            }
+
+            return RenderPipelineType.BuiltIn;
+        }
+
+        /// <summary>
+        /// Updates shader files based on the current pipeline.
+        /// Enables shaders for the current pipeline and disables others.
+        /// </summary>
+        [MenuItem("Tools/Synaptic Pro/Update Shaders for Pipeline")]
+        public static void UpdateShadersForCurrentPipeline()
+        {
+            var currentPipeline = DetectCurrentPipeline();
+            SynLog.Info($"[Synaptic] Detected render pipeline: {currentPipeline}");
+
+            bool changed = false;
+
+            foreach (var folder in PIPELINE_FOLDERS)
+            {
+                string folderPath = Path.Combine(SHADER_BASE_PATH, folder);
+
+                if (!Directory.Exists(folderPath))
+                {
+                    continue;
+                }
+
+                bool shouldEnable = ShouldEnableFolder(folder, currentPipeline);
+                changed |= UpdateShaderFolder(folderPath, shouldEnable);
+            }
+
+            if (changed)
+            {
+                AssetDatabase.Refresh();
+                SynLog.Info($"[Synaptic] Shaders updated for {currentPipeline} pipeline");
+            }
+        }
+
+        private static bool ShouldEnableFolder(string folder, RenderPipelineType currentPipeline)
+        {
+            switch (folder)
+            {
+                case BUILTIN_FOLDER:
+                    return currentPipeline == RenderPipelineType.BuiltIn;
+                case URP_FOLDER:
+                    return currentPipeline == RenderPipelineType.URP;
+                case HDRP_FOLDER:
+                    return currentPipeline == RenderPipelineType.HDRP;
+                default:
+                    return true;
+            }
+        }
+
+        private static bool UpdateShaderFolder(string folderPath, bool enable)
+        {
+            bool changed = false;
+
+            // Get all shader files (both enabled and disabled)
+            var shaderFiles = Directory.GetFiles(folderPath, "*.shader", SearchOption.AllDirectories)
+                .Concat(Directory.GetFiles(folderPath, "*.shader" + DISABLED_EXTENSION, SearchOption.AllDirectories))
+                .ToArray();
+
+            foreach (var filePath in shaderFiles)
+            {
+                bool isDisabled = filePath.EndsWith(DISABLED_EXTENSION);
+
+                if (enable && isDisabled)
+                {
+                    // Enable: remove .disabled extension
+                    string newPath = filePath.Substring(0, filePath.Length - DISABLED_EXTENSION.Length);
+                    MoveFile(filePath, newPath);
+                    changed = true;
+                }
+                else if (!enable && !isDisabled)
+                {
+                    // Disable: add .disabled extension
+                    string newPath = filePath + DISABLED_EXTENSION;
+                    MoveFile(filePath, newPath);
+                    changed = true;
+                }
+            }
+
+            return changed;
+        }
+
+        private static void MoveFile(string sourcePath, string destPath)
+        {
+            // Also handle .meta files
+            string sourceMetaPath = sourcePath + ".meta";
+            string destMetaPath = destPath + ".meta";
+
+            try
+            {
+                if (File.Exists(sourcePath))
+                {
+                    File.Move(sourcePath, destPath);
+                }
+
+                if (File.Exists(sourceMetaPath))
+                {
+                    File.Move(sourceMetaPath, destMetaPath);
+                }
+            }
+            catch (System.Exception e)
+            {
+                SynLog.Warn($"[Synaptic] Failed to move shader file: {e.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Gets the appropriate shader name for the current pipeline.
+        /// </summary>
+        public static string GetShaderName(string baseShaderName)
+        {
+            var pipeline = DetectCurrentPipeline();
+            string pipelineFolder = GetPipelineFolderName(pipeline);
+            return $"Synaptic/{pipelineFolder}/{baseShaderName}";
+        }
+
+        /// <summary>
+        /// Gets the folder name for a specific pipeline type.
+        /// </summary>
+        public static string GetPipelineFolderName(RenderPipelineType pipeline)
+        {
+            switch (pipeline)
+            {
+                case RenderPipelineType.URP:
+                    return URP_FOLDER;
+                case RenderPipelineType.HDRP:
+                    return HDRP_FOLDER;
+                default:
+                    return BUILTIN_FOLDER;
+            }
+        }
+
+        /// <summary>
+        /// Finds a shader compatible with the current pipeline.
+        /// Uses PackageRequirements-enabled multi-SubShader approach.
+        /// </summary>
+        public static Shader FindShaderForCurrentPipeline(string baseShaderName)
+        {
+            // Shaders now use PackageRequirements tags, so Unity automatically
+            // skips SubShaders for missing render pipelines.
+            // Just use the standard shader name.
+            return Shader.Find($"Synaptic/{baseShaderName}");
+        }
+    }
+}