rustial-renderer-wgpu 0.0.1

//! Shadow depth render pipelines for cascaded shadow maps.
//!
//! Two depth-only pipelines are provided:
//!
//! - **Fill-extrusion caster**: uses the standard `FillExtrusionVertex` layout
//!   and the `vs_fill_extrusion` entry point.
//! - **Model caster**: uses `ModelVertex` + per-instance transform and the
//!   `vs_model` entry point.

use crate::gpu::depth::DEPTH_FORMAT;
use crate::gpu::fill_extrusion_vertex::FillExtrusionVertex;
use crate::gpu::model_vertex::ModelVertex;

/// Uniform for the shadow depth pass (single light VP per cascade).
#[repr(C)]
#[derive(Debug, Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
pub struct ShadowDepthUniform {
    /// Column-major 4×4 light view-projection matrix for this cascade.
    pub light_view_proj: [[f32; 4]; 4],
}

/// Shadow depth pipeline for fill-extrusion casters.
pub struct ShadowFillExtrusionPipeline {
    /// Depth-only render pipeline.
    pub pipeline: wgpu::RenderPipeline,
    /// Bind group layout for the shadow uniform.
    pub uniform_bind_group_layout: wgpu::BindGroupLayout,
}

impl ShadowFillExtrusionPipeline {
    /// Create the fill-extrusion shadow caster pipeline.
    pub fn new(device: &wgpu::Device) -> Self {
        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("shadow_depth_shader"),
            source: wgpu::ShaderSource::Wgsl(include_str!("../shaders/shadow_depth.wgsl").into()),
        });

        let uniform_bind_group_layout =
            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                label: Some("shadow_fill_ext_uniform_bgl"),
                entries: &[wgpu::BindGroupLayoutEntry {
                    binding: 0,
                    visibility: wgpu::ShaderStages::VERTEX,
                    ty: wgpu::BindingType::Buffer {
                        ty: wgpu::BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: wgpu::BufferSize::new(std::mem::size_of::<
                            ShadowDepthUniform,
                        >() as u64),
                    },
                    count: None,
                }],
            });

        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
            label: Some("shadow_fill_ext_pipeline_layout"),
            bind_group_layouts: &[&uniform_bind_group_layout],
            push_constant_ranges: &[],
        });

        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
            label: Some("shadow_fill_extrusion_pipeline"),
            layout: Some(&pipeline_layout),
            vertex: wgpu::VertexState {
                module: &shader,
                entry_point: Some("vs_fill_extrusion"),
                buffers: &[FillExtrusionVertex::layout()],
                compilation_options: wgpu::PipelineCompilationOptions::default(),
            },
            fragment: None,
            primitive: wgpu::PrimitiveState {
                topology: wgpu::PrimitiveTopology::TriangleList,
                front_face: wgpu::FrontFace::Ccw,
                // Render both faces for shadow map to avoid light leaking.
                cull_mode: None,
                ..Default::default()
            },
            depth_stencil: Some(wgpu::DepthStencilState {
                format: DEPTH_FORMAT,
                depth_write_enabled: true,
                depth_compare: wgpu::CompareFunction::Less,
                stencil: wgpu::StencilState::default(),
                bias: wgpu::DepthBiasState {
                    constant: 2,
                    slope_scale: 2.0,
                    clamp: 0.0,
                },
            }),
            multisample: wgpu::MultisampleState::default(),
            multiview: None,
            cache: None,
        });

        Self {
            pipeline,
            uniform_bind_group_layout,
        }
    }
}

/// Shadow depth pipeline for model casters.
pub struct ShadowModelPipeline {
    /// Depth-only render pipeline.
    pub pipeline: wgpu::RenderPipeline,
    /// Bind group layout for the shadow uniform.
    pub uniform_bind_group_layout: wgpu::BindGroupLayout,
    /// Bind group layout for per-model transform uniforms.
    pub model_bind_group_layout: wgpu::BindGroupLayout,
}

impl ShadowModelPipeline {
    /// Create the model shadow caster pipeline.
    pub fn new(device: &wgpu::Device) -> Self {
        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("shadow_depth_model_shader"),
            source: wgpu::ShaderSource::Wgsl(include_str!("../shaders/shadow_depth.wgsl").into()),
        });

        let uniform_bind_group_layout =
            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                label: Some("shadow_model_uniform_bgl"),
                entries: &[wgpu::BindGroupLayoutEntry {
                    binding: 0,
                    visibility: wgpu::ShaderStages::VERTEX,
                    ty: wgpu::BindingType::Buffer {
                        ty: wgpu::BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: wgpu::BufferSize::new(std::mem::size_of::<
                            ShadowDepthUniform,
                        >() as u64),
                    },
                    count: None,
                }],
            });

        let model_bind_group_layout =
            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                label: Some("shadow_model_transform_bgl"),
                entries: &[wgpu::BindGroupLayoutEntry {
                    binding: 0,
                    visibility: wgpu::ShaderStages::VERTEX,
                    ty: wgpu::BindingType::Buffer {
                        ty: wgpu::BufferBindingType::Uniform,
                        has_dynamic_offset: true,
                        min_binding_size: wgpu::BufferSize::new(64), // mat4x4<f32>
                    },
                    count: None,
                }],
            });

        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
            label: Some("shadow_model_pipeline_layout"),
            bind_group_layouts: &[&uniform_bind_group_layout, &model_bind_group_layout],
            push_constant_ranges: &[],
        });

        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
            label: Some("shadow_model_pipeline"),
            layout: Some(&pipeline_layout),
            vertex: wgpu::VertexState {
                module: &shader,
                entry_point: Some("vs_model"),
                buffers: &[ModelVertex::layout()],
                compilation_options: wgpu::PipelineCompilationOptions::default(),
            },
            fragment: None,
            primitive: wgpu::PrimitiveState {
                topology: wgpu::PrimitiveTopology::TriangleList,
                front_face: wgpu::FrontFace::Ccw,
                cull_mode: None,
                ..Default::default()
            },
            depth_stencil: Some(wgpu::DepthStencilState {
                format: DEPTH_FORMAT,
                depth_write_enabled: true,
                depth_compare: wgpu::CompareFunction::Less,
                stencil: wgpu::StencilState::default(),
                bias: wgpu::DepthBiasState {
                    constant: 2,
                    slope_scale: 2.0,
                    clamp: 0.0,
                },
            }),
            multisample: wgpu::MultisampleState::default(),
            multiview: None,
            cache: None,
        });

        Self {
            pipeline,
            uniform_bind_group_layout,
            model_bind_group_layout,
        }
    }
}