scena 1.5.1

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

use super::materials::MaterialResources;
use super::pipeline::{ColorLoad, DrawFilter, UnlitPass, encode_unlit_pass};
use super::vertices::PrimitiveDrawBatch;

pub(super) struct SceneColorPasses<'a> {
    pub(super) final_view: &'a wgpu::TextureView,
    pub(super) final_pipeline: &'a wgpu::RenderPipeline,
    pub(super) depth_view: Option<&'a wgpu::TextureView>,
    pub(super) vertex_buffer: &'a wgpu::Buffer,
    pub(super) output_bind_group: &'a wgpu::BindGroup,
    pub(super) opaque_output_bind_group: &'a wgpu::BindGroup,
    pub(super) draw_bind_group: &'a wgpu::BindGroup,
    pub(super) material_resources: &'a MaterialResources,
    pub(super) draw_batches: &'a [PrimitiveDrawBatch],
    pub(super) transmission_view: &'a wgpu::TextureView,
    pub(super) transmission_pipeline: &'a wgpu::RenderPipeline,
    pub(super) clear_color: wgpu::Color,
    pub(super) base_label: &'static str,
}

pub(super) fn encode_scene_color_passes(
    encoder: &mut wgpu::CommandEncoder,
    passes: SceneColorPasses<'_>,
) {
    if has_transparent_batches(passes.draw_batches) {
        encode_unlit_pass(
            encoder,
            UnlitPass {
                view: passes.transmission_view,
                depth_view: None,
                vertex_buffer: passes.vertex_buffer,
                output_bind_group: passes.opaque_output_bind_group,
                draw_bind_group: passes.draw_bind_group,
                material_resources: passes.material_resources,
                draw_batches: passes.draw_batches,
                pipeline: passes.transmission_pipeline,
                color_load: ColorLoad::Clear(passes.clear_color),
                draw_filter: DrawFilter::OpaqueOnly,
                label: "scena.transmission.scene_color_pass",
            },
        );
        encode_unlit_pass(
            encoder,
            UnlitPass {
                view: passes.final_view,
                depth_view: passes.depth_view,
                vertex_buffer: passes.vertex_buffer,
                output_bind_group: passes.output_bind_group,
                draw_bind_group: passes.draw_bind_group,
                material_resources: passes.material_resources,
                draw_batches: passes.draw_batches,
                pipeline: passes.final_pipeline,
                color_load: ColorLoad::Clear(passes.clear_color),
                draw_filter: DrawFilter::OpaqueOnly,
                label: "scena.final.opaque_pass",
            },
        );
        encode_unlit_pass(
            encoder,
            UnlitPass {
                view: passes.final_view,
                depth_view: passes.depth_view,
                vertex_buffer: passes.vertex_buffer,
                output_bind_group: passes.output_bind_group,
                draw_bind_group: passes.draw_bind_group,
                material_resources: passes.material_resources,
                draw_batches: passes.draw_batches,
                pipeline: passes.final_pipeline,
                color_load: ColorLoad::Load,
                draw_filter: DrawFilter::TransparentOnly,
                label: "scena.final.transparent_pass",
            },
        );
    } else {
        encode_unlit_pass(
            encoder,
            UnlitPass {
                view: passes.final_view,
                depth_view: passes.depth_view,
                vertex_buffer: passes.vertex_buffer,
                output_bind_group: passes.output_bind_group,
                draw_bind_group: passes.draw_bind_group,
                material_resources: passes.material_resources,
                draw_batches: passes.draw_batches,
                pipeline: passes.final_pipeline,
                color_load: ColorLoad::Clear(passes.clear_color),
                draw_filter: DrawFilter::All,
                label: passes.base_label,
            },
        );
    }
}

fn has_transparent_batches(draw_batches: &[PrimitiveDrawBatch]) -> bool {
    draw_batches
        .iter()
        .any(|batch| !batch.depth_prepass_eligible)
}