Struct Material

Source

pub struct Material<T = ()> { /* private fields */ }

Expand description

A material represents a unique combination of a Texture and Shader, while also containing all nessicary buffers. If you don’t have any uniform data attached to the shader utilized by the material use the unit () type.

Implementations§

Source §

impl<T> Material<T>

Source

pub fn change_texture(&mut self, texture: ResourceId<Texture>)

Swaps out the inner texture of the material

Examples found in repository ?

examples/rectangles.rs (line 119)

110    fn update(&mut self, engine_handle: &mut Engine) {
111        let dt = engine_handle.get_frame_delta_time();
112        self.pos.x += 100.0 * dt;
113        if engine_handle.is_mouse_key_pressed(MouseKey::Left) {
114            let new_texture = Texture::new(
115                engine_handle,
116                "examples/eggshark.png",
117                LoadingOp::Background,
118            );
119            self.texture_material.change_texture(new_texture);
120        }
121
122        self.state = engine_handle.is_key_down(Key::Space);
123    }

Source

pub fn add_rectangle( &mut self, position: Vec2<f32>, size: Vec2<f32>, colour: Colour, render: &Renderer<'_, '_>, )

Will queue a Rectangle to be draw.

Examples found in repository ?

examples/texture.rs (lines 45-50)

42    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
43        let mut render_handle = render.begin_pass(Colour::BLACK);
44
45        self.current.add_rectangle(
46            vec2! { 0.0 },
47            vec2! { 400.0 },
48            Colour::WHITE,
49            &render_handle,
50        );
51        self.current.draw(&mut render_handle);
52    }

More examples

Hide additional examples

examples/lightmap.rs (line 91)

80    fn render<'o>(&'o mut self, mut render_handle: RenderHandle<'o>) {
81        self.create_shadow_map(&mut render_handle);
82
83        let mut p2 = render_handle.begin_pass(Colour::BLACK);
84        let size = p2.get_size();
85        let size = Vec2 {
86            x: size.x as f32,
87            y: size.y as f32,
88        };
89
90        self.material
91            .add_rectangle(Vec2 { x: 0.0, y: 0.0 }, size, Colour::WHITE, &p2);
92        self.material.draw(&mut p2);
93    }
94
95    fn update(&mut self, engine_handle: &mut Engine) {
96        let mouse_pos = engine_handle.get_mouse_position();
97        self.mouse_pos = mouse_pos;
98        let window_size = engine_handle.get_window_size();
99
100        self.light.pos_x = mouse_pos.x / window_size.x as f32;
101        self.light.pos_y = mouse_pos.y / window_size.y as f32;
102        self.material
103            .update_uniform_data(&self.light, &engine_handle)
104            .unwrap();
105
106        self.material
107            .update_uniform_texture(&mut self.uniform_texture, engine_handle)
108            .unwrap_or_else(|_| {});
109    }
110
111    fn on_resize(&mut self, new_size: Vec2<u32>, engine_handle: &mut Engine) {
112        self.light.aspect_ratio = new_size.x as f32 / new_size.y as f32;
113        match self
114            .material
115            .update_uniform_data(&self.light, &engine_handle)
116        {
117            Ok(_) => {}
118            Err(e) => match e {
119                UniformError::NotLoadedYet => {}
120                _ => panic!("{}", e),
121            },
122        }
123
124        match self.material.resize_uniform_texture(
125            &mut self.uniform_texture,
126            new_size,
127            engine_handle,
128        ) {
129            Ok(_) => {}
130            Err(e) => match e {
131                UniformError::NotLoadedYet => {}
132                _ => panic!("{}", e),
133            },
134        }
135    }
136}
137
138impl TextureExample {
139    fn create_shadow_map<'o>(&mut self, render_handle: &mut RenderHandle<'o>) {
140        let mut p1 = render_handle.begin_texture_pass(&mut self.uniform_texture, Colour::WHITE);
141
142        let light_pos = self.mouse_pos;
143
144        for rect in self.rectangles.iter() {
145            for (segment_1, segment_2) in rect.create_segments() {
146                let vert_1 = segment_1;
147                let vert_2 = segment_1
148                    + Vec2 {
149                        x: 300.0 * (segment_1.x - light_pos.x),
150                        y: 300.0 * (segment_1.y - light_pos.y),
151                    };
152                let vert_3 = segment_2;
153                let vert_4 = segment_2
154                    + Vec2 {
155                        x: 300.0 * (segment_2.x - light_pos.x),
156                        y: 300.0 * (segment_2.y - light_pos.y),
157                    };
158
159                let mut arr = [vert_1, vert_2, vert_3, vert_4];
160
161                let center_point = Vec2 {
162                    x: (vert_1.x + vert_2.x + vert_3.x + vert_4.x) / 4.0,
163                    y: (vert_1.y + vert_2.y + vert_3.y + vert_4.y) / 4.0,
164                };
165
166                for point in arr.iter_mut() {
167                    *point = *point - center_point;
168                }
169                arr.sort_by(|left, right| compare_points(left, right));
170                for point in arr.iter_mut() {
171                    *point = *point + center_point;
172                }
173
174                self.ocluder_material
175                    .add_custom(arr, [ZEROS; 4], 0.0, Colour::BLACK, &p1);
176            }
177        }
178
179        // makes sure there is not light in the squares
180        self.rectangles.iter().for_each(|rect| {
181            self.ocluder_material
182                .add_rectangle(rect.pos, rect.size, Colour::BLACK, &mut p1)
183        });
184
185        self.ocluder_material.draw(&mut p1);
186    }

examples/camera.rs (lines 50-55)

47    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
48        let mut render_handle = render.begin_pass(Colour::BLACK);
49
50        self.material.add_rectangle(
51            Vec2 { x: 0.0, y: 0.0 },
52            Vec2 { x: 300.0, y: 300.0 },
53            Colour::WHITE,
54            &render_handle,
55        );
56
57        self.camera.set_active(&mut render_handle);
58        self.material.draw(&mut render_handle);
59
60        render_handle.reset_camera();
61        self.text
62            .add_instance(vec2!(0.0), Colour::WHITE, &render_handle);
63        self.text.draw(&mut render_handle);
64    }

examples/debug_triangle.rs (line 42)

27    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
28        let mut render_handle = render.begin_pass(Colour::BLACK);
29
30        self.material.add_triangle_with_coloured_verticies(
31            [
32                vec2! { 200.0, 0.0 },
33                // supplying one value to the macro will
34                // make x and y the same value
35                vec2! { 400.0 },
36                vec2! { 0.0, 400.0 },
37            ],
38            [Colour::RED, Colour::GREEN, Colour::BLUE],
39            &render_handle,
40        );
41        self.material
42            .add_rectangle(vec2! { 0.0 }, vec2! { 100.0 }, Colour::RED, &render_handle);
43        self.material.draw(&mut render_handle);
44    }

examples/shader.rs (lines 84-89)

81    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
82        let mut render_handle = render.begin_pass(Colour::BLACK);
83
84        self.mouse_material.add_rectangle(
85            vec2! { 0.0 },
86            vec2! { 100.0 },
87            Colour::RED,
88            &render_handle,
89        );
90        self.circle_material.add_rectangle(
91            vec2! { 100.0 },
92            vec2! { 100.0 },
93            Colour::RED,
94            &render_handle,
95        );
96        self.defualt_material.add_rectangle(
97            Vec2 { x: 0.0, y: 200.0 },
98            vec2! { 100.0 },
99            Colour::RED,
100            &render_handle,
101        );
102
103        self.mouse_material.draw(&mut render_handle);
104        self.circle_material.draw(&mut render_handle);
105        self.defualt_material.draw(&mut render_handle);
106    }

examples/rectangles.rs (lines 44-49)

40    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
41        let mut render_handle = render.begin_pass(Colour::BLACK);
42
43        let defualt_size = vec2! { 50.0 };
44        self.regular_material.add_rectangle(
45            vec2! { 0.0 },
46            defualt_size,
47            Colour::RED,
48            &render_handle,
49        );
50        self.regular_material
51            .add_rectangle(self.pos, vec2! { 100.0 }, Colour::RED, &render_handle);
52        self.texture_material.add_rectangle(
53            vec2! { 0.0, 50.0 },
54            defualt_size,
55            Colour::WHITE,
56            &render_handle,
57        );
58        self.texture_material.add_rectangle_with_uv(
59            Vec2 { x: 0.0, y: 100.0 },
60            defualt_size,
61            vec2! { 311.0 },
62            vec2! { 311.0 },
63            Colour::WHITE,
64            &render_handle,
65        );
66        self.regular_material.add_rectangle_with_rotation(
67            Vec2 { x: 0.0, y: 150.0 },
68            defualt_size,
69            Colour::GREEN,
70            45.0,
71            &render_handle,
72        );
73
74        let points = [
75            Vec2 { x: 0.0, y: 300.0 },
76            Vec2 { x: 80.0, y: 290.0 },
77            Vec2 { x: 100.0, y: 400.0 },
78            Vec2 { x: 60.0, y: 400.0 },
79        ];
80        let uvs = [
81            vec2! { 0.0 },
82            Vec2 { x: 1.0, y: 0.0 },
83            vec2! { 1.0 },
84            Vec2 { x: 0.0, y: 1.0 },
85        ];
86
87        self.regular_material
88            .add_custom(points, uvs, 0.0, Colour::RED, &render_handle);
89
90        self.regular_material.add_screenspace_rectangle(
91            vec2!(0.0, 0.0),
92            vec2!(1.0),
93            Colour::YELLOW,
94            &render_handle,
95        );
96
97        if self.state {
98            self.regular_material.add_rectangle(
99                vec2!(300.0),
100                vec2!(100.0),
101                Colour::GREEN,
102                &render_handle,
103            );
104        }
105
106        self.texture_material.draw(&mut render_handle);
107        self.regular_material.draw(&mut render_handle);
108    }

Source

pub fn add_screenspace_rectangle( &mut self, position: Vec2<f32>, size: Vec2<f32>, colour: Colour, render: &Renderer<'_, '_>, )

Queues a rectangle using WGSL cordinate space. (0, 0) is the center of the screen and (-1, 1) is the top left corner

Examples found in repository ?

examples/rectangles.rs (lines 90-95)

40    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
41        let mut render_handle = render.begin_pass(Colour::BLACK);
42
43        let defualt_size = vec2! { 50.0 };
44        self.regular_material.add_rectangle(
45            vec2! { 0.0 },
46            defualt_size,
47            Colour::RED,
48            &render_handle,
49        );
50        self.regular_material
51            .add_rectangle(self.pos, vec2! { 100.0 }, Colour::RED, &render_handle);
52        self.texture_material.add_rectangle(
53            vec2! { 0.0, 50.0 },
54            defualt_size,
55            Colour::WHITE,
56            &render_handle,
57        );
58        self.texture_material.add_rectangle_with_uv(
59            Vec2 { x: 0.0, y: 100.0 },
60            defualt_size,
61            vec2! { 311.0 },
62            vec2! { 311.0 },
63            Colour::WHITE,
64            &render_handle,
65        );
66        self.regular_material.add_rectangle_with_rotation(
67            Vec2 { x: 0.0, y: 150.0 },
68            defualt_size,
69            Colour::GREEN,
70            45.0,
71            &render_handle,
72        );
73
74        let points = [
75            Vec2 { x: 0.0, y: 300.0 },
76            Vec2 { x: 80.0, y: 290.0 },
77            Vec2 { x: 100.0, y: 400.0 },
78            Vec2 { x: 60.0, y: 400.0 },
79        ];
80        let uvs = [
81            vec2! { 0.0 },
82            Vec2 { x: 1.0, y: 0.0 },
83            vec2! { 1.0 },
84            Vec2 { x: 0.0, y: 1.0 },
85        ];
86
87        self.regular_material
88            .add_custom(points, uvs, 0.0, Colour::RED, &render_handle);
89
90        self.regular_material.add_screenspace_rectangle(
91            vec2!(0.0, 0.0),
92            vec2!(1.0),
93            Colour::YELLOW,
94            &render_handle,
95        );
96
97        if self.state {
98            self.regular_material.add_rectangle(
99                vec2!(300.0),
100                vec2!(100.0),
101                Colour::GREEN,
102                &render_handle,
103            );
104        }
105
106        self.texture_material.draw(&mut render_handle);
107        self.regular_material.draw(&mut render_handle);
108    }

Source

pub fn add_rectangle_with_uv( &mut self, position: Vec2<f32>, size: Vec2<f32>, uv_position: Vec2<f32>, uv_size: Vec2<f32>, colour: Colour, render: &Renderer<'_, '_>, )

Queues a rectagnle with UV coordniates. The position and size of the UV cordniates are the same as the pixels in the actaul image.

Examples found in repository ?

examples/rectangles.rs (lines 58-65)

40    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
41        let mut render_handle = render.begin_pass(Colour::BLACK);
42
43        let defualt_size = vec2! { 50.0 };
44        self.regular_material.add_rectangle(
45            vec2! { 0.0 },
46            defualt_size,
47            Colour::RED,
48            &render_handle,
49        );
50        self.regular_material
51            .add_rectangle(self.pos, vec2! { 100.0 }, Colour::RED, &render_handle);
52        self.texture_material.add_rectangle(
53            vec2! { 0.0, 50.0 },
54            defualt_size,
55            Colour::WHITE,
56            &render_handle,
57        );
58        self.texture_material.add_rectangle_with_uv(
59            Vec2 { x: 0.0, y: 100.0 },
60            defualt_size,
61            vec2! { 311.0 },
62            vec2! { 311.0 },
63            Colour::WHITE,
64            &render_handle,
65        );
66        self.regular_material.add_rectangle_with_rotation(
67            Vec2 { x: 0.0, y: 150.0 },
68            defualt_size,
69            Colour::GREEN,
70            45.0,
71            &render_handle,
72        );
73
74        let points = [
75            Vec2 { x: 0.0, y: 300.0 },
76            Vec2 { x: 80.0, y: 290.0 },
77            Vec2 { x: 100.0, y: 400.0 },
78            Vec2 { x: 60.0, y: 400.0 },
79        ];
80        let uvs = [
81            vec2! { 0.0 },
82            Vec2 { x: 1.0, y: 0.0 },
83            vec2! { 1.0 },
84            Vec2 { x: 0.0, y: 1.0 },
85        ];
86
87        self.regular_material
88            .add_custom(points, uvs, 0.0, Colour::RED, &render_handle);
89
90        self.regular_material.add_screenspace_rectangle(
91            vec2!(0.0, 0.0),
92            vec2!(1.0),
93            Colour::YELLOW,
94            &render_handle,
95        );
96
97        if self.state {
98            self.regular_material.add_rectangle(
99                vec2!(300.0),
100                vec2!(100.0),
101                Colour::GREEN,
102                &render_handle,
103            );
104        }
105
106        self.texture_material.draw(&mut render_handle);
107        self.regular_material.draw(&mut render_handle);
108    }

Source

pub fn add_rectangle_with_rotation( &mut self, position: Vec2<f32>, size: Vec2<f32>, colour: Colour, rotation: f32, render: &Renderer<'_, '_>, )

Queues a rectangle that will be rotated around its centerpoint. Rotation is in degrees

Examples found in repository ?

examples/rectangles.rs (lines 66-72)

40    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
41        let mut render_handle = render.begin_pass(Colour::BLACK);
42
43        let defualt_size = vec2! { 50.0 };
44        self.regular_material.add_rectangle(
45            vec2! { 0.0 },
46            defualt_size,
47            Colour::RED,
48            &render_handle,
49        );
50        self.regular_material
51            .add_rectangle(self.pos, vec2! { 100.0 }, Colour::RED, &render_handle);
52        self.texture_material.add_rectangle(
53            vec2! { 0.0, 50.0 },
54            defualt_size,
55            Colour::WHITE,
56            &render_handle,
57        );
58        self.texture_material.add_rectangle_with_uv(
59            Vec2 { x: 0.0, y: 100.0 },
60            defualt_size,
61            vec2! { 311.0 },
62            vec2! { 311.0 },
63            Colour::WHITE,
64            &render_handle,
65        );
66        self.regular_material.add_rectangle_with_rotation(
67            Vec2 { x: 0.0, y: 150.0 },
68            defualt_size,
69            Colour::GREEN,
70            45.0,
71            &render_handle,
72        );
73
74        let points = [
75            Vec2 { x: 0.0, y: 300.0 },
76            Vec2 { x: 80.0, y: 290.0 },
77            Vec2 { x: 100.0, y: 400.0 },
78            Vec2 { x: 60.0, y: 400.0 },
79        ];
80        let uvs = [
81            vec2! { 0.0 },
82            Vec2 { x: 1.0, y: 0.0 },
83            vec2! { 1.0 },
84            Vec2 { x: 0.0, y: 1.0 },
85        ];
86
87        self.regular_material
88            .add_custom(points, uvs, 0.0, Colour::RED, &render_handle);
89
90        self.regular_material.add_screenspace_rectangle(
91            vec2!(0.0, 0.0),
92            vec2!(1.0),
93            Colour::YELLOW,
94            &render_handle,
95        );
96
97        if self.state {
98            self.regular_material.add_rectangle(
99                vec2!(300.0),
100                vec2!(100.0),
101                Colour::GREEN,
102                &render_handle,
103            );
104        }
105
106        self.texture_material.draw(&mut render_handle);
107        self.regular_material.draw(&mut render_handle);
108    }

Source

pub fn add_rectangle_ex( &mut self, position: Vec2<f32>, size: Vec2<f32>, colour: Colour, rotation: f32, uv_position: Vec2<f32>, uv_size: Vec2<f32>, render: &Renderer<'_, '_>, )

Queues a rectangle with both UV, and Rotation,

Source

pub fn add_screenspace_rectangle_ex( &mut self, position: Vec2<f32>, size: Vec2<f32>, colour: Colour, rotation: f32, uv_position: Vec2<f32>, uv_size: Vec2<f32>, render: &Renderer<'_, '_>, )

Queues a rectangle with both UV, and Rotation, but will draw the rectangle in WGSL screenspace

Source

pub fn add_custom( &mut self, points: [Vec2<f32>; 4], uv_points: [Vec2<f32>; 4], rotation: f32, colour: Colour, render: &Renderer<'_, '_>, )

Queues a 4 pointed polygon with complete control over uv coordinates and rotation. The points need to be in top left, right bottom right and bottom left order as it will not render porperly otherwise.

Examples found in repository ?

examples/lightmap.rs (line 175)

139    fn create_shadow_map<'o>(&mut self, render_handle: &mut RenderHandle<'o>) {
140        let mut p1 = render_handle.begin_texture_pass(&mut self.uniform_texture, Colour::WHITE);
141
142        let light_pos = self.mouse_pos;
143
144        for rect in self.rectangles.iter() {
145            for (segment_1, segment_2) in rect.create_segments() {
146                let vert_1 = segment_1;
147                let vert_2 = segment_1
148                    + Vec2 {
149                        x: 300.0 * (segment_1.x - light_pos.x),
150                        y: 300.0 * (segment_1.y - light_pos.y),
151                    };
152                let vert_3 = segment_2;
153                let vert_4 = segment_2
154                    + Vec2 {
155                        x: 300.0 * (segment_2.x - light_pos.x),
156                        y: 300.0 * (segment_2.y - light_pos.y),
157                    };
158
159                let mut arr = [vert_1, vert_2, vert_3, vert_4];
160
161                let center_point = Vec2 {
162                    x: (vert_1.x + vert_2.x + vert_3.x + vert_4.x) / 4.0,
163                    y: (vert_1.y + vert_2.y + vert_3.y + vert_4.y) / 4.0,
164                };
165
166                for point in arr.iter_mut() {
167                    *point = *point - center_point;
168                }
169                arr.sort_by(|left, right| compare_points(left, right));
170                for point in arr.iter_mut() {
171                    *point = *point + center_point;
172                }
173
174                self.ocluder_material
175                    .add_custom(arr, [ZEROS; 4], 0.0, Colour::BLACK, &p1);
176            }
177        }
178
179        // makes sure there is not light in the squares
180        self.rectangles.iter().for_each(|rect| {
181            self.ocluder_material
182                .add_rectangle(rect.pos, rect.size, Colour::BLACK, &mut p1)
183        });
184
185        self.ocluder_material.draw(&mut p1);
186    }

More examples

Hide additional examples

examples/rectangles.rs (line 88)

40    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
41        let mut render_handle = render.begin_pass(Colour::BLACK);
42
43        let defualt_size = vec2! { 50.0 };
44        self.regular_material.add_rectangle(
45            vec2! { 0.0 },
46            defualt_size,
47            Colour::RED,
48            &render_handle,
49        );
50        self.regular_material
51            .add_rectangle(self.pos, vec2! { 100.0 }, Colour::RED, &render_handle);
52        self.texture_material.add_rectangle(
53            vec2! { 0.0, 50.0 },
54            defualt_size,
55            Colour::WHITE,
56            &render_handle,
57        );
58        self.texture_material.add_rectangle_with_uv(
59            Vec2 { x: 0.0, y: 100.0 },
60            defualt_size,
61            vec2! { 311.0 },
62            vec2! { 311.0 },
63            Colour::WHITE,
64            &render_handle,
65        );
66        self.regular_material.add_rectangle_with_rotation(
67            Vec2 { x: 0.0, y: 150.0 },
68            defualt_size,
69            Colour::GREEN,
70            45.0,
71            &render_handle,
72        );
73
74        let points = [
75            Vec2 { x: 0.0, y: 300.0 },
76            Vec2 { x: 80.0, y: 290.0 },
77            Vec2 { x: 100.0, y: 400.0 },
78            Vec2 { x: 60.0, y: 400.0 },
79        ];
80        let uvs = [
81            vec2! { 0.0 },
82            Vec2 { x: 1.0, y: 0.0 },
83            vec2! { 1.0 },
84            Vec2 { x: 0.0, y: 1.0 },
85        ];
86
87        self.regular_material
88            .add_custom(points, uvs, 0.0, Colour::RED, &render_handle);
89
90        self.regular_material.add_screenspace_rectangle(
91            vec2!(0.0, 0.0),
92            vec2!(1.0),
93            Colour::YELLOW,
94            &render_handle,
95        );
96
97        if self.state {
98            self.regular_material.add_rectangle(
99                vec2!(300.0),
100                vec2!(100.0),
101                Colour::GREEN,
102                &render_handle,
103            );
104        }
105
106        self.texture_material.draw(&mut render_handle);
107        self.regular_material.draw(&mut render_handle);
108    }

Source

pub fn add_triangle( &mut self, p1: Vec2<f32>, p2: Vec2<f32>, p3: Vec2<f32>, colour: Colour, render: &Renderer<'_, '_>, )

Queues a traingle, the points must be provided in clockwise order

Source

pub fn add_triangle_with_coloured_verticies( &mut self, points: [Vec2<f32>; 3], colours: [Colour; 3], render: &Renderer<'_, '_>, )

Queues a triangle where each vertex is given its own colour. Points must be given in clockwise order

Examples found in repository ?

examples/debug_triangle.rs (lines 30-40)

27    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
28        let mut render_handle = render.begin_pass(Colour::BLACK);
29
30        self.material.add_triangle_with_coloured_verticies(
31            [
32                vec2! { 200.0, 0.0 },
33                // supplying one value to the macro will
34                // make x and y the same value
35                vec2! { 400.0 },
36                vec2! { 0.0, 400.0 },
37            ],
38            [Colour::RED, Colour::GREEN, Colour::BLUE],
39            &render_handle,
40        );
41        self.material
42            .add_rectangle(vec2! { 0.0 }, vec2! { 100.0 }, Colour::RED, &render_handle);
43        self.material.draw(&mut render_handle);
44    }

Source

pub fn add_regular_n_gon( &mut self, number_of_sides: usize, radius: f32, center: Vec2<f32>, colour: Colour, render: &Renderer<'_, '_>, )

Queues a polygon with the specified number of sides at a position with size and colour. This will not play nicely with texture as all the UV coords will be at [0, 0].

Examples found in repository ?

examples/ngon.rs (lines 68-74)

65    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
66        let mut render_handle = render.begin_pass(Colour::BLACK);
67
68        self.regular_material.add_regular_n_gon(
69            120,
70            200.0,
71            vec2! { 250.0 },
72            Colour::BLUE,
73            &render_handle,
74        );
75
76        self.regular_material.draw(&mut render_handle);
77    }

Source

pub fn resize_uniform_texture( &mut self, texture: &mut UniformTexture, size: Vec2<u32>, engine: &mut Engine, ) -> Result<(), UniformError>

This will attempt to resize the texture stored within the shader. This will fail in the event that the shader has not loaded yet or if the shader used to create the material never had an UniformTexture.

Examples found in repository ?

examples/lightmap.rs (lines 124-128)

111    fn on_resize(&mut self, new_size: Vec2<u32>, engine_handle: &mut Engine) {
112        self.light.aspect_ratio = new_size.x as f32 / new_size.y as f32;
113        match self
114            .material
115            .update_uniform_data(&self.light, &engine_handle)
116        {
117            Ok(_) => {}
118            Err(e) => match e {
119                UniformError::NotLoadedYet => {}
120                _ => panic!("{}", e),
121            },
122        }
123
124        match self.material.resize_uniform_texture(
125            &mut self.uniform_texture,
126            new_size,
127            engine_handle,
128        ) {
129            Ok(_) => {}
130            Err(e) => match e {
131                UniformError::NotLoadedYet => {}
132                _ => panic!("{}", e),
133            },
134        }
135    }

Source

pub fn update_uniform_texture( &mut self, texture: &mut UniformTexture, engine: &mut Engine, ) -> Result<(), UniformError>

Examples found in repository ?

examples/lightmap.rs (line 107)

95    fn update(&mut self, engine_handle: &mut Engine) {
96        let mouse_pos = engine_handle.get_mouse_position();
97        self.mouse_pos = mouse_pos;
98        let window_size = engine_handle.get_window_size();
99
100        self.light.pos_x = mouse_pos.x / window_size.x as f32;
101        self.light.pos_y = mouse_pos.y / window_size.y as f32;
102        self.material
103            .update_uniform_data(&self.light, &engine_handle)
104            .unwrap();
105
106        self.material
107            .update_uniform_texture(&mut self.uniform_texture, engine_handle)
108            .unwrap_or_else(|_| {});
109    }

Source

pub fn get_vertex_number(&self) -> u64

Returns the number of verticies in the buffer

Source

pub fn get_index_number(&self) -> u64

Returns the number if indincies in the buffer

Source

pub fn get_texture_size(&self, engine: &Engine) -> Option<Vec2<f32>>

Returns the size of the texture in pixels. Returns None when the texture is not loaded yet

Source

pub fn draw<'others>(&'others mut self, information: &mut Renderer<'_, 'others>)

Draws all queued shapes to the screen.

Examples found in repository ?

examples/texture.rs (line 51)

42    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
43        let mut render_handle = render.begin_pass(Colour::BLACK);
44
45        self.current.add_rectangle(
46            vec2! { 0.0 },
47            vec2! { 400.0 },
48            Colour::WHITE,
49            &render_handle,
50        );
51        self.current.draw(&mut render_handle);
52    }

More examples

Hide additional examples

examples/ngon.rs (line 76)

65    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
66        let mut render_handle = render.begin_pass(Colour::BLACK);
67
68        self.regular_material.add_regular_n_gon(
69            120,
70            200.0,
71            vec2! { 250.0 },
72            Colour::BLUE,
73            &render_handle,
74        );
75
76        self.regular_material.draw(&mut render_handle);
77    }

examples/lightmap.rs (line 92)

80    fn render<'o>(&'o mut self, mut render_handle: RenderHandle<'o>) {
81        self.create_shadow_map(&mut render_handle);
82
83        let mut p2 = render_handle.begin_pass(Colour::BLACK);
84        let size = p2.get_size();
85        let size = Vec2 {
86            x: size.x as f32,
87            y: size.y as f32,
88        };
89
90        self.material
91            .add_rectangle(Vec2 { x: 0.0, y: 0.0 }, size, Colour::WHITE, &p2);
92        self.material.draw(&mut p2);
93    }
94
95    fn update(&mut self, engine_handle: &mut Engine) {
96        let mouse_pos = engine_handle.get_mouse_position();
97        self.mouse_pos = mouse_pos;
98        let window_size = engine_handle.get_window_size();
99
100        self.light.pos_x = mouse_pos.x / window_size.x as f32;
101        self.light.pos_y = mouse_pos.y / window_size.y as f32;
102        self.material
103            .update_uniform_data(&self.light, &engine_handle)
104            .unwrap();
105
106        self.material
107            .update_uniform_texture(&mut self.uniform_texture, engine_handle)
108            .unwrap_or_else(|_| {});
109    }
110
111    fn on_resize(&mut self, new_size: Vec2<u32>, engine_handle: &mut Engine) {
112        self.light.aspect_ratio = new_size.x as f32 / new_size.y as f32;
113        match self
114            .material
115            .update_uniform_data(&self.light, &engine_handle)
116        {
117            Ok(_) => {}
118            Err(e) => match e {
119                UniformError::NotLoadedYet => {}
120                _ => panic!("{}", e),
121            },
122        }
123
124        match self.material.resize_uniform_texture(
125            &mut self.uniform_texture,
126            new_size,
127            engine_handle,
128        ) {
129            Ok(_) => {}
130            Err(e) => match e {
131                UniformError::NotLoadedYet => {}
132                _ => panic!("{}", e),
133            },
134        }
135    }
136}
137
138impl TextureExample {
139    fn create_shadow_map<'o>(&mut self, render_handle: &mut RenderHandle<'o>) {
140        let mut p1 = render_handle.begin_texture_pass(&mut self.uniform_texture, Colour::WHITE);
141
142        let light_pos = self.mouse_pos;
143
144        for rect in self.rectangles.iter() {
145            for (segment_1, segment_2) in rect.create_segments() {
146                let vert_1 = segment_1;
147                let vert_2 = segment_1
148                    + Vec2 {
149                        x: 300.0 * (segment_1.x - light_pos.x),
150                        y: 300.0 * (segment_1.y - light_pos.y),
151                    };
152                let vert_3 = segment_2;
153                let vert_4 = segment_2
154                    + Vec2 {
155                        x: 300.0 * (segment_2.x - light_pos.x),
156                        y: 300.0 * (segment_2.y - light_pos.y),
157                    };
158
159                let mut arr = [vert_1, vert_2, vert_3, vert_4];
160
161                let center_point = Vec2 {
162                    x: (vert_1.x + vert_2.x + vert_3.x + vert_4.x) / 4.0,
163                    y: (vert_1.y + vert_2.y + vert_3.y + vert_4.y) / 4.0,
164                };
165
166                for point in arr.iter_mut() {
167                    *point = *point - center_point;
168                }
169                arr.sort_by(|left, right| compare_points(left, right));
170                for point in arr.iter_mut() {
171                    *point = *point + center_point;
172                }
173
174                self.ocluder_material
175                    .add_custom(arr, [ZEROS; 4], 0.0, Colour::BLACK, &p1);
176            }
177        }
178
179        // makes sure there is not light in the squares
180        self.rectangles.iter().for_each(|rect| {
181            self.ocluder_material
182                .add_rectangle(rect.pos, rect.size, Colour::BLACK, &mut p1)
183        });
184
185        self.ocluder_material.draw(&mut p1);
186    }

examples/camera.rs (line 58)

47    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
48        let mut render_handle = render.begin_pass(Colour::BLACK);
49
50        self.material.add_rectangle(
51            Vec2 { x: 0.0, y: 0.0 },
52            Vec2 { x: 300.0, y: 300.0 },
53            Colour::WHITE,
54            &render_handle,
55        );
56
57        self.camera.set_active(&mut render_handle);
58        self.material.draw(&mut render_handle);
59
60        render_handle.reset_camera();
61        self.text
62            .add_instance(vec2!(0.0), Colour::WHITE, &render_handle);
63        self.text.draw(&mut render_handle);
64    }

examples/debug_triangle.rs (line 43)

27    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
28        let mut render_handle = render.begin_pass(Colour::BLACK);
29
30        self.material.add_triangle_with_coloured_verticies(
31            [
32                vec2! { 200.0, 0.0 },
33                // supplying one value to the macro will
34                // make x and y the same value
35                vec2! { 400.0 },
36                vec2! { 0.0, 400.0 },
37            ],
38            [Colour::RED, Colour::GREEN, Colour::BLUE],
39            &render_handle,
40        );
41        self.material
42            .add_rectangle(vec2! { 0.0 }, vec2! { 100.0 }, Colour::RED, &render_handle);
43        self.material.draw(&mut render_handle);
44    }

examples/shader.rs (line 103)

81    fn render<'o>(&'o mut self, mut render: RenderHandle<'o>) {
82        let mut render_handle = render.begin_pass(Colour::BLACK);
83
84        self.mouse_material.add_rectangle(
85            vec2! { 0.0 },
86            vec2! { 100.0 },
87            Colour::RED,
88            &render_handle,
89        );
90        self.circle_material.add_rectangle(
91            vec2! { 100.0 },
92            vec2! { 100.0 },
93            Colour::RED,
94            &render_handle,
95        );
96        self.defualt_material.add_rectangle(
97            Vec2 { x: 0.0, y: 200.0 },
98            vec2! { 100.0 },
99            Colour::RED,
100            &render_handle,
101        );
102
103        self.mouse_material.draw(&mut render_handle);
104        self.circle_material.draw(&mut render_handle);
105        self.defualt_material.draw(&mut render_handle);
106    }

Additional examples can be found in:

examples/rectangles.rs

Source §

impl<T: ShaderType + WriteInto> Material<T>

Source

pub fn update_uniform_data( &self, data: &T, engine: &Engine, ) -> Result<(), UniformError>

Attempts to update the uniform data held within in the shader. This will fail in the event that the shader has not loaded yet or if the shader used to create the material never had any UniformData,

Examples found in repository ?

examples/ngon.rs (line 83)

79    fn update(&mut self, engine_handle: &mut Engine) {
80        let dt = engine_handle.get_frame_delta_time();
81        self.time.time = (self.time.time + dt) % (32.0 * PI);
82        self.regular_material
83            .update_uniform_data(&self.time, &engine_handle)
84            .unwrap();
85    }

More examples

Hide additional examples

examples/lightmap.rs (line 103)

95    fn update(&mut self, engine_handle: &mut Engine) {
96        let mouse_pos = engine_handle.get_mouse_position();
97        self.mouse_pos = mouse_pos;
98        let window_size = engine_handle.get_window_size();
99
100        self.light.pos_x = mouse_pos.x / window_size.x as f32;
101        self.light.pos_y = mouse_pos.y / window_size.y as f32;
102        self.material
103            .update_uniform_data(&self.light, &engine_handle)
104            .unwrap();
105
106        self.material
107            .update_uniform_texture(&mut self.uniform_texture, engine_handle)
108            .unwrap_or_else(|_| {});
109    }
110
111    fn on_resize(&mut self, new_size: Vec2<u32>, engine_handle: &mut Engine) {
112        self.light.aspect_ratio = new_size.x as f32 / new_size.y as f32;
113        match self
114            .material
115            .update_uniform_data(&self.light, &engine_handle)
116        {
117            Ok(_) => {}
118            Err(e) => match e {
119                UniformError::NotLoadedYet => {}
120                _ => panic!("{}", e),
121            },
122        }
123
124        match self.material.resize_uniform_texture(
125            &mut self.uniform_texture,
126            new_size,
127            engine_handle,
128        ) {
129            Ok(_) => {}
130            Err(e) => match e {
131                UniformError::NotLoadedYet => {}
132                _ => panic!("{}", e),
133            },
134        }
135    }

examples/shader.rs (line 125)

108    fn update(&mut self, engine_handle: &mut Engine) {
109        let dt = engine_handle.get_frame_delta_time();
110
111        self.theta.x = (self.theta.x + dt) % (2.0 * PI);
112
113        let size = engine_handle.get_window_size();
114        let mouse_pos = engine_handle.get_mouse_position();
115
116        let new_data = MousePos {
117            x: mouse_pos.x / size.x as f32,
118            y: mouse_pos.y / size.y as f32,
119            _junk: 0.0,
120            _padding2: 0.0,
121        };
122
123        self.data = new_data;
124        self.mouse_material
125            .update_uniform_data(&self.data, &engine_handle)
126            .unwrap();
127        self.circle_material
128            .update_uniform_data(&self.theta, &engine_handle)
129            .unwrap();
130    }

Trait Implementations§

Source §

impl<T: Debug> Debug for Material<T>

Source §

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl<T = ()> !UnwindSafe for Material<T>

Blanket Implementations§

§

impl<T> Any for T
where T: 'static + ?Sized,

§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

§

impl<T> Borrow<T> for T
where T: ?Sized,

§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

§

impl<T> BorrowMut<T> for T
where T: ?Sized,

§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

Source §

impl<T> Downcast<T> for T

Source §

fn downcast(&self) -> &T

Source §

impl<T> Downcast for T
where T: Any,

Source §

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.

Source §

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.

Source §

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.

Source §

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.

Source §

impl<T> DowncastSync for T
where T: Any + Send + Sync,

Source §

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.

§

impl<T> From<T> for T

§

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T, W> HasTypeWitness<W> for T
where W: MakeTypeWitness<Arg = T>, T: ?Sized,

Source §

const WITNESS: W = W::MAKE

A constant of the type witness

Source §

impl<T> Identity for T
where T: ?Sized,

Source §

const TYPE_EQ: TypeEq<T, <T as Identity>::Type> = TypeEq::NEW

Proof that Self is the same type as Self::Type, provides methods for casting between Self and Self::Type.

Source §

type Type = T

The same type as Self, used to emulate type equality bounds (T == U) with associated type equality constraints (T: Identity<Type = U>).

Source §

impl<T> Instrument for T

Source §

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

Source §

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

§

impl<T, U> Into for T
where U: From<T>,

§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> IntoEither for T

Source §

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §