rein 0.1.1

rein 3D Rendering Library
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

//! Depth material for shadow map generation

use super::traits::ModelUniform;
use crate::context::WgpuContext;
use crate::core::buffer::RawUniformBuffer;
use crate::core::pipeline::PipelineBuilder;
use crate::core::render_states::{CullState, DepthState};
use crate::core::vertex::VertexP;
use glam::Mat4;

/// Light view-projection uniform for shadow mapping.
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
pub struct LightMatrixUniform {
    pub light_view_proj: [[f32; 4]; 4],
}

/// Depth-only material for shadow map generation.
pub struct DepthMaterial {
    pipeline: wgpu::RenderPipeline,
    light_buffer: RawUniformBuffer,
    light_bind_group: wgpu::BindGroup,
    model_buffer: RawUniformBuffer,
    model_bind_group: wgpu::BindGroup,
}

impl DepthMaterial {
    /// Create a new depth material.
    pub fn new(ctx: &WgpuContext) -> anyhow::Result<Self> {
        let shader = include_str!("../../shaders/depth.wgsl");

        // Light matrix bind group layout (group 0)
        let light_bind_group_layout =
            ctx.device
                .create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                    label: Some("depth light bind group layout"),
                    entries: &[wgpu::BindGroupLayoutEntry {
                        binding: 0,
                        visibility: wgpu::ShaderStages::VERTEX,
                        ty: wgpu::BindingType::Buffer {
                            ty: wgpu::BufferBindingType::Uniform,
                            has_dynamic_offset: false,
                            min_binding_size: None,
                        },
                        count: None,
                    }],
                });

        // Model bind group layout (group 1)
        let model_bind_group_layout =
            ctx.device
                .create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                    label: Some("depth model bind group layout"),
                    entries: &[wgpu::BindGroupLayoutEntry {
                        binding: 0,
                        visibility: wgpu::ShaderStages::VERTEX,
                        ty: wgpu::BindingType::Buffer {
                            ty: wgpu::BufferBindingType::Uniform,
                            has_dynamic_offset: false,
                            min_binding_size: None,
                        },
                        count: None,
                    }],
                });

        let pipeline = PipelineBuilder::new(ctx)
            .label("depth material pipeline")
            .shader(shader)
            .vertex_layout(VertexP::layout())
            .bind_group_layout(&light_bind_group_layout)
            .bind_group_layout(&model_bind_group_layout)
            .color_format(wgpu::TextureFormat::R8Unorm) // Dummy format, no color output
            .depth(DepthState::read_write())
            .cull(CullState::Back)
            .build()?;

        // Create light matrix buffer
        let light_buffer = RawUniformBuffer::new(
            ctx,
            std::mem::size_of::<LightMatrixUniform>() as u64,
            Some("depth light uniform"),
        );

        let light_bind_group = ctx.device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("depth light bind group"),
            layout: &light_bind_group_layout,
            entries: &[wgpu::BindGroupEntry {
                binding: 0,
                resource: light_buffer.buffer().as_entire_binding(),
            }],
        });

        // Create model buffer
        let model_buffer = RawUniformBuffer::new(
            ctx,
            std::mem::size_of::<ModelUniform>() as u64,
            Some("depth model uniform"),
        );

        let model_bind_group = ctx.device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("depth model bind group"),
            layout: &model_bind_group_layout,
            entries: &[wgpu::BindGroupEntry {
                binding: 0,
                resource: model_buffer.buffer().as_entire_binding(),
            }],
        });

        Ok(Self {
            pipeline,
            light_buffer,
            light_bind_group,
            model_buffer,
            model_bind_group,
        })
    }

    /// Update uniforms for shadow pass.
    pub fn update_uniforms(&self, ctx: &WgpuContext, light_view_proj: Mat4, model_matrix: Mat4) {
        let light_uniform = LightMatrixUniform {
            light_view_proj: light_view_proj.to_cols_array_2d(),
        };
        self.light_buffer.write(ctx, &light_uniform);

        let model_uniform = ModelUniform::from_matrix(model_matrix);
        self.model_buffer.write(ctx, &model_uniform);
    }

    /// Get the render pipeline.
    pub fn pipeline(&self) -> &wgpu::RenderPipeline {
        &self.pipeline
    }

    /// Get the light matrix bind group.
    pub fn light_bind_group(&self) -> &wgpu::BindGroup {
        &self.light_bind_group
    }

    /// Get the model bind group.
    pub fn model_bind_group(&self) -> &wgpu::BindGroup {
        &self.model_bind_group
    }
}