chaos_framework

Struct Renderer

Source 
pub struct Renderer {
    pub meshes: HashMap<MeshHandle, Mesh>,
    pub lights: HashMap<LightHandle, Light>,
    pub textures: HashMap<TextureHandle, GLuint>,
    pub models: HashMap<ModelHandle, Model>,
    pub skeletal_meshes: HashMap<SkeletalMeshHandle, SkeletalMesh>,
    pub camera: Camera,
}

Fields§

§meshes: HashMap<MeshHandle, Mesh>§lights: HashMap<LightHandle, Light>§textures: HashMap<TextureHandle, GLuint>§models: HashMap<ModelHandle, Model>§skeletal_meshes: HashMap<SkeletalMeshHandle, SkeletalMesh>§camera: Camera

Implementations§

Source§

impl Renderer

Source

pub fn new() -> Self

Examples found in repository?
examples/simple2d.rs (line 10)
8fn main() {
9    let mut el = EventLoop::new(600, 600);
10    let mut renderer = Renderer::new();
11
12    /* default projection type is perspective */
13    renderer.camera.set_projection(ProjectionType::Orthographic);
14    renderer.add_light(Light { position: vec3(0.0, 0.0, 1.0), color: Vec3::ONE })
15        .unwrap();
16
17    /* we'll represent our player using a quad */
18    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
19        .unwrap();
20
21    while !el.window.should_close() {
22        el.update();
23
24        /* we can modify the player by indexing into it in the renderer's meshes */
25        let player = &mut renderer.meshes[player_handle];
26        player.color = vec3(0.5, 0.0, el.time.sin());
27        move_player(&el, &mut player.position);
28    
29        renderer.camera.update(Vec3::ZERO, &el);
30    
31        let frame = el.ui.frame(&mut el.window);
32        frame.text("hello, world! this is imgui");
33
34        unsafe {
35            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
36            ClearColor(0.1, 0.2, 0.3, 1.0);
37            
38            renderer.draw();
39            el.ui.draw();
40        }
41    }
42}
More examples
Hide additional examples
examples/ik.rs (line 9)
7fn main() {
8    let mut el = EventLoop::new(600, 600);
9    let mut renderer = Renderer::new();
10
11    unsafe {
12        Enable(DEPTH_TEST);
13    }
14
15    /* default projection type is perspective */
16    renderer.camera.set_projection(ProjectionType::Orthographic);
17    renderer.add_light(Light { position: vec3(0.0, 0.0, 3.0), color: Vec3::ONE })
18        .unwrap();
19
20    /* we'll represent our player using a quad */
21    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
22        .unwrap();
23
24    renderer.meshes[player_handle].position = Vec3::Z * 2.0; // so the player stays in front of everything
25
26    let mut segments = vec![];
27    for _ in 0..128 {
28        let new_segment = Segment::new(vec3(0.0, 0.0, 0.0), 0.05, &mut renderer);
29
30        segments.push(new_segment);
31    }
32
33    renderer.meshes[segments[0].handle].hidden = true;
34    renderer.meshes[segments[segments.len()-1].handle].hidden = true;
35
36    renderer.meshes[player_handle].hidden = true;
37    
38
39    segments[0].pos = Vec3::new(-2.0, -2.0, 0.0);
40
41    let mut clamped_pos;
42    let mut player_vel;
43    let mut old_pos = Vec3::ZERO;
44
45    while !el.window.should_close() {
46        el.update();
47        renderer.update();
48        
49        segments.iter_mut().for_each(|s| {
50            s.update(&mut renderer);
51        });
52        
53        let player = &mut renderer.meshes[player_handle];
54        let mp = el.event_handler.mouse_pos / el.event_handler.width * 2.0;
55        let clamped_player_pos = {
56            // clamped_pos = lerp(clamped_pos, player.position, 0.1);
57            clamped_pos = player.position;
58
59            vec3(clamped_pos.x, clamped_pos.y, 0.0)
60        };
61        fabrik(&mut segments, {
62            if el.event_handler.lmb {
63                clamped_player_pos + vec3(mp.x, mp.y, 0.0)
64            } else {
65                clamped_player_pos
66            }
67        }, 0.0, 2);
68
69        let first_segment_position = segments[0].pos;
70        let seg_amm = segments.len() as f32;
71        let distance = first_segment_position.distance(segments[segments.len()-1].pos);
72        let len = segments[0].length;
73        if distance > segments.len() as f32 * segments[0].length + segments[0].length {
74            segments[0].pos += ((clamped_player_pos - first_segment_position) / seg_amm) * len * f32::powf(distance, 2.3);
75        }
76
77        player_vel = player.position - old_pos;
78        old_pos = player.position;
79
80        player.color = vec3(0.5, 0.0, el.time.sin());
81        move_player(&el, &mut player.position);
82    
83        renderer.camera.update(lerp(renderer.camera.pos, player.position, 0.125), &el);
84        renderer.camera.mouse_callback(el.event_handler.mouse_pos, &el.window);
85
86        let frame = el.ui.frame(&mut el.window);
87        frame.text("Hello, world! This is imgui.");
88        frame.text(format!("p: {:.1}\nv: {:.3}", player.position, player_vel));
89
90        unsafe {
91            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
92            ClearColor(0.1, 0.2, 0.3, 1.0);
93            
94            renderer.draw();
95            el.ui.draw();
96        }
97    }
98}
Source

pub fn update(&mut self)

Examples found in repository?
examples/ik.rs (line 47)
7fn main() {
8    let mut el = EventLoop::new(600, 600);
9    let mut renderer = Renderer::new();
10
11    unsafe {
12        Enable(DEPTH_TEST);
13    }
14
15    /* default projection type is perspective */
16    renderer.camera.set_projection(ProjectionType::Orthographic);
17    renderer.add_light(Light { position: vec3(0.0, 0.0, 3.0), color: Vec3::ONE })
18        .unwrap();
19
20    /* we'll represent our player using a quad */
21    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
22        .unwrap();
23
24    renderer.meshes[player_handle].position = Vec3::Z * 2.0; // so the player stays in front of everything
25
26    let mut segments = vec![];
27    for _ in 0..128 {
28        let new_segment = Segment::new(vec3(0.0, 0.0, 0.0), 0.05, &mut renderer);
29
30        segments.push(new_segment);
31    }
32
33    renderer.meshes[segments[0].handle].hidden = true;
34    renderer.meshes[segments[segments.len()-1].handle].hidden = true;
35
36    renderer.meshes[player_handle].hidden = true;
37    
38
39    segments[0].pos = Vec3::new(-2.0, -2.0, 0.0);
40
41    let mut clamped_pos;
42    let mut player_vel;
43    let mut old_pos = Vec3::ZERO;
44
45    while !el.window.should_close() {
46        el.update();
47        renderer.update();
48        
49        segments.iter_mut().for_each(|s| {
50            s.update(&mut renderer);
51        });
52        
53        let player = &mut renderer.meshes[player_handle];
54        let mp = el.event_handler.mouse_pos / el.event_handler.width * 2.0;
55        let clamped_player_pos = {
56            // clamped_pos = lerp(clamped_pos, player.position, 0.1);
57            clamped_pos = player.position;
58
59            vec3(clamped_pos.x, clamped_pos.y, 0.0)
60        };
61        fabrik(&mut segments, {
62            if el.event_handler.lmb {
63                clamped_player_pos + vec3(mp.x, mp.y, 0.0)
64            } else {
65                clamped_player_pos
66            }
67        }, 0.0, 2);
68
69        let first_segment_position = segments[0].pos;
70        let seg_amm = segments.len() as f32;
71        let distance = first_segment_position.distance(segments[segments.len()-1].pos);
72        let len = segments[0].length;
73        if distance > segments.len() as f32 * segments[0].length + segments[0].length {
74            segments[0].pos += ((clamped_player_pos - first_segment_position) / seg_amm) * len * f32::powf(distance, 2.3);
75        }
76
77        player_vel = player.position - old_pos;
78        old_pos = player.position;
79
80        player.color = vec3(0.5, 0.0, el.time.sin());
81        move_player(&el, &mut player.position);
82    
83        renderer.camera.update(lerp(renderer.camera.pos, player.position, 0.125), &el);
84        renderer.camera.mouse_callback(el.event_handler.mouse_pos, &el.window);
85
86        let frame = el.ui.frame(&mut el.window);
87        frame.text("Hello, world! This is imgui.");
88        frame.text(format!("p: {:.1}\nv: {:.3}", player.position, player_vel));
89
90        unsafe {
91            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
92            ClearColor(0.1, 0.2, 0.3, 1.0);
93            
94            renderer.draw();
95            el.ui.draw();
96        }
97    }
98}
Source

pub unsafe fn draw(&self)

Examples found in repository?
examples/simple2d.rs (line 38)
8fn main() {
9    let mut el = EventLoop::new(600, 600);
10    let mut renderer = Renderer::new();
11
12    /* default projection type is perspective */
13    renderer.camera.set_projection(ProjectionType::Orthographic);
14    renderer.add_light(Light { position: vec3(0.0, 0.0, 1.0), color: Vec3::ONE })
15        .unwrap();
16
17    /* we'll represent our player using a quad */
18    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
19        .unwrap();
20
21    while !el.window.should_close() {
22        el.update();
23
24        /* we can modify the player by indexing into it in the renderer's meshes */
25        let player = &mut renderer.meshes[player_handle];
26        player.color = vec3(0.5, 0.0, el.time.sin());
27        move_player(&el, &mut player.position);
28    
29        renderer.camera.update(Vec3::ZERO, &el);
30    
31        let frame = el.ui.frame(&mut el.window);
32        frame.text("hello, world! this is imgui");
33
34        unsafe {
35            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
36            ClearColor(0.1, 0.2, 0.3, 1.0);
37            
38            renderer.draw();
39            el.ui.draw();
40        }
41    }
42}
More examples
Hide additional examples
examples/ik.rs (line 94)
7fn main() {
8    let mut el = EventLoop::new(600, 600);
9    let mut renderer = Renderer::new();
10
11    unsafe {
12        Enable(DEPTH_TEST);
13    }
14
15    /* default projection type is perspective */
16    renderer.camera.set_projection(ProjectionType::Orthographic);
17    renderer.add_light(Light { position: vec3(0.0, 0.0, 3.0), color: Vec3::ONE })
18        .unwrap();
19
20    /* we'll represent our player using a quad */
21    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
22        .unwrap();
23
24    renderer.meshes[player_handle].position = Vec3::Z * 2.0; // so the player stays in front of everything
25
26    let mut segments = vec![];
27    for _ in 0..128 {
28        let new_segment = Segment::new(vec3(0.0, 0.0, 0.0), 0.05, &mut renderer);
29
30        segments.push(new_segment);
31    }
32
33    renderer.meshes[segments[0].handle].hidden = true;
34    renderer.meshes[segments[segments.len()-1].handle].hidden = true;
35
36    renderer.meshes[player_handle].hidden = true;
37    
38
39    segments[0].pos = Vec3::new(-2.0, -2.0, 0.0);
40
41    let mut clamped_pos;
42    let mut player_vel;
43    let mut old_pos = Vec3::ZERO;
44
45    while !el.window.should_close() {
46        el.update();
47        renderer.update();
48        
49        segments.iter_mut().for_each(|s| {
50            s.update(&mut renderer);
51        });
52        
53        let player = &mut renderer.meshes[player_handle];
54        let mp = el.event_handler.mouse_pos / el.event_handler.width * 2.0;
55        let clamped_player_pos = {
56            // clamped_pos = lerp(clamped_pos, player.position, 0.1);
57            clamped_pos = player.position;
58
59            vec3(clamped_pos.x, clamped_pos.y, 0.0)
60        };
61        fabrik(&mut segments, {
62            if el.event_handler.lmb {
63                clamped_player_pos + vec3(mp.x, mp.y, 0.0)
64            } else {
65                clamped_player_pos
66            }
67        }, 0.0, 2);
68
69        let first_segment_position = segments[0].pos;
70        let seg_amm = segments.len() as f32;
71        let distance = first_segment_position.distance(segments[segments.len()-1].pos);
72        let len = segments[0].length;
73        if distance > segments.len() as f32 * segments[0].length + segments[0].length {
74            segments[0].pos += ((clamped_player_pos - first_segment_position) / seg_amm) * len * f32::powf(distance, 2.3);
75        }
76
77        player_vel = player.position - old_pos;
78        old_pos = player.position;
79
80        player.color = vec3(0.5, 0.0, el.time.sin());
81        move_player(&el, &mut player.position);
82    
83        renderer.camera.update(lerp(renderer.camera.pos, player.position, 0.125), &el);
84        renderer.camera.mouse_callback(el.event_handler.mouse_pos, &el.window);
85
86        let frame = el.ui.frame(&mut el.window);
87        frame.text("Hello, world! This is imgui.");
88        frame.text(format!("p: {:.1}\nv: {:.3}", player.position, player_vel));
89
90        unsafe {
91            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
92            ClearColor(0.1, 0.2, 0.3, 1.0);
93            
94            renderer.draw();
95            el.ui.draw();
96        }
97    }
98}
Source§

impl Renderer

Source

pub fn add_mesh_from_vertices_and_indices( &mut self, vertices: Vec<Vertex>, indices: Vec<u32>, ) -> Option<MeshHandle>

Source

pub fn add_mesh(&mut self, mesh: Mesh) -> Option<MeshHandle>

Examples found in repository?
examples/simple2d.rs (line 18)
8fn main() {
9    let mut el = EventLoop::new(600, 600);
10    let mut renderer = Renderer::new();
11
12    /* default projection type is perspective */
13    renderer.camera.set_projection(ProjectionType::Orthographic);
14    renderer.add_light(Light { position: vec3(0.0, 0.0, 1.0), color: Vec3::ONE })
15        .unwrap();
16
17    /* we'll represent our player using a quad */
18    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
19        .unwrap();
20
21    while !el.window.should_close() {
22        el.update();
23
24        /* we can modify the player by indexing into it in the renderer's meshes */
25        let player = &mut renderer.meshes[player_handle];
26        player.color = vec3(0.5, 0.0, el.time.sin());
27        move_player(&el, &mut player.position);
28    
29        renderer.camera.update(Vec3::ZERO, &el);
30    
31        let frame = el.ui.frame(&mut el.window);
32        frame.text("hello, world! this is imgui");
33
34        unsafe {
35            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
36            ClearColor(0.1, 0.2, 0.3, 1.0);
37            
38            renderer.draw();
39            el.ui.draw();
40        }
41    }
42}
More examples
Hide additional examples
examples/ik.rs (line 21)
7fn main() {
8    let mut el = EventLoop::new(600, 600);
9    let mut renderer = Renderer::new();
10
11    unsafe {
12        Enable(DEPTH_TEST);
13    }
14
15    /* default projection type is perspective */
16    renderer.camera.set_projection(ProjectionType::Orthographic);
17    renderer.add_light(Light { position: vec3(0.0, 0.0, 3.0), color: Vec3::ONE })
18        .unwrap();
19
20    /* we'll represent our player using a quad */
21    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
22        .unwrap();
23
24    renderer.meshes[player_handle].position = Vec3::Z * 2.0; // so the player stays in front of everything
25
26    let mut segments = vec![];
27    for _ in 0..128 {
28        let new_segment = Segment::new(vec3(0.0, 0.0, 0.0), 0.05, &mut renderer);
29
30        segments.push(new_segment);
31    }
32
33    renderer.meshes[segments[0].handle].hidden = true;
34    renderer.meshes[segments[segments.len()-1].handle].hidden = true;
35
36    renderer.meshes[player_handle].hidden = true;
37    
38
39    segments[0].pos = Vec3::new(-2.0, -2.0, 0.0);
40
41    let mut clamped_pos;
42    let mut player_vel;
43    let mut old_pos = Vec3::ZERO;
44
45    while !el.window.should_close() {
46        el.update();
47        renderer.update();
48        
49        segments.iter_mut().for_each(|s| {
50            s.update(&mut renderer);
51        });
52        
53        let player = &mut renderer.meshes[player_handle];
54        let mp = el.event_handler.mouse_pos / el.event_handler.width * 2.0;
55        let clamped_player_pos = {
56            // clamped_pos = lerp(clamped_pos, player.position, 0.1);
57            clamped_pos = player.position;
58
59            vec3(clamped_pos.x, clamped_pos.y, 0.0)
60        };
61        fabrik(&mut segments, {
62            if el.event_handler.lmb {
63                clamped_player_pos + vec3(mp.x, mp.y, 0.0)
64            } else {
65                clamped_player_pos
66            }
67        }, 0.0, 2);
68
69        let first_segment_position = segments[0].pos;
70        let seg_amm = segments.len() as f32;
71        let distance = first_segment_position.distance(segments[segments.len()-1].pos);
72        let len = segments[0].length;
73        if distance > segments.len() as f32 * segments[0].length + segments[0].length {
74            segments[0].pos += ((clamped_player_pos - first_segment_position) / seg_amm) * len * f32::powf(distance, 2.3);
75        }
76
77        player_vel = player.position - old_pos;
78        old_pos = player.position;
79
80        player.color = vec3(0.5, 0.0, el.time.sin());
81        move_player(&el, &mut player.position);
82    
83        renderer.camera.update(lerp(renderer.camera.pos, player.position, 0.125), &el);
84        renderer.camera.mouse_callback(el.event_handler.mouse_pos, &el.window);
85
86        let frame = el.ui.frame(&mut el.window);
87        frame.text("Hello, world! This is imgui.");
88        frame.text(format!("p: {:.1}\nv: {:.3}", player.position, player_vel));
89
90        unsafe {
91            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
92            ClearColor(0.1, 0.2, 0.3, 1.0);
93            
94            renderer.draw();
95            el.ui.draw();
96        }
97    }
98}
99
100struct Segment {
101    pos: Vec3,
102    length: f32,
103    angle: f32,
104    handle: MeshHandle,
105}
106
107impl Segment {
108    fn new(a: Vec3, length: f32, renderer: &mut Renderer) -> Self {
109        let handle = renderer.add_mesh(Quad::new(Vec3::ONE * length, Vec4::ONE).mesh())
110            .unwrap();
111
112        Self {
113            pos: a,
114            length: length / 2.0,
115            angle: 0.0,
116            handle: handle,
117        }
118    }
Source

pub fn get_mesh_mut(&mut self, handle: MeshHandle) -> Option<&mut Mesh>

Source

pub fn get_mesh(&self, handle: MeshHandle) -> Option<&Mesh>

Source

pub fn destroy_mesh(&mut self, handle: MeshHandle)

Source§

impl Renderer

Source

pub fn add_texture(&mut self, path: &str) -> Option<TextureHandle>

Source

pub fn destroy_texture(&mut self, handle: TextureHandle)

Source§

impl Renderer

Source

pub unsafe fn send_light_uniforms(&self, shader: &Shader)

Source

pub fn add_light(&mut self, light: Light) -> Option<LightHandle>

Examples found in repository?
examples/simple2d.rs (line 14)
8fn main() {
9    let mut el = EventLoop::new(600, 600);
10    let mut renderer = Renderer::new();
11
12    /* default projection type is perspective */
13    renderer.camera.set_projection(ProjectionType::Orthographic);
14    renderer.add_light(Light { position: vec3(0.0, 0.0, 1.0), color: Vec3::ONE })
15        .unwrap();
16
17    /* we'll represent our player using a quad */
18    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
19        .unwrap();
20
21    while !el.window.should_close() {
22        el.update();
23
24        /* we can modify the player by indexing into it in the renderer's meshes */
25        let player = &mut renderer.meshes[player_handle];
26        player.color = vec3(0.5, 0.0, el.time.sin());
27        move_player(&el, &mut player.position);
28    
29        renderer.camera.update(Vec3::ZERO, &el);
30    
31        let frame = el.ui.frame(&mut el.window);
32        frame.text("hello, world! this is imgui");
33
34        unsafe {
35            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
36            ClearColor(0.1, 0.2, 0.3, 1.0);
37            
38            renderer.draw();
39            el.ui.draw();
40        }
41    }
42}
More examples
Hide additional examples
examples/ik.rs (line 17)
7fn main() {
8    let mut el = EventLoop::new(600, 600);
9    let mut renderer = Renderer::new();
10
11    unsafe {
12        Enable(DEPTH_TEST);
13    }
14
15    /* default projection type is perspective */
16    renderer.camera.set_projection(ProjectionType::Orthographic);
17    renderer.add_light(Light { position: vec3(0.0, 0.0, 3.0), color: Vec3::ONE })
18        .unwrap();
19
20    /* we'll represent our player using a quad */
21    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
22        .unwrap();
23
24    renderer.meshes[player_handle].position = Vec3::Z * 2.0; // so the player stays in front of everything
25
26    let mut segments = vec![];
27    for _ in 0..128 {
28        let new_segment = Segment::new(vec3(0.0, 0.0, 0.0), 0.05, &mut renderer);
29
30        segments.push(new_segment);
31    }
32
33    renderer.meshes[segments[0].handle].hidden = true;
34    renderer.meshes[segments[segments.len()-1].handle].hidden = true;
35
36    renderer.meshes[player_handle].hidden = true;
37    
38
39    segments[0].pos = Vec3::new(-2.0, -2.0, 0.0);
40
41    let mut clamped_pos;
42    let mut player_vel;
43    let mut old_pos = Vec3::ZERO;
44
45    while !el.window.should_close() {
46        el.update();
47        renderer.update();
48        
49        segments.iter_mut().for_each(|s| {
50            s.update(&mut renderer);
51        });
52        
53        let player = &mut renderer.meshes[player_handle];
54        let mp = el.event_handler.mouse_pos / el.event_handler.width * 2.0;
55        let clamped_player_pos = {
56            // clamped_pos = lerp(clamped_pos, player.position, 0.1);
57            clamped_pos = player.position;
58
59            vec3(clamped_pos.x, clamped_pos.y, 0.0)
60        };
61        fabrik(&mut segments, {
62            if el.event_handler.lmb {
63                clamped_player_pos + vec3(mp.x, mp.y, 0.0)
64            } else {
65                clamped_player_pos
66            }
67        }, 0.0, 2);
68
69        let first_segment_position = segments[0].pos;
70        let seg_amm = segments.len() as f32;
71        let distance = first_segment_position.distance(segments[segments.len()-1].pos);
72        let len = segments[0].length;
73        if distance > segments.len() as f32 * segments[0].length + segments[0].length {
74            segments[0].pos += ((clamped_player_pos - first_segment_position) / seg_amm) * len * f32::powf(distance, 2.3);
75        }
76
77        player_vel = player.position - old_pos;
78        old_pos = player.position;
79
80        player.color = vec3(0.5, 0.0, el.time.sin());
81        move_player(&el, &mut player.position);
82    
83        renderer.camera.update(lerp(renderer.camera.pos, player.position, 0.125), &el);
84        renderer.camera.mouse_callback(el.event_handler.mouse_pos, &el.window);
85
86        let frame = el.ui.frame(&mut el.window);
87        frame.text("Hello, world! This is imgui.");
88        frame.text(format!("p: {:.1}\nv: {:.3}", player.position, player_vel));
89
90        unsafe {
91            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
92            ClearColor(0.1, 0.2, 0.3, 1.0);
93            
94            renderer.draw();
95            el.ui.draw();
96        }
97    }
98}
Source

pub fn destroy_light(&mut self, handle: LightHandle)

Source§

impl Renderer

Source

pub fn add_model(&mut self, model: Model) -> Option<ModelHandle>

Source

pub fn destroy_model(&mut self, handle: ModelHandle)

Source§

impl Renderer

Source

pub fn add_skeletal_mesh_from_vertices_and_indices( &mut self, vertices: Vec<SkeletalVertex>, indices: Vec<u32>, ) -> Option<SkeletalMeshHandle>

Source

pub fn add_skeletal_mesh( &mut self, mesh: SkeletalMesh, ) -> Option<SkeletalMeshHandle>

Source

pub fn get_skeletal_mesh_mut( &mut self, handle: SkeletalMeshHandle, ) -> Option<&mut SkeletalMesh>

Source

pub fn get_skeletal_mesh( &self, handle: SkeletalMeshHandle, ) -> Option<&SkeletalMesh>

Source

pub fn destroy_skeletal_mesh(&mut self, handle: SkeletalMeshHandle)

Auto Trait Implementations§

Blanket Implementations§

Source§

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

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

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

Source§

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§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

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

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V