Struct ShaderOptions 

pub struct ShaderOptions<T> { /* private fields */ }

ShaderOptions controlls the layout of your shader and wether or not you want extra uniforms like a texture or a uniform buffer

Implementations

impl<T> ShaderOptions<T>

pub const EMPTY: Self

pub fn with_uniform_data(data: &UniformData<T>) -> Self

This will create a shader with a layout of:

struct MousePos {
    stuff: vec2<f32>,
    _junk: vec2<f32>,
}

@group(2) @binding(0)
var<uniform> mouse: MousePos;

Examples found in repository

examples/ngon.rs (line 34)

fn main() {
    let mut engine = EngineBuilder::new()
        .with_resolution((500, 500))
        .remove_vsync()
        .build()
        .unwrap();

    let data = Time {
        time: 0.0,
        _pading: 0.0,
        _padding2: 0.0,
        _padding4: 0.0,
    };

    let uniform_data = UniformData::new(&data);

    let mouse_shader = Shader::new(
        "examples/sinewaves.wgsl",
        ShaderOptions::with_uniform_data(&uniform_data),
        &mut engine,
        LoadingOp::Blocking,
    );

    let regular_material = MaterialBuilder::new()
        .set_shader(mouse_shader)
        .build(&mut engine);

    let pos = Position {
        regular_material,
        time: data,
    };

    engine.run(pos);
}

examples/shader.rs (line 28)

fn main() {
    let mut engine = EngineBuilder::new().build().unwrap();

    let data = MousePos {
        x: 0.0,
        y: 0.0,
        _junk: 0.0,
        _padding2: 0.0,
    };

    let mouse_uniform_data = UniformData::new(&data);
    let mouse_shader = Shader::new(
        "examples/mouse.wgsl",
        ShaderOptions::with_uniform_data(&mouse_uniform_data),
        &mut engine,
        LoadingOp::Blocking,
    );

    // On wasm we need this to be 16 bytes aligned so we have added this instead of
    // a 0.0_f32
    let circle_uniform_data = UniformData::new(&data);
    let circle_shader = Shader::new(
        "examples/movement.wgsl",
        ShaderOptions::with_uniform_data(&circle_uniform_data),
        &mut engine,
        LoadingOp::Blocking,
    );

    let mouse_material = MaterialBuilder::new()
        .set_shader(mouse_shader)
        .build(&mut engine);

    let circle_material = MaterialBuilder::new()
        .set_shader(circle_shader)
        .build(&mut engine);

    let defualt_material = MaterialBuilder::new().build(&mut engine);

    let game = ShaderExample {
        data,
        mouse_material,
        circle_material,
        defualt_material,
        theta: data,
    };

    engine.run(game);
}

pub fn with_uniform_texture(texture: &UniformTexture) -> Self

This will create a shader with a layout of:

@group(2) @binding(0)
var light_map: texture_2d<f32>;
@group(2) @binding(1)
var light_map_sampler: sampler;

pub fn with_all(data: &UniformData<T>, texture: &UniformTexture) -> Self

This will create a shader with a layout of:

@group(2) binding(0)
var<uniform> value: SomeStruct;
@group(2) @binding(1)
var light_map: texture_2d<f32>;
@group(2) @binding(2)
var light_map_sampler: sampler;

Examples found in repository

examples/lightmap.rs (line 34)

fn main() {
    let mut engine = EngineBuilder::new()
        .set_window_title("Lightmap")
        .with_resolution((800, 800))
        .build()
        .unwrap();

    let uniform_texture = UniformTexture::new(&engine, engine.get_window_size());

    let light = Light {
        colour: Colour::ORANGE,
        pos_x: 0.0,
        pos_y: 0.0,
        brightness: 0.75,
        aspect_ratio: 1.0,
    };

    let light_data = UniformData::new(&light);

    let shader_options = ShaderOptions::with_all(&light_data, &uniform_texture);
    let light_shader = Shader::new(
        "examples/light.wgsl",
        shader_options,
        &mut engine,
        LoadingOp::Blocking,
    );

    let material = MaterialBuilder::new()
        .set_shader(light_shader)
        .build(&mut engine);

    let ocluder_material = MaterialBuilder::new().build(&mut engine);

    let rectangles = vec![
        Rectangle::new(Vec2 { x: 120.0, y: 20.0 }, Vec2 { x: 50.0, y: 50.0 }),
        Rectangle::new(Vec2 { x: 270.0, y: 70.0 }, Vec2 { x: 50.0, y: 50.0 }),
        Rectangle::new(Vec2 { x: 130.0, y: 280.0 }, Vec2 { x: 50.0, y: 50.0 }),
        Rectangle::new(Vec2 { x: 220.0, y: 300.0 }, Vec2 { x: 50.0, y: 50.0 }),
        Rectangle::new(Vec2 { x: 350.0, y: 350.0 }, Vec2 { x: 100.0, y: 100.0 }),
    ];

    let s = TextureExample {
        material,
        ocluder_material,
        light,
        uniform_texture,
        rectangles,
        mouse_pos: ZEROS,
    };

    engine.run(s);
}

Trait Implementations

impl<T: Debug> Debug for ShaderOptions<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.