Shaders

 GDScript / inspector
   ShaderMaterial ── shader: .gdshader
        │  set_shader_parameter("u", v)
        ▼
 vertex()    once per vertex: move VERTEX, set varyings
        │    (canvas_item: local space; spatial: model space)
        ▼
 rasterise   varyings interpolated
        ▼
 fragment()  once per pixel: COLOR (2D) or ALBEDO,
        │    ROUGHNESS, NORMAL_MAP ... (3D)
        ▼
 light()     once per pixel per light (optional):
             LIGHT (2D) or DIFFUSE_LIGHT / SPECULAR_LIGHT (3D)

shader_type canvas_item;          // required, first
render_mode blend_mix, unshaded;  // optional flags
 
uniform vec4 tint : source_color = vec4(1.0);
uniform float amount : hint_range(0.0, 1.0) = 0.5;
 
varying vec2 world_pos;           // vertex -> fragment
 
const float PI_2 = 6.2831853;
 
float wave(float x) {             // helper functions
    return 0.5 + 0.5 * sin(x * PI_2);
}
 
void vertex() {
    world_pos = (MODEL_MATRIX * vec4(VERTEX, 0.0, 1.0)).xy;
}
 
void fragment() {
    // COLOR = TEXTURE sample x vertex color x modulate
    vec3 c = mix(COLOR.rgb, tint.rgb, amount);
    COLOR.rgb = c * wave(TIME + world_pos.x * 0.01);
}

shader_type spatial;
 
uniform sampler2D albedo_tex : source_color,
    filter_linear_mipmap_anisotropic;
uniform sampler2D normal_tex : hint_normal;
uniform float rough : hint_range(0.0, 1.0) = 0.6;
 
void fragment() {
    ALBEDO = texture(albedo_tex, UV).rgb;
    NORMAL_MAP = texture(normal_tex, UV).rgb;
    ROUGHNESS = rough;
    METALLIC = 0.0;
    // world-space normal from the view-space one
    vec3 wn = (INV_VIEW_MATRIX * vec4(NORMAL, 0.0)).xyz;
    EMISSION = vec3(0.2, 0.6, 1.0) * max(wn.y, 0.0) * 0.2;
}
 
void light() {            // replaces built-in lighting
    float ndl = max(dot(NORMAL, LIGHT), 0.0);
    float toon = step(0.5, ndl);   // two-band toon
    DIFFUSE_LIGHT += toon * ATTENUATION * LIGHT_COLOR / PI;
}

shader_type particles;
uniform float spread = 2.0;
 
void start() {              // when a particle (re)spawns
    uint s = NUMBER;        // per-particle seed
    float a = float(s % 360u) * 0.01745;
    VELOCITY = vec3(cos(a), 4.0, sin(a)) * spread;
    COLOR = vec4(1.0);
    CUSTOM.y = 0.0;         // our own age counter
    TRANSFORM = EMISSION_TRANSFORM;
}
 
void process() {            // every frame per particle
    VELOCITY.y -= 9.8 * DELTA;
    TRANSFORM[3].xyz += VELOCITY * DELTA;
    CUSTOM.y += DELTA / LIFETIME;   // 0 -> 1 over life
    COLOR.a = 1.0 - CUSTOM.y;
}

shader_type sky;
uniform vec3 top : source_color = vec3(0.2, 0.4, 0.9);
uniform vec3 horizon : source_color = vec3(0.9, 0.8, 0.7);
 
void sky() {
    float t = clamp(EYEDIR.y, 0.0, 1.0);
    COLOR = mix(horizon, top, pow(t, 0.5));
    // sun disc from the first DirectionalLight3D
    float sun = dot(EYEDIR, LIGHT0_DIRECTION);
    COLOR += LIGHT0_COLOR * smoothstep(0.998, 1.0, sun);
}

uniform float speed = 1.0;                    // default
uniform vec4 color : source_color;           // sRGB picker
uniform float fade : hint_range(0.0, 1.0, 0.01) = 1.0;
uniform int mode : hint_enum("Add", "Mul") = 0;
uniform sampler2D tex : source_color, filter_nearest,
    repeat_enable;
uniform sampler2D mask : hint_default_white;
uniform float weights[4];                     // arrays
 
group_uniforms Wind;                          // inspector
uniform float wind_strength = 0.1;
uniform float wind_speed = 1.0;
group_uniforms;

# Instance uniform on a GeometryInstance3D
$Crate.set_instance_shader_parameter("tint", Color.RED)
 
# Global uniform (declare it in Project Settings first)
func _process(_d: float) -> void:
    RenderingServer.global_shader_parameter_set(
        "player_pos", $Player.global_position)

shader_type spatial;
varying vec3 world_pos;
 
void vertex() {
    world_pos = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz;
}
 
void fragment() {
    // world-space checkerboard, independent of UVs
    vec3 cell = floor(world_pos);
    float c = mod(cell.x + cell.y + cell.z, 2.0);
    ALBEDO = mix(vec3(0.2), vec3(0.8), c);
}

shader_type canvas_item;
uniform sampler2D screen_tex : hint_screen_texture,
    filter_linear_mipmap;
uniform float blur : hint_range(0.0, 5.0) = 2.0;
 
void fragment() {
    // mipmapped screen texture: cheap frosted-glass blur
    COLOR = textureLod(screen_tex, SCREEN_UV, blur);
}

shader_type spatial;
render_mode unshaded, blend_mix;
uniform sampler2D depth_tex : hint_depth_texture,
    repeat_disable, filter_nearest;
 
void fragment() {
    float d = textureLod(depth_tex, SCREEN_UV, 0.0).r;
    // Forward+ / Mobile (reverse-Z). Compatibility:
    // vec3 ndc = vec3(SCREEN_UV, d) * 2.0 - 1.0;
    vec3 ndc = vec3(SCREEN_UV * 2.0 - 1.0, d);
    vec4 view = INV_PROJECTION_MATRIX * vec4(ndc, 1.0);
    view.xyz /= view.w;
    float scene_depth = -view.z;         // meters
    float my_depth = -VERTEX.z;          // view space
    float edge = clamp(scene_depth - my_depth, 0.0, 1.0);
    ALBEDO = vec3(1.0);
    ALPHA = 1.0 - edge;      // foam where water meets ground
}

@onready var mat := $Sprite2D.material as ShaderMaterial
 
func _ready() -> void:
    mat.set_shader_parameter("amount", 0.5)
    mat.set_shader_parameter("tex", preload("res://n.png"))
    print(mat.get_shader_parameter("amount"))
 
func flash() -> void:
    var t := create_tween()
    t.tween_property(mat, "shader_parameter/amount",
        0.0, 0.25).from(1.0)
 
# 3D mesh: material slots
var m := $Mesh.get_active_material(0) as ShaderMaterial
$Mesh.set_surface_override_material(0, m.duplicate())

shader_type canvas_item;
uniform vec4 flash_color : source_color = vec4(1.0);
uniform float amount : hint_range(0.0, 1.0) = 0.0;
 
void fragment() {
    // COLOR already holds texture x modulate
    COLOR.rgb = mix(COLOR.rgb, flash_color.rgb, amount);
}

func hit() -> void:
    var m := $Sprite2D.material as ShaderMaterial
    create_tween().tween_property(
        m, "shader_parameter/amount", 0.0, 0.2).from(1.0)

shader_type canvas_item;
uniform sampler2D noise : repeat_enable;
uniform float progress : hint_range(0.0, 1.0) = 0.0;
uniform float edge : hint_range(0.0, 0.2) = 0.05;
uniform vec4 edge_color : source_color =
    vec4(1.0, 0.5, 0.1, 1.0);
 
void fragment() {
    float n = texture(noise, UV).r;
    if (n < progress) {
        discard;
    }
    // glowing rim just above the cut-off
    float rim = 1.0 - step(progress + edge, n);
    COLOR.rgb = mix(COLOR.rgb, edge_color.rgb, rim);
}

shader_type canvas_item;
uniform vec4 line_color : source_color = vec4(1.0);
uniform float width : hint_range(0.0, 8.0) = 1.0;
 
void fragment() {
    vec2 o = TEXTURE_PIXEL_SIZE * width;
    float a = texture(TEXTURE, UV + vec2(o.x, 0.0)).a;
    a = max(a, texture(TEXTURE, UV - vec2(o.x, 0.0)).a);
    a = max(a, texture(TEXTURE, UV + vec2(0.0, o.y)).a);
    a = max(a, texture(TEXTURE, UV - vec2(0.0, o.y)).a);
    vec4 outline = vec4(line_color.rgb, a * line_color.a);
    COLOR = mix(outline, COLOR, COLOR.a);  // inside wins
}

shader_type canvas_item;
uniform sampler2D screen_tex : hint_screen_texture,
    filter_linear;
uniform sampler2D noise : repeat_enable, filter_linear;
uniform vec2 scroll = vec2(0.05, 0.02);
uniform float distortion : hint_range(0.0, 0.05) = 0.01;
uniform vec4 tint : source_color = vec4(0.2, 0.5, 0.8, 0.5);
 
void fragment() {
    vec2 n = texture(noise, UV + TIME * scroll).rg - 0.5;
    vec2 n2 = texture(noise, UV * 1.7 - TIME * scroll).rg;
    vec2 off = (n + n2 - 0.5) * distortion;
    vec3 under = texture(screen_tex, SCREEN_UV + off).rgb;
    COLOR = vec4(mix(under, tint.rgb, tint.a), 1.0);
}

shader_type spatial;
render_mode cull_disabled;
uniform sampler2D albedo_tex : source_color,
    filter_linear_mipmap;
uniform float strength = 0.15;
uniform float speed = 1.5;
uniform vec2 wind_dir = vec2(1.0, 0.0);
 
void vertex() {
    vec3 w = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz;
    float t = TIME * speed + w.x * 0.4 + w.z * 0.3;
    float sway = sin(t) + 0.5 * sin(t * 2.3);
    float weight = 1.0 - UV.y;         // 0 at the root
    VERTEX.xz += wind_dir * sway * strength * weight;
}
 
void fragment() {
    vec4 c = texture(albedo_tex, UV);
    ALBEDO = c.rgb;
    ALPHA = c.a;
    ALPHA_SCISSOR_THRESHOLD = 0.5;     // no sorting cost
}

shader_type canvas_item;
uniform sampler2D screen_tex : hint_screen_texture,
    filter_linear;
uniform float amount : hint_range(0.0, 1.0) = 1.0;
 
void fragment() {
    vec3 c = texture(screen_tex, SCREEN_UV).rgb;
    float l = dot(c, vec3(0.2126, 0.7152, 0.0722));
    COLOR = vec4(mix(c, vec3(l), amount), 1.0);
}