Struct Texture 

pub struct Texture { /* private fields */ }

Contains all the information need to render an image/texture to the screen. In order to be used it must be put inside a Material

Implementations

impl Texture

pub fn new<P>( engine: &mut Engine, path: P, loading_op: LoadingOp, ) -> ResourceId<Texture>

where P: AsRef<Path>,

Attempts to both read a file at the specified path and turn it into an image.

Examples found in repository

examples/rectangles.rs (line 15)

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

    let texture = Texture::new(&mut engine, "examples/bplogo.png", LoadingOp::Blocking);

    let texture_material = MaterialBuilder::new()
        .add_texture(texture)
        .build(&mut engine);
    let regular_material = MaterialBuilder::new().build(&mut engine);

    let pos = Position {
        pos: vec2! { 0.0 },
        regular_material,
        texture_material,
        state: false,
    };

    engine.run(pos);
}

struct Position {
    pos: Vec2<f32>,
    regular_material: Material,
    texture_material: Material,
    state: bool,
}

impl Game for Position {
    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
        let mut render_handle = render.begin_pass(Colour::BLACK);

        let defualt_size = vec2! { 50.0 };
        self.regular_material.add_rectangle(
            vec2! { 0.0 },
            defualt_size,
            Colour::RED,
            &render_handle,
        );
        self.regular_material
            .add_rectangle(self.pos, vec2! { 100.0 }, Colour::RED, &render_handle);
        self.texture_material.add_rectangle(
            vec2! { 0.0, 50.0 },
            defualt_size,
            Colour::WHITE,
            &render_handle,
        );
        self.texture_material.add_rectangle_with_uv(
            Vec2 { x: 0.0, y: 100.0 },
            defualt_size,
            vec2! { 311.0 },
            vec2! { 311.0 },
            Colour::WHITE,
            &render_handle,
        );
        self.regular_material.add_rectangle_with_rotation(
            Vec2 { x: 0.0, y: 150.0 },
            defualt_size,
            Colour::GREEN,
            45.0,
            &render_handle,
        );

        let points = [
            Vec2 { x: 0.0, y: 300.0 },
            Vec2 { x: 80.0, y: 290.0 },
            Vec2 { x: 100.0, y: 400.0 },
            Vec2 { x: 60.0, y: 400.0 },
        ];
        let uvs = [
            vec2! { 0.0 },
            Vec2 { x: 1.0, y: 0.0 },
            vec2! { 1.0 },
            Vec2 { x: 0.0, y: 1.0 },
        ];

        self.regular_material
            .add_custom(points, uvs, 0.0, Colour::RED, &render_handle);

        self.regular_material.add_screenspace_rectangle(
            vec2!(0.0, 0.0),
            vec2!(1.0),
            Colour::YELLOW,
            &render_handle,
        );

        if self.state {
            self.regular_material.add_rectangle(
                vec2!(300.0),
                vec2!(100.0),
                Colour::GREEN,
                &render_handle,
            );
        }

        self.texture_material.draw(&mut render_handle);
        self.regular_material.draw(&mut render_handle);
    }

    fn update(&mut self, engine_handle: &mut Engine) {
        let dt = engine_handle.get_frame_delta_time();
        self.pos.x += 100.0 * dt;
        if engine_handle.is_mouse_key_pressed(MouseKey::Left) {
            let new_texture = Texture::new(
                engine_handle,
                "examples/eggshark.png",
                LoadingOp::Background,
            );
            self.texture_material.change_texture(new_texture);
        }

        self.state = engine_handle.is_key_down(Key::Space);
    }

examples/camera.rs (line 16)

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

    let texture = Texture::new(&mut engine, "examples/bplogo.png", LoadingOp::Blocking);

    let material = MaterialBuilder::new()
        .add_texture(texture)
        .build(&mut engine);

    let camera = Camera::default();

    let text = TextMaterial::new(
        "Mouse pos: 0,0 \n Mouse pos: 0, 0",
        Colour::WHITE,
        15.0,
        20.0,
    );

    let game = CameraExample {
        material,
        text,
        camera,
    };

    engine.run(game);
}

examples/texture.rs (line 19)

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

    let texture = Texture::new(&mut engine, "examples/bplogo.png", LoadingOp::Blocking);

    let texture = MaterialBuilder::new()
        .add_texture(texture)
        .build(&mut engine);
    let defualt = MaterialBuilder::new().build(&mut engine);

    let s = TextureExample {
        current: texture,
        other: defualt,
        pos: vec2! { 0.0 },
    };

    engine.run(s);
}

pub fn new_with_sampler<P>( engine: &mut Engine, path: P, sampler: SamplerType, loading_op: LoadingOp, ) -> ResourceId<Texture>

where P: AsRef<Path>,

Attempts to both read a file at the specified path and turn it into an image.

pub fn new_with_mag_min_sampler<P>( engine: &mut Engine, path: P, mag_sampler: SamplerType, min_sampler: SamplerType, loading_op: LoadingOp, ) -> ResourceId<Texture>

where P: AsRef<Path>,

Attempts to load the file at the path and then turn it into a texture. This also 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.