Struct BinnedRenderPhase

pub struct BinnedRenderPhase<BPI>
where
    BPI: BinnedPhaseItem,
{
    pub multidrawable_meshes: IndexMap<BPI::BatchSetKey, IndexMap<BPI::BinKey, RenderBin>>,
    pub batchable_meshes: IndexMap<(BPI::BatchSetKey, BPI::BinKey), RenderBin>,
    pub unbatchable_meshes: IndexMap<(BPI::BatchSetKey, BPI::BinKey), UnbatchableBinnedEntities>,
    pub non_mesh_items: IndexMap<(BPI::BatchSetKey, BPI::BinKey), NonMeshEntities>,
    /* private fields */
}

A collection of all rendering instructions, that will be executed by the GPU, for a single render phase for a single view.

Each view (camera, or shadow-casting light, etc.) can have one or multiple render phases. They are used to queue entities for rendering. Multiple phases might be required due to different sorting/batching behaviors (e.g. opaque: front to back, transparent: back to front) or because one phase depends on the rendered texture of the previous phase (e.g. for screen-space reflections). All PhaseItems are then rendered using a single TrackedRenderPass. The render pass might be reused for multiple phases to reduce GPU overhead.

This flavor of render phase is used for phases in which the ordering is less critical: for example, Opaque3d. It’s generally faster than the alternative SortedRenderPhase.

Fields

multidrawable_meshes: IndexMap<BPI::BatchSetKey, IndexMap<BPI::BinKey, RenderBin>>

The multidrawable bins.

Each batch set key maps to a batch set, which in this case is a set of meshes that can be drawn together in one multidraw call. Each batch set is subdivided into bins, each of which represents a particular mesh. Each bin contains the entity IDs of instances of that mesh.

So, for example, if there are two cubes and a sphere present in the scene, we would generally have one batch set containing two bins, assuming that the cubes and sphere meshes are allocated together and use the same pipeline. The first bin, corresponding to the cubes, will have two entities in it. The second bin, corresponding to the sphere, will have one entity in it.

batchable_meshes: IndexMap<(BPI::BatchSetKey, BPI::BinKey), RenderBin>

The bins corresponding to batchable items that aren’t multidrawable.

For multidrawable entities, use multidrawable_meshes; for unbatchable entities, use unbatchable_values.

unbatchable_meshes: IndexMap<(BPI::BatchSetKey, BPI::BinKey), UnbatchableBinnedEntities>

The unbatchable bins.

Each entity here is rendered in a separate drawcall.

non_mesh_items: IndexMap<(BPI::BatchSetKey, BPI::BinKey), NonMeshEntities>

Items in the bin that aren’t meshes at all.

Bevy itself doesn’t place anything in this list, but plugins or your app can in order to execute custom drawing commands. Draw functions for each entity are simply called in order at rendering time.

See the custom_phase_item example for an example of how to use this.

Implementations

impl<BPI> BinnedRenderPhase<BPI>

where BPI: BinnedPhaseItem,

pub fn add( &mut self, batch_set_key: BPI::BatchSetKey, bin_key: BPI::BinKey, (entity, main_entity): (Entity, MainEntity), input_uniform_index: InputUniformIndex, phase_type: BinnedRenderPhaseType, change_tick: Tick, )

Bins a new entity.

The phase_type parameter specifies whether the entity is a preprocessable mesh and whether it can be binned with meshes of the same type.

pub fn update_cache( &mut self, main_entity: MainEntity, cached_bin_key: Option<CachedBinKey<BPI>>, change_tick: Tick, )

Inserts an entity into the cache with the given change tick.

pub fn render<'w>( &self, render_pass: &mut TrackedRenderPass<'w>, world: &'w World, view: Entity, ) -> Result<(), DrawError>

Encodes the GPU commands needed to render all entities in this phase.

pub fn is_empty(&self) -> bool

pub fn prepare_for_new_frame(&mut self)

pub fn validate_cached_entity( &mut self, visible_entity: MainEntity, current_change_tick: Tick, ) -> bool

Checks to see whether the entity is in a bin and returns true if it’s both in a bin and up to date.

If this function returns true, we also add the entry to the valid_cached_entity_bin_keys list.

pub fn sweep_old_entities(&mut self)

Removes all entities not marked as clean from the bins.

During queue_material_meshes, we process all visible entities and mark each as clean as we come to it. Then, in sweep_old_entities, we call this method, which removes entities that aren’t marked as clean from the bins.