Shader Imports and decouple Mesh logic from PBR

Author: cart

assets/shaders/custom.wgsl

@@ -0,0 +1,11 @@
+[[block]]
+struct CustomMaterial {
+    color: vec4<f32>;
+};
+[[group(1), binding(0)]]
+var<uniform> material: CustomMaterial;
+
+[[stage(fragment)]]
+fn fragment() -> [[location(0)]] vec4<f32> {
+    return material.color;
+}

assets/shaders/custom_material.wgsl

@@ -1,16 +1,6 @@
-[[block]]
-struct View {
-    view_proj: mat4x4<f32>;
-    projection: mat4x4<f32>;
-    world_position: vec3<f32>;
-};
-[[group(0), binding(0)]]
-var<uniform> view: View;
+#import bevy_pbr::mesh_view_bind_group
+#import bevy_pbr::mesh_struct
 
-[[block]]
-struct Mesh {
-    transform: mat4x4<f32>;
-};
 [[group(1), binding(0)]]
 var<uniform> mesh: Mesh;
 
@@ -26,7 +16,7 @@ struct VertexOutput {
 
 [[stage(vertex)]]
 fn vertex(vertex: Vertex) -> VertexOutput {
-    let world_position = mesh.transform * vec4<f32>(vertex.position, 1.0);
+    let world_position = mesh.model * vec4<f32>(vertex.position, 1.0);
 
     var out: VertexOutput;
     out.clip_position = view.view_proj * world_position;

assets/shaders/shader_defs.wgsl

@@ -46,13 +46,19 @@ impl<T: Asset> LoadedAsset<T> {
         }
     }
 
-    pub fn with_dependency(mut self, asset_path: AssetPath) -> Self {
+    pub fn add_dependency(&mut self, asset_path: AssetPath) {
         self.dependencies.push(asset_path.to_owned());
+    }
+
+    pub fn with_dependency(mut self, asset_path: AssetPath) -> Self {
+        self.add_dependency(asset_path);
         self
     }
 
-    pub fn with_dependencies(mut self, asset_paths: Vec<AssetPath<'static>>) -> Self {
-        self.dependencies.extend(asset_paths);
+    pub fn with_dependencies(mut self, mut asset_paths: Vec<AssetPath<'static>>) -> Self {
+        for asset_path in asset_paths.drain(..) {
+            self.add_dependency(asset_path);
+        }
         self
     }
 }

crates/bevy_asset/src/loader.rs

@@ -7,8 +7,8 @@ use bevy::{
     },
     math::{Vec3, Vec4},
     pbr2::{
-        DrawMesh, MeshUniform, PbrPipeline, PbrPipelineKey, SetMeshViewBindGroup,
-        SetTransformBindGroup,
+        DrawMesh, MeshPipeline, MeshPipelineKey, MeshUniform, SetMeshBindGroup,
+        SetMeshViewBindGroup,
     },
     prelude::{AddAsset, App, AssetServer, Assets, GlobalTransform, Handle, Plugin, Transform},
     reflect::TypeUuid,
@@ -19,8 +19,8 @@ use bevy::{
         render_asset::{PrepareAssetError, RenderAsset, RenderAssetPlugin, RenderAssets},
         render_component::ExtractComponentPlugin,
         render_phase::{
-            AddRenderCommand, DrawFunctions, EntityRenderCommand, RenderPhase, SetItemPipeline,
-            TrackedRenderPass,
+            AddRenderCommand, DrawFunctions, EntityRenderCommand, RenderCommandResult, RenderPhase,
+            SetItemPipeline, TrackedRenderPass,
         },
         render_resource::*,
         renderer::RenderDevice,
@@ -127,22 +127,21 @@ impl Plugin for CustomMaterialPlugin {
 }
 
 pub struct CustomPipeline {
+    mesh_pipeline: MeshPipeline,
     material_layout: BindGroupLayout,
     shader: Handle<Shader>,
-    pbr_pipeline: PbrPipeline,
 }
 
 impl SpecializedPipeline for CustomPipeline {
-    type Key = PbrPipelineKey;
+    type Key = MeshPipelineKey;
 
     fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
-        let mut descriptor = self.pbr_pipeline.specialize(key);
-        descriptor.vertex.shader = self.shader.clone();
+        let mut descriptor = self.mesh_pipeline.specialize(key);
         descriptor.fragment.as_mut().unwrap().shader = self.shader.clone();
         descriptor.layout = Some(vec![
-            self.pbr_pipeline.view_layout.clone(),
-            self.pbr_pipeline.mesh_layout.clone(),
+            self.mesh_pipeline.view_layout.clone(),
             self.material_layout.clone(),
+            self.mesh_pipeline.mesh_layout.clone(),
         ]);
         descriptor
     }
@@ -167,8 +166,8 @@ impl FromWorld for CustomPipeline {
         });
 
         CustomPipeline {
-            pbr_pipeline: world.get_resource::<PbrPipeline>().unwrap().clone(),
-            shader: asset_server.load("shaders/custom.wgsl"),
+            mesh_pipeline: world.get_resource::<MeshPipeline>().unwrap().clone(),
+            shader: asset_server.load("shaders/custom_material.wgsl"),
             material_layout,
         }
     }
@@ -189,7 +188,7 @@ pub fn queue_custom(
         .read()
         .get_id::<DrawCustom>()
         .unwrap();
-    let key = PbrPipelineKey::from_msaa_samples(msaa.samples);
+    let key = MeshPipelineKey::from_msaa_samples(msaa.samples);
     for (view, mut transparent_phase) in views.iter_mut() {
         let view_matrix = view.transform.compute_matrix();
         let view_row_2 = view_matrix.row(2);
@@ -213,8 +212,8 @@ pub fn queue_custom(
 type DrawCustom = (
     SetItemPipeline,
     SetMeshViewBindGroup<0>,
-    SetTransformBindGroup<1>,
     SetCustomMaterialBindGroup,
+    SetMeshBindGroup<2>,
     DrawMesh,
 );
 
@@ -229,9 +228,10 @@ impl EntityRenderCommand for SetCustomMaterialBindGroup {
         item: Entity,
         (materials, query): SystemParamItem<'w, '_, Self::Param>,
         pass: &mut TrackedRenderPass<'w>,
-    ) {
+    ) -> RenderCommandResult {
         let material_handle = query.get(item).unwrap();
         let material = materials.into_inner().get(material_handle).unwrap();
-        pass.set_bind_group(2, &material.bind_group, &[]);
+        pass.set_bind_group(1, &material.bind_group, &[]);
+        RenderCommandResult::Success
     }
 }

examples/shader/custom_shader_pipelined.rs

@@ -4,8 +4,8 @@ use bevy::{
     ecs::prelude::*,
     math::Vec3,
     pbr2::{
-        DrawMesh, MeshUniform, PbrPipeline, PbrPipelineKey, SetMeshViewBindGroup,
-        SetTransformBindGroup,
+        DrawMesh, MeshPipeline, MeshPipelineKey, MeshUniform, SetMeshBindGroup,
+        SetMeshViewBindGroup,
     },
     prelude::{App, AssetServer, Assets, GlobalTransform, Handle, Plugin, Transform},
     render2::{
@@ -86,39 +86,39 @@ fn setup(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>) {
 }
 
 struct IsRedPipeline {
+    mesh_pipline: MeshPipeline,
     shader: Handle<Shader>,
-    pbr_pipeline: PbrPipeline,
 }
 
 impl FromWorld for IsRedPipeline {
     fn from_world(world: &mut World) -> Self {
         let asset_server = world.get_resource::<AssetServer>().unwrap();
-        let pbr_pipeline = world.get_resource::<PbrPipeline>().unwrap();
+        let mesh_pipeline = world.get_resource::<MeshPipeline>().unwrap();
         let shader = asset_server.load("shaders/shader_defs.wgsl");
         IsRedPipeline {
+            mesh_pipline: mesh_pipeline.clone(),
             shader,
-            pbr_pipeline: pbr_pipeline.clone(),
         }
     }
 }
 
 impl SpecializedPipeline for IsRedPipeline {
-    type Key = (IsRed, PbrPipelineKey);
+    type Key = (IsRed, MeshPipelineKey);
 
     fn specialize(&self, (is_red, pbr_pipeline_key): Self::Key) -> RenderPipelineDescriptor {
         let mut shader_defs = Vec::new();
         if is_red.0 {
             shader_defs.push("IS_RED".to_string());
         }
-        let mut descriptor = self.pbr_pipeline.specialize(pbr_pipeline_key);
+        let mut descriptor = self.mesh_pipline.specialize(pbr_pipeline_key);
         descriptor.vertex.shader = self.shader.clone();
         descriptor.vertex.shader_defs = shader_defs.clone();
         let fragment = descriptor.fragment.as_mut().unwrap();
         fragment.shader = self.shader.clone();
         fragment.shader_defs = shader_defs;
         descriptor.layout = Some(vec![
-            self.pbr_pipeline.view_layout.clone(),
-            self.pbr_pipeline.mesh_layout.clone(),
+            self.mesh_pipline.view_layout.clone(),
+            self.mesh_pipline.mesh_layout.clone(),
         ]);
         descriptor
     }
@@ -127,7 +127,7 @@ impl SpecializedPipeline for IsRedPipeline {
 type DrawIsRed = (
     SetItemPipeline,
     SetMeshViewBindGroup<0>,
-    SetTransformBindGroup<1>,
+    SetMeshBindGroup<1>,
     DrawMesh,
 );
 
@@ -144,7 +144,7 @@ fn queue_custom(
         .read()
         .get_id::<DrawIsRed>()
         .unwrap();
-    let key = PbrPipelineKey::from_msaa_samples(msaa.samples);
+    let key = MeshPipelineKey::from_msaa_samples(msaa.samples);
     for (view, mut transparent_phase) in views.iter_mut() {
         let view_matrix = view.transform.compute_matrix();
         let view_row_2 = view_matrix.row(2);

examples/shader/shader_defs_pipelined.rs

@@ -3,7 +3,7 @@ use bevy_reflect::Reflect;
 
 // FIXME: This should probably be part of bevy_render2!
 /// Alpha mode
-#[derive(Debug, Reflect, Clone, PartialEq)]
+#[derive(Debug, Reflect, Copy, Clone, PartialEq)]
 #[reflect(Component)]
 pub enum AlphaMode {
     Opaque,

pipelined/bevy_pbr2/src/alpha.rs

@@ -16,7 +16,7 @@ use bevy_core_pipeline::{AlphaMask3d, Opaque3d, Transparent3d};
 use bevy_ecs::prelude::*;
 use bevy_reflect::TypeUuid;
 use bevy_render2::{
-    render_component::{ExtractComponentPlugin, UniformComponentPlugin},
+    render_component::ExtractComponentPlugin,
     render_graph::RenderGraph,
     render_phase::{sort_phase_system, AddRenderCommand, DrawFunctions},
     render_resource::{Shader, SpecializedPipelines},
@@ -44,14 +44,18 @@ pub struct PbrPlugin;
 impl Plugin for PbrPlugin {
     fn build(&self, app: &mut App) {
         let mut shaders = app.world.get_resource_mut::<Assets<Shader>>().unwrap();
-        let pbr_shader = Shader::from_wgsl(include_str!("render/pbr.wgsl"));
-        shaders.set_untracked(PBR_SHADER_HANDLE, pbr_shader);
-        let shadow_shader = Shader::from_wgsl(include_str!("render/depth.wgsl"));
-        shaders.set_untracked(SHADOW_SHADER_HANDLE, shadow_shader);
+        shaders.set_untracked(
+            PBR_SHADER_HANDLE,
+            Shader::from_wgsl(include_str!("render/pbr.wgsl")),
+        );
+        shaders.set_untracked(
+            SHADOW_SHADER_HANDLE,
+            Shader::from_wgsl(include_str!("render/depth.wgsl")),
+        );
 
         app.add_plugin(StandardMaterialPlugin)
+            .add_plugin(MeshRenderPlugin)
             .add_plugin(ExtractComponentPlugin::<Handle<StandardMaterial>>::default())
-            .add_plugin(UniformComponentPlugin::<MeshUniform>::default())
             .init_resource::<AmbientLight>()
             .init_resource::<DirectionalLightShadowMap>()
             .init_resource::<PointLightShadowMap>()
@@ -84,7 +88,6 @@ impl Plugin for PbrPlugin {
 
         let render_app = app.sub_app(RenderApp);
         render_app
-            .add_system_to_stage(RenderStage::Extract, render::extract_meshes)
             .add_system_to_stage(
                 RenderStage::Extract,
                 render::extract_lights.label(RenderLightSystems::ExtractLights),
@@ -97,13 +100,12 @@ impl Plugin for PbrPlugin {
                     .exclusive_system()
                     .label(RenderLightSystems::PrepareLights),
             )
-            .add_system_to_stage(RenderStage::Queue, render::queue_meshes)
             .add_system_to_stage(
                 RenderStage::Queue,
                 render::queue_shadows.label(RenderLightSystems::QueueShadows),
             )
+            .add_system_to_stage(RenderStage::Queue, queue_meshes)
             .add_system_to_stage(RenderStage::Queue, render::queue_shadow_view_bind_group)
-            .add_system_to_stage(RenderStage::Queue, render::queue_transform_bind_group)
             .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<Shadow>)
             .init_resource::<PbrPipeline>()
             .init_resource::<ShadowPipeline>()

pipelined/bevy_pbr2/src/lib.rs

@@ -163,38 +163,44 @@ impl RenderAsset for StandardMaterial {
         material: Self::ExtractedAsset,
         (render_device, pbr_pipeline, gpu_images): &mut SystemParamItem<Self::Param>,
     ) -> Result<Self::PreparedAsset, PrepareAssetError<Self::ExtractedAsset>> {
-        let (base_color_texture_view, base_color_sampler) = if let Some(result) =
-            pbr_pipeline.image_handle_to_texture(gpu_images, &material.base_color_texture)
+        let (base_color_texture_view, base_color_sampler) = if let Some(result) = pbr_pipeline
+            .mesh_pipeline
+            .get_image_texture(gpu_images, &material.base_color_texture)
         {
             result
         } else {
             return Err(PrepareAssetError::RetryNextUpdate(material));
         };
 
-        let (emissive_texture_view, emissive_sampler) = if let Some(result) =
-            pbr_pipeline.image_handle_to_texture(gpu_images, &material.emissive_texture)
+        let (emissive_texture_view, emissive_sampler) = if let Some(result) = pbr_pipeline
+            .mesh_pipeline
+            .get_image_texture(gpu_images, &material.emissive_texture)
         {
             result
         } else {
             return Err(PrepareAssetError::RetryNextUpdate(material));
         };
 
         let (metallic_roughness_texture_view, metallic_roughness_sampler) = if let Some(result) =
-            pbr_pipeline.image_handle_to_texture(gpu_images, &material.metallic_roughness_texture)
+            pbr_pipeline
+                .mesh_pipeline
+                .get_image_texture(gpu_images, &material.metallic_roughness_texture)
         {
             result
         } else {
             return Err(PrepareAssetError::RetryNextUpdate(material));
         };
-        let (normal_map_texture_view, normal_map_sampler) = if let Some(result) =
-            pbr_pipeline.image_handle_to_texture(gpu_images, &material.normal_map_texture)
+        let (normal_map_texture_view, normal_map_sampler) = if let Some(result) = pbr_pipeline
+            .mesh_pipeline
+            .get_image_texture(gpu_images, &material.normal_map_texture)
         {
             result
         } else {
             return Err(PrepareAssetError::RetryNextUpdate(material));
         };
-        let (occlusion_texture_view, occlusion_sampler) = if let Some(result) =
-            pbr_pipeline.image_handle_to_texture(gpu_images, &material.occlusion_texture)
+        let (occlusion_texture_view, occlusion_sampler) = if let Some(result) = pbr_pipeline
+            .mesh_pipeline
+            .get_image_texture(gpu_images, &material.occlusion_texture)
         {
             result
         } else {