Struct DirtySpecializations 

pub struct DirtySpecializations {
    pub changed_renderables: HashSet<MainEntity, EntityHash>,
    pub removed_renderables: HashSet<MainEntity, EntityHash>,
    pub views: HashSet<RetainedViewEntity>,
}

Stores information about all entities that have changed in such a way as to potentially require their pipelines to be re-specialized.

This is conservative; there’s no harm, other than performance, in having an entity in this list that doesn’t actually need to be re-specialized. Note that the presence of an entity in this list doesn’t mean that a new shader will necessarily be compiled; the pipeline cache is checked first.

This handles 2D meshes, 3D meshes, and sprites. For 2D and 3D wireframes, see DirtyWireframeSpecializations. The reason for having two separate lists is that a single entity can have both a mesh and a wireframe.

Fields

changed_renderables: HashSet<MainEntity, EntityHash>

All renderable objects that must be re-specialized this frame.

removed_renderables: HashSet<MainEntity, EntityHash>

All renderable objects that need their specializations removed this frame.

Note that this may include entities in Self::changed_renderables. This is fine, as old specializations are removed before new ones are added.

views: HashSet<RetainedViewEntity>

Views that must be respecialized this frame.

The presence of a view in this list causes all entities that it renders to be re-specialized.

Implementations

impl DirtySpecializations

pub fn must_wipe_specializations_for_view( &self, view: RetainedViewEntity, ) -> bool

Returns true if the view has changed in such a way that all specialized pipelines for entities visible from it must be regenerated.

pub fn iter_to_despecialize<'a>( &'a self, ) -> impl Iterator<Item = &'a MainEntity>

Iterates over all entities that need their specializations cleared in this frame.

pub fn iter_to_specialize<'a>( &'a self, view: RetainedViewEntity, render_view_visible_mesh_entities: &'a RenderVisibleEntitiesClass, last_frame_view_pending_queues: &'a HashSet<(Entity, MainEntity)>, ) -> impl Iterator<Item = (&'a Entity, &'a MainEntity)>

Iterates over all entities that need to have their pipelines re-specialized this frame.

last_frame_view_pending_queues should be the contents of the ViewPendingQueues::prev_frame list.

pub fn iter_to_dequeue<'a>( &'a self, view: RetainedViewEntity, render_visible_mesh_entities: &'a RenderVisibleEntitiesClass, ) -> impl Iterator<Item = &'a MainEntity>

Iterates over all renderables that should be removed from the phase.

This includes renderables that became invisible this frame, renderables that are in DirtySpecializations::changed_renderables, and renderables that are in DirtySpecializations::removed_renderables. If this view must itself be re-specialized, this will iterate over all visible entities in addition to those that became invisible.

pub fn iter_to_queue<'a>( &'a self, view: RetainedViewEntity, render_visible_mesh_entities: &'a RenderVisibleEntitiesClass, last_frame_view_pending_queues: &'a HashSet<(Entity, MainEntity)>, ) -> impl Iterator<Item = (&'a Entity, &'a MainEntity)>

Iterates over all renderables that potentially need to be re-queued.

This includes both renderables that became visible and those that are in DirtySpecializations::changed_renderables. If this view must itself be re-specialized, this will iterate over all visible renderables.

last_frame_view_pending_queues should be the contents of the ViewPendingQueues::prev_frame list.

Trait Implementations

impl Clone for DirtySpecializations

fn clone(&self) -> DirtySpecializations

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for DirtySpecializations

where DirtySpecializations: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::SparseSet

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<DirtySpecializations>>

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]

impl Default for DirtySpecializations

fn default() -> DirtySpecializations

Returns the “default value” for a type.

impl Resource for DirtySpecializations

where DirtySpecializations: Send + Sync + 'static,