indicatrix 0.9.0

A physically-based spectral gemstone renderer that turns GemCAD-style cutting instructions into rendered output.
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

//! Pipeline cache and compilation management for the event wavefront kernels.

use std::collections::HashMap;

use super::kernels::EwKernel;

/// Standalone reduce kernel source: sums `out_xyz` per-sample values into per-pixel XYZ.
const REDUCE_SHADER_SRC: &str = include_str!("../../shaders/reduce_xyz.wgsl");

/// Lazy pipeline cache mapping `(EwKernel, material_class)` pairs to compiled `wgpu::ComputePipeline`s,
/// plus the eagerly built `reduce_pipeline`.
pub struct EwPipelines {
    pipelines: HashMap<(EwKernel, u32), wgpu::ComputePipeline>,
    reduce_pipeline: wgpu::ComputePipeline,
}

impl EwPipelines {
    /// Creates a new pipeline cache and compiles `reduce_xyz_main`.
    #[must_use]
    pub fn new(device: &wgpu::Device) -> Self {
        let reduce_pipeline = crate::renderer::gpu::compute::create_compute_pipeline_cached(
            device,
            None,
            "reduce_xyz_main",
            REDUCE_SHADER_SRC,
            "reduce_xyz_main",
            &[],
        );
        Self {
            pipelines: HashMap::new(),
            reduce_pipeline,
        }
    }

    /// Ensures that the pipeline for `(kernel, class)` is compiled and returns a reference to it.
    pub fn ensure(
        &mut self,
        device: &wgpu::Device,
        kernel: EwKernel,
        class: u32,
    ) -> &wgpu::ComputePipeline {
        self.pipelines.entry((kernel, class)).or_insert_with(|| {
            crate::renderer::gpu::compute::create_compute_pipeline_cached(
                device,
                None,
                kernel.entry_point(),
                kernel.source(),
                kernel.entry_point(),
                &[("MATERIAL_CLASS", f64::from(class))],
            )
        })
    }

    /// Retrieves an already-compiled compute pipeline.
    ///
    /// # Panics
    /// Panics if the pipeline was not compiled by [`Self::ensure`] first.
    #[must_use]
    pub fn get(&self, kernel: EwKernel, class: u32) -> &wgpu::ComputePipeline {
        self.pipelines
            .get(&(kernel, class))
            .unwrap_or_else(|| panic!("pipeline {kernel:?} (class {class}) was not compiled"))
    }

    /// Accessor for the shared `reduce_xyz_main` compute pipeline.
    #[must_use]
    pub const fn reduce_pipeline(&self) -> &wgpu::ComputePipeline {
        &self.reduce_pipeline
    }

    /// Returns an iterator over all compiled `(EwKernel, class)` pairs.
    pub fn compiled(&self) -> impl Iterator<Item = (EwKernel, u32)> + '_ {
        self.pipelines.keys().copied()
    }
}