[Merged by Bors] - Pipeline Specialization, Shader Assets, and Shader Preprocessing

Cargo.toml

@@ -471,6 +471,10 @@ path = "examples/shader/shader_defs.rs"
 name = "custom_shader_pipelined"
 path = "examples/shader/custom_shader_pipelined.rs"
 
+[[example]]
+name = "shader_defs_pipelined"
+path = "examples/shader/shader_defs_pipelined.rs"
+
 # Tools
 [[example]]
 name = "bevymark"

assets/shaders/shader_defs.wgsl

@@ -0,0 +1,43 @@
+[[block]]
+struct View {
+    view_proj: mat4x4<f32>;
+    projection: mat4x4<f32>;
+    world_position: vec3<f32>;
+};
+[[group(0), binding(0)]]
+var<uniform> view: View;
+
+[[block]]
+struct Mesh {
+    transform: mat4x4<f32>;
+};
+[[group(1), binding(0)]]
+var<uniform> mesh: Mesh;
+
+struct Vertex {
+    [[location(0)]] position: vec3<f32>;
+    [[location(1)]] normal: vec3<f32>;
+    [[location(2)]] uv: vec2<f32>;
+};
+
+struct VertexOutput {
+    [[builtin(position)]] clip_position: vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vertex(vertex: Vertex) -> VertexOutput {
+    let world_position = mesh.transform * vec4<f32>(vertex.position, 1.0);
+
+    var out: VertexOutput;
+    out.clip_position = view.view_proj * world_position;
+    return out;
+}
+
+[[stage(fragment)]]
+fn fragment() -> [[location(0)]] vec4<f32> {
+    var color = vec4<f32>(0.0, 0.0, 1.0, 1.0);
+# ifdef IS_RED 
+    color = vec4<f32>(1.0, 0.0, 0.0, 1.0);
+# endif
+    return color;
+}

examples/shader/custom_shader_pipelined.rs

@@ -1,13 +1,16 @@
 use bevy::{
-    core_pipeline::Transparent3d,
+    core_pipeline::{SetItemPipeline, Transparent3d},
     diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
     ecs::{
         prelude::*,
         system::{lifetimeless::*, SystemParamItem},
     },
     math::{Vec3, Vec4},
-    pbr2::{DrawMesh, MeshUniform, PbrShaders, SetMeshViewBindGroup, SetTransformBindGroup},
-    prelude::{AddAsset, App, Assets, GlobalTransform, Handle, Plugin, Transform},
+    pbr2::{
+        DrawMesh, MeshUniform, PbrPipeline, PbrPipelineKey, SetMeshViewBindGroup,
+        SetTransformBindGroup,
+    },
+    prelude::{AddAsset, App, AssetServer, Assets, GlobalTransform, Handle, Plugin, Transform},
     reflect::TypeUuid,
     render2::{
         camera::PerspectiveCameraBundle,
@@ -20,15 +23,46 @@ use bevy::{
         },
         render_resource::*,
         renderer::RenderDevice,
-        shader::Shader,
-        texture::BevyDefault,
         view::ExtractedView,
         RenderApp, RenderStage,
     },
     PipelinedDefaultPlugins,
 };
 use crevice::std140::{AsStd140, Std140};
 
+fn main() {
+    App::new()
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_plugin(FrameTimeDiagnosticsPlugin::default())
+        .add_plugin(LogDiagnosticsPlugin::default())
+        .add_plugin(CustomMaterialPlugin)
+        .add_startup_system(setup)
+        .run();
+}
+
+/// set up a simple 3D scene
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<CustomMaterial>>,
+) {
+    // cube
+    commands.spawn().insert_bundle((
+        meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+        Transform::from_xyz(0.0, 0.5, 0.0),
+        GlobalTransform::default(),
+        materials.add(CustomMaterial {
+            color: Color::GREEN,
+        }),
+    ));
+
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..Default::default()
+    });
+}
+
 #[derive(Debug, Clone, TypeUuid)]
 #[uuid = "4ee9c363-1124-4113-890e-199d81b00281"]
 pub struct CustomMaterial {
@@ -88,51 +122,18 @@ impl Plugin for CustomMaterialPlugin {
     }
 }
 
-fn main() {
-    App::new()
-        .add_plugins(PipelinedDefaultPlugins)
-        .add_plugin(FrameTimeDiagnosticsPlugin::default())
-        .add_plugin(LogDiagnosticsPlugin::default())
-        .add_plugin(CustomMaterialPlugin)
-        .add_startup_system(setup)
-        .run();
-}
-
-/// set up a simple 3D scene
-fn setup(
-    mut commands: Commands,
-    mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<CustomMaterial>>,
-) {
-    // cube
-    commands.spawn().insert_bundle((
-        meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
-        Transform::from_xyz(0.0, 0.5, 0.0),
-        GlobalTransform::default(),
-        materials.add(CustomMaterial {
-            color: Color::GREEN,
-        }),
-    ));
-
-    // camera
-    commands.spawn_bundle(PerspectiveCameraBundle {
-        transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
-        ..Default::default()
-    });
-}
-
 pub struct CustomPipeline {
     material_layout: BindGroupLayout,
-    pipeline: RenderPipeline,
+    pipeline: CachedPipelineId,
 }
 
-// TODO: this pattern for initializing the shaders / pipeline isn't ideal. this should be handled by the asset system
 impl FromWorld for CustomPipeline {
     fn from_world(world: &mut World) -> Self {
-        let render_device = world.get_resource::<RenderDevice>().unwrap();
-        let shader = Shader::from_wgsl(include_str!("../../assets/shaders/custom.wgsl"));
-        let shader_module = render_device.create_shader_module(&shader);
+        let world = world.cell();
+        let asset_server = world.get_resource::<AssetServer>().unwrap();
+        let shader = asset_server.load("shaders/custom.wgsl");
 
+        let render_device = world.get_resource::<RenderDevice>().unwrap();
         let material_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[BindGroupLayoutEntry {
                 binding: 0,
@@ -146,99 +147,20 @@ impl FromWorld for CustomPipeline {
             }],
             label: None,
         });
-        let pbr_pipeline = world.get_resource::<PbrShaders>().unwrap();
-
-        let pipeline_layout = render_device.create_pipeline_layout(&PipelineLayoutDescriptor {
-            label: None,
-            push_constant_ranges: &[],
-            bind_group_layouts: &[
-                &pbr_pipeline.view_layout,
-                &material_layout,
-                &pbr_pipeline.mesh_layout,
-            ],
-        });
-
-        let pipeline = render_device.create_render_pipeline(&RenderPipelineDescriptor {
-            label: None,
-            vertex: VertexState {
-                buffers: &[VertexBufferLayout {
-                    array_stride: 32,
-                    step_mode: VertexStepMode::Vertex,
-                    attributes: &[
-                        // Position (GOTCHA! Vertex_Position isn't first in the buffer due to how Mesh sorts attributes (alphabetically))
-                        VertexAttribute {
-                            format: VertexFormat::Float32x3,
-                            offset: 12,
-                            shader_location: 0,
-                        },
-                        // Normal
-                        VertexAttribute {
-                            format: VertexFormat::Float32x3,
-                            offset: 0,
-                            shader_location: 1,
-                        },
-                        // Uv
-                        VertexAttribute {
-                            format: VertexFormat::Float32x2,
-                            offset: 24,
-                            shader_location: 2,
-                        },
-                    ],
-                }],
-                module: &shader_module,
-                entry_point: "vertex",
-            },
-            fragment: Some(FragmentState {
-                module: &shader_module,
-                entry_point: "fragment",
-                targets: &[ColorTargetState {
-                    format: TextureFormat::bevy_default(),
-                    blend: Some(BlendState {
-                        color: BlendComponent {
-                            src_factor: BlendFactor::SrcAlpha,
-                            dst_factor: BlendFactor::OneMinusSrcAlpha,
-                            operation: BlendOperation::Add,
-                        },
-                        alpha: BlendComponent {
-                            src_factor: BlendFactor::One,
-                            dst_factor: BlendFactor::One,
-                            operation: BlendOperation::Add,
-                        },
-                    }),
-                    write_mask: ColorWrites::ALL,
-                }],
-            }),
-            depth_stencil: Some(DepthStencilState {
-                format: TextureFormat::Depth32Float,
-                depth_write_enabled: true,
-                depth_compare: CompareFunction::Greater,
-                stencil: StencilState {
-                    front: StencilFaceState::IGNORE,
-                    back: StencilFaceState::IGNORE,
-                    read_mask: 0,
-                    write_mask: 0,
-                },
-                bias: DepthBiasState {
-                    constant: 0,
-                    slope_scale: 0.0,
-                    clamp: 0.0,
-                },
-            }),
-            layout: Some(&pipeline_layout),
-            multisample: MultisampleState::default(),
-            primitive: PrimitiveState {
-                topology: PrimitiveTopology::TriangleList,
-                strip_index_format: None,
-                front_face: FrontFace::Ccw,
-                cull_mode: Some(Face::Back),
-                polygon_mode: PolygonMode::Fill,
-                clamp_depth: false,
-                conservative: false,
-            },
-        });
 
+        let pbr_pipeline = world.get_resource::<PbrPipeline>().unwrap();
+        let mut descriptor = pbr_pipeline.specialize(PbrPipelineKey::empty());
+        descriptor.vertex.shader = shader.clone_weak();
+        descriptor.fragment.as_mut().unwrap().shader = shader.clone_weak();
+        descriptor.layout = Some(vec![
+            pbr_pipeline.view_layout.clone(),
+            material_layout.clone(),
+            pbr_pipeline.mesh_layout.clone(),
+        ]);
+
+        let mut pipeline_cache = world.get_resource_mut::<RenderPipelineCache>().unwrap();
         CustomPipeline {
-            pipeline,
+            pipeline: pipeline_cache.queue(descriptor),
             material_layout,
         }
     }
@@ -247,6 +169,7 @@ impl FromWorld for CustomPipeline {
 pub fn queue_custom(
     transparent_3d_draw_functions: Res<DrawFunctions<Transparent3d>>,
     materials: Res<RenderAssets<CustomMaterial>>,
+    custom_pipeline: Res<CustomPipeline>,
     material_meshes: Query<(Entity, &Handle<CustomMaterial>, &MeshUniform), With<Handle<Mesh>>>,
     mut views: Query<(&ExtractedView, &mut RenderPhase<Transparent3d>)>,
 ) {
@@ -261,6 +184,7 @@ pub fn queue_custom(
             if materials.contains_key(material_handle) {
                 transparent_phase.add(Transparent3d {
                     entity,
+                    pipeline: custom_pipeline.pipeline,
                     draw_function: draw_custom,
                     distance: view_row_2.dot(mesh_uniform.transform.col(3)),
                 });
@@ -270,28 +194,27 @@ pub fn queue_custom(
 }
 
 type DrawCustom = (
-    SetCustomMaterialPipeline,
+    SetItemPipeline,
     SetMeshViewBindGroup<0>,
+    SetCustomMaterialBindGroup,
     SetTransformBindGroup<2>,
     DrawMesh,
 );
 
-struct SetCustomMaterialPipeline;
-impl RenderCommand<Transparent3d> for SetCustomMaterialPipeline {
+struct SetCustomMaterialBindGroup;
+impl RenderCommand<Transparent3d> for SetCustomMaterialBindGroup {
     type Param = (
         SRes<RenderAssets<CustomMaterial>>,
-        SRes<CustomPipeline>,
         SQuery<Read<Handle<CustomMaterial>>>,
     );
     fn render<'w>(
         _view: Entity,
         item: &Transparent3d,
-        (materials, custom_pipeline, query): SystemParamItem<'w, '_, Self::Param>,
+        (materials, query): SystemParamItem<'w, '_, Self::Param>,
         pass: &mut TrackedRenderPass<'w>,
     ) {
         let material_handle = query.get(item.entity).unwrap();
         let material = materials.into_inner().get(material_handle).unwrap();
-        pass.set_render_pipeline(&custom_pipeline.into_inner().pipeline);
         pass.set_bind_group(1, &material.bind_group, &[]);
     }
 }