aleatico 0.1.1

stub package for furmint engine graphics
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

use crate::errors::{AleaticoError, AleaticoResult};
use crate::renderer::RenderStats;
use crate::renderer::resources::ResourceStore;
use wgpu::RenderPass;
use crate::renderer::camera::Camera;

/// The main renderer pass, separated into this type for readability
pub(crate) struct MainPass;

impl MainPass {
    pub(crate) fn render(
        pass: &mut RenderPass,
        camera: &Camera,
        resources: &ResourceStore,
        stats: &mut RenderStats,
    ) -> AleaticoResult<()> {
        let mut triangles: usize = 0;

        for render_item in &resources.render_item_store {
            let mesh = resources
                .mesh_store
                .get(render_item.mesh_id)
                .ok_or(AleaticoError::MeshNotFound)?;

            let material = resources
                .material_store
                .get(render_item.material_id)
                .ok_or(AleaticoError::TextureNotFound)?;

            let pipeline = resources
                .pipeline_store
                .get(material.pipeline_id)
                .ok_or(AleaticoError::PipelineNotFound)?;

            pass.set_pipeline(pipeline.raw());

            if let Some(albedo_id) = material.textures.albedo {
                let texture = resources
                    .texture_store
                    .get(albedo_id)
                    .ok_or(AleaticoError::TextureNotFound)?;

                pass.set_bind_group(0, texture.raw(), &[]);
            }
            pass.set_bind_group(1, camera.bind_group(), &[]);
            pass.set_vertex_buffer(0, mesh.vertex_buffer.slice(..));

            if let Some(index_buffer) = &mesh.index_buffer {
                pass.set_index_buffer(index_buffer.slice(..), wgpu::IndexFormat::Uint16);
                pass.draw_indexed(0..mesh.num_indices as u32, 0, 0..1);

                triangles += mesh.num_indices / 3;
            } else {
                pass.draw(0..mesh.num_vertices as u32, 0..1);

                triangles += mesh.num_vertices / 3;
            }
        }

        stats.triangles = triangles;

        Ok(())
    }
}