Struct MeshPipeline 

pub struct MeshPipeline {
    pub view_layouts: MeshPipelineViewLayouts,
    pub clustered_forward_buffer_binding_type: BufferBindingType,
    pub mesh_layouts: MeshLayouts,
    pub shader: Handle<Shader>,
    pub per_object_buffer_batch_size: Option<u32>,
    pub binding_arrays_are_usable: bool,
    pub clustered_decals_are_usable: bool,
    pub skins_use_uniform_buffers: bool,
    pub metadata_use_uniform_buffers: bool,
}

All data needed to construct a pipeline for rendering 3D meshes.

Fields

view_layouts: MeshPipelineViewLayouts

A reference to all the mesh pipeline view layouts.

clustered_forward_buffer_binding_type: BufferBindingType

mesh_layouts: MeshLayouts

shader: Handle<Shader>

The shader asset handle.

per_object_buffer_batch_size: Option<u32>

MeshUniforms are stored in arrays in buffers. If storage buffers are available, they are used and this will be None, otherwise uniform buffers will be used with batches of this many MeshUniforms, stored at dynamic offsets within the uniform buffer. Use code like this in custom shaders:

@if(PER_OBJECT_BUFFER_BATCH_SIZE)
@group(1) @binding(0) var<uniform> mesh: array<Mesh, u32(constants::PER_OBJECT_BUFFER_BATCH_SIZE)>;
@else
@group(1) @binding(0) var<storage> mesh: array<Mesh>;

binding_arrays_are_usable: bool

Whether binding arrays (a.k.a. bindless textures) are usable on the current render device.

This affects whether reflection probes can be used.

clustered_decals_are_usable: bool

Whether clustered decals are usable on the current render device.

skins_use_uniform_buffers: bool

Whether skins will use uniform buffers on account of storage buffers being unavailable on this platform.

metadata_use_uniform_buffers: bool

Whether mesh metadata will use uniform buffers on account of storage buffers being unavailable on this platform.

Implementations

impl MeshPipeline

pub fn get_view_layout( &self, layout_key: MeshPipelineViewLayoutKey, ) -> MeshPipelineViewLayout

Trait Implementations

impl Clone for MeshPipeline

fn clone(&self) -> MeshPipeline

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for MeshPipeline

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

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]

const HAS_SUMMARY_TICK: bool = false

Set this constant to true if the component should track a summary tick.

impl GetBatchData for MeshPipeline

type Param = (Res<'static, RenderMeshInstances>, Res<'static, RenderLightmaps>, Res<'static, MeshAllocator>, Res<'static, SkinUniforms>, Res<'static, MorphIndices>)

The system parameters GetBatchData::get_batch_data needs in order to compute the batch data.

type BatchSetCompareData = MeshBatchSetCompareData

Data used for comparison between phase items to decide whether items can be grouped in the same batch set (i.e. multi-drawn).

type BatchCompareData = AssetId<Mesh>

Data used for comparison between phase items to decide whether items can be batched.

type BufferData = MeshUniform

The per-instance data to be inserted into the crate::render_resource::GpuArrayBuffer containing these data for all instances.

fn get_batch_data( _: &<<MeshPipeline as GetBatchData>::Param as SystemParam>::Item<'_, '_>, _: (Entity, MainEntity), ) -> Option<(<MeshPipeline as GetBatchData>::BufferData, Option<(<MeshPipeline as GetBatchData>::BatchSetCompareData, <MeshPipeline as GetBatchData>::BatchCompareData)>)>

Get the per-instance data to be inserted into the crate::render_resource::GpuArrayBuffer. If the instance can be batched, also return the data used for comparison when deciding whether draws can be batched, else return None for the CompareData.

impl GetFullBatchData for MeshPipeline

type BufferInputData = MeshInputUniform

The per-instance data that was inserted into the crate::render_resource::BufferVec during extraction.

fn get_index_and_compare_data( _: &<<MeshPipeline as GetBatchData>::Param as SystemParam>::Item<'_, '_>, main_entity: MainEntity, ) -> Option<(NonMaxU32, Option<(<MeshPipeline as GetBatchData>::BatchSetCompareData, <MeshPipeline as GetBatchData>::BatchCompareData)>)>

Returns the index of the GetFullBatchData::BufferInputData that the GPU preprocessing phase will use.

fn get_binned_batch_data( _: &<<MeshPipeline as GetBatchData>::Param as SystemParam>::Item<'_, '_>, main_entity: MainEntity, ) -> Option<<MeshPipeline as GetBatchData>::BufferData>

Get the per-instance data to be inserted into the crate::render_resource::GpuArrayBuffer.

fn get_binned_index( _: &<<MeshPipeline as GetBatchData>::Param as SystemParam>::Item<'_, '_>, main_entity: MainEntity, ) -> Option<NonMaxU32>

Returns the index of the GetFullBatchData::BufferInputData that the GPU preprocessing phase will use.

fn write_batch_indirect_parameters_metadata( indexed: bool, base_output_index: u32, batch_set_index: Option<NonMaxU32>, phase_indirect_parameters_buffers: &mut UntypedPhaseIndirectParametersBuffers, indirect_parameters_offset: u32, )

Writes the gpu_preprocessing::IndirectParametersMetadata necessary to draw this batch into the given metadata buffer at the given index.

impl SpecializedMeshPipeline for MeshPipeline

type Key = MeshPipelineKey

The key that defines each “variant” of the render pipeline.

fn specialize( &self, key: <MeshPipeline as SpecializedMeshPipeline>::Key, layout: &MeshVertexBufferLayoutRef, ) -> Result<RenderPipelineDescriptor, SpecializedMeshPipelineError>

Construct a new render pipeline based on the provided key and vertex layout.

impl Resource for MeshPipeline

where MeshPipeline: Send + Sync + 'static,