Struct RenderHandle 

pub struct RenderHandle<'a> { /* private fields */ }

The renderer is used to create render passes or Renderers

Implementations

impl<'a> RenderHandle<'a>

pub fn begin_pass<'p>(&mut self, clear_colour: Colour) -> Renderer<'_, 'p>

Creates a render pass that will render onto the windows surface.

Examples found in repository

examples/input.rs (line 29)

    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
        let mut render_handle = render.begin_pass(Colour::BLACK);
        self.text_mat
            .add_instance(vec2! { 0.0 }, Colour::WHITE, &render_handle);

        self.text_mat.draw(&mut render_handle);
    }

examples/texture.rs (line 43)

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

        self.current.add_rectangle(
            vec2! { 0.0 },
            vec2! { 400.0 },
            Colour::WHITE,
            &render_handle,
        );
        self.current.draw(&mut render_handle);
    }

examples/ngon.rs (line 66)

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

        self.regular_material.add_regular_n_gon(
            120,
            200.0,
            vec2! { 250.0 },
            Colour::BLUE,
            &render_handle,
        );

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

examples/text.rs (line 34)

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

        self.text_mat
            .add_instance(vec2! { 0.0 }, Colour::WHITE, &render_handle);
        self.text_mat.add_instance_with_rotation(
            Vec2 { x: 100.0, y: 0.0 },
            Colour::WHITE,
            45.0,
            &render_handle,
        );

        self.text_mat.draw(&mut render_handle);
    }

examples/lightmap.rs (line 83)

    fn render<'o>(&'o mut self, mut render_handle: RenderHandle<'o>) {
        self.create_shadow_map(&mut render_handle);

        let mut p2 = render_handle.begin_pass(Colour::BLACK);
        let size = p2.get_size();
        let size = Vec2 {
            x: size.x as f32,
            y: size.y as f32,
        };

        self.material
            .add_rectangle(Vec2 { x: 0.0, y: 0.0 }, size, Colour::WHITE, &p2);
        self.material.draw(&mut p2);
    }

examples/line.rs (line 27)

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

        self.material.add_line(
            vec2! { 0.0, 0.0 },
            vec2! { 100.0, 100.0 },
            Colour::WHITE,
            &render_handle,
        );

        self.material.add_screenspace_line(
            vec2!(-1.0, 1.0),
            vec2!(1.0, -1.0),
            Colour::RED,
            &render_handle,
        );

        self.material.draw(&mut render_handle);
    }

Additional examples can be found in:

• examples/camera.rs
• examples/debug_triangle.rs
• examples/shader.rs
• examples/rectangles.rs

pub fn begin_texture_pass<'o, 'p>( &'o mut self, texture: &'o mut UniformTexture, clear_colour: Colour, ) -> Renderer<'o, 'p>

Creates a render pass that can be used to render to a texture. This is usefull for lightmaps, or generating heightmaps. Any advanced graphics techique that requires uniform textures.

Examples found in repository

examples/lightmap.rs (line 140)

    fn create_shadow_map<'o>(&mut self, render_handle: &mut RenderHandle<'o>) {
        let mut p1 = render_handle.begin_texture_pass(&mut self.uniform_texture, Colour::WHITE);

        let light_pos = self.mouse_pos;

        for rect in self.rectangles.iter() {
            for (segment_1, segment_2) in rect.create_segments() {
                let vert_1 = segment_1;
                let vert_2 = segment_1
                    + Vec2 {
                        x: 300.0 * (segment_1.x - light_pos.x),
                        y: 300.0 * (segment_1.y - light_pos.y),
                    };
                let vert_3 = segment_2;
                let vert_4 = segment_2
                    + Vec2 {
                        x: 300.0 * (segment_2.x - light_pos.x),
                        y: 300.0 * (segment_2.y - light_pos.y),
                    };

                let mut arr = [vert_1, vert_2, vert_3, vert_4];

                let center_point = Vec2 {
                    x: (vert_1.x + vert_2.x + vert_3.x + vert_4.x) / 4.0,
                    y: (vert_1.y + vert_2.y + vert_3.y + vert_4.y) / 4.0,
                };

                for point in arr.iter_mut() {
                    *point = *point - center_point;
                }
                arr.sort_by(|left, right| compare_points(left, right));
                for point in arr.iter_mut() {
                    *point = *point + center_point;
                }

                self.ocluder_material
                    .add_custom(arr, [ZEROS; 4], 0.0, Colour::BLACK, &p1);
            }
        }

        // makes sure there is not light in the squares
        self.rectangles.iter().for_each(|rect| {
            self.ocluder_material
                .add_rectangle(rect.pos, rect.size, Colour::BLACK, &mut p1)
        });

        self.ocluder_material.draw(&mut p1);
    }

Trait Implementations

impl Drop for RenderHandle<'_>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> From<&'a mut Engine> for RenderHandle<'a>

fn from(value: &'a mut Engine) -> Self

Converts to this type from the input type.