scena 1.7.2

A Rust-native scene-graph renderer with typed scene state, glTF assets, and explicit prepare/render lifecycles.
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

use crate::diagnostics::RenderError;

use super::overlays::{OverlayPasses, encode_overlay_passes};
use super::{GpuPreparedResources, labels, strokes};
use crate::render::RasterTarget;

pub(super) fn resolved_depth_view(
    resources: &GpuPreparedResources,
    sample_count: u32,
) -> Option<&wgpu::TextureView> {
    if sample_count == 1 {
        resources.depth_prepass.as_ref().map(|depth| &depth.view)
    } else {
        resources
            .overlay_depth_prepass
            .as_ref()
            .map(|depth| &depth.view)
    }
}

pub(super) fn encode_offscreen_overlay_pass(
    encoder: &mut wgpu::CommandEncoder,
    resources: &GpuPreparedResources,
    view: &wgpu::TextureView,
    depth_view: Option<&wgpu::TextureView>,
    label: &'static str,
    draw_submissions: &mut u64,
) {
    encode_overlay_passes(
        encoder,
        OverlayPasses {
            view,
            depth_view,
            output_bind_group: &resources.output_bind_group,
            draw_bind_group: &resources.draw_bind_group,
            stroke_resources: resources.strokes.as_ref(),
            stroke_pipeline: resources.strokes.as_ref().map(|resources| {
                if depth_view.is_some() {
                    strokes::pipeline(resources)
                } else {
                    strokes::flat_pipeline(resources)
                }
            }),
            label_resources: resources.labels.as_ref(),
            label_pipeline: resources.labels.as_ref().map(|resources| {
                if depth_view.is_some() {
                    labels::pipeline(resources)
                } else {
                    labels::flat_pipeline(resources)
                }
            }),
            label,
            draw_submissions,
        },
    );
}

pub(super) fn encode_surface_overlay_pass(
    encoder: &mut wgpu::CommandEncoder,
    resources: &GpuPreparedResources,
    view: &wgpu::TextureView,
    depth_view: Option<&wgpu::TextureView>,
    label: &'static str,
    target: RasterTarget,
    draw_submissions: &mut u64,
) -> Result<(), RenderError> {
    let stroke_pipeline = match resources.strokes.as_ref() {
        Some(stroke_resources) => {
            let pipeline = if depth_view.is_some() {
                strokes::surface_pipeline(stroke_resources)
            } else {
                strokes::surface_flat_pipeline(stroke_resources)
            };
            Some(pipeline.ok_or(RenderError::GpuResourcesNotPrepared {
                backend: target.backend,
            })?)
        }
        None => None,
    };
    let label_pipeline = match resources.labels.as_ref() {
        Some(label_resources) => {
            let pipeline = if depth_view.is_some() {
                labels::surface_pipeline(label_resources)
            } else {
                labels::surface_flat_pipeline(label_resources)
            };
            Some(pipeline.ok_or(RenderError::GpuResourcesNotPrepared {
                backend: target.backend,
            })?)
        }
        None => None,
    };
    encode_overlay_passes(
        encoder,
        OverlayPasses {
            view,
            depth_view,
            output_bind_group: &resources.output_bind_group,
            draw_bind_group: &resources.draw_bind_group,
            stroke_resources: resources.strokes.as_ref(),
            stroke_pipeline,
            label_resources: resources.labels.as_ref(),
            label_pipeline,
            label,
            draw_submissions,
        },
    );
    Ok(())
}