refactored the pipeline cache to accommodate both render and compute …

…pipelines

crates/bevy_pbr/src/lib.rs

@@ -40,7 +40,7 @@ use bevy_render::{
     prelude::Color,
     render_graph::RenderGraph,
     render_phase::{sort_phase_system, AddRenderCommand, DrawFunctions},
-    render_resource::{Shader, SpecializedPipelines},
+    render_resource::{Shader, SpecializedRenderPipelines},
     view::VisibilitySystems,
     RenderApp, RenderStage,
 };
@@ -178,7 +178,7 @@ impl Plugin for PbrPlugin {
             .init_resource::<DrawFunctions<Shadow>>()
             .init_resource::<LightMeta>()
             .init_resource::<GlobalLightMeta>()
-            .init_resource::<SpecializedPipelines<ShadowPipeline>>();
+            .init_resource::<SpecializedRenderPipelines<ShadowPipeline>>();
 
         let shadow_pass_node = ShadowPassNode::new(&mut render_app.world);
         render_app.add_render_command::<Shadow, DrawShadowMesh>();

crates/bevy_pbr/src/material.rs

@@ -23,8 +23,8 @@ use bevy_render::{
         SetItemPipeline, TrackedRenderPass,
     },
     render_resource::{
-        BindGroup, BindGroupLayout, RenderPipelineCache, RenderPipelineDescriptor, Shader,
-        SpecializedPipeline, SpecializedPipelines,
+        BindGroup, BindGroupLayout, PipelineCache, RenderPipelineDescriptor, Shader,
+        SpecializedRenderPipeline, SpecializedRenderPipelines,
     },
     renderer::RenderDevice,
     view::{ExtractedView, Msaa, VisibleEntities},
@@ -188,7 +188,7 @@ impl<M: SpecializedMaterial> Plugin for MaterialPlugin<M> {
                 .add_render_command::<Opaque3d, DrawMaterial<M>>()
                 .add_render_command::<AlphaMask3d, DrawMaterial<M>>()
                 .init_resource::<MaterialPipeline<M>>()
-                .init_resource::<SpecializedPipelines<MaterialPipeline<M>>>()
+                .init_resource::<SpecializedRenderPipelines<MaterialPipeline<M>>>()
                 .add_system_to_stage(RenderStage::Queue, queue_material_meshes::<M>);
         }
     }
@@ -202,7 +202,7 @@ pub struct MaterialPipeline<M: SpecializedMaterial> {
     marker: PhantomData<M>,
 }
 
-impl<M: SpecializedMaterial> SpecializedPipeline for MaterialPipeline<M> {
+impl<M: SpecializedMaterial> SpecializedRenderPipeline for MaterialPipeline<M> {
     type Key = (MeshPipelineKey, M::Key);
 
     fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
@@ -275,8 +275,8 @@ pub fn queue_material_meshes<M: SpecializedMaterial>(
     alpha_mask_draw_functions: Res<DrawFunctions<AlphaMask3d>>,
     transparent_draw_functions: Res<DrawFunctions<Transparent3d>>,
     material_pipeline: Res<MaterialPipeline<M>>,
-    mut pipelines: ResMut<SpecializedPipelines<MaterialPipeline<M>>>,
-    mut pipeline_cache: ResMut<RenderPipelineCache>,
+    mut pipelines: ResMut<SpecializedRenderPipelines<MaterialPipeline<M>>>,
+    mut pipeline_cache: ResMut<PipelineCache>,
     msaa: Res<Msaa>,
     render_meshes: Res<RenderAssets<Mesh>>,
     render_materials: Res<RenderAssets<M>>,

crates/bevy_pbr/src/render/light.rs

@@ -244,7 +244,7 @@ impl ShadowPipelineKey {
     }
 }
 
-impl SpecializedPipeline for ShadowPipeline {
+impl SpecializedRenderPipeline for ShadowPipeline {
     type Key = ShadowPipelineKey;
 
     fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
@@ -1090,8 +1090,8 @@ pub fn queue_shadows(
     shadow_pipeline: Res<ShadowPipeline>,
     casting_meshes: Query<&Handle<Mesh>, Without<NotShadowCaster>>,
     render_meshes: Res<RenderAssets<Mesh>>,
-    mut pipelines: ResMut<SpecializedPipelines<ShadowPipeline>>,
-    mut pipeline_cache: ResMut<RenderPipelineCache>,
+    mut pipelines: ResMut<SpecializedRenderPipelines<ShadowPipeline>>,
+    mut pipeline_cache: ResMut<PipelineCache>,
     view_lights: Query<&ViewLightEntities>,
     mut view_light_shadow_phases: Query<(&LightEntity, &mut RenderPhase<Shadow>)>,
     point_light_entities: Query<&CubemapVisibleEntities, With<ExtractedPointLight>>,

crates/bevy_pbr/src/render/mesh.rs

@@ -411,7 +411,7 @@ impl MeshPipelineKey {
     }
 }
 
-impl SpecializedPipeline for MeshPipeline {
+impl SpecializedRenderPipeline for MeshPipeline {
     type Key = MeshPipelineKey;
 
     fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {

crates/bevy_pbr/src/wireframe.rs

@@ -10,7 +10,9 @@ use bevy_render::{
     mesh::Mesh,
     render_asset::RenderAssets,
     render_phase::{AddRenderCommand, DrawFunctions, RenderPhase, SetItemPipeline},
-    render_resource::{RenderPipelineCache, Shader, SpecializedPipeline, SpecializedPipelines},
+    render_resource::{
+        PipelineCache, Shader, SpecializedRenderPipeline, SpecializedRenderPipelines,
+    },
     view::{ExtractedView, Msaa},
     RenderApp, RenderStage,
 };
@@ -35,7 +37,7 @@ impl Plugin for WireframePlugin {
             render_app
                 .add_render_command::<Opaque3d, DrawWireframes>()
                 .init_resource::<WireframePipeline>()
-                .init_resource::<SpecializedPipelines<WireframePipeline>>()
+                .init_resource::<SpecializedRenderPipelines<WireframePipeline>>()
                 .add_system_to_stage(RenderStage::Extract, extract_wireframes)
                 .add_system_to_stage(RenderStage::Extract, extract_wireframe_config)
                 .add_system_to_stage(RenderStage::Queue, queue_wireframes);
@@ -79,7 +81,7 @@ impl FromWorld for WireframePipeline {
     }
 }
 
-impl SpecializedPipeline for WireframePipeline {
+impl SpecializedRenderPipeline for WireframePipeline {
     type Key = MeshPipelineKey;
 
     fn specialize(&self, key: Self::Key) -> bevy_render::render_resource::RenderPipelineDescriptor {
@@ -98,8 +100,8 @@ fn queue_wireframes(
     render_meshes: Res<RenderAssets<Mesh>>,
     wireframe_config: Res<WireframeConfig>,
     wireframe_pipeline: Res<WireframePipeline>,
-    mut pipeline_cache: ResMut<RenderPipelineCache>,
-    mut specialized_pipelines: ResMut<SpecializedPipelines<WireframePipeline>>,
+    mut pipeline_cache: ResMut<PipelineCache>,
+    mut specialized_pipelines: ResMut<SpecializedRenderPipelines<WireframePipeline>>,
     msaa: Res<Msaa>,
     mut material_meshes: QuerySet<(
         QueryState<(Entity, &Handle<Mesh>, &MeshUniform)>,

crates/bevy_render/src/lib.rs

@@ -36,7 +36,7 @@ use crate::{
     mesh::MeshPlugin,
     primitives::{CubemapFrusta, Frustum},
     render_graph::RenderGraph,
-    render_resource::{RenderPipelineCache, Shader, ShaderLoader},
+    render_resource::{PipelineCache, Shader, ShaderLoader},
     renderer::render_system,
     texture::ImagePlugin,
     view::{ViewPlugin, WindowRenderPlugin},
@@ -145,12 +145,12 @@ impl Plugin for RenderPlugin {
                 .init_resource::<ScratchRenderWorld>()
                 .register_type::<Frustum>()
                 .register_type::<CubemapFrusta>();
-            let render_pipeline_cache = RenderPipelineCache::new(device.clone());
+            let render_pipeline_cache = PipelineCache::new(device.clone());
             let asset_server = app.world.get_resource::<AssetServer>().unwrap().clone();
 
             let mut render_app = App::empty();
             let mut extract_stage =
-                SystemStage::parallel().with_system(RenderPipelineCache::extract_shaders);
+                SystemStage::parallel().with_system(PipelineCache::extract_shaders);
             // don't apply buffers when the stage finishes running
             // extract stage runs on the app world, but the buffers are applied to the render world
             extract_stage.set_apply_buffers(false);
@@ -162,7 +162,7 @@ impl Plugin for RenderPlugin {
                 .add_stage(
                     RenderStage::Render,
                     SystemStage::parallel()
-                        .with_system(RenderPipelineCache::process_pipeline_queue_system)
+                        .with_system(PipelineCache::process_pipeline_queue_system)
                         .with_system(render_system.exclusive_system().at_end()),
                 )
                 .add_stage(RenderStage::Cleanup, SystemStage::parallel())

crates/bevy_render/src/render_phase/draw.rs

@@ -1,6 +1,6 @@
 use crate::{
     render_phase::TrackedRenderPass,
-    render_resource::{CachedPipelineId, RenderPipelineCache},
+    render_resource::{CachedPipelineId, PipelineCache},
 };
 use bevy_app::App;
 use bevy_ecs::{
@@ -225,15 +225,18 @@ impl<P: EntityPhaseItem, E: EntityRenderCommand> RenderCommand<P> for E {
 
 pub struct SetItemPipeline;
 impl<P: CachedPipelinePhaseItem> RenderCommand<P> for SetItemPipeline {
-    type Param = SRes<RenderPipelineCache>;
+    type Param = SRes<PipelineCache>;
     #[inline]
     fn render<'w>(
         _view: Entity,
         item: &P,
         pipeline_cache: SystemParamItem<'w, '_, Self::Param>,
         pass: &mut TrackedRenderPass<'w>,
     ) -> RenderCommandResult {
-        if let Some(pipeline) = pipeline_cache.into_inner().get(item.cached_pipeline()) {
+        if let Some(pipeline) = pipeline_cache
+            .into_inner()
+            .get_render_pipeline(item.cached_pipeline())
+        {
             pass.set_render_pipeline(pipeline);
             RenderCommandResult::Success
         } else {

crates/bevy_render/src/render_resource/mod.rs

@@ -26,13 +26,13 @@ pub use wgpu::{
     BindGroupEntry, BindGroupLayoutDescriptor, BindGroupLayoutEntry, BindingResource, BindingType,
     BlendComponent, BlendFactor, BlendOperation, BlendState, BufferAddress, BufferBinding,
     BufferBindingType, BufferDescriptor, BufferSize, BufferUsages, ColorTargetState, ColorWrites,
-    CommandEncoder, CommandEncoderDescriptor, CompareFunction, ComputePassDescriptor,
-    ComputePipelineDescriptor, DepthBiasState, DepthStencilState, Extent3d, Face,
-    Features as WgpuFeatures, FilterMode, FragmentState as RawFragmentState, FrontFace,
-    ImageCopyBuffer, ImageCopyBufferBase, ImageCopyTexture, ImageCopyTextureBase, ImageDataLayout,
-    ImageSubresourceRange, IndexFormat, Limits as WgpuLimits, LoadOp, MapMode, MultisampleState,
-    Operations, Origin3d, PipelineLayout, PipelineLayoutDescriptor, PolygonMode, PrimitiveState,
-    PrimitiveTopology, RenderPassColorAttachment, RenderPassDepthStencilAttachment,
+    CommandEncoder, CommandEncoderDescriptor, CompareFunction, ComputePass, ComputePassDescriptor,
+    ComputePipelineDescriptor as RawComputePipelineDescriptor, DepthBiasState, DepthStencilState,
+    Extent3d, Face, Features as WgpuFeatures, FilterMode, FragmentState as RawFragmentState,
+    FrontFace, ImageCopyBuffer, ImageCopyBufferBase, ImageCopyTexture, ImageCopyTextureBase,
+    ImageDataLayout, ImageSubresourceRange, IndexFormat, Limits as WgpuLimits, LoadOp, MapMode,
+    MultisampleState, Operations, Origin3d, PipelineLayout, PipelineLayoutDescriptor, PolygonMode,
+    PrimitiveState, PrimitiveTopology, RenderPassColorAttachment, RenderPassDepthStencilAttachment,
     RenderPassDescriptor, RenderPipelineDescriptor as RawRenderPipelineDescriptor,
     SamplerBindingType, SamplerDescriptor, ShaderModule, ShaderModuleDescriptor, ShaderSource,
     ShaderStages, StencilFaceState, StencilOperation, StencilState, StorageTextureAccess,

crates/bevy_render/src/render_resource/pipeline.rs

@@ -140,3 +140,16 @@ pub struct FragmentState {
     /// The color state of the render targets.
     pub targets: Vec<ColorTargetState>,
 }
+
+/// Describes a compute pipeline.
+#[derive(Clone, Debug)]
+pub struct ComputePipelineDescriptor {
+    pub label: Option<Cow<'static, str>>,
+    pub layout: Option<Vec<BindGroupLayout>>,
+    /// The compiled shader module for this stage.
+    pub shader: Handle<Shader>,
+    pub shader_defs: Vec<String>,
+    /// The name of the entry point in the compiled shader. There must be a
+    /// function with this name in the shader.
+    pub entry_point: Cow<'static, str>,
+}