Struct PipelineCache 

pub struct PipelineCache { /* private fields */ }

Available on crate feature bevy_render only.

Cache for render and compute pipelines.

The cache stores existing render and compute pipelines allocated on the GPU, as well as pending creation. Pipelines inserted into the cache are identified by a unique ID, which can be used to retrieve the actual GPU object once it’s ready. The creation of the GPU pipeline object is deferred to the RenderSystems::Render step, just before the render graph starts being processed, as this requires access to the GPU.

Note that the cache does not perform automatic deduplication of identical pipelines. It is up to the user not to insert the same pipeline twice to avoid wasting GPU resources.

Implementations

impl PipelineCache

pub fn pipelines(&self) -> impl Iterator<Item = &CachedPipeline>

Returns an iterator over the pipelines in the pipeline cache.

pub fn waiting_pipelines(&self) -> impl Iterator<Item = usize>

Returns a iterator of the IDs of all currently waiting pipelines.

Examples found in repository

examples/showcase/loading_screen.rs (line 302)

    fn update_pipelines_ready(mut main_world: ResMut<MainWorld>, pipelines: Res<PipelineCache>) {
        if let Some(mut pipelines_ready) = main_world.get_resource_mut::<PipelinesReady>() {
            pipelines_ready.0 = pipelines.waiting_pipelines().count() == 0;
        }
    }

pub fn new( device: RenderDevice, synchronous_pipeline_compilation: bool, ) -> PipelineCache

Create a new pipeline cache associated with the given render device.

pub fn get_render_pipeline_state( &self, id: CachedRenderPipelineId, ) -> &CachedPipelineState

Get the state of a cached render pipeline.

See PipelineCache::queue_render_pipeline().

pub fn get_compute_pipeline_state( &self, id: CachedComputePipelineId, ) -> &CachedPipelineState

Get the state of a cached compute pipeline.

See PipelineCache::queue_compute_pipeline().

Examples found in repository

examples/shader/compute_shader_game_of_life.rs (line 229)

fn update(
    pipeline: Res<GameOfLifePipeline>,
    pipeline_cache: Res<PipelineCache>,
    mut state: ResMut<GameOfLifeState>,
) {
    // if the corresponding pipeline has loaded, transition to the next stage
    match *state {
        GameOfLifeState::Loading => {
            match pipeline_cache.get_compute_pipeline_state(pipeline.init_pipeline) {
                CachedPipelineState::Ok(_) => {
                    *state = GameOfLifeState::Init;
                }
                // If the shader hasn't loaded yet, just wait.
                CachedPipelineState::Err(ShaderCacheError::ShaderNotLoaded(_)) => {}
                CachedPipelineState::Err(err) => {
                    panic!("Initializing assets/{SHADER_ASSET_PATH}:\n{err}")
                }
                _ => {}
            }
        }
        GameOfLifeState::Init => {
            if let CachedPipelineState::Ok(_) =
                pipeline_cache.get_compute_pipeline_state(pipeline.update_pipeline)
            {
                *state = GameOfLifeState::Update(1);
            }
        }
        GameOfLifeState::Update(0) => {
            *state = GameOfLifeState::Update(1);
        }
        GameOfLifeState::Update(1) => {
            *state = GameOfLifeState::Update(0);
        }
        GameOfLifeState::Update(_) => unreachable!(),
    }
}

pub fn get_render_pipeline_descriptor( &self, id: CachedRenderPipelineId, ) -> &RenderPipelineDescriptor

Get the render pipeline descriptor a cached render pipeline was inserted from.

See PipelineCache::queue_render_pipeline().

Note: Be careful calling this method. It will panic if called with a pipeline that has been queued but has not yet been processed by PipelineCache::process_queue().

pub fn get_compute_pipeline_descriptor( &self, id: CachedComputePipelineId, ) -> &ComputePipelineDescriptor

Get the compute pipeline descriptor a cached render pipeline was inserted from.

See PipelineCache::queue_compute_pipeline().

Note: Be careful calling this method. It will panic if called with a pipeline that has been queued but has not yet been processed by PipelineCache::process_queue().

pub fn get_mesh_pipeline_descriptor( &self, id: CachedRenderPipelineId, ) -> &MeshPipelineDescriptor

Get the mesh pipeline descriptor a cached mesh pipeline was inserted from.

See PipelineCache::queue_mesh_pipeline().

Note: Be careful calling this method. It will panic if called with a pipeline that has been queued but has not yet been processed by PipelineCache::process_queue().

pub fn get_render_pipeline( &self, id: CachedRenderPipelineId, ) -> Option<&RenderPipeline>

Try to retrieve a render pipeline GPU object from a cached ID.

Returns

This method returns a successfully created render pipeline if any, or None if the pipeline was not created yet or if there was an error during creation. You can check the actual creation state with PipelineCache::get_render_pipeline_state().

Examples found in repository

examples/shader_advanced/mesh_shader_intro.rs (line 217)

fn draw_mesh_shader_cubes(
    mut views: Query<(
        &ExtractedCamera,
        &ExtractedView,
        &ViewTarget,
        &ViewDepthStencilTexture,
        &ViewUniformOffset,
        Option<&MainPassResolutionOverride>,
    )>,
    mut render_context: RenderContext,
    data: Res<MyMeshShaderDrawNode>,
    view_uniforms: Res<ViewUniforms>,
    globals: Res<GlobalsBuffer>,
    pipeline_cache: Res<PipelineCache>,
) {
    let Some(mesh_pipeline) = pipeline_cache.get_render_pipeline(data.mesh_pipeline) else {
        return;
    };

    for (camera, _, target, depth, view_uniform_offset, resolution_override) in &mut views {
        let Some(view_binding) = view_uniforms.uniforms.binding() else {
            return;
        };
        let Some(globals_binding) = globals.buffer.binding() else {
            return;
        };
        let bind_group = render_context.render_device().create_bind_group(
            "custom_task_mesh_bind_group",
            &pipeline_cache.get_bind_group_layout(&data.layout),
            &BindGroupEntries::sequential((globals_binding, view_binding)),
        );

        {
            let mut pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
                label: Some("custom_mesh_shader_pass"),
                // Write directly to the view target
                color_attachments: &[Some(target.get_color_attachment())],
                depth_stencil_attachment: Some(depth.get_attachment(StoreOp::Store)),
                timestamp_writes: None,
                occlusion_query_set: None,
                multiview_mask: None,
            });

            pass.set_render_pipeline(mesh_pipeline);
            pass.set_bind_group(0, &bind_group, &[view_uniform_offset.offset]);
            if let Some(viewport) =
                Viewport::from_viewport_and_override(camera.viewport.as_ref(), resolution_override)
            {
                pass.set_camera_viewport(&viewport);
            }

            // Since this MeshPipeline has a task shader, this call
            // dispatches the task shader workgroup
            pass.draw_mesh_tasks(1, 1, 1);
        }
    }
}

examples/shader_advanced/deferred_raymarch.rs (line 244)

fn raymarch_gbuffer_pass(
    view: ViewQuery<(
        &ViewUniformOffset,
        &ViewDepthStencilTexture,
        &ViewPrepassTextures,
    )>,
    pipeline: Option<Res<RaymarchGBufferPipeline>>,
    pipeline_cache: Res<PipelineCache>,
    view_uniforms: Res<ViewUniforms>,
    globals: Res<GlobalsBuffer>,
    mut ctx: RenderContext,
) {
    let Some(pipeline) = pipeline else {
        return;
    };
    let Some(render_pipeline) = pipeline_cache.get_render_pipeline(pipeline.pipeline_id) else {
        return;
    };

    let (view_uniform_offset, view_depth, view_prepass_textures) = view.into_inner();

    let (Some(deferred), Some(lighting_pass_id)) = (
        &view_prepass_textures.deferred,
        &view_prepass_textures.deferred_lighting_pass_id,
    ) else {
        return;
    };

    let Some(bind_group) = raymarch_bind_group(
        &ctx,
        &pipeline_cache,
        &pipeline.layout,
        &view_uniforms,
        &globals,
    ) else {
        return;
    };

    {
        // We load rather than clear because we only want to overwrite the pixels which the deferred mesh
        // prepass didn't write
        let mut pass = ctx.begin_tracked_render_pass(RenderPassDescriptor {
            label: Some("raymarch_gbuffer_pass"),
            color_attachments: &[
                Some(deferred.get_attachment()),
                Some(lighting_pass_id.get_attachment()),
            ],
            depth_stencil_attachment: Some(view_depth.get_attachment(StoreOp::Store)),
            timestamp_writes: None,
            occlusion_query_set: None,
            multiview_mask: None,
        });

        pass.set_render_pipeline(render_pipeline);
        pass.set_bind_group(0, &bind_group, &[view_uniform_offset.offset]);
        pass.draw(0..3, 0..1);
    }

    // The deferred lighting pass reconstructs world position from the prepass depth
    // texture, not the depth attachment we just wrote, so we have to do a copy.
    if let Some(prepass_depth) = &view_prepass_textures.depth {
        ctx.command_encoder().copy_texture_to_texture(
            view_depth.texture().as_image_copy(),
            prepass_depth.texture.texture.as_image_copy(),
            view_prepass_textures.size,
        );
    }
}

fn raymarch_directional_shadow_pass(
    view: ViewQuery<&ViewLightEntities>,
    shadow_views: Query<(&ShadowView, &ViewUniformOffset)>,
    pipeline: Option<Res<RaymarchShadowPipeline>>,
    pipeline_cache: Res<PipelineCache>,
    view_uniforms: Res<ViewUniforms>,
    globals: Res<GlobalsBuffer>,
    mut ctx: RenderContext,
) {
    let Some(pipeline) = pipeline else {
        return;
    };
    let Some(render_pipeline) = pipeline_cache.get_render_pipeline(pipeline.pipeline_id) else {
        return;
    };

    let view_lights = view.into_inner();
    for light_entity in view_lights.lights.iter().copied() {
        let Ok((shadow_view, view_uniform_offset)) = shadow_views.get(light_entity) else {
            continue;
        };
        draw_raymarch_shadow(
            &mut ctx,
            &pipeline_cache,
            &pipeline.layout,
            &view_uniforms,
            &globals,
            render_pipeline,
            shadow_view,
            view_uniform_offset,
        );
    }
}

fn raymarch_shared_shadow_pass(
    view: ViewQuery<(&ShadowView, &ViewUniformOffset)>,
    pipeline: Option<Res<RaymarchShadowPipeline>>,
    pipeline_cache: Res<PipelineCache>,
    view_uniforms: Res<ViewUniforms>,
    globals: Res<GlobalsBuffer>,
    mut ctx: RenderContext,
) {
    let Some(pipeline) = pipeline else {
        return;
    };
    let Some(render_pipeline) = pipeline_cache.get_render_pipeline(pipeline.pipeline_id) else {
        return;
    };

    let (shadow_view, view_uniform_offset) = view.into_inner();
    draw_raymarch_shadow(
        &mut ctx,
        &pipeline_cache,
        &pipeline.layout,
        &view_uniforms,
        &globals,
        render_pipeline,
        shadow_view,
        view_uniform_offset,
    );
}

examples/shader_advanced/custom_post_processing.rs (line 156)

fn post_process_system(
    view: ViewQuery<(
        &ViewTarget,
        &DynamicUniformIndex<PostProcessSettings>,
        &PostProcessBindGroups,
    )>,
    post_process_pipeline: Option<Res<PostProcessPipeline>>,
    pipeline_cache: Res<PipelineCache>,
    mut ctx: RenderContext,
) {
    let Some(post_process_pipeline) = post_process_pipeline else {
        return;
    };

    let (view_target, settings_index, bind_groups) = view.into_inner();

    let Some(pipeline) = pipeline_cache.get_render_pipeline(post_process_pipeline.pipeline_id)
    else {
        return;
    };

    // This will start a new "post process write", obtaining two texture
    // views from the view target - a `source` and a `destination`.
    // `source` is the "current" main texture and you _must_ write into
    // `destination` because calling `post_process_write()` on the
    // [`ViewTarget`] will internally flip the [`ViewTarget`]'s main
    // texture to the `destination` texture. Failing to do so will cause
    // the current main texture information to be lost.
    let post_process = view_target.post_process_write();

    // We prepared the bind group ahead of time but now we need to make sure
    // we pick the bind group associated with the source texture
    let (_, bind_group) = if bind_groups.a.0 == post_process.source.id() {
        &bind_groups.a
    } else {
        &bind_groups.b
    };

    let mut render_pass = ctx
        .command_encoder()
        .begin_render_pass(&RenderPassDescriptor {
            label: Some("post_process_pass"),
            color_attachments: &[Some(RenderPassColorAttachment {
                // We need to specify the post process destination view here
                // to make sure we write to the appropriate texture.
                view: post_process.destination,
                depth_slice: None,
                resolve_target: None,
                ops: Operations::default(),
            })],
            depth_stencil_attachment: None,
            timestamp_writes: None,
            occlusion_query_set: None,
            multiview_mask: None,
        });

    render_pass.set_pipeline(pipeline);
    // By passing in the index of the post process settings on this view, we ensure
    // that in the event that multiple settings were sent to the GPU (as would be the
    // case with multiple cameras), we use the correct one.
    render_pass.set_bind_group(0, bind_group, &[settings_index.index()]);
    render_pass.draw(0..3, 0..1);
}

pub fn block_on_render_pipeline(&mut self, id: CachedRenderPipelineId)

Wait for a render pipeline to finish compiling.

pub fn get_compute_pipeline( &self, id: CachedComputePipelineId, ) -> Option<&ComputePipeline>

Try to retrieve a compute pipeline GPU object from a cached ID.

Returns

This method returns a successfully created compute pipeline if any, or None if the pipeline was not created yet or if there was an error during creation. You can check the actual creation state with PipelineCache::get_compute_pipeline_state().

Examples found in repository

examples/shader/gpu_readback.rs (line 220)

fn compute(
    mut render_context: RenderContext,
    pipeline_cache: Res<PipelineCache>,
    pipeline: Res<ComputePipeline>,
    bind_group: Res<GpuBufferBindGroup>,
) {
    if let Some(init_pipeline) = pipeline_cache.get_compute_pipeline(pipeline.pipeline) {
        let mut pass =
            render_context
                .command_encoder()
                .begin_compute_pass(&ComputePassDescriptor {
                    label: Some("GPU readback compute pass"),
                    ..default()
                });

        pass.set_bind_group(0, &bind_group.0, &[]);
        pass.set_pipeline(init_pipeline);
        pass.dispatch_workgroups(BUFFER_LEN as u32, 1, 1);
    }
}

examples/shader_advanced/compute_mesh.rs (line 185)

fn prepare_chunks(
    meshes_to_generate: Query<&GenerateMesh>,
    mut chunks: ResMut<ChunksToProcess>,
    pipeline_cache: Res<PipelineCache>,
    pipeline: Res<ComputePipeline>,
    mut processed: Local<HashSet<AssetId<Mesh>>>,
) {
    // If the pipeline isn't ready, then meshes
    // won't be processed. So we want to wait until
    // the pipeline is ready before considering any mesh processed.
    if pipeline_cache
        .get_compute_pipeline(pipeline.pipeline)
        .is_some()
    {
        // get the AssetId for each Handle<Mesh>
        // which we'll use later to get the relevant buffers
        // from the mesh_allocator
        let chunk_data: Vec<AssetId<Mesh>> = meshes_to_generate
            .iter()
            .filter_map(|gmesh| {
                let id = gmesh.0.id();
                processed.contains(&id).not().then_some(id)
            })
            .collect();

        // Cache any meshes we're going to process this frame
        for id in &chunk_data {
            processed.insert(*id);
        }

        chunks.0 = chunk_data;
    }
}

#[derive(Resource)]
struct ComputePipeline {
    layout: BindGroupLayoutDescriptor,
    pipeline: CachedComputePipelineId,
}

// init only happens once
fn init_compute_pipeline(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    pipeline_cache: Res<PipelineCache>,
) {
    let layout = BindGroupLayoutDescriptor::new(
        "",
        &BindGroupLayoutEntries::sequential(
            ShaderStages::COMPUTE,
            (
                // offsets
                uniform_buffer::<DataRanges>(false),
                // vertices
                storage_buffer::<Vec<f32>>(false),
                // indices
                storage_buffer::<Vec<u32>>(false),
            ),
        ),
    );
    let shader = asset_server.load(SHADER_ASSET_PATH);
    let pipeline = pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
        label: Some("Mesh generation compute shader".into()),
        layout: vec![layout.clone()],
        shader: shader.clone(),
        ..default()
    });
    commands.insert_resource(ComputePipeline { layout, pipeline });
}

// A uniform that holds the vertex and index offsets
// for the vertex/index mesh_allocator buffer slabs
#[derive(ShaderType)]
struct DataRanges {
    vertex_start: u32,
    vertex_end: u32,
    index_start: u32,
    index_end: u32,
}

fn compute_mesh(
    mut render_context: RenderContext,
    chunks: Res<ChunksToProcess>,
    mesh_allocator: Res<MeshAllocator>,
    pipeline_cache: Res<PipelineCache>,
    pipeline: Res<ComputePipeline>,
    render_queue: Res<RenderQueue>,
) {
    let Some(init_pipeline) = pipeline_cache.get_compute_pipeline(pipeline.pipeline) else {
        return;
    };

    for mesh_id in &chunks.0 {
        info!(?mesh_id, "processing mesh");

        // the mesh_allocator holds slabs of meshes, so the buffers we get here
        // can contain more data than just the mesh we're asking for.
        // That's why there is a range field.
        // You should *not* touch data in these buffers that is outside of the range.
        let vertex_buffer_slice = mesh_allocator.mesh_vertex_slice(mesh_id).unwrap();
        let index_buffer_slice = mesh_allocator.mesh_index_slice(mesh_id).unwrap();

        let first = DataRanges {
            // there are 8 vertex data values (pos, normal, uv) per vertex
            // and the vertex_buffer_slice.range.start is in "vertex elements"
            // which includes all of that data, so each index is worth 8 indices
            // to our shader code.
            vertex_start: vertex_buffer_slice.range.start * 8,
            vertex_end: vertex_buffer_slice.range.end * 8,
            // but each vertex index is a single value, so the index of the
            // vertex indices is exactly what the value is
            index_start: index_buffer_slice.range.start,
            index_end: index_buffer_slice.range.end,
        };

        let mut uniforms = UniformBuffer::from(first);
        uniforms.write_buffer(render_context.render_device(), &render_queue);

        // pass in the full mesh_allocator slabs as well as the first index
        // offsets for the vertex and index buffers
        let bind_group = render_context.render_device().create_bind_group(
            None,
            &pipeline_cache.get_bind_group_layout(&pipeline.layout),
            &BindGroupEntries::sequential((
                &uniforms,
                vertex_buffer_slice.buffer.as_entire_buffer_binding(),
                index_buffer_slice.buffer.as_entire_buffer_binding(),
            )),
        );

        let mut pass =
            render_context
                .command_encoder()
                .begin_compute_pass(&ComputePassDescriptor {
                    label: Some("Mesh generation compute pass"),
                    ..default()
                });
        pass.push_debug_group("compute_mesh");

        pass.set_bind_group(0, &bind_group, &[]);
        pass.set_pipeline(init_pipeline);
        // we only dispatch 1,1,1 workgroup here, but a real compute shader
        // would take advantage of more and larger size workgroups
        pass.dispatch_workgroups(1, 1, 1);

        pass.pop_debug_group();
    }
}

examples/shader/compute_shader_game_of_life.rs (line 274)

fn game_of_life(
    mut render_context: RenderContext,
    bind_groups: Res<GameOfLifeImageBindGroups>,
    pipeline_cache: Res<PipelineCache>,
    pipeline: Res<GameOfLifePipeline>,
    state: Res<GameOfLifeState>,
) {
    let mut pass = render_context
        .command_encoder()
        .begin_compute_pass(&ComputePassDescriptor::default());

    // select the pipeline based on the current state
    match *state {
        GameOfLifeState::Loading => {}
        GameOfLifeState::Init => {
            let init_pipeline = pipeline_cache
                .get_compute_pipeline(pipeline.init_pipeline)
                .unwrap();
            pass.set_bind_group(0, &bind_groups.0[0], &[]);
            pass.set_pipeline(init_pipeline);
            pass.dispatch_workgroups(SIZE.x / WORKGROUP_SIZE, SIZE.y / WORKGROUP_SIZE, 1);
        }
        GameOfLifeState::Update(index) => {
            let update_pipeline = pipeline_cache
                .get_compute_pipeline(pipeline.update_pipeline)
                .unwrap();
            pass.set_bind_group(0, &bind_groups.0[index], &[]);
            pass.set_pipeline(update_pipeline);
            pass.dispatch_workgroups(SIZE.x / WORKGROUP_SIZE, SIZE.y / WORKGROUP_SIZE, 1);
        }
    }
}

pub fn queue_render_pipeline( &self, descriptor: RenderPipelineDescriptor, ) -> CachedRenderPipelineId

Insert a render pipeline into the cache, and queue its creation.

The pipeline is always inserted and queued for creation. There is no attempt to deduplicate it with an already cached pipeline.

Returns

This method returns the unique render shader ID of the cached pipeline, which can be used to query the caching state with get_render_pipeline_state() and to retrieve the created GPU pipeline once it’s ready with get_render_pipeline().

Examples found in repository

examples/shader_advanced/custom_post_processing.rs (lines 244-260)

fn init_post_process_pipeline(
    mut commands: Commands,
    render_device: Res<RenderDevice>,
    asset_server: Res<AssetServer>,
    fullscreen_shader: Res<FullscreenShader>,
    pipeline_cache: Res<PipelineCache>,
) {
    // We need to define the bind group layout used for our pipeline
    let layout = BindGroupLayoutDescriptor::new(
        "post_process_bind_group_layout",
        &BindGroupLayoutEntries::sequential(
            // The layout entries will only be visible in the fragment stage
            ShaderStages::FRAGMENT,
            (
                // The screen texture
                texture_2d(TextureSampleType::Float { filterable: true }),
                // The sampler that will be used to sample the screen texture
                sampler(SamplerBindingType::Filtering),
                // The settings uniform that will control the effect
                uniform_buffer::<PostProcessSettings>(true),
            ),
        ),
    );
    // We can create the sampler here since it won't change at runtime and doesn't depend on the view
    let sampler = render_device.create_sampler(&SamplerDescriptor::default());

    // Get the shader handle
    let shader = asset_server.load(SHADER_ASSET_PATH);
    // This will setup a fullscreen triangle for the vertex state.
    let vertex_state = fullscreen_shader.to_vertex_state();
    let pipeline_id = pipeline_cache
        // This will add the pipeline to the cache and queue its creation
        .queue_render_pipeline(RenderPipelineDescriptor {
            label: Some("post_process_pipeline".into()),
            layout: vec![layout.clone()],
            vertex: vertex_state,
            fragment: Some(FragmentState {
                shader,
                // Make sure this matches the entry point of your shader.
                // It can be anything as long as it matches here and in the shader.
                targets: vec![Some(ColorTargetState {
                    format: TextureFormat::Rgba8UnormSrgb,
                    blend: None,
                    write_mask: ColorWrites::ALL,
                })],
                ..default()
            }),
            ..default()
        });
    commands.insert_resource(PostProcessPipeline {
        layout,
        sampler,
        pipeline_id,
    });
}

examples/shader_advanced/deferred_raymarch.rs (lines 164-187)

fn init_raymarch_pipelines(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    fullscreen_shader: Res<FullscreenShader>,
    pipeline_cache: Res<PipelineCache>,
) {
    let layout = BindGroupLayoutDescriptor::new(
        "raymarch_bind_group_layout",
        &BindGroupLayoutEntries::sequential(
            ShaderStages::FRAGMENT,
            (
                uniform_buffer::<ViewUniform>(true),
                uniform_buffer::<GlobalsUniform>(false),
            ),
        ),
    );

    let shader = asset_server.load::<Shader>(SHADER_ASSET_PATH);
    let vertex_state = fullscreen_shader.to_vertex_state();

    // Writing depth lets the SDF sort against meshes
    let depth_stencil = DepthStencilState {
        format: CORE_3D_DEPTH_FORMAT,
        depth_write_enabled: Some(true),
        depth_compare: Some(CompareFunction::GreaterEqual),
        stencil: StencilState::default(),
        bias: DepthBiasState::default(),
    };

    let gbuffer_pipeline_id = pipeline_cache.queue_render_pipeline(RenderPipelineDescriptor {
        label: Some("raymarch_gbuffer_pipeline".into()),
        layout: vec![layout.clone()],
        vertex: vertex_state.clone(),
        fragment: Some(FragmentState {
            shader: shader.clone(),
            entry_point: Some("fragment".into()),
            targets: vec![
                Some(ColorTargetState {
                    format: DEFERRED_PREPASS_FORMAT,
                    blend: None,
                    write_mask: ColorWrites::ALL,
                }),
                Some(ColorTargetState {
                    format: DEFERRED_LIGHTING_PASS_ID_FORMAT,
                    blend: None,
                    write_mask: ColorWrites::ALL,
                }),
            ],
            ..default()
        }),
        depth_stencil: Some(depth_stencil.clone()),
        ..default()
    });

    let shadow_pipeline_id = pipeline_cache.queue_render_pipeline(RenderPipelineDescriptor {
        label: Some("raymarch_shadow_pipeline".into()),
        layout: vec![layout.clone()],
        vertex: vertex_state,
        fragment: Some(FragmentState {
            shader,
            entry_point: Some("fragment_shadow".into()),
            targets: vec![],
            ..default()
        }),
        depth_stencil: Some(depth_stencil),
        ..default()
    });

    commands.insert_resource(RaymarchGBufferPipeline {
        layout: layout.clone(),
        pipeline_id: gbuffer_pipeline_id,
    });
    commands.insert_resource(RaymarchShadowPipeline {
        layout,
        pipeline_id: shadow_pipeline_id,
    });
}

pub fn queue_compute_pipeline( &self, descriptor: ComputePipelineDescriptor, ) -> CachedComputePipelineId

Insert a compute pipeline into the cache, and queue its creation.

The pipeline is always inserted and queued for creation. There is no attempt to deduplicate it with an already cached pipeline.

Returns

This method returns the unique compute shader ID of the cached pipeline, which can be used to query the caching state with get_compute_pipeline_state() and to retrieve the created GPU pipeline once it’s ready with get_compute_pipeline().

Examples found in repository

examples/shader/gpu_readback.rs (lines 205-210)

fn init_compute_pipeline(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    pipeline_cache: Res<PipelineCache>,
) {
    let layout = BindGroupLayoutDescriptor::new(
        "",
        &BindGroupLayoutEntries::sequential(
            ShaderStages::COMPUTE,
            (
                storage_buffer::<Vec<u32>>(false),
                texture_storage_2d(TextureFormat::R32Uint, StorageTextureAccess::WriteOnly),
            ),
        ),
    );
    let shader = asset_server.load(SHADER_ASSET_PATH);
    let pipeline = pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
        label: Some("GPU readback compute shader".into()),
        layout: vec![layout.clone()],
        shader: shader.clone(),
        ..default()
    });
    commands.insert_resource(ComputePipeline { layout, pipeline });
}

examples/shader_advanced/compute_mesh.rs (lines 235-240)

fn init_compute_pipeline(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    pipeline_cache: Res<PipelineCache>,
) {
    let layout = BindGroupLayoutDescriptor::new(
        "",
        &BindGroupLayoutEntries::sequential(
            ShaderStages::COMPUTE,
            (
                // offsets
                uniform_buffer::<DataRanges>(false),
                // vertices
                storage_buffer::<Vec<f32>>(false),
                // indices
                storage_buffer::<Vec<u32>>(false),
            ),
        ),
    );
    let shader = asset_server.load(SHADER_ASSET_PATH);
    let pipeline = pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
        label: Some("Mesh generation compute shader".into()),
        layout: vec![layout.clone()],
        shader: shader.clone(),
        ..default()
    });
    commands.insert_resource(ComputePipeline { layout, pipeline });
}

examples/shader/compute_shader_game_of_life.rs (lines 193-198)

fn init_game_of_life_pipeline(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    pipeline_cache: Res<PipelineCache>,
) {
    let texture_bind_group_layout = BindGroupLayoutDescriptor::new(
        "GameOfLifeImages",
        &BindGroupLayoutEntries::sequential(
            ShaderStages::COMPUTE,
            (
                texture_storage_2d(TextureFormat::Rgba32Float, StorageTextureAccess::ReadOnly),
                texture_storage_2d(TextureFormat::Rgba32Float, StorageTextureAccess::WriteOnly),
                uniform_buffer::<GameOfLifeUniforms>(false),
            ),
        ),
    );
    let shader = asset_server.load(SHADER_ASSET_PATH);
    let init_pipeline = pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
        layout: vec![texture_bind_group_layout.clone()],
        shader: shader.clone(),
        entry_point: Some(Cow::from("init")),
        ..default()
    });
    let update_pipeline = pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
        layout: vec![texture_bind_group_layout.clone()],
        shader,
        entry_point: Some(Cow::from("update")),
        ..default()
    });

    commands.insert_resource(GameOfLifePipeline {
        texture_bind_group_layout,
        init_pipeline,
        update_pipeline,
    });
}

pub fn queue_mesh_pipeline( &self, descriptor: MeshPipelineDescriptor, ) -> CachedRenderPipelineId

Insert a mesh pipeline into the cache, and queue its creation.

The pipeline is always inserted and queued for creation. There is no attempt to deduplicate it with an already cached pipeline.

Returns

This method returns the unique mesh shader ID of the cached pipeline, which can be used to query the caching state with get_render_pipeline_state() and to retrieve the created GPU pipeline once it’s ready with get_render_pipeline().

Examples found in repository

examples/shader_advanced/mesh_shader_intro.rs (lines 157-185)

fn init_mesh_pipelines(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    pipeline_cache: Res<PipelineCache>,
) {
    let task_shader = asset_server.load::<Shader>("shaders/mesh_shader_intro/task.wesl");
    let mesh_shader = asset_server.load::<Shader>("shaders/mesh_shader_intro/mesh.wesl");
    let fragment_shader = asset_server.load::<Shader>("shaders/mesh_shader_intro/fragment.wesl");

    let layout = BindGroupLayoutDescriptor::new(
        "custom_mesh_shader_bind_group_layout",
        &BindGroupLayoutEntries::sequential(
            ShaderStages::MESH | ShaderStages::TASK | ShaderStages::FRAGMENT,
            (
                uniform_buffer::<GlobalsUniform>(false),
                uniform_buffer::<ViewUniform>(true),
            ),
        ),
    );

    let depth_stencil = DepthStencilState {
        format: CORE_3D_DEPTH_FORMAT,
        depth_write_enabled: Some(true),
        depth_compare: Some(CompareFunction::GreaterEqual),
        stencil: StencilState::default(),
        bias: DepthBiasState::default(),
    };

    let cached_pipeline_id = pipeline_cache.queue_mesh_pipeline(MeshPipelineDescriptor {
        label: Some("custom_mesh_shader_pipeline".into()),
        layout: vec![layout.clone()],
        immediate_size: 0,
        task: Some(TaskState {
            shader: task_shader,
            entry_point: Some("task".into()),
            ..default()
        }),
        mesh: MeshState {
            shader: mesh_shader,
            entry_point: Some("mesh".into()),
            ..default()
        },
        primitive: Default::default(),
        depth_stencil: Some(depth_stencil),
        multisample: Default::default(),
        fragment: Some(FragmentState {
            shader: fragment_shader,
            entry_point: Some("fragment".into()),
            targets: vec![Some(ColorTargetState {
                format: TextureFormat::Rgba8UnormSrgb,
                blend: None,
                write_mask: ColorWrites::ALL,
            })],
            ..default()
        }),
        zero_initialize_workgroup_memory: false,
    });

    commands.insert_resource(MyMeshShaderDrawNode {
        mesh_pipeline: cached_pipeline_id,
        layout,
    });
}

pub fn get_bind_group_layout( &self, bind_group_layout_descriptor: &BindGroupLayoutDescriptor, ) -> BindGroupLayout

Examples found in repository

examples/shader_advanced/deferred_raymarch.rs (line 224)

fn raymarch_bind_group(
    ctx: &RenderContext,
    pipeline_cache: &PipelineCache,
    layout: &BindGroupLayoutDescriptor,
    view_uniforms: &ViewUniforms,
    globals: &GlobalsBuffer,
) -> Option<BindGroup> {
    let view_binding = view_uniforms.uniforms.binding()?;
    let globals_binding = globals.buffer.binding()?;
    Some(ctx.render_device().create_bind_group(
        "raymarch_bind_group",
        &pipeline_cache.get_bind_group_layout(layout),
        &BindGroupEntries::sequential((view_binding, globals_binding)),
    ))
}

examples/shader/gpu_readback.rs (line 174)

fn prepare_bind_group(
    mut commands: Commands,
    pipeline: Res<ComputePipeline>,
    render_device: Res<RenderDevice>,
    pipeline_cache: Res<PipelineCache>,
    buffer: Res<ReadbackBuffer>,
    image: Res<ReadbackImage>,
    buffers: Res<RenderAssets<GpuShaderBuffer>>,
    images: Res<RenderAssets<GpuImage>>,
) {
    let buffer = buffers.get(&buffer.0).unwrap();
    let image = images.get(&image.0).unwrap();
    let bind_group = render_device.create_bind_group(
        None,
        &pipeline_cache.get_bind_group_layout(&pipeline.layout),
        &BindGroupEntries::sequential((
            buffer.buffer.as_entire_buffer_binding(),
            image.texture_view.into_binding(),
        )),
    );
    commands.insert_resource(GpuBufferBindGroup(bind_group));
}

examples/shader/compute_shader_game_of_life.rs (line 150)

fn prepare_bind_group(
    mut commands: Commands,
    pipeline: Res<GameOfLifePipeline>,
    gpu_images: Res<RenderAssets<GpuImage>>,
    game_of_life_images: Res<GameOfLifeImages>,
    game_of_life_uniforms: Res<GameOfLifeUniforms>,
    render_device: Res<RenderDevice>,
    pipeline_cache: Res<PipelineCache>,
    queue: Res<RenderQueue>,
) {
    let view_a = gpu_images.get(&game_of_life_images.texture_a).unwrap();
    let view_b = gpu_images.get(&game_of_life_images.texture_b).unwrap();

    // Uniform buffer is used here to demonstrate how to set up a uniform in a compute shader
    // Alternatives such as storage buffers or push constants may be more suitable for your use case
    let mut uniform_buffer = UniformBuffer::from(game_of_life_uniforms.into_inner());
    uniform_buffer.write_buffer(&render_device, &queue);

    let bind_group_0 = render_device.create_bind_group(
        None,
        &pipeline_cache.get_bind_group_layout(&pipeline.texture_bind_group_layout),
        &BindGroupEntries::sequential((
            &view_a.texture_view,
            &view_b.texture_view,
            &uniform_buffer,
        )),
    );
    let bind_group_1 = render_device.create_bind_group(
        None,
        &pipeline_cache.get_bind_group_layout(&pipeline.texture_bind_group_layout),
        &BindGroupEntries::sequential((
            &view_b.texture_view,
            &view_a.texture_view,
            &uniform_buffer,
        )),
    );
    commands.insert_resource(GameOfLifeImageBindGroups([bind_group_0, bind_group_1]));
}

examples/shader_advanced/texture_binding_array.rs (line 138)

    fn as_bind_group(
        &self,
        layout: &BindGroupLayoutDescriptor,
        render_device: &RenderDevice,
        pipeline_cache: &PipelineCache,
        _: &FallbackBuffer,
        shader_buffer_assets: &RenderAssets<GpuShaderBuffer>,
        (image_assets, fallback_image): &mut SystemParamItem<'_, '_, Self::Param>,
    ) -> Result<PreparedBindGroup, AsBindGroupError> {
        let _ = shader_buffer_assets;
        // retrieve the render resources from handles
        let mut images = vec![];
        for handle in self.textures.iter().take(MAX_TEXTURE_COUNT) {
            match image_assets.get(handle) {
                Some(image) => images.push(image),
                None => return Err(AsBindGroupError::RetryNextUpdate),
            }
        }

        let fallback_image = &fallback_image.d2;

        let textures = vec![&fallback_image.texture_view; MAX_TEXTURE_COUNT];

        // convert bevy's resource types to WGPU's references
        let mut textures: Vec<_> = textures.into_iter().map(|texture| &**texture).collect();

        // fill in up to the first `MAX_TEXTURE_COUNT` textures and samplers to the arrays
        for (id, image) in images.into_iter().enumerate() {
            textures[id] = &*image.texture_view;
        }

        let bind_group = render_device.create_bind_group(
            Self::label(),
            &pipeline_cache.get_bind_group_layout(layout),
            &BindGroupEntries::sequential((&textures[..], &fallback_image.sampler)),
        );

        Ok(PreparedBindGroup {
            bindings: BindingResources(vec![]),
            bind_group,
        })
    }

examples/shader_advanced/custom_post_processing.rs (line 108)

fn prepare_bind_groups(
    mut commands: Commands,
    mut views: Query<(Entity, &ViewTarget, Option<&mut PostProcessBindGroups>)>,
    post_process_pipeline: Option<Res<PostProcessPipeline>>,
    pipeline_cache: Res<PipelineCache>,
    settings_uniforms: Res<ComponentUniforms<PostProcessSettings>>,
    render_device: Res<RenderDevice>,
) {
    let Some(post_process_pipeline) = post_process_pipeline else {
        return;
    };
    let Some(settings_binding) = settings_uniforms.uniforms().binding() else {
        return;
    };

    let create_bind_group = |texture: &TextureView| {
        (
            texture.id(),
            render_device.create_bind_group(
                "post_process_bind_group",
                &pipeline_cache.get_bind_group_layout(&post_process_pipeline.layout),
                &BindGroupEntries::sequential((
                    texture,
                    &post_process_pipeline.sampler,
                    settings_binding.clone(),
                )),
            ),
        )
    };

    for (entity, view_target, mut maybe_bind_groups) in &mut views {
        let main_texture_view = view_target.main_texture_view();
        let main_texture_other_view = view_target.main_texture_other_view();

        // Only update the cached bind groups if the main texture has changed
        if let Some(bind_groups) = &mut maybe_bind_groups {
            if bind_groups.a.0 != main_texture_view.id() {
                bind_groups.a = create_bind_group(main_texture_view);
            }
            if bind_groups.b.0 != main_texture_other_view.id() {
                bind_groups.b = create_bind_group(main_texture_other_view);
            }
        } else {
            // Create the bind groups and add them to the view
            commands.entity(entity).insert(PostProcessBindGroups {
                a: create_bind_group(main_texture_view),
                b: create_bind_group(main_texture_other_view),
            });
        }
    }
}

examples/shader_advanced/mesh_shader_intro.rs (line 230)

fn draw_mesh_shader_cubes(
    mut views: Query<(
        &ExtractedCamera,
        &ExtractedView,
        &ViewTarget,
        &ViewDepthStencilTexture,
        &ViewUniformOffset,
        Option<&MainPassResolutionOverride>,
    )>,
    mut render_context: RenderContext,
    data: Res<MyMeshShaderDrawNode>,
    view_uniforms: Res<ViewUniforms>,
    globals: Res<GlobalsBuffer>,
    pipeline_cache: Res<PipelineCache>,
) {
    let Some(mesh_pipeline) = pipeline_cache.get_render_pipeline(data.mesh_pipeline) else {
        return;
    };

    for (camera, _, target, depth, view_uniform_offset, resolution_override) in &mut views {
        let Some(view_binding) = view_uniforms.uniforms.binding() else {
            return;
        };
        let Some(globals_binding) = globals.buffer.binding() else {
            return;
        };
        let bind_group = render_context.render_device().create_bind_group(
            "custom_task_mesh_bind_group",
            &pipeline_cache.get_bind_group_layout(&data.layout),
            &BindGroupEntries::sequential((globals_binding, view_binding)),
        );

        {
            let mut pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
                label: Some("custom_mesh_shader_pass"),
                // Write directly to the view target
                color_attachments: &[Some(target.get_color_attachment())],
                depth_stencil_attachment: Some(depth.get_attachment(StoreOp::Store)),
                timestamp_writes: None,
                occlusion_query_set: None,
                multiview_mask: None,
            });

            pass.set_render_pipeline(mesh_pipeline);
            pass.set_bind_group(0, &bind_group, &[view_uniform_offset.offset]);
            if let Some(viewport) =
                Viewport::from_viewport_and_override(camera.viewport.as_ref(), resolution_override)
            {
                pass.set_camera_viewport(&viewport);
            }

            // Since this MeshPipeline has a task shader, this call
            // dispatches the task shader workgroup
            pass.draw_mesh_tasks(1, 1, 1);
        }
    }
}

Additional examples can be found in:

• examples/shader_advanced/compute_mesh.rs

pub fn set_shader(&mut self, id: AssetId<Shader>, shader: Shader)

Inserts a Shader into this cache with the provided AssetId.

pub fn remove_shader(&mut self, shader: AssetId<Shader>)

Removes a Shader from this cache if it exists.

pub fn process_queue(&mut self)

Process the pipeline queue and create all pending pipelines if possible.

This is generally called automatically during the RenderSystems::Render step, but can be called manually to force creation at a different time.

Trait Implementations

impl Component for PipelineCache

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

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 Resource for PipelineCache

where PipelineCache: Send + Sync + 'static,