Rebase of existing PBR work (#1554)

This is a rebase of StarArawns PBR work from #261 with IngmarBitters work from #1160 cherry-picked on top.

I had to make a few minor changes to make some intermediate commits compile and the end result is not yet 100% what I expected, so there's a bit more work to do.

Co-authored-by: John Mitchell <[email protected]>
Co-authored-by: Ingmar Bitter <[email protected]>

Cargo.toml

@@ -135,6 +135,10 @@ path = "examples/3d/orthographic.rs"
 name = "parenting"
 path = "examples/3d/parenting.rs"
 
+[[example]]
+name = "pbr"
+path = "examples/3d/pbr.rs"
+
 [[example]]
 name = "spawner"
 path = "examples/3d/spawner.rs"

crates/bevy_gltf/src/loader.rs

@@ -277,9 +277,12 @@ fn load_material(material: &Material, load_context: &mut LoadContext) -> Handle<
     load_context.set_labeled_asset(
         &material_label,
         LoadedAsset::new(StandardMaterial {
-            albedo: Color::rgba(color[0], color[1], color[2], color[3]),
-            albedo_texture: texture_handle,
+            base_color: Color::rgba(color[0], color[1], color[2], color[3]),
+            base_color_texture: texture_handle,
+            roughness: pbr.roughness_factor(),
+            metallic: pbr.metallic_factor(),
             unlit: material.unlit(),
+            ..Default::default()
         })
         .with_dependencies(dependencies),
     )

crates/bevy_internal/src/lib.rs

@@ -96,7 +96,6 @@ pub mod gltf {
 #[cfg(feature = "bevy_pbr")]
 pub mod pbr {
     //! Physically based rendering.
-    //! **Note**: true PBR has not yet been implemented; the name `pbr` is aspirational.
     pub use bevy_pbr::*;
 }
 

crates/bevy_pbr/src/entity.rs

@@ -1,4 +1,4 @@
-use crate::{light::Light, material::StandardMaterial, render_graph::FORWARD_PIPELINE_HANDLE};
+use crate::{light::Light, material::StandardMaterial, render_graph::PBR_PIPELINE_HANDLE};
 use bevy_asset::Handle;
 use bevy_ecs::bundle::Bundle;
 use bevy_render::{
@@ -27,7 +27,7 @@ impl Default for PbrBundle {
     fn default() -> Self {
         Self {
             render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
-                FORWARD_PIPELINE_HANDLE.typed(),
+                PBR_PIPELINE_HANDLE.typed(),
             )]),
             mesh: Default::default(),
             visible: Default::default(),

crates/bevy_pbr/src/lib.rs

@@ -42,9 +42,9 @@ impl Plugin for PbrPlugin {
         materials.set_untracked(
             Handle::<StandardMaterial>::default(),
             StandardMaterial {
-                albedo: Color::PINK,
+                base_color: Color::PINK,
                 unlit: true,
-                albedo_texture: None,
+                ..Default::default()
             },
         );
     }

crates/bevy_pbr/src/light.rs

@@ -15,6 +15,8 @@ pub struct Light {
     pub color: Color,
     pub fov: f32,
     pub depth: Range<f32>,
+    pub intensity: f32,
+    pub range: f32,
 }
 
 impl Default for Light {
@@ -23,6 +25,8 @@ impl Default for Light {
             color: Color::rgb(1.0, 1.0, 1.0),
             depth: 0.1..50.0,
             fov: f32::to_radians(60.0),
+            intensity: 200.0,
+            range: 20.0,
         }
     }
 }
@@ -48,10 +52,14 @@ impl LightRaw {
 
         let proj = perspective.get_projection_matrix() * global_transform.compute_matrix();
         let (x, y, z) = global_transform.translation.into();
+
+        // premultiply color by intensity
+        // we don't use the alpha at all, so no reason to multiply only [0..3]
+        let color: [f32; 4] = (light.color * light.intensity).into();
         LightRaw {
             proj: proj.to_cols_array_2d(),
-            pos: [x, y, z, 1.0],
-            color: light.color.into(),
+            pos: [x, y, z, 1.0 / (light.range * light.range)], // pos.w is the attenuation.
+            color,
         }
     }
 }

crates/bevy_pbr/src/material.rs

@@ -3,12 +3,28 @@ use bevy_reflect::TypeUuid;
 use bevy_render::{color::Color, renderer::RenderResources, shader::ShaderDefs, texture::Texture};
 
 /// A material with "standard" properties used in PBR lighting
+/// Standard property values with pictures here https://google.github.io/filament/Material%20Properties.pdf
 #[derive(Debug, RenderResources, ShaderDefs, TypeUuid)]
 #[uuid = "dace545e-4bc6-4595-a79d-c224fc694975"]
 pub struct StandardMaterial {
-    pub albedo: Color,
+    /// Doubles as diffuse albedo for non-metallic, specular for metallic and a mix for everything in between
+    /// If used together with a base_color_texture, this is factored into the final base color
+    /// as `base_color * base_color_texture_value`
+    pub base_color: Color,
     #[shader_def]
-    pub albedo_texture: Option<Handle<Texture>>,
+    pub base_color_texture: Option<Handle<Texture>>,
+    /// Linear perceptual roughness, clamped to [0.089, 1.0] in the shader
+    /// Defaults to minimum of 0.089
+    /// If used together with a roughness/metallic texture, this is factored into the final base color
+    /// as `roughness * roughness_texture_value`
+    pub roughness: f32,
+    /// From [0.0, 1.0], dielectric to pure metallic
+    /// If used together with a roughness/metallic texture, this is factored into the final base color
+    /// as `metallic * metallic_texture_value`
+    pub metallic: f32,
+    /// Specular intensity for non-metals on a linear scale of [0.0, 1.0]
+    /// defaults to 0.5 which is mapped to 4% reflectance in the shader
+    pub reflectance: f32,
     #[render_resources(ignore)]
     #[shader_def]
     pub unlit: bool,
@@ -17,8 +33,19 @@ pub struct StandardMaterial {
 impl Default for StandardMaterial {
     fn default() -> Self {
         StandardMaterial {
-            albedo: Color::rgb(1.0, 1.0, 1.0),
-            albedo_texture: None,
+            base_color: Color::rgb(1.0, 1.0, 1.0),
+            base_color_texture: None,
+            // This is the minimum the roughness is clamped to in shader code
+            // See https://google.github.io/filament/Filament.html#materialsystem/parameterization/
+            // It's the minimum floating point value that won't be rounded down to 0 in the calculations used.
+            // Although technically for 32-bit floats, 0.045 could be used.
+            roughness: 0.089,
+            // Few materials are purely dielectric or metallic
+            // This is just a default for mostly-dielectric
+            metallic: 0.01,
+            // Minimum real-world reflectance is 2%, most materials between 2-5%
+            // Expressed in a linear scale and equivalent to 4% reflectance see https://google.github.io/filament/Material%20Properties.pdf
+            reflectance: 0.5,
             unlit: false,
         }
     }
@@ -27,7 +54,7 @@ impl Default for StandardMaterial {
 impl From<Color> for StandardMaterial {
     fn from(color: Color) -> Self {
         StandardMaterial {
-            albedo: color,
+            base_color: color,
             ..Default::default()
         }
     }
@@ -36,7 +63,7 @@ impl From<Color> for StandardMaterial {
 impl From<Handle<Texture>> for StandardMaterial {
     fn from(texture: Handle<Texture>) -> Self {
         StandardMaterial {
-            albedo_texture: Some(texture),
+            base_color_texture: Some(texture),
             ..Default::default()
         }
     }

crates/bevy_pbr/src/render_graph/mod.rs

@@ -1,9 +1,9 @@
-mod forward_pipeline;
 mod lights_node;
+mod pbr_pipeline;
 
 use bevy_ecs::world::World;
-pub use forward_pipeline::*;
 pub use lights_node::*;
+pub use pbr_pipeline::*;
 
 /// the names of pbr graph nodes
 pub mod node {
@@ -50,10 +50,9 @@ pub(crate) fn add_pbr_graph(world: &mut World) {
             .add_node_edge(node::LIGHTS, base::node::MAIN_PASS)
             .unwrap();
     }
-    let forward_pipeline =
-        build_forward_pipeline(&mut world.get_resource_mut::<Assets<Shader>>().unwrap());
+    let pipeline = build_pbr_pipeline(&mut world.get_resource_mut::<Assets<Shader>>().unwrap());
     let mut pipelines = world
         .get_resource_mut::<Assets<PipelineDescriptor>>()
         .unwrap();
-    pipelines.set_untracked(FORWARD_PIPELINE_HANDLE, forward_pipeline);
+    pipelines.set_untracked(PBR_PIPELINE_HANDLE, pipeline);
 }

crates/bevy_pbr/src/render_graph/forward_pipeline/mod.rs → crates/bevy_pbr/src/render_graph/pbr_pipeline/mod.rs

@@ -9,10 +9,10 @@ use bevy_render::{
     texture::TextureFormat,
 };
 
-pub const FORWARD_PIPELINE_HANDLE: HandleUntyped =
+pub const PBR_PIPELINE_HANDLE: HandleUntyped =
     HandleUntyped::weak_from_u64(PipelineDescriptor::TYPE_UUID, 13148362314012771389);
 
-pub(crate) fn build_forward_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor {
+pub(crate) fn build_pbr_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor {
     PipelineDescriptor {
         depth_stencil: Some(DepthStencilState {
             format: TextureFormat::Depth32Float,
@@ -48,11 +48,11 @@ pub(crate) fn build_forward_pipeline(shaders: &mut Assets<Shader>) -> PipelineDe
         ..PipelineDescriptor::new(ShaderStages {
             vertex: shaders.add(Shader::from_glsl(
                 ShaderStage::Vertex,
-                include_str!("forward.vert"),
+                include_str!("pbr.vert"),
             )),
             fragment: Some(shaders.add(Shader::from_glsl(
                 ShaderStage::Fragment,
-                include_str!("forward.frag"),
+                include_str!("pbr.frag"),
             ))),
         })
     }