@graphty/graphty-element 1.0.1

package/dist/envTextureLoader-DdCLpySN.js

@@ -0,0 +1,238 @@
+import { c as B, a as z, V as m, I as O, B as S, e as G, g as V, P as k } from "./index-ChGTkj2q.js";
+import "./dumpTools-DA1xMSIZ.js";
+const R = "image/png", F = 2, D = [134, 22, 135, 150, 246, 214, 150, 54];
+function H(e) {
+  const t = new DataView(e.buffer, e.byteOffset, e.byteLength);
+  let n = 0;
+  for (let r = 0; r < D.length; r++)
+    if (t.getUint8(n++) !== D[r])
+      return B.Error("Not a babylon environment map"), null;
+  let i = "", o = 0;
+  for (; o = t.getUint8(n++); )
+    i += String.fromCharCode(o);
+  let a = JSON.parse(i);
+  return a = A(a), a.binaryDataPosition = n, a.specular && (a.specular.lodGenerationScale = a.specular.lodGenerationScale || 0.8), a;
+}
+function A(e) {
+  if (e.version > F)
+    throw new Error(`Unsupported babylon environment map version "${e.version}". Latest supported version is "${F}".`);
+  return e.version === 2 || (e = { ...e, version: 2, imageType: R }), e;
+}
+function E(e, t) {
+  t = A(t);
+  const n = t.specular;
+  let i = Math.log2(t.width);
+  if (i = Math.round(i) + 1, n.mipmaps.length !== 6 * i)
+    throw new Error(`Unsupported specular mipmaps number "${n.mipmaps.length}"`);
+  const o = new Array(i);
+  for (let a = 0; a < i; a++) {
+    o[a] = new Array(6);
+    for (let r = 0; r < 6; r++) {
+      const s = n.mipmaps[a * 6 + r];
+      o[a][r] = new Uint8Array(e.buffer, e.byteOffset + t.binaryDataPosition + s.position, s.length);
+    }
+  }
+  return o;
+}
+function N(e, t) {
+  var o;
+  t = A(t);
+  const n = new Array(6), i = (o = t.irradiance) == null ? void 0 : o.irradianceTexture;
+  if (i) {
+    if (i.faces.length !== 6)
+      throw new Error(`Incorrect irradiance texture faces number "${i.faces.length}"`);
+    for (let a = 0; a < 6; a++) {
+      const r = i.faces[a];
+      n[a] = new Uint8Array(e.buffer, e.byteOffset + t.binaryDataPosition + r.position, r.length);
+    }
+  }
+  return n;
+}
+function P(e, t, n) {
+  var s, f, c;
+  n = A(n);
+  const i = n.specular;
+  if (!i)
+    return Promise.resolve([]);
+  e._lodGenerationScale = i.lodGenerationScale;
+  const o = [], a = E(t, n);
+  o.push($(e, a, n.imageType));
+  const r = (s = n.irradiance) == null ? void 0 : s.irradianceTexture;
+  if (r) {
+    const g = N(t, n);
+    let d = null;
+    (c = (f = n.irradiance) == null ? void 0 : f.irradianceTexture) != null && c.dominantDirection && (d = m.FromArray(n.irradiance.irradianceTexture.dominantDirection)), o.push(Y(e, g, r.size, n.imageType, d));
+  }
+  return Promise.all(o);
+}
+async function C(e, t, n, i, o, a, r, s, f, c, g) {
+  return await new Promise((d, I) => {
+    if (n) {
+      const h = t.createTexture(null, !0, !0, null, 1, null, (l) => {
+        I(l);
+      }, e);
+      i == null || i.onEffectCreatedObservable.addOnce((l) => {
+        l.executeWhenCompiled(() => {
+          i.externalTextureSamplerBinding = !0, i.onApply = (u) => {
+            u._bindTexture("textureSampler", h), u.setFloat2("scale", 1, t._features.needsInvertingBitmap && e instanceof ImageBitmap ? -1 : 1);
+          }, t.scenes.length && (t.scenes[0].postProcessManager.directRender([i], c, !0, a, r), t.restoreDefaultFramebuffer(), h.dispose(), URL.revokeObjectURL(o), d());
+        });
+      });
+    } else {
+      if (t._uploadImageToTexture(g, e, a, r), s) {
+        const h = f[r];
+        h && t._uploadImageToTexture(h._texture, e, a, 0);
+      }
+      d();
+    }
+  });
+}
+async function $(e, t, n = R) {
+  const i = e.getEngine();
+  e.format = 5, e.type = 0, e.generateMipMaps = !0, e._cachedAnisotropicFilteringLevel = null, i.updateTextureSamplingMode(3, e), await U(e, t, !0, n), e.isReady = !0;
+}
+async function Y(e, t, n, i = R, o = null) {
+  const a = e.getEngine(), r = new O(
+    a,
+    5
+    /* InternalTextureSource.RenderTarget */
+  ), s = new S(a, r);
+  e._irradianceTexture = s, s._dominantDirection = o, r.isCube = !0, r.format = 5, r.type = 0, r.generateMipMaps = !0, r._cachedAnisotropicFilteringLevel = null, r.generateMipMaps = !0, r.width = n, r.height = n, a.updateTextureSamplingMode(3, r), await U(r, [t], !1, i), a.generateMipMapsForCubemap(r), r.isReady = !0;
+}
+async function U(e, t, n, i = R) {
+  if (!G.IsExponentOfTwo(e.width))
+    throw new Error("Texture size must be a power of two");
+  const o = V(e.width) + 1, a = e.getEngine();
+  let r = !1, s = !1, f = null, c = null, g = null;
+  const d = a.getCaps();
+  d.textureLOD ? a._features.supportRenderAndCopyToLodForFloatTextures ? d.textureHalfFloatRender && d.textureHalfFloatLinearFiltering ? (r = !0, e.type = 2) : d.textureFloatRender && d.textureFloatLinearFiltering && (r = !0, e.type = 1) : r = !1 : (r = !1, s = n);
+  let I = 0;
+  if (r)
+    a.isWebGPU ? (I = 1, await import("./rgbdDecode.fragment-bNaGtQ-x.js")) : await import("./rgbdDecode.fragment-koAcppx0.js"), f = new k("rgbdDecode", "rgbdDecode", null, null, 1, null, 3, a, !1, void 0, e.type, void 0, null, !1, void 0, I), e._isRGBD = !1, e.invertY = !1, c = a.createRenderTargetCubeTexture(e.width, {
+      generateDepthBuffer: !1,
+      generateMipMaps: !0,
+      generateStencilBuffer: !1,
+      samplingMode: 3,
+      type: e.type,
+      format: 5
+    });
+  else if (e._isRGBD = !0, e.invertY = !0, s) {
+    g = {};
+    const u = e._lodGenerationScale, T = e._lodGenerationOffset;
+    for (let p = 0; p < 3; p++) {
+      const x = 1 - p / 2, y = T, L = (o - 1) * u + T, M = y + (L - y) * x, b = Math.round(Math.min(Math.max(M, 0), L)), v = new O(
+        a,
+        2
+        /* InternalTextureSource.Temp */
+      );
+      v.isCube = !0, v.invertY = !0, v.generateMipMaps = !1, a.updateTextureSamplingMode(2, v);
+      const _ = new S(null);
+      switch (_._isCube = !0, _._texture = v, g[b] = _, p) {
+        case 0:
+          e._lodTextureLow = _;
+          break;
+        case 1:
+          e._lodTextureMid = _;
+          break;
+        case 2:
+          e._lodTextureHigh = _;
+          break;
+      }
+    }
+  }
+  const h = [];
+  for (let l = 0; l < t.length; l++)
+    for (let u = 0; u < 6; u++) {
+      const T = t[l][u], p = new Blob([T], { type: i }), w = URL.createObjectURL(p);
+      let x;
+      if (a._features.forceBitmapOverHTMLImageElement)
+        x = a.createImageBitmap(p, { premultiplyAlpha: "none" }).then(async (y) => await C(y, a, r, f, w, u, l, s, g, c, e));
+      else {
+        const y = new Image();
+        y.src = w, x = new Promise((L, M) => {
+          y.onload = () => {
+            C(y, a, r, f, w, u, l, s, g, c, e).then(() => L()).catch((b) => {
+              M(b);
+            });
+          }, y.onerror = (b) => {
+            M(b);
+          };
+        });
+      }
+      h.push(x);
+    }
+  if (await Promise.all(h), t.length < o) {
+    let l;
+    const u = Math.pow(2, o - 1 - t.length), T = u * u * 4;
+    switch (e.type) {
+      case 0: {
+        l = new Uint8Array(T);
+        break;
+      }
+      case 2: {
+        l = new Uint16Array(T);
+        break;
+      }
+      case 1: {
+        l = new Float32Array(T);
+        break;
+      }
+    }
+    for (let p = t.length; p < o; p++)
+      for (let w = 0; w < 6; w++)
+        a._uploadArrayBufferViewToTexture((c == null ? void 0 : c.texture) || e, l, w, p);
+  }
+  if (c) {
+    const l = e._irradianceTexture;
+    e._irradianceTexture = null, a._releaseTexture(e), c._swapAndDie(e), e._irradianceTexture = l;
+  }
+  f && f.dispose(), s && (e._lodTextureHigh && e._lodTextureHigh._texture && (e._lodTextureHigh._texture.isReady = !0), e._lodTextureMid && e._lodTextureMid._texture && (e._lodTextureMid._texture.isReady = !0), e._lodTextureLow && e._lodTextureLow._texture && (e._lodTextureLow._texture.isReady = !0));
+}
+function W(e, t) {
+  t = A(t);
+  const n = t.irradiance;
+  if (!n)
+    return;
+  const i = new z();
+  m.FromArrayToRef(n.x, 0, i.x), m.FromArrayToRef(n.y, 0, i.y), m.FromArrayToRef(n.z, 0, i.z), m.FromArrayToRef(n.xx, 0, i.xx), m.FromArrayToRef(n.yy, 0, i.yy), m.FromArrayToRef(n.zz, 0, i.zz), m.FromArrayToRef(n.yz, 0, i.yz), m.FromArrayToRef(n.zx, 0, i.zx), m.FromArrayToRef(n.xy, 0, i.xy), e._sphericalPolynomial = i;
+}
+class q {
+  constructor() {
+    this.supportCascades = !1;
+  }
+  /**
+   * Uploads the cube texture data to the WebGL texture. It has already been bound.
+   * @param data contains the texture data
+   * @param texture defines the BabylonJS internal texture
+   * @param createPolynomials will be true if polynomials have been requested
+   * @param onLoad defines the callback to trigger once the texture is ready
+   * @param onError defines the callback to trigger in case of error
+   */
+  loadCubeData(t, n, i, o, a) {
+    if (Array.isArray(t))
+      return;
+    const r = H(t);
+    if (r) {
+      n.width = r.width, n.height = r.width;
+      try {
+        W(n, r), P(n, t, r).then(() => {
+          n.isReady = !0, n.onLoadedObservable.notifyObservers(n), n.onLoadedObservable.clear(), o && o();
+        }, (s) => {
+          a == null || a("Can not upload environment levels", s);
+        });
+      } catch (s) {
+        a == null || a("Can not upload environment file", s);
+      }
+    } else a && a("Can not parse the environment file", null);
+  }
+  /**
+   * Uploads the 2D texture data to the WebGL texture. It has already been bound once in the callback.
+   */
+  loadData() {
+    throw ".env not supported in 2d.";
+  }
+}
+export {
+  q as _ENVTextureLoader
+};
+//# sourceMappingURL=envTextureLoader-DdCLpySN.js.map

package/dist/envTextureLoader-DdCLpySN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"envTextureLoader-DdCLpySN.js","sources":["../node_modules/@babylonjs/core/Misc/environmentTextureTools.js","../node_modules/@babylonjs/core/Materials/Textures/Loaders/envTextureLoader.js"],"sourcesContent":["import { Tools } from \"./tools.js\";\nimport { Vector3 } from \"../Maths/math.vector.js\";\nimport { ILog2 } from \"../Maths/math.scalar.functions.js\";\nimport { SphericalPolynomial } from \"../Maths/sphericalPolynomial.js\";\nimport { InternalTexture } from \"../Materials/Textures/internalTexture.js\";\nimport { BaseTexture } from \"../Materials/Textures/baseTexture.js\";\n\nimport { Scene } from \"../scene.js\";\nimport { PostProcess } from \"../PostProcesses/postProcess.js\";\nimport { Logger } from \"../Misc/logger.js\";\nimport { RGBDTextureTools } from \"./rgbdTextureTools.js\";\nimport { DumpDataAsync } from \"../Misc/dumpTools.js\";\nimport \"../Materials/Textures/baseTexture.polynomial.js\";\nconst DefaultEnvironmentTextureImageType = \"image/png\";\nconst CurrentVersion = 2;\n/**\n * Magic number identifying the env file.\n */\nconst MagicBytes = [0x86, 0x16, 0x87, 0x96, 0xf6, 0xd6, 0x96, 0x36];\n/**\n * Gets the environment info from an env file.\n * @param data The array buffer containing the .env bytes.\n * @returns the environment file info (the json header) if successfully parsed, normalized to the latest supported version.\n */\nexport function GetEnvInfo(data) {\n    const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);\n    let pos = 0;\n    for (let i = 0; i < MagicBytes.length; i++) {\n        if (dataView.getUint8(pos++) !== MagicBytes[i]) {\n            Logger.Error(\"Not a babylon environment map\");\n            return null;\n        }\n    }\n    // Read json manifest - collect characters up to null terminator\n    let manifestString = \"\";\n    let charCode = 0x00;\n    while ((charCode = dataView.getUint8(pos++))) {\n        manifestString += String.fromCharCode(charCode);\n    }\n    let manifest = JSON.parse(manifestString);\n    manifest = normalizeEnvInfo(manifest);\n    // Extend the header with the position of the payload.\n    manifest.binaryDataPosition = pos;\n    if (manifest.specular) {\n        // Fallback to 0.8 exactly if lodGenerationScale is not defined for backward compatibility.\n        manifest.specular.lodGenerationScale = manifest.specular.lodGenerationScale || 0.8;\n    }\n    return manifest;\n}\n/**\n * Normalizes any supported version of the environment file info to the latest version\n * @param info environment file info on any supported version\n * @returns environment file info in the latest supported version\n * @private\n */\nexport function normalizeEnvInfo(info) {\n    if (info.version > CurrentVersion) {\n        throw new Error(`Unsupported babylon environment map version \"${info.version}\". Latest supported version is \"${CurrentVersion}\".`);\n    }\n    if (info.version === 2) {\n        return info;\n    }\n    // Migrate a v1 info to v2\n    info = { ...info, version: 2, imageType: DefaultEnvironmentTextureImageType };\n    return info;\n}\n/**\n * Creates an environment texture from a loaded cube texture.\n * @param texture defines the cube texture to convert in env file\n * @param options options for the conversion process\n * @returns a promise containing the environment data if successful.\n */\nexport async function CreateEnvTextureAsync(texture, options = {}) {\n    const internalTexture = texture.getInternalTexture();\n    if (!internalTexture) {\n        // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors\n        return await Promise.reject(\"The cube texture is invalid.\");\n    }\n    const engine = internalTexture.getEngine();\n    if (texture.textureType !== 2 &&\n        texture.textureType !== 1 &&\n        texture.textureType !== 0 &&\n        texture.textureType !== 0 &&\n        texture.textureType !== 7 &&\n        texture.textureType !== -1) {\n        // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors\n        return await Promise.reject(\"The cube texture should allow HDR (Full Float or Half Float).\");\n    }\n    let textureType = 1;\n    if (!engine.getCaps().textureFloatRender) {\n        textureType = 2;\n        if (!engine.getCaps().textureHalfFloatRender) {\n            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors\n            return await Promise.reject(\"Env texture can only be created when the browser supports half float or full float rendering.\");\n        }\n    }\n    // sphericalPolynomial is lazy loaded so simply accessing it should trigger the computation.\n    // eslint-disable-next-line @typescript-eslint/no-unused-expressions\n    texture.sphericalPolynomial;\n    // Lets keep track of the polynomial promise so we can wait for it to be ready before generating the pixels.\n    const sphericalPolynomialPromise = texture.getInternalTexture()?._sphericalPolynomialPromise;\n    const cubeWidth = internalTexture.width;\n    const hostingScene = new Scene(engine);\n    const specularTextures = {};\n    const diffuseTextures = {};\n    // 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!\n    engine.flushFramebuffer();\n    const imageType = options.imageType ?? DefaultEnvironmentTextureImageType;\n    // Read and collect all mipmaps data from the cube.\n    const mipmapsCount = ILog2(internalTexture.width);\n    for (let i = 0; i <= mipmapsCount; i++) {\n        const faceWidth = Math.pow(2, mipmapsCount - i);\n        // All faces of the cube.\n        for (let face = 0; face < 6; face++) {\n            // eslint-disable-next-line no-await-in-loop\n            specularTextures[i * 6 + face] = await _GetTextureEncodedDataAsync(hostingScene, texture, textureType, face, i, faceWidth, imageType, options.imageQuality);\n        }\n    }\n    // Read and collect all irradiance data from the cube.\n    const irradianceTexture = options.disableIrradianceTexture ? null : texture.irradianceTexture;\n    if (irradianceTexture) {\n        const faceWidth = irradianceTexture.getSize().width;\n        // All faces of the cube.\n        for (let face = 0; face < 6; face++) {\n            // eslint-disable-next-line no-await-in-loop\n            diffuseTextures[face] = await _GetTextureEncodedDataAsync(hostingScene, irradianceTexture, textureType, face, 0, faceWidth, imageType, options.imageQuality);\n        }\n    }\n    // We can delete the hosting scene keeping track of all the creation objects\n    hostingScene.dispose();\n    // Ensure completion of the polynomial creation promise.\n    if (sphericalPolynomialPromise) {\n        await sphericalPolynomialPromise;\n    }\n    // Creates the json header for the env texture\n    const info = {\n        version: CurrentVersion,\n        width: cubeWidth,\n        imageType,\n        irradiance: CreateEnvTextureIrradiance(texture),\n        specular: {\n            mipmaps: [],\n            lodGenerationScale: texture.lodGenerationScale,\n        },\n    };\n    // Sets the specular image data information\n    let position = 0;\n    for (let i = 0; i <= mipmapsCount; i++) {\n        for (let face = 0; face < 6; face++) {\n            const byteLength = specularTextures[i * 6 + face].byteLength;\n            info.specular.mipmaps.push({\n                length: byteLength,\n                position: position,\n            });\n            position += byteLength;\n        }\n    }\n    // Sets the irradiance image data information\n    if (irradianceTexture) {\n        info.irradiance = info.irradiance || {\n            x: [0, 0, 0],\n            xx: [0, 0, 0],\n            y: [0, 0, 0],\n            yy: [0, 0, 0],\n            z: [0, 0, 0],\n            zz: [0, 0, 0],\n            yz: [0, 0, 0],\n            zx: [0, 0, 0],\n            xy: [0, 0, 0],\n        };\n        info.irradiance.irradianceTexture = {\n            size: irradianceTexture.getSize().width,\n            faces: [],\n            dominantDirection: irradianceTexture._dominantDirection?.asArray(),\n        };\n        for (let face = 0; face < 6; face++) {\n            const byteLength = diffuseTextures[face].byteLength;\n            info.irradiance.irradianceTexture.faces.push({\n                length: byteLength,\n                position: position,\n            });\n            position += byteLength;\n        }\n    }\n    // Encode the JSON as an array buffer\n    const infoString = JSON.stringify(info);\n    const infoBuffer = new ArrayBuffer(infoString.length + 1);\n    const infoView = new Uint8Array(infoBuffer); // Limited to ascii subset matching unicode.\n    for (let i = 0, strLen = infoString.length; i < strLen; i++) {\n        infoView[i] = infoString.charCodeAt(i);\n    }\n    // Ends up with a null terminator for easier parsing\n    infoView[infoString.length] = 0x00;\n    // Computes the final required size and creates the storage\n    const totalSize = MagicBytes.length + position + infoBuffer.byteLength;\n    const finalBuffer = new ArrayBuffer(totalSize);\n    const finalBufferView = new Uint8Array(finalBuffer);\n    const dataView = new DataView(finalBuffer);\n    // Copy the magic bytes identifying the file in\n    let pos = 0;\n    for (let i = 0; i < MagicBytes.length; i++) {\n        dataView.setUint8(pos++, MagicBytes[i]);\n    }\n    // Add the json info\n    finalBufferView.set(new Uint8Array(infoBuffer), pos);\n    pos += infoBuffer.byteLength;\n    // Finally inserts the radiance texture data\n    for (let i = 0; i <= mipmapsCount; i++) {\n        for (let face = 0; face < 6; face++) {\n            const dataBuffer = specularTextures[i * 6 + face];\n            finalBufferView.set(new Uint8Array(dataBuffer), pos);\n            pos += dataBuffer.byteLength;\n        }\n    }\n    // Finally inserts the irradiance texture data\n    if (irradianceTexture) {\n        for (let face = 0; face < 6; face++) {\n            const dataBuffer = diffuseTextures[face];\n            finalBufferView.set(new Uint8Array(dataBuffer), pos);\n            pos += dataBuffer.byteLength;\n        }\n    }\n    // Voila\n    return finalBuffer;\n}\n/**\n * Get the texture encoded data from the current texture\n * @internal\n */\nasync function _GetTextureEncodedDataAsync(hostingScene, texture, textureType, face, i, size, imageType, imageQuality) {\n    let faceData = await texture.readPixels(face, i, undefined, false);\n    if (faceData && faceData.byteLength === faceData.length) {\n        const faceDataFloat = new Float32Array(faceData.byteLength * 4);\n        for (let i = 0; i < faceData.byteLength; i++) {\n            faceDataFloat[i] = faceData[i] / 255;\n            // Gamma to linear\n            faceDataFloat[i] = Math.pow(faceDataFloat[i], 2.2);\n        }\n        faceData = faceDataFloat;\n    }\n    else if (faceData && texture.gammaSpace) {\n        const floatData = faceData;\n        for (let i = 0; i < floatData.length; i++) {\n            // Gamma to linear\n            floatData[i] = Math.pow(floatData[i], 2.2);\n        }\n    }\n    const engine = hostingScene.getEngine();\n    const tempTexture = engine.createRawTexture(faceData, size, size, 5, false, true, 1, null, textureType);\n    await RGBDTextureTools.EncodeTextureToRGBD(tempTexture, hostingScene, textureType);\n    const rgbdEncodedData = await engine._readTexturePixels(tempTexture, size, size);\n    const imageEncodedData = await DumpDataAsync(size, size, rgbdEncodedData, imageType, undefined, false, true, imageQuality);\n    tempTexture.dispose();\n    return imageEncodedData;\n}\n/**\n * Creates a JSON representation of the spherical data.\n * @param texture defines the texture containing the polynomials\n * @returns the JSON representation of the spherical info\n */\nfunction CreateEnvTextureIrradiance(texture) {\n    const polynmials = texture.sphericalPolynomial;\n    if (polynmials == null) {\n        return null;\n    }\n    return {\n        x: [polynmials.x.x, polynmials.x.y, polynmials.x.z],\n        y: [polynmials.y.x, polynmials.y.y, polynmials.y.z],\n        z: [polynmials.z.x, polynmials.z.y, polynmials.z.z],\n        xx: [polynmials.xx.x, polynmials.xx.y, polynmials.xx.z],\n        yy: [polynmials.yy.x, polynmials.yy.y, polynmials.yy.z],\n        zz: [polynmials.zz.x, polynmials.zz.y, polynmials.zz.z],\n        yz: [polynmials.yz.x, polynmials.yz.y, polynmials.yz.z],\n        zx: [polynmials.zx.x, polynmials.zx.y, polynmials.zx.z],\n        xy: [polynmials.xy.x, polynmials.xy.y, polynmials.xy.z],\n    };\n}\n/**\n * Creates the ArrayBufferViews used for initializing environment texture image data.\n * @param data the image data\n * @param info parameters that determine what views will be created for accessing the underlying buffer\n * @returns the views described by info providing access to the underlying buffer\n */\nexport function CreateRadianceImageDataArrayBufferViews(data, info) {\n    info = normalizeEnvInfo(info);\n    const specularInfo = info.specular;\n    // Double checks the enclosed info\n    let mipmapsCount = Math.log2(info.width);\n    mipmapsCount = Math.round(mipmapsCount) + 1;\n    if (specularInfo.mipmaps.length !== 6 * mipmapsCount) {\n        throw new Error(`Unsupported specular mipmaps number \"${specularInfo.mipmaps.length}\"`);\n    }\n    const imageData = new Array(mipmapsCount);\n    for (let i = 0; i < mipmapsCount; i++) {\n        imageData[i] = new Array(6);\n        for (let face = 0; face < 6; face++) {\n            const imageInfo = specularInfo.mipmaps[i * 6 + face];\n            imageData[i][face] = new Uint8Array(data.buffer, data.byteOffset + info.binaryDataPosition + imageInfo.position, imageInfo.length);\n        }\n    }\n    return imageData;\n}\n/**\n * Creates the ArrayBufferViews used for initializing environment texture image data.\n * @param data the image data\n * @param info parameters that determine what views will be created for accessing the underlying buffer\n * @returns the views described by info providing access to the underlying buffer\n */\nexport function CreateIrradianceImageDataArrayBufferViews(data, info) {\n    info = normalizeEnvInfo(info);\n    const imageData = new Array(6);\n    const irradianceTexture = info.irradiance?.irradianceTexture;\n    if (irradianceTexture) {\n        if (irradianceTexture.faces.length !== 6) {\n            throw new Error(`Incorrect irradiance texture faces number \"${irradianceTexture.faces.length}\"`);\n        }\n        for (let face = 0; face < 6; face++) {\n            const imageInfo = irradianceTexture.faces[face];\n            imageData[face] = new Uint8Array(data.buffer, data.byteOffset + info.binaryDataPosition + imageInfo.position, imageInfo.length);\n        }\n    }\n    return imageData;\n}\n/**\n * Uploads the texture info contained in the env file to the GPU.\n * @param texture defines the internal texture to upload to\n * @param data defines the data to load\n * @param info defines the texture info retrieved through the GetEnvInfo method\n * @returns a promise\n */\n// eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\nexport function UploadEnvLevelsAsync(texture, data, info) {\n    info = normalizeEnvInfo(info);\n    const specularInfo = info.specular;\n    if (!specularInfo) {\n        // Nothing else parsed so far\n        return Promise.resolve([]);\n    }\n    texture._lodGenerationScale = specularInfo.lodGenerationScale;\n    const promises = [];\n    const radianceImageData = CreateRadianceImageDataArrayBufferViews(data, info);\n    promises.push(UploadRadianceLevelsAsync(texture, radianceImageData, info.imageType));\n    const irradianceTexture = info.irradiance?.irradianceTexture;\n    if (irradianceTexture) {\n        const irradianceImageData = CreateIrradianceImageDataArrayBufferViews(data, info);\n        let dominantDirection = null;\n        if (info.irradiance?.irradianceTexture?.dominantDirection) {\n            dominantDirection = Vector3.FromArray(info.irradiance.irradianceTexture.dominantDirection);\n        }\n        promises.push(UploadIrradianceLevelsAsync(texture, irradianceImageData, irradianceTexture.size, info.imageType, dominantDirection));\n    }\n    return Promise.all(promises);\n}\nasync function _OnImageReadyAsync(image, engine, expandTexture, rgbdPostProcess, url, face, i, generateNonLODTextures, lodTextures, cubeRtt, texture) {\n    return await new Promise((resolve, reject) => {\n        if (expandTexture) {\n            const tempTexture = engine.createTexture(null, true, true, null, 1, null, (message) => {\n                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors\n                reject(message);\n            }, image);\n            rgbdPostProcess?.onEffectCreatedObservable.addOnce((effect) => {\n                effect.executeWhenCompiled(() => {\n                    // Uncompress the data to a RTT\n                    rgbdPostProcess.externalTextureSamplerBinding = true;\n                    rgbdPostProcess.onApply = (effect) => {\n                        effect._bindTexture(\"textureSampler\", tempTexture);\n                        effect.setFloat2(\"scale\", 1, engine._features.needsInvertingBitmap && image instanceof ImageBitmap ? -1 : 1);\n                    };\n                    if (!engine.scenes.length) {\n                        return;\n                    }\n                    engine.scenes[0].postProcessManager.directRender([rgbdPostProcess], cubeRtt, true, face, i);\n                    // Cleanup\n                    engine.restoreDefaultFramebuffer();\n                    tempTexture.dispose();\n                    URL.revokeObjectURL(url);\n                    resolve();\n                });\n            });\n        }\n        else {\n            engine._uploadImageToTexture(texture, image, face, i);\n            // Upload the face to the non lod texture support\n            if (generateNonLODTextures) {\n                const lodTexture = lodTextures[i];\n                if (lodTexture) {\n                    engine._uploadImageToTexture(lodTexture._texture, image, face, 0);\n                }\n            }\n            resolve();\n        }\n    });\n}\n/**\n * Uploads the levels of image data to the GPU.\n * @param texture defines the internal texture to upload to\n * @param imageData defines the array buffer views of image data [mipmap][face]\n * @param imageType the mime type of the image data\n * @returns a promise\n */\nexport async function UploadRadianceLevelsAsync(texture, imageData, imageType = DefaultEnvironmentTextureImageType) {\n    const engine = texture.getEngine();\n    texture.format = 5;\n    texture.type = 0;\n    texture.generateMipMaps = true;\n    texture._cachedAnisotropicFilteringLevel = null;\n    engine.updateTextureSamplingMode(3, texture);\n    await _UploadLevelsAsync(texture, imageData, true, imageType);\n    // Flag internal texture as ready in case they are in use.\n    texture.isReady = true;\n}\n/**\n * Uploads the levels of image data to the GPU.\n * @param mainTexture defines the internal texture to upload to\n * @param imageData defines the array buffer views of image data [mipmap][face]\n * @param size defines the size of the texture faces\n * @param imageType the mime type of the image data\n * @param dominantDirection the dominant direction of light in the environment texture, if available\n * @returns a promise\n */\nexport async function UploadIrradianceLevelsAsync(mainTexture, imageData, size, imageType = DefaultEnvironmentTextureImageType, dominantDirection = null) {\n    // Gets everything ready.\n    const engine = mainTexture.getEngine();\n    const texture = new InternalTexture(engine, 5 /* InternalTextureSource.RenderTarget */);\n    const baseTexture = new BaseTexture(engine, texture);\n    mainTexture._irradianceTexture = baseTexture;\n    baseTexture._dominantDirection = dominantDirection;\n    texture.isCube = true;\n    texture.format = 5;\n    texture.type = 0;\n    texture.generateMipMaps = true;\n    texture._cachedAnisotropicFilteringLevel = null;\n    texture.generateMipMaps = true;\n    texture.width = size;\n    texture.height = size;\n    engine.updateTextureSamplingMode(3, texture);\n    await _UploadLevelsAsync(texture, [imageData], false, imageType);\n    engine.generateMipMapsForCubemap(texture);\n    // Flag internal texture as ready in case they are in use.\n    texture.isReady = true;\n}\n/**\n * Uploads the levels of image data to the GPU.\n * @param texture defines the internal texture to upload to\n * @param imageData defines the array buffer views of image data [mipmap][face]\n * @param canGenerateNonLODTextures defines whether or not to generate non lod textures\n * @param imageType the mime type of the image data\n * @returns a promise\n */\nasync function _UploadLevelsAsync(texture, imageData, canGenerateNonLODTextures, imageType = DefaultEnvironmentTextureImageType) {\n    if (!Tools.IsExponentOfTwo(texture.width)) {\n        throw new Error(\"Texture size must be a power of two\");\n    }\n    const mipmapsCount = ILog2(texture.width) + 1;\n    // Gets everything ready.\n    const engine = texture.getEngine();\n    let expandTexture = false;\n    let generateNonLODTextures = false;\n    let rgbdPostProcess = null;\n    let cubeRtt = null;\n    let lodTextures = null;\n    const caps = engine.getCaps();\n    if (!caps.textureLOD) {\n        expandTexture = false;\n        generateNonLODTextures = canGenerateNonLODTextures;\n    }\n    else if (!engine._features.supportRenderAndCopyToLodForFloatTextures) {\n        expandTexture = false;\n    }\n    // If half float available we can uncompress the texture\n    else if (caps.textureHalfFloatRender && caps.textureHalfFloatLinearFiltering) {\n        expandTexture = true;\n        texture.type = 2;\n    }\n    // If full float available we can uncompress the texture\n    else if (caps.textureFloatRender && caps.textureFloatLinearFiltering) {\n        expandTexture = true;\n        texture.type = 1;\n    }\n    // Expand the texture if possible\n    let shaderLanguage = 0 /* ShaderLanguage.GLSL */;\n    if (expandTexture) {\n        if (engine.isWebGPU) {\n            shaderLanguage = 1 /* ShaderLanguage.WGSL */;\n            await import(\"../ShadersWGSL/rgbdDecode.fragment.js\");\n        }\n        else {\n            await import(\"../Shaders/rgbdDecode.fragment.js\");\n        }\n        // Simply run through the decode PP\n        rgbdPostProcess = new PostProcess(\"rgbdDecode\", \"rgbdDecode\", null, null, 1, null, 3, engine, false, undefined, texture.type, undefined, null, false, undefined, shaderLanguage);\n        texture._isRGBD = false;\n        texture.invertY = false;\n        cubeRtt = engine.createRenderTargetCubeTexture(texture.width, {\n            generateDepthBuffer: false,\n            generateMipMaps: true,\n            generateStencilBuffer: false,\n            samplingMode: 3,\n            type: texture.type,\n            format: 5,\n        });\n    }\n    else {\n        texture._isRGBD = true;\n        texture.invertY = true;\n        // In case of missing support, applies the same patch than DDS files.\n        if (generateNonLODTextures) {\n            const mipSlices = 3;\n            lodTextures = {};\n            const scale = texture._lodGenerationScale;\n            const offset = texture._lodGenerationOffset;\n            for (let i = 0; i < mipSlices; i++) {\n                //compute LOD from even spacing in smoothness (matching shader calculation)\n                const smoothness = i / (mipSlices - 1);\n                const roughness = 1 - smoothness;\n                const minLODIndex = offset; // roughness = 0\n                const maxLODIndex = (mipmapsCount - 1) * scale + offset; // roughness = 1 (mipmaps start from 0)\n                const lodIndex = minLODIndex + (maxLODIndex - minLODIndex) * roughness;\n                const mipmapIndex = Math.round(Math.min(Math.max(lodIndex, 0), maxLODIndex));\n                //compute LOD from even spacing in smoothness (matching shader calculation)\n                const glTextureFromLod = new InternalTexture(engine, 2 /* InternalTextureSource.Temp */);\n                glTextureFromLod.isCube = true;\n                glTextureFromLod.invertY = true;\n                glTextureFromLod.generateMipMaps = false;\n                engine.updateTextureSamplingMode(2, glTextureFromLod);\n                // Wrap in a base texture for easy binding.\n                const lodTexture = new BaseTexture(null);\n                lodTexture._isCube = true;\n                lodTexture._texture = glTextureFromLod;\n                lodTextures[mipmapIndex] = lodTexture;\n                switch (i) {\n                    case 0:\n                        texture._lodTextureLow = lodTexture;\n                        break;\n                    case 1:\n                        texture._lodTextureMid = lodTexture;\n                        break;\n                    case 2:\n                        texture._lodTextureHigh = lodTexture;\n                        break;\n                }\n            }\n        }\n    }\n    const promises = [];\n    // All mipmaps up to provided number of images\n    for (let i = 0; i < imageData.length; i++) {\n        // All faces\n        for (let face = 0; face < 6; face++) {\n            // Constructs an image element from image data\n            const bytes = imageData[i][face];\n            const blob = new Blob([bytes], { type: imageType });\n            const url = URL.createObjectURL(blob);\n            let promise;\n            if (engine._features.forceBitmapOverHTMLImageElement) {\n                // eslint-disable-next-line github/no-then\n                promise = engine.createImageBitmap(blob, { premultiplyAlpha: \"none\" }).then(async (img) => {\n                    return await _OnImageReadyAsync(img, engine, expandTexture, rgbdPostProcess, url, face, i, generateNonLODTextures, lodTextures, cubeRtt, texture);\n                });\n            }\n            else {\n                const image = new Image();\n                image.src = url;\n                // Enqueue promise to upload to the texture.\n                promise = new Promise((resolve, reject) => {\n                    image.onload = () => {\n                        _OnImageReadyAsync(image, engine, expandTexture, rgbdPostProcess, url, face, i, generateNonLODTextures, lodTextures, cubeRtt, texture)\n                            // eslint-disable-next-line github/no-then\n                            .then(() => resolve())\n                            // eslint-disable-next-line github/no-then\n                            .catch((reason) => {\n                            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors\n                            reject(reason);\n                        });\n                    };\n                    image.onerror = (error) => {\n                        // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors\n                        reject(error);\n                    };\n                });\n            }\n            promises.push(promise);\n        }\n    }\n    await Promise.all(promises);\n    // Fill remaining mipmaps with black textures.\n    if (imageData.length < mipmapsCount) {\n        let data;\n        const size = Math.pow(2, mipmapsCount - 1 - imageData.length);\n        const dataLength = size * size * 4;\n        switch (texture.type) {\n            case 0: {\n                data = new Uint8Array(dataLength);\n                break;\n            }\n            case 2: {\n                data = new Uint16Array(dataLength);\n                break;\n            }\n            case 1: {\n                data = new Float32Array(dataLength);\n                break;\n            }\n        }\n        for (let i = imageData.length; i < mipmapsCount; i++) {\n            for (let face = 0; face < 6; face++) {\n                engine._uploadArrayBufferViewToTexture(cubeRtt?.texture || texture, data, face, i);\n            }\n        }\n    }\n    // Release temp RTT.\n    if (cubeRtt) {\n        const irradiance = texture._irradianceTexture;\n        texture._irradianceTexture = null;\n        engine._releaseTexture(texture);\n        cubeRtt._swapAndDie(texture);\n        texture._irradianceTexture = irradiance;\n    }\n    // Release temp Post Process.\n    if (rgbdPostProcess) {\n        rgbdPostProcess.dispose();\n    }\n    // Flag internal texture as ready in case they are in use.\n    if (generateNonLODTextures) {\n        if (texture._lodTextureHigh && texture._lodTextureHigh._texture) {\n            texture._lodTextureHigh._texture.isReady = true;\n        }\n        if (texture._lodTextureMid && texture._lodTextureMid._texture) {\n            texture._lodTextureMid._texture.isReady = true;\n        }\n        if (texture._lodTextureLow && texture._lodTextureLow._texture) {\n            texture._lodTextureLow._texture.isReady = true;\n        }\n    }\n}\n/**\n * Uploads spherical polynomials information to the texture.\n * @param texture defines the texture we are trying to upload the information to\n * @param info defines the environment texture info retrieved through the GetEnvInfo method\n */\nexport function UploadEnvSpherical(texture, info) {\n    info = normalizeEnvInfo(info);\n    const irradianceInfo = info.irradiance;\n    if (!irradianceInfo) {\n        return;\n    }\n    const sp = new SphericalPolynomial();\n    Vector3.FromArrayToRef(irradianceInfo.x, 0, sp.x);\n    Vector3.FromArrayToRef(irradianceInfo.y, 0, sp.y);\n    Vector3.FromArrayToRef(irradianceInfo.z, 0, sp.z);\n    Vector3.FromArrayToRef(irradianceInfo.xx, 0, sp.xx);\n    Vector3.FromArrayToRef(irradianceInfo.yy, 0, sp.yy);\n    Vector3.FromArrayToRef(irradianceInfo.zz, 0, sp.zz);\n    Vector3.FromArrayToRef(irradianceInfo.yz, 0, sp.yz);\n    Vector3.FromArrayToRef(irradianceInfo.zx, 0, sp.zx);\n    Vector3.FromArrayToRef(irradianceInfo.xy, 0, sp.xy);\n    texture._sphericalPolynomial = sp;\n}\n/**\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\nexport function _UpdateRGBDAsync(internalTexture, data, sphericalPolynomial, lodScale, lodOffset) {\n    const proxy = internalTexture\n        .getEngine()\n        .createRawCubeTexture(null, internalTexture.width, internalTexture.format, internalTexture.type, internalTexture.generateMipMaps, internalTexture.invertY, internalTexture.samplingMode, internalTexture._compression);\n    // eslint-disable-next-line github/no-then\n    const proxyPromise = UploadRadianceLevelsAsync(proxy, data).then(() => internalTexture);\n    internalTexture.onRebuildCallback = (_internalTexture) => {\n        return {\n            proxy: proxyPromise,\n            isReady: true,\n            isAsync: true,\n        };\n    };\n    internalTexture._source = 13 /* InternalTextureSource.CubeRawRGBD */;\n    internalTexture._bufferViewArrayArray = data;\n    internalTexture._lodGenerationScale = lodScale;\n    internalTexture._lodGenerationOffset = lodOffset;\n    internalTexture._sphericalPolynomial = sphericalPolynomial;\n    // eslint-disable-next-line github/no-then\n    return UploadRadianceLevelsAsync(internalTexture, data).then(() => {\n        internalTexture.isReady = true;\n        return internalTexture;\n    });\n}\n/**\n * Sets of helpers addressing the serialization and deserialization of environment texture\n * stored in a BabylonJS env file.\n * Those files are usually stored as .env files.\n */\nexport const EnvironmentTextureTools = {\n    /**\n     * Gets the environment info from an env file.\n     * @param data The array buffer containing the .env bytes.\n     * @returns the environment file info (the json header) if successfully parsed, normalized to the latest supported version.\n     */\n    GetEnvInfo,\n    /**\n     * Creates an environment texture from a loaded cube texture.\n     * @param texture defines the cube texture to convert in env file\n     * @param options options for the conversion process\n     * @param options.imageType the mime type for the encoded images, with support for \"image/png\" (default) and \"image/webp\"\n     * @param options.imageQuality the image quality of encoded WebP images.\n     * @returns a promise containing the environment data if successful.\n     */\n    CreateEnvTextureAsync,\n    /**\n     * Creates the ArrayBufferViews used for initializing environment texture image data.\n     * @param data the image data\n     * @param info parameters that determine what views will be created for accessing the underlying buffer\n     * @returns the views described by info providing access to the underlying buffer\n     */\n    CreateRadianceImageDataArrayBufferViews,\n    /**\n     * Creates the ArrayBufferViews used for initializing environment texture image data.\n     * @param data the image data\n     * @param info parameters that determine what views will be created for accessing the underlying buffer\n     * @returns the views described by info providing access to the underlying buffer\n     */\n    CreateIrradianceImageDataArrayBufferViews,\n    /**\n     * Uploads the texture info contained in the env file to the GPU.\n     * @param texture defines the internal texture to upload to\n     * @param data defines the data to load\n     * @param info defines the texture info retrieved through the GetEnvInfo method\n     * @returns a promise\n     */\n    UploadEnvLevelsAsync,\n    /**\n     * Uploads the levels of image data to the GPU.\n     * @param texture defines the internal texture to upload to\n     * @param imageData defines the array buffer views of image data [mipmap][face]\n     * @param imageType the mime type of the image data\n     * @returns a promise\n     */\n    UploadRadianceLevelsAsync,\n    /**\n     * Uploads the levels of image data to the GPU.\n     * @param texture defines the internal texture to upload to\n     * @param imageData defines the array buffer views of image data [mipmap][face]\n     * @param imageType the mime type of the image data\n     * @param dominantDirection the dominant direction of light in the environment texture, if available\n     * @returns a promise\n     */\n    UploadIrradianceLevelsAsync,\n    /**\n     * Uploads spherical polynomials information to the texture.\n     * @param texture defines the texture we are trying to upload the information to\n     * @param info defines the environment texture info retrieved through the GetEnvInfo method\n     */\n    UploadEnvSpherical,\n};\n//# sourceMappingURL=environmentTextureTools.js.map","import { GetEnvInfo, UploadEnvLevelsAsync, UploadEnvSpherical } from \"../../../Misc/environmentTextureTools.js\";\n/**\n * Implementation of the ENV Texture Loader.\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport class _ENVTextureLoader {\n    constructor() {\n        /**\n         * Defines whether the loader supports cascade loading the different faces.\n         */\n        this.supportCascades = false;\n    }\n    /**\n     * Uploads the cube texture data to the WebGL texture. It has already been bound.\n     * @param data contains the texture data\n     * @param texture defines the BabylonJS internal texture\n     * @param createPolynomials will be true if polynomials have been requested\n     * @param onLoad defines the callback to trigger once the texture is ready\n     * @param onError defines the callback to trigger in case of error\n     */\n    loadCubeData(data, texture, createPolynomials, onLoad, onError) {\n        if (Array.isArray(data)) {\n            return;\n        }\n        const info = GetEnvInfo(data);\n        if (info) {\n            texture.width = info.width;\n            texture.height = info.width;\n            try {\n                UploadEnvSpherical(texture, info);\n                // eslint-disable-next-line github/no-then\n                UploadEnvLevelsAsync(texture, data, info).then(() => {\n                    texture.isReady = true;\n                    texture.onLoadedObservable.notifyObservers(texture);\n                    texture.onLoadedObservable.clear();\n                    if (onLoad) {\n                        onLoad();\n                    }\n                }, (reason) => {\n                    onError?.(\"Can not upload environment levels\", reason);\n                });\n            }\n            catch (e) {\n                onError?.(\"Can not upload environment file\", e);\n            }\n        }\n        else if (onError) {\n            onError(\"Can not parse the environment file\", null);\n        }\n    }\n    /**\n     * Uploads the 2D texture data to the WebGL texture. It has already been bound once in the callback.\n     */\n    loadData() {\n        // eslint-disable-next-line no-throw-literal\n        throw \".env not supported in 2d.\";\n    }\n}\n//# sourceMappingURL=envTextureLoader.js.map"],"names":["DefaultEnvironmentTextureImageType","CurrentVersion","MagicBytes","GetEnvInfo","data","dataView","pos","i","Logger","manifestString","charCode","manifest","normalizeEnvInfo","info","CreateRadianceImageDataArrayBufferViews","specularInfo","mipmapsCount","imageData","face","imageInfo","CreateIrradianceImageDataArrayBufferViews","irradianceTexture","_a","UploadEnvLevelsAsync","texture","promises","radianceImageData","UploadRadianceLevelsAsync","irradianceImageData","dominantDirection","_c","_b","Vector3","UploadIrradianceLevelsAsync","_OnImageReadyAsync","image","engine","expandTexture","rgbdPostProcess","url","generateNonLODTextures","lodTextures","cubeRtt","resolve","reject","tempTexture","message","effect","lodTexture","imageType","_UploadLevelsAsync","mainTexture","size","InternalTexture","baseTexture","BaseTexture","canGenerateNonLODTextures","Tools","ILog2","caps","shaderLanguage","PostProcess","scale","offset","roughness","minLODIndex","maxLODIndex","lodIndex","mipmapIndex","glTextureFromLod","bytes","blob","promise","img","reason","error","dataLength","irradiance","UploadEnvSpherical","irradianceInfo","sp","SphericalPolynomial","_ENVTextureLoader","createPolynomials","onLoad","onError","e"],"mappings":"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","x_google_ignoreList":[0,1]}