Revert "Improve shadow normal bias calculation (#9734)"

This reverts commit 81c71fbbb9.

README.md

@@ -31,7 +31,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.69.5'
+    implementation 'com.google.android.filament:filament-android:1.70.0'
 }
 ```
 
@@ -50,7 +50,7 @@ Here are all the libraries available in the group `com.google.android.filament`:
 iOS projects can use CocoaPods to install the latest release:
 
 ```shell
-pod 'Filament', '~> 1.69.5'
+pod 'Filament', '~> 1.70.0'
 ```
 
 ## Documentation

android/gradle.properties

@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.69.5
+VERSION_NAME=1.70.0
 
 POM_DESCRIPTION=Real-time physically based rendering engine for Android.
 

filament/src/ShadowMap.cpp

@@ -1120,16 +1120,16 @@ bool ShadowMap::intersectSegmentWithPlanarQuad(float3& UTILS_RESTRICT p,
     return hit;
 }
 
-float2 ShadowMap::texelSizeWorldSpace(const mat3f& clipFromWorld, uint16_t shadowDimension) noexcept {
+float ShadowMap::texelSizeWorldSpace(const mat3f& clipFromWorld, uint16_t shadowDimension) noexcept {
     // The Jacobian of the transformation from texture-to-world is the matrix itself for
     // orthographic projections. We just need to inverse shadowMapFromWorld,
     // which is guaranteed to be orthographic.
     // The two first columns give us how a texel maps in world-space.
     float const oneTexel = 2.0f / float(shadowDimension);
-    mat3f const worldFromClip(inverse(clipFromWorld));
-    float3 const Jx = worldFromClip[0];
-    float3 const Jy = worldFromClip[1];
-    float2 const s = float2{ length(Jx), length(Jy) } * oneTexel;
+    const mat3f worldFromClip(inverse(clipFromWorld));
+    const float3 Jx = worldFromClip[0];
+    const float3 Jy = worldFromClip[1];
+    const float s = std::max(length(Jx), length(Jy)) * oneTexel;
     return s;
 }
 
@@ -1174,13 +1174,13 @@ static mat3f jacobian(mat4f const& M, float3 const& p) noexcept {
     return (M_sub - t_cross_w / T.w) / T.w;
 }
 
-float2 ShadowMap::texelSizeWorldSpace(mat4f const& S, uint16_t const shadowDimension) noexcept {
+float ShadowMap::texelSizeWorldSpace(mat4f const& S, uint16_t const shadowDimension) noexcept {
     // The Jacobian is not constant, so we evaluate it in the center of the shadow-map texture.
     // It might be better to do this computation in the vertex shader.
     float3 const p = { 0.0f, 0.0f, 0.0f }; // clip-space
     float const oneTexel = 2.0f / float(shadowDimension);
     mat3f const J = jacobian(inverse(S), p);
-    float2 const s = float2{ length(J[0]), length(J[1]) } * oneTexel;
+    const float s = std::max(length(J[0]), length(J[1])) * oneTexel;
     return s;
 }
 

filament/src/ShadowMap.h

@@ -135,7 +135,7 @@ public:
         math::mat4f lightSpace{};
         math::float4 lightFromWorldZ{};
         math::float4 scissorNormalized{};
-        math::float2 texelSizeAtOneMeterWs{};
+        float texelSizeAtOneMeterWs{};
     };
 
     // Call once per frame if the light, scene (or visible layers) or camera changes.
@@ -321,8 +321,8 @@ private:
 
     math::float4 getClampToEdgeCoords(ShadowMapInfo const& shadowMapInfo) const noexcept;
 
-    static math::float2 texelSizeWorldSpace(const math::mat3f& clipFromWorld, uint16_t shadowDimension) noexcept;
-    static math::float2 texelSizeWorldSpace(const math::mat4f& clipFromWorld, uint16_t shadowDimension) noexcept;
+    static float texelSizeWorldSpace(const math::mat3f& clipFromWorld, uint16_t shadowDimension) noexcept;
+    static float texelSizeWorldSpace(const math::mat4f& clipFromWorld, uint16_t shadowDimension) noexcept;
 
     static constexpr Segment sBoxSegments[12] = {
             { 0, 1 }, { 1, 3 }, { 3, 2 }, { 2, 0 },

filament/src/ShadowMapManager.cpp

@@ -739,17 +739,18 @@ ShadowMapManager::ShadowTechnique ShadowMapManager::updateCascadeShadowMaps(FEng
 
                 // Texel size is constant for directional light (although that's not true when LISPSM
                 // is used, but in that case we're pretending it is).
-                float2 const wsTexelSize = shaderParameters.texelSizeAtOneMeterWs;
+                const float wsTexelSize = shaderParameters.texelSizeAtOneMeterWs;
 
                 auto& s = mShadowUb.edit();
                 s.shadows[shadowIndex].layer = shadowMap.getLayer();
                 s.shadows[shadowIndex].lightFromWorldMatrix = shaderParameters.lightSpace;
                 s.shadows[shadowIndex].scissorNormalized = shaderParameters.scissorNormalized;
-                s.shadows[shadowIndex].normalBias = wsTexelSize * normalBias;
+                s.shadows[shadowIndex].normalBias = normalBias * wsTexelSize;
+                s.shadows[shadowIndex].texelSizeAtOneMeter = wsTexelSize;
                 s.shadows[shadowIndex].elvsm = options.vsm.elvsm;
                 s.shadows[shadowIndex].vsmExponent = getWrapExponentEVSM(vsmShadowOptions, options);
                 s.shadows[shadowIndex].bulbRadiusLs =
-                        mSoftShadowOptions.penumbraScale * options.shadowBulbRadius / length(wsTexelSize);
+                        mSoftShadowOptions.penumbraScale * options.shadowBulbRadius / wsTexelSize;
 
                 shadowTechnique |= ShadowTechnique::SHADOW_MAP;
                 cascadeHasVisibleShadows |= 0x1u << i;
@@ -829,7 +830,7 @@ void ShadowMapManager::prepareSpotShadowMap(ShadowMap& shadowMap, FEngine& engin
     // and if we need to generate it, update all the UBO data
     if (shadowMap.hasVisibleShadows()) {
         const size_t shadowIndex = shadowMap.getShadowIndex();
-        const float2 wsTexelSizeAtOneMeter = shaderParameters.texelSizeAtOneMeterWs;
+        const float wsTexelSizeAtOneMeter = shaderParameters.texelSizeAtOneMeterWs;
         // note: normalBias is set to zero for VSM
         const float normalBias = shadowMapInfo.vsm ? 0.0f : options.normalBias;
 
@@ -841,12 +842,13 @@ void ShadowMapManager::prepareSpotShadowMap(ShadowMap& shadowMap, FEngine& engin
         s.shadows[shadowIndex].scissorNormalized = shaderParameters.scissorNormalized;
         s.shadows[shadowIndex].normalBias = normalBias * wsTexelSizeAtOneMeter;
         s.shadows[shadowIndex].lightFromWorldZ = shaderParameters.lightFromWorldZ;
+        s.shadows[shadowIndex].texelSizeAtOneMeter = wsTexelSizeAtOneMeter;
         s.shadows[shadowIndex].nearOverFarMinusNear = float(n / (f - n));
         s.shadows[shadowIndex].elvsm = options.vsm.elvsm;
         s.shadows[shadowIndex].vsmExponent = getWrapExponentEVSM(vsmShadowOptions, options);
         s.shadows[shadowIndex].bulbRadiusLs =
                 mSoftShadowOptions.penumbraScale * options.shadowBulbRadius
-                        / length(wsTexelSizeAtOneMeter);
+                        / wsTexelSizeAtOneMeter;
 
     }
 }
@@ -923,7 +925,7 @@ void ShadowMapManager::preparePointShadowMap(ShadowMap& shadowMap,
     // and if we need to generate it, update all the UBO data
     if (shadowMap.hasVisibleShadows()) {
         const size_t shadowIndex = shadowMap.getShadowIndex();
-        const float2 wsTexelSizeAtOneMeter = shaderParameters.texelSizeAtOneMeterWs;
+        const float wsTexelSizeAtOneMeter = shaderParameters.texelSizeAtOneMeterWs;
         // note: normalBias is set to zero for VSM
         const float normalBias = shadowMapInfo.vsm ? 0.0f : options.normalBias;
 
@@ -935,12 +937,13 @@ void ShadowMapManager::preparePointShadowMap(ShadowMap& shadowMap,
         s.shadows[shadowIndex].scissorNormalized = shaderParameters.scissorNormalized;
         s.shadows[shadowIndex].normalBias = normalBias * wsTexelSizeAtOneMeter;
         s.shadows[shadowIndex].lightFromWorldZ = shaderParameters.lightFromWorldZ;
+        s.shadows[shadowIndex].texelSizeAtOneMeter = wsTexelSizeAtOneMeter;
         s.shadows[shadowIndex].nearOverFarMinusNear = float(n / (f - n));
         s.shadows[shadowIndex].elvsm = options.vsm.elvsm;
         s.shadows[shadowIndex].vsmExponent = getWrapExponentEVSM(vsmShadowOptions, options);
         s.shadows[shadowIndex].bulbRadiusLs =
                 mSoftShadowOptions.penumbraScale * options.shadowBulbRadius
-                        / length(wsTexelSizeAtOneMeter);
+                        / wsTexelSizeAtOneMeter;
     }
 }
 

ios/CocoaPods/Filament.podspec

@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
   spec.name = "Filament"
-  spec.version = "1.69.5"
+  spec.version = "1.70.0"
   spec.license = { :type => "Apache 2.0", :file => "LICENSE" }
   spec.homepage = "https://google.github.io/filament"
   spec.authors = "Google LLC."
   spec.summary = "Filament is a real-time physically based rendering engine for Android, iOS, Windows, Linux, macOS, and WASM/WebGL."
   spec.platform = :ios, "11.0"
-  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.69.5/filament-v1.69.5-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.70.0/filament-v1.70.0-ios.tgz" }
 
   spec.libraries = 'c++'
 

libs/filabridge/include/private/filament/UibStructs.h

@@ -299,11 +299,12 @@ struct ShadowUib { // NOLINT(cppcoreguidelines-pro-type-member-init)
         math::mat4f lightFromWorldMatrix;       // 64
         math::float4 lightFromWorldZ;           // 16
         math::float4 scissorNormalized;         // 16
+        float texelSizeAtOneMeter;              //  4
         float bulbRadiusLs;                     //  4
         float nearOverFarMinusNear;             //  4
-        math::float2 normalBias;                //  4
-        bool elvsm;                             //  4   // could be 1 bit
-        uint32_t layer;                         //  4   // could be 8 bits
+        float normalBias;                       //  4
+        bool elvsm;                             //  4
+        uint32_t layer;                         //  4
         float vsmExponent;                      //  4   // could be fp16
         uint32_t reserved2;                     //  4
     };

shaders/src/surface_getters.fs

@@ -111,7 +111,7 @@ highp vec4 getSpotLightSpacePosition(int index, highp vec3 dir, highp float zLig
     highp mat4 lightFromWorldMatrix = shadowUniforms.shadows[index].lightFromWorldMatrix;
 
     // for spotlights, the bias depends on z
-    highp vec2 bias = shadowUniforms.shadows[index].normalBias * zLight;
+    float bias = shadowUniforms.shadows[index].normalBias * zLight;
 
     return computeLightSpacePosition(getWorldPosition(), getWorldGeometricNormalVector(),
             dir, bias, lightFromWorldMatrix);

shaders/src/surface_shadowing.glsl

@@ -12,51 +12,12 @@
  */
 
 highp vec4 computeLightSpacePosition(highp vec3 p, const highp vec3 n,
-        const highp vec3 dir, const highp vec2 b, highp_mat4 lightFromWorldMatrix) {
+        const highp vec3 dir, const float b, highp_mat4 lightFromWorldMatrix) {
 
 #if !defined(VARIANT_HAS_VSM)
-    // --------------------------------------------------------------------------------------
-    // Anisotropic Normal Bias for Shadow Mapping
-    // --------------------------------------------------------------------------------------
-    // To prevent shadow acne, we must push the geometry along its normal to clear the
-    // quantization steps of the shadow map's discrete depth grid. The exact physical depth
-    // error we must clear is proportional to the shadow texel's world-space dimensions.
-    //
-    // This implementation computes the exact geometric projection of the rectangular
-    // shadow map texel onto the surface normal.
-    //
-    // 1. Coordinate Space Transition:
-    //    We project the world-space normal onto the light's X and Y basis vectors (L_right,
-    //    L_up). This gives us the lateral components of the normal in Light Space (n_Lx, n_Ly).
-    //
-    // 2. The Implicit sin(theta) Slope Scale:
-    //    Because the normal is a unit vector, the magnitude of its lateral components in
-    //    light space inherently equals sin(theta), where theta is the angle of incidence.
-    //    This perfectly and automatically scales the bias from 0.0 (top-down, flat surface)
-    //    to maximum (grazing angle).
-    //
-    // 3. Exact Anisotropic Footprint (The L1 Norm):
-    //    Shadow texels are rarely perfectly square due to Cascaded Shadow Maps (CSM) or
-    //    Light Space Perspective Shadow Maps (LiSPSM). Jx and Jy are the physical world-space
-    //    dimensions of the texel.
-    //    By evaluating `abs(n_Lx * Jx) + abs(n_Ly * Jy)`, we compute the exact scalar
-    //    projection of the rectangular texel footprint.
-    //      - It is superior to `max(Jx, Jy)` which assumes a massive square and causes Peter Panning.
-    //      - It is superior to `length()` which assumes an ellipse and under-biases the corners.
-    // --------------------------------------------------------------------------------------
-
-    // Extract the first row (Light's Right vector in World Space)
-    highp vec3 L_right = vec3(lightFromWorldMatrix[0][0], lightFromWorldMatrix[1][0], lightFromWorldMatrix[2][0]);
-
-    // Extract the second row (Light's Up vector in World Space)
-    highp vec3 L_up    = vec3(lightFromWorldMatrix[0][1], lightFromWorldMatrix[1][1], lightFromWorldMatrix[2][1]);
-
-    // Project the world normal onto the shadow map's 2D grid
-    highp float n_Lx = dot(n, L_right);
-    highp float n_Ly = dot(n, L_up);
-
-    // Apply the anisotropic normal bias
-    p += n * (abs(n_Lx * b.x) + abs(n_Ly * b.y));
+    highp float cosTheta = saturate(dot(n, dir));
+    highp float sinTheta = sqrt(1.0 - cosTheta * cosTheta);
+    p += n * (sinTheta * b);
 #endif
 
     return mulMat4x4Float3(lightFromWorldMatrix, p);

shaders/src/surface_types.glsl

@@ -5,9 +5,10 @@ struct ShadowData {
     highp mat4 lightFromWorldMatrix;
     highp vec4 lightFromWorldZ;
     highp vec4 scissorNormalized;
+    mediump float texelSizeAtOneMeter;
     mediump float bulbRadiusLs;
     mediump float nearOverFarMinusNear;
-    highp vec2 normalBias;
+    mediump float normalBias;
     bool elvsm;
     mediump uint layer;
     mediump float vsmExponent;

web/filament-js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "filament",
-  "version": "1.69.5",
+  "version": "1.70.0",
   "description": "Real-time physically based rendering engine",
   "main": "filament.js",
   "module": "filament.js",