molgfx-render 0.2.1

The render graph, passes and the engine that drives a frame.
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

//! GPU-resident temporal occupancy accumulation pipelines.

use crate::error::RenderError;
use molgfx_gpu::{
    Capabilities, ComputePipelineDesc, Device, GpuError, ShaderModuleDesc, TextureFormat,
};

/// The physical storage representation selected for temporal occupancy bounds.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub(crate) enum OccupancyBoundsFormat {
    /// Native two-channel min/max texture.
    Rg32Float,
    /// Portable four-channel texture with minimum and maximum in `.xy`.
    Rgba32Float,
}

impl OccupancyBoundsFormat {
    /// Resolves the occupancy implementation from normalized device capabilities.
    pub(crate) fn resolve(capabilities: &Capabilities) -> Result<Self, RenderError> {
        if !capabilities.r32float.sampled || !capabilities.r32float.storage_write {
            return Err(GpuError::Capability {
                name: "temporal occupancy r32float sampled storage texture",
            }
            .into());
        }
        if capabilities.rg32float.sampled && capabilities.rg32float.storage_write {
            return Ok(Self::Rg32Float);
        }
        if capabilities.rgba32float.sampled && capabilities.rgba32float.storage_write {
            return Ok(Self::Rgba32Float);
        }
        Err(GpuError::Capability {
            name: "temporal occupancy bounds sampled storage texture",
        }
        .into())
    }

    pub(crate) const fn texture_format(self) -> TextureFormat {
        match self {
            Self::Rg32Float => TextureFormat::Rg32Float,
            Self::Rgba32Float => TextureFormat::Rgba32Float,
        }
    }

    fn shader(self) -> &'static str {
        match self {
            Self::Rg32Float => molgfx_shaders::OCCUPANCY,
            Self::Rgba32Float => molgfx_shaders::OCCUPANCY_RGBA,
        }
    }
}

#[derive(Debug)]
pub(crate) struct OccupancyPass<D: Device> {
    pub(crate) clear: D::Pipeline,
    pub(crate) decay: D::Pipeline,
    pub(crate) deposit: D::Pipeline,
    pub(crate) resolve: D::Pipeline,
    pub(crate) bounds: D::Pipeline,
}

impl<D: Device> OccupancyPass<D> {
    pub(crate) fn new(
        device: &D,
        layout: &D::BindGroupLayout,
        format: OccupancyBoundsFormat,
    ) -> Result<Self, RenderError> {
        let shader = device.create_shader_module(&ShaderModuleDesc {
            label: "temporal occupancy accumulation",
            wgsl: format.shader(),
        })?;
        let pipeline = |label, entry| {
            device.create_compute_pipeline(&ComputePipelineDesc {
                label,
                layouts: &[Some(layout)],
                shader: &shader,
                entry,
            })
        };
        Ok(Self {
            clear: pipeline("clear temporal occupancy", "clear_occupancy")?,
            decay: pipeline("decay temporal occupancy", "decay_occupancy")?,
            deposit: pipeline("deposit temporal occupancy", "deposit_occupancy")?,
            resolve: pipeline("resolve temporal occupancy", "resolve_occupancy")?,
            bounds: pipeline(
                "resolve temporal occupancy bounds",
                "resolve_occupancy_bounds",
            )?,
        })
    }
}

#[cfg(test)]
#[path = "occupancy_tests.rs"]
mod tests;