Struct bevy_core_pipeline::core_3d::Transmissive3d

pub struct Transmissive3d {
    pub distance: f32,
    pub pipeline: CachedRenderPipelineId,
    pub entity: Entity,
    pub draw_function: DrawFunctionId,
    pub batch_range: Range<u32>,
    pub dynamic_offset: Option<NonMaxU32>,
}

Fields

distance: f32

pipeline: CachedRenderPipelineId

entity: Entity

draw_function: DrawFunctionId

batch_range: Range<u32>

dynamic_offset: Option<NonMaxU32>

Trait Implementations

impl CachedRenderPipelinePhaseItem for Transmissive3d

fn cached_pipeline(&self) -> CachedRenderPipelineId

The id of the render pipeline, cached in the PipelineCache, that will be used to draw this phase item.

impl PhaseItem for Transmissive3d

const AUTOMATIC_BATCHING: bool = false

For now, automatic batching is disabled for transmissive items because their rendering is split into multiple steps depending on Camera3d::screen_space_specular_transmission_steps, which the batching system doesn’t currently know about.

Having batching enabled would cause the same item to be drawn multiple times across different steps, whenever the batching range crossed a step boundary.

Eventually, we could add support for this by having the batching system break up the batch ranges using the same logic as the transmissive pass, but for now it’s simpler to just disable batching.

type SortKey = FloatOrd

The type used for ordering the items. The smallest values are drawn first. This order can be calculated using the ViewRangefinder3d, based on the view-space Z value of the corresponding view matrix.

fn entity(&self) -> Entity

The corresponding entity that will be drawn.

fn sort_key(&self) -> Self::SortKey

Determines the order in which the items are drawn.

fn draw_function(&self) -> DrawFunctionId

Specifies the Draw function used to render the item.

fn sort(items: &mut [Self])

Sorts a slice of phase items into render order. Generally if the same type is batched this should use a stable sort like slice::sort_by_key. In almost all other cases, this should not be altered from the default, which uses a unstable sort, as this provides the best balance of CPU and GPU performance.

fn batch_range(&self) -> &Range<u32>

The range of instances that the batch covers. After doing a batched draw, batch range length phase items will be skipped. This design is to avoid having to restructure the render phase unnecessarily.

fn batch_range_mut(&mut self) -> &mut Range<u32>

fn dynamic_offset(&self) -> Option<NonMaxU32>

fn dynamic_offset_mut(&mut self) -> &mut Option<NonMaxU32>