@dsalazardev/ai-hub-cli 0.0.0-stage → 0.2.0

package/skills/shared/gamedev-shaders/references/effect-recipes.md

@@ -0,0 +1,205 @@
+# Effect recipes
+
+Full per-engine detail behind SKILL.md's recipe table. Each recipe: the technique, then code.
+Godot examples are `.gdshader` (4.x); Unity is URP HLSL/Shader Graph; Unreal is Material graph
+described as node chains (drop to a Custom node only where noted).
+
+---
+
+## 1. Dissolve
+
+**Technique.** Sample a noise texture, compare to an animated `threshold`; cut pixels below it;
+add an emissive band in a thin range above the threshold so the edge glows as the object burns.
+
+**Godot (spatial):**
+
+```glsl
+shader_type spatial;
+render_mode cull_disabled;
+uniform sampler2D noise : hint_default_white;
+uniform float threshold : hint_range(0.0, 1.0) = 0.0;
+uniform float edge = 0.05;
+uniform vec3 edge_color : source_color = vec3(1.0, 0.4, 0.0);
+void fragment() {
+    float n = texture(noise, UV).r;
+    if (n < threshold) discard;
+    float e = smoothstep(threshold, threshold + edge, n);
+    ALBEDO = vec3(0.6);
+    EMISSION = edge_color * (1.0 - e) * 4.0;   // >1 for bloom
+}
+```
+
+**Unity URP (fragment):** `float n = SAMPLE_TEXTURE2D(_Noise, s, uv).r; clip(n - _Threshold);`
+then `emission = _EdgeColor * (1 - smoothstep(_Threshold, _Threshold + _Edge, n));`. In Shader
+Graph: Sample Texture → Step/Smoothstep → Alpha Clip Threshold + Emission.
+
+**Unreal:** Blend Mode = Masked. Noise Texture → Subtract Threshold parameter → **Opacity Mask**.
+For the glow, `Smoothstep` around the threshold → multiply EdgeColor → **Emissive Color**. Animate
+Threshold via a Dynamic Material Instance or a Curve.
+
+---
+
+## 2. Rim light & outline
+
+**Rim (fresnel).** Brightens grazing angles: `rim = pow(1 - saturate(dot(N, V)), power)`. Cheap,
+per-pixel, great for shields/highlights.
+
+**Godot:**
+
+```glsl
+shader_type spatial;
+uniform vec3 rim_color : source_color = vec3(0.4, 0.7, 1.0);
+uniform float power : hint_range(0.5, 8.0) = 3.0;
+void fragment() {
+    float f = pow(1.0 - dot(normalize(NORMAL), normalize(VIEW)), power);
+    EMISSION = rim_color * f;
+}
+```
+
+**Unity:** Fresnel Effect node (Power input) → multiply color → Emission. **Unreal:** Fresnel node
+→ multiply → Emissive Color.
+
+**Outline** — two approaches:
+- **Inverted hull** (mesh outline): a second pass that pushes vertices along their normals and
+  renders only back faces in the outline color. Godot: a second material pass with
+  `render_mode cull_front;` and `VERTEX += NORMAL * width;` in `vertex()`. Unity: an extra Pass
+  with `Cull Front` offsetting `positionOS` along the normal. Unreal: post-process, or a second
+  mesh scaled along normals.
+- **Post-process edge detect** (screen outline): compare neighboring **depth** and **normal**
+  samples; large deltas = an edge. Domain = Post Process (UE) / Full Screen (URP) / ColorRect
+  reading `hint_depth_texture` (Godot). Best for uniform-width screen outlines regardless of mesh.
+
+---
+
+## 3. Toon / cel
+
+**Technique.** Replace smooth diffuse `N·L` with quantized bands (a hard `step`, a few
+`smoothstep` bands, or a 1D ramp texture lookup). Add a stepped specular and optional rim.
+
+**Godot (custom lighting via `light()`):**
+
+```glsl
+shader_type spatial;
+uniform sampler2D ramp : hint_default_white, filter_linear;
+void light() {
+    float ndl = clamp(dot(NORMAL, LIGHT), 0.0, 1.0);
+    float band = texture(ramp, vec2(ndl, 0.5)).r;   // ramp = your toon gradient
+    DIFFUSE_LIGHT += ATTENUATION * LIGHT_COLOR.rgb * band;
+}
+```
+
+Cheaper hard cut without a ramp: `float band = step(0.5, ndl);` or two-step
+`smoothstep(0.48, 0.5, ndl)`. **Unity:** compute `NdotL` in a lit HLSL pass and quantize, or a
+Shader Graph with the main light direction + Step. **Unreal:** custom shading is limited without
+engine mods — approximate with a Post Process banding of scene color, or `CustomLighting`-style
+math in an Unlit material driven by a light vector parameter.
+
+---
+
+## 4. Water / flow
+
+**Technique.** Two scrolling normal maps at different speeds/scales summed for waves; refract the
+scene behind by offsetting the screen UV with the normal; add depth-based foam where scene depth
+is close to the surface. A **flow map** (RG = 2D flow direction) advects UVs for rivers.
+
+**Godot (spatial, refraction + normals):**
+
+```glsl
+shader_type spatial;
+render_mode cull_disabled;
+uniform sampler2D normal_map : hint_normal, repeat_enable;
+uniform sampler2D screen_tex : hint_screen_texture, filter_linear_mipmap;
+uniform sampler2D depth_tex  : hint_depth_texture;
+uniform float speed = 0.03;
+uniform float strength = 0.02;
+void fragment() {
+    vec2 uv1 = UV + vec2(TIME * speed, 0.0);
+    vec2 uv2 = UV - vec2(0.0, TIME * speed * 0.7);
+    vec3 n = normalize(texture(normal_map, uv1).xyz + texture(normal_map, uv2).xyz - 1.0);
+    vec2 refr = SCREEN_UV + n.xy * strength;
+    ALBEDO = texture(screen_tex, refr).rgb;
+    NORMAL_MAP = n * 0.5 + 0.5;
+}
+```
+
+Foam: compare linearized `depth_tex` at `SCREEN_UV` to the surface's own depth; where the
+difference is small, `mix` toward white. **Unity:** two Sample Texture 2D (normal) with
+Time-driven offsets → combine → Scene Color offset by normal; Scene Depth node difference for
+foam. **Unreal:** Panner nodes on normal maps, Refraction pin, and `SceneDepth − PixelDepth` for a
+foam mask; Single Layer Water shading model for oceans.
+
+---
+
+## 5. Force field / shield
+
+**Technique.** Fresnel base + a scrolling hex/pattern texture, boosted where the mesh intersects
+other geometry (scene-depth difference), additive/translucent. Optional hit ripples from a
+world-space impact point parameter.
+
+**Godot:**
+
+```glsl
+shader_type spatial;
+render_mode blend_add, cull_disabled, unshaded, depth_draw_never;
+uniform sampler2D pattern : repeat_enable;
+uniform sampler2D depth_tex : hint_depth_texture;
+uniform vec3 color : source_color = vec3(0.2, 0.7, 1.0);
+uniform float power : hint_range(0.5, 8.0) = 2.0;
+void fragment() {
+    float fres = pow(1.0 - dot(normalize(NORMAL), normalize(VIEW)), power);
+    float hex = texture(pattern, UV + TIME * 0.05).r;
+    // intersection glow
+    float scene = texture(depth_tex, SCREEN_UV).x;
+    vec4 v = INV_PROJECTION_MATRIX * vec4(SCREEN_UV * 2.0 - 1.0, scene, 1.0);
+    float edge = smoothstep(0.0, 1.0, abs(-v.z / v.w - (-VERTEX.z)));
+    EMISSION = color * (fres + hex * 0.3 + (1.0 - edge));
+    ALPHA = clamp(fres + hex * 0.3, 0.0, 1.0);
+}
+```
+
+**Unity/Unreal:** Fresnel + Panner on a pattern texture, additive/translucent blend, and a Scene
+Depth vs pixel-depth difference (Unity Scene Depth node; UE `SceneDepth − PixelDepth`) for the
+intersection band.
+
+---
+
+## 6. Hologram
+
+**Technique.** Scanlines from `sin(worldY * freq + TIME)`, fresnel edge glow, periodic flicker
+(noise or `sin`), a small per-channel UV offset for chromatic fringing, additive or translucent.
+
+**Godot:**
+
+```glsl
+shader_type spatial;
+render_mode blend_add, cull_disabled, unshaded;
+uniform vec3 color : source_color = vec3(0.3, 0.9, 1.0);
+uniform float lines = 120.0;
+uniform float speed = 2.0;
+varying vec3 wpos;
+void vertex() { wpos = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz; }
+void fragment() {
+    float scan = 0.5 + 0.5 * sin(wpos.y * lines + TIME * speed);
+    float fres = pow(1.0 - dot(normalize(NORMAL), normalize(VIEW)), 2.0);
+    float flicker = 0.9 + 0.1 * sin(TIME * 30.0);
+    EMISSION = color * (scan * 0.6 + fres) * flicker;
+    ALPHA = (scan * 0.5 + fres) * flicker;
+}
+```
+
+**Unity:** world-position Y into a Sine → scanlines; Fresnel node; Time-driven flicker; additive.
+**Unreal:** `WorldPosition.B` (Z-up) → Sine → scanlines, Fresnel, Time flicker → Emissive; Blend
+Mode Translucent/Additive, Unlit. Chromatic fringing: sample the effect at slightly offset UVs per
+R/G/B channel.
+
+---
+
+## Cross-cutting notes
+
+- **Additive/translucent** effects (shield, hologram, force field) stack overdraw — keep them
+  small on screen and unshaded (`render_mode unshaded` / Unlit / Emissive-only).
+- **Depth-based** recipes (foam, intersection glow, screen outline) need the engine's depth
+  texture enabled: URP *Depth Texture* toggle; UE reads SceneDepth natively; Godot's
+  `hint_depth_texture` is available in the forward+ / mobile renderers.
+- Author tunables (speed, power, colors, thresholds) as **parameters/uniforms** and drive them
+  from an animation track or code — never bake magic numbers you'll want to tweak live.

package/skills/shared/gamedev-shaders/references/godot-shading-language.md

@@ -0,0 +1,133 @@
+# Godot 4.x shading language
+
+Depth behind SKILL.md's Godot section. Targets Godot 4.4/4.5. Godot ships its own GLSL-like
+language in `.gdshader` files; a `ShaderMaterial` binds a shader to a node and stores uniform values.
+
+## The five shader types
+
+Every `.gdshader` starts with exactly one `shader_type`:
+
+| `shader_type` | Drives | Key entry points |
+| --- | --- | --- |
+| `spatial` | 3D materials on `MeshInstance3D` etc. | `vertex()`, `fragment()`, `light()` |
+| `canvas_item` | 2D (`Sprite2D`, `TextureRect`, `Control`, …) | `vertex()`, `fragment()`, `light()` |
+| `particles` | GPU particle process (`GPUParticles2D/3D`) | `start()`, `process()` |
+| `sky` | `Sky` resource in an `Environment` | `sky()` |
+| `fog` | `FogVolume` local volumetric fog | `fog()` |
+
+Tokens are exact: `canvas_item` has an underscore, `particles` is plural.
+
+## Uniforms and hints
+
+`uniform`s become material parameters (editable in the inspector, settable from code). Hints tell
+the engine how to treat them:
+
+```glsl
+uniform vec4  albedo      : source_color = vec4(1.0);        // sRGB→linear color picker
+uniform float amount      : hint_range(0.0, 1.0, 0.01) = 0.5;// slider min,max,step
+uniform sampler2D tex      : source_color, filter_linear_mipmap, repeat_enable;
+uniform sampler2D mask     : hint_default_white;             // default when unbound (also _black, _transparent)
+uniform sampler2D screen_tex : hint_screen_texture, filter_linear_mipmap;
+uniform sampler2D depth_tex  : hint_depth_texture;
+uniform sampler2D nr_tex     : hint_normal_roughness_texture;
+global uniform float game_time;                              // shared project-wide global
+instance uniform vec4 tint : source_color;                   // per-instance override
+```
+
+Migration from Godot 3 (never emit the left side): `hint_color`/`hint_albedo` → `source_color`;
+`hint_white`/`hint_black` → `hint_default_white`/`hint_default_black`; the `SCREEN_TEXTURE`,
+`DEPTH_TEXTURE`, `NORMAL_TEXTURE` **built-ins** → `hint_screen_texture` / `hint_depth_texture` /
+`hint_normal_roughness_texture` **uniforms**.
+
+Texture filter/repeat qualifiers: `filter_nearest`, `filter_linear`, `filter_nearest_mipmap`,
+`filter_linear_mipmap`, `filter_linear_mipmap_anisotropic`; `repeat_enable`, `repeat_disable`.
+
+## varying — vertex → fragment
+
+Declare at file scope, write in `vertex()`, read (interpolated) in `fragment()`:
+
+```glsl
+varying vec3 world_pos;
+void vertex()   { world_pos = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz; }
+void fragment() { /* use world_pos */ }
+```
+
+Add an interpolation qualifier when needed: `varying flat int id;` (no interpolation),
+`varying smooth vec3 n;` (default).
+
+## render_mode
+
+Comma-separated flags right after `shader_type`. Common spatial modes:
+
+```glsl
+render_mode blend_add, cull_disabled, unshaded, depth_draw_opaque, depth_test_disabled, shadows_disabled;
+```
+
+`blend_mix|add|sub|mul`; `cull_back|front|disabled`; `unshaded` (skip lighting); `depth_draw_*`;
+`fog_disabled`. canvas_item supports `blend_*`, `unshaded`, `light_only`, etc.
+
+## Built-ins by type (most-used)
+
+**spatial `fragment()` — inputs:** `UV`, `UV2`, `NORMAL` (view space), `VIEW` (view space, toward
+camera), `VERTEX` (view-space position), `COLOR` (vertex color), `SCREEN_UV`, `TIME`,
+`FRAGCOORD`, matrices `MODEL_MATRIX`, `VIEW_MATRIX`, `INV_VIEW_MATRIX`, `PROJECTION_MATRIX`,
+`INV_PROJECTION_MATRIX`. **outputs:** `ALBEDO`, `ALPHA`, `METALLIC`, `ROUGHNESS`, `SPECULAR`,
+`EMISSION`, `NORMAL_MAP` (tangent-space, expects 0–1), `NORMAL_MAP_DEPTH`, `AO`, `RIM`,
+`CLEARCOAT`, `ALPHA_SCISSOR_THRESHOLD`.
+
+**spatial `vertex()`:** read/write `VERTEX`, `NORMAL`, `TANGENT`, `UV`, `COLOR`; write `POSITION`
+directly (in clip space) to bypass the standard transform — used for full-screen quads:
+`POSITION = vec4(VERTEX.xy, 1.0, 1.0);`.
+
+**canvas_item `fragment()`:** inputs `UV`, `COLOR` (vertex×modulate), `SCREEN_UV`, `TEXTURE`
+(the node's texture), `TEXTURE_PIXEL_SIZE`, `TIME`; output `COLOR`. `MODULATE` exposes the
+CanvasItem modulate separately.
+
+**particles `process()`:** `TRANSFORM`, `VELOCITY`, `COLOR`, `CUSTOM`, `LIFETIME`, `DELTA`,
+`RESTART`, `EMISSION_TRANSFORM`, `ATTRACTOR_FORCE`.
+
+## Screen and depth reads
+
+`SCREEN_TEXTURE` is gone — declare a uniform:
+
+```glsl
+shader_type canvas_item;
+uniform sampler2D screen_tex : hint_screen_texture, filter_linear_mipmap;
+void fragment() { COLOR = texture(screen_tex, SCREEN_UV); }  // what's behind this node
+```
+
+Depth to view/world position in a spatial full-screen pass:
+
+```glsl
+uniform sampler2D depth_tex : hint_depth_texture;
+void fragment() {
+    float d = texture(depth_tex, SCREEN_UV).x;
+    vec4 ndc = vec4(SCREEN_UV * 2.0 - 1.0, d, 1.0);
+    vec4 view = INV_PROJECTION_MATRIX * ndc; view.xyz /= view.w;   // view-space position
+    float linear_depth = -view.z;
+}
+```
+
+## ShaderMaterial from code (GDScript)
+
+```gdscript
+var mat := ShaderMaterial.new()
+mat.shader = preload("res://dissolve.gdshader")
+mesh.material_override = mat
+mat.set_shader_parameter("threshold", 0.7)
+mat.set_shader_parameter("edge_color", Color(1, 0.4, 0))
+# animate a uniform each frame
+func _process(delta): mat.set_shader_parameter("threshold", t)
+```
+
+C# parity: `mat.SetShaderParameter("threshold", 0.7f);`. Prefer an `AnimationPlayer` track on the
+material's `shader_parameter/<name>` for authored animations.
+
+## Common gotchas
+
+- `NORMAL` and `VIEW` in a spatial `fragment()` are **view space**, not world — transform with
+  `INV_VIEW_MATRIX` if you need world space (e.g. triplanar, world-space fresnel toward a point).
+- Re-`normalize()` interpolated normals per pixel.
+- `discard` (and `ALPHA_SCISSOR_THRESHOLD`) disables early depth — costs overdraw; use only for cutouts.
+- Set `render_mode unshaded` on pure-emissive/effect materials to skip the lighting cost.
+- Precompute in `vertex()` and pass a `varying` whenever the quantity interpolates linearly.

package/skills/shared/gamedev-shaders/references/unity-and-unreal-shaders.md

@@ -0,0 +1,169 @@
+# Unity 6 & Unreal 5.x shaders
+
+Depth behind SKILL.md's Unity and Unreal sections.
+
+---
+
+## Unity 6 (URP / HDRP)
+
+Unity 6 (6000.x LTS) ships the Scriptable Render Pipeline as the norm: **URP** (Universal) for
+most projects, **HDRP** (High Definition) for high-end PC/console. The retired Built-in RP still
+exists but do not author new shaders for it.
+
+### Choosing the authoring path
+
+| Path | When | Notes |
+| --- | --- | --- |
+| **Shader Graph** | Surface looks, VFX, artist iteration | Visual master stack (Vertex + Fragment blocks); URP/HDRP; compiles to HLSL. |
+| **Hand-written HLSL** | Custom lighting, tight control, compute-driven | ShaderLab wrapper + `HLSLPROGRAM` block including URP libraries. |
+
+**Surface shaders (`#pragma surface`) do NOT compile under URP/HDRP** — they are a Built-in-RP
+feature. Under SRP write a lit HLSL pass or use Shader Graph.
+
+### Minimal URP unlit HLSL shader
+
+```hlsl
+Shader "Custom/URPUnlitScroll" {
+    Properties {
+        _BaseMap ("Texture", 2D) = "white" {}
+        _Tint ("Tint", Color) = (1,1,1,1)
+        _Speed ("Scroll Speed", Float) = 0.1
+    }
+    SubShader {
+        Tags { "RenderPipeline"="UniversalPipeline" "RenderType"="Opaque" }
+        Pass {
+            HLSLPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+
+            struct Attributes { float4 positionOS : POSITION; float2 uv : TEXCOORD0; };
+            struct Varyings   { float4 positionHCS : SV_POSITION; float2 uv : TEXCOORD0; };
+
+            TEXTURE2D(_BaseMap); SAMPLER(sampler_BaseMap);
+            CBUFFER_START(UnityPerMaterial)
+                float4 _BaseMap_ST; float4 _Tint; float _Speed;
+            CBUFFER_END
+
+            Varyings vert (Attributes IN) {
+                Varyings o;
+                o.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);   // NOT UnityObjectToClipPos
+                o.uv = TRANSFORM_TEX(IN.uv, _BaseMap);
+                return o;
+            }
+            half4 frag (Varyings IN) : SV_Target {
+                float2 uv = IN.uv + float2(_Time.y * _Speed, 0);
+                return SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv) * _Tint;
+            }
+            ENDHLSL
+        }
+    }
+}
+```
+
+For a **lit** pass add `#include ".../Lighting.hlsl"`, compute normals in world space, and call
+`UniversalFragmentPBR` / light loops. `mul(UNITY_MATRIX_MVP, v)` and `UnityObjectToClipPos` are
+Built-in-RP idioms — never emit them for URP.
+
+### Shader Graph mapping (concepts)
+
+- **Master stack** = Vertex block (Position/Normal/Tangent) + Fragment block (Base Color, Metallic,
+  Smoothness, Emission, Alpha, Normal (Tangent Space)).
+- Time node → scrolling; Fresnel Effect node → rim; Sample Texture 2D → maps; Step/Smoothstep →
+  toon banding; Scene Color / Scene Depth nodes need the URP opaque texture / depth toggles on.
+- **Custom Function node** embeds an `.hlsl` snippet inside the graph (the Shader Graph analog of
+  UE's Custom node).
+
+### Runtime parameters
+
+`Material.SetFloat/SetColor/SetTexture`, or a `MaterialPropertyBlock` on the renderer for
+per-instance values without new material instances. Enable keyword variants with `#pragma
+multi_compile` / `shader_feature` and `Material.EnableKeyword`.
+
+### Full-screen / post-process (URP)
+
+Add a **Full Screen Pass Renderer Feature** to the URP Renderer and point it at a *Fullscreen*
+Shader Graph (Fullscreen master) or a Blit material. HDRP uses a Custom Pass Volume / Fullscreen
+Custom Pass. `OnRenderImage`/`Graphics.Blit` image effects are Built-in-RP only.
+
+---
+
+## Unreal 5.x
+
+A **Material** is a node graph compiled to HLSL. Targets UE 5.4+.
+
+### Result-node outputs
+
+Base Color, Metallic, Specular, Roughness, Anisotropy, Emissive Color, Opacity, Opacity Mask,
+Normal, World Position Offset, Ambient Occlusion, Refraction, Pixel Depth Offset. Which are active
+depends on the Blend Mode and Shading Model.
+
+### Material Domain — pick what it drives
+
+| Domain | Use |
+| --- | --- |
+| **Surface** | Standard meshes (default). |
+| **Deferred Decal** | Projected decals onto the g-buffer. |
+| **Light Function** | Modulates a light's contribution. |
+| **Volume** | Volumetric fog/clouds. |
+| **Post Process** | Full-screen effect on a Post Process Volume (see below). |
+| **User Interface** | UMG widget materials. |
+
+**Blend Mode**: Opaque / Masked (uses Opacity Mask + a mask clip value) / Translucent (uses
+Opacity) / Additive / Modulate. **Shading Model**: Default Lit / Unlit / Subsurface / Clear Coat /
+Two Sided Foliage / Hair / Eye / Cloth / Single Layer Water.
+
+Match the pin to the mode: Opacity needs Translucent/Additive; Opacity Mask needs Masked; feeding
+the wrong one is a silent no-op.
+
+### Custom HLSL node
+
+The escape hatch when the node set can't express the logic (loops, bitwise, custom math). Set the
+node's **Output Type**, add named **Inputs** (they become HLSL variables), write HLSL, `return`:
+
+```hlsl
+// Inputs: Time (Scalar), UV (Vector2), Freq (Scalar). Output Type: CMOT Float3.
+float scan = 0.5 + 0.5 * sin(UV.y * Freq + Time * 6.2831);
+float rim  = pow(1.0 - saturate(dot(normalize(V), normalize(N))), 3.0); // wire V,N as inputs
+return float3(scan, scan, scan) * rim;
+```
+
+Prefer graph nodes for anything nodes *can* express — Custom nodes block constant-folding and
+some cross-platform optimizations. Reuse shared logic via **Material Functions**.
+
+### Material Instances
+
+Mark parameters (right-click a constant → *Convert to Parameter*): Scalar, Vector, Texture,
+StaticSwitch. A **Material Instance Constant** is an authored variant; a **Dynamic Material
+Instance** (`CreateDynamicMaterialInstance`) is set at runtime:
+
+```cpp
+UMaterialInstanceDynamic* MID = Mesh->CreateDynamicMaterialInstance(0, BaseMat);
+MID->SetScalarParameterValue("Dissolve", 0.7f);
+MID->SetVectorParameterValue("EdgeColor", FLinearColor(1, 0.4f, 0));
+```
+
+Static switches compile out branches into variants; use them for feature toggles rather than a
+runtime `if`.
+
+### Post-process material
+
+Set Material Domain = **Post Process**, add it to a **Post Process Volume** (or camera). Read the
+frame with **SceneTexture** nodes — `PostProcessInput0` (scene color), `SceneDepth`, world normal,
+custom-depth/custom-stencil for masking specific actors. **Blendable Location** (Before/After
+Tonemapping, etc.) sets ordering; SceneTexture nodes only work in this domain.
+
+---
+
+## Godot ↔ Unity ↔ Unreal quick map
+
+| Concept | Godot 4 | Unity URP | Unreal 5 |
+| --- | --- | --- | --- |
+| Color output | `ALBEDO` / `EMISSION` | Base Color / Emission block | Base Color / Emissive Color |
+| Alpha cutout | `discard` / `ALPHA_SCISSOR_THRESHOLD` | `clip()` / Alpha Clip Threshold | Opacity Mask (Masked) |
+| Fresnel/rim | `1 - dot(NORMAL, VIEW)` | Fresnel Effect node | Fresnel node |
+| Screen color | `hint_screen_texture` | Scene Color node / opaque texture | SceneTexture: PostProcessInput0 |
+| Scene depth | `hint_depth_texture` | Scene Depth node | SceneTexture: SceneDepth |
+| Time | `TIME` | Time node / `_Time.y` | Time node |
+| Runtime param | `set_shader_parameter` | `Material.SetFloat` | `SetScalarParameterValue` (MID) |
+| Full-screen FX | ColorRect + `hint_screen_texture` / CompositorEffect | Full Screen Pass Renderer Feature | Post Process material + volume |