Merge remote-tracking branch 'origin/master'

Author: Babylon.js Platform

packages/dev/core/src/Engines/constants.ts

@@ -484,6 +484,33 @@ export class Constants {
      */
     public static readonly MATERIAL_DIFFUSE_MODEL_LAMBERT = 2;
 
+    /**
+     * Specular lighting for dielectric materials follows the logic
+     * in the glTF specification and KHR_materials_specular extension.
+     * Specular colour is applied only at normal incidence (i.e. F0) while
+     * glancing angles (i.e. F90) tend towards white.
+     */
+    public static readonly MATERIAL_DIELECTRIC_SPECULAR_MODEL_GLTF = 0;
+
+    /**
+     * Specular lighting for dielectric materials follows the logic
+     * in the OpenPBR specification. Specular colour is applied to all
+     * dielectric reflection, not just at normal incidence (i.e. F0).
+     */
+    public static readonly MATERIAL_DIELECTRIC_SPECULAR_MODEL_OPENPBR = 1;
+
+    /**
+     * Specular lighting for metals follows the logic in the glTF specification.
+     * Base colour is applied at F0 while glancing angles tend towards white.
+     */
+    public static readonly MATERIAL_CONDUCTOR_SPECULAR_MODEL_GLTF = 0;
+
+    /**
+     * Specular lighting for metals follows the logic in the OpenPBR specification.
+     * Specular colour is applied to glancing angles using the F82 spec.
+     */
+    public static readonly MATERIAL_CONDUCTOR_SPECULAR_MODEL_OPENPBR = 1;
+
     /**
      * Nothing
      * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers

packages/dev/core/src/Materials/Node/Blocks/PBR/pbrMetallicRoughnessBlock.ts

@@ -29,7 +29,7 @@ import { SubSurfaceBlock } from "./subSurfaceBlock";
 import type { RefractionBlock } from "./refractionBlock";
 import type { PerturbNormalBlock } from "../Fragment/perturbNormalBlock";
 import { Constants } from "../../../../Engines/constants";
-import { Color3, TmpColors } from "../../../../Maths/math.color";
+import { Color3 } from "../../../../Maths/math.color";
 import { Logger } from "core/Misc/logger";
 import {
     BindLight,
@@ -889,19 +889,9 @@ export class PBRMetallicRoughnessBlock extends NodeMaterialBlock {
         effect.setFloat4("vLightingIntensity", this.directIntensity, 1, this.environmentIntensity * this._scene.environmentIntensity, this.specularIntensity);
 
         // reflectivity bindings
-        const outsideIOR = 1; // consider air as clear coat and other layers would remap in the shader.
-        const ior = this.indexOfRefraction.connectInputBlock?.value ?? 1.5;
-
-        // We are here deriving our default reflectance from a common value for none metallic surface.
-        // Based of the schlick fresnel approximation model
-        // for dielectrics.
-        const f0 = Math.pow((ior - outsideIOR) / (ior + outsideIOR), 2);
-
-        // Tweak the default F0 and F90 based on our given setup
-        this._metallicReflectanceColor.scaleToRef(f0 * this._metallicF0Factor, TmpColors.Color3[0]);
         const metallicF90 = this._metallicF0Factor;
 
-        effect.setColor4(this._vMetallicReflectanceFactorsName, TmpColors.Color3[0], metallicF90);
+        effect.setColor4(this._vMetallicReflectanceFactorsName, this._metallicReflectanceColor, metallicF90);
 
         if (nodeMaterial.imageProcessingConfiguration) {
             nodeMaterial.imageProcessingConfiguration.bind(effect);
@@ -1034,8 +1024,14 @@ export class PBRMetallicRoughnessBlock extends NodeMaterialBlock {
         this._baseDiffuseRoughnessName = state._getFreeVariableName("baseDiffuseRoughness");
         state._emitUniformFromString(this._baseDiffuseRoughnessName, NodeMaterialBlockConnectionPointTypes.Float);
 
+        const outsideIOR = 1; // consider air as clear coat and other layers would remap in the shader.
+        const ior = this.indexOfRefraction.connectInputBlock?.value ?? 1.5;
+        // Based of the schlick fresnel approximation model
+        // for dielectrics.
+        const f0 = Math.pow((ior - outsideIOR) / (ior + outsideIOR), 2);
+
         code += `${state._declareLocalVar("baseColor", NodeMaterialBlockConnectionPointTypes.Vector3)} = surfaceAlbedo;
-            ${isWebGPU ? "let" : `vec4${state.fSuffix}`} vReflectivityColor = vec4${state.fSuffix}(${this.metallic.associatedVariableName}, ${this.roughness.associatedVariableName}, ${this.indexOfRefraction.associatedVariableName || "1.5"}, 1.0);
+            ${isWebGPU ? "let" : `vec4${state.fSuffix}`} vReflectivityColor = vec4${state.fSuffix}(${this.metallic.associatedVariableName}, ${this.roughness.associatedVariableName}, ${this.indexOfRefraction.associatedVariableName || "1.5"}, ${f0});
             reflectivityOut = reflectivityBlock(
                 vReflectivityColor
             #ifdef METALLICWORKFLOW

packages/dev/core/src/Materials/Node/Blocks/PBR/sheenBlock.ts

@@ -141,7 +141,7 @@ export class SheenBlock extends NodeMaterialBlock {
                 ${isWebGPU ? `, ${texture}Sampler` : ""}
                 , 1.0
             #endif
-                , reflectance
+                , reflectanceF0
             #ifdef SHEEN_LINKWITHALBEDO
                 , baseColor
                 , surfaceAlbedo

packages/dev/core/src/Materials/Node/Blocks/PBR/subSurfaceBlock.ts

@@ -188,7 +188,11 @@ export class SubSurfaceBlock extends NodeMaterialBlock {
                 , vThicknessParam
                 , vTintColor
                 , normalW
-                , specularEnvironmentReflectance
+            #ifdef LEGACY_SPECULAR_ENERGY_CONSERVATION
+                , vec3(max(cumulativeSpecularEnvironmentReflectance.r, max(cumulativeSpecularEnvironmentReflectance.g, cumulativeSpecularEnvironmentReflectance.b)))
+            #else
+                , baseSpecularEnvironmentReflectance
+            #endif
             #ifdef SS_THICKNESSANDMASK_TEXTURE
                 , vec4${state.fSuffix}(0.)
             #endif
@@ -282,7 +286,7 @@ export class SubSurfaceBlock extends NodeMaterialBlock {
                 #endif
             #endif
         #else
-            subSurfaceOut.specularEnvironmentReflectance = specularEnvironmentReflectance;
+            subSurfaceOut.specularEnvironmentReflectance = cumulativeSpecularEnvironmentReflectance;
         #endif\n`;
 
         return code;

packages/dev/core/src/Materials/PBR/pbrBRDFConfiguration.ts

@@ -14,6 +14,7 @@ export class MaterialBRDFDefines extends MaterialDefines {
     SPHERICAL_HARMONICS = false;
     SPECULAR_GLOSSINESS_ENERGY_CONSERVATION = false;
     MIX_IBL_RADIANCE_WITH_IRRADIANCE = true;
+    LEGACY_SPECULAR_ENERGY_CONSERVATION = false;
 }
 
 /**
@@ -53,6 +54,11 @@ export class PBRBRDFConfiguration extends MaterialPluginBase {
      */
     public static DEFAULT_MIX_IBL_RADIANCE_WITH_IRRADIANCE = true;
 
+    /**
+     * Default value for whether the legacy specular energy conservation is used.
+     */
+    public static DEFAULT_USE_LEGACY_SPECULAR_ENERGY_CONSERVATION = true;
+
     private _useEnergyConservation = PBRBRDFConfiguration.DEFAULT_USE_ENERGY_CONSERVATION;
     /**
      * Defines if the material uses energy conservation.
@@ -107,6 +113,15 @@ export class PBRBRDFConfiguration extends MaterialPluginBase {
     @expandToProperty("_markAllSubMeshesAsMiscDirty")
     public mixIblRadianceWithIrradiance = PBRBRDFConfiguration.DEFAULT_MIX_IBL_RADIANCE_WITH_IRRADIANCE;
 
+    private _useLegacySpecularEnergyConservation = PBRBRDFConfiguration.DEFAULT_USE_LEGACY_SPECULAR_ENERGY_CONSERVATION;
+    /**
+     * Defines if the legacy specular energy conservation is used.
+     * If activated, the specular color is multiplied with (1. - maxChannel(albedo color)).
+     */
+    @serialize()
+    @expandToProperty("_markAllSubMeshesAsMiscDirty")
+    public useLegacySpecularEnergyConservation = PBRBRDFConfiguration.DEFAULT_USE_LEGACY_SPECULAR_ENERGY_CONSERVATION;
+
     /** @internal */
     private _internalMarkAllSubMeshesAsMiscDirty: () => void;
 
@@ -136,6 +151,7 @@ export class PBRBRDFConfiguration extends MaterialPluginBase {
         defines.SPHERICAL_HARMONICS = this._useSphericalHarmonics;
         defines.SPECULAR_GLOSSINESS_ENERGY_CONSERVATION = this._useSpecularGlossinessInputEnergyConservation;
         defines.MIX_IBL_RADIANCE_WITH_IRRADIANCE = this._mixIblRadianceWithIrradiance;
+        defines.LEGACY_SPECULAR_ENERGY_CONSERVATION = this._useLegacySpecularEnergyConservation;
     }
 
     public override getClassName(): string {

packages/dev/core/src/Materials/PBR/pbrBaseMaterial.ts

@@ -197,6 +197,8 @@ export class PBRMaterialDefines extends MaterialDefines implements IImageProcess
     public LINEARSPECULARREFLECTION = false;
     public RADIANCEOCCLUSION = false;
     public HORIZONOCCLUSION = false;
+    public DIELECTRIC_SPECULAR_MODEL = 0;
+    public CONDUCTOR_SPECULAR_MODEL = 0;
 
     public INSTANCES = false;
     public THIN_INSTANCES = false;
@@ -827,6 +829,9 @@ export abstract class PBRBaseMaterial extends PushMaterial {
 
     private _baseDiffuseModel: number = PBRBaseMaterial.DEFAULT_DIFFUSE_MODEL;
 
+    private _dielectricSpecularModel: number = Constants.MATERIAL_DIELECTRIC_SPECULAR_MODEL_GLTF;
+    private _conductorSpecularModel: number = Constants.MATERIAL_CONDUCTOR_SPECULAR_MODEL_GLTF;
+
     /**
      * Can this material render to several textures at once
      */
@@ -2001,6 +2006,10 @@ export abstract class PBRBaseMaterial extends PushMaterial {
 
         defines.HORIZONOCCLUSION = this._useHorizonOcclusion;
 
+        defines.DIELECTRIC_SPECULAR_MODEL = this._dielectricSpecularModel;
+
+        defines.CONDUCTOR_SPECULAR_MODEL = this._conductorSpecularModel;
+
         // Misc.
         if (defines._areMiscDirty) {
             PrepareDefinesForMisc(
@@ -2363,22 +2372,18 @@ export abstract class PBRBaseMaterial extends PushMaterial {
 
                 // Colors
                 if (defines.METALLICWORKFLOW) {
-                    TmpColors.Color3[0].r = this._metallic === undefined || this._metallic === null ? 1 : this._metallic;
-                    TmpColors.Color3[0].g = this._roughness === undefined || this._roughness === null ? 1 : this._roughness;
+                    TmpColors.Color4[0].r = this._metallic === undefined || this._metallic === null ? 1 : this._metallic;
+                    TmpColors.Color4[0].g = this._roughness === undefined || this._roughness === null ? 1 : this._roughness;
                     const ior = this.subSurface?._indexOfRefraction ?? 1.5;
                     const outsideIOR = 1; // consider air as clear coat and other layers would remap in the shader.
-                    TmpColors.Color3[0].b = ior;
-                    ubo.updateColor4("vReflectivityColor", TmpColors.Color3[0], 1);
+                    TmpColors.Color4[0].b = ior;
                     // We are here deriving our default reflectance from a common value for none metallic surface.
                     // Based of the schlick fresnel approximation model
                     // for dielectrics.
                     const f0 = Math.pow((ior - outsideIOR) / (ior + outsideIOR), 2);
-
-                    // Tweak the default F0 and F90 based on our given setup
-                    this._metallicReflectanceColor.scaleToRef(f0 * this._metallicF0Factor, TmpColors.Color3[0]);
-                    const metallicF90 = this._metallicF0Factor;
-
-                    ubo.updateColor4("vMetallicReflectanceFactors", TmpColors.Color3[0], metallicF90);
+                    TmpColors.Color4[0].a = f0;
+                    ubo.updateDirectColor4("vReflectivityColor", TmpColors.Color4[0]);
+                    ubo.updateColor4("vMetallicReflectanceFactors", this._metallicReflectanceColor, this._metallicF0Factor);
                 } else {
                     ubo.updateColor4("vReflectivityColor", this._reflectivityColor, this._microSurface);
                 }

packages/dev/core/src/Materials/PBR/pbrMaterial.ts

@@ -325,6 +325,20 @@ export class PBRMaterial extends PBRBaseMaterial {
     @expandToProperty("_markAllSubMeshesAsTexturesDirty")
     public reflectionColor = new Color3(1.0, 1.0, 1.0);
 
+    /**
+     * The material model to use for specular lighting of dielectric materials.
+     */
+    @serialize("dielectricSpecularModel")
+    @expandToProperty("_markAllSubMeshesAsMiscDirty")
+    public dielectricSpecularModel: number = Constants.MATERIAL_DIELECTRIC_SPECULAR_MODEL_GLTF;
+
+    /**
+     * The material model to use for specular lighting.
+     */
+    @serialize("conductorSpecularModel")
+    @expandToProperty("_markAllSubMeshesAsMiscDirty")
+    public conductorSpecularModel: number = Constants.MATERIAL_CONDUCTOR_SPECULAR_MODEL_GLTF;
+
     /**
      * The color emitted from the material.
      */

packages/dev/core/src/Shaders/ShadersInclude/lightFragment.fx

@@ -103,10 +103,15 @@
                 #if AREALIGHT{X}
                     info.specular = computeAreaSpecularLighting(preInfo, light{X}.vLightSpecular.rgb);
                 #else
+                    fresnel = fresnelSchlickGGX(preInfo.VdotH, vec3(reflectanceF0), specularEnvironmentR90);
+                    coloredFresnel = fresnelSchlickGGX(preInfo.VdotH, clearcoatOut.specularEnvironmentR0, specularEnvironmentR90);
+                    #ifndef LEGACY_SPECULAR_ENERGY_CONSERVATION
+                        info.diffuse *= (1.0 - fresnel);
+                    #endif
                     #ifdef ANISOTROPIC
                         info.specular = computeAnisotropicSpecularLighting(preInfo, viewDirectionW, normalW, anisotropicOut.anisotropicTangent, anisotropicOut.anisotropicBitangent, anisotropicOut.anisotropy, clearcoatOut.specularEnvironmentR0, specularEnvironmentR90, AARoughnessFactors.x, diffuse{X}.rgb);
                     #else
-                        info.specular = computeSpecularLighting(preInfo, normalW, clearcoatOut.specularEnvironmentR0, specularEnvironmentR90, AARoughnessFactors.x, diffuse{X}.rgb, vReflectivityColor.b);
+                        info.specular = computeSpecularLighting(preInfo, normalW, clearcoatOut.specularEnvironmentR0, coloredFresnel, AARoughnessFactors.x, diffuse{X}.rgb);
                     #endif
                 #endif
             #endif

packages/dev/core/src/Shaders/ShadersInclude/pbrBRDFFunctions.fx

@@ -3,6 +3,10 @@
 #define BRDF_DIFFUSE_MODEL_EON 0
 #define BRDF_DIFFUSE_MODEL_BURLEY 1
 #define BRDF_DIFFUSE_MODEL_LAMBERT 2
+#define DIELECTRIC_SPECULAR_MODEL_GLTF 0
+#define DIELECTRIC_SPECULAR_MODEL_OPENPBR 1
+#define CONDUCTOR_SPECULAR_MODEL_GLTF 0
+#define CONDUCTOR_SPECULAR_MODEL_OPENPBR 1
 
 // ______________________________________________________________________
 //
@@ -17,6 +21,27 @@
     }
 #endif
 
+#if CONDUCTOR_SPECULAR_MODEL == CONDUCTOR_SPECULAR_MODEL_OPENPBR 
+    vec3 getF82Specular(float NdotV, vec3 F0, vec3 edgeTint, float roughness) {
+        // F82 specular model for metals
+        // https://www.slideshare.net/PeterKutz/fresnel-equations-considered-harmful
+        // Peter Kutz, 2020
+        const float cos_theta_max = 0.142857143; // 1 / 7
+        
+        const float one_minus_cos_theta_max_to_the_fifth = 0.462664366; // (1 - cos_theta_max)^5
+        const float one_minus_cos_theta_max_to_the_sixth = 0.396569457; // (1 - cos_theta_max)^6
+        vec3 white_minus_F0 = vec3(1.0) - F0;
+        vec3 b_numerator = (F0 + white_minus_F0 * one_minus_cos_theta_max_to_the_fifth) * (vec3(1.0) - edgeTint);
+        const float b_denominator = cos_theta_max * one_minus_cos_theta_max_to_the_sixth;
+        const float b_denominator_reciprocal = 1.0 / b_denominator;
+        vec3 b = b_numerator * b_denominator_reciprocal; // analogous to "a" in the "Fresnel Equations Considered Harmful" slides
+        float cos_theta = max(roughness, NdotV);
+        float one_minus_cos_theta = 1.0 - cos_theta;
+        vec3 offset_from_F0 = (white_minus_F0 - b * cos_theta * one_minus_cos_theta) * pow(one_minus_cos_theta, 5.0);
+        return clamp(F0 + offset_from_F0, 0.0, 1.0);
+    }
+#endif
+
 #ifdef ENVIRONMENTBRDF
     vec3 getBRDFLookup(float NdotV, float perceptualRoughness) {
         // Indexed on cos(theta) and roughness
@@ -32,14 +57,9 @@
         return brdfLookup.rgb;
     }
 
-    vec3 getReflectanceFromBRDFLookup(const vec3 specularEnvironmentR0, const vec3 specularEnvironmentR90, const float ior, const vec3 environmentBrdf) {
+    vec3 getReflectanceFromBRDFLookup(const vec3 specularEnvironmentR0, const vec3 specularEnvironmentR90, const vec3 environmentBrdf) {
         #ifdef BRDF_V_HEIGHT_CORRELATED
-            #ifdef METALLICWORKFLOW
-                // Scale the reflectance by the IOR for values less than 1.5
-                vec3 reflectance = (specularEnvironmentR90 - specularEnvironmentR0) * clamp(environmentBrdf.x * 2.0 * (ior - 1.0), 0.0, 1.0) + specularEnvironmentR0 * environmentBrdf.y;
-            #else
-                vec3 reflectance = (specularEnvironmentR90 - specularEnvironmentR0) * environmentBrdf.x + specularEnvironmentR0 * environmentBrdf.y;
-            #endif
+            vec3 reflectance = (specularEnvironmentR90 - specularEnvironmentR0) * environmentBrdf.x + specularEnvironmentR0 * environmentBrdf.y;
             // Simplification if F90 = 1 vec3 reflectance = (specularEnvironmentR90 - specularEnvironmentR0) * environmentBrdf.xxx + specularEnvironmentR0 * environmentBrdf.yyy;
         #else
             vec3 reflectance = specularEnvironmentR0 * environmentBrdf.x + specularEnvironmentR90 * environmentBrdf.y;

packages/dev/core/src/Shaders/ShadersInclude/pbrBlockDirectLighting.fx

@@ -12,6 +12,10 @@ vec3 diffuseBase = vec3(0., 0., 0.);
     vec3 sheenBase = vec3(0., 0., 0.);
 #endif
 
+#if defined(SPECULARTERM) && defined(LIGHT0)
+    vec3 fresnel;
+    vec3 coloredFresnel;
+#endif
 // Direct Lighting Variables
 preLightingInfo preInfo;
 lightingInfo info;