Fixes for vis tests

Author: Mike Bond

packages/dev/core/src/Materials/materialHelper.functions.ts

@@ -741,6 +741,7 @@ export function PrepareDefinesForLights(scene: Scene, mesh: AbstractMesh, define
  * @param realTimeFiltering Whether realtime filting of IBL texture is being used
  * @param realTimeFilteringQuality The quality of realtime filtering
  * @param forceSHInVertex Whether the SH are handled in the vertex shader
+ * @returns true if the defines were updated
  */
 export function PrepareDefinesForIBL(
     scene: Scene,
@@ -749,10 +750,10 @@ export function PrepareDefinesForIBL(
     realTimeFiltering: boolean = false,
     realTimeFilteringQuality: number = Constants.TEXTURE_FILTERING_QUALITY_LOW,
     forceSHInVertex: boolean = false
-) {
+): boolean {
     if (reflectionTexture && MaterialFlags.ReflectionTextureEnabled) {
         if (!reflectionTexture.isReadyOrNotBlocking()) {
-            return;
+            return false;
         }
         defines.REFLECTION = true;
         defines.GAMMAREFLECTION = reflectionTexture.gammaSpace;
@@ -864,6 +865,7 @@ export function PrepareDefinesForIBL(
         defines.RGBDREFLECTION = false;
         defines.LINEARSPECULARREFLECTION = false;
     }
+    return true;
 }
 
 /**

packages/dev/core/src/Materials/standardMaterial.ts

@@ -827,9 +827,16 @@ export class StandardMaterial extends StandardMaterialBase {
                 } else {
                     defines.OPACITY = false;
                 }
-                defines.ROUGHNESS = this._roughness > 0;
-                defines.REFLECTIONOVERALPHA = this._useReflectionOverAlpha;
-                PrepareDefinesForIBL(scene, this._reflectionTexture, defines);
+                if (this._reflectionTexture && StandardMaterial.ReflectionTextureEnabled) {
+                    defines.ROUGHNESS = this._roughness > 0;
+                    defines.REFLECTIONOVERALPHA = this._useReflectionOverAlpha;
+                } else {
+                    defines.ROUGHNESS = false;
+                    defines.REFLECTIONOVERALPHA = false;
+                }
+                if (!PrepareDefinesForIBL(scene, this._reflectionTexture, defines)) {
+                    return false;
+                }
 
                 if (this._emissiveTexture && StandardMaterial.EmissiveTextureEnabled) {
                     if (!this._emissiveTexture.isReadyOrNotBlocking()) {
@@ -1471,6 +1478,9 @@ export class StandardMaterial extends StandardMaterialBase {
                     }
 
                     BindIBLParameters(scene, defines, ubo, this._reflectionTexture, false, false, true);
+                    if (!this._reflectionTexture || !StandardMaterial.ReflectionTextureEnabled) {
+                        ubo.updateFloat2("vReflectionInfos", 0.0, this.roughness);
+                    }
 
                     if (this._emissiveTexture && StandardMaterial.EmissiveTextureEnabled) {
                         ubo.updateFloat2("vEmissiveInfos", this._emissiveTexture.coordinatesIndex, this._emissiveTexture.level);

packages/dev/loaders/src/glTF/2.0/Extensions/KHR_materials_transmission.ts

@@ -397,11 +397,14 @@ export class KHR_materials_transmission implements IGLTFLoaderExtension {
         if (!(babylonMaterial instanceof PBRMaterialClass)) {
             throw new Error(`${context}: Material type not supported`);
         }
+        if (useOpenPBR) {
+            return Promise.resolve();
+        }
 
         let transmissionWeight = 0.0;
         let transmissionWeightTexture: Nullable<BaseTexture> = null;
 
-        const promises = new Array<Promise<any>>();
+        let texturePromise = new Promise<Nullable<BaseTexture>>((resolve) => resolve(null));
         if (extension.transmissionFactor !== undefined) {
             transmissionWeight = extension.transmissionFactor;
         } else {
@@ -410,43 +413,40 @@ export class KHR_materials_transmission implements IGLTFLoaderExtension {
         if (extension.transmissionTexture) {
             (extension.transmissionTexture as ITextureInfo).nonColorData = true;
             // eslint-disable-next-line github/no-then
-            promises.push(
-                this._loader.loadTextureInfoAsync(`${context}/transmissionTexture`, extension.transmissionTexture, (texture: BaseTexture) => {
-                    texture.name = `${babylonMaterial.name} (Transmission)`;
-                    transmissionWeightTexture = texture;
-                })
-            );
+            texturePromise = this._loader.loadTextureInfoAsync(`${context}/transmissionTexture`, extension.transmissionTexture, (texture: BaseTexture) => {
+                texture.name = `${babylonMaterial.name} (Transmission)`;
+                transmissionWeightTexture = texture;
+            });
         }
 
-        // eslint-disable-next-line github/no-then
-        return Promise.all(promises).then(() => {
-            if (useOpenPBR) {
-                return;
-            }
-            const pbrMaterial = babylonMaterial as PBRMaterial;
+        const pbrMaterial = babylonMaterial as PBRMaterial;
 
-            // Enables "refraction" texture which represents transmitted light.
-            pbrMaterial.subSurface.isRefractionEnabled = transmissionWeight !== 0;
+        // Enables "refraction" texture which represents transmitted light.
+        pbrMaterial.subSurface.isRefractionEnabled = transmissionWeight !== 0;
 
-            // Since this extension models thin-surface transmission only, we must make IOR = 1.0
-            pbrMaterial.subSurface.volumeIndexOfRefraction = 1.0;
+        // Since this extension models thin-surface transmission only, we must make IOR = 1.0
+        pbrMaterial.subSurface.volumeIndexOfRefraction = 1.0;
 
-            // Albedo colour will tint transmission.
-            pbrMaterial.subSurface.useAlbedoToTintRefraction = true;
+        // Albedo colour will tint transmission.
+        pbrMaterial.subSurface.useAlbedoToTintRefraction = true;
 
-            pbrMaterial.subSurface.refractionIntensity = transmissionWeight;
+        pbrMaterial.subSurface.refractionIntensity = transmissionWeight;
 
-            if (transmissionWeight) {
-                const scene = pbrMaterial.getScene() as unknown as ITransmissionHelperHolder;
-                if (pbrMaterial.subSurface.refractionIntensity && !scene._transmissionHelper) {
-                    new TransmissionHelper({}, pbrMaterial.getScene());
-                } else if (pbrMaterial.subSurface.refractionIntensity && !scene._transmissionHelper?._isRenderTargetValid()) {
-                    // If the render target is not valid, recreate it.
-                    scene._transmissionHelper?._setupRenderTargets();
-                }
+        if (transmissionWeight) {
+            const scene = pbrMaterial.getScene() as unknown as ITransmissionHelperHolder;
+            if (pbrMaterial.subSurface.refractionIntensity && !scene._transmissionHelper) {
+                new TransmissionHelper({}, pbrMaterial.getScene());
+            } else if (pbrMaterial.subSurface.refractionIntensity && !scene._transmissionHelper?._isRenderTargetValid()) {
+                // If the render target is not valid, recreate it.
+                scene._transmissionHelper?._setupRenderTargets();
             }
-            pbrMaterial.subSurface.minimumThickness = 0.0;
-            pbrMaterial.subSurface.maximumThickness = 0.0;
+        }
+
+        pbrMaterial.subSurface.minimumThickness = 0.0;
+        pbrMaterial.subSurface.maximumThickness = 0.0;
+
+        // eslint-disable-next-line github/no-then
+        return texturePromise.then(() => {
             pbrMaterial.subSurface.refractionIntensityTexture = transmissionWeightTexture;
             pbrMaterial.subSurface.useGltfStyleTextures = true;
         });