Struct ViewTarget 

pub struct ViewTarget {
    pub compositing_space: Option<CompositingSpace>,
    /* private fields */
}

Fields

compositing_space: Option<CompositingSpace>

Color space of values stored in the main texture (for blit conversion to output)

Implementations

impl ViewTarget

pub const TEXTURE_FORMAT_HDR: TextureFormat = TextureFormat::Rgba16Float

👎Deprecated:

Use ExtractedView::target_format where possible. Bevy does not encourage a default HDR TextureFormat anymore. If you really need this, use TextureFormat::Rgba16Float

pub fn get_color_attachment(&self) -> RenderPassColorAttachment<'_>

Retrieve this target’s main texture’s color attachment.

Examples found in repository

examples/shader_advanced/custom_render_phase.rs (line 672)

fn custom_draw_system(
    world: &World,
    view: ViewQuery<(
        &ExtractedCamera,
        &ExtractedView,
        &ViewTarget,
        Option<&MainPassResolutionOverride>,
    )>,
    stencil_phases: Res<ViewSortedRenderPhases<Stencil3d>>,
    mut ctx: RenderContext,
) {
    let view_entity = view.entity();
    let (camera, extracted_view, target, resolution_override) = view.into_inner();

    let Some(stencil_phase) = stencil_phases.get(&extracted_view.retained_view_entity) else {
        return;
    };

    let mut render_pass = ctx.begin_tracked_render_pass(RenderPassDescriptor {
        label: Some("stencil pass"),
        // For the purpose of the example, we will write directly to the view target. A real
        // stencil pass would write to a custom texture and that texture would be used in later
        // passes to render custom effects using it.
        color_attachments: &[Some(target.get_color_attachment())],
        // We don't bind any depth buffer for this pass
        depth_stencil_attachment: None,
        timestamp_writes: None,
        occlusion_query_set: None,
        multiview_mask: None,
    });

    if let Some(viewport) =
        Viewport::from_viewport_and_override(camera.viewport.as_ref(), resolution_override)
    {
        render_pass.set_camera_viewport(&viewport);
    }

    if let Err(err) = stencil_phase.render(&mut render_pass, world, view_entity) {
        error!("Error encountered while rendering the stencil phase {err:?}");
    }
}

pub fn get_unsampled_color_attachment(&self) -> RenderPassColorAttachment<'_>

Retrieve this target’s “unsampled” main texture’s color attachment.

pub fn main_texture(&self) -> &Texture

The “main” unsampled texture.

pub fn main_texture_other(&self) -> &Texture

The other “main” unsampled texture. In most cases you should use Self::main_texture instead and never this. The textures will naturally be swapped when Self::post_process_write is called.

A use case for this is to be able to prepare a bind group for all main textures ahead of time.

pub fn main_texture_view(&self) -> &TextureView

The “main” unsampled texture.

pub fn main_texture_other_view(&self) -> &TextureView

The other “main” unsampled texture view. In most cases you should use Self::main_texture_view instead and never this. The textures will naturally be swapped when Self::post_process_write is called.

A use case for this is to be able to prepare a bind group for all main textures ahead of time.

pub fn sampled_main_texture(&self) -> Option<&Texture>

The “main” sampled texture.

pub fn sampled_main_texture_view(&self) -> Option<&TextureView>

The “main” sampled texture view.

pub fn main_texture_format(&self) -> TextureFormat

Currently bevy’s main texture format can be:

• If rendering to screen: For HDR, it’s Rgba16Float. For LDR, it’s Rgba8Unorm when CompositingSpace::Srgb, otherwise Rgba8UnormSrgb.
• If rendering to texture: the format is the same as texture view’s format.

pub fn out_texture(&self) -> Option<&TextureView>

The final texture this view will render to.

pub fn out_texture_color_attachment( &self, clear_color: Option<LinearRgba>, ) -> Option<RenderPassColorAttachment<'_>>

The final texture this view will render to, as a color attachment.

pub fn needs_present(&self) -> bool

Whether the final texture this view will render to needs to be presented.

pub fn out_texture_view_format(&self) -> Option<TextureFormat>

The format of the final texture this view will render to, if any.

pub fn post_process_write(&self) -> PostProcessWrite<'_>

This will start a new “post process write”, which assumes that the caller will write the PostProcessWrite’s source to the destination.

source is the “current” main texture. This will internally flip this ViewTarget’s main texture to the destination texture, so the caller must ensure source is copied to destination, with or without modifications. Failing to do so will cause the current main texture information to be lost.

Examples found in repository

examples/shader_advanced/custom_post_processing.rs (line 109)

fn post_process_system(
    view: ViewQuery<(
        &ViewTarget,
        &PostProcessSettings,
        &DynamicUniformIndex<PostProcessSettings>,
    )>,
    post_process_pipeline: Option<Res<PostProcessPipeline>>,
    pipeline_cache: Res<PipelineCache>,
    settings_uniforms: Res<ComponentUniforms<PostProcessSettings>>,
    mut cache: Local<PostProcessBindGroupCache>,
    mut ctx: RenderContext,
) {
    let Some(post_process_pipeline) = post_process_pipeline else {
        return;
    };

    let (view_target, _post_process_settings, settings_index) = view.into_inner();

    let Some(pipeline) = pipeline_cache.get_render_pipeline(post_process_pipeline.pipeline_id)
    else {
        return;
    };

    let Some(settings_binding) = settings_uniforms.uniforms().binding() else {
        return;
    };

    // This will start a new "post process write", obtaining two texture
    // views from the view target - a `source` and a `destination`.
    // `source` is the "current" main texture and you _must_ write into
    // `destination` because calling `post_process_write()` on the
    // [`ViewTarget`] will internally flip the [`ViewTarget`]'s main
    // texture to the `destination` texture. Failing to do so will cause
    // the current main texture information to be lost.
    let post_process = view_target.post_process_write();

    let bind_group = match &mut cache.cached {
        Some((texture_id, bind_group)) if post_process.source.id() == *texture_id => bind_group,
        cached => {
            // The bind_group gets created each frame.
            //
            // Normally, you would create a bind_group in the Queue set,
            // but this doesn't work with the post_process_write().
            // The reason it doesn't work is because each post_process_write will alternate the source/destination.
            // The only way to have the correct source/destination for the bind_group
            // is to make sure you get it during the node execution.
            let bind_group = ctx.render_device().create_bind_group(
                "post_process_bind_group",
                &pipeline_cache.get_bind_group_layout(&post_process_pipeline.layout),
                // It's important for this to match the BindGroupLayout defined in the PostProcessPipeline
                &BindGroupEntries::sequential((
                    // Make sure to use the source view
                    post_process.source,
                    // Use the sampler created for the pipeline
                    &post_process_pipeline.sampler,
                    // Set the settings binding
                    settings_binding.clone(),
                )),
            );

            let (_, bind_group) = cached.insert((post_process.source.id(), bind_group));
            bind_group
        }
    };

    let mut render_pass = ctx
        .command_encoder()
        .begin_render_pass(&RenderPassDescriptor {
            label: Some("post_process_pass"),
            color_attachments: &[Some(RenderPassColorAttachment {
                // We need to specify the post process destination view here
                // to make sure we write to the appropriate texture.
                view: post_process.destination,
                depth_slice: None,
                resolve_target: None,
                ops: Operations::default(),
            })],
            depth_stencil_attachment: None,
            timestamp_writes: None,
            occlusion_query_set: None,
            multiview_mask: None,
        });

    render_pass.set_pipeline(pipeline);
    // By passing in the index of the post process settings on this view, we ensure
    // that in the event that multiple settings were sent to the GPU (as would be the
    // case with multiple cameras), we use the correct one.
    render_pass.set_bind_group(0, bind_group, &[settings_index.index()]);
    render_pass.draw(0..3, 0..1);
}

Trait Implementations

impl Clone for ViewTarget

fn clone(&self) -> ViewTarget

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Component for ViewTarget

where ViewTarget: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have Component<Mutability = Mutable>, while immutable components will instead have Component<Mutability = Immutable>.

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<ViewTarget>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_discard() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_discard ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]