@babylonjs/core 7.48.0 → 7.48.2

package/Misc/environmentTextureTools.js

@@ -9,8 +9,8 @@ import { Scene } from "../scene.js";
 import { PostProcess } from "../PostProcesses/postProcess.js";
 import { Logger } from "../Misc/logger.js";
 import { RGBDTextureTools } from "./rgbdTextureTools.js";
-import "../Materials/Textures/baseTexture.polynomial.js";
 import { DumpDataAsync } from "../Misc/dumpTools.js";
+import "../Materials/Textures/baseTexture.polynomial.js";
 const DefaultEnvironmentTextureImageType = "image/png";
 const CurrentVersion = 2;
 /**
@@ -39,9 +39,9 @@ export function GetEnvInfo(data) {
     }
     let manifest = JSON.parse(manifestString);
     manifest = normalizeEnvInfo(manifest);
+    // Extend the header with the position of the payload.
+    manifest.binaryDataPosition = pos;
     if (manifest.specular) {
-        // Extend the header with the position of the payload.
-        manifest.specular.specularDataPosition = pos;
         // Fallback to 0.8 exactly if lodGenerationScale is not defined for backward compatibility.
         manifest.specular.lodGenerationScale = manifest.specular.lodGenerationScale || 0.8;
     }
@@ -77,7 +77,6 @@ export async function CreateEnvTextureAsync(texture, options = {}) {
     if (!internalTexture) {
         return Promise.reject("The cube texture is invalid.");
     }
-    const imageType = options.imageType ?? DefaultEnvironmentTextureImageType;
     const engine = internalTexture.getEngine();
     if (texture.textureType !== 2 &&
         texture.textureType !== 1 &&
@@ -101,37 +100,26 @@ export async function CreateEnvTextureAsync(texture, options = {}) {
     const cubeWidth = internalTexture.width;
     const hostingScene = new Scene(engine);
     const specularTextures = {};
+    const diffuseTextures = {};
     // As we are going to readPixels the faces of the cube, make sure the drawing/update commands for the cube texture are fully sent to the GPU in case it is drawn for the first time in this very frame!
     engine.flushFramebuffer();
+    const imageType = options.imageType ?? DefaultEnvironmentTextureImageType;
     // Read and collect all mipmaps data from the cube.
     const mipmapsCount = ILog2(internalTexture.width);
     for (let i = 0; i <= mipmapsCount; i++) {
         const faceWidth = Math.pow(2, mipmapsCount - i);
         // All faces of the cube.
         for (let face = 0; face < 6; face++) {
-            let faceData = await texture.readPixels(face, i, undefined, false);
-            if (faceData && faceData.byteLength === faceData.length) {
-                const faceDataFloat = new Float32Array(faceData.byteLength * 4);
-                for (let i = 0; i < faceData.byteLength; i++) {
-                    faceDataFloat[i] = faceData[i] / 255;
-                    // Gamma to linear
-                    faceDataFloat[i] = Math.pow(faceDataFloat[i], 2.2);
-                }
-                faceData = faceDataFloat;
-            }
-            else if (faceData && texture.gammaSpace) {
-                const floatData = faceData;
-                for (let i = 0; i < floatData.length; i++) {
-                    // Gamma to linear
-                    floatData[i] = Math.pow(floatData[i], 2.2);
-                }
-            }
-            const tempTexture = engine.createRawTexture(faceData, faceWidth, faceWidth, 5, false, true, 1, null, textureType);
-            await RGBDTextureTools.EncodeTextureToRGBD(tempTexture, hostingScene, textureType);
-            const rgbdEncodedData = await engine._readTexturePixels(tempTexture, faceWidth, faceWidth);
-            const imageEncodedData = await DumpDataAsync(faceWidth, faceWidth, rgbdEncodedData, imageType, undefined, false, true, options.imageQuality);
-            specularTextures[i * 6 + face] = imageEncodedData;
-            tempTexture.dispose();
+            specularTextures[i * 6 + face] = await _getTextureEncodedData(hostingScene, texture, textureType, face, i, faceWidth, imageType, options.imageQuality);
+        }
+    }
+    // Read and collect all irradiance data from the cube.
+    const irradianceTexture = options.disableIrradianceTexture ? null : texture.irradianceTexture;
+    if (irradianceTexture) {
+        const faceWidth = irradianceTexture.getSize().width;
+        // All faces of the cube.
+        for (let face = 0; face < 6; face++) {
+            diffuseTextures[face] = await _getTextureEncodedData(hostingScene, irradianceTexture, textureType, face, 0, faceWidth, imageType, options.imageQuality);
         }
     }
     // We can delete the hosting scene keeping track of all the creation objects
@@ -163,6 +151,32 @@ export async function CreateEnvTextureAsync(texture, options = {}) {
             position += byteLength;
         }
     }
+    // Sets the irradiance image data information
+    if (irradianceTexture) {
+        info.irradiance = info.irradiance || {
+            x: [0, 0, 0],
+            xx: [0, 0, 0],
+            y: [0, 0, 0],
+            yy: [0, 0, 0],
+            z: [0, 0, 0],
+            zz: [0, 0, 0],
+            yz: [0, 0, 0],
+            zx: [0, 0, 0],
+            xy: [0, 0, 0],
+        };
+        info.irradiance.irradianceTexture = {
+            size: irradianceTexture.getSize().width,
+            faces: [],
+        };
+        for (let face = 0; face < 6; face++) {
+            const byteLength = diffuseTextures[face].byteLength;
+            info.irradiance.irradianceTexture.faces.push({
+                length: byteLength,
+                position: position,
+            });
+            position += byteLength;
+        }
+    }
     // Encode the JSON as an array buffer
     const infoString = JSON.stringify(info);
     const infoBuffer = new ArrayBuffer(infoString.length + 1);
@@ -185,7 +199,7 @@ export async function CreateEnvTextureAsync(texture, options = {}) {
     // Add the json info
     finalBufferView.set(new Uint8Array(infoBuffer), pos);
     pos += infoBuffer.byteLength;
-    // Finally inserts the texture data
+    // Finally inserts the radiance texture data
     for (let i = 0; i <= mipmapsCount; i++) {
         for (let face = 0; face < 6; face++) {
             const dataBuffer = specularTextures[i * 6 + face];
@@ -193,9 +207,47 @@ export async function CreateEnvTextureAsync(texture, options = {}) {
             pos += dataBuffer.byteLength;
         }
     }
+    // Finally inserts the irradiance texture data
+    if (irradianceTexture) {
+        for (let face = 0; face < 6; face++) {
+            const dataBuffer = diffuseTextures[face];
+            finalBufferView.set(new Uint8Array(dataBuffer), pos);
+            pos += dataBuffer.byteLength;
+        }
+    }
     // Voila
     return finalBuffer;
 }
+/**
+ * Get the texture encoded data from the current texture
+ * @internal
+ */
+async function _getTextureEncodedData(hostingScene, texture, textureType, face, i, size, imageType, imageQuality) {
+    let faceData = await texture.readPixels(face, i, undefined, false);
+    if (faceData && faceData.byteLength === faceData.length) {
+        const faceDataFloat = new Float32Array(faceData.byteLength * 4);
+        for (let i = 0; i < faceData.byteLength; i++) {
+            faceDataFloat[i] = faceData[i] / 255;
+            // Gamma to linear
+            faceDataFloat[i] = Math.pow(faceDataFloat[i], 2.2);
+        }
+        faceData = faceDataFloat;
+    }
+    else if (faceData && texture.gammaSpace) {
+        const floatData = faceData;
+        for (let i = 0; i < floatData.length; i++) {
+            // Gamma to linear
+            floatData[i] = Math.pow(floatData[i], 2.2);
+        }
+    }
+    const engine = hostingScene.getEngine();
+    const tempTexture = engine.createRawTexture(faceData, size, size, 5, false, true, 1, null, textureType);
+    await RGBDTextureTools.EncodeTextureToRGBD(tempTexture, hostingScene, textureType);
+    const rgbdEncodedData = await engine._readTexturePixels(tempTexture, size, size);
+    const imageEncodedData = await DumpDataAsync(size, size, rgbdEncodedData, imageType, undefined, false, true, imageQuality);
+    tempTexture.dispose();
+    return imageEncodedData;
+}
 /**
  * Creates a JSON representation of the spherical data.
  * @param texture defines the texture containing the polynomials
@@ -224,7 +276,7 @@ function _CreateEnvTextureIrradiance(texture) {
  * @param info parameters that determine what views will be created for accessing the underlying buffer
  * @returns the views described by info providing access to the underlying buffer
  */
-export function CreateImageDataArrayBufferViews(data, info) {
+export function CreateRadianceImageDataArrayBufferViews(data, info) {
     info = normalizeEnvInfo(info);
     const specularInfo = info.specular;
     // Double checks the enclosed info
@@ -238,7 +290,28 @@ export function CreateImageDataArrayBufferViews(data, info) {
         imageData[i] = new Array(6);
         for (let face = 0; face < 6; face++) {
             const imageInfo = specularInfo.mipmaps[i * 6 + face];
-            imageData[i][face] = new Uint8Array(data.buffer, data.byteOffset + specularInfo.specularDataPosition + imageInfo.position, imageInfo.length);
+            imageData[i][face] = new Uint8Array(data.buffer, data.byteOffset + info.binaryDataPosition + imageInfo.position, imageInfo.length);
+        }
+    }
+    return imageData;
+}
+/**
+ * Creates the ArrayBufferViews used for initializing environment texture image data.
+ * @param data the image data
+ * @param info parameters that determine what views will be created for accessing the underlying buffer
+ * @returns the views described by info providing access to the underlying buffer
+ */
+export function CreateIrradianceImageDataArrayBufferViews(data, info) {
+    info = normalizeEnvInfo(info);
+    const imageData = new Array(6);
+    const irradianceTexture = info.irradiance?.irradianceTexture;
+    if (irradianceTexture) {
+        if (irradianceTexture.faces.length !== 6) {
+            throw new Error(`Incorrect irradiance texture faces number "${irradianceTexture.faces.length}"`);
+        }
+        for (let face = 0; face < 6; face++) {
+            const imageInfo = irradianceTexture.faces[face];
+            imageData[face] = new Uint8Array(data.buffer, data.byteOffset + info.binaryDataPosition + imageInfo.position, imageInfo.length);
         }
     }
     return imageData;
@@ -255,11 +328,18 @@ export function UploadEnvLevelsAsync(texture, data, info) {
     const specularInfo = info.specular;
     if (!specularInfo) {
         // Nothing else parsed so far
-        return Promise.resolve();
+        return Promise.resolve([]);
     }
     texture._lodGenerationScale = specularInfo.lodGenerationScale;
-    const imageData = CreateImageDataArrayBufferViews(data, info);
-    return UploadLevelsAsync(texture, imageData, info.imageType);
+    const promises = [];
+    const radianceImageData = CreateRadianceImageDataArrayBufferViews(data, info);
+    promises.push(UploadRadianceLevelsAsync(texture, radianceImageData, info.imageType));
+    const irradianceTexture = info.irradiance?.irradianceTexture;
+    if (irradianceTexture) {
+        const irradianceImageData = CreateIrradianceImageDataArrayBufferViews(data, info);
+        promises.push(UploadIrradianceLevelsAsync(texture, irradianceImageData, irradianceTexture.size, info.imageType));
+    }
+    return Promise.all(promises);
 }
 function _OnImageReadyAsync(image, engine, expandTexture, rgbdPostProcess, url, face, i, generateNonLODTextures, lodTextures, cubeRtt, texture) {
     return new Promise((resolve, reject) => {
@@ -307,7 +387,54 @@ function _OnImageReadyAsync(image, engine, expandTexture, rgbdPostProcess, url,
  * @param imageType the mime type of the image data
  * @returns a promise
  */
-export async function UploadLevelsAsync(texture, imageData, imageType = DefaultEnvironmentTextureImageType) {
+export async function UploadRadianceLevelsAsync(texture, imageData, imageType = DefaultEnvironmentTextureImageType) {
+    const engine = texture.getEngine();
+    texture.format = 5;
+    texture.type = 0;
+    texture.generateMipMaps = true;
+    texture._cachedAnisotropicFilteringLevel = null;
+    engine.updateTextureSamplingMode(3, texture);
+    await _UploadLevelsAsync(texture, imageData, true, imageType);
+    // Flag internal texture as ready in case they are in use.
+    texture.isReady = true;
+}
+/**
+ * Uploads the levels of image data to the GPU.
+ * @param mainTexture defines the internal texture to upload to
+ * @param imageData defines the array buffer views of image data [mipmap][face]
+ * @param size defines the size of the texture faces
+ * @param imageType the mime type of the image data
+ * @returns a promise
+ */
+export async function UploadIrradianceLevelsAsync(mainTexture, imageData, size, imageType = DefaultEnvironmentTextureImageType) {
+    // Gets everything ready.
+    const engine = mainTexture.getEngine();
+    const texture = new InternalTexture(engine, 5 /* InternalTextureSource.RenderTarget */);
+    const baseTexture = new BaseTexture(engine, texture);
+    mainTexture._irradianceTexture = baseTexture;
+    texture.isCube = true;
+    texture.format = 5;
+    texture.type = 0;
+    texture.generateMipMaps = true;
+    texture._cachedAnisotropicFilteringLevel = null;
+    texture.generateMipMaps = true;
+    texture.width = size;
+    texture.height = size;
+    engine.updateTextureSamplingMode(3, texture);
+    await _UploadLevelsAsync(texture, [imageData], false, imageType);
+    engine.generateMipMapsForCubemap(texture);
+    // Flag internal texture as ready in case they are in use.
+    texture.isReady = true;
+}
+/**
+ * Uploads the levels of image data to the GPU.
+ * @param texture defines the internal texture to upload to
+ * @param imageData defines the array buffer views of image data [mipmap][face]
+ * @param canGenerateNonLODTextures defines whether or not to generate non lod textures
+ * @param imageType the mime type of the image data
+ * @returns a promise
+ */
+async function _UploadLevelsAsync(texture, imageData, canGenerateNonLODTextures, imageType = DefaultEnvironmentTextureImageType) {
     if (!Tools.IsExponentOfTwo(texture.width)) {
         throw new Error("Texture size must be a power of two");
     }
@@ -320,18 +447,10 @@ export async function UploadLevelsAsync(texture, imageData, imageType = DefaultE
     let cubeRtt = null;
     let lodTextures = null;
     const caps = engine.getCaps();
-    texture.format = 5;
-    texture.type = 0;
-    texture.generateMipMaps = true;
-    texture._cachedAnisotropicFilteringLevel = null;
-    engine.updateTextureSamplingMode(3, texture);
-    // Add extra process if texture lod is not supported
     if (!caps.textureLOD) {
         expandTexture = false;
-        generateNonLODTextures = true;
-        lodTextures = {};
+        generateNonLODTextures = canGenerateNonLODTextures;
     }
-    // in webgl 1 there are no ways to either render or copy lod level information for float textures.
     else if (!engine._features.supportRenderAndCopyToLodForFloatTextures) {
         expandTexture = false;
     }
@@ -374,6 +493,7 @@ export async function UploadLevelsAsync(texture, imageData, imageType = DefaultE
         // In case of missing support, applies the same patch than DDS files.
         if (generateNonLODTextures) {
             const mipSlices = 3;
+            lodTextures = {};
             const scale = texture._lodGenerationScale;
             const offset = texture._lodGenerationOffset;
             for (let i = 0; i < mipSlices; i++) {
@@ -384,6 +504,7 @@ export async function UploadLevelsAsync(texture, imageData, imageType = DefaultE
                 const maxLODIndex = (mipmapsCount - 1) * scale + offset; // roughness = 1 (mipmaps start from 0)
                 const lodIndex = minLODIndex + (maxLODIndex - minLODIndex) * roughness;
                 const mipmapIndex = Math.round(Math.min(Math.max(lodIndex, 0), maxLODIndex));
+                //compute LOD from even spacing in smoothness (matching shader calculation)
                 const glTextureFromLod = new InternalTexture(engine, 2 /* InternalTextureSource.Temp */);
                 glTextureFromLod.isCube = true;
                 glTextureFromLod.invertY = true;
@@ -468,30 +589,31 @@ export async function UploadLevelsAsync(texture, imageData, imageType = DefaultE
             }
         }
     }
-    // Once all done, finishes the cleanup and return
-    return Promise.all(promises).then(() => {
-        // Release temp RTT.
-        if (cubeRtt) {
-            engine._releaseTexture(texture);
-            cubeRtt._swapAndDie(texture);
+    await Promise.all(promises);
+    // Release temp RTT.
+    if (cubeRtt) {
+        const irradiance = texture._irradianceTexture;
+        texture._irradianceTexture = null;
+        engine._releaseTexture(texture);
+        cubeRtt._swapAndDie(texture);
+        texture._irradianceTexture = irradiance;
+    }
+    // Release temp Post Process.
+    if (rgbdPostProcess) {
+        rgbdPostProcess.dispose();
+    }
+    // Flag internal texture as ready in case they are in use.
+    if (generateNonLODTextures) {
+        if (texture._lodTextureHigh && texture._lodTextureHigh._texture) {
+            texture._lodTextureHigh._texture.isReady = true;
         }
-        // Release temp Post Process.
-        if (rgbdPostProcess) {
-            rgbdPostProcess.dispose();
+        if (texture._lodTextureMid && texture._lodTextureMid._texture) {
+            texture._lodTextureMid._texture.isReady = true;
         }
-        // Flag internal texture as ready in case they are in use.
-        if (generateNonLODTextures) {
-            if (texture._lodTextureHigh && texture._lodTextureHigh._texture) {
-                texture._lodTextureHigh._texture.isReady = true;
-            }
-            if (texture._lodTextureMid && texture._lodTextureMid._texture) {
-                texture._lodTextureMid._texture.isReady = true;
-            }
-            if (texture._lodTextureLow && texture._lodTextureLow._texture) {
-                texture._lodTextureLow._texture.isReady = true;
-            }
+        if (texture._lodTextureLow && texture._lodTextureLow._texture) {
+            texture._lodTextureLow._texture.isReady = true;
         }
-    });
+    }
 }
 /**
  * Uploads spherical polynomials information to the texture.
@@ -523,7 +645,7 @@ export function _UpdateRGBDAsync(internalTexture, data, sphericalPolynomial, lod
     const proxy = internalTexture
         .getEngine()
         .createRawCubeTexture(null, internalTexture.width, internalTexture.format, internalTexture.type, internalTexture.generateMipMaps, internalTexture.invertY, internalTexture.samplingMode, internalTexture._compression);
-    const proxyPromise = UploadLevelsAsync(proxy, data).then(() => internalTexture);
+    const proxyPromise = UploadRadianceLevelsAsync(proxy, data).then(() => internalTexture);
     internalTexture.onRebuildCallback = (_internalTexture) => {
         return {
             proxy: proxyPromise,
@@ -536,7 +658,7 @@ export function _UpdateRGBDAsync(internalTexture, data, sphericalPolynomial, lod
     internalTexture._lodGenerationScale = lodScale;
     internalTexture._lodGenerationOffset = lodOffset;
     internalTexture._sphericalPolynomial = sphericalPolynomial;
-    return UploadLevelsAsync(internalTexture, data).then(() => {
+    return UploadRadianceLevelsAsync(internalTexture, data).then(() => {
         internalTexture.isReady = true;
         return internalTexture;
     });
@@ -568,7 +690,14 @@ export const EnvironmentTextureTools = {
      * @param info parameters that determine what views will be created for accessing the underlying buffer
      * @returns the views described by info providing access to the underlying buffer
      */
-    CreateImageDataArrayBufferViews,
+    CreateRadianceImageDataArrayBufferViews,
+    /**
+     * Creates the ArrayBufferViews used for initializing environment texture image data.
+     * @param data the image data
+     * @param info parameters that determine what views will be created for accessing the underlying buffer
+     * @returns the views described by info providing access to the underlying buffer
+     */
+    CreateIrradianceImageDataArrayBufferViews,
     /**
      * Uploads the texture info contained in the env file to the GPU.
      * @param texture defines the internal texture to upload to
@@ -584,7 +713,15 @@ export const EnvironmentTextureTools = {
      * @param imageType the mime type of the image data
      * @returns a promise
      */
-    UploadLevelsAsync,
+    UploadRadianceLevelsAsync,
+    /**
+     * Uploads the levels of image data to the GPU.
+     * @param texture defines the internal texture to upload to
+     * @param imageData defines the array buffer views of image data [mipmap][face]
+     * @param imageType the mime type of the image data
+     * @returns a promise
+     */
+    UploadIrradianceLevelsAsync,
     /**
      * Uploads spherical polynomials information to the texture.
      * @param texture defines the texture we are trying to upload the information to