Struct MeshPipeline

pub struct MeshPipeline {
    pub view_layouts: MeshPipelineViewLayouts,
    pub dummy_white_gpu_image: GpuImage,
    pub clustered_forward_buffer_binding_type: BufferBindingType,
    pub mesh_layouts: MeshLayouts,
    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,
}

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

Fields

view_layouts: MeshPipelineViewLayouts

A reference to all the mesh pipeline view layouts.

dummy_white_gpu_image: GpuImage

clustered_forward_buffer_binding_type: BufferBindingType

mesh_layouts: MeshLayouts

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:

##ifdef PER_OBJECT_BUFFER_BATCH_SIZE
@group(1) @binding(0) var<uniform> mesh: array<Mesh, #{PER_OBJECT_BUFFER_BATCH_SIZE}u>;
##else
@group(1) @binding(0) var<storage> mesh: array<Mesh>;
##endif // PER_OBJECT_BUFFER_BATCH_SIZE

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.

Implementations

impl MeshPipeline

pub fn get_image_texture<'a>( &'a self, gpu_images: &'a RenderAssets<GpuImage>, handle_option: &Option<Handle<Image>>, ) -> Option<(&'a TextureView, &'a Sampler)>

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

Trait Implementations

impl Clone for MeshPipeline

fn clone(&self) -> MeshPipeline

Returns a copy of the value.

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

Performs copy-assignment from source.

impl FromWorld for MeshPipeline

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

Creates Self using data from the given World.

impl GetBatchData for MeshPipeline

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

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

type CompareData = (MaterialBindGroupIndex, AssetId<Mesh>, Option<LightmapSlabIndex>)

Data used for comparison between phase items. If the pipeline id, draw function id, per-instance data buffer dynamic offset and this data matches, the draws 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( (mesh_instances, lightmaps, _, mesh_allocator, skin_uniforms): &SystemParamItem<'_, '_, Self::Param>, (_entity, main_entity): (Entity, MainEntity), ) -> Option<(Self::BufferData, Option<Self::CompareData>)>

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( (mesh_instances, lightmaps, _, _, _): &SystemParamItem<'_, '_, Self::Param>, main_entity: MainEntity, ) -> Option<(NonMaxU32, Option<Self::CompareData>)>

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

fn get_binned_batch_data( (mesh_instances, lightmaps, _, mesh_allocator, skin_uniforms): &SystemParamItem<'_, '_, Self::Param>, main_entity: MainEntity, ) -> Option<Self::BufferData>

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

fn get_binned_index( (mesh_instances, _, _, _, _): &SystemParamItem<'_, '_, Self::Param>, 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::IndirectParametersGpuMetadata necessary to draw this batch into the given metadata buffer at the given index.

impl SpecializedMeshPipeline for MeshPipeline

type Key = MeshPipelineKey

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

impl Resource for MeshPipeline

where Self: Send + Sync + 'static,