Materials and MaterialPlugin (bevyengine#3428)

This adds "high level" `Material` and `SpecializedMaterial` traits, which can be used with a `MaterialPlugin<T: SpecializedMaterial>`. `MaterialPlugin` automatically registers the appropriate resources, draw functions, and queue systems. The `Material` trait is simpler, and should cover most use cases. `SpecializedMaterial` is like `Material`, but it also requires defining a "specialization key" (see bevyengine#3031). `Material` has a trivial blanket impl of `SpecializedMaterial`, which allows us to use the same types + functions for both.

This makes defining custom 3d materials much simpler (see the `shader_material` example diff) and ensures consistent behavior across all 3d materials (both built in and custom). I ported the built in `StandardMaterial` to `MaterialPlugin`. There is also a new `MaterialMeshBundle<T: SpecializedMaterial>`, which `PbrBundle` aliases to.

crates/bevy_pbr/Cargo.toml

@@ -29,4 +29,3 @@ bevy_window = { path = "../bevy_window", version = "0.5.0" }
 bitflags = "1.2"
 # direct dependency required for derive macro
 bytemuck = { version = "1", features = ["derive"] }
-wgpu = { version = "0.12.0", features = ["spirv"] }

crates/bevy_pbr/src/bundle.rs

@@ -1,4 +1,4 @@
-use crate::{DirectionalLight, PointLight, StandardMaterial, DEFAULT_STANDARD_MATERIAL_HANDLE};
+use crate::{DirectionalLight, PointLight, SpecializedMaterial, StandardMaterial};
 use bevy_asset::Handle;
 use bevy_ecs::{bundle::Bundle, component::Component};
 use bevy_render::{
@@ -9,10 +9,13 @@ use bevy_render::{
 use bevy_transform::components::{GlobalTransform, Transform};
 
 /// A component bundle for PBR entities with a [`Mesh`] and a [`StandardMaterial`].
+pub type PbrBundle = MaterialMeshBundle<StandardMaterial>;
+
+/// A component bundle for entities with a [`Mesh`] and a [`SpecializedMaterial`].
 #[derive(Bundle, Clone)]
-pub struct PbrBundle {
+pub struct MaterialMeshBundle<M: SpecializedMaterial> {
     pub mesh: Handle<Mesh>,
-    pub material: Handle<StandardMaterial>,
+    pub material: Handle<M>,
     pub transform: Transform,
     pub global_transform: GlobalTransform,
     /// User indication of whether an entity is visible
@@ -21,11 +24,11 @@ pub struct PbrBundle {
     pub computed_visibility: ComputedVisibility,
 }
 
-impl Default for PbrBundle {
+impl<M: SpecializedMaterial> Default for MaterialMeshBundle<M> {
     fn default() -> Self {
         Self {
             mesh: Default::default(),
-            material: DEFAULT_STANDARD_MATERIAL_HANDLE.typed(),
+            material: Default::default(),
             transform: Default::default(),
             global_transform: Default::default(),
             visibility: Default::default(),

crates/bevy_pbr/src/lib.rs

@@ -4,21 +4,24 @@ mod alpha;
 mod bundle;
 mod light;
 mod material;
+mod pbr_material;
 mod render;
 
 pub use alpha::*;
 pub use bundle::*;
 pub use light::*;
 pub use material::*;
+pub use pbr_material::*;
 pub use render::*;
 
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
         alpha::AlphaMode,
-        bundle::{DirectionalLightBundle, PbrBundle, PointLightBundle},
+        bundle::{DirectionalLightBundle, MaterialMeshBundle, PbrBundle, PointLightBundle},
         light::{AmbientLight, DirectionalLight, PointLight},
-        material::StandardMaterial,
+        material::{Material, MaterialPlugin},
+        pbr_material::StandardMaterial,
     };
 }
 
@@ -31,7 +34,6 @@ pub mod draw_3d_graph {
 
 use bevy_app::prelude::*;
 use bevy_asset::{Assets, Handle, HandleUntyped};
-use bevy_core_pipeline::{AlphaMask3d, Opaque3d, Transparent3d};
 use bevy_ecs::prelude::*;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
@@ -66,8 +68,8 @@ impl Plugin for PbrPlugin {
             Shader::from_wgsl(include_str!("render/depth.wgsl")),
         );
 
-        app.add_plugin(StandardMaterialPlugin)
-            .add_plugin(MeshRenderPlugin)
+        app.add_plugin(MeshRenderPlugin)
+            .add_plugin(MaterialPlugin::<StandardMaterial>::default())
             .add_plugin(ExtractComponentPlugin::<Handle<StandardMaterial>>::default())
             .init_resource::<AmbientLight>()
             .init_resource::<DirectionalLightShadowMap>()
@@ -127,7 +129,7 @@ impl Plugin for PbrPlugin {
             .get_resource_mut::<Assets<StandardMaterial>>()
             .unwrap()
             .set_untracked(
-                DEFAULT_STANDARD_MATERIAL_HANDLE,
+                Handle::<StandardMaterial>::default(),
                 StandardMaterial {
                     base_color: Color::rgb(1.0, 0.0, 0.5),
                     unlit: true,
@@ -166,21 +168,15 @@ impl Plugin for PbrPlugin {
                 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::PhaseSort, sort_phase_system::<Shadow>)
-            .init_resource::<PbrPipeline>()
             .init_resource::<ShadowPipeline>()
             .init_resource::<DrawFunctions<Shadow>>()
             .init_resource::<LightMeta>()
             .init_resource::<GlobalLightMeta>()
-            .init_resource::<SpecializedPipelines<PbrPipeline>>()
             .init_resource::<SpecializedPipelines<ShadowPipeline>>();
 
         let shadow_pass_node = ShadowPassNode::new(&mut render_app.world);
-        render_app.add_render_command::<Opaque3d, DrawPbr>();
-        render_app.add_render_command::<AlphaMask3d, DrawPbr>();
-        render_app.add_render_command::<Transparent3d, DrawPbr>();
         render_app.add_render_command::<Shadow, DrawShadowMesh>();
         let mut graph = render_app.world.get_resource_mut::<RenderGraph>().unwrap();
         let draw_3d_graph = graph