Struct bevy_internal::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<Image>, 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>)

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 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 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 SpecializedMeshPipeline for MeshPipeline

type Key = MeshPipelineKey

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

impl Resource for MeshPipeline

where MeshPipeline: Send + Sync + 'static,