soorat 1.0.0

Soorat — GPU rendering engine for AGNOS
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

//! GPU capability reporting — feature detection and limit queries.
//!
//! Re-exported from [`mabda`] — the shared GPU foundation.
//! Soorat adds [`SooratCapabilities`] for renderer-specific requirement checks.

pub use mabda::capabilities::{GpuCapabilities, webgpu};

/// Soorat-specific capability extensions.
pub trait SooratCapabilities {
    /// Check if the device meets minimum requirements for soorat rendering.
    fn meets_soorat_requirements(&self) -> bool;
}

impl SooratCapabilities for GpuCapabilities {
    fn meets_soorat_requirements(&self) -> bool {
        self.max_texture_dimension_2d >= 2048
            && self.max_uniform_buffer_size >= 16384
            && self.max_bind_groups >= 4
    }
}

/// Soorat-specific WebGPU compatibility checks.
pub mod soorat_webgpu {
    /// Check if soorat's current uniform sizes are WebGPU-compatible.
    #[must_use]
    pub fn check_soorat_uniforms() -> Vec<(&'static str, u32, bool)> {
        let checks = vec![
            (
                "CameraUniforms",
                std::mem::size_of::<crate::mesh_pipeline::CameraUniforms>() as u32,
            ),
            (
                "LightArrayUniforms",
                std::mem::size_of::<crate::lights::LightArrayUniforms>() as u32,
            ),
            (
                "MaterialUniforms",
                std::mem::size_of::<crate::pbr_material::MaterialUniforms>() as u32,
            ),
            (
                "ShadowPassUniforms",
                std::mem::size_of::<crate::mesh_pipeline::ShadowPassUniforms>() as u32,
            ),
            (
                "CascadeUniforms",
                std::mem::size_of::<crate::shadow::CascadeUniforms>() as u32,
            ),
            (
                "PostProcessUniforms",
                std::mem::size_of::<crate::postprocess::PostProcessUniforms>() as u32,
            ),
            (
                "BloomUniforms",
                std::mem::size_of::<crate::hdr::BloomUniforms>() as u32,
            ),
            (
                "SsaoUniforms",
                std::mem::size_of::<crate::ssao::SsaoUniforms>() as u32,
            ),
        ];

        checks
            .into_iter()
            .map(|(name, size)| (name, size, mabda::capabilities::webgpu::uniform_fits(size)))
            .collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn webgpu_uniform_fits() {
        assert!(webgpu::uniform_fits(1024));
        assert!(webgpu::uniform_fits(65536));
        assert!(!webgpu::uniform_fits(65537));
    }

    #[test]
    fn webgpu_constants() {
        assert_eq!(webgpu::MAX_BIND_GROUPS, 4);
        assert_eq!(webgpu::MAX_UNIFORM_BUFFER, 65536);
    }

    #[test]
    fn soorat_uniforms_webgpu_compatible() {
        let checks = soorat_webgpu::check_soorat_uniforms();
        for (name, size, fits) in &checks {
            assert!(*fits, "{name} ({size} bytes) exceeds WebGPU uniform limit");
        }
    }

    #[test]
    fn gpu_capabilities_types() {
        let _size = std::mem::size_of::<GpuCapabilities>();
    }
}