Struct ShaderEffect 

pub struct ShaderEffect { /* private fields */ }

A post effect made of one WGSL fragment shader, run as a full-screen pass.

The toolkit prepends SHADER_PRELUDE, which declares:

• input_tex: texture_2d<f32> - the image so far, sampled with nearest_sampler or linear_sampler;
• history_tex: texture_2d<f32> - the stage’s previous output (see ShaderEffect::with_history; otherwise the input again);
• post: PostGlobals - the uniform with size, canvas_size, window_size, canvas_origin, canvas_extent, time and frame (see PostGlobals);
• struct VsOut { @builtin(position) pos: vec4<f32>, @location(0) uv: vec2<f32> } and the vertex shader;
• bayer4(p) / bayer8(p) ordered-dithering thresholds (see BAYER_WGSL);
• indices_tex: texture_2d<f32> - with indexed colour, the canvas’s palette indices before the lookup, at canvas size (see PostPass::indices); read them with index_at(canvas_px) or index_in(textureLoad(indices_tex, ..)). post.indexed is 1u when they are there; otherwise indices_tex is the input again;
• source_tex: texture_2d<f32> - the effect’s own source texture, set with ShaderEffect::with_source (a frame the game uploads, a lookup table); post.source is 1u when it is bound, otherwise source_tex is the input again.

Your source must define @fragment fn fs_main(in: VsOut) -> @location(0) vec4<f32>. With ShaderEffect::with_params, it must also declare its parameter block as @group(1) @binding(0) var<uniform> params: YourParams; matching the Rust struct you pass to ShaderEffect::set_params. Colours are linear (textures are sRGB, decoded on sample).

let invert = ShaderEffect::new(&ctx.gfx, "invert", r#"
    @fragment fn fs_main(in: VsOut) -> @location(0) vec4<f32> {
        let c = textureSample(input_tex, nearest_sampler, in.uv);
        return vec4<f32>(1.0 - c.rgb, c.a);
    }
"#);
ctx.gfx.add_post_effect(PostStage::Canvas, invert);

Implementations

impl ShaderEffect

pub fn new(gfx: &Graphics, label: &str, wgsl: &str) -> ShaderEffect

Compile wgsl (see the type docs for what it must define) for gfx’s frame format. Shader errors surface as wgpu validation errors, like any other pipeline.

pub fn with_params<T>( gfx: &Graphics, label: &str, wgsl: &str, params: &T, ) -> ShaderEffect

where T: Pod,

Like ShaderEffect::new, with a uniform parameter block initialised to params at @group(1) @binding(0). Mind WGSL’s uniform layout rules: pad the Rust struct to a multiple of 16 bytes and align vec3/vec4 members to 16.

pub fn with_source(self, source: TextureId) -> ShaderEffect

Bind painter texture source as source_tex, besides the scene in input_tex: an emulated screen or video frame the game uploads every frame with Graphics::update_texture_rgba, a colour lookup table. It is looked up on every run, so it follows update_texture_rgba and hot reloads. Sample it with linear_sampler or nearest_sampler; in the Window stage map a fragment to its place in the canvas with (in.pos.xy - post.canvas_origin) / post.canvas_extent.

let screen = ctx.gfx.create_texture_rgba(320, 200, &pixels, Some("screen"));
let beam = ShaderEffect::new(&ctx.gfx, "beam", BEAM_WGSL).with_source(screen);
ctx.gfx.add_post_effect(PostStage::Window, beam);
// every frame: ctx.gfx.update_texture_rgba(screen, &pixels);

pub fn set_source(&mut self, source: Option<TextureId>)

Change or (None) drop the source texture; see Self::with_source.

pub fn source(&self) -> Option<TextureId>

The source texture set with Self::with_source or Self::set_source.

pub fn with_history(self) -> ShaderEffect

Bind the stage’s previous output as history_tex (otherwise it is the input again).

pub fn set_params<T>(&mut self, params: &T)

where T: Pod,

Replace the parameter block; uploaded before the next run. Ignored (with a warning) for an effect created without params or with params of another type.

Trait Implementations

impl PostEffect for ShaderEffect

fn apply(&mut self, pass: &mut PostPass<'_>)

Read PostPass::input and write every pixel of PostPass::output. Both are PostPass::size pixels in PostPass::format.

fn uses_history(&self) -> bool

Return true to get PostPass::history: the stage’s final output from the previous frame, for afterglow and other temporal effects.