Struct bevy::pbr::MeshPipeline

pub struct MeshPipeline {
    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,
    /* private fields */
}

Fields

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.

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) -> MeshPipeline

Creates Self using data from the given World.

impl GetBatchData for MeshPipeline

type Param = (Res<'static, RenderMeshInstances>, Res<'static, RenderLightmaps>, Res<'static, RenderAssets<GpuMesh>>)

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

type CompareData = (MaterialBindGroupId, AssetId<Mesh>, Option<AssetId<Image>>)

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( _: &<<MeshPipeline as GetBatchData>::Param as SystemParam>::Item<'_, '_>, entity: Entity ) -> Option<(<MeshPipeline as GetBatchData>::BufferData, Option<<MeshPipeline as GetBatchData>::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( _: &<<MeshPipeline as GetBatchData>::Param as SystemParam>::Item<'_, '_>, entity: Entity ) -> Option<(NonMaxU32, Option<<MeshPipeline as GetBatchData>::CompareData>)>

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<'_, '_>, entity: Entity ) -> 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<'_, '_>, entity: Entity ) -> Option<NonMaxU32>

Returns the index of the GetFullBatchData::BufferInputData that the GPU preprocessing phase will use, for the binning path.

fn get_batch_indirect_parameters_index( _: &<<MeshPipeline as GetBatchData>::Param as SystemParam>::Item<'_, '_>, indirect_parameters_buffer: &mut IndirectParametersBuffer, entity: Entity, instance_index: u32 ) -> Option<NonMaxU32>

Pushes gpu_preprocessing::IndirectParameters necessary to draw this batch onto the given IndirectParametersBuffer, and returns its index.

impl SpecializedMeshPipeline for MeshPipeline

type Key = MeshPipelineKey

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

impl Resource for MeshPipeline

where MeshPipeline: Send + Sync + 'static,