Shaders & VFX (game engines)

Author shaders, materials, and full-screen effects across Godot, Unity, and Unreal. One mental model — the GPU pipeline — mapped onto each engine's authoring surface, plus recipes for the effects people actually ask for.

Version contract — read first

Target the current stable line of each engine and never emit its retired APIs. If unsure a symbol is current, say so rather than guess.

Engine	Target	Never emit → use instead
Godot	4.x (4.4/4.5 stable)	SCREEN_TEXTURE/DEPTH_TEXTURE/NORMAL_TEXTURE built-ins → declare a uniform sampler2D … : hint_screen_texture / hint_depth_texture / hint_normal_roughness_texture. hint_color/hint_albedo → source_color. hint_white/hint_black → hint_default_white/hint_default_black. GLES2-era guides.
Unity	6 (6000.x LTS), URP/HDRP	Surface shaders (#pragma surface) — Built-in-RP only, they do not compile under URP/HDRP. CGPROGRAM+UnityCG.cginc, UnityObjectToClipPos, mul(UNITY_MATRIX_MVP, v) → HLSLPROGRAM + URP Core.hlsl and TransformObjectToHClip(posOS). OnRenderImage/Graphics.Blit post FX → URP Renderer Feature / Fullscreen Shader Graph.
Unreal	5.x (5.4+)	SceneTexture:PostProcessInput0 outside a Post Process material; Opacity without a translucent blend mode; Opacity Mask without a Masked blend mode. Prefer graph nodes; drop to a Custom HLSL node only for logic nodes can't express.

shader_type tokens in Godot 4 are exact: spatial, canvas_item (underscore), particles (plural), sky, fog.

Shader fundamentals (the pipeline)

Every engine compiles your material into the same GPU stages. Two you write:

• Vertex stage — runs once per vertex. Transforms position into clip space and passes interpolated data (UVs, normals, custom varyings) down. Cheap; scales with mesh vertex count.
• Rasterizer (fixed) turns triangles into fragments and interpolates the vertex outputs.
• Fragment / pixel stage — runs once per covered pixel (× overdraw). Samples textures, does lighting, writes the final color. Expensive; scales with screen coverage.

Per-vertex vs per-pixel is the core performance lever: compute anything that interpolates linearly (position offsets, un-normalized directions, scalar masks) in the vertex stage and pass it as a varying; keep only what must be exact per-pixel (normalizing interpolated normals, texture sampling, lighting, fresnel) in the fragment stage.

UVs are per-vertex 2D texture coordinates (0–1), interpolated across the face — you sample textures and drive scrolling/tiling/masks with them. Normals are surface directions used for lighting and rim; interpolated normals must be re-normalized per pixel. Normal maps store directions in tangent space (unpack with ×2−1); respect handedness.

Coordinate spaces — know which space each value is in before you do math on it:

Space	Meaning	Typical use
Object / model	mesh-local, origin at the pivot	authoring positions/normals start here
World	scene-global	world-space effects, triplanar, lighting
View / camera	relative to the camera	Godot spatial NORMAL/VIEW live here
Clip / NDC	post-projection homogeneous coords	the vertex stage's required output
Tangent	per-fragment surface basis (T,B,N)	normal maps are decoded here
Screen / UV	0–1 across the framebuffer	post-process sampling (SCREEN_UV)

Per-engine authoring

Godot 4.x

Godot ships its own GLSL-like language (.gdshader). Pick a shader_type, declare uniforms (exposed as material parameters), pass data with varying, write vertex()/fragment() (+light()). A ShaderMaterial binds the shader to a node and holds uniform values; set them from code with material.set_shader_parameter("name", value). Uniform hints: source_color (sRGB→linear color pickers), hint_range(a,b), hint_default_white, hint_screen_texture, plus texture filters/repeats (filter_linear_mipmap, repeat_enable).

Small canvas_item (2D) shader — scroll and tint a texture:

shader_type canvas_item;
uniform sampler2D noise : repeat_enable;
uniform vec4 tint : source_color = vec4(1.0);
uniform float speed = 0.1;

void fragment() {
    vec2 uv = UV + vec2(TIME * speed, 0.0);   // UV is the node's texcoord
    COLOR = texture(noise, uv) * tint * COLOR; // in COLOR = vertex/modulate color
}

Small spatial (3D) shader — a fresnel rim glow (NORMAL and VIEW are view-space here):

shader_type spatial;
render_mode blend_add, cull_back;
uniform vec3 rim_color : source_color = vec3(0.2, 0.6, 1.0);
uniform float power : hint_range(0.0, 8.0) = 3.0;

varying vec3 v_normal;
void vertex()   { v_normal = NORMAL; }        // pass to fragment via varying
void fragment() {
    float f = pow(1.0 - dot(normalize(v_normal), normalize(VIEW)), power);
    EMISSION = rim_color * f;
    ALPHA = f;
}

Deep dive (built-in variables per type, render_modes, particles/sky/fog, screen/depth reads) → references/godot-shading-language.md.

Unity 6

Two authoring paths, both on the Scriptable Render Pipeline (URP for most projects, HDRP for high-end):

• Shader Graph — visual node graph feeding a master stack (Vertex + Fragment blocks). Artist-friendly, URP/HDRP only, compiles to HLSL. Default choice for surface looks and VFX.
• Hand-written HLSL — a Shader "…" { … } (ShaderLab) wrapping Properties and Pass blocks; the program goes in an HLSLPROGRAM … ENDHLSL block that #includes URP's Core.hlsl / Lighting.hlsl. Use for full control, custom lighting, or compute-driven effects.

Surface shaders are not an option under URP/HDRP (see the Version contract) — a lit look is an HLSL pass or a Shader Graph. Set parameters at runtime through a MaterialPropertyBlock or Material.SetFloat/SetColor/SetTexture. Full URP unlit + lit HLSL pass and a Shader Graph mapping → references/unity-and-unreal-shaders.md.

Unreal 5.x

A Material is a node graph the engine compiles to HLSL. You wire outputs on the main result node — Base Color, Metallic, Roughness, Emissive Color, Normal, Opacity / Opacity Mask, World Position Offset. Key knobs on the material:

• Material Domain — what the material drives: Surface (default meshes), Deferred Decal, Light Function, Volume, Post Process (full-screen), User Interface.
• Blend Mode (Opaque/Masked/Translucent/Additive…) and Shading Model (Default Lit, Unlit, Subsurface, …). Opacity needs Translucent; Opacity Mask needs Masked.
• Material Instances expose parameters (scalar/vector/texture/switch) for cheap variants and runtime tweaks via a Dynamic Material Instance (SetScalarParameterValue, …).
• Custom node — a raw HLSL escape hatch: set Output Type, add named Inputs, return …;. Reach for it only when the node set can't express the logic (loops, bitops). Reuse via Material Functions. UE5.5+ adds Substrate as an opt-in shading system; the standard material is still default.

Custom-node HLSL, domains, and a Godot↔Unreal recipe mapping → references/unity-and-unreal-shaders.md.

Common effect recipes (concepts)

Each is a technique, engine-agnostic — the reference has full per-engine code.

Effect	Core idea
Dissolve	Threshold a noise texture against an animated cutoff; discard/clip below it; add an emissive band at the edge.
Rim / outline	Rim = fresnel pow(1 − N·V, p). Outline = inverted-hull pass (scale along normals, flip culling) or a post-process depth/normal edge detect.
Toon / cel	Quantize diffuse N·L into bands (step/smoothstep or a ramp texture); hard-stepped specular.
Water / flow	Scroll two normal maps at different speeds (or advect a flow-map's RG); refract the screen texture; depth-difference foam at shorelines.
Force field	Fresnel + scrolling hex/pattern texture + intersection glow from a scene-depth difference; additive.
Hologram	Scanlines sin(worldY·f + TIME) + fresnel + flicker + slight RGB channel offset; additive/translucent.

Worked example — dissolve (Godot spatial):

shader_type spatial;
render_mode cull_disabled;
uniform sampler2D dissolve_noise : hint_default_white;
uniform float threshold : hint_range(0.0, 1.0) = 0.0;   // animate 0 → 1
uniform float edge = 0.05;
uniform vec3 edge_color : source_color = vec3(1.0, 0.4, 0.0);

void fragment() {
    float n = texture(dissolve_noise, UV).r;
    if (n < threshold) discard;                      // cut the hole
    float e = smoothstep(threshold, threshold + edge, n);
    EMISSION = edge_color * (1.0 - e);               // glowing burn ring
    ALBEDO = vec3(0.6);
}

Drive threshold from an AnimationPlayer or set_shader_parameter. The same math ports to Unity (clip(n - threshold)) and Unreal (Opacity Mask + a threshold parameter). All six recipes, per engine → references/effect-recipes.md.

Post-processing / full-screen effects

• Godot — a canvas_item shader on a full-rect ColorRect reading hint_screen_texture, or a spatial unshaded full-screen quad reading hint_screen_texture/hint_depth_texture; or a CompositorEffect (4.3+) for a custom render pass. Environment already covers glow/tonemap/SSAO.
• Unity (URP) — a Full Screen Pass Renderer Feature driving a Fullscreen Shader Graph (or a Blit pass). HDRP uses Custom Pass / Fullscreen. Legacy OnRenderImage is Built-in-RP only.
• Unreal — a Post Process Material (Material Domain = Post Process) on a Post Process Volume; read the frame with SceneTexture nodes (SceneColor, SceneDepth, custom stencil). Blendable Location orders it against tonemapping.

Performance

• Overdraw is the top cost: transparent/additive layers each re-shade the same pixels. Prefer opaque, sort and minimize overlap, keep particle fill low. discard/clip disables early-Z — don't use it as a cheap "invisible".
• Texture sampling = a memory fetch + filter each call; dependent reads (UV derived from a prior sample) stall the pipeline. Pack masks into channels, atlas, and cache samples in locals.
• Branching: a divergent if across a GPU warp can execute both sides. Prefer step/mix/clamp; branches on a uniform (same value for all pixels) are cheap; static branches compile out.
• LOD & precision: use mipmaps, shader LOD variants, and mediump/half precision on mobile; full float only where banding shows. Move linear work to the vertex stage.
• Mobile / tile GPUs: bandwidth-bound — keep render targets small, avoid mid-pass framebuffer reads, and note that discard and large full-screen passes break tile hidden-surface removal.

Anti-patterns

Anti-pattern	Do instead
Porting a tutorial verbatim from Godot 3, Built-in RP, or pre-5.0 UE	Translate it through the Version contract table first — retired symbols still compile in old guides, not in your project.
Reading a texture or writing a color without minding linear vs sRGB	Author color uniforms as source_color (Godot) / sRGB-marked properties and check the space at every read and output — the #1 "looks washed out / too dark" bug.
Using interpolated normals raw, or a normal map straight from the sample	Re-normalize per pixel; unpack with ×2−1 and mind tangent handedness.
Writing the shader before choosing the target surface	Pick shader_type / render pipeline / material domain first (2D vs 3D, URP vs HDRP, Surface vs Post Process) — it decides which built-ins and blend modes exist.
Fresnel, normalization, or lighting math in the vertex stage	Only linearly-interpolating work goes per-vertex; exact math stays per-pixel.
discard/clip as a cheap "make it invisible"	Cull it or scale to zero — discard disables early-Z and breaks tile hidden-surface removal on mobile.
Stacking additive/translucent layers until the look works	Count the overdraw: each layer re-shades the same pixels. Prefer opaque, minimize overlap, keep particle fill low.
Full-screen effects via OnRenderImage/Graphics.Blit, or SceneTexture outside the Post Process domain	Use the engine's supported path — URP Renderer Feature / Fullscreen Shader Graph, UE Post Process material, Godot ColorRect + hint_screen_texture or CompositorEffect.

Related skills

• godot / unity / unreal — gameplay code, nodes/components, input, scene wiring; this skill owns the shading, not the C#/GDScript/Blueprint around it.
• gamedev-physics — simulation, collision, rigid bodies, character controllers (a shader that fakes refraction is here; simulating fluid dynamics is not).
• gamedev-shipping — platform export and shader-variant stripping in the build (this skill keeps the per-shader performance work).

Checklist

• Correct engine + version idiom (no banned API from the Version contract table).
• Right shader_type / render pipeline / material domain for the target (2D vs 3D, URP vs HDRP, Surface vs Post Process).
• Work placed in the right stage: linear math per-vertex via varying, exact math per-pixel.
• Colors authored in the correct space (source_color / sRGB handling); normals normalized and unpacked.
• Uniforms/parameters exposed and driven from code or an animation track — not hard-coded.
• Performance sanity: overdraw, sample count, and branching considered; mobile precision set if targeted.
• Post-process uses the engine's supported full-screen path (not a retired Built-in-RP mechanism).