Type erased materials

Cargo.toml

@@ -566,7 +566,7 @@ ron = "0.10"
 flate2 = "1.0"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1.0.140"
-bytemuck = "1.7"
+bytemuck = "1"
 bevy_render = { path = "crates/bevy_render", version = "0.16.0-dev", default-features = false }
 # The following explicit dependencies are needed for proc macros to work inside of examples as they are part of the bevy crate itself.
 bevy_ecs = { path = "crates/bevy_ecs", version = "0.16.0-dev", default-features = false }
@@ -1027,6 +1027,17 @@ description = "Showcases different blend modes"
 category = "3D Rendering"
 wasm = true
 
+[[example]]
+name = "custom_material_implementation"
+path = "examples/3d/custom_material_implementation.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.custom_material_implementation]
+name = "Custom Material Implementation"
+description = "Demonstrates how to implement a custom material"
+category = "3D Rendering"
+wasm = true
+
 [[example]]
 name = "edit_material_on_gltf"
 path = "examples/3d/edit_material_on_gltf.rs"

assets/shaders/custom_material_implementation.wgsl

@@ -0,0 +1,11 @@
+#import bevy_pbr::forward_io::VertexOutput
+
+@group(2) @binding(0) var material_color_texture: texture_2d<f32>;
+@group(2) @binding(1) var material_color_sampler: sampler;
+
+@fragment
+fn fragment(
+    mesh: VertexOutput,
+) -> @location(0) vec4<f32> {
+    return textureSample(material_color_texture, material_color_sampler, mesh.uv);
+}

crates/bevy_gizmos/src/pipeline_3d.rs

@@ -50,9 +50,7 @@ impl Plugin for LineGizmo3dPlugin {
             .init_resource::<SpecializedRenderPipelines<LineJointGizmoPipeline>>()
             .configure_sets(
                 Render,
-                GizmoRenderSystems::QueueLineGizmos3d
-                    .in_set(RenderSystems::Queue)
-                    .ambiguous_with(bevy_pbr::queue_material_meshes::<bevy_pbr::StandardMaterial>),
+                GizmoRenderSystems::QueueLineGizmos3d.in_set(RenderSystems::Queue),
             )
             .add_systems(
                 Render,

crates/bevy_pbr/Cargo.toml

@@ -51,7 +51,7 @@ bevy_platform = { path = "../bevy_platform", version = "0.16.0-dev", default-fea
 ] }
 
 # other
-bitflags = "2.3"
+bitflags = { version = "2.3", features = ["bytemuck"] }
 fixedbitset = "0.5"
 thiserror = { version = "2", default-features = false }
 derive_more = { version = "1", default-features = false, features = ["from"] }

crates/bevy_pbr/src/extended_material.rs

@@ -1,6 +1,6 @@
 use alloc::borrow::Cow;
 
-use bevy_asset::{Asset, Handle};
+use bevy_asset::Asset;
 use bevy_ecs::system::SystemParamItem;
 use bevy_platform::{collections::HashSet, hash::FixedHasher};
 use bevy_reflect::{impl_type_path, Reflect};
@@ -9,8 +9,8 @@ use bevy_render::{
     mesh::MeshVertexBufferLayoutRef,
     render_resource::{
         AsBindGroup, AsBindGroupError, BindGroupLayout, BindGroupLayoutEntry, BindlessDescriptor,
-        BindlessResourceType, BindlessSlabResourceLimit, RenderPipelineDescriptor, Shader,
-        ShaderRef, SpecializedMeshPipelineError, UnpreparedBindGroup,
+        BindlessResourceType, BindlessSlabResourceLimit, RenderPipelineDescriptor, ShaderRef,
+        SpecializedMeshPipelineError, UnpreparedBindGroup,
     },
     renderer::RenderDevice,
 };
@@ -19,10 +19,6 @@ use crate::{Material, MaterialPipeline, MaterialPipelineKey, MeshPipeline, MeshP
 
 pub struct MaterialExtensionPipeline {
     pub mesh_pipeline: MeshPipeline,
-    pub material_layout: BindGroupLayout,
-    pub vertex_shader: Option<Handle<Shader>>,
-    pub fragment_shader: Option<Handle<Shader>>,
-    pub bindless: bool,
 }
 
 pub struct MaterialExtensionKey<E: MaterialExtension> {
@@ -150,12 +146,19 @@ where
     }
 }
 
+#[derive(bytemuck::Pod, bytemuck::Zeroable, Copy, Clone, PartialEq, Eq, Hash)]
+#[repr(C, packed)]
+pub struct MaterialExtensionBindGroupData<B, E> {
+    pub base: B,
+    pub extension: E,
+}
+
 // We don't use the `TypePath` derive here due to a bug where `#[reflect(type_path = false)]`
 // causes the `TypePath` derive to not generate an implementation.
 impl_type_path!((in bevy_pbr::extended_material) ExtendedMaterial<B: Material, E: MaterialExtension>);
 
 impl<B: Material, E: MaterialExtension> AsBindGroup for ExtendedMaterial<B, E> {
-    type Data = (<B as AsBindGroup>::Data, <E as AsBindGroup>::Data);
+    type Data = MaterialExtensionBindGroupData<B::Data, E::Data>;
     type Param = (<B as AsBindGroup>::Param, <E as AsBindGroup>::Param);
 
     fn bindless_slot_count() -> Option<BindlessSlabResourceLimit> {
@@ -179,20 +182,24 @@ impl<B: Material, E: MaterialExtension> AsBindGroup for ExtendedMaterial<B, E> {
         }
     }
 
+    fn bind_group_data(&self) -> Self::Data {
+        MaterialExtensionBindGroupData {
+            base: self.base.bind_group_data(),
+            extension: self.extension.bind_group_data(),
+        }
+    }
+
     fn unprepared_bind_group(
         &self,
         layout: &BindGroupLayout,
         render_device: &RenderDevice,
         (base_param, extended_param): &mut SystemParamItem<'_, '_, Self::Param>,
         mut force_non_bindless: bool,
-    ) -> Result<UnpreparedBindGroup<Self::Data>, AsBindGroupError> {
+    ) -> Result<UnpreparedBindGroup, AsBindGroupError> {
         force_non_bindless = force_non_bindless || Self::bindless_slot_count().is_none();
 
         // add together the bindings of the base material and the user material
-        let UnpreparedBindGroup {
-            mut bindings,
-            data: base_data,
-        } = B::unprepared_bind_group(
+        let UnpreparedBindGroup { mut bindings } = B::unprepared_bind_group(
             &self.base,
             layout,
             render_device,
@@ -209,10 +216,7 @@ impl<B: Material, E: MaterialExtension> AsBindGroup for ExtendedMaterial<B, E> {
 
         bindings.extend(extended_bindgroup.bindings.0);
 
-        Ok(UnpreparedBindGroup {
-            bindings,
-            data: (base_data, extended_bindgroup.data),
-        })
+        Ok(UnpreparedBindGroup { bindings })
     }
 
     fn bind_group_layout_entries(
@@ -373,57 +377,30 @@ impl<B: Material, E: MaterialExtension> Material for ExtendedMaterial<B, E> {
     }
 
     fn specialize(
-        pipeline: &MaterialPipeline<Self>,
+        pipeline: &MaterialPipeline,
         descriptor: &mut RenderPipelineDescriptor,
         layout: &MeshVertexBufferLayoutRef,
         key: MaterialPipelineKey<Self>,
     ) -> Result<(), SpecializedMeshPipelineError> {
         // Call the base material's specialize function
-        let MaterialPipeline::<Self> {
-            mesh_pipeline,
-            material_layout,
-            vertex_shader,
-            fragment_shader,
-            bindless,
-            ..
-        } = pipeline.clone();
-        let base_pipeline = MaterialPipeline::<B> {
-            mesh_pipeline,
-            material_layout,
-            vertex_shader,
-            fragment_shader,
-            bindless,
-            marker: Default::default(),
-        };
+        let MaterialPipeline { mesh_pipeline } = pipeline.clone();
+        let base_pipeline = MaterialPipeline { mesh_pipeline };
         let base_key = MaterialPipelineKey::<B> {
             mesh_key: key.mesh_key,
-            bind_group_data: key.bind_group_data.0,
+            bind_group_data: key.bind_group_data.base,
         };
         B::specialize(&base_pipeline, descriptor, layout, base_key)?;
 
         // Call the extended material's specialize function afterwards
-        let MaterialPipeline::<Self> {
-            mesh_pipeline,
-            material_layout,
-            vertex_shader,
-            fragment_shader,
-            bindless,
-            ..
-        } = pipeline.clone();
+        let MaterialPipeline { mesh_pipeline, .. } = pipeline.clone();
 
         E::specialize(
-            &MaterialExtensionPipeline {
-                mesh_pipeline,
-                material_layout,
-                vertex_shader,
-                fragment_shader,
-                bindless,
-            },
+            &MaterialExtensionPipeline { mesh_pipeline },
             descriptor,
             layout,
             MaterialExtensionKey {
                 mesh_key: key.mesh_key,
-                bind_group_data: key.bind_group_data.1,
+                bind_group_data: key.bind_group_data.extension,
             },
         )
     }

crates/bevy_pbr/src/lib.rs

@@ -239,6 +239,9 @@ impl Plugin for PbrPlugin {
                     use_gpu_instance_buffer_builder: self.use_gpu_instance_buffer_builder,
                     debug_flags: self.debug_flags,
                 },
+                MaterialsPlugin {
+                    debug_flags: self.debug_flags,
+                },
                 MaterialPlugin::<StandardMaterial> {
                     prepass_enabled: self.prepass_enabled,
                     debug_flags: self.debug_flags,