Move MaterialProperties and MaterialPipeline to bevy_material

Author: Zeophlite

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -846,6 +846,10 @@ pub fn prepare_core_3d_depth_textures(
     }
 }
 
+/// A material can specify [`MaterialProperties::reads_view_transmission_texture`](`bevy_material::material::MaterialProperties`) to read from [`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.
 #[derive(Component)]
 pub struct ViewTransmissionTexture {
     pub texture: Texture,

crates/bevy_gizmos_render/src/pipeline_3d.rs

@@ -21,7 +21,7 @@ use bevy_ecs::{
     system::{Commands, Query, Res, ResMut},
 };
 use bevy_image::BevyDefault as _;
-use bevy_pbr::{MeshPipeline, MeshPipelineKey, SetMeshViewBindGroup};
+use bevy_pbr::{init_mesh_pipeline, MeshPipeline, MeshPipelineKey, SetMeshViewBindGroup};
 use bevy_render::{
     render_asset::{prepare_assets, RenderAssets},
     render_phase::{
@@ -56,7 +56,9 @@ impl Plugin for LineGizmo3dPlugin {
             )
             .add_systems(
                 RenderStartup,
-                init_line_gizmo_pipelines.after(init_line_gizmo_uniform_bind_group_layout),
+                init_line_gizmo_pipelines
+                    .after(init_line_gizmo_uniform_bind_group_layout)
+                    .after(init_mesh_pipeline),
             )
             .add_systems(
                 Render,

crates/bevy_internal/Cargo.toml

@@ -235,11 +235,7 @@ bevy_window = ["dep:bevy_window", "dep:bevy_a11y", "bevy_image"]
 bevy_winit = ["dep:bevy_winit", "bevy_window"]
 bevy_camera = ["dep:bevy_camera", "bevy_mesh", "bevy_window"]
 bevy_scene = ["dep:bevy_scene", "bevy_asset"]
-bevy_material = [
-  "dep:bevy_material",
-  "bevy_image",
-  "bevy_shader",
-]
+bevy_material = ["dep:bevy_material", "bevy_image", "bevy_shader"]
 bevy_light = ["dep:bevy_light", "bevy_camera", "bevy_gizmos?/bevy_light"]
 bevy_render = [
   "dep:bevy_render",

crates/bevy_material/src/lib.rs

@@ -1,5 +1,5 @@
 //! Provides a material abstraction for bevy
-#![allow(missing_docs)]
+#![allow(missing_docs, reason = "Needs docs")]
 
 extern crate alloc;
 

crates/bevy_material/src/material.rs

@@ -1,13 +1,33 @@
+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 core::any::{Any, TypeId};
-use core::hash::{BuildHasher, Hasher};
 use core::hash::Hash;
+use core::hash::{BuildHasher, Hasher};
+use smallvec::SmallVec;
 
 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 +114,83 @@ 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.
+    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 a view transmission texture
+    ///
+    /// This allows taking color output from the opaque 3d pass as an input, (for screen-space transmission) but requires
+    /// rendering to take place in a separate transmissive 3d 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 {
@@ -104,4 +200,3 @@ pub enum RenderPhaseType {
     Transmissive,
     Transparent,
 }
-

crates/bevy_material/src/render/mesh.rs

@@ -1,12 +1,16 @@
+use crate::{
+    render::{
+        MeshLayouts, MeshPipelineViewLayout, MeshPipelineViewLayoutKey, MeshPipelineViewLayouts,
+    },
+    render_resource::*,
+};
 use bevy_asset::Handle;
 use bevy_ecs::resource::Resource;
 use bevy_mesh::BaseMeshPipelineKey;
 use bevy_shader::Shader;
-use crate::{render::{MeshLayouts, MeshPipelineViewLayout, MeshPipelineViewLayoutKey, MeshPipelineViewLayouts}, render_resource::*};
 
 use static_assertions::const_assert_eq;
 
-
 /// How many textures are allowed in the view bind group layout (`@group(0)`) before
 /// broader compatibility with WebGL and WebGPU is at risk, due to the minimum guaranteed
 /// values for `MAX_TEXTURE_IMAGE_UNITS` (in WebGL) and `maxSampledTexturesPerShaderStage` (in WebGPU),
@@ -18,7 +22,6 @@ use static_assertions::const_assert_eq;
 #[cfg(debug_assertions)]
 pub const MESH_PIPELINE_VIEW_LAYOUT_SAFE_MAX_TEXTURES: usize = 10;
 
-
 /// All data needed to construct a pipeline for rendering 3D meshes.
 #[derive(Resource, Clone)]
 pub struct MeshPipeline {
@@ -223,4 +226,3 @@ const_assert_eq!(
         & MeshPipelineKey::ALL_RESERVED_BITS.bits(),
     0
 );
-

crates/bevy_material/src/render/mesh_bindings.rs

@@ -1,8 +1,6 @@
-
 use crate::render_resource::BindGroupLayoutDescriptor;
 
-
-/// All possible [`BindGroupLayout`]s in bevy's default mesh shader (`mesh.wgsl`).
+/// All possible [`BindGroupLayoutDescriptor`]s in bevy's default mesh shader (`mesh.wgsl`).
 #[derive(Clone)]
 pub struct MeshLayouts {
     /// The mesh model uniform (transform) and nothing else.
@@ -18,19 +16,15 @@ pub struct MeshLayouts {
     /// frame's joint matrices, so that we can compute motion vectors.
     pub skinned_motion: BindGroupLayoutDescriptor,
 
-    /// Also includes the uniform and [`MorphAttributes`] for morph targets.
-    ///
-    /// [`MorphAttributes`]: bevy_mesh::morph::MorphAttributes
+    /// Also includes the uniform and [`MorphAttributes`](`bevy_mesh::morph::MorphAttributes`) for morph targets.
     pub morphed: BindGroupLayoutDescriptor,
 
     /// Like [`MeshLayouts::morphed`], but includes a slot for the previous
     /// frame's morph weights, so that we can compute motion vectors.
     pub morphed_motion: BindGroupLayoutDescriptor,
 
     /// Also includes both uniforms for skinning and morph targets, also the
-    /// morph target [`MorphAttributes`] binding.
-    ///
-    /// [`MorphAttributes`]: bevy_mesh::morph::MorphAttributes
+    /// morph target [`MorphAttributes`](`bevy_mesh::morph::MorphAttributes`) binding.
     pub morphed_skinned: BindGroupLayoutDescriptor,
 
     /// Like [`MeshLayouts::morphed_skinned`], but includes slots for the

crates/bevy_material/src/render/mesh_view_bindings.rs

@@ -1,11 +1,7 @@
+use crate::{render::MeshPipelineKey, render_resource::*};
 use alloc::sync::Arc;
 use bevy_derive::{Deref, DerefMut};
-use bevy_ecs::{
-    resource::Resource,
-};
-use crate::{
-    render::MeshPipelineKey, render_resource::*
-};
+use bevy_ecs::resource::Resource;
 
 #[cfg(debug_assertions)]
 use {crate::render::MESH_PIPELINE_VIEW_LAYOUT_SAFE_MAX_TEXTURES, bevy_utils::once, tracing::warn};
@@ -135,4 +131,3 @@ impl MeshPipelineViewLayouts {
         layout
     }
 }
-

crates/bevy_material/src/render_phase/draw.rs

@@ -1,7 +1,6 @@
 use core::{fmt::Debug, hash::Hash};
 
 // TODO: make this generic?
-/// An identifier for a [`Draw`] function stored in [`DrawFunctions`].
+/// An identifier for a draw functions stored.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
 pub struct DrawFunctionId(pub u32);
-

crates/bevy_material/src/render_resource/mod.rs

@@ -1,11 +1,9 @@
 mod bind_group_layout_entries;
 mod pipeline;
-// mod pipeline_cache;
 mod pipeline_specializer;
 
 pub use bind_group_layout_entries::*;
 pub use pipeline::*;
-// pub use pipeline_cache::*;
 pub use pipeline_specializer::*;
 
 // TODO: decide where re-exports should go