Gamedev Shaders

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.

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:

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.

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.