Struct TransparentUi 

pub struct TransparentUi {
    pub sort_key: FloatOrd,
    pub entity: (Entity, MainEntity),
    pub pipeline: CachedRenderPipelineId,
    pub draw_function: DrawFunctionId,
    pub batch_range: Range<u32>,
    pub extra_index: PhaseItemExtraIndex,
    pub index: usize,
    pub indexed: bool,
}

Fields

sort_key: FloatOrd

entity: (Entity, MainEntity)

pipeline: CachedRenderPipelineId

draw_function: DrawFunctionId

batch_range: Range<u32>

extra_index: PhaseItemExtraIndex

index: usize

indexed: bool

Trait Implementations

impl CachedRenderPipelinePhaseItem for TransparentUi

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 TransparentUi

fn entity(&self) -> Entity

The corresponding entity that will be drawn.

fn main_entity(&self) -> MainEntity

The main world entity represented by this PhaseItem.

fn draw_function(&self) -> DrawFunctionId

Specifies the Draw function used to render the item.

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 extra_index(&self) -> PhaseItemExtraIndex

Returns the PhaseItemExtraIndex.

fn batch_range_and_extra_index_mut( &mut self, ) -> (&mut Range<u32>, &mut PhaseItemExtraIndex)

Returns a pair of mutable references to both the batch range and extra index.

const AUTOMATIC_BATCHING: bool = true

Whether or not this PhaseItem should be subjected to automatic batching. (Default: true)

impl SortedPhaseItem for TransparentUi

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 sort_key(&self) -> Self::SortKey

Determines the order in which the items are drawn.

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 an unstable sort, as this provides the best balance of CPU and GPU performance.

fn indexed(&self) -> bool

Whether this phase item targets indexed meshes (those with both vertex and index buffers as opposed to just vertex buffers).