Struct PassSpanGuard 

pub struct PassSpanGuard<'a, R, P>
where
    R: ?Sized,
{ /* private fields */ }

Available on crate feature bevy_render only.

Guard returned by RecordDiagnostics::pass_span.

Will panic on drop unless PassSpanGuard::end is called.

Implementations

impl<R, P> PassSpanGuard<'_, R, P>

where R: RecordDiagnostics + ?Sized, P: Pass,

pub fn end(self, pass: &mut P)

End the span. You have to provide the same pass which was used to begin the span.

Examples found in repository

examples/2d/mesh2d_manual.rs (line 696)

fn main_colored_transparent_pass_2d(
    world: &World,
    view: ViewQuery<(
        &ExtractedCamera,
        &ExtractedView,
        &ViewTarget,
        &ViewDepthStencilTexture,
    )>,
    transparent_phases: Res<ViewSortedRenderPhases<TransparentColoredMesh2d>>,
    mut ctx: RenderContext,
) {
    let view_entity = view.entity();
    let (camera, extracted_view, target, depth) = view.into_inner();

    let Some(transparent_phase) = transparent_phases.get(&extracted_view.retained_view_entity)
    else {
        return;
    };

    #[cfg(feature = "trace")]
    let _span = info_span!("main_colored_transparent_pass_2d").entered();

    let diagnostics = ctx.diagnostic_recorder();
    let diagnostics = diagnostics.as_deref();

    let color_attachments = [Some(target.get_color_attachment())];
    // NOTE: For the transparent pass we load the depth buffer. There should be no
    // need to write to it, but store is set to `true` as a workaround for issue #3776,
    // https://github.com/bevyengine/bevy/issues/3776
    // so that wgpu does not clear the depth buffer.
    // As the opaque and alpha mask passes run first, opaque meshes can occlude
    // transparent ones.
    let depth_stencil_attachment = Some(depth.get_attachment(StoreOp::Store));

    {
        let mut render_pass = ctx.begin_tracked_render_pass(RenderPassDescriptor {
            label: Some("main_colored_transparent_pass_2d"),
            color_attachments: &color_attachments,
            depth_stencil_attachment,
            timestamp_writes: None,
            occlusion_query_set: None,
            multiview_mask: None,
        });
        let pass_span = diagnostics.pass_span(&mut render_pass, "main_colored_transparent_pass_2d");

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

        if !transparent_phase.items.is_empty() {
            #[cfg(feature = "trace")]
            let _transparent_span = info_span!("colored_transparent_main_pass_2d").entered();
            if let Err(err) = transparent_phase.render(&mut render_pass, world, view_entity) {
                error!(
                    "Error encountered while rendering the colored transparent 2D phase {err:?}"
                );
            }
        }

        pass_span.end(&mut render_pass);
    }
}

Trait Implementations

impl<R, P> Drop for PassSpanGuard<'_, R, P>

where R: ?Sized,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.