Move MaterialProperties and MaterialPipeline to bevy_material

Author: Zeophlite

crates/bevy_material/src/material.rs

@@ -1,13 +1,29 @@
+use crate::alpha::AlphaMode;
+use crate::opaque::OpaqueRendererMethod;
+use crate::render::MeshPipeline;
 use crate::render::MeshPipelineKey;
+use crate::render_phase::{DrawFunctionId, DrawFunctionLabel, InternedDrawFunctionLabel, InternedShaderLabel, ShaderLabel};
+use crate::render_resource::{BindGroupLayoutDescriptor, RenderPipelineDescriptor, SpecializedMeshPipelineError};
 use crate::*;
 use alloc::sync::Arc;
+use bevy_asset::Handle;
+use bevy_ecs::resource::Resource;
+use bevy_mesh::MeshVertexBufferLayoutRef;
 use bevy_platform::hash::FixedHasher;
+use bevy_shader::Shader;
+use smallvec::SmallVec;
 use core::any::{Any, TypeId};
 use core::hash::{BuildHasher, Hasher};
 use core::hash::Hash;
 
 pub const MATERIAL_BIND_GROUP_INDEX: usize = 3;
 
+/// Render pipeline data for a given [`Material`].
+#[derive(Resource, Clone)]
+pub struct MaterialPipeline {
+    pub mesh_pipeline: MeshPipeline,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct ErasedMaterialPipelineKey {
     pub mesh_key: MeshPipelineKey,
@@ -94,7 +110,84 @@ impl Default for ErasedMaterialKey {
     }
 }
 
-// pub struct MaterialProperties {
+/// Common [`Material`] properties, calculated for a specific material instance.
+#[derive(Default)]
+pub struct MaterialProperties {
+    /// Is this material should be rendered by the deferred renderer when.
+    /// [`AlphaMode::Opaque`] or [`AlphaMode::Mask`]
+    pub render_method: OpaqueRendererMethod,
+    /// The [`AlphaMode`] of this material.
+    pub alpha_mode: AlphaMode,
+    /// The bits in the [`MeshPipelineKey`] for this material.
+    ///
+    /// These are precalculated so that we can just "or" them together in
+    /// [`queue_material_meshes`].
+    pub mesh_pipeline_key_bits: MeshPipelineKey,
+    /// Add a bias to the view depth of the mesh which can be used to force a specific render order
+    /// for meshes with equal depth, to avoid z-fighting.
+    /// The bias is in depth-texture units so large values may be needed to overcome small depth differences.
+    pub depth_bias: f32,
+    /// Whether the material would like to read from [`ViewTransmissionTexture`](bevy_core_pipeline::core_3d::ViewTransmissionTexture).
+    ///
+    /// This allows taking color output from the [`Opaque3d`] pass as an input, (for screen-space transmission) but requires
+    /// rendering to take place in a separate [`Transmissive3d`] pass.
+    pub reads_view_transmission_texture: bool,
+    pub render_phase_type: RenderPhaseType,
+    pub material_layout: Option<BindGroupLayoutDescriptor>,
+    /// Backing array is a size of 4 because the `StandardMaterial` needs 4 draw functions by default
+    pub draw_functions: SmallVec<[(InternedDrawFunctionLabel, DrawFunctionId); 4]>,
+    /// Backing array is a size of 3 because the `StandardMaterial` has 3 custom shaders (`frag`, `prepass_frag`, `deferred_frag`) which is the
+    /// most common use case
+    pub shaders: SmallVec<[(InternedShaderLabel, Handle<Shader>); 3]>,
+    /// Whether this material *actually* uses bindless resources, taking the
+    /// platform support (or lack thereof) of bindless resources into account.
+    pub bindless: bool,
+    pub specialize: Option<
+        fn(
+            &MaterialPipeline,
+            &mut RenderPipelineDescriptor,
+            &MeshVertexBufferLayoutRef,
+            ErasedMaterialPipelineKey,
+        ) -> Result<(), SpecializedMeshPipelineError>,
+    >,
+    /// The key for this material, typically a bitfield of flags that are used to modify
+    /// the pipeline descriptor used for this material.
+    pub material_key: ErasedMaterialKey,
+    /// Whether shadows are enabled for this material
+    pub shadows_enabled: bool,
+    /// Whether prepass is enabled for this material
+    pub prepass_enabled: bool,
+}
+
+impl MaterialProperties {
+    pub fn get_shader(&self, label: impl ShaderLabel) -> Option<Handle<Shader>> {
+        self.shaders
+            .iter()
+            .find(|(inner_label, _)| inner_label == &label.intern())
+            .map(|(_, shader)| shader)
+            .cloned()
+    }
+
+    pub fn add_shader(&mut self, label: impl ShaderLabel, shader: Handle<Shader>) {
+        self.shaders.push((label.intern(), shader));
+    }
+
+    pub fn get_draw_function(&self, label: impl DrawFunctionLabel) -> Option<DrawFunctionId> {
+        self.draw_functions
+            .iter()
+            .find(|(inner_label, _)| inner_label == &label.intern())
+            .map(|(_, shader)| shader)
+            .cloned()
+    }
+
+    pub fn add_draw_function(
+        &mut self,
+        label: impl DrawFunctionLabel,
+        draw_function: DrawFunctionId,
+    ) {
+        self.draw_functions.push((label.intern(), draw_function));
+    }
+}
 
 #[derive(Clone, Copy, Default)]
 pub enum RenderPhaseType {

crates/bevy_pbr/src/material.rs

@@ -59,7 +59,7 @@ use bevy_render::{
 };
 use bevy_render::{mesh::allocator::MeshAllocator, sync_world::MainEntityHashMap};
 use bevy_render::{texture::FallbackImage, view::RenderVisibleEntities};
-use bevy_shader::{Shader, ShaderDefVal};
+use bevy_shader::ShaderDefVal;
 use bevy_utils::Parallel;
 use core::any::TypeId;
 use core::{hash::Hash, marker::PhantomData};
@@ -431,12 +431,6 @@ pub struct MaterialPipelineKey<M: Material> {
     pub bind_group_data: M::Data,
 }
 
-/// Render pipeline data for a given [`Material`].
-#[derive(Resource, Clone)]
-pub struct MaterialPipeline {
-    pub mesh_pipeline: MeshPipeline,
-}
-
 pub struct MaterialPipelineSpecializer {
     pub(crate) pipeline: MaterialPipeline,
     pub(crate) properties: Arc<MaterialProperties>,
@@ -1274,84 +1268,7 @@ pub struct DeferredDrawFunction;
 #[derive(DrawFunctionLabel, Debug, Hash, PartialEq, Eq, Clone, Default)]
 pub struct ShadowsDrawFunction;
 
-/// Common [`Material`] properties, calculated for a specific material instance.
-#[derive(Default)]
-pub struct MaterialProperties {
-    /// Is this material should be rendered by the deferred renderer when.
-    /// [`AlphaMode::Opaque`] or [`AlphaMode::Mask`]
-    pub render_method: OpaqueRendererMethod,
-    /// The [`AlphaMode`] of this material.
-    pub alpha_mode: AlphaMode,
-    /// The bits in the [`MeshPipelineKey`] for this material.
-    ///
-    /// These are precalculated so that we can just "or" them together in
-    /// [`queue_material_meshes`].
-    pub mesh_pipeline_key_bits: MeshPipelineKey,
-    /// Add a bias to the view depth of the mesh which can be used to force a specific render order
-    /// for meshes with equal depth, to avoid z-fighting.
-    /// The bias is in depth-texture units so large values may be needed to overcome small depth differences.
-    pub depth_bias: f32,
-    /// Whether the material would like to read from [`ViewTransmissionTexture`](bevy_core_pipeline::core_3d::ViewTransmissionTexture).
-    ///
-    /// This allows taking color output from the [`Opaque3d`] pass as an input, (for screen-space transmission) but requires
-    /// rendering to take place in a separate [`Transmissive3d`] pass.
-    pub reads_view_transmission_texture: bool,
-    pub render_phase_type: RenderPhaseType,
-    pub material_layout: Option<BindGroupLayoutDescriptor>,
-    /// Backing array is a size of 4 because the `StandardMaterial` needs 4 draw functions by default
-    pub draw_functions: SmallVec<[(InternedDrawFunctionLabel, DrawFunctionId); 4]>,
-    /// Backing array is a size of 3 because the `StandardMaterial` has 3 custom shaders (`frag`, `prepass_frag`, `deferred_frag`) which is the
-    /// most common use case
-    pub shaders: SmallVec<[(InternedShaderLabel, Handle<Shader>); 3]>,
-    /// Whether this material *actually* uses bindless resources, taking the
-    /// platform support (or lack thereof) of bindless resources into account.
-    pub bindless: bool,
-    pub specialize: Option<
-        fn(
-            &MaterialPipeline,
-            &mut RenderPipelineDescriptor,
-            &MeshVertexBufferLayoutRef,
-            ErasedMaterialPipelineKey,
-        ) -> Result<(), SpecializedMeshPipelineError>,
-    >,
-    /// The key for this material, typically a bitfield of flags that are used to modify
-    /// the pipeline descriptor used for this material.
-    pub material_key: ErasedMaterialKey,
-    /// Whether shadows are enabled for this material
-    pub shadows_enabled: bool,
-    /// Whether prepass is enabled for this material
-    pub prepass_enabled: bool,
-}
-
-impl MaterialProperties {
-    pub fn get_shader(&self, label: impl ShaderLabel) -> Option<Handle<Shader>> {
-        self.shaders
-            .iter()
-            .find(|(inner_label, _)| inner_label == &label.intern())
-            .map(|(_, shader)| shader)
-            .cloned()
-    }
-
-    pub fn add_shader(&mut self, label: impl ShaderLabel, shader: Handle<Shader>) {
-        self.shaders.push((label.intern(), shader));
-    }
-
-    pub fn get_draw_function(&self, label: impl DrawFunctionLabel) -> Option<DrawFunctionId> {
-        self.draw_functions
-            .iter()
-            .find(|(inner_label, _)| inner_label == &label.intern())
-            .map(|(_, shader)| shader)
-            .cloned()
-    }
-
-    pub fn add_draw_function(
-        &mut self,
-        label: impl DrawFunctionLabel,
-        draw_function: DrawFunctionId,
-    ) {
-        self.draw_functions.push((label.intern(), draw_function));
-    }
-}
+pub use bevy_material::material::MaterialProperties;
 
 /// A resource that maps each untyped material ID to its binding.
 ///