miye 0.1.2

A simple, lightweight .obj model renderer.
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

use crate::models::Model;
use crate::state::State;
use std::ops::Range;

pub fn draw(state: &mut State) {
    let frame = state.surface.get_current_texture().unwrap();

    let view = frame
        .texture
        .create_view(&wgpu::TextureViewDescriptor::default());

    let mut encoder = state
        .device
        .create_command_encoder(&wgpu::CommandEncoderDescriptor {
            label: Some("Command Encoder"),
        });

    state.camera_uniform.update_view_proj(&state.camera);
    state.queue.write_buffer(
        &state.camera_buffer,
        0,
        bytemuck::cast_slice(&[state.camera_uniform]),
    );

    {
        let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
            label: Some("Vertex Render Pass"),
            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                view: &view,
                resolve_target: None,
                ops: wgpu::Operations {
                    load: wgpu::LoadOp::Clear(wgpu::Color::WHITE),
                    store: wgpu::StoreOp::Store,
                },
            })],
            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
                view: &state.depth_texture.view,
                depth_ops: Some(wgpu::Operations {
                    load: wgpu::LoadOp::Clear(1.0),
                    store: wgpu::StoreOp::Store,
                }),
                stencil_ops: None,
            }),
            timestamp_writes: None,
            occlusion_query_set: None,
        });

        render_pass.set_bind_group(0, &state.camera_bind_group, &[]);
        render_pass.set_pipeline(&state.render_pipeline);
        for i in &state.instances {
            render_pass.draw_model(&i.model);
        }
    }

    state.queue.submit(Some(encoder.finish()));
    frame.present();
}

pub trait DrawModel<'a> {
    fn draw_mesh(&mut self, mesh: &'a crate::models::Mesh, material: &'a crate::models::Material);
    fn draw_mesh_instanced(
        &mut self,
        mesh: &'a crate::models::Mesh,
        instances: Range<u32>,
        material: &'a crate::models::Material,
    );
    fn draw_model(&mut self, model: &'a Model);
    fn draw_model_instanced(&mut self, model: &'a Model, instances: Range<u32>);
}

impl<'a, 'b> DrawModel<'b> for wgpu::RenderPass<'a>
where
    'b: 'a,
{
    fn draw_mesh(&mut self, mesh: &'b crate::models::Mesh, material: &'a crate::models::Material) {
        self.draw_mesh_instanced(mesh, 0..1, material)
    }

    fn draw_mesh_instanced(
        &mut self,
        mesh: &'b crate::models::Mesh,
        instances: Range<u32>,
        material: &'b crate::models::Material,
    ) {
        self.set_vertex_buffer(0, mesh.vertex_buffer.slice(..));
        self.set_index_buffer(mesh.index_buffer.slice(..), wgpu::IndexFormat::Uint32);
        self.set_bind_group(1, &material.bind_group, &[]);
        self.draw_indexed(0..mesh.num_elements, 0, instances);
    }

    fn draw_model(&mut self, model: &'b Model) {
        self.draw_model_instanced(model, 0..1);
    }

    fn draw_model_instanced(&mut self, model: &'b Model, instances: Range<u32>) {
        for mesh in &model.mesh {
            let material = &model.material[mesh.material];
            self.draw_mesh_instanced(mesh, instances.clone(), material);
        }
    }
}