Struct UniformTexture 

pub struct UniformTexture { /* private fields */ }

A UniformTexture is a special type of texture that you can renderer to and also render itself to the screen. Uniform Textures is usefull for things like lightmaps or graphics techniques that reuqire multiple rendering passes.

Implementations

impl UniformTexture

pub fn new(engine: &Engine, size: Vec2<u32>) -> Self

creates a UniformTexture of a specified size this can be reszied at anytime with Material::resize_uniform_texture

Examples found in repository

examples/lightmap.rs (line 22)

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

pub fn new_with_sampler( engine: &Engine, size: Vec2<u32>, mag_sampler: SamplerType, min_sampler: SamplerType, ) -> Self

This creates a UniformTexture with samplers which allows you to select what sampling type to use for both the mag_sampler, when the texture is being drawn larger than the orignal resolution and min_sampler, when the texture is being drawn smaller than the original resolution.

pub fn get_size(&self) -> Vec2<u32>

Gets the current size of the texture