vert 0.1.1

The 51th Rust Game Engine, to write the 6th Game in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use std::fmt::Debug;

pub mod gizmos;
pub use gizmos::Gizmos;

pub mod color_mesh;
pub use color_mesh::ColorMeshRenderer;

pub mod ui_rect;
pub use ui_rect::UiRectRenderer;

pub mod world_rect;
pub use world_rect::WorldRectRenderer;

pub mod text_renderer;
pub use text_renderer::TextRenderer;

use crate::{
    app::{ModuleId, UntypedHandle},
    Handle, Module,
};

pub trait MainPassRenderer {
    /// The renderpass here is expected to be 4xMSAA and has HDR_COLOR_FORMAT as its format.
    fn render<'encoder>(&'encoder self, render_pass: &mut wgpu::RenderPass<'encoder>);
}

pub(super) struct MainPassRendererHandle {
    module_id: ModuleId,
    handle: UntypedHandle,
    /// A type punned fn render<'pass, 'encoder>(&'encoder self, render_pass: &'pass mut wgpu::RenderPass<'encoder>);
    render_fn: fn(*const (), render_pass: *const ()) -> (),
}

impl Debug for MainPassRendererHandle {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("MainPassRendererHandle")
            .field("module_id", &self.module_id)
            .finish()
    }
}

impl MainPassRendererHandle {
    pub fn new<R: MainPassRenderer + Module>(handle: Handle<R>) -> Self {
        return MainPassRendererHandle {
            module_id: ModuleId::of::<R>(),
            handle: handle.untyped(),
            render_fn: render::<R>,
        };

        fn render<R: MainPassRenderer>(obj: *const (), render_pass: *const ()) {
            unsafe {
                <R as MainPassRenderer>::render(
                    &*(obj as *const R),
                    &mut *(render_pass as *mut wgpu::RenderPass<'_>),
                );
            }
        }
    }

    pub fn render<'encoder>(&self, render_pass: &mut wgpu::RenderPass<'encoder>) {
        let obj_ptr = self.handle.ptr();
        let render_pass_ptr = render_pass as *const wgpu::RenderPass<'encoder> as *const ();
        (self.render_fn)(obj_ptr, render_pass_ptr);
    }
}