scenix-renderer 0.7.0

wgpu renderer, GPU scene upload, passes, and frame orchestration for scenix.
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

use scenix_core::Color;
use scenix_material::{LambertMaterial, Material, PbrMaterial, UnlitMaterial};
use scenix_math::Vec3;

use crate::TextureStore;

/// GPU-ready material uniform shared by built-in v0.6 material paths.
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, bytemuck::Pod, bytemuck::Zeroable)]
pub struct MaterialUniform {
    /// Base color or diffuse color in linear RGBA.
    pub base_color: [f32; 4],
    /// Emissive color and alpha cutoff.
    pub emissive_cutoff: [f32; 4],
    /// Metallic, roughness, shader kind, and flags.
    pub params: [f32; 4],
}

impl MaterialUniform {
    /// Creates a material uniform from common factors.
    #[inline]
    pub fn new(
        base_color: Color,
        emissive: Vec3,
        metallic: f32,
        roughness: f32,
        alpha_cutoff: Option<f32>,
        shader_kind: f32,
        feature_bits: u64,
    ) -> Self {
        Self {
            base_color: base_color.to_array(),
            emissive_cutoff: [
                emissive.x,
                emissive.y,
                emissive.z,
                alpha_cutoff.unwrap_or(-1.0),
            ],
            params: [
                metallic.clamp(0.0, 1.0),
                roughness.clamp(0.0, 1.0),
                shader_kind,
                feature_bits as f32,
            ],
        }
    }
}

/// Bridges CPU-side material descriptions into renderer-owned GPU resources.
pub trait GpuMaterial: Material {
    /// Returns the bind-group layout used by this material family.
    fn bind_group_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout
    where
        Self: Sized,
    {
        device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
            label: Some("scenix.material.empty_layout"),
            entries: &[],
        })
    }

    /// Serializes material state into uniform bytes.
    fn to_uniform_bytes(&self) -> Vec<u8>;

    /// Creates a bind group for this material.
    fn create_bind_group(
        &self,
        device: &wgpu::Device,
        layout: &wgpu::BindGroupLayout,
        _textures: &TextureStore,
    ) -> wgpu::BindGroup {
        device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("scenix.material.bind_group"),
            layout,
            entries: &[],
        })
    }
}

impl GpuMaterial for PbrMaterial {
    fn to_uniform_bytes(&self) -> Vec<u8> {
        let uniform = MaterialUniform::new(
            self.albedo,
            self.emissive,
            self.metallic,
            self.roughness,
            self.alpha_cutoff(),
            0.0,
            self.pipeline_key().feature_bits,
        );
        bytemuck::bytes_of(&uniform).to_vec()
    }
}

impl GpuMaterial for UnlitMaterial {
    fn to_uniform_bytes(&self) -> Vec<u8> {
        let uniform = MaterialUniform::new(
            self.color,
            Vec3::ZERO,
            0.0,
            1.0,
            self.alpha_cutoff(),
            1.0,
            self.pipeline_key().feature_bits,
        );
        bytemuck::bytes_of(&uniform).to_vec()
    }
}

impl GpuMaterial for LambertMaterial {
    fn to_uniform_bytes(&self) -> Vec<u8> {
        let uniform = MaterialUniform::new(
            self.color,
            self.emissive,
            0.0,
            1.0,
            self.alpha_cutoff(),
            2.0,
            self.pipeline_key().feature_bits,
        );
        bytemuck::bytes_of(&uniform).to_vec()
    }
}