diff --git a/android/filamat-android/src/main/cpp/MaterialBuilder.cpp b/android/filamat-android/src/main/cpp/MaterialBuilder.cpp
index 6069b39eeb..48b83ecfdf 100644
--- a/android/filamat-android/src/main/cpp/MaterialBuilder.cpp
+++ b/android/filamat-android/src/main/cpp/MaterialBuilder.cpp
@@ -226,17 +226,24 @@ Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderShadowM
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderCurvatureToRoughness(
-        JNIEnv*, jclass, jlong nativeBuilder, jboolean curvatureToRoughness) {
+Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderSpecularAntiAliasing(
+        JNIEnv*, jclass, jlong nativeBuilder, jboolean specularAntiAliasing) {
     auto builder = (MaterialBuilder*) nativeBuilder;
-    builder->curvatureToRoughness(curvatureToRoughness);
+    builder->specularAntiAliasing(specularAntiAliasing);
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderLimitOverInterpolation(
-        JNIEnv*, jclass, jlong nativeBuilder, jboolean limitOverInterpolation) {
+Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderSpecularAntiAliasingVariance(
+        JNIEnv*, jclass, jlong nativeBuilder, jfloat variance) {
     auto builder = (MaterialBuilder*) nativeBuilder;
-    builder->limitOverInterpolation(limitOverInterpolation);
+    builder->specularAntiAliasingVariance(variance);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_filamat_MaterialBuilder_nMaterialBuilderSpecularAntiAliasingThreshold(
+        JNIEnv*, jclass, jlong nativeBuilder, jfloat threshold) {
+    auto builder = (MaterialBuilder*) nativeBuilder;
+    builder->specularAntiAliasingThreshold(threshold);
 }
 
 extern "C" JNIEXPORT void JNICALL
diff --git a/android/filamat-android/src/main/java/com/google/android/filament/filamat/MaterialBuilder.java b/android/filamat-android/src/main/java/com/google/android/filament/filamat/MaterialBuilder.java
index 81689afeeb..532f2d8ee9 100644
--- a/android/filamat-android/src/main/java/com/google/android/filament/filamat/MaterialBuilder.java
+++ b/android/filamat-android/src/main/java/com/google/android/filament/filamat/MaterialBuilder.java
@@ -290,14 +290,20 @@ public class MaterialBuilder {
     }
 
     @NonNull
-    public MaterialBuilder curvatureToRoughness(boolean curvatureToRoughness) {
-        nMaterialBuilderCurvatureToRoughness(mNativeObject, curvatureToRoughness);
+    public MaterialBuilder specularAntiAliasing(boolean specularAntiAliasing) {
+        nMaterialBuilderSpecularAntiAliasing(mNativeObject, specularAntiAliasing);
         return this;
     }
 
     @NonNull
-    public MaterialBuilder limitOverInterpolation(boolean limitOverInterpolation) {
-        nMaterialBuilderLimitOverInterpolation(mNativeObject, limitOverInterpolation);
+    public MaterialBuilder specularAntiAliasingVariance(float variance) {
+        nMaterialBuilderSpecularAntiAliasingVariance(mNativeObject, variance);
+        return this;
+    }
+
+    @NonNull
+    public MaterialBuilder specularAntiAliasingThreshold(float threshold) {
+        nMaterialBuilderSpecularAntiAliasingThreshold(mNativeObject, threshold);
         return this;
     }
 
@@ -420,10 +426,12 @@ public class MaterialBuilder {
 
     private static native void nMaterialBuilderShadowMultiplier(long mNativeObject,
             boolean shadowMultiplier);
-    private static native void nMaterialBuilderCurvatureToRoughness(long mNativeObject,
-            boolean curvatureToRoughness);
-    private static native void nMaterialBuilderLimitOverInterpolation(long mNativeObject,
-            boolean limitOverInterpolation);
+    private static native void nMaterialBuilderSpecularAntiAliasing(long mNativeObject,
+            boolean specularAntiAliasing);
+    private static native void nMaterialBuilderSpecularAntiAliasingVariance(long mNativeObject,
+            float variance);
+    private static native void nMaterialBuilderSpecularAntiAliasingThreshold(long mNativeObject,
+            float threshold);
     private static native void nMaterialBuilderClearCoatIorChange(long mNativeObject,
             boolean clearCoatIorChange);
     private static native void nMaterialBuilderFlipUV(long nativeBuilder, boolean flipUV);
diff --git a/android/filament-android/src/main/cpp/Material.cpp b/android/filament-android/src/main/cpp/Material.cpp
index 9dc83f52d7..366c3e9f78 100644
--- a/android/filament-android/src/main/cpp/Material.cpp
+++ b/android/filament-android/src/main/cpp/Material.cpp
@@ -140,6 +140,22 @@ Java_com_google_android_filament_Material_nGetMaskThreshold(JNIEnv*, jclass,
     return material->getMaskThreshold();
 }
 
+extern "C"
+JNIEXPORT jfloat JNICALL
+Java_com_google_android_filament_Material_nGetSpecularAntiAliasingVariance(JNIEnv*, jclass,
+        jlong nativeMaterial) {
+    Material* material = (Material*) nativeMaterial;
+    return material->getSpecularAntiAliasingVariance();
+}
+
+extern "C"
+JNIEXPORT jfloat JNICALL
+Java_com_google_android_filament_Material_nGetSpecularAntiAliasingThreshold(JNIEnv*, jclass,
+        jlong nativeMaterial) {
+    Material* material = (Material*) nativeMaterial;
+    return material->getSpecularAntiAliasingThreshold();
+}
+
 extern "C"
 JNIEXPORT jint JNICALL
 Java_com_google_android_filament_Material_nGetParameterCount(JNIEnv*, jclass,
diff --git a/android/filament-android/src/main/cpp/MaterialInstance.cpp b/android/filament-android/src/main/cpp/MaterialInstance.cpp
index 785ba08f02..0223ca1a5a 100644
--- a/android/filament-android/src/main/cpp/MaterialInstance.cpp
+++ b/android/filament-android/src/main/cpp/MaterialInstance.cpp
@@ -226,6 +226,22 @@ Java_com_google_android_filament_MaterialInstance_nSetMaskThreshold(JNIEnv*,
     instance->setMaskThreshold(threshold);
 }
 
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_google_android_filament_MaterialInstance_nSetSpecularAntiAliasingVariance(JNIEnv*,
+        jclass, jlong nativeMaterialInstance, jfloat variance) {
+    MaterialInstance* instance = (MaterialInstance*) nativeMaterialInstance;
+    instance->setSpecularAntiAliasingVariance(variance);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_google_android_filament_MaterialInstance_nSetSpecularAntiAliasingThreshold(JNIEnv*,
+        jclass, jlong nativeMaterialInstance, jfloat threshold) {
+    MaterialInstance* instance = (MaterialInstance*) nativeMaterialInstance;
+    instance->setSpecularAntiAliasingThreshold(threshold);
+}
+
 extern "C"
 JNIEXPORT void JNICALL
 Java_com_google_android_filament_MaterialInstance_nSetDoubleSided(JNIEnv*,
diff --git a/android/filament-android/src/main/java/com/google/android/filament/Material.java b/android/filament-android/src/main/java/com/google/android/filament/Material.java
index c982897ab5..67b58205c8 100644
--- a/android/filament-android/src/main/java/com/google/android/filament/Material.java
+++ b/android/filament-android/src/main/java/com/google/android/filament/Material.java
@@ -215,6 +215,14 @@ public class Material {
         return nGetMaskThreshold(getNativeObject());
     }
 
+    public float getSpecularAntiAliasingVariance() {
+        return nGetSpecularAntiAliasingVariance(getNativeObject());
+    }
+
+    public float getSpecularAntiAliasingThreshold() {
+        return nGetSpecularAntiAliasingThreshold(getNativeObject());
+    }
+
     public Set<VertexBuffer.VertexAttribute> getRequiredAttributes() {
         if (mRequiredAttributes == null) {
             int bitSet = nGetRequiredAttributes(getNativeObject());
@@ -356,6 +364,8 @@ public class Material {
     private static native boolean nIsDepthCullingEnabled(long nativeMaterial);
     private static native boolean nIsDoubleSided(long nativeMaterial);
     private static native float nGetMaskThreshold(long nativeMaterial);
+    private static native float nGetSpecularAntiAliasingVariance(long nativeMaterial);
+    private static native float nGetSpecularAntiAliasingThreshold(long nativeMaterial);
 
     private static native int nGetParameterCount(long nativeMaterial);
     private static native void nGetParameters(long nativeMaterial,
diff --git a/android/filament-android/src/main/java/com/google/android/filament/MaterialInstance.java b/android/filament-android/src/main/java/com/google/android/filament/MaterialInstance.java
index 1460f47bb3..3b9db03151 100644
--- a/android/filament-android/src/main/java/com/google/android/filament/MaterialInstance.java
+++ b/android/filament-android/src/main/java/com/google/android/filament/MaterialInstance.java
@@ -155,6 +155,14 @@ public class MaterialInstance {
         nSetMaskThreshold(getNativeObject(), threshold);
     }
 
+    public void setSpecularAntiAliasingVariance(float variance) {
+        nSetSpecularAntiAliasingVariance(getNativeObject(), variance);
+    }
+
+    public void setSpecularAntiAliasingThreshold(float threshold) {
+        nSetSpecularAntiAliasingThreshold(getNativeObject(), threshold);
+    }
+
     public void setDoubleSided(boolean doubleSided) {
         nSetDoubleSided(getNativeObject(), doubleSided);
     }
@@ -218,9 +226,14 @@ public class MaterialInstance {
     private static native void nUnsetScissor(long nativeMaterialInstance);
 
     private static native void nSetPolygonOffset(long nativeMaterialInstance,
-        float scale, float constant);
+            float scale, float constant);
 
     private static native void nSetMaskThreshold(long nativeMaterialInstance, float threshold);
 
+    private static native void nSetSpecularAntiAliasingVariance(long nativeMaterialInstance,
+            float variance);
+    private static native void nSetSpecularAntiAliasingThreshold(long nativeMaterialInstance,
+            float threshold);
+
     private static native void nSetDoubleSided(long nativeMaterialInstance, boolean doubleSided);
 }
diff --git a/docs/Materials.html b/docs/Materials.html
index ca927400bd..3b2ecf7c20 100644
--- a/docs/Materials.html
+++ b/docs/Materials.html
@@ -86,8 +86,9 @@ counter-increment: h6;margin-right:10px}</style><style>.hljs{display:block;overf
 &#xA0;&#xA0;&#xA0;&#xA0;<a href="#materialdefinitions/materialblock/lighting:clearcoatiorchange" class="level3"><span class="tocNumber">4.2.20&#xA0; </span>Lighting: clearCoatIorChange</a><br>
 &#xA0;&#xA0;&#xA0;&#xA0;<a href="#materialdefinitions/materialblock/lighting:multibounceambientocclusion" class="level3"><span class="tocNumber">4.2.21&#xA0; </span>Lighting: multiBounceAmbientOcclusion</a><br>
 &#xA0;&#xA0;&#xA0;&#xA0;<a href="#materialdefinitions/materialblock/lighting:specularambientocclusion" class="level3"><span class="tocNumber">4.2.22&#xA0; </span>Lighting: specularAmbientOcclusion</a><br>
-&#xA0;&#xA0;&#xA0;&#xA0;<a href="#materialdefinitions/materialblock/anti-aliasing:curvaturetoroughness" class="level3"><span class="tocNumber">4.2.23&#xA0; </span>Anti-aliasing: curvatureToRoughness</a><br>
-&#xA0;&#xA0;&#xA0;&#xA0;<a href="#materialdefinitions/materialblock/anti-aliasing:limitoverinterpolation" class="level3"><span class="tocNumber">4.2.24&#xA0; </span>Anti-aliasing: limitOverInterpolation</a><br>
+&#xA0;&#xA0;&#xA0;&#xA0;<a href="#materialdefinitions/materialblock/anti-aliasing:specularantialiasing" class="level3"><span class="tocNumber">4.2.23&#xA0; </span>Anti-aliasing: specularAntiAliasing</a><br>
+&#xA0;&#xA0;&#xA0;&#xA0;<a href="#materialdefinitions/materialblock/anti-aliasing:specularantialiasingvariance" class="level3"><span class="tocNumber">4.2.24&#xA0; </span>Anti-aliasing: specularAntiAliasingVariance</a><br>
+&#xA0;&#xA0;&#xA0;&#xA0;<a href="#materialdefinitions/materialblock/anti-aliasing:specularantialiasingthreshold" class="level3"><span class="tocNumber">4.2.25&#xA0; </span>Anti-aliasing: specularAntiAliasingThreshold</a><br>
 &#xA0;&#xA0;<a href="#materialdefinitions/vertexblock" class="level2"><span class="tocNumber">4.3&#xA0; </span>Vertex block</a><br>
 &#xA0;&#xA0;&#xA0;&#xA0;<a href="#materialdefinitions/vertexblock/materialvertexinputs" class="level3"><span class="tocNumber">4.3.1&#xA0; </span>Material vertex inputs</a><br>
 &#xA0;&#xA0;<a href="#materialdefinitions/fragmentblock" class="level2"><span class="tocNumber">4.4&#xA0; </span>Fragment block</a><br>
@@ -1586,7 +1587,7 @@ occclusion enabled and disabled.</div></div></center>
 particularly visible under the hose.</div></div></center>
 
 <p></p>
-<a class="target" name="anti-aliasing:curvaturetoroughness">&#xA0;</a><a class="target" name="materialdefinitions/materialblock/anti-aliasing:curvaturetoroughness">&#xA0;</a><a class="target" name="toc4.2.23">&#xA0;</a><h3>Anti-aliasing: curvatureToRoughness</h3>
+<a class="target" name="anti-aliasing:specularantialiasing">&#xA0;</a><a class="target" name="materialdefinitions/materialblock/anti-aliasing:specularantialiasing">&#xA0;</a><a class="target" name="toc4.2.23">&#xA0;</a><h3>Anti-aliasing: specularAntiAliasing</h3>
 <p>
 
 
@@ -1594,33 +1595,43 @@ particularly visible under the hose.</div></div></center>
 
 </p></dd><dt>Value</dt><dd><p>      <code>true</code> or <code>false</code>. Defaults to <code>false</code>.
 
-</p></dd><dt>Description</dt><dd><p>     Reduces specular aliasing by increasing roughness based on the local geometric curvature.
-     This property is particularly effective if you only use MSAA as your anti-aliasing method.
+</p></dd><dt>Description</dt><dd><p>     Reduces specular aliasing and preserves the shape of specular highlights as an object moves
+     away from the camera. This anti-aliasing solution is particularly effective on glossy materials
+     (low roughness) but increases the cost of the material. The strengthf of the anti-aliasing
+     effect can be controlled using two other properties: <code>specularAntiAliasingVariance</code> and
+     <code>specularAntiAliasingThreshold</code>.
 
 </p></dd></dl><p></p><pre class="listing tilde"><code><span class="line">material {</span>
-<span class="line">    curvatureToRoughness : true</span>
-<span class="line">}</span></code></pre><p>
-
-</p><center><div class="image" style><a href="images/screenshot_curvature_to_roughness.jpg" target="_blank"><img class="markdeep" src="images/screenshot_curvature_to_roughness.jpg"></a><div class="imagecaption"><a class="target" name="figure_curvaturetoroughness">&#xA0;</a><b style="font-style:normal;">Figure&#xA0;29:</b> Close up of a glossy metallic surface rendered normally (left) and
-with <code>curvatureToRoughness</code> (right).</div></div></center>
-
-<p></p>
-<a class="target" name="anti-aliasing:limitoverinterpolation">&#xA0;</a><a class="target" name="materialdefinitions/materialblock/anti-aliasing:limitoverinterpolation">&#xA0;</a><a class="target" name="toc4.2.24">&#xA0;</a><h3>Anti-aliasing: limitOverInterpolation</h3>
+<span class="line">    specularAntiAliasing : true</span>
+<span class="line">}</span></code></pre>
+<a class="target" name="anti-aliasing:specularantialiasingvariance">&#xA0;</a><a class="target" name="materialdefinitions/materialblock/anti-aliasing:specularantialiasingvariance">&#xA0;</a><a class="target" name="toc4.2.24">&#xA0;</a><h3>Anti-aliasing: specularAntiAliasingVariance</h3>
 <p>
 
 
-</p><dl><dt>Type</dt><dd><p>     <code>boolean</code>
+</p><dl><dt>Type</dt><dd><p>     <code>float</code>
 
-</p></dd><dt>Value</dt><dd><p>      <code>true</code> or <code>false</code>. Defaults to <code>false</code>.
+</p></dd><dt>Value</dt><dd><p>      A value between 0 and 1, set to 0.15 by default.
 
-</p></dd><dt>Description</dt><dd><p>     Reduces specular aliasing by attempting to eliminate normal over-interpolation. When this
-     property is turned on, the material switches to centroid normal interpolation when the
-     interpolated normals are too long. This property should only be used if your anti-aliasing
-     method is MSAA. The effects are a lot more subtle than <code>curvatureToRoughness</code>, which should be
-     used first to eliminate specular aliasing.
+</p></dd><dt>Description</dt><dd><p>     Sets the screen space variance of the filter kernel used when applying specular anti-aliasing.
+     Higher values will increase the effect of the filter but may increase roughness in unwanted
+     areas.
 
 </p></dd></dl><p></p><pre class="listing tilde"><code><span class="line">material {</span>
-<span class="line">    limitOverInterpolation : true</span>
+<span class="line">    specularAntiAliasingVariance : 0.2</span>
+<span class="line">}</span></code></pre>
+<a class="target" name="anti-aliasing:specularantialiasingthreshold">&#xA0;</a><a class="target" name="materialdefinitions/materialblock/anti-aliasing:specularantialiasingthreshold">&#xA0;</a><a class="target" name="toc4.2.25">&#xA0;</a><h3>Anti-aliasing: specularAntiAliasingThreshold</h3>
+<p>
+
+
+</p><dl><dt>Type</dt><dd><p>     <code>float</code>
+
+</p></dd><dt>Value</dt><dd><p>      A value between 0 and 1, set to 0.2 by default.
+
+</p></dd><dt>Description</dt><dd><p>     Sets the clamping threshold used to suppress estimation errors when applying specular
+     anti-aliasing. When set to 0, specular anti-aliasing is disabled.
+
+</p></dd></dl><p></p><pre class="listing tilde"><code><span class="line">material {</span>
+<span class="line">    specularAntiAliasingThreshold : 0.1</span>
 <span class="line">}</span></code></pre>
 <a class="target" name="vertexblock">&#xA0;</a><a class="target" name="materialdefinitions/vertexblock">&#xA0;</a><a class="target" name="toc4.3">&#xA0;</a><h2>Vertex block</h2>
 <p>
@@ -1880,11 +1891,13 @@ The following APIs are only available from the fragment block:
 <tr><td style="text-align:left"> <strong class="asterisk">getWorldPosition()</strong> </td><td style="text-align:center"> float3 </td><td style="text-align:left"> Position of the fragment in world space </td></tr>
 <tr><td style="text-align:left"> <strong class="asterisk">getWorldViewVector()</strong> </td><td style="text-align:center"> float3 </td><td style="text-align:left"> Normalized vector in world space from the fragment position to the eye </td></tr>
 <tr><td style="text-align:left"> <strong class="asterisk">getWorldNormalVector()</strong> </td><td style="text-align:center"> float3 </td><td style="text-align:left"> Normalized normal in world space, after bump mapping (must be used after <code>prepareMaterial()</code>) </td></tr>
+<tr><td style="text-align:left"> <strong class="asterisk">getWorldGeometricNormalVector()</strong> </td><td style="text-align:center"> float3 </td><td style="text-align:left"> Normalized normal in world space, before bump mapping (can be used before <code>prepareMaterial()</code>) </td></tr>
 <tr><td style="text-align:left"> <strong class="asterisk">getWorldReflectedVector()</strong> </td><td style="text-align:center"> float3 </td><td style="text-align:left"> Reflection of the view vector about the normal (must be used after <code>prepareMaterial()</code>) </td></tr>
 <tr><td style="text-align:left"> <strong class="asterisk">getNdotV()</strong> </td><td style="text-align:center"> float </td><td style="text-align:left"> The result of <code>dot(normal, view)</code>, always strictly greater than 0 (must be used after <code>prepareMaterial()</code>) </td></tr>
 <tr><td style="text-align:left"> <strong class="asterisk">getColor()</strong> </td><td style="text-align:center"> float4 </td><td style="text-align:left"> Interpolated color of the fragment, if the color attribute is required </td></tr>
-<tr><td style="text-align:left"> <strong class="asterisk">getUV0()</strong> </td><td style="text-align:center"> float2 </td><td style="text-align:left"> First interpolated set of UV coordinates, if the uv0 attribute is required </td></tr>
-<tr><td style="text-align:left"> <strong class="asterisk">getUV1()</strong> </td><td style="text-align:center"> float2 </td><td style="text-align:left"> First interpolated set of UV coordinates, if the uv1 attribute is required </td></tr>
+<tr><td style="text-align:left"> <strong class="asterisk">getUV0()</strong> </td><td style="text-align:center"> float2 </td><td style="text-align:left"> First interpolated set of UV coordinates, only available if the uv0 attribute is required </td></tr>
+<tr><td style="text-align:left"> <strong class="asterisk">getUV1()</strong> </td><td style="text-align:center"> float2 </td><td style="text-align:left"> First interpolated set of UV coordinates, only available if the uv1 attribute is required </td></tr>
+<tr><td style="text-align:left"> <strong class="asterisk">getMaskThreshold()</strong> </td><td style="text-align:center"> float </td><td style="text-align:left"> Returns the mask threshold, only available when <code>blending</code> is set to <code>masked</code> </td></tr>
 <tr><td style="text-align:left"> <strong class="asterisk">inverseTonemap(float3)</strong> </td><td style="text-align:center"> float3 </td><td style="text-align:left"> Applies the inverse tone mapping operator to the specified linear sRGB color and returns a linear sRGB color. This operation may be an approximation </td></tr>
 <tr><td style="text-align:left"> <strong class="asterisk">inverseTonemapSRGB(float3)</strong> </td><td style="text-align:center"> float3 </td><td style="text-align:left"> Applies the inverse tone mapping operator to the specified non-linear sRGB color and returns a linear sRGB color. This operation may be an approximation </td></tr>
 <tr><td style="text-align:left"> <strong class="asterisk">luminance(float3)</strong> </td><td style="text-align:center"> float </td><td style="text-align:left"> Computes the luminance of the specified linear sRGB color </td></tr>
diff --git a/docs/Materials.md.html b/docs/Materials.md.html
index c641f03af9..96e4ec608d 100644
--- a/docs/Materials.md.html
+++ b/docs/Materials.md.html
@@ -1283,7 +1283,7 @@ material {
 ![Figure [specularAO]: Comparison of specular ambient occlusion on and off. The effect is
 particularly visible under the hose.](images/screenshot_specular_ao.gif)
 
-### Anti-aliasing: curvatureToRoughness
+### Anti-aliasing: specularAntiAliasing
 
 Type
 :    `boolean`
@@ -1292,36 +1292,52 @@ Value
 :     `true` or `false`. Defaults to `false`.
 
 Description
-:    Reduces specular aliasing by increasing roughness based on the local geometric curvature.
-     This property is particularly effective if you only use MSAA as your anti-aliasing method.
+:    Reduces specular aliasing and preserves the shape of specular highlights as an object moves
+     away from the camera. This anti-aliasing solution is particularly effective on glossy materials
+     (low roughness) but increases the cost of the material. The strengthf of the anti-aliasing
+     effect can be controlled using two other properties: `specularAntiAliasingVariance` and
+     `specularAntiAliasingThreshold`.
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ JSON
 material {
-    curvatureToRoughness : true
+    specularAntiAliasing : true
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-![Figure [curvatureToRoughness]: Close up of a glossy metallic surface rendered normally (left) and
-with `curvatureToRoughness` (right).](images/screenshot_curvature_to_roughness.jpg)
-
-### Anti-aliasing: limitOverInterpolation
+### Anti-aliasing: specularAntiAliasingVariance
 
 Type
-:    `boolean`
+:    `float`
 
 Value
-:     `true` or `false`. Defaults to `false`.
+:     A value between 0 and 1, set to 0.15 by default.
 
 Description
-:    Reduces specular aliasing by attempting to eliminate normal over-interpolation. When this
-     property is turned on, the material switches to centroid normal interpolation when the
-     interpolated normals are too long. This property should only be used if your anti-aliasing
-     method is MSAA. The effects are a lot more subtle than `curvatureToRoughness`, which should be
-     used first to eliminate specular aliasing.
+:    Sets the screen space variance of the filter kernel used when applying specular anti-aliasing.
+     Higher values will increase the effect of the filter but may increase roughness in unwanted
+     areas.
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ JSON
 material {
-    limitOverInterpolation : true
+    specularAntiAliasingVariance : 0.2
+}
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+### Anti-aliasing: specularAntiAliasingThreshold
+
+Type
+:    `float`
+
+Value
+:     A value between 0 and 1, set to 0.2 by default.
+
+Description
+:    Sets the clamping threshold used to suppress estimation errors when applying specular
+     anti-aliasing. When set to 0, specular anti-aliasing is disabled.
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ JSON
+material {
+    specularAntiAliasingThreshold : 0.1
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -1567,20 +1583,22 @@ The following APIs are only available from the vertex block:
 
 The following APIs are only available from the fragment block:
 
-               Name              |   Type   |            Description
-:--------------------------------|:--------:|:------------------------------------
-**getWorldTangentFrame()**       | float3x3 |  Matrix containing in each column the `tangent` (`frame[0]`), `bi-tangent` (`frame[1]`) and `normal` (`frame[2]`) of the vertex in world space. If the material does not compute a tangent space normal for bump mapping or if the shading is not anisotropic, only the `normal` is valid in this matrix.
-**getWorldPosition()**           | float3   |  Position of the fragment in world space
-**getWorldViewVector()**         | float3   |  Normalized vector in world space from the fragment position to the eye
-**getWorldNormalVector()**       | float3   |  Normalized normal in world space, after bump mapping (must be used after `prepareMaterial()`)
-**getWorldReflectedVector()**    | float3   |  Reflection of the view vector about the normal (must be used after `prepareMaterial()`)
-**getNdotV()**                   | float    |  The result of `dot(normal, view)`, always strictly greater than 0 (must be used after `prepareMaterial()`)
-**getColor()**                   | float4   |  Interpolated color of the fragment, if the color attribute is required
-**getUV0()**                     | float2   |  First interpolated set of UV coordinates, if the uv0 attribute is required
-**getUV1()**                     | float2   |  First interpolated set of UV coordinates, if the uv1 attribute is required
-**inverseTonemap(float3)**       | float3   |  Applies the inverse tone mapping operator to the specified linear sRGB color and returns a linear sRGB color. This operation may be an approximation
-**inverseTonemapSRGB(float3)**   | float3   |  Applies the inverse tone mapping operator to the specified non-linear sRGB color and returns a linear sRGB color. This operation may be an approximation
-**luminance(float3)**            | float    |  Computes the luminance of the specified linear sRGB color
+                 Name               |   Type   |            Description
+:-----------------------------------|:--------:|:------------------------------------
+**getWorldTangentFrame()**          | float3x3 |  Matrix containing in each column the `tangent` (`frame[0]`), `bi-tangent` (`frame[1]`) and `normal` (`frame[2]`) of the vertex in world space. If the material does not compute a tangent space normal for bump mapping or if the shading is not anisotropic, only the `normal` is valid in this matrix.
+**getWorldPosition()**              | float3   |  Position of the fragment in world space
+**getWorldViewVector()**            | float3   |  Normalized vector in world space from the fragment position to the eye
+**getWorldNormalVector()**          | float3   |  Normalized normal in world space, after bump mapping (must be used after `prepareMaterial()`)
+**getWorldGeometricNormalVector()** | float3   |  Normalized normal in world space, before bump mapping (can be used before `prepareMaterial()`)
+**getWorldReflectedVector()**       | float3   |  Reflection of the view vector about the normal (must be used after `prepareMaterial()`)
+**getNdotV()**                      | float    |  The result of `dot(normal, view)`, always strictly greater than 0 (must be used after `prepareMaterial()`)
+**getColor()**                      | float4   |  Interpolated color of the fragment, if the color attribute is required
+**getUV0()**                        | float2   |  First interpolated set of UV coordinates, only available if the uv0 attribute is required
+**getUV1()**                        | float2   |  First interpolated set of UV coordinates, only available if the uv1 attribute is required
+**getMaskThreshold()**              | float    |  Returns the mask threshold, only available when `blending` is set to `masked`
+**inverseTonemap(float3)**          | float3   |  Applies the inverse tone mapping operator to the specified linear sRGB color and returns a linear sRGB color. This operation may be an approximation
+**inverseTonemapSRGB(float3)**      | float3   |  Applies the inverse tone mapping operator to the specified non-linear sRGB color and returns a linear sRGB color. This operation may be an approximation
+**luminance(float3)**               | float    |  Computes the luminance of the specified linear sRGB color
 
 # Compiling materials
 
diff --git a/docs/images/screenshot_curvature_to_roughness.jpg b/docs/images/screenshot_curvature_to_roughness.jpg
deleted file mode 100644
index 02556c28f9..0000000000
Binary files a/docs/images/screenshot_curvature_to_roughness.jpg and /dev/null differ
diff --git a/filament/include/filament/Material.h b/filament/include/filament/Material.h
index 67111336fb..47f5fbca1a 100644
--- a/filament/include/filament/Material.h
+++ b/filament/include/filament/Material.h
@@ -163,6 +163,15 @@ public:
     //! This values only makes sense when the shading mode is unlit.
     bool hasShadowMultiplier() const noexcept;
 
+    //! Indicates whether this material has specular anti-aliasing enabled
+    bool hasSpecularAntiAliasing() const noexcept;
+
+    //! Returns the screen-space variance for specular-antialiasing, this value is between 0 and 1.
+    float getSpecularAntiAliasingVariance() const noexcept;
+
+    //! Returns the clamping threshold for specular-antialiasing, this value is between 0 and 1.
+    float getSpecularAntiAliasingThreshold() const noexcept;
+
     //! Returns the list of vertex attributes required by this material.
     AttributeBitset getRequiredAttributes() const noexcept;
 
diff --git a/filament/include/filament/MaterialInstance.h b/filament/include/filament/MaterialInstance.h
index 0633a2572e..71863cb729 100644
--- a/filament/include/filament/MaterialInstance.h
+++ b/filament/include/filament/MaterialInstance.h
@@ -126,10 +126,25 @@ public:
 
     /**
      * Overrides the minimum alpha value a fragment must have to not be discarded when the blend
-     * mode is MASKED. Defaults to 0.4 if it has not been set in the parent Material.
+     * mode is MASKED. Defaults to 0.4 if it has not been set in the parent Material. The specified
+     * value should be between 0 and 1 and will be clamped if necessary.
      */
     void setMaskThreshold(float threshold) noexcept;
 
+    /**
+     * Sets the screen space variance of the filter kernel used when applying specular
+     * anti-aliasing. The default value is set to 0.15. The specified value should be between
+     * 0 and 1 and will be clamped if necessary.
+     */
+    void setSpecularAntiAliasingVariance(float variance) noexcept;
+
+    /**
+     * Sets the clamping threshold used to suppress estimation errors when applying specular
+     * anti-aliasing. The default value is set to 0.2. The specified value should be between 0
+     * and 1 and will be clamped if necessary.
+     */
+    void setSpecularAntiAliasingThreshold(float threshold) noexcept;
+
     /**
      * Enables or disables double-sided lighting if the parent Material has double-sided capability,
      * otherwise prints a warning.
diff --git a/filament/src/Material.cpp b/filament/src/Material.cpp
index 2b35d7715e..4e17fb4ee6 100644
--- a/filament/src/Material.cpp
+++ b/filament/src/Material.cpp
@@ -230,6 +230,12 @@ FMaterial::FMaterial(FEngine& engine, const Material::Builder& builder)
     mRasterState.depthFunc = depthTest ? DepthFunc::LE : DepthFunc::A;
     mRasterState.alphaToCoverage = mBlendingMode == BlendingMode::MASKED;
 
+    parser->hasSpecularAntiAliasing(&mSpecularAntiAliasing);
+    if (mSpecularAntiAliasing) {
+        parser->getSpecularAntiAliasingVariance(&mSpecularAntiAliasingVariance);
+        parser->getSpecularAntiAliasingThreshold(&mSpecularAntiAliasingThreshold);
+    }
+
     // we can only initialize the default instance once we're initialized ourselves
     mDefaultInstance.initDefaultInstance(engine, this);
 }
@@ -439,6 +445,18 @@ bool Material::hasShadowMultiplier() const noexcept {
     return upcast(this)->hasShadowMultiplier();
 }
 
+bool Material::hasSpecularAntiAliasing() const noexcept {
+    return upcast(this)->hasSpecularAntiAliasing();
+}
+
+float Material::getSpecularAntiAliasingVariance() const noexcept {
+    return upcast(this)->getSpecularAntiAliasingVariance();
+}
+
+float Material::getSpecularAntiAliasingThreshold() const noexcept {
+    return upcast(this)->getSpecularAntiAliasingThreshold();
+}
+
 size_t Material::getParameterCount() const noexcept {
     return upcast(this)->getParameterCount();
 }
diff --git a/filament/src/MaterialInstance.cpp b/filament/src/MaterialInstance.cpp
index 5642bfa6f8..204eb726c5 100644
--- a/filament/src/MaterialInstance.cpp
+++ b/filament/src/MaterialInstance.cpp
@@ -42,11 +42,12 @@ namespace details {
 FMaterialInstance::FMaterialInstance() noexcept = default;
 
 FMaterialInstance::FMaterialInstance(FEngine& engine, FMaterial const* material) {
-    FEngine::DriverApi& driver = engine.getDriverApi();
     mMaterial = material;
     mMaterialSortingKey = RenderPass::makeMaterialSortingKey(
             material->getId(), material->generateMaterialInstanceId());
 
+    FEngine::DriverApi& driver = engine.getDriverApi();
+
     if (!material->getUniformInterfaceBlock().isEmpty()) {
         mUniforms.setUniforms(material->getDefaultInstance()->getUniformBuffer());
         mUbHandle = driver.createUniformBuffer(mUniforms.getSize(), backend::BufferUsage::DYNAMIC);
@@ -57,24 +58,17 @@ FMaterialInstance::FMaterialInstance(FEngine& engine, FMaterial const* material)
         mSbHandle = driver.createSamplerGroup(mSamplers.getSize());
     }
 
-    if (material->getBlendingMode() == BlendingMode::MASKED) {
-        static_cast<MaterialInstance*>(this)->setParameter(
-                "_maskThreshold", material->getMaskThreshold());
-    }
-
-    if (material->hasDoubleSidedCapability()) {
-        static_cast<MaterialInstance*>(this)->setParameter(
-                "_doubleSided", material->isDoubleSided());
-    }
+    initParameters(material);
 }
 
 // This version is used to initialize the default material instance
 void FMaterialInstance::initDefaultInstance(FEngine& engine, FMaterial const* material) {
-    FEngine::DriverApi& driver = engine.getDriverApi();
     mMaterial = material;
     mMaterialSortingKey = RenderPass::makeMaterialSortingKey(
             material->getId(), material->generateMaterialInstanceId());
 
+    FEngine::DriverApi& driver = engine.getDriverApi();
+
     if (!material->getUniformInterfaceBlock().isEmpty()) {
         mUniforms = UniformBuffer(material->getUniformInterfaceBlock().getSize());
         mUbHandle = driver.createUniformBuffer(mUniforms.getSize(), backend::BufferUsage::STATIC);
@@ -85,6 +79,19 @@ void FMaterialInstance::initDefaultInstance(FEngine& engine, FMaterial const* ma
         mSbHandle = driver.createSamplerGroup(mSamplers.getSize());
     }
 
+    initParameters(material);
+}
+
+FMaterialInstance::~FMaterialInstance() noexcept = default;
+
+void FMaterialInstance::terminate(FEngine& engine) {
+    FEngine::DriverApi& driver = engine.getDriverApi();
+    driver.destroyUniformBuffer(mUbHandle);
+    driver.destroySamplerGroup(mSbHandle);
+}
+
+void FMaterialInstance::initParameters(FMaterial const* material) {
+
     if (material->getBlendingMode() == BlendingMode::MASKED) {
         static_cast<MaterialInstance*>(this)->setParameter(
                 "_maskThreshold", material->getMaskThreshold());
@@ -94,14 +101,13 @@ void FMaterialInstance::initDefaultInstance(FEngine& engine, FMaterial const* ma
         static_cast<MaterialInstance*>(this)->setParameter(
                 "_doubleSided", material->isDoubleSided());
     }
-}
 
-FMaterialInstance::~FMaterialInstance() noexcept = default;
-
-void FMaterialInstance::terminate(FEngine& engine) {
-    FEngine::DriverApi& driver = engine.getDriverApi();
-    driver.destroyUniformBuffer(mUbHandle);
-    driver.destroySamplerGroup(mSbHandle);
+    if (material->hasSpecularAntiAliasing()) {
+        static_cast<MaterialInstance*>(this)->setParameter(
+                "_specularAntiAliasingVariance", material->getSpecularAntiAliasingVariance());
+        static_cast<MaterialInstance*>(this)->setParameter(
+                "_specularAntiAliasingThreshold", material->getSpecularAntiAliasingThreshold());
+    }
 }
 
 void FMaterialInstance::commitSlow(DriverApi& driver) const {
@@ -273,6 +279,14 @@ void MaterialInstance::setMaskThreshold(float threshold) noexcept {
     upcast(this)->setMaskThreshold(threshold);
 }
 
+void MaterialInstance::setSpecularAntiAliasingVariance(float variance) noexcept {
+    upcast(this)->setSpecularAntiAliasingVariance(variance);
+}
+
+void MaterialInstance::setSpecularAntiAliasingThreshold(float threshold) noexcept {
+    upcast(this)->setSpecularAntiAliasingThreshold(threshold);
+}
+
 void MaterialInstance::setDoubleSided(bool doubleSided) noexcept {
     upcast(this)->setDoubleSided(doubleSided);
 }
diff --git a/filament/src/MaterialParser.cpp b/filament/src/MaterialParser.cpp
index aa72fc4135..863cc0c6bd 100644
--- a/filament/src/MaterialParser.cpp
+++ b/filament/src/MaterialParser.cpp
@@ -236,6 +236,18 @@ bool MaterialParser::hasCustomDepthShader(bool* value) const noexcept {
     return mImpl.getFromSimpleChunk(ChunkType::MaterialHasCustomDepthShader, value);
 }
 
+bool MaterialParser::hasSpecularAntiAliasing(bool* value) const noexcept {
+    return mImpl.getFromSimpleChunk(ChunkType::MaterialSpecularAntiAliasing, value);
+}
+
+bool MaterialParser::getSpecularAntiAliasingVariance(float* value) const noexcept {
+    return mImpl.getFromSimpleChunk(ChunkType::MaterialSpecularAntiAliasingVariance, value);
+}
+
+bool MaterialParser::getSpecularAntiAliasingThreshold(float* value) const noexcept {
+    return mImpl.getFromSimpleChunk(ChunkType::MaterialSpecularAntiAliasingThreshold, value);
+}
+
 bool MaterialParser::getRequiredAttributes(AttributeBitset* value) const noexcept {
     uint32_t rawAttributes = 0;
     if (!mImpl.getFromSimpleChunk(ChunkType::MaterialRequiredAttributes, &rawAttributes)) {
diff --git a/filament/src/MaterialParser.h b/filament/src/MaterialParser.h
index 10d4958e6b..59c2de3b83 100644
--- a/filament/src/MaterialParser.h
+++ b/filament/src/MaterialParser.h
@@ -77,6 +77,9 @@ public:
     bool hasShadowMultiplier(bool*) const noexcept;
     bool getRequiredAttributes(AttributeBitset*) const noexcept;
     bool hasCustomDepthShader(bool* value) const noexcept;
+    bool hasSpecularAntiAliasing(bool* value) const noexcept;
+    bool getSpecularAntiAliasingVariance(float* value) const noexcept;
+    bool getSpecularAntiAliasingThreshold(float* value) const noexcept;
 
     bool getShader(filaflat::ShaderBuilder& shader, backend::ShaderModel shaderModel,
             uint8_t variant, backend::ShaderType stage) noexcept;
diff --git a/filament/src/details/Material.h b/filament/src/details/Material.h
index 353bc061ab..46c4af768f 100644
--- a/filament/src/details/Material.h
+++ b/filament/src/details/Material.h
@@ -107,6 +107,10 @@ public:
     bool hasShadowMultiplier() const noexcept { return mHasShadowMultiplier; }
     AttributeBitset getRequiredAttributes() const noexcept { return mRequiredAttributes; }
 
+    bool hasSpecularAntiAliasing() const noexcept { return mSpecularAntiAliasing; }
+    float getSpecularAntiAliasingVariance() const noexcept { return mSpecularAntiAliasingVariance; }
+    float getSpecularAntiAliasingThreshold() const noexcept { return mSpecularAntiAliasingThreshold; }
+
     size_t getParameterCount() const noexcept {
         return mUniformInterfaceBlock.getUniformInfoList().size() +
                 mSamplerInterfaceBlock.getSamplerInfoList().size();
@@ -130,12 +134,17 @@ private:
     VertexDomain mVertexDomain;
     CullingMode mCullingMode;
     AttributeBitset mRequiredAttributes;
-    float mMaskThreshold;
+
+    float mMaskThreshold = 0.4f;
+    float mSpecularAntiAliasingVariance;
+    float mSpecularAntiAliasingThreshold;
+
     bool mDoubleSided;
     bool mDoubleSidedCapability = false;
     bool mHasShadowMultiplier = false;
     bool mHasCustomDepthShader = false;
     bool mIsDefaultMaterial = false;
+    bool mSpecularAntiAliasing = false;
 
     FMaterialInstance mDefaultInstance;
     SamplerInterfaceBlock mSamplerInterfaceBlock;
diff --git a/filament/src/details/MaterialInstance.h b/filament/src/details/MaterialInstance.h
index 027551d9c4..5eee9758d2 100644
--- a/filament/src/details/MaterialInstance.h
+++ b/filament/src/details/MaterialInstance.h
@@ -25,6 +25,8 @@
 
 #include <backend/Handle.h>
 
+#include <math/scalar.h>
+
 #include <utils/compiler.h>
 
 #include <filament/MaterialInstance.h>
@@ -101,7 +103,15 @@ public:
     backend::PolygonOffset getPolygonOffset() const noexcept { return mPolygonOffset; }
 
     void setMaskThreshold(float threshold) noexcept {
-        setParameter("_maskThreshold", threshold);
+        setParameter("_maskThreshold", math::saturate(threshold));
+    }
+
+    void setSpecularAntiAliasingVariance(float variance) noexcept {
+        setParameter("_specularAntiAliasingVariance", math::saturate(variance));
+    }
+
+    void setSpecularAntiAliasingThreshold(float threshold) noexcept {
+        setParameter("_specularAntiAliasingThreshold", math::saturate(threshold * threshold));
     }
 
     void setDoubleSided(bool doubleSided) noexcept;
@@ -112,6 +122,7 @@ private:
 
     FMaterialInstance() noexcept;
     void initDefaultInstance(FEngine& engine, FMaterial const* material);
+    void initParameters(FMaterial const* material);
 
     void commitSlow(FEngine::DriverApi& driver) const;
 
diff --git a/libs/filabridge/include/filament/MaterialChunkType.h b/libs/filabridge/include/filament/MaterialChunkType.h
index c899cf59bf..4f0eeac652 100644
--- a/libs/filabridge/include/filament/MaterialChunkType.h
+++ b/libs/filabridge/include/filament/MaterialChunkType.h
@@ -53,8 +53,9 @@ enum UTILS_PUBLIC ChunkType : uint64_t {
     MaterialTransparencyMode = charTo64bitNum("MAT_TRMD"),
     MaterialMaskThreshold = charTo64bitNum("MAT_THRS"),
     MaterialShadowMultiplier = charTo64bitNum("MAT_SHML"),
-    MaterialCurvatureToRoughness = charTo64bitNum("MAT_CV2R"),
-    MaterialLimitOverInterpolation = charTo64bitNum("MAT_LMOI"),
+    MaterialSpecularAntiAliasing = charTo64bitNum("MAT_SPAA"),
+    MaterialSpecularAntiAliasingVariance = charTo64bitNum("MAT_SVAR"),
+    MaterialSpecularAntiAliasingThreshold = charTo64bitNum("MAT_STHR"),
     MaterialClearCoatIorChange = charTo64bitNum("MAT_CIOR"),
 
     MaterialRequiredAttributes = charTo64bitNum("MAT_REQA"),
diff --git a/libs/filamat/include/filamat/MaterialBuilder.h b/libs/filamat/include/filamat/MaterialBuilder.h
index 763cb33871..d7dbc8d205 100644
--- a/libs/filamat/include/filamat/MaterialBuilder.h
+++ b/libs/filamat/include/filamat/MaterialBuilder.h
@@ -217,18 +217,30 @@ public:
     MaterialBuilder& doubleSided(bool doubleSided) noexcept;
 
     // any fragment with an alpha below this threshold is clipped (MASKED blending mode only)
+    // the mask threshold can also be controlled by using the float material parameter
+    // called "_maskTrehshold", or by calling MaterialInstance::setMaskTreshold
     MaterialBuilder& maskThreshold(float threshold) noexcept;
 
     // the material output is multiplied by the shadowing factor (UNLIT model only)
     MaterialBuilder& shadowMultiplier(bool shadowMultiplier) noexcept;
 
-    // reduce specular aliasing by locally increasing roughness using geometric curvature
+    // reduces specular aliasing for materials that have low roughness. Turning this feature
+    // on also helps preserve the shapes of specular highlights as an object moves away from
+    // the camera. When turned on, two float material parameters are added to control the effect:
+    // "_specularAAScreenSpaceVariance" and "_specularAAThreshold". You can also use
+    // MaterialInstance::setSpecularAntiAliasingVariance and setSpecularAntiAliasingThreshold
     // disabled by default
-    MaterialBuilder& curvatureToRoughness(bool curvatureToRoughness) noexcept;
+    MaterialBuilder& specularAntiAliasing(bool specularAntiAliasing) noexcept;
 
-    // reduce specular aliasing at silhouette by preventing over-interpolation of geometric normals
-    // disabled by default
-    MaterialBuilder& limitOverInterpolation(bool limitOverInterpolation) noexcept;
+    // sets the screen space variance of the filter kernel used when applying specular
+    // anti-aliasing. The default value is set to 0.15. The specified value should be between
+    // 0 and 1 and will be clamped if necessary.
+    MaterialBuilder& specularAntiAliasingVariance(float screenSpaceVariance) noexcept;
+
+    // sets the clamping threshold used to suppress estimation errors when applying specular
+    // anti-aliasing. The default value is set to 0.2. The specified value should be between 0
+    // and 1 and will be clamped if necessary.
+    MaterialBuilder& specularAntiAliasingThreshold(float threshold) noexcept;
 
     // enables or disables the index of refraction (IoR) change caused by the clear coat layer when
     // present. When the IoR changes, the base color is darkened. Disabling this feature preserves
@@ -350,6 +362,9 @@ private:
     filament::AttributeBitset mRequiredAttributes;
 
     float mMaskThreshold = 0.4f;
+    float mSpecularAntiAliasingVariance = 0.15f;
+    float mSpecularAntiAliasingThreshold = 0.2f;
+
     bool mShadowMultiplier = false;
 
     uint8_t mParameterCount = 0;
@@ -361,8 +376,7 @@ private:
     bool mDepthWrite = true;
     bool mDepthWriteSet = false;
 
-    bool mCurvatureToRoughness = false;
-    bool mLimitOverInterpolation = false;
+    bool mSpecularAntiAliasing = false;
     bool mClearCoatIorChange = true;
 
     bool mFlipUV = true;
diff --git a/libs/filamat/src/MaterialBuilder.cpp b/libs/filamat/src/MaterialBuilder.cpp
index c8df0eb49d..4fd85d517f 100644
--- a/libs/filamat/src/MaterialBuilder.cpp
+++ b/libs/filamat/src/MaterialBuilder.cpp
@@ -244,13 +244,18 @@ MaterialBuilder& MaterialBuilder::shadowMultiplier(bool shadowMultiplier) noexce
     return *this;
 }
 
-MaterialBuilder& MaterialBuilder::curvatureToRoughness(bool curvatureToRoughness) noexcept {
-    mCurvatureToRoughness = curvatureToRoughness;
+MaterialBuilder& MaterialBuilder::specularAntiAliasing(bool specularAntiAliasing) noexcept {
+    mSpecularAntiAliasing = specularAntiAliasing;
     return *this;
 }
 
-MaterialBuilder& MaterialBuilder::limitOverInterpolation(bool limitOverInterpolation) noexcept {
-    mLimitOverInterpolation = limitOverInterpolation;
+MaterialBuilder& MaterialBuilder::specularAntiAliasingVariance(float screenSpaceVariance) noexcept {
+    mSpecularAntiAliasingVariance = screenSpaceVariance;
+    return *this;
+}
+
+MaterialBuilder& MaterialBuilder::specularAntiAliasingThreshold(float threshold) noexcept {
+    mSpecularAntiAliasingThreshold = threshold;
     return *this;
 }
 
@@ -329,6 +334,11 @@ void MaterialBuilder::prepareToBuild(MaterialInfo& info) noexcept {
         }
     }
 
+    if (mSpecularAntiAliasing) {
+        ibb.add("_specularAntiAliasingVariance", 1, UniformType::FLOAT);
+        ibb.add("_specularAntiAliasingThreshold", 1, UniformType::FLOAT);
+    }
+
     if (mBlendingMode == BlendingMode::MASKED) {
         ibb.add("_maskThreshold", 1, UniformType::FLOAT);
     }
@@ -348,8 +358,7 @@ void MaterialBuilder::prepareToBuild(MaterialInfo& info) noexcept {
     info.isLit = isLit();
     info.hasDoubleSidedCapability = mDoubleSidedCapability;
     info.hasExternalSamplers = hasExternalSampler();
-    info.curvatureToRoughness = mCurvatureToRoughness;
-    info.limitOverInterpolation = mLimitOverInterpolation;
+    info.specularAntiAliasing = mSpecularAntiAliasing;
     info.clearCoatIorChange = mClearCoatIorChange;
     info.flipUV = mFlipUV;
     info.requiredAttributes = mRequiredAttributes;
@@ -477,13 +486,17 @@ Package MaterialBuilder::build() noexcept {
         container.addChild(&matShadowMultiplier);
     }
 
-    SimpleFieldChunk<bool> matCurvatureToRoughness(
-            ChunkType::MaterialCurvatureToRoughness, mCurvatureToRoughness);
-    container.addChild(&matCurvatureToRoughness);
+    SimpleFieldChunk<bool> matSpecularAntiAliasing(
+            ChunkType::MaterialSpecularAntiAliasing, mSpecularAntiAliasing);
+    container.addChild(&matSpecularAntiAliasing);
 
-    SimpleFieldChunk<bool> matLimitOverInterpolation(
-            ChunkType::MaterialLimitOverInterpolation, mLimitOverInterpolation);
-    container.addChild(&matLimitOverInterpolation);
+    SimpleFieldChunk<float> matSpecularAntiAliasingVariance(
+            ChunkType::MaterialSpecularAntiAliasingVariance, mSpecularAntiAliasingVariance);
+    container.addChild(&matSpecularAntiAliasingVariance);
+
+    SimpleFieldChunk<float> matSpecularAntiAliasingThreshold(
+            ChunkType::MaterialSpecularAntiAliasingThreshold, mSpecularAntiAliasingThreshold);
+    container.addChild(&matSpecularAntiAliasingThreshold);
 
     SimpleFieldChunk<bool> matClearCoatIorChange(
             ChunkType::MaterialClearCoatIorChange, mClearCoatIorChange);
diff --git a/libs/filamat/src/shaders/CodeGenerator.cpp b/libs/filamat/src/shaders/CodeGenerator.cpp
index e7fc45d5a7..39aa298697 100644
--- a/libs/filamat/src/shaders/CodeGenerator.cpp
+++ b/libs/filamat/src/shaders/CodeGenerator.cpp
@@ -406,16 +406,18 @@ io::sstream& CodeGenerator::generateCommon(io::sstream& out, ShaderType type) co
     out << SHADERS_COMMON_MATH_FS_DATA;
     if (type == ShaderType::VERTEX) {
     } else if (type == ShaderType::FRAGMENT) {
+        out << SHADERS_COMMON_SHADING_FS_DATA;
         out << SHADERS_COMMON_GRAPHICS_FS_DATA;
+        out << SHADERS_COMMON_MATERIAL_FS_DATA;
     }
     return out;
 }
 
 io::sstream& CodeGenerator::generateCommonMaterial(io::sstream& out, ShaderType type) const {
     if (type == ShaderType::VERTEX) {
-        out << SHADERS_COMMON_MATERIAL_VS_DATA;
+        out << SHADERS_MATERIAL_INPUTS_VS_DATA;
     } else if (type == ShaderType::FRAGMENT) {
-        out << SHADERS_COMMON_MATERIAL_FS_DATA;
+        out << SHADERS_MATERIAL_INPUTS_FS_DATA;
     }
     return out;
 }
diff --git a/libs/filamat/src/shaders/MaterialInfo.h b/libs/filamat/src/shaders/MaterialInfo.h
index 4733d3a7e0..e132a510c5 100644
--- a/libs/filamat/src/shaders/MaterialInfo.h
+++ b/libs/filamat/src/shaders/MaterialInfo.h
@@ -36,8 +36,7 @@ struct UTILS_PUBLIC MaterialInfo {
     bool hasDoubleSidedCapability;
     bool hasExternalSamplers;
     bool hasShadowMultiplier;
-    bool curvatureToRoughness;
-    bool limitOverInterpolation;
+    bool specularAntiAliasing;
     bool clearCoatIorChange;
     bool flipUV;
     bool multiBounceAO;
diff --git a/libs/filamat/src/shaders/ShaderGenerator.cpp b/libs/filamat/src/shaders/ShaderGenerator.cpp
index e77c2c7842..d76341ea07 100644
--- a/libs/filamat/src/shaders/ShaderGenerator.cpp
+++ b/libs/filamat/src/shaders/ShaderGenerator.cpp
@@ -139,7 +139,6 @@ const std::string ShaderGenerator::createVertexProgram(filament::backend::Shader
     cg.generateProlog(vs, ShaderType::VERTEX, material.hasExternalSamplers);
 
     cg.generateDefine(vs, "FLIP_UV_ATTRIBUTE", material.flipUV);
-    cg.generateDefine(vs, "GEOMETRIC_SPECULAR_AA_NORMAL", material.limitOverInterpolation);
 
     bool litVariants = lit || material.hasShadowMultiplier;
     cg.generateDefine(vs, "HAS_DIRECTIONAL_LIGHTING", litVariants && variant.hasDirectionalLighting());
@@ -232,8 +231,7 @@ const std::string ShaderGenerator::createFragmentProgram(filament::backend::Shad
     // this should probably be a code generation option
     cg.generateDefine(fs, "USE_MULTIPLE_SCATTERING_COMPENSATION", true);
 
-    cg.generateDefine(fs, "GEOMETRIC_SPECULAR_AA_ROUGHNESS", material.curvatureToRoughness);
-    cg.generateDefine(fs, "GEOMETRIC_SPECULAR_AA_NORMAL", material.limitOverInterpolation);
+    cg.generateDefine(fs, "GEOMETRIC_SPECULAR_AA", material.specularAntiAliasing && lit);
 
     cg.generateDefine(fs, "CLEAR_COAT_IOR_CHANGE", material.clearCoatIorChange);
 
diff --git a/samples/material_sandbox.cpp b/samples/material_sandbox.cpp
index d1ce27634c..a39990db1b 100644
--- a/samples/material_sandbox.cpp
+++ b/samples/material_sandbox.cpp
@@ -313,6 +313,11 @@ static void gui(filament::Engine* engine, filament::View*) {
             }
         }
 
+        if (ImGui::CollapsingHeader("Shading AA")) {
+            ImGui::SliderFloat("variance", &params.specularAntiAliasingVariance, 0.0f, 1.0f);
+            ImGui::SliderFloat("threshold", &params.specularAntiAliasingThreshold, 0.0f, 1.0f);
+        }
+
         if (ImGui::CollapsingHeader("Object")) {
             ImGui::Checkbox("castShadows", &params.castShadows);
         }
diff --git a/samples/material_sandbox.h b/samples/material_sandbox.h
index 9a6736e327..399140c178 100644
--- a/samples/material_sandbox.h
+++ b/samples/material_sandbox.h
@@ -64,6 +64,8 @@ struct SandboxParameters {
     float thickness = 1.0f;
     float subsurfacePower = 12.234f;
     float glossiness = 0.0f;
+    float specularAntiAliasingVariance = 0.0f;
+    float specularAntiAliasingThreshold = 0.0f;
     filament::sRGBColor specularColor = {0.0f, 0.0f, 0.0f};
     filament::sRGBColor subsurfaceColor = {0.0f};
     filament::sRGBColor sheenColor = {0.83f, 0.0f, 0.0f};
@@ -199,6 +201,10 @@ inline filament::MaterialInstance* updateInstances(SandboxParameters& params,
         materialInstance->setParameter("sheenColor", RgbType::sRGB, params.sheenColor);
         materialInstance->setParameter("subsurfaceColor", RgbType::sRGB, params.subsurfaceColor);
     }
+    if (params.currentMaterialModel != MATERIAL_MODEL_UNLIT) {
+        materialInstance->setSpecularAntiAliasingVariance(params.specularAntiAliasingVariance);
+        materialInstance->setSpecularAntiAliasingThreshold(params.specularAntiAliasingThreshold);
+    }
 
     return materialInstance;
 }
diff --git a/samples/materials/sandboxCloth.mat b/samples/materials/sandboxCloth.mat
index 98454edbf2..b4b4c8b8bf 100644
--- a/samples/materials/sandboxCloth.mat
+++ b/samples/materials/sandboxCloth.mat
@@ -19,6 +19,7 @@ material {
             name : subsurfaceColor
         }
     ],
+    specularAntiAliasing : true
 }
 
 fragment {
diff --git a/samples/materials/sandboxLit.mat b/samples/materials/sandboxLit.mat
index d3da18c1b8..e877af9568 100644
--- a/samples/materials/sandboxLit.mat
+++ b/samples/materials/sandboxLit.mat
@@ -30,7 +30,8 @@ material {
             type : float,
             name : anisotropy
         }
-    ]
+    ],
+    specularAntiAliasing : true
 }
 
 fragment {
diff --git a/samples/materials/sandboxLitFade.mat b/samples/materials/sandboxLitFade.mat
index 44fcec51e1..b31e7b17d5 100644
--- a/samples/materials/sandboxLitFade.mat
+++ b/samples/materials/sandboxLitFade.mat
@@ -36,6 +36,7 @@ material {
             name : anisotropy
         }
     ],
+    specularAntiAliasing : true
 }
 
 fragment {
diff --git a/samples/materials/sandboxLitTransparent.mat b/samples/materials/sandboxLitTransparent.mat
index 6a42773b2e..e06b4eecd8 100644
--- a/samples/materials/sandboxLitTransparent.mat
+++ b/samples/materials/sandboxLitTransparent.mat
@@ -36,6 +36,7 @@ material {
             name : anisotropy
         }
     ],
+    specularAntiAliasing : true
 }
 
 fragment {
diff --git a/samples/materials/sandboxSpecGloss.mat b/samples/materials/sandboxSpecGloss.mat
index 765679f579..dec8ec7c4e 100644
--- a/samples/materials/sandboxSpecGloss.mat
+++ b/samples/materials/sandboxSpecGloss.mat
@@ -30,7 +30,8 @@ material {
             type : float,
             name : anisotropy
         }
-    ]
+    ],
+    specularAntiAliasing : true
 }
 
 fragment {
diff --git a/samples/materials/sandboxSubsurface.mat b/samples/materials/sandboxSubsurface.mat
index 5f44890959..00dee84b47 100644
--- a/samples/materials/sandboxSubsurface.mat
+++ b/samples/materials/sandboxSubsurface.mat
@@ -31,6 +31,7 @@ material {
             name : subsurfaceColor
         }
     ],
+    specularAntiAliasing : true
 }
 
 fragment {
diff --git a/samples/sample_normal_map.cpp b/samples/sample_normal_map.cpp
index 51c9cfcbea..39d7e42122 100644
--- a/samples/sample_normal_map.cpp
+++ b/samples/sample_normal_map.cpp
@@ -260,9 +260,9 @@ static void setup(Engine* engine, View*, Scene* scene) {
         )SHADER";
     } else {
         shader += R"SHADER(
-            material.baseColor.rgb = float3(0.6, 0.6, 0.6);
+            material.baseColor.rgb = float3(0.3, 0.0, 0.0);
             material.metallic = 0.0;
-            material.roughness = 0.7;
+            material.roughness = 0.0;
         )SHADER";
     }
 
@@ -276,6 +276,7 @@ static void setup(Engine* engine, View*, Scene* scene) {
     MaterialBuilder builder = MaterialBuilder()
             .name("DefaultMaterial")
             .material(shader.c_str())
+            .specularAntiAliasing(true)
             .shading(Shading::LIT);
 
     if (hasNormalMap) {
diff --git a/shaders/CMakeLists.txt b/shaders/CMakeLists.txt
index e2b6eba4bb..c0cf03c057 100644
--- a/shaders/CMakeLists.txt
+++ b/shaders/CMakeLists.txt
@@ -17,8 +17,8 @@ set(SHADERS
         src/common_graphics.fs
         src/common_lighting.fs
         src/common_material.fs
-        src/common_material.vs
         src/common_math.fs
+        src/common_shading.fs
         src/common_types.fs
         src/conversion_functions.fs
         src/depth_main.fs
@@ -34,6 +34,8 @@ set(SHADERS
         src/light_punctual.fs
         src/main.fs
         src/main.vs
+        src/material_inputs.fs
+        src/material_inputs.vs
         src/post_process.fs
         src/post_process.vs
         src/shading_lit.fs
diff --git a/shaders/src/common_lighting.fs b/shaders/src/common_lighting.fs
index dd49e89fc6..54d85d571a 100644
--- a/shaders/src/common_lighting.fs
+++ b/shaders/src/common_lighting.fs
@@ -1,18 +1,3 @@
-//------------------------------------------------------------------------------
-// Lighting declarations
-//------------------------------------------------------------------------------
-
-#if defined(TARGET_MOBILE)
-// min roughness such that (MIN_PERCEPTUAL_ROUGHNESS^4) > 0 in fp16 (i.e. 2^(-14/4), rounded up)
-#define MIN_PERCEPTUAL_ROUGHNESS 0.089
-#define MIN_ROUGHNESS            0.007921
-#else
-#define MIN_PERCEPTUAL_ROUGHNESS 0.045
-#define MIN_ROUGHNESS            0.002025
-#endif
-
-#define MAX_CLEAR_COAT_PERCEPTUAL_ROUGHNESS 0.6
-
 struct Light {
     vec4 colorIntensity;  // rgb, pre-exposed intensity
     vec3 l;
@@ -51,52 +36,9 @@ struct PixelParams {
 #endif
 };
 
-vec3 computeDiffuseColor(const vec4 baseColor, float metallic) {
-    return baseColor.rgb * (1.0 - metallic);
-}
-
-vec3 computeF0(const vec4 baseColor, float metallic, float reflectance) {
-    return baseColor.rgb * metallic + (reflectance * (1.0 - metallic));
-}
-
-float computeDielectricF0(float reflectance) {
-    return 0.16 * reflectance * reflectance;
-}
-
-float computeMetallicFromSpecularColor(const vec3 specularColor) {
-    return max3(specularColor);
-}
-
-float computeRoughnessFromGlossiness(float glossiness) {
-    return 1.0 - glossiness;
-}
-
-float perceptualRoughnessToRoughness(float perceptualRoughness) {
-    return perceptualRoughness * perceptualRoughness;
-}
-
 float computeMicroShadowing(float NoL, float visibility) {
     // Chan 2018, "Material Advances in Call of Duty: WWII"
     float aperture = inversesqrt(1.0 - visibility);
     float microShadow = saturate(NoL * aperture);
     return microShadow * microShadow;
 }
-
-float iorToF0(float transmittedIor, float incidentIor) {
-    return sq((transmittedIor - incidentIor) / (transmittedIor + incidentIor));
-}
-
-float f0ToIor(float f0) {
-    float r = sqrt(f0);
-    return (1.0 + r) / (1.0 - r);
-}
-
-vec3 f0ClearCoatToSurface(const vec3 f0) {
-    // Approximation of iorTof0(f0ToIor(f0), 1.5)
-    // This assumes that the clear coat layer has an IOR of 1.5
-#if defined(TARGET_MOBILE)
-    return saturate(f0 * (f0 * 0.526868 + 0.529324) - 0.0482256);
-#else
-    return saturate(f0 * (f0 * (0.941892 - 0.263008 * f0) + 0.346479) - 0.0285998);
-#endif
-}
diff --git a/shaders/src/common_material.fs b/shaders/src/common_material.fs
index 6b8b399af7..992ebe7d22 100644
--- a/shaders/src/common_material.fs
+++ b/shaders/src/common_material.fs
@@ -1,169 +1,64 @@
-//------------------------------------------------------------------------------
-// Material parameters
-//------------------------------------------------------------------------------
+#if defined(TARGET_MOBILE)
+    // min roughness such that (MIN_PERCEPTUAL_ROUGHNESS^4) > 0 in fp16 (i.e. 2^(-14/4), rounded up)
+    #define MIN_PERCEPTUAL_ROUGHNESS 0.089
+    #define MIN_ROUGHNESS            0.007921
+#else
+    #define MIN_PERCEPTUAL_ROUGHNESS 0.045
+    #define MIN_ROUGHNESS            0.002025
+#endif
+
+#define MAX_CLEAR_COAT_PERCEPTUAL_ROUGHNESS 0.6
 
 #define MIN_N_DOT_V 1e-4
 
-// Decide if we can skip lighting when dot(n, l) <= 0.0
-#if defined(SHADING_MODEL_CLOTH)
-#if !defined(MATERIAL_HAS_SUBSURFACE_COLOR)
-    #define MATERIAL_CAN_SKIP_LIGHTING
-#endif
-#elif defined(SHADING_MODEL_SUBSURFACE)
-    // Cannot skip lighting
-#else
-    #define MATERIAL_CAN_SKIP_LIGHTING
-#endif
-
-
-// These variables should be in a struct but some GPU drivers ignore the
-// precision qualifier on individual struct members
-highp mat3  shading_tangentToWorld;   // TBN matrix
-highp vec3  shading_position;         // position of the fragment in world space
-      vec3  shading_view;             // normalized vector from the fragment to the eye
-      vec3  shading_normal;           // normalized normal, in world space
-      vec3  shading_reflected;        // reflection of view about normal
-      float shading_NoV;              // dot(normal, view), always strictly >= MIN_N_DOT_V
-
-#if defined(MATERIAL_HAS_CLEAR_COAT)
-      vec3  shading_clearCoatNormal;  // normalized clear coat layer normal, in world space
-#endif
-
-/** @public-api */
-highp mat3 getWorldTangentFrame() {
-    return shading_tangentToWorld;
-}
-
-/** @public-api */
-highp vec3 getWorldPosition() {
-    return shading_position;
-}
-
-/** @public-api */
-vec3 getWorldViewVector() {
-    return shading_view;
-}
-
-/** @public-api */
-vec3 getWorldNormalVector() {
-    return shading_normal;
-}
-
-/** @public-api */
-vec3 getWorldReflectedVector() {
-    return shading_reflected;
-}
-
-/** @public-api */
-float getNdotV() {
-    return shading_NoV;
-}
-
 float clampNoV(float NoV) {
     // Neubelt and Pettineo 2013, "Crafting a Next-gen Material Pipeline for The Order: 1886"
     return max(dot(shading_normal, shading_view), MIN_N_DOT_V);
 }
 
-struct MaterialInputs {
-    vec4  baseColor;
-#if !defined(SHADING_MODEL_UNLIT)
-#if !defined(SHADING_MODEL_SPECULAR_GLOSSINESS)
-    float roughness;
-#endif
-#if !defined(SHADING_MODEL_CLOTH) && !defined(SHADING_MODEL_SPECULAR_GLOSSINESS)
-    float metallic;
-    float reflectance;
-#endif
-    float ambientOcclusion;
-#endif
-    vec4  emissive;
+vec3 computeDiffuseColor(const vec4 baseColor, float metallic) {
+    return baseColor.rgb * (1.0 - metallic);
+}
 
-    float clearCoat;
-    float clearCoatRoughness;
+vec3 computeF0(const vec4 baseColor, float metallic, float reflectance) {
+    return baseColor.rgb * metallic + (reflectance * (1.0 - metallic));
+}
 
-    float anisotropy;
-    vec3  anisotropyDirection;
+float computeDielectricF0(float reflectance) {
+    return 0.16 * reflectance * reflectance;
+}
 
-#if defined(SHADING_MODEL_SUBSURFACE)
-    float thickness;
-    float subsurfacePower;
-    vec3  subsurfaceColor;
-#endif
+float computeMetallicFromSpecularColor(const vec3 specularColor) {
+    return max3(specularColor);
+}
 
-#if defined(SHADING_MODEL_CLOTH)
-    vec3  sheenColor;
-#if defined(MATERIAL_HAS_SUBSURFACE_COLOR)
-    vec3  subsurfaceColor;
-#endif
-#endif
+float computeRoughnessFromGlossiness(float glossiness) {
+    return 1.0 - glossiness;
+}
 
-#if defined(SHADING_MODEL_SPECULAR_GLOSSINESS)
-    vec3  specularColor;
-    float glossiness;
-#endif
+float perceptualRoughnessToRoughness(float perceptualRoughness) {
+    return perceptualRoughness * perceptualRoughness;
+}
 
-#if defined(MATERIAL_HAS_NORMAL)
-    vec3  normal;
-#endif
-#if defined(MATERIAL_HAS_CLEAR_COAT) && defined(MATERIAL_HAS_CLEAR_COAT_NORMAL)
-    vec3  clearCoatNormal;
-#endif
+float roughnessToPerceptualRoughness(float roughness) {
+    return sqrt(roughness);
+}
 
-#if defined(MATERIAL_HAS_POST_LIGHTING_COLOR)
-    vec4  postLightingColor;
-#endif
-};
+float iorToF0(float transmittedIor, float incidentIor) {
+    return sq((transmittedIor - incidentIor) / (transmittedIor + incidentIor));
+}
 
-void initMaterial(out MaterialInputs material) {
-    material.baseColor = vec4(1.0);
-#if !defined(SHADING_MODEL_UNLIT)
-#if !defined(SHADING_MODEL_SPECULAR_GLOSSINESS)
-    material.roughness = 1.0;
-#endif
-#if !defined(SHADING_MODEL_CLOTH) && !defined(SHADING_MODEL_SPECULAR_GLOSSINESS)
-    material.metallic = 0.0;
-    material.reflectance = 0.5;
-#endif
-    material.ambientOcclusion = 1.0;
-#endif
-    material.emissive = vec4(0.0);
+float f0ToIor(float f0) {
+    float r = sqrt(f0);
+    return (1.0 + r) / (1.0 - r);
+}
 
-#if defined(MATERIAL_HAS_CLEAR_COAT)
-    material.clearCoat = 1.0;
-    material.clearCoatRoughness = 0.0;
-#endif
-
-#if defined(MATERIAL_HAS_ANISOTROPY)
-    material.anisotropy = 0.0;
-    material.anisotropyDirection = vec3(1.0, 0.0, 0.0);
-#endif
-
-#if defined(SHADING_MODEL_SUBSURFACE)
-    material.thickness = 0.5;
-    material.subsurfacePower = 12.234;
-    material.subsurfaceColor = vec3(1.0);
-#endif
-
-#if defined(SHADING_MODEL_CLOTH)
-    material.sheenColor = sqrt(material.baseColor.rgb);
-#if defined(MATERIAL_HAS_SUBSURFACE_COLOR)
-    material.subsurfaceColor = vec3(0.0);
-#endif
-#endif
-
-#if defined(SHADING_MODEL_SPECULAR_GLOSSINESS)
-    material.glossiness = 0.0;
-    material.specularColor = vec3(0.0);
-#endif
-
-#if defined(MATERIAL_HAS_NORMAL)
-    material.normal = vec3(0.0, 0.0, 1.0);
-#endif
-#if defined(MATERIAL_HAS_CLEAR_COAT) && defined(MATERIAL_HAS_CLEAR_COAT_NORMAL)
-    material.clearCoatNormal = vec3(0.0, 0.0, 1.0);
-#endif
-
-#if defined(MATERIAL_HAS_POST_LIGHTING_COLOR)
-    material.postLightingColor = vec4(0.0);
+vec3 f0ClearCoatToSurface(const vec3 f0) {
+    // Approximation of iorTof0(f0ToIor(f0), 1.5)
+    // This assumes that the clear coat layer has an IOR of 1.5
+#if defined(TARGET_MOBILE)
+    return saturate(f0 * (f0 * 0.526868 + 0.529324) - 0.0482256);
+#else
+    return saturate(f0 * (f0 * (0.941892 - 0.263008 * f0) + 0.346479) - 0.0285998);
 #endif
 }
diff --git a/shaders/src/common_shading.fs b/shaders/src/common_shading.fs
new file mode 100644
index 0000000000..18823854dd
--- /dev/null
+++ b/shaders/src/common_shading.fs
@@ -0,0 +1,12 @@
+// These variables should be in a struct but some GPU drivers ignore the
+// precision qualifier on individual struct members
+highp mat3  shading_tangentToWorld;   // TBN matrix
+highp vec3  shading_position;         // position of the fragment in world space
+      vec3  shading_view;             // normalized vector from the fragment to the eye
+      vec3  shading_normal;           // normalized normal, in world space
+      vec3  shading_reflected;        // reflection of view about normal
+      float shading_NoV;              // dot(normal, view), always strictly >= MIN_N_DOT_V
+
+#if defined(MATERIAL_HAS_CLEAR_COAT)
+      vec3  shading_clearCoatNormal;  // normalized clear coat layer normal, in world space
+#endif
diff --git a/shaders/src/getters.fs b/shaders/src/getters.fs
index d9169fca1b..71496f663c 100644
--- a/shaders/src/getters.fs
+++ b/shaders/src/getters.fs
@@ -1,7 +1,3 @@
-//------------------------------------------------------------------------------
-// Input access
-//------------------------------------------------------------------------------
-
 #if defined(HAS_ATTRIBUTE_COLOR)
 /** @public-api */
 vec4 getColor() {
@@ -23,15 +19,51 @@ vec2 getUV1() {
 }
 #endif
 
-#if defined(HAS_SHADOWING) && defined(HAS_DIRECTIONAL_LIGHTING)
-highp vec3 getLightSpacePosition() {
-    return vertex_lightSpacePosition.xyz * (1.0 / vertex_lightSpacePosition.w);
+#if defined(BLEND_MODE_MASKED)
+/** @public-api */
+float getMaskThreshold() {
+    return materialParams._maskThreshold;
 }
 #endif
 
-#if defined(BLEND_MODE_MASKED)
-float getMaskThreshold() {
-    return materialParams._maskThreshold;
+/** @public-api */
+highp mat3 getWorldTangentFrame() {
+    return shading_tangentToWorld;
+}
+
+/** @public-api */
+highp vec3 getWorldPosition() {
+    return shading_position;
+}
+
+/** @public-api */
+vec3 getWorldViewVector() {
+    return shading_view;
+}
+
+/** @public-api */
+vec3 getWorldNormalVector() {
+    return shading_normal;
+}
+
+/** @public-api */
+vec3 getWorldGeometricNormalVector() {
+    return shading_tangentToWorld[2];
+}
+
+/** @public-api */
+vec3 getWorldReflectedVector() {
+    return shading_reflected;
+}
+
+/** @public-api */
+float getNdotV() {
+    return shading_NoV;
+}
+
+#if defined(HAS_SHADOWING) && defined(HAS_DIRECTIONAL_LIGHTING)
+highp vec3 getLightSpacePosition() {
+    return vertex_lightSpacePosition.xyz * (1.0 / vertex_lightSpacePosition.w);
 }
 #endif
 
diff --git a/shaders/src/inputs.fs b/shaders/src/inputs.fs
index a247c05755..38c7f9068a 100644
--- a/shaders/src/inputs.fs
+++ b/shaders/src/inputs.fs
@@ -12,9 +12,6 @@ LAYOUT_LOCATION(5) SHADING_INTERPOLATION in mediump vec3 vertex_worldNormal;
 LAYOUT_LOCATION(6) SHADING_INTERPOLATION in mediump vec3 vertex_worldTangent;
 LAYOUT_LOCATION(7) SHADING_INTERPOLATION in mediump vec3 vertex_worldBitangent;
 #endif
-#if defined(GEOMETRIC_SPECULAR_AA_NORMAL)
-LAYOUT_LOCATION(8) SHADING_INTERPOLATION centroid in highp vec3 vertex_worldNormalCentroid;
-#endif
 #endif
 
 #if defined(HAS_ATTRIBUTE_COLOR)
diff --git a/shaders/src/inputs.vs b/shaders/src/inputs.vs
index db4f677b17..bec1fd9034 100644
--- a/shaders/src/inputs.vs
+++ b/shaders/src/inputs.vs
@@ -31,9 +31,6 @@ LAYOUT_LOCATION(5) SHADING_INTERPOLATION out mediump vec3 vertex_worldNormal;
 LAYOUT_LOCATION(6) SHADING_INTERPOLATION out mediump vec3 vertex_worldTangent;
 LAYOUT_LOCATION(7) SHADING_INTERPOLATION out mediump vec3 vertex_worldBitangent;
 #endif
-#if defined(GEOMETRIC_SPECULAR_AA_NORMAL)
-LAYOUT_LOCATION(8) SHADING_INTERPOLATION centroid out vec3 vertex_worldNormalCentroid;
-#endif
 #endif
 
 #if defined(HAS_ATTRIBUTE_COLOR)
diff --git a/shaders/src/main.fs b/shaders/src/main.fs
index 2b208e9611..f24dbce8f4 100644
--- a/shaders/src/main.fs
+++ b/shaders/src/main.fs
@@ -15,7 +15,7 @@ void main() {
     // Computes global variables we need to evaluate material and lighting
     computeShadingParams();
 
-    // Initialize the inputs to sensible default values, see common_material.fs
+    // Initialize the inputs to sensible default values, see material_inputs.fs
     MaterialInputs inputs;
     initMaterial(inputs);
 
diff --git a/shaders/src/main.vs b/shaders/src/main.vs
index 6d2e8af6d1..64c4c1d45b 100644
--- a/shaders/src/main.vs
+++ b/shaders/src/main.vs
@@ -1,5 +1,5 @@
 void main() {
-    // Initialize the inputs to sensible default values, see common_material.vs
+    // Initialize the inputs to sensible default values, see material_inputs.vs
     MaterialVertexInputs material;
     initMaterialVertex(material);
 
@@ -35,11 +35,6 @@ void main() {
             skinNormal(material.worldNormal, mesh_bone_indices, mesh_bone_weights);
         #endif
     #endif // MATERIAL_HAS_ANISOTROPY || MATERIAL_HAS_NORMAL
-
-#ifdef GEOMETRIC_SPECULAR_AA_NORMAL
-    vertex_worldNormalCentroid = material.worldNormal;
-#endif // GEOMETRIC_SPECULAR_AA_NORMAL
-
 #endif // HAS_ATTRIBUTE_TANGENTS
 
     // Invoke user code
diff --git a/shaders/src/material_inputs.fs b/shaders/src/material_inputs.fs
new file mode 100644
index 0000000000..f34bd9c95f
--- /dev/null
+++ b/shaders/src/material_inputs.fs
@@ -0,0 +1,114 @@
+// Decide if we can skip lighting when dot(n, l) <= 0.0
+#if defined(SHADING_MODEL_CLOTH)
+#if !defined(MATERIAL_HAS_SUBSURFACE_COLOR)
+    #define MATERIAL_CAN_SKIP_LIGHTING
+#endif
+#elif defined(SHADING_MODEL_SUBSURFACE)
+    // Cannot skip lighting
+#else
+    #define MATERIAL_CAN_SKIP_LIGHTING
+#endif
+
+struct MaterialInputs {
+    vec4  baseColor;
+#if !defined(SHADING_MODEL_UNLIT)
+#if !defined(SHADING_MODEL_SPECULAR_GLOSSINESS)
+    float roughness;
+#endif
+#if !defined(SHADING_MODEL_CLOTH) && !defined(SHADING_MODEL_SPECULAR_GLOSSINESS)
+    float metallic;
+    float reflectance;
+#endif
+    float ambientOcclusion;
+#endif
+    vec4  emissive;
+
+    float clearCoat;
+    float clearCoatRoughness;
+
+    float anisotropy;
+    vec3  anisotropyDirection;
+
+#if defined(SHADING_MODEL_SUBSURFACE)
+    float thickness;
+    float subsurfacePower;
+    vec3  subsurfaceColor;
+#endif
+
+#if defined(SHADING_MODEL_CLOTH)
+    vec3  sheenColor;
+#if defined(MATERIAL_HAS_SUBSURFACE_COLOR)
+    vec3  subsurfaceColor;
+#endif
+#endif
+
+#if defined(SHADING_MODEL_SPECULAR_GLOSSINESS)
+    vec3  specularColor;
+    float glossiness;
+#endif
+
+#if defined(MATERIAL_HAS_NORMAL)
+    vec3  normal;
+#endif
+#if defined(MATERIAL_HAS_CLEAR_COAT) && defined(MATERIAL_HAS_CLEAR_COAT_NORMAL)
+    vec3  clearCoatNormal;
+#endif
+
+#if defined(MATERIAL_HAS_POST_LIGHTING_COLOR)
+    vec4  postLightingColor;
+#endif
+};
+
+void initMaterial(out MaterialInputs material) {
+    material.baseColor = vec4(1.0);
+#if !defined(SHADING_MODEL_UNLIT)
+#if !defined(SHADING_MODEL_SPECULAR_GLOSSINESS)
+    material.roughness = 1.0;
+#endif
+#if !defined(SHADING_MODEL_CLOTH) && !defined(SHADING_MODEL_SPECULAR_GLOSSINESS)
+    material.metallic = 0.0;
+    material.reflectance = 0.5;
+#endif
+    material.ambientOcclusion = 1.0;
+#endif
+    material.emissive = vec4(0.0);
+
+#if defined(MATERIAL_HAS_CLEAR_COAT)
+    material.clearCoat = 1.0;
+    material.clearCoatRoughness = 0.0;
+#endif
+
+#if defined(MATERIAL_HAS_ANISOTROPY)
+    material.anisotropy = 0.0;
+    material.anisotropyDirection = vec3(1.0, 0.0, 0.0);
+#endif
+
+#if defined(SHADING_MODEL_SUBSURFACE)
+    material.thickness = 0.5;
+    material.subsurfacePower = 12.234;
+    material.subsurfaceColor = vec3(1.0);
+#endif
+
+#if defined(SHADING_MODEL_CLOTH)
+    material.sheenColor = sqrt(material.baseColor.rgb);
+#if defined(MATERIAL_HAS_SUBSURFACE_COLOR)
+    material.subsurfaceColor = vec3(0.0);
+#endif
+#endif
+
+#if defined(SHADING_MODEL_SPECULAR_GLOSSINESS)
+    material.glossiness = 0.0;
+    material.specularColor = vec3(0.0);
+#endif
+
+#if defined(MATERIAL_HAS_NORMAL)
+    material.normal = vec3(0.0, 0.0, 1.0);
+#endif
+#if defined(MATERIAL_HAS_CLEAR_COAT) && defined(MATERIAL_HAS_CLEAR_COAT_NORMAL)
+    material.clearCoatNormal = vec3(0.0, 0.0, 1.0);
+#endif
+
+#if defined(MATERIAL_HAS_POST_LIGHTING_COLOR)
+    material.postLightingColor = vec4(0.0);
+#endif
+}
diff --git a/shaders/src/common_material.vs b/shaders/src/material_inputs.vs
similarity index 100%
rename from shaders/src/common_material.vs
rename to shaders/src/material_inputs.vs
diff --git a/shaders/src/shading_lit.fs b/shaders/src/shading_lit.fs
index bda7a5a182..54642d992a 100644
--- a/shaders/src/shading_lit.fs
+++ b/shaders/src/shading_lit.fs
@@ -26,15 +26,31 @@ void applyAlphaMask(inout vec4 baseColor) {
 #endif
 }
 
-float geometricSpecularAntiAliasing(const vec3 n) {
-    // Increase the roughness based on the curvature of the geometry to reduce
-    // shading aliasing. The curvature is approximated using the derivatives
-    // of the geometric normal
-    vec3 ndFdx = dFdx(n);
-    vec3 ndFdy = dFdy(n);
-    float geometricRoughness = pow(saturate(max(dot(ndFdx, ndFdx), dot(ndFdy, ndFdy))), 0.333);
-    return geometricRoughness;
+#if defined(GEOMETRIC_SPECULAR_AA)
+float normalFiltering(float perceptualRoughness, const vec3 worldNormal) {
+    // Kaplanyan 2016, "Stable specular highlights"
+    // Tokuyoshi 2017, "Error Reduction and Simplification for Shading Anti-Aliasing"
+    // Tokuyoshi and Kaplanyan 2019, "Improved Geometric Specular Antialiasing"
+
+    // This implementation is meant for deferred rendering in the original paper but
+    // we use it in forward rendering as well (as discussed in Tokuyoshi and Kaplanyan
+    // 2019). The main reason is that the forward version requires an expensive transform
+    // of the half vector by the tangent frame for every light. This is therefore an
+    // approximation but it works well enough for our needs and provides an improvement
+    // over our original implementation based on Vlachos 2015, "Advanced VR Rendering".
+
+    vec3 du = dFdx(worldNormal);
+    vec3 dv = dFdy(worldNormal);
+
+    float variance = materialParams._specularAntiAliasingVariance * (dot(du, du) + dot(dv, dv));
+
+    float roughness = perceptualRoughnessToRoughness(perceptualRoughness);
+    float kernelRoughness = min(2.0 * variance, materialParams._specularAntiAliasingThreshold);
+    float squareRoughness = saturate(roughness * roughness + kernelRoughness);
+
+    return roughnessToPerceptualRoughness(sqrt(squareRoughness));
 }
+#endif
 
 void getCommonPixelParams(const MaterialInputs material, inout PixelParams pixel) {
     vec4 baseColor = material.baseColor;
@@ -79,6 +95,11 @@ void getClearCoatPixelParams(const MaterialInputs material, inout PixelParams pi
     clearCoatPerceptualRoughness = mix(MIN_PERCEPTUAL_ROUGHNESS,
             MAX_CLEAR_COAT_PERCEPTUAL_ROUGHNESS, clearCoatPerceptualRoughness);
 
+#if defined(GEOMETRIC_SPECULAR_AA)
+    clearCoatPerceptualRoughness =
+            normalFiltering(clearCoatPerceptualRoughness, getWorldGeometricNormalVector());
+#endif
+
     pixel.clearCoatPerceptualRoughness = clearCoatPerceptualRoughness;
     pixel.clearCoatRoughness = perceptualRoughnessToRoughness(clearCoatPerceptualRoughness);
 
@@ -102,13 +123,8 @@ void getRoughnessPixelParams(const MaterialInputs material, inout PixelParams pi
     // Clamp the roughness to a minimum value to avoid divisions by 0 during lighting
     perceptualRoughness = clamp(perceptualRoughness, MIN_PERCEPTUAL_ROUGHNESS, 1.0);
 
-#if defined(GEOMETRIC_SPECULAR_AA_ROUGHNESS)
-    float geometricRoughness = geometricSpecularAntiAliasing(shading_tangentToWorld[2]);
-    perceptualRoughness = max(perceptualRoughness, geometricRoughness);
-#if defined(MATERIAL_HAS_CLEAR_COAT)
-    pixel.clearCoatPerceptualRoughness = max(pixel.clearCoatPerceptualRoughness, geometricRoughness);
-    pixel.clearCoatRoughness = perceptualRoughnessToRoughness(pixel.clearCoatPerceptualRoughness);
-#endif
+#if defined(GEOMETRIC_SPECULAR_AA)
+    perceptualRoughness = normalFiltering(perceptualRoughness, getWorldGeometricNormalVector());
 #endif
 
 #if defined(MATERIAL_HAS_CLEAR_COAT) && defined(MATERIAL_HAS_CLEAR_COAT_ROUGHNESS)
@@ -136,7 +152,7 @@ void getAnisotropyPixelParams(const MaterialInputs material, inout PixelParams p
     vec3 direction = material.anisotropyDirection;
     pixel.anisotropy = material.anisotropy;
     pixel.anisotropicT = normalize(shading_tangentToWorld * direction);
-    pixel.anisotropicB = normalize(cross(shading_tangentToWorld[2], pixel.anisotropicT));
+    pixel.anisotropicB = normalize(cross(getWorldGeometricNormalVector(), pixel.anisotropicT));
 #endif
 }
 
diff --git a/shaders/src/shading_parameters.fs b/shaders/src/shading_parameters.fs
index 688d60ac98..521a44d66d 100644
--- a/shaders/src/shading_parameters.fs
+++ b/shaders/src/shading_parameters.fs
@@ -8,14 +8,7 @@
  */
 void computeShadingParams() {
 #if defined(HAS_ATTRIBUTE_TANGENTS)
-#if defined(GEOMETRIC_SPECULAR_AA_NORMAL)
-    // Pick either the regular interpolated normal or the centroid interpolated
-    // normal to reduce shading aliasing
-    highp vec3 n = dot(vertex_worldNormal, vertex_worldNormal) >= 1.01 ?
-            vertex_worldNormalCentroid : vertex_worldNormal;
-#else
     highp vec3 n = vertex_worldNormal;
-#endif
 
 #if defined(MATERIAL_HAS_DOUBLE_SIDED_CAPABILITY)
     if (isDoubleSided()) {
@@ -50,7 +43,7 @@ void prepareMaterial(const MaterialInputs material) {
 #if defined(MATERIAL_HAS_NORMAL)
     shading_normal = normalize(shading_tangentToWorld * material.normal);
 #else
-    shading_normal = shading_tangentToWorld[2];
+    shading_normal = getWorldGeometricNormalVector();
 #endif
     shading_NoV = clampNoV(dot(shading_normal, shading_view));
     shading_reflected = reflect(-shading_view, shading_normal);
@@ -59,7 +52,7 @@ void prepareMaterial(const MaterialInputs material) {
 #if defined(MATERIAL_HAS_CLEAR_COAT_NORMAL)
     shading_clearCoatNormal = normalize(shading_tangentToWorld * material.clearCoatNormal);
 #else
-    shading_clearCoatNormal = shading_tangentToWorld[2];
+    shading_clearCoatNormal = getWorldGeometricNormalVector();
 #endif
 #endif
 #endif
diff --git a/tools/matc/src/matc/ParametersProcessor.cpp b/tools/matc/src/matc/ParametersProcessor.cpp
index 4308bb900d..d617e2dda5 100644
--- a/tools/matc/src/matc/ParametersProcessor.cpp
+++ b/tools/matc/src/matc/ParametersProcessor.cpp
@@ -385,13 +385,18 @@ static bool processShadowMultiplier(MaterialBuilder& builder, const JsonishValue
     return true;
 }
 
-static bool processCurvatureToRoughness(MaterialBuilder& builder, const JsonishValue& value) {
-    builder.curvatureToRoughness(value.toJsonBool()->getBool());
+static bool processSpecularAntiAliasing(MaterialBuilder& builder, const JsonishValue& value) {
+    builder.specularAntiAliasing(value.toJsonBool()->getBool());
     return true;
 }
 
-static bool processLimitOverInterpolation(MaterialBuilder& builder, const JsonishValue& value) {
-    builder.limitOverInterpolation(value.toJsonBool()->getBool());
+static bool processSpecularAntiAliasingVariance(MaterialBuilder& builder, const JsonishValue& value) {
+    builder.specularAntiAliasingVariance(value.toJsonNumber()->getFloat());
+    return true;
+}
+
+static bool processSpecularAntiAliasingThreshold(MaterialBuilder& builder, const JsonishValue& value) {
+    builder.specularAntiAliasingThreshold(value.toJsonNumber()->getFloat());
     return true;
 }
 
@@ -471,30 +476,31 @@ static bool processVariantFilter(MaterialBuilder& builder, const JsonishValue& v
 
 ParametersProcessor::ParametersProcessor() {
     using Type = JsonishValue::Type;
-    mParameters["name"]                        = { &processName, Type::STRING };
-    mParameters["interpolation"]               = { &processInterpolation, Type::STRING };
-    mParameters["parameters"]                  = { &processParameters, Type::ARRAY };
-    mParameters["variables"]                   = { &processVariables, Type::ARRAY };
-    mParameters["requires"]                    = { &processRequires, Type::ARRAY };
-    mParameters["blending"]                    = { &processBlending, Type::STRING };
-    mParameters["postLightingBlending"]        = { &processPostLightingBlending, Type::STRING };
-    mParameters["vertexDomain"]                = { &processVertexDomain, Type::STRING };
-    mParameters["culling"]                     = { &processCulling, Type::STRING };
-    mParameters["colorWrite"]                  = { &processColorWrite, Type::BOOL };
-    mParameters["depthWrite"]                  = { &processDepthWrite, Type::BOOL };
-    mParameters["depthCulling"]                = { &processDepthCull, Type::BOOL };
-    mParameters["doubleSided"]                 = { &processDoubleSided, Type::BOOL };
-    mParameters["transparency"]                = { &processTransparencyMode, Type::STRING };
-    mParameters["maskThreshold"]               = { &processMaskThreshold, Type::NUMBER };
-    mParameters["shadowMultiplier"]            = { &processShadowMultiplier, Type::BOOL };
-    mParameters["shadingModel"]                = { &processShading, Type::STRING };
-    mParameters["variantFilter"]               = { &processVariantFilter, Type::ARRAY };
-    mParameters["curvatureToRoughness"]        = { &processCurvatureToRoughness, Type::BOOL };
-    mParameters["limitOverInterpolation"]      = { &processLimitOverInterpolation, Type::BOOL };
-    mParameters["clearCoatIorChange"]          = { &processClearCoatIorChange, Type::BOOL };
-    mParameters["flipUV"]                      = { &processFlipUV, Type::BOOL };
-    mParameters["multiBounceAmbientOcclusion"] = { &processMultiBounceAO, Type::BOOL };
-    mParameters["specularAmbientOcclusion"]    = { &processSpecularAmbientOcclusion, Type::BOOL };
+    mParameters["name"]                          = { &processName, Type::STRING };
+    mParameters["interpolation"]                 = { &processInterpolation, Type::STRING };
+    mParameters["parameters"]                    = { &processParameters, Type::ARRAY };
+    mParameters["variables"]                     = { &processVariables, Type::ARRAY };
+    mParameters["requires"]                      = { &processRequires, Type::ARRAY };
+    mParameters["blending"]                      = { &processBlending, Type::STRING };
+    mParameters["postLightingBlending"]          = { &processPostLightingBlending, Type::STRING };
+    mParameters["vertexDomain"]                  = { &processVertexDomain, Type::STRING };
+    mParameters["culling"]                       = { &processCulling, Type::STRING };
+    mParameters["colorWrite"]                    = { &processColorWrite, Type::BOOL };
+    mParameters["depthWrite"]                    = { &processDepthWrite, Type::BOOL };
+    mParameters["depthCulling"]                  = { &processDepthCull, Type::BOOL };
+    mParameters["doubleSided"]                   = { &processDoubleSided, Type::BOOL };
+    mParameters["transparency"]                  = { &processTransparencyMode, Type::STRING };
+    mParameters["maskThreshold"]                 = { &processMaskThreshold, Type::NUMBER };
+    mParameters["shadowMultiplier"]              = { &processShadowMultiplier, Type::BOOL };
+    mParameters["shadingModel"]                  = { &processShading, Type::STRING };
+    mParameters["variantFilter"]                 = { &processVariantFilter, Type::ARRAY };
+    mParameters["specularAntiAliasing"]          = { &processSpecularAntiAliasing, Type::BOOL };
+    mParameters["specularAntiAliasingVariance"]  = { &processSpecularAntiAliasingVariance, Type::NUMBER };
+    mParameters["specularAntiAliasingThreshold"] = { &processSpecularAntiAliasingThreshold, Type::NUMBER };
+    mParameters["clearCoatIorChange"]            = { &processClearCoatIorChange, Type::BOOL };
+    mParameters["flipUV"]                        = { &processFlipUV, Type::BOOL };
+    mParameters["multiBounceAmbientOcclusion"]   = { &processMultiBounceAO, Type::BOOL };
+    mParameters["specularAmbientOcclusion"]      = { &processSpecularAmbientOcclusion, Type::BOOL };
 }
 
 bool ParametersProcessor::process(MaterialBuilder& builder, const JsonishObject& jsonObject) {
diff --git a/tools/matinfo/src/main.cpp b/tools/matinfo/src/main.cpp
index 6df33dcc0f..1eb6f73cf6 100644
--- a/tools/matinfo/src/main.cpp
+++ b/tools/matinfo/src/main.cpp
@@ -449,8 +449,9 @@ static bool printMaterial(const ChunkContainer& container) {
     printChunk<Interpolation, uint8_t>(container, filamat::MaterialInterpolation,
             "Interpolation: ");
     printChunk<bool, bool>(container, filamat::MaterialShadowMultiplier, "Shadow multiply: ");
-    printChunk<bool, bool>(container, filamat::MaterialCurvatureToRoughness, "Curvature to roughness: ");
-    printChunk<bool, bool>(container, filamat::MaterialLimitOverInterpolation, "Limit interpolation: ");
+    printChunk<bool, bool>(container, filamat::MaterialSpecularAntiAliasing, "Specular anti-aliasing: ");
+    printFloatChunk(container, filamat::MaterialSpecularAntiAliasingVariance, "    Variance: ");
+    printFloatChunk(container, filamat::MaterialSpecularAntiAliasingThreshold, "    Threshold: ");
     printChunk<bool, bool>(container, filamat::MaterialClearCoatIorChange, "Clear coat IOR change: ");
 
     std::cout << std::endl;
@@ -462,10 +463,8 @@ static bool printMaterial(const ChunkContainer& container) {
     printChunk<bool, bool>(container, filamat::MaterialDepthWrite, "Depth write: ");
     printChunk<bool, bool>(container, filamat::MaterialDepthTest, "Depth test: ");
     printChunk<bool, bool>(container, filamat::MaterialDoubleSided, "Double sided: ");
-    printChunk<CullingMode, uint8_t>(container, filamat::MaterialCullingMode,
-            "Culling: ");
-    printChunk<TransparencyMode, uint8_t>(container, filamat::MaterialTransparencyMode,
-            "Transparency: ");
+    printChunk<CullingMode, uint8_t>(container, filamat::MaterialCullingMode, "Culling: ");
+    printChunk<TransparencyMode, uint8_t>(container, filamat::MaterialTransparencyMode, "Transparency: ");
 
     std::cout << std::endl;