Struct MeshAllocator 

pub struct MeshAllocator { /* private fields */ }

Manages the assignment of mesh data to GPU buffers.

The Bevy renderer tries to pack vertex and index data for multiple meshes together so that multiple meshes can be drawn back-to-back without any rebinding. This resource manages these buffers.

The MeshAllocatorSettings allows you to tune the behavior of the allocator for better performance with your use case. Most applications won’t need to change the settings from their default values.

Implementations

impl MeshAllocator

pub fn mesh_vertex_slice( &self, mesh_id: &AssetId<Mesh>, ) -> Option<MeshBufferSlice<'_>>

Returns the buffer and range within that buffer of the vertex data for the mesh with the given ID.

If the mesh wasn’t allocated, returns None.

pub fn mesh_index_slice( &self, mesh_id: &AssetId<Mesh>, ) -> Option<MeshBufferSlice<'_>>

Returns the buffer and range within that buffer of the index data for the mesh with the given ID.

If the mesh has no index data or wasn’t allocated, returns None.

pub fn mesh_slabs(&self, mesh_id: &AssetId<Mesh>) -> Option<MeshSlabs>

Returns the IDs of the vertex buffer and index buffer respectively for the mesh with the given ID.

If the mesh wasn’t allocated, or has no index data in the case of the index buffer, the corresponding element in the returned tuple will be None.

pub fn index_allocation_count(&self) -> usize

Returns the number of index allocations that this mesh allocator manages.

Methods from Deref<Target = SlabAllocator<MeshSlabItem>>

pub fn stage_allocation(&mut self) -> AllocationStage<'_, I>

Creates an AllocationStage, enabling batched allocation of objects in this slab.

Allocation of objects in the slab requires calling this function, calling AllocationStage::allocate on the resulting AllocationStage, and finally calling AllocationStage::commit. Grouping allocations into a batch, preferably at most one per frame, is the most efficient way to perform many allocations at once.

pub fn stage_deallocation(&mut self) -> DeallocationStage<'_, I>

Creates a DeallocationStage, enabling batched deallocation.

Deallocation of objects in the slab requires calling this function, calling DeallocationStage::free on the resulting DeallocationStage, and finally calling DeallocationStage::commit. Grouping deallocations into a batch, preferably at most one per frame, is the most efficient way to perform many deallocations at once.

pub fn buffer_for_slab(&self, slab_id: SlabId<I>) -> Option<&Buffer>

Returns the GPU buffer corresponding to the slab with the given ID if that slab has been uploaded to the GPU.

pub fn slab_allocation_slice( &self, key: &I::Key, slab_id: SlabId<I>, ) -> Option<SlabAllocationBufferSlice<'_, I>>

Given a slab and the key of data located with it, returns the buffer and range of that data within the slab.

pub fn slab_count(&self) -> usize

Get the number of allocated slabs

pub fn slabs_size(&self) -> u64

Get the total size of all allocated slabs

pub fn copy_element_data( &mut self, key: &I::Key, len: usize, fill_data: impl Fn(WriteOnly<'_, [u8]>), render_device: &RenderDevice, render_queue: &RenderQueue, )

Copies data into an allocated slab.

len specifies the size of the data to be copied in bytes. The given fill_data callback is expected to write the data into the given slice; this callback approach avoids a copy.

Trait Implementations

impl Component for MeshAllocator

where Self: 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<Self>>

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 Deref for MeshAllocator

type Target = SlabAllocator<MeshSlabItem>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for MeshAllocator

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl FromWorld for MeshAllocator

fn from_world(world: &mut World) -> Self

Creates Self using data from the given World.

impl Resource for MeshAllocator

where Self: Send + Sync + 'static,