Allow for different transform matrices for clearcoat texture and textureRoughness

src/Materials/PBR/pbrBaseMaterial.ts

@@ -223,6 +223,7 @@ export class PBRMaterialDefines extends MaterialDefines
     public CLEARCOAT_TEXTURE = false;
     public CLEARCOAT_TEXTURE_ROUGHNESS = false;
     public CLEARCOAT_TEXTUREDIRECTUV = 0;
+    public CLEARCOAT_TEXTURE_ROUGHNESSDIRECTUV = 0;
     public CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE = false;
     public CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL = false;
     public CLEARCOAT_BUMP = false;
@@ -2006,7 +2007,7 @@ export abstract class PBRBaseMaterial extends PushMaterial {
 
             this.detailMap.bindForSubMesh(ubo, scene, this.isFrozen);
             this.subSurface.bindForSubMesh(ubo, scene, engine, this.isFrozen, defines.LODBASEDMICROSFURACE, this.realTimeFiltering);
-            this.clearCoat.bindForSubMesh(ubo, scene, engine, this._disableBumpMap, this.isFrozen, this._invertNormalMapX, this._invertNormalMapY);
+            this.clearCoat.bindForSubMesh(ubo, scene, engine, this._disableBumpMap, this.isFrozen, this._invertNormalMapX, this._invertNormalMapY, subMesh);
             this.anisotropy.bindForSubMesh(ubo, scene, this.isFrozen);
             this.sheen.bindForSubMesh(ubo, scene, this.isFrozen, subMesh);
 

src/Materials/PBR/pbrClearCoatConfiguration.ts

@@ -7,6 +7,7 @@ import { UniformBuffer } from "../../Materials/uniformBuffer";
 import { MaterialHelper } from "../../Materials/materialHelper";
 import { IAnimatable } from '../../Animations/animatable.interface';
 import { EffectFallbacks } from '../effectFallbacks';
+import { SubMesh } from '../../Meshes/subMesh';
 
 declare type Engine = import("../../Engines/engine").Engine;
 declare type Scene = import("../../scene").Scene;
@@ -20,6 +21,7 @@ export interface IMaterialClearCoatDefines {
     CLEARCOAT_TEXTURE: boolean;
     CLEARCOAT_TEXTURE_ROUGHNESS: boolean;
     CLEARCOAT_TEXTUREDIRECTUV: number;
+    CLEARCOAT_TEXTURE_ROUGHNESSDIRECTUV: number;
     CLEARCOAT_BUMP: boolean;
     CLEARCOAT_BUMPDIRECTUV: number;
     CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE: boolean;
@@ -216,7 +218,7 @@ export class PBRClearCoatConfiguration {
         if (this._isEnabled) {
             defines.CLEARCOAT = true;
             defines.CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE = this._useRoughnessFromMainTexture;
-            defines.CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL = this._texture !== null && this._texture._texture === this._textureRoughness?._texture;
+            defines.CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL = this._texture !== null && this._texture._texture === this._textureRoughness?._texture && this._texture.checkTransformsAreIdentical(this._textureRoughness);
 
             if (defines._areTexturesDirty) {
                 if (scene.texturesEnabled) {
@@ -277,15 +279,24 @@ export class PBRClearCoatConfiguration {
      * @param isFrozen defines wether the material is frozen or not.
      * @param invertNormalMapX If sets to true, x component of normal map value will be inverted (x = 1.0 - x).
      * @param invertNormalMapY If sets to true, y component of normal map value will be inverted (y = 1.0 - y).
+     * @param subMesh the submesh to bind data for
      */
-    public bindForSubMesh(uniformBuffer: UniformBuffer, scene: Scene, engine: Engine, disableBumpMap: boolean, isFrozen: boolean, invertNormalMapX: boolean, invertNormalMapY: boolean): void {
+    public bindForSubMesh(uniformBuffer: UniformBuffer, scene: Scene, engine: Engine, disableBumpMap: boolean, isFrozen: boolean, invertNormalMapX: boolean, invertNormalMapY: boolean, subMesh?: SubMesh): void {
+        const defines = subMesh!._materialDefines as unknown as IMaterialClearCoatDefines;
+
+        const identicalTextures = defines.CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL;
+
         if (!uniformBuffer.useUbo || !isFrozen || !uniformBuffer.isSync) {
-            if ((this._texture || this._textureRoughness) && MaterialFlags.ClearCoatTextureEnabled) {
-                uniformBuffer.updateFloat4("vClearCoatInfos", this._texture?.coordinatesIndex ?? this._textureRoughness?.coordinatesIndex ?? 0, this._texture?.level ?? 0, 0 /* not used */, this._textureRoughness?.level ?? 0);
+            if (identicalTextures && MaterialFlags.ClearCoatTextureEnabled) {
+                uniformBuffer.updateFloat4("vClearCoatInfos", this._texture!.coordinatesIndex, this._texture!.level, -1, -1);
+                MaterialHelper.BindTextureMatrix(this._texture!, uniformBuffer, "clearCoat");
+            } else  if ((this._texture || this._textureRoughness) && MaterialFlags.ClearCoatTextureEnabled) {
+                uniformBuffer.updateFloat4("vClearCoatInfos", this._texture?.coordinatesIndex ?? 0, this._texture?.level ?? 0, this._textureRoughness?.coordinatesIndex ?? 0, this._textureRoughness?.level ?? 0);
                 if (this._texture) {
                     MaterialHelper.BindTextureMatrix(this._texture, uniformBuffer, "clearCoat");
-                } else if (this._textureRoughness) {
-                    MaterialHelper.BindTextureMatrix(this._textureRoughness, uniformBuffer, "clearCoat");
+                }
+                if (this._textureRoughness && !identicalTextures && !defines.CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE) {
+                    MaterialHelper.BindTextureMatrix(this._textureRoughness, uniformBuffer, "clearCoatRoughness");
                 }
             }
 
@@ -331,7 +342,7 @@ export class PBRClearCoatConfiguration {
                 uniformBuffer.setTexture("clearCoatSampler", this._texture);
             }
 
-            if (this._textureRoughness && (this._texture === null || this._texture._texture !== this._textureRoughness._texture) && MaterialFlags.ClearCoatTextureEnabled) {
+            if (this._textureRoughness && !identicalTextures && !defines.CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE && MaterialFlags.ClearCoatTextureEnabled) {
                 uniformBuffer.setTexture("clearCoatRoughnessSampler", this._textureRoughness);
             }
 
@@ -462,7 +473,7 @@ export class PBRClearCoatConfiguration {
     public static AddUniforms(uniforms: string[]): void {
         uniforms.push("vClearCoatTangentSpaceParams", "vClearCoatParams", "vClearCoatRefractionParams",
             "vClearCoatTintParams", "clearCoatColorAtDistance",
-            "clearCoatMatrix", "clearCoatBumpMatrix", "clearCoatTintMatrix",
+            "clearCoatMatrix", "clearCoatRoughnessMatrix", "clearCoatBumpMatrix", "clearCoatTintMatrix",
             "vClearCoatInfos", "vClearCoatBumpInfos", "vClearCoatTintInfos");
     }
 
@@ -483,6 +494,7 @@ export class PBRClearCoatConfiguration {
         uniformBuffer.addUniform("vClearCoatRefractionParams", 4);
         uniformBuffer.addUniform("vClearCoatInfos", 4);
         uniformBuffer.addUniform("clearCoatMatrix", 16);
+        uniformBuffer.addUniform("clearCoatRoughnessMatrix", 16);
         uniformBuffer.addUniform("vClearCoatBumpInfos", 2);
         uniformBuffer.addUniform("vClearCoatTangentSpaceParams", 2);
         uniformBuffer.addUniform("clearCoatBumpMatrix", 16);

src/Materials/PBR/pbrSheenConfiguration.ts

@@ -208,7 +208,7 @@ export class PBRSheenConfiguration {
         const identicalTextures = defines.SHEEN_TEXTURE_ROUGHNESS_IDENTICAL;
 
         if (!uniformBuffer.useUbo || !isFrozen || !uniformBuffer.isSync) {
-            if (identicalTextures) {
+            if (identicalTextures && MaterialFlags.SheenTextureEnabled) {
                 uniformBuffer.updateFloat4("vSheenInfos", this._texture!.coordinatesIndex, this._texture!.level, -1, -1);
                 MaterialHelper.BindTextureMatrix(this._texture!, uniformBuffer, "sheen");
             } else  if ((this._texture || this._textureRoughness) && MaterialFlags.SheenTextureEnabled) {

src/Shaders/ShadersInclude/pbrBlockClearcoat.fx

@@ -36,7 +36,7 @@ struct clearcoatOutParams
         const in vec3 geometricNormalW,
         const in vec3 viewDirectionW,
         const in vec2 vClearCoatParams,
-    #if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL)
+    #if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE)
         const in vec4 clearCoatMapRoughnessData,
     #endif
         const in vec3 specularEnvironmentR0,

src/Shaders/ShadersInclude/pbrFragmentDeclaration.fx

@@ -69,11 +69,18 @@ uniform mat4 view;
     uniform vec2 vClearCoatParams;
     uniform vec4 vClearCoatRefractionParams;
 
-    #ifdef CLEARCOAT_TEXTURE
+    #if defined(CLEARCOAT_TEXTURE) || defined(CLEARCOAT_TEXTURE_ROUGHNESS)
         uniform vec4 vClearCoatInfos;
+    #endif
+
+    #ifdef CLEARCOAT_TEXTURE
         uniform mat4 clearCoatMatrix;
     #endif
 
+    #ifdef CLEARCOAT_TEXTURE_ROUGHNESS
+        uniform mat4 clearCoatRoughnessMatrix;
+    #endif
+
     #ifdef CLEARCOAT_BUMP
         uniform vec2 vClearCoatBumpInfos;
         uniform vec2 vClearCoatTangentSpaceParams;

src/Shaders/ShadersInclude/pbrFragmentSamplersDeclaration.fx

@@ -87,7 +87,7 @@
 #endif
 
 #ifdef CLEARCOAT
-    #if defined(CLEARCOAT_TEXTURE) || defined(CLEARCOAT_TEXTURE_ROUGHNESS)
+    #if defined(CLEARCOAT_TEXTURE)
         #if CLEARCOAT_TEXTUREDIRECTUV == 1
             #define vClearCoatUV vMainUV1
         #elif CLEARCOAT_TEXTUREDIRECTUV == 2
@@ -97,6 +97,16 @@
         #endif
     #endif
 
+    #if defined(CLEARCOAT_TEXTURE_ROUGHNESS)
+        #if CLEARCOAT_TEXTURE_ROUGHNESSDIRECTUV == 1
+            #define vClearCoatRoughnessUV vMainUV1
+        #elif CLEARCOAT_TEXTURE_ROUGHNESSDIRECTUV == 2
+            #define vClearCoatRoughnessUV vMainUV2
+        #else
+            varying vec2 vClearCoatRoughnessUV;
+        #endif
+    #endif
+
     #ifdef CLEARCOAT_TEXTURE
         uniform sampler2D clearCoatSampler;
     #endif

src/Shaders/ShadersInclude/pbrUboDeclaration.fx

@@ -42,6 +42,7 @@ uniform Material
     uniform vec4 vClearCoatRefractionParams;
     uniform vec4 vClearCoatInfos;
     uniform mat4 clearCoatMatrix;
+    uniform mat4 clearCoatRoughnessMatrix;
     uniform vec2 vClearCoatBumpInfos;
     uniform vec2 vClearCoatTangentSpaceParams;
     uniform mat4 clearCoatBumpMatrix;

src/Shaders/ShadersInclude/pbrVertexDeclaration.fx

@@ -58,11 +58,18 @@ uniform float pointSize;
 
 // Clear Coat
 #ifdef CLEARCOAT
-    #ifdef CLEARCOAT_TEXTURE
+    #if defined(CLEARCOAT_TEXTURE) || defined(CLEARCOAT_TEXTURE_ROUGHNESS)
         uniform vec4 vClearCoatInfos;
+    #endif
+
+    #ifdef CLEARCOAT_TEXTURE
         uniform mat4 clearCoatMatrix;
     #endif
 
+    #ifdef CLEARCOAT_TEXTURE_ROUGHNESS
+        uniform mat4 clearCoatRoughnessMatrix;
+    #endif
+
     #ifdef CLEARCOAT_BUMP
         uniform vec2 vClearCoatBumpInfos;
         uniform mat4 clearCoatBumpMatrix;

src/Shaders/pbr.fragment.fx

@@ -347,8 +347,8 @@ void main(void) {
             vec2 clearCoatMapData = texture2D(clearCoatSampler, vClearCoatUV + uvOffset).rg * vClearCoatInfos.y;
         #endif
 
-        #if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL)
-            vec4 clearCoatMapRoughnessData = texture2D(clearCoatRoughnessSampler, vClearCoatUV + uvOffset) * vClearCoatInfos.w;
+        #if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE)
+            vec4 clearCoatMapRoughnessData = texture2D(clearCoatRoughnessSampler, vClearCoatRoughnessUV + uvOffset) * vClearCoatInfos.w;
         #endif
 
         #if defined(CLEARCOAT_TINT) && defined(CLEARCOAT_TINT_TEXTURE)
@@ -364,7 +364,7 @@ void main(void) {
             geometricNormalW,
             viewDirectionW,
             vClearCoatParams,
-            #if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL)
+            #if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE)
                 clearCoatMapRoughnessData,
             #endif
             specularEnvironmentR0,

src/Shaders/pbr.vertex.fx

@@ -79,10 +79,14 @@ varying vec2 vBumpUV;
 #endif
 
 #ifdef CLEARCOAT
-    #if (defined(CLEARCOAT_TEXTURE) || defined(CLEARCOAT_TEXTURE_ROUGHNESS)) && CLEARCOAT_TEXTUREDIRECTUV == 0 
+    #if defined(CLEARCOAT_TEXTURE) && CLEARCOAT_TEXTUREDIRECTUV == 0 
         varying vec2 vClearCoatUV;
     #endif
 
+    #if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && CLEARCOAT_TEXTURE_ROUGHNESSDIRECTUV == 0 
+        varying vec2 vClearCoatRoughnessUV;
+    #endif
+
     #if defined(CLEARCOAT_BUMP) && CLEARCOAT_BUMPDIRECTUV == 0 
         varying vec2 vClearCoatBumpUV;
     #endif
@@ -355,7 +359,7 @@ void main(void) {
 #endif
 
 #ifdef CLEARCOAT
-    #if (defined(CLEARCOAT_TEXTURE) || defined(CLEARCOAT_TEXTURE_ROUGHNESS)) && CLEARCOAT_TEXTUREDIRECTUV == 0 
+    #if defined(CLEARCOAT_TEXTURE) && CLEARCOAT_TEXTUREDIRECTUV == 0 
         if (vClearCoatInfos.x == 0.)
         {
             vClearCoatUV = vec2(clearCoatMatrix * vec4(uvUpdated, 1.0, 0.0));
@@ -366,6 +370,17 @@ void main(void) {
         }
     #endif
 
+    #if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && CLEARCOAT_TEXTURE_ROUGHNESSDIRECTUV == 0 
+        if (vClearCoatInfos.z == 0.)
+        {
+            vClearCoatRoughnessUV = vec2(clearCoatRoughnessMatrix * vec4(uvUpdated, 1.0, 0.0));
+        }
+        else
+        {
+            vClearCoatRoughnessUV = vec2(clearCoatRoughnessMatrix * vec4(uv2, 1.0, 0.0));
+        }
+    #endif
+
     #if defined(CLEARCOAT_BUMP) && CLEARCOAT_BUMPDIRECTUV == 0 
         if (vClearCoatBumpInfos.x == 0.)
         {