bevy_core_pipeline/prepass/
node.rs

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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
use bevy_ecs::{prelude::*, query::QueryItem};
use bevy_render::{
    camera::ExtractedCamera,
    diagnostic::RecordDiagnostics,
    render_graph::{NodeRunError, RenderGraphContext, ViewNode},
    render_phase::{TrackedRenderPass, ViewBinnedRenderPhases},
    render_resource::{CommandEncoderDescriptor, PipelineCache, RenderPassDescriptor, StoreOp},
    renderer::RenderContext,
    view::{ViewDepthTexture, ViewUniformOffset},
};
use bevy_utils::tracing::error;
#[cfg(feature = "trace")]
use bevy_utils::tracing::info_span;

use crate::skybox::prepass::{RenderSkyboxPrepassPipeline, SkyboxPrepassBindGroup};

use super::{
    AlphaMask3dPrepass, DeferredPrepass, Opaque3dPrepass, PreviousViewUniformOffset,
    ViewPrepassTextures,
};

/// Render node used by the prepass.
///
/// By default, inserted before the main pass in the render graph.
#[derive(Default)]
pub struct PrepassNode;

impl ViewNode for PrepassNode {
    type ViewQuery = (
        Entity,
        &'static ExtractedCamera,
        &'static ViewDepthTexture,
        &'static ViewPrepassTextures,
        &'static ViewUniformOffset,
        Option<&'static DeferredPrepass>,
        Option<&'static RenderSkyboxPrepassPipeline>,
        Option<&'static SkyboxPrepassBindGroup>,
        Option<&'static PreviousViewUniformOffset>,
    );

    fn run<'w>(
        &self,
        graph: &mut RenderGraphContext,
        render_context: &mut RenderContext<'w>,
        (
            view,
            camera,
            view_depth_texture,
            view_prepass_textures,
            view_uniform_offset,
            deferred_prepass,
            skybox_prepass_pipeline,
            skybox_prepass_bind_group,
            view_prev_uniform_offset,
        ): QueryItem<'w, Self::ViewQuery>,
        world: &'w World,
    ) -> Result<(), NodeRunError> {
        let (Some(opaque_prepass_phases), Some(alpha_mask_prepass_phases)) = (
            world.get_resource::<ViewBinnedRenderPhases<Opaque3dPrepass>>(),
            world.get_resource::<ViewBinnedRenderPhases<AlphaMask3dPrepass>>(),
        ) else {
            return Ok(());
        };

        let (Some(opaque_prepass_phase), Some(alpha_mask_prepass_phase)) = (
            opaque_prepass_phases.get(&view),
            alpha_mask_prepass_phases.get(&view),
        ) else {
            return Ok(());
        };

        let diagnostics = render_context.diagnostic_recorder();

        let mut color_attachments = vec![
            view_prepass_textures
                .normal
                .as_ref()
                .map(|normals_texture| normals_texture.get_attachment()),
            view_prepass_textures
                .motion_vectors
                .as_ref()
                .map(|motion_vectors_texture| motion_vectors_texture.get_attachment()),
            // Use None in place of deferred attachments
            None,
            None,
        ];

        // If all color attachments are none: clear the color attachment list so that no fragment shader is required
        if color_attachments.iter().all(Option::is_none) {
            color_attachments.clear();
        }

        let depth_stencil_attachment = Some(view_depth_texture.get_attachment(StoreOp::Store));

        let view_entity = graph.view_entity();
        render_context.add_command_buffer_generation_task(move |render_device| {
            #[cfg(feature = "trace")]
            let _prepass_span = info_span!("prepass").entered();

            // Command encoder setup
            let mut command_encoder =
                render_device.create_command_encoder(&CommandEncoderDescriptor {
                    label: Some("prepass_command_encoder"),
                });

            // Render pass setup
            let render_pass = command_encoder.begin_render_pass(&RenderPassDescriptor {
                label: Some("prepass"),
                color_attachments: &color_attachments,
                depth_stencil_attachment,
                timestamp_writes: None,
                occlusion_query_set: None,
            });

            let mut render_pass = TrackedRenderPass::new(&render_device, render_pass);
            let pass_span = diagnostics.pass_span(&mut render_pass, "prepass");

            if let Some(viewport) = camera.viewport.as_ref() {
                render_pass.set_camera_viewport(viewport);
            }

            // Opaque draws
            if !opaque_prepass_phase.batchable_mesh_keys.is_empty()
                || !opaque_prepass_phase.unbatchable_mesh_keys.is_empty()
            {
                #[cfg(feature = "trace")]
                let _opaque_prepass_span = info_span!("opaque_prepass").entered();
                if let Err(err) = opaque_prepass_phase.render(&mut render_pass, world, view_entity)
                {
                    error!("Error encountered while rendering the opaque prepass phase {err:?}");
                }
            }

            // Alpha masked draws
            if !alpha_mask_prepass_phase.is_empty() {
                #[cfg(feature = "trace")]
                let _alpha_mask_prepass_span = info_span!("alpha_mask_prepass").entered();
                if let Err(err) =
                    alpha_mask_prepass_phase.render(&mut render_pass, world, view_entity)
                {
                    error!(
                        "Error encountered while rendering the alpha mask prepass phase {err:?}"
                    );
                }
            }

            // Skybox draw using a fullscreen triangle
            if let (
                Some(skybox_prepass_pipeline),
                Some(skybox_prepass_bind_group),
                Some(view_prev_uniform_offset),
            ) = (
                skybox_prepass_pipeline,
                skybox_prepass_bind_group,
                view_prev_uniform_offset,
            ) {
                let pipeline_cache = world.resource::<PipelineCache>();
                if let Some(pipeline) =
                    pipeline_cache.get_render_pipeline(skybox_prepass_pipeline.0)
                {
                    render_pass.set_render_pipeline(pipeline);
                    render_pass.set_bind_group(
                        0,
                        &skybox_prepass_bind_group.0,
                        &[view_uniform_offset.offset, view_prev_uniform_offset.offset],
                    );
                    render_pass.draw(0..3, 0..1);
                }
            }

            pass_span.end(&mut render_pass);
            drop(render_pass);

            // After rendering to the view depth texture, copy it to the prepass depth texture if deferred isn't going to
            if deferred_prepass.is_none() {
                if let Some(prepass_depth_texture) = &view_prepass_textures.depth {
                    command_encoder.copy_texture_to_texture(
                        view_depth_texture.texture.as_image_copy(),
                        prepass_depth_texture.texture.texture.as_image_copy(),
                        view_prepass_textures.size,
                    );
                }
            }

            command_encoder.finish()
        });

        Ok(())
    }
}