verve.gl post-processing

Guide: Image quality & post-processing · WebGL · Advanced WebGL.

The post-processing API is part of the low-level gl core (src/core/gl/command.zig). It is driven from island code via the encoder — beginPostProcess / endPostProcess and the Encoder.run* passes — not through the declarative ctx.glScene builder. All shaders ship as WGSL + GLSL twins (WebGPU / WebGL2).

PostProcess struct

Configuration for beginPostProcess / endPostProcess.

pub const PostProcess = struct {
    bloom:     ?Bloom    = .{},     // null → skip bright-pass + blur
    fxaa:      bool      = true,    // FXAA on the final blit
    webgpu:    bool      = false,   // emit WGSL modules vs GLSL
    tonemap:   ToneMap   = .aces,   // composite tone-mapping operator
    vignette:  ?Vignette = null,    // null → off
    ao_tex:    u32       = 0,       // SSAO blurred-AO handle (composite tex2); 0 → 1×1 white (AO=1)
    scene_src: u32       = 0,       // scene-source override; 0 → h_scene_hdr (240)
};

ToneMap enum

pub const ToneMap = enum(u8) {
    linear       = 0,  // pow(clamp(hdr,0,1), 1/2.2) — clips highlights
    reinhard     = 1,  // hdr/(1+hdr), gamma 2.2
    reinhard_ext = 2,  // hdr*(1+hdr/W²)/(1+hdr), W=4, gamma 2.2
    aces         = 3,  // Hill ACES fit, NO gamma (default; pre-slice-2 output)
    agx          = 4,  // minimal AgX (Sobotka/Filament); basis for three.js AgXToneMapping
    uncharted2   = 5,  // Hable filmic, bias 2.0, W=11.2, gamma 2.2
};

The integer value is the wire contract with the composite shader (op = i32(P.tonemap + 0.5) selects the branch).

Vignette struct

pub const Vignette = struct {
    intensity: f32 = 0.0,   // 0 = off, 1 = full effect
    radius:    f32 = 0.75,  // distance from center where falloff begins (0.5–0.8)
};

Applied after tone-mapping via smoothstep(radius, radius − 0.45, d).

Bloom struct

pub const Bloom = struct {
    threshold: f32 = 1.0,  // luminance above which pixels bloom
    intensity: f32 = 0.6,  // bloom blended into the composite
};

Composite params packing

The composite stage packs into one 16-byte slot — no separate buffer:

p_comp = [intensity, tonemap, vig_intensity, vig_radius]

Render-target & shader handles

Each effect reserves a contiguous handle block (h_ = render target, sh_ = shader). Handles 240–266 are reserved for the post path so they never clash with app handles.

Post Params layout (SSAO / SSR)

SSAO and SSR share one 144-byte Params block so the bridge's binding-size path is reused:

[0..4)   = params (vec4)        // SSAO: (radius, bias, intensity, _)
                                // SSR:  (strength, max_distance, thickness, fresnel_power)
[4..20)  = inv_proj (mat4, column-major)
[20..36) = proj     (mat4, column-major)

DOF needs no matrices — its combine params are a single vec4 (focus_distance, focal_range, max_blur, _) → 32 bytes.

Encoder passes

OIT wire tags & blend state

runOit emits backend-specific structure; the resolve and weight/blend math are identical, so both backends produce the same image.

On WebGPU per-target blend is baked into the MRT pipeline, so the WebGL2 blend bits only steer the fallback (two single-target passes).

Backend divergence