Struct Shader 

pub struct Shader { /* private fields */ }

An internal representation of an WGSL Shader. Under the hood this creates a new pipeline with or without the support for any extra uniforms. To be utilze the shader it must be added to a material

Implementations

impl Shader

pub fn new<P: AsRef<Path>, T>( path: P, options: ShaderOptions<T>, engine: &mut Engine, loading_op: LoadingOp, ) -> ResourceId<Shader>

Attempts to create a shader from a file. Requires ShaderOptions which implents Defualt for quick and easy creation.

Examples found in repository

examples/ngon.rs (lines 32-37)

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 (lines 26-31)

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);
}

examples/lightmap.rs (lines 35-40)

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 Debug for Shader

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

Formats the value using the given formatter.