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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

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

pub mod tone_mapping;
pub use tone_mapping::{AcesToneMapping, ToneMappingSettings};

pub mod bloom;
pub use bloom::{Bloom, BloomSettings};

pub trait PostProcessingEffect {
    fn apply<'e>(
        &'e mut self,
        encoder: &'e mut CommandEncoder,
        input_texture: &wgpu::BindGroup,
        output_texture: &wgpu::TextureView,
    );
}

pub(super) struct PostProcessingEffectHandle {
    module_id: ModuleId,
    handle: UntypedHandle,
    /// A type punned fn apply<'e>(&'e mut self, encoder: &'e mut CommandEncoder, input_texture: &wgpu::BindGroup, output_texture: &wgpu::TextureView, );
    apply_fn: fn(
        *const (),
        encoder: *const (),
        input_texture: *const (),
        output_texture: *const (),
    ) -> (),
}

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

impl PostProcessingEffectHandle {
    pub fn new<R: PostProcessingEffect + Module>(handle: Handle<R>) -> Self {
        return PostProcessingEffectHandle {
            module_id: ModuleId::of::<R>(),
            handle: handle.untyped(),
            apply_fn: apply::<R>,
        };

        fn apply<R: PostProcessingEffect>(
            obj: *const (),
            encoder: *const (),
            input_texture: *const (),
            output_texture: *const (),
        ) {
            unsafe {
                <R as PostProcessingEffect>::apply(
                    &mut *(obj as *mut R),
                    &mut *(encoder as *mut wgpu::CommandEncoder),
                    &*(input_texture as *const wgpu::BindGroup),
                    &*(output_texture as *const wgpu::TextureView),
                );
            }
        }
    }

    pub fn apply<'e>(
        &'e self,
        encoder: &'e mut CommandEncoder,
        input_texture: &wgpu::BindGroup,
        output_texture: &wgpu::TextureView,
    ) {
        let obj_ptr = self.handle.ptr();
        let encoder_ptr = encoder as *const CommandEncoder as *const ();
        let input_texture_ptr = input_texture as *const wgpu::BindGroup as *const ();
        let output_texture_ptr = output_texture as *const wgpu::TextureView as *const ();
        (self.apply_fn)(obj_ptr, encoder_ptr, input_texture_ptr, output_texture_ptr);
    }
}

/// Shader for a single triangle that covers the entire screen.
pub struct ScreenVertexShader(wgpu::ShaderModule);

impl ScreenVertexShader {
    pub fn new(device: &wgpu::Device) -> Self {
        let module = device.create_shader_module(ShaderModuleDescriptor {
            label: Some("Screen Vertex Shader"),
            source: wgpu::ShaderSource::Wgsl(include_str!("screen.vert.wgsl").into()),
        });
        ScreenVertexShader(module)
    }

    pub fn vertex_state(&self) -> wgpu::VertexState<'_> {
        wgpu::VertexState {
            module: &self.0,
            entry_point: "vs_main",
            buffers: &[],
        }
    }
}

pub trait SdrSurfaceRenderer {
    fn render<'e>(&'e self, encoder: &'e mut CommandEncoder, view: &wgpu::TextureView);
}

pub(super) struct SdrSurfaceRendererHandle {
    module_id: ModuleId,
    handle: UntypedHandle,
    /// A type punned fn render<'e>(&'e mut self, encoder: &'e mut CommandEncoder, view: &wgpu::TextureView);
    render_fn: fn(*const (), encoder: *const (), view: *const ()) -> (),
}

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

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

        fn render<R: SdrSurfaceRenderer>(obj: *const (), encoder: *const (), view: *const ()) {
            unsafe {
                <R as SdrSurfaceRenderer>::render(
                    &*(obj as *const R),
                    &mut *(encoder as *mut wgpu::CommandEncoder),
                    &*(view as *const wgpu::TextureView),
                );
            }
        }
    }

    pub fn render<'e>(&'e self, encoder: &'e mut CommandEncoder, view: &wgpu::TextureView) {
        let obj_ptr = self.handle.ptr();
        let encoder_ptr = encoder as *const CommandEncoder as *const ();
        let view_ptr = view as *const wgpu::TextureView as *const ();
        (self.render_fn)(obj_ptr, encoder_ptr, view_ptr);
    }
}