@aqian0/dsh-unity 0.0.0-stage → 0.1.0

package/skills/manage-sprite-atlas/resources/variantatlas.cs

@@ -0,0 +1,39 @@
+void GenerateVariantAtlas(string masterPath, string variantPath, float scale)
+{
+    // Load master atlas (must exist and be imported first)
+    SpriteAtlas masterRuntime = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(masterPath);
+    if (masterRuntime == null)
+    {
+        Debug.LogError($"Master atlas not found: {masterPath}");
+        return;
+    }
+
+    // Get original packables from master
+    Object[] originalPackables = masterRuntime.GetPackables();
+
+    // Create variant
+    SpriteAtlasAsset variantAsset = new SpriteAtlasAsset();
+    variantAsset.SetIsVariant(true);
+    variantAsset.Add(originalPackables);
+    variantAsset.SetMasterAtlas(masterRuntime);
+
+    SpriteAtlasAsset.Save(variantAsset, variantPath);
+    AssetDatabase.ImportAsset(variantPath);
+
+    // Configure variant scale
+    SpriteAtlasImporter importer = AssetImporter.GetAtPath(variantPath) as SpriteAtlasImporter;
+    if (importer != null)
+    {
+        importer.variantScale = scale;
+        importer.includeInBuild = true;
+        importer.SaveAndReimport();
+    }
+}
+
+// Usage in OnPreprocessBuild:
+GenerateAtlasByFolder("Assets/Art/UI", "Assets/Atlases/UI_Master.spriteatlasv2");
+GenerateVariantAtlas(
+    "Assets/Atlases/UI_Master.spriteatlasv2",
+    "Assets/Atlases/UI_HD.spriteatlasv2",
+    0.5f  // HD variant at 50% scale
+);

package/skills/migrate-birp-to-urp/SECURITY.md

@@ -0,0 +1,16 @@
+# Security notes: migrate-birp-to-urp
+
+This skill has the agent run C# inside the user's open Unity Editor through `unity command script eval`. Automated skill scanners flag that as a powerful capability. It is intentional, and it is limited by the safeguards below.
+
+## Accepted risks
+
+| Risk | Capability | Why it is accepted |
+|---|---|---|
+| `SEC_POWER_CAP` | Runs C# in the user's open Editor through `unity command script eval` | It only reaches the Editor the user already has open, on their own machine, as that user, so it grants nothing they couldn't do themselves. `script eval` sits behind the Pipeline capability gate. No code fetched from a remote source is run. Where a named `unity command` covers a step, the skill uses that instead of `script eval`. |
+
+## Mitigations
+
+- **Only the user's own Editor.** `unity command script eval` talks to the Editor open on this machine. It can't reach another machine or another user's Editor.
+- **Capability gate.** `script eval` is only available when the project's Pipeline package provides it.
+- **No remote code.** The agent runs C# it writes from this skill's own recipes. Nothing downloaded from outside is executed.
+- **Named commands first.** When a dedicated `unity command` covers a step, the skill uses it instead of `script eval`.

package/skills/migrate-birp-to-urp/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: migrate-birp-to-urp
+description: Plans, executes, and troubleshoots migration from the Built-in Render Pipeline to URP. Use when asked to convert a project, scene, material, or shader to URP, or to fix visuals broken by the change.
+---
+Classify the request, inspect the current project state, choose the correct migration path, and validate the Built-in to URP migration outcome carefully.
+
+## Mandatory Execution Reference
+
+For any actual migration or repair pass, read [references/implementation-patterns.md](references/implementation-patterns.md) before the first `script eval` call that edits project settings, materials, post-processing, lighting, probes, or scenes. This is mandatory even for short prompts such as "migrate this project to URP" when rollback safety is already confirmed.
+
+If that resource cannot be loaded, use the embedded rules in this SKILL.md and lower your confidence: do not claim PPv2 conversion, lighting/probe refresh, or migration completion from intent or tool logs alone.
+
+## Critical Default
+
+For a generic "migrate this project to URP" request, run phases 0-4: inspect and plan, URP setup and material conversion, post-processing and cameras, lighting and probes, validation and report. Read [Critical Default](references/preflight-and-urp-setup.md#critical-default) before starting and before any success claim: it holds the upgrade contract and the success gate.
+
+## Execution path: running C# in the Editor
+
+Every C# step in this skill runs inside a live Editor through the Unity CLI. **The `unity-cli`
+skill owns getting you there** — installing the CLI, confirming a connected Editor, adding the
+project's `com.unity.pipeline` package, telling a genuinely absent Editor apart from one stuck in
+Safe Mode, and discovering the Editor's command catalog. Follow it first; don't re-derive any of
+it here.
+
+Two things it can't know for you:
+
+- **You need `script eval` in particular**, not just a reachable Editor. Confirm it appears in the
+  catalog. Its presence depends on the Pipeline package version, not on the CLI, so a healthy
+  install can still lack it — if it's missing, say so and stop.
+- **On an Editor older than 6000.3, expect the Pipeline package not to work at all**, and read the
+  symptom correctly rather than retrying. `com.unity.pipeline` uses `IPreprocessBuildWithContext`
+  and `BuildCallbackContext`, which Unity introduced in **6000.3**; the package's own manifest
+  declares `"unity": "6000.0"`, so it installs happily and then fails to compile. Measured:
+  present in 6000.3 / 6000.4 / 6000.5, absent in 6000.0 / 6000.1 / 6000.2 and in the 2022 and 2023
+  lines. The symptom is misleading — the server never starts, `unity status` shows no row and no
+  error, and the real cause is `CS0246` on those two types in the Editor log. If you see that,
+  tell the user the Editor is too old for the Pipeline package rather than debugging the CLI.
+
+  **This matters here more than in most skills:** someone migrating a project off the Built-in
+  pipeline is, by definition, often on an older Editor.
+- **A render-pipeline migration is not safely authorable blind.** Assigning a URP asset, converting
+  materials, and rebaking lighting all need a live Editor. An unreachable Editor is a stop, not a
+  cue to hand-edit `ProjectSettings/GraphicsSettings.asset`.
+
+Run C# with `unity command script eval --caller plugin --skill migrate-birp-to-urp --code '<snippet>'`. `unity command` defaults to a 30 second
+timeout, which matters here: installing URP triggers a package refresh and domain reload that will
+outlast it. Treat that as a phase boundary rather than raising the timeout.
+
+### Passing C# to `script eval`
+
+`script eval` compiles a **statement block, not a file**. Three consequences, all of which cause a compile
+error rather than a warning:
+
+- **No `using` directives.** The compiler reads `using UnityEngine;` as a resource-disposal
+  statement and rejects it (`CS0210`).
+- **Types must be fully qualified.** A bare `GraphicsSettings` or `Volume` does not resolve
+  (`CS0246` / `CS0103`), and a bare `Object` is ambiguous with `object` (`CS0104`).
+- **Extension methods are unavailable**, because they resolve through `using`. Two that this skill
+  would otherwise reach for: `camera.GetUniversalAdditionalCameraData()` becomes
+  `camera.GetComponent<UnityEngine.Rendering.Universal.UniversalAdditionalCameraData>()`, and LINQ
+  calls must be written statically — `System.Linq.Enumerable.FirstOrDefault(sequence, predicate)`
+  rather than `sequence.FirstOrDefault(predicate)`.
+
+### Two execution modes — pick by the snippet's shape
+
+The references carry both shapes, and they are not interchangeable:
+
+- **Statement-shaped** (a bare sequence of statements, like the detection snippets above) — pass
+  straight to `script eval`, fully qualified, with no `using` lines.
+- **Class- or method-shaped** (anything declaring a `class`, a `static` method, or a `[MenuItem]`,
+  such as the material-snapshot pattern) — these are **project files, not `script eval` input**. A class
+  declaration cannot be flattened into a statement block. Save the snippet under
+  `Assets/Editor/`, let Unity compile it, then invoke its entry point through a one-line `script eval`
+  call. Keep the `using` directives in that file; they are correct there.
+
+For a multi-step migration the script route is the more reliable one anyway: it survives the domain
+reloads that URP installation and material conversion trigger, whereas a long `script eval` payload does
+not.
+
+### Detecting the active render pipeline
+
+Read [pipeline detection](references/preflight-and-urp-setup.md#detecting-the-active-render-pipeline) for the snippets that tell Built-in, URP, and HDRP apart.
+
+## 0. Pre-Flight: Pipeline Detection and Reference Loading
+
+Read [0. Pre-Flight](references/preflight-and-urp-setup.md#0-pre-flight-pipeline-detection-and-reference-loading) first; it fixes the migration mode and the reference set.
+
+## 1. Assess Current Migration State
+
+Read [assess current state](references/preflight-and-urp-setup.md#1-assess-current-migration-state) to inventory materials, shaders, scenes, volumes, lighting, and probes.
+
+## 2. Gather Requirements
+
+Read [gather requirements](references/preflight-and-urp-setup.md#2-gather-requirements) when the request is ambiguous.
+
+## 3. Safety Gate
+
+Read [safety gate](references/preflight-and-urp-setup.md#3-safety-gate) before any rollback-sensitive step.
+
+## 4. Choose the Migration Path
+
+Read [migration paths](references/conversion-and-rendering-triage.md#4-choose-the-migration-path) before choosing a workflow.
+
+## 5. URP Setup Workflow
+
+Read [URP setup](references/preflight-and-urp-setup.md#5-urp-setup-workflow) when installing or assigning URP, or after a package-refresh boundary.
+
+## 6. Conversion Workflow
+
+Read [conversion workflow](references/conversion-and-rendering-triage.md#6-conversion-workflow) when running Render Pipeline Converter and checking its saved results.
+
+## 7. Shader and Material Triage
+
+Read [shader triage](references/conversion-and-rendering-triage.md#7-shader-and-material-triage) when materials are magenta or shaders fail to compile.
+
+## 8. Post-Processing, Cameras, and Rendering-Effect Triage
+
+Read [rendering-effect triage](references/conversion-and-rendering-triage.md#8-post-processing-cameras-and-rendering-effect-triage) when PPv2, camera effects, or replacement shaders are in scope.
+
+## 9. Quality, Lighting, and Visual Parity Review
+
+Read [parity review](references/parity-validation-and-troubleshooting.md#9-quality-lighting-and-visual-parity-review) when the scene looks wrong after migration.
+
+## 10. Validation
+
+Read [validation](references/parity-validation-and-troubleshooting.md#10-validation) before reporting results.
+
+## 11. Troubleshooting Decision Tree
+
+Read [troubleshooting tree](references/parity-validation-and-troubleshooting.md#11-troubleshooting-decision-tree) when the user reports a migration symptom.
+
+## 12. Core Guardrails
+
+- Detect the active render pipeline first; for HDRP, explain the mismatch and offer only basic comparison guidance.
+- Do not mutate the project before rollback safety is confirmed; instead stop in planning mode before URP install, asset assignment, converters, material edits, or scene edits.
+- Do not treat tool logs or created assets as proof; instead save/reload/re-query Graphics, Quality, materials, Volumes, lighting, probes, Console, and representative scenes before status claims.
+- Do not collapse partial phases into project-level completion; instead report `Phase complete`, `Partial migration`, and `Manual follow-up` based on the success gate.
+- Do not bulk-rewrite fragile rendering code; instead use scoped mappings for custom shaders, `GrabPass`, `OnRenderImage`, replacement shaders, package-owned render code, and unsupported PPv2 effects.
+
+## 13. Reporting Back
+
+Summarize:
+
+- which migration path was used
+- whether the project is still Built-in, partially migrated, or fully on URP
+- which converters ran
+- what was fixed automatically
+- what still needs manual work
+- which scenes, materials, or cameras were validated
+- what remains risky, especially around complex shaders, package effects, and visual parity
+- whether post-processing was fully migrated, partially prepared, or only documented for manual follow-up
+- whether Quality levels are explicitly assigned or intentionally relying on Graphics settings fallback
+- whether particle/VFX materials were converted or still need URP particle-shader follow-up
+- whether baked lighting/lightmaps/reflection probes were preserved as reference, verified visually, rebaked/refreshed, or left as manual follow-up
+- whether exposure, tonemapping, ambient fill, and camera/Volume post-processing wiring were visually balanced or still remain partial
+
+Use completion language conservatively. If the report contains any `Partial`, `Manual follow-up`, `not validated`, `may still need`, or unsupported-feature item, state that specific completed phases passed and call the overall migration partial/manual. Do not pair a project-level "complete" claim with manual follow-up bullets.
+
+## References
+
+- [Migration Workflow](references/migration-workflow.md)
+- [Custom Shader Triage](references/custom-shader-triage.md)
+- [Complex Shader Situations](references/complex-shader-situations.md)
+- [Quality Settings Map](references/quality-settings-map.md)
+- [Implementation Patterns](references/implementation-patterns.md)
+
+When this skill is activated, proactively read [references/migration-workflow.md](references/migration-workflow.md). If the request involves materials, shaders, magenta materials, custom rendering, or fullscreen effects, also read [references/custom-shader-triage.md](references/custom-shader-triage.md) and [references/complex-shader-situations.md](references/complex-shader-situations.md). If the request involves visual mismatch, lighting, baked lighting, lightmaps, reflection probes, shadows, or performance after migration, also read [references/quality-settings-map.md](references/quality-settings-map.md). If the user permits actual migration changes or asks to continue/repair a partial migration, also read [references/implementation-patterns.md](references/implementation-patterns.md).

package/skills/migrate-birp-to-urp/references/capturing-the-editor.md

@@ -0,0 +1,66 @@
+# Capturing the Editor for visual checks
+
+There is no capture command in the Pipeline catalog. Run the capture as C# through `script eval`, write
+a PNG, then **read that file** — reading an image is something the agent does natively, so the
+two-step version is equivalent to a single capture tool.
+
+Both variants below were verified against a live Unity 6 Editor.
+
+## Scene View
+
+```csharp
+var sv = UnityEditor.SceneView.lastActiveSceneView;
+if (sv == null) throw new System.Exception("No active SceneView to capture.");
+var cam = sv.camera;
+var rt = new UnityEngine.RenderTexture(1280, 720, 24);
+var prevTarget = cam.targetTexture; cam.targetTexture = rt; cam.Render(); cam.targetTexture = prevTarget;
+var prevActive = UnityEngine.RenderTexture.active; UnityEngine.RenderTexture.active = rt;
+var tex = new UnityEngine.Texture2D(1280, 720, UnityEngine.TextureFormat.RGB24, false);
+tex.ReadPixels(new UnityEngine.Rect(0, 0, 1280, 720), 0, 0); tex.Apply();
+UnityEngine.RenderTexture.active = prevActive;
+var path = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "unity-sceneview.png");
+System.IO.File.WriteAllBytes(path, UnityEngine.ImageConversion.EncodeToPNG(tex));
+return path;
+```
+
+## Game camera
+
+Same shape, rendering `Camera.main` instead:
+
+```csharp
+var cam = UnityEngine.Camera.main;
+if (cam == null) throw new System.Exception("No Camera.main in the active scene.");
+var rt = new UnityEngine.RenderTexture(1280, 720, 24);
+var prevTarget = cam.targetTexture; cam.targetTexture = rt; cam.Render(); cam.targetTexture = prevTarget;
+var prevActive = UnityEngine.RenderTexture.active; UnityEngine.RenderTexture.active = rt;
+var tex = new UnityEngine.Texture2D(1280, 720, UnityEngine.TextureFormat.RGB24, false);
+tex.ReadPixels(new UnityEngine.Rect(0, 0, 1280, 720), 0, 0); tex.Apply();
+UnityEngine.RenderTexture.active = prevActive;
+var path = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "unity-gameview.png");
+System.IO.File.WriteAllBytes(path, UnityEngine.ImageConversion.EncodeToPNG(tex));
+return path;
+```
+
+## Several angles
+
+Move the Scene View camera between captures and write a distinct filename each time. `sv.pivot`
+sets what it looks at, `sv.rotation` the direction, `sv.size` the distance; call `sv.Repaint()`
+after changing them, then capture as above.
+
+```csharp
+var sv = UnityEditor.SceneView.lastActiveSceneView;
+sv.pivot = new UnityEngine.Vector3(0, 0, 0);
+sv.rotation = UnityEngine.Quaternion.Euler(30, 45, 0);   // vary this per angle
+sv.size = 10f;
+sv.Repaint();
+```
+
+To frame specific objects rather than a fixed point, select them and use
+`UnityEditor.SceneView.FrameLastActiveSceneView()`, or set `sv.pivot` to the centre of their
+combined bounds.
+
+**Then read the returned path.** Write each capture to a distinct filename so a later capture
+doesn't get confused with an earlier one — comparing before and after a change is the whole point.
+
+Temp files are the default here rather than `Assets/`: a PNG written into the project becomes an
+imported asset the user then has to clean up.

package/skills/migrate-birp-to-urp/references/complex-shader-situations.md

@@ -0,0 +1,272 @@
+# Complex Shader Situations
+
+Use deliberate URP migration strategies for higher-risk Built-in rendering patterns instead of quick shader rewrites.
+
+## Table of Contents
+
+- [Official References](#official-references)
+- [Ground Truth](#ground-truth)
+- [Case 1: Surface Shaders](#case-1-surface-shaders)
+- [Case 2: GrabPass, Refraction, and Scene-Color Effects](#case-2-grabpass-refraction-and-scene-color-effects)
+- [Case 3: Built-in Fullscreen Effects and `OnRenderImage`](#case-3-built-in-fullscreen-effects-and-onrenderimage)
+- [Case 4: Replacement Shader and Alternate-Camera Rendering Workflows](#case-4-replacement-shader-and-alternate-camera-rendering-workflows)
+- [Case 5: Multi-Pass, Custom Lighting, and Deferred-Specific Shaders](#case-5-multi-pass-custom-lighting-and-deferred-specific-shaders)
+- [Case 6: Package-Owned and Framework Shaders](#case-6-package-owned-and-framework-shaders)
+- [Stop-and-Escalate Signals](#stop-and-escalate-signals)
+
+## Official References
+
+- [Render pipeline feature comparison](https://docs.unity3d.com/Manual/render-pipelines-feature-comparison.html)
+- [Upgrade custom shaders for URP compatibility](https://docs.unity3d.com/Manual/urp/urp-shaders/birp-urp-custom-shader-upgrade-guide.html)
+- [Camera.OnRenderImage](https://docs.unity3d.com/ScriptReference/Camera.OnRenderImage.html)
+- [Custom post-processing in URP](https://docs.unity3d.com/Manual/urp/post-processing/custom-post-processing.html)
+- [Make a shader compatible with the Deferred rendering path in URP](https://docs.unity3d.com/Manual/urp/rendering/make-shader-compatible-with-deferred.html)
+
+## Ground Truth
+
+- The Render Pipeline Converter does not auto-upgrade custom shaders.
+- URP does not support `GrabPass`.
+- URP does not support Surface Shaders.
+- `OnRenderImage` is a Built-in image-effect path; URP custom fullscreen effects should move toward `ScriptableRenderPass`, Renderer Features, or URP custom post-processing.
+- Hand-written shaders can work in URP, but Shader Graph is often the safer option for simpler effects.
+
+## Case 1: Surface Shaders
+
+Indicators:
+
+- `#pragma surface`
+- Surface-shader lighting models
+- heavy reliance on Built-in lighting helpers
+
+Implication:
+
+- Surface shaders do not carry over directly to URP.
+
+Safer migration path:
+
+1. Do not attempt a blind syntax patch.
+2. Decide whether the shader should be:
+   - rebuilt in Shader Graph
+   - rewritten as a URP HLSL shader
+   - replaced with an existing URP shader if the effect is not special
+3. Port and validate one representative shader before scaling.
+
+## Case 2: GrabPass, Refraction, and Scene-Color Effects
+
+Indicators:
+
+- `GrabPass`
+- screen-copy distortion or refraction effects
+- shaders that expect to sample the already-rendered scene the Built-in way
+
+Implication:
+
+- URP does not support `GrabPass`.
+
+Safer migration path:
+
+1. Determine whether the effect really needs scene color.
+2. Enable **Opaque Texture** in the URP Asset if the effect needs to sample already-rendered opaque color.
+3. For simple material-level effects, consider a Shader Graph Scene Color path when appropriate.
+4. For hand-written HLSL, prefer URP's opaque texture include instead of a raw `GrabPass` replacement:
+
+   ```hlsl
+   #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareOpaqueTexture.hlsl"
+
+   float2 screenUV = input.positionCS.xy / _ScaledScreenParams.xy;
+   half3 sceneColor = SampleSceneColor(screenUV);
+   ```
+
+5. For broader effect pipelines, plan a Renderer Feature or custom pass approach.
+6. Call out that Built-in `GrabPass` and URP opaque texture are not perfectly equivalent. Transparent sorting, when the texture is captured, and camera stacking can affect parity.
+7. Do not claim direct parity until the effect is revalidated in-scene.
+
+## Case 3: Built-in Fullscreen Effects and `OnRenderImage`
+
+Indicators:
+
+- `OnRenderImage(RenderTexture, RenderTexture)`
+- custom image-effect scripts
+- blit-style camera callbacks
+
+Implication:
+
+- In URP, these effects should move toward `ScriptableRenderPass`, Renderer Features, or URP custom post-processing.
+
+Safer migration path:
+
+1. Identify what the effect actually needs: full-screen color, depth, normals, or custom buffers.
+2. Choose a URP-compatible implementation path.
+3. For a normal fullscreen blit in Unity 6 / recent URP, propose a `ScriptableRendererFeature` with a `ScriptableRenderPass`, `RTHandle`, and `Blitter` rather than preserving `OnRenderImage`.
+4. Port one effect at a time.
+5. Validate in Game View, not only in Scene View.
+
+Avoid this common mistake:
+
+```csharp
+Blitter.BlitCameraTexture(cmd, source, source, material, 0);
+```
+
+Do not present source-to-source blits as the recommended replacement for `OnRenderImage`. Use a temporary target, then blit back to the camera color target.
+
+Minimal shape for an answer:
+
+```csharp
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+public sealed class CustomFullscreenEffectFeature : ScriptableRendererFeature
+{
+    sealed class CustomFullscreenEffectPass : ScriptableRenderPass
+    {
+        readonly ProfilingSampler m_ProfilingSampler = new("CustomFullscreenEffect");
+        Material m_Material;
+        RTHandle m_TemporaryColor;
+
+        public CustomFullscreenEffectPass(Material material)
+        {
+            m_Material = material;
+            renderPassEvent = RenderPassEvent.AfterRenderingPostProcessing;
+        }
+
+        public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
+        {
+            var descriptor = renderingData.cameraData.cameraTargetDescriptor;
+            descriptor.depthBufferBits = 0;
+            RenderingUtils.ReAllocateIfNeeded(ref m_TemporaryColor, descriptor, name: "_CustomFullscreenEffectTemp");
+        }
+
+        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
+        {
+            if (m_Material == null)
+                return;
+
+            var cmd = CommandBufferPool.Get();
+            using (new ProfilingScope(cmd, m_ProfilingSampler))
+            {
+                var source = renderingData.cameraData.renderer.cameraColorTargetHandle;
+                Blitter.BlitCameraTexture(cmd, source, m_TemporaryColor, m_Material, 0);
+                Blitter.BlitCameraTexture(cmd, m_TemporaryColor, source);
+            }
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
+        }
+
+        public void Dispose()
+        {
+            m_TemporaryColor?.Release();
+        }
+    }
+
+    [SerializeField] Material m_Material;
+    CustomFullscreenEffectPass m_Pass;
+
+    public override void Create()
+    {
+        m_Pass = new CustomFullscreenEffectPass(m_Material);
+    }
+
+    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
+    {
+        if (m_Material != null)
+            renderer.EnqueuePass(m_Pass);
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        m_Pass?.Dispose();
+    }
+}
+```
+
+Use this as a starting point, not a guarantee. The exact pass event, intermediate texture needs, camera stacking behavior, XR handling, and RenderGraph path may need adjustment for the target URP version.
+
+## Case 4: Replacement Shader and Alternate-Camera Rendering Workflows
+
+Indicators:
+
+- `RenderWithShader`
+- `SetReplacementShader`
+- camera-based normal/depth/edge pipelines
+
+Implication:
+
+- These workflows often depend on Built-in rendering assumptions and pass tags.
+
+Safer migration path:
+
+1. Identify the purpose of the replacement pass — outlines, selection, depth, normals, masks, and so on.
+2. Determine whether URP already exposes a better path through renderer configuration, depth/normal textures, or a custom pass.
+3. If a custom shader is still required, port the shader with explicit URP pass/tag expectations instead of assuming Built-in tags still drive the same behavior.
+
+## Case 5: Multi-Pass, Custom Lighting, and Deferred-Specific Shaders
+
+Indicators:
+
+- many passes in one shader
+- custom forward-add or deferred assumptions
+- lighting code tightly coupled to Built-in helper includes
+- shaders that need specific deferred compatibility
+
+Implication:
+
+- These are not simple "replace includes and tags" conversions.
+
+Safer migration path:
+
+1. Determine which passes are still needed in URP.
+2. If the shader must support URP Deferred, validate the required URP pass tags and rendering-path behavior.
+3. If the shader can be forward-only, say so explicitly and scope the port accordingly.
+4. Expect multiple validation rounds.
+
+## Case 6: Package-Owned and Framework Shaders
+
+Indicators:
+
+- Asset Store shader frameworks
+- water, foliage, toon, outline, dissolve, or special rendering packages
+- package namespace includes or generated shader code
+
+Implication:
+
+- These are not safe to rewrite blindly. They may need maintainer guidance, a scoped custom replacement, or manual follow-up if the project does not already contain an approved URP-compatible path.
+
+Safer migration path:
+
+1. Identify the exact materials and shader files affected.
+2. Do not edit immutable package files or generated shader internals in bulk.
+3. Use local material copies or scoped custom replacements when the user approves that approach.
+4. Limit manual ports to the exact materials the user needs and call out the risk clearly.
+
+## Case 7: Foliage, Grass, Tree, and Billboard Shaders
+
+Indicators:
+
+- grass, tree, bush, leaf, terrain detail, SpeedTree, billboard, or vegetation material names
+- `Nature/`, `TreeCreator`, `Grass`, `Foliage`, or similar shader names
+- cutout or alpha-test properties such as `_Cutoff`, `_AlphaClip`, `_AlphaTest`, or alpha threshold keywords
+- culling, two-sided, billboard, wind, bend, hue variation, or terrain-detail keywords
+
+Implication:
+
+- A grass or tree material can be "not pink" but still wrong if the converter drops alpha clipping, two-sided leaf rendering, wind, billboard behavior, normals, tint, or terrain detail integration.
+- Plain URP Lit can be acceptable only for simple opaque bark or non-specialized meshes. It is usually not enough for grass cards, leaf cards, billboards, or wind-driven foliage.
+
+Safer migration path:
+
+1. Separate bark/opaque mesh materials from leaf, grass, billboard, and terrain-detail materials.
+2. For simple bark/opaque materials, preserve base map, color, normal, metallic/smoothness, and tiling/offset.
+3. For foliage cards, preserve base texture, tint, alpha cutoff, transparent/cutout intent, culling/two-sided intent, and normal/detail maps.
+4. Do not call foliage complete until a representative scene/camera confirms grass and leaves are not solid opaque quads.
+5. If wind, billboard, or terrain-detail behavior cannot be preserved in the current pass, report that exact behavior as manual/custom-shader follow-up instead of claiming full visual parity.
+
+## Stop-and-Escalate Signals
+
+Stop and summarize the blocker instead of guessing when:
+
+- multiple high-risk shader categories overlap in the same project
+- the effect depends on undocumented package internals
+- the shader compiles but visual parity is clearly not explainable by parameter tuning
+- the project relies heavily on custom fullscreen or replacement-shader rendering paths
+- the user expects production-safe parity but the port strategy is still exploratory