Struct bevy::render::render_resource::SpecializedMeshPipelines

pub struct SpecializedMeshPipelines<S>
where
    S: SpecializedMeshPipeline,
{ /* private fields */ }

Implementations

impl<S> SpecializedMeshPipelines<S>

where S: SpecializedMeshPipeline,

pub fn specialize( &mut self, cache: &PipelineCache, specialize_pipeline: &S, key: <S as SpecializedMeshPipeline>::Key, layout: &Hashed<InnerMeshVertexBufferLayout> ) -> Result<CachedRenderPipelineId, SpecializedMeshPipelineError>

Examples found in repository

examples/shader/shader_instancing.rs (line 138)

fn queue_custom(
    transparent_3d_draw_functions: Res<DrawFunctions<Transparent3d>>,
    custom_pipeline: Res<CustomPipeline>,
    msaa: Res<Msaa>,
    mut pipelines: ResMut<SpecializedMeshPipelines<CustomPipeline>>,
    pipeline_cache: Res<PipelineCache>,
    meshes: Res<RenderAssets<Mesh>>,
    render_mesh_instances: Res<RenderMeshInstances>,
    material_meshes: Query<Entity, With<InstanceMaterialData>>,
    mut views: Query<(&ExtractedView, &mut RenderPhase<Transparent3d>)>,
) {
    let draw_custom = transparent_3d_draw_functions.read().id::<DrawCustom>();

    let msaa_key = MeshPipelineKey::from_msaa_samples(msaa.samples());

    for (view, mut transparent_phase) in &mut views {
        let view_key = msaa_key | MeshPipelineKey::from_hdr(view.hdr);
        let rangefinder = view.rangefinder3d();
        for entity in &material_meshes {
            let Some(mesh_instance) = render_mesh_instances.get(&entity) else {
                continue;
            };
            let Some(mesh) = meshes.get(mesh_instance.mesh_asset_id) else {
                continue;
            };
            let key = view_key | MeshPipelineKey::from_primitive_topology(mesh.primitive_topology);
            let pipeline = pipelines
                .specialize(&pipeline_cache, &custom_pipeline, key, &mesh.layout)
                .unwrap();
            transparent_phase.add(Transparent3d {
                entity,
                pipeline,
                draw_function: draw_custom,
                distance: rangefinder
                    .distance_translation(&mesh_instance.transforms.transform.translation),
                batch_range: 0..1,
                dynamic_offset: None,
            });
        }
    }
}

Trait Implementations

impl<S> Default for SpecializedMeshPipelines<S>

where S: SpecializedMeshPipeline,

fn default() -> SpecializedMeshPipelines<S>

Returns the “default value” for a type.

impl<S> Resource for SpecializedMeshPipelines<S>

where S: SpecializedMeshPipeline, SpecializedMeshPipelines<S>: Send + Sync + 'static,