@babylonjs/viewer 7.42.0 → 7.44.0

package/dist/chunks/dumpTools-JfWNUHd1.esm.js

@@ -0,0 +1,200 @@
+import { br as Clamp, C as Constants, T as Tools, ab as EngineStore, bs as EffectRenderer, bt as EffectWrapper } from './index-D46Rc8Qa.esm.js';
+
+let _dumpToolsEngine;
+let _enginePromise = null;
+async function _CreateDumpRenderer() {
+    if (!_enginePromise) {
+        _enginePromise = new Promise((resolve, reject) => {
+            let canvas;
+            let engine = null;
+            const options = {
+                preserveDrawingBuffer: true,
+                depth: false,
+                stencil: false,
+                alpha: true,
+                premultipliedAlpha: false,
+                antialias: false,
+                failIfMajorPerformanceCaveat: false,
+            };
+            import('./index-D46Rc8Qa.esm.js').then(function (n) { return n.bN; })
+                .then(({ ThinEngine: thinEngineClass }) => {
+                try {
+                    canvas = new OffscreenCanvas(100, 100); // will be resized later
+                    engine = new thinEngineClass(canvas, false, options);
+                }
+                catch (e) {
+                    // The browser either does not support OffscreenCanvas or WebGL context in OffscreenCanvas, fallback on a regular canvas
+                    canvas = document.createElement("canvas");
+                    engine = new thinEngineClass(canvas, false, options);
+                }
+                // remove this engine from the list of instances to avoid using it for other purposes
+                EngineStore.Instances.pop();
+                // However, make sure to dispose it when no other engines are left
+                EngineStore.OnEnginesDisposedObservable.add((e) => {
+                    // guaranteed to run when no other instances are left
+                    // only dispose if it's not the current engine
+                    if (engine && e !== engine && !engine.isDisposed && EngineStore.Instances.length === 0) {
+                        // Dump the engine and the associated resources
+                        Dispose();
+                    }
+                });
+                engine.getCaps().parallelShaderCompile = undefined;
+                const renderer = new EffectRenderer(engine);
+                import('./pass.fragment-BgXOqRns.esm.js').then(({ passPixelShader }) => {
+                    if (!engine) {
+                        reject("Engine is not defined");
+                        return;
+                    }
+                    const wrapper = new EffectWrapper({
+                        engine,
+                        name: passPixelShader.name,
+                        fragmentShader: passPixelShader.shader,
+                        samplerNames: ["textureSampler"],
+                    });
+                    _dumpToolsEngine = {
+                        canvas,
+                        engine,
+                        renderer,
+                        wrapper,
+                    };
+                    resolve(_dumpToolsEngine);
+                });
+            })
+                .catch(reject);
+        });
+    }
+    return await _enginePromise;
+}
+/**
+ * Dumps the current bound framebuffer
+ * @param width defines the rendering width
+ * @param height defines the rendering height
+ * @param engine defines the hosting engine
+ * @param successCallback defines the callback triggered once the data are available
+ * @param mimeType defines the mime type of the result
+ * @param fileName defines the filename to download. If present, the result will automatically be downloaded
+ * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+ * @returns a void promise
+ */
+async function DumpFramebuffer(width, height, engine, successCallback, mimeType = "image/png", fileName, quality) {
+    // Read the contents of the framebuffer
+    const bufferView = await engine.readPixels(0, 0, width, height);
+    const data = new Uint8Array(bufferView.buffer);
+    DumpData(width, height, data, successCallback, mimeType, fileName, true, undefined, quality);
+}
+/**
+ * Dumps an array buffer
+ * @param width defines the rendering width
+ * @param height defines the rendering height
+ * @param data the data array
+ * @param mimeType defines the mime type of the result
+ * @param fileName defines the filename to download. If present, the result will automatically be downloaded
+ * @param invertY true to invert the picture in the Y dimension
+ * @param toArrayBuffer true to convert the data to an ArrayBuffer (encoded as `mimeType`) instead of a base64 string
+ * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+ * @returns a promise that resolve to the final data
+ */
+function DumpDataAsync(width, height, data, mimeType = "image/png", fileName, invertY = false, toArrayBuffer = false, quality) {
+    return new Promise((resolve) => {
+        DumpData(width, height, data, (result) => resolve(result), mimeType, fileName, invertY, toArrayBuffer, quality);
+    });
+}
+/**
+ * Dumps an array buffer
+ * @param width defines the rendering width
+ * @param height defines the rendering height
+ * @param data the data array
+ * @param successCallback defines the callback triggered once the data are available
+ * @param mimeType defines the mime type of the result
+ * @param fileName defines the filename to download. If present, the result will automatically be downloaded
+ * @param invertY true to invert the picture in the Y dimension
+ * @param toArrayBuffer true to convert the data to an ArrayBuffer (encoded as `mimeType`) instead of a base64 string
+ * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+ */
+function DumpData(width, height, data, successCallback, mimeType = "image/png", fileName, invertY = false, toArrayBuffer = false, quality) {
+    _CreateDumpRenderer().then((renderer) => {
+        renderer.engine.setSize(width, height, true);
+        // Convert if data are float32
+        if (data instanceof Float32Array) {
+            const data2 = new Uint8Array(data.length);
+            let n = data.length;
+            while (n--) {
+                const v = data[n];
+                data2[n] = Math.round(Clamp(v) * 255);
+            }
+            data = data2;
+        }
+        // Create the image
+        const texture = renderer.engine.createRawTexture(data, width, height, Constants.TEXTUREFORMAT_RGBA, false, !invertY, Constants.TEXTURE_NEAREST_NEAREST);
+        renderer.renderer.setViewport();
+        renderer.renderer.applyEffectWrapper(renderer.wrapper);
+        renderer.wrapper.effect._bindTexture("textureSampler", texture);
+        renderer.renderer.draw();
+        if (toArrayBuffer) {
+            Tools.ToBlob(renderer.canvas, (blob) => {
+                const fileReader = new FileReader();
+                fileReader.onload = (event) => {
+                    const arrayBuffer = event.target.result;
+                    if (successCallback) {
+                        successCallback(arrayBuffer);
+                    }
+                };
+                fileReader.readAsArrayBuffer(blob);
+            }, mimeType, quality);
+        }
+        else {
+            Tools.EncodeScreenshotCanvasData(renderer.canvas, successCallback, mimeType, fileName, quality);
+        }
+        texture.dispose();
+    });
+}
+/**
+ * Dispose the dump tools associated resources
+ */
+function Dispose() {
+    if (_dumpToolsEngine) {
+        _dumpToolsEngine.wrapper.dispose();
+        _dumpToolsEngine.renderer.dispose();
+        _dumpToolsEngine.engine.dispose();
+    }
+    else {
+        // in cases where the engine is not yet created, we need to wait for it to dispose it
+        _enginePromise?.then((dumpToolsEngine) => {
+            dumpToolsEngine.wrapper.dispose();
+            dumpToolsEngine.renderer.dispose();
+            dumpToolsEngine.engine.dispose();
+        });
+    }
+    _enginePromise = null;
+    _dumpToolsEngine = null;
+}
+/**
+ * Object containing a set of static utilities functions to dump data from a canvas
+ * @deprecated use functions
+ */
+const DumpTools = {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    DumpData,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    DumpDataAsync,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    DumpFramebuffer,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    Dispose,
+};
+/**
+ * This will be executed automatically for UMD and es5.
+ * If esm dev wants the side effects to execute they will have to run it manually
+ * Once we build native modules those need to be exported.
+ * @internal
+ */
+const initSideEffects = () => {
+    // References the dependencies.
+    Tools.DumpData = DumpData;
+    Tools.DumpDataAsync = DumpDataAsync;
+    Tools.DumpFramebuffer = DumpFramebuffer;
+};
+initSideEffects();
+
+export { Dispose, DumpData, DumpDataAsync, DumpFramebuffer, DumpTools };
+//# sourceMappingURL=dumpTools-JfWNUHd1.esm.js.map

package/dist/chunks/dumpTools-JfWNUHd1.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dumpTools-JfWNUHd1.esm.js","sources":["../../../../../dev/core/dist/Misc/dumpTools.js"],"sourcesContent":["import { Constants } from \"../Engines/constants\";\nimport { EffectRenderer, EffectWrapper } from \"../Materials/effectRenderer\";\nimport { Tools } from \"./tools\";\nimport { Clamp } from \"../Maths/math.scalar.functions\";\nimport { EngineStore } from \"../Engines/engineStore\";\nlet _dumpToolsEngine;\nlet _enginePromise = null;\nasync function _CreateDumpRenderer() {\n    if (!_enginePromise) {\n        _enginePromise = new Promise((resolve, reject) => {\n            let canvas;\n            let engine = null;\n            const options = {\n                preserveDrawingBuffer: true,\n                depth: false,\n                stencil: false,\n                alpha: true,\n                premultipliedAlpha: false,\n                antialias: false,\n                failIfMajorPerformanceCaveat: false,\n            };\n            import(\"../Engines/thinEngine\")\n                .then(({ ThinEngine: thinEngineClass }) => {\n                try {\n                    canvas = new OffscreenCanvas(100, 100); // will be resized later\n                    engine = new thinEngineClass(canvas, false, options);\n                }\n                catch (e) {\n                    // The browser either does not support OffscreenCanvas or WebGL context in OffscreenCanvas, fallback on a regular canvas\n                    canvas = document.createElement(\"canvas\");\n                    engine = new thinEngineClass(canvas, false, options);\n                }\n                // remove this engine from the list of instances to avoid using it for other purposes\n                EngineStore.Instances.pop();\n                // However, make sure to dispose it when no other engines are left\n                EngineStore.OnEnginesDisposedObservable.add((e) => {\n                    // guaranteed to run when no other instances are left\n                    // only dispose if it's not the current engine\n                    if (engine && e !== engine && !engine.isDisposed && EngineStore.Instances.length === 0) {\n                        // Dump the engine and the associated resources\n                        Dispose();\n                    }\n                });\n                engine.getCaps().parallelShaderCompile = undefined;\n                const renderer = new EffectRenderer(engine);\n                import(\"../Shaders/pass.fragment\").then(({ passPixelShader }) => {\n                    if (!engine) {\n                        reject(\"Engine is not defined\");\n                        return;\n                    }\n                    const wrapper = new EffectWrapper({\n                        engine,\n                        name: passPixelShader.name,\n                        fragmentShader: passPixelShader.shader,\n                        samplerNames: [\"textureSampler\"],\n                    });\n                    _dumpToolsEngine = {\n                        canvas,\n                        engine,\n                        renderer,\n                        wrapper,\n                    };\n                    resolve(_dumpToolsEngine);\n                });\n            })\n                .catch(reject);\n        });\n    }\n    return await _enginePromise;\n}\n/**\n * Dumps the current bound framebuffer\n * @param width defines the rendering width\n * @param height defines the rendering height\n * @param engine defines the hosting engine\n * @param successCallback defines the callback triggered once the data are available\n * @param mimeType defines the mime type of the result\n * @param fileName defines the filename to download. If present, the result will automatically be downloaded\n * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.\n * @returns a void promise\n */\nexport async function DumpFramebuffer(width, height, engine, successCallback, mimeType = \"image/png\", fileName, quality) {\n    // Read the contents of the framebuffer\n    const bufferView = await engine.readPixels(0, 0, width, height);\n    const data = new Uint8Array(bufferView.buffer);\n    DumpData(width, height, data, successCallback, mimeType, fileName, true, undefined, quality);\n}\n/**\n * Dumps an array buffer\n * @param width defines the rendering width\n * @param height defines the rendering height\n * @param data the data array\n * @param mimeType defines the mime type of the result\n * @param fileName defines the filename to download. If present, the result will automatically be downloaded\n * @param invertY true to invert the picture in the Y dimension\n * @param toArrayBuffer true to convert the data to an ArrayBuffer (encoded as `mimeType`) instead of a base64 string\n * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.\n * @returns a promise that resolve to the final data\n */\nexport function DumpDataAsync(width, height, data, mimeType = \"image/png\", fileName, invertY = false, toArrayBuffer = false, quality) {\n    return new Promise((resolve) => {\n        DumpData(width, height, data, (result) => resolve(result), mimeType, fileName, invertY, toArrayBuffer, quality);\n    });\n}\n/**\n * Dumps an array buffer\n * @param width defines the rendering width\n * @param height defines the rendering height\n * @param data the data array\n * @param successCallback defines the callback triggered once the data are available\n * @param mimeType defines the mime type of the result\n * @param fileName defines the filename to download. If present, the result will automatically be downloaded\n * @param invertY true to invert the picture in the Y dimension\n * @param toArrayBuffer true to convert the data to an ArrayBuffer (encoded as `mimeType`) instead of a base64 string\n * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.\n */\nexport function DumpData(width, height, data, successCallback, mimeType = \"image/png\", fileName, invertY = false, toArrayBuffer = false, quality) {\n    _CreateDumpRenderer().then((renderer) => {\n        renderer.engine.setSize(width, height, true);\n        // Convert if data are float32\n        if (data instanceof Float32Array) {\n            const data2 = new Uint8Array(data.length);\n            let n = data.length;\n            while (n--) {\n                const v = data[n];\n                data2[n] = Math.round(Clamp(v) * 255);\n            }\n            data = data2;\n        }\n        // Create the image\n        const texture = renderer.engine.createRawTexture(data, width, height, Constants.TEXTUREFORMAT_RGBA, false, !invertY, Constants.TEXTURE_NEAREST_NEAREST);\n        renderer.renderer.setViewport();\n        renderer.renderer.applyEffectWrapper(renderer.wrapper);\n        renderer.wrapper.effect._bindTexture(\"textureSampler\", texture);\n        renderer.renderer.draw();\n        if (toArrayBuffer) {\n            Tools.ToBlob(renderer.canvas, (blob) => {\n                const fileReader = new FileReader();\n                fileReader.onload = (event) => {\n                    const arrayBuffer = event.target.result;\n                    if (successCallback) {\n                        successCallback(arrayBuffer);\n                    }\n                };\n                fileReader.readAsArrayBuffer(blob);\n            }, mimeType, quality);\n        }\n        else {\n            Tools.EncodeScreenshotCanvasData(renderer.canvas, successCallback, mimeType, fileName, quality);\n        }\n        texture.dispose();\n    });\n}\n/**\n * Dispose the dump tools associated resources\n */\nexport function Dispose() {\n    if (_dumpToolsEngine) {\n        _dumpToolsEngine.wrapper.dispose();\n        _dumpToolsEngine.renderer.dispose();\n        _dumpToolsEngine.engine.dispose();\n    }\n    else {\n        // in cases where the engine is not yet created, we need to wait for it to dispose it\n        _enginePromise?.then((dumpToolsEngine) => {\n            dumpToolsEngine.wrapper.dispose();\n            dumpToolsEngine.renderer.dispose();\n            dumpToolsEngine.engine.dispose();\n        });\n    }\n    _enginePromise = null;\n    _dumpToolsEngine = null;\n}\n/**\n * Object containing a set of static utilities functions to dump data from a canvas\n * @deprecated use functions\n */\nexport const DumpTools = {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    DumpData,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    DumpDataAsync,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    DumpFramebuffer,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    Dispose,\n};\n/**\n * This will be executed automatically for UMD and es5.\n * If esm dev wants the side effects to execute they will have to run it manually\n * Once we build native modules those need to be exported.\n * @internal\n */\nconst initSideEffects = () => {\n    // References the dependencies.\n    Tools.DumpData = DumpData;\n    Tools.DumpDataAsync = DumpDataAsync;\n    Tools.DumpFramebuffer = DumpFramebuffer;\n};\ninitSideEffects();\n//# sourceMappingURL=dumpTools.js.map"],"names":[],"mappings":"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"}

package/dist/chunks/dumpTools-MGQM1tV4.esm.min.js

@@ -0,0 +1,2 @@
+import{br as e,C as n,T as a,ab as r,bs as s,bt as t}from"./index-r5IGv8fd.esm.min.js";let i,p=null;async function o(e,n,a,r,s="image/png",t,i){const p=await a.readPixels(0,0,e,n);d(e,n,new Uint8Array(p.buffer),r,s,t,!0,void 0,i)}function c(e,n,a,r="image/png",s,t=!1,i=!1,p){return new Promise((o=>{d(e,n,a,(e=>o(e)),r,s,t,i,p)}))}function d(o,c,d,m,f="image/png",u,g=!1,w=!1,h){(async function(){return p||(p=new Promise(((e,n)=>{let a,p=null;const o={preserveDrawingBuffer:!0,depth:!1,stencil:!1,alpha:!0,premultipliedAlpha:!1,antialias:!1,failIfMajorPerformanceCaveat:!1};import("./index-r5IGv8fd.esm.min.js").then((function(e){return e.bN})).then((({ThinEngine:c})=>{try{a=new OffscreenCanvas(100,100),p=new c(a,!1,o)}catch(e){a=document.createElement("canvas"),p=new c(a,!1,o)}r.Instances.pop(),r.OnEnginesDisposedObservable.add((e=>{p&&e!==p&&!p.isDisposed&&0===r.Instances.length&&l()})),p.getCaps().parallelShaderCompile=void 0;const d=new s(p);import("./pass.fragment-Dqmp3CRB.esm.min.js").then((({passPixelShader:r})=>{if(!p)return void n("Engine is not defined");const s=new t({engine:p,name:r.name,fragmentShader:r.shader,samplerNames:["textureSampler"]});i={canvas:a,engine:p,renderer:d,wrapper:s},e(i)}))})).catch(n)}))),await p})().then((r=>{if(r.engine.setSize(o,c,!0),d instanceof Float32Array){const n=new Uint8Array(d.length);let a=d.length;for(;a--;){const r=d[a];n[a]=Math.round(255*e(r))}d=n}const s=r.engine.createRawTexture(d,o,c,n.TEXTUREFORMAT_RGBA,!1,!g,n.TEXTURE_NEAREST_NEAREST);r.renderer.setViewport(),r.renderer.applyEffectWrapper(r.wrapper),r.wrapper.effect._bindTexture("textureSampler",s),r.renderer.draw(),w?a.ToBlob(r.canvas,(e=>{const n=new FileReader;n.onload=e=>{const n=e.target.result;m&&m(n)},n.readAsArrayBuffer(e)}),f,h):a.EncodeScreenshotCanvasData(r.canvas,m,f,u,h),s.dispose()}))}function l(){i?(i.wrapper.dispose(),i.renderer.dispose(),i.engine.dispose()):p?.then((e=>{e.wrapper.dispose(),e.renderer.dispose(),e.engine.dispose()})),p=null,i=null}const m={DumpData:d,DumpDataAsync:c,DumpFramebuffer:o,Dispose:l};a.DumpData=d,a.DumpDataAsync=c,a.DumpFramebuffer=o;export{l as Dispose,d as DumpData,c as DumpDataAsync,o as DumpFramebuffer,m as DumpTools};
+//# sourceMappingURL=dumpTools-MGQM1tV4.esm.min.js.map

package/dist/chunks/dumpTools-MGQM1tV4.esm.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dumpTools-MGQM1tV4.esm.min.js","sources":["../../../../../dev/core/dist/Misc/dumpTools.js"],"sourcesContent":["import { Constants } from \"../Engines/constants\";\nimport { EffectRenderer, EffectWrapper } from \"../Materials/effectRenderer\";\nimport { Tools } from \"./tools\";\nimport { Clamp } from \"../Maths/math.scalar.functions\";\nimport { EngineStore } from \"../Engines/engineStore\";\nlet _dumpToolsEngine;\nlet _enginePromise = null;\nasync function _CreateDumpRenderer() {\n    if (!_enginePromise) {\n        _enginePromise = new Promise((resolve, reject) => {\n            let canvas;\n            let engine = null;\n            const options = {\n                preserveDrawingBuffer: true,\n                depth: false,\n                stencil: false,\n                alpha: true,\n                premultipliedAlpha: false,\n                antialias: false,\n                failIfMajorPerformanceCaveat: false,\n            };\n            import(\"../Engines/thinEngine\")\n                .then(({ ThinEngine: thinEngineClass }) => {\n                try {\n                    canvas = new OffscreenCanvas(100, 100); // will be resized later\n                    engine = new thinEngineClass(canvas, false, options);\n                }\n                catch (e) {\n                    // The browser either does not support OffscreenCanvas or WebGL context in OffscreenCanvas, fallback on a regular canvas\n                    canvas = document.createElement(\"canvas\");\n                    engine = new thinEngineClass(canvas, false, options);\n                }\n                // remove this engine from the list of instances to avoid using it for other purposes\n                EngineStore.Instances.pop();\n                // However, make sure to dispose it when no other engines are left\n                EngineStore.OnEnginesDisposedObservable.add((e) => {\n                    // guaranteed to run when no other instances are left\n                    // only dispose if it's not the current engine\n                    if (engine && e !== engine && !engine.isDisposed && EngineStore.Instances.length === 0) {\n                        // Dump the engine and the associated resources\n                        Dispose();\n                    }\n                });\n                engine.getCaps().parallelShaderCompile = undefined;\n                const renderer = new EffectRenderer(engine);\n                import(\"../Shaders/pass.fragment\").then(({ passPixelShader }) => {\n                    if (!engine) {\n                        reject(\"Engine is not defined\");\n                        return;\n                    }\n                    const wrapper = new EffectWrapper({\n                        engine,\n                        name: passPixelShader.name,\n                        fragmentShader: passPixelShader.shader,\n                        samplerNames: [\"textureSampler\"],\n                    });\n                    _dumpToolsEngine = {\n                        canvas,\n                        engine,\n                        renderer,\n                        wrapper,\n                    };\n                    resolve(_dumpToolsEngine);\n                });\n            })\n                .catch(reject);\n        });\n    }\n    return await _enginePromise;\n}\n/**\n * Dumps the current bound framebuffer\n * @param width defines the rendering width\n * @param height defines the rendering height\n * @param engine defines the hosting engine\n * @param successCallback defines the callback triggered once the data are available\n * @param mimeType defines the mime type of the result\n * @param fileName defines the filename to download. If present, the result will automatically be downloaded\n * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.\n * @returns a void promise\n */\nexport async function DumpFramebuffer(width, height, engine, successCallback, mimeType = \"image/png\", fileName, quality) {\n    // Read the contents of the framebuffer\n    const bufferView = await engine.readPixels(0, 0, width, height);\n    const data = new Uint8Array(bufferView.buffer);\n    DumpData(width, height, data, successCallback, mimeType, fileName, true, undefined, quality);\n}\n/**\n * Dumps an array buffer\n * @param width defines the rendering width\n * @param height defines the rendering height\n * @param data the data array\n * @param mimeType defines the mime type of the result\n * @param fileName defines the filename to download. If present, the result will automatically be downloaded\n * @param invertY true to invert the picture in the Y dimension\n * @param toArrayBuffer true to convert the data to an ArrayBuffer (encoded as `mimeType`) instead of a base64 string\n * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.\n * @returns a promise that resolve to the final data\n */\nexport function DumpDataAsync(width, height, data, mimeType = \"image/png\", fileName, invertY = false, toArrayBuffer = false, quality) {\n    return new Promise((resolve) => {\n        DumpData(width, height, data, (result) => resolve(result), mimeType, fileName, invertY, toArrayBuffer, quality);\n    });\n}\n/**\n * Dumps an array buffer\n * @param width defines the rendering width\n * @param height defines the rendering height\n * @param data the data array\n * @param successCallback defines the callback triggered once the data are available\n * @param mimeType defines the mime type of the result\n * @param fileName defines the filename to download. If present, the result will automatically be downloaded\n * @param invertY true to invert the picture in the Y dimension\n * @param toArrayBuffer true to convert the data to an ArrayBuffer (encoded as `mimeType`) instead of a base64 string\n * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.\n */\nexport function DumpData(width, height, data, successCallback, mimeType = \"image/png\", fileName, invertY = false, toArrayBuffer = false, quality) {\n    _CreateDumpRenderer().then((renderer) => {\n        renderer.engine.setSize(width, height, true);\n        // Convert if data are float32\n        if (data instanceof Float32Array) {\n            const data2 = new Uint8Array(data.length);\n            let n = data.length;\n            while (n--) {\n                const v = data[n];\n                data2[n] = Math.round(Clamp(v) * 255);\n            }\n            data = data2;\n        }\n        // Create the image\n        const texture = renderer.engine.createRawTexture(data, width, height, Constants.TEXTUREFORMAT_RGBA, false, !invertY, Constants.TEXTURE_NEAREST_NEAREST);\n        renderer.renderer.setViewport();\n        renderer.renderer.applyEffectWrapper(renderer.wrapper);\n        renderer.wrapper.effect._bindTexture(\"textureSampler\", texture);\n        renderer.renderer.draw();\n        if (toArrayBuffer) {\n            Tools.ToBlob(renderer.canvas, (blob) => {\n                const fileReader = new FileReader();\n                fileReader.onload = (event) => {\n                    const arrayBuffer = event.target.result;\n                    if (successCallback) {\n                        successCallback(arrayBuffer);\n                    }\n                };\n                fileReader.readAsArrayBuffer(blob);\n            }, mimeType, quality);\n        }\n        else {\n            Tools.EncodeScreenshotCanvasData(renderer.canvas, successCallback, mimeType, fileName, quality);\n        }\n        texture.dispose();\n    });\n}\n/**\n * Dispose the dump tools associated resources\n */\nexport function Dispose() {\n    if (_dumpToolsEngine) {\n        _dumpToolsEngine.wrapper.dispose();\n        _dumpToolsEngine.renderer.dispose();\n        _dumpToolsEngine.engine.dispose();\n    }\n    else {\n        // in cases where the engine is not yet created, we need to wait for it to dispose it\n        _enginePromise?.then((dumpToolsEngine) => {\n            dumpToolsEngine.wrapper.dispose();\n            dumpToolsEngine.renderer.dispose();\n            dumpToolsEngine.engine.dispose();\n        });\n    }\n    _enginePromise = null;\n    _dumpToolsEngine = null;\n}\n/**\n * Object containing a set of static utilities functions to dump data from a canvas\n * @deprecated use functions\n */\nexport const DumpTools = {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    DumpData,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    DumpDataAsync,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    DumpFramebuffer,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    Dispose,\n};\n/**\n * This will be executed automatically for UMD and es5.\n * If esm dev wants the side effects to execute they will have to run it manually\n * Once we build native modules those need to be exported.\n * @internal\n */\nconst initSideEffects = () => {\n    // References the dependencies.\n    Tools.DumpData = DumpData;\n    Tools.DumpDataAsync = DumpDataAsync;\n    Tools.DumpFramebuffer = DumpFramebuffer;\n};\ninitSideEffects();\n//# sourceMappingURL=dumpTools.js.map"],"names":["_dumpToolsEngine","_enginePromise","async","DumpFramebuffer","width","height","engine","successCallback","mimeType","fileName","quality","bufferView","readPixels","DumpData","Uint8Array","buffer","undefined","DumpDataAsync","data","invertY","toArrayBuffer","Promise","resolve","result","reject","canvas","options","preserveDrawingBuffer","depth","stencil","alpha","premultipliedAlpha","antialias","failIfMajorPerformanceCaveat","import","then","n","bN","ThinEngine","thinEngineClass","OffscreenCanvas","e","document","createElement","EngineStore","Instances","pop","OnEnginesDisposedObservable","add","isDisposed","length","Dispose","getCaps","parallelShaderCompile","renderer","EffectRenderer","passPixelShader","wrapper","EffectWrapper","name","fragmentShader","shader","samplerNames","catch","_CreateDumpRenderer","setSize","Float32Array","data2","v","Math","round","Clamp","texture","createRawTexture","Constants","TEXTUREFORMAT_RGBA","TEXTURE_NEAREST_NEAREST","setViewport","applyEffectWrapper","effect","_bindTexture","draw","Tools","ToBlob","blob","fileReader","FileReader","onload","event","arrayBuffer","target","readAsArrayBuffer","EncodeScreenshotCanvasData","dispose","dumpToolsEngine","DumpTools"],"mappings":"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"}

package/dist/chunks/envTextureLoader-CoD9RkFy.esm.js

@@ -0,0 +1,64 @@
+import { G as GetEnvInfo, U as UploadEnvSpherical, a as UploadEnvLevelsAsync } from './environmentTextureTools-DMKf2lIW.esm.js';
+import './index-D46Rc8Qa.esm.js';
+import './dumpTools-JfWNUHd1.esm.js';
+
+/**
+ * Implementation of the ENV Texture Loader.
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+class _ENVTextureLoader {
+    constructor() {
+        /**
+         * Defines whether the loader supports cascade loading the different faces.
+         */
+        this.supportCascades = false;
+    }
+    /**
+     * 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(data, texture, createPolynomials, onLoad, onError) {
+        if (Array.isArray(data)) {
+            return;
+        }
+        const info = GetEnvInfo(data);
+        if (info) {
+            texture.width = info.width;
+            texture.height = info.width;
+            try {
+                UploadEnvSpherical(texture, info);
+                UploadEnvLevelsAsync(texture, data, info).then(() => {
+                    texture.isReady = true;
+                    texture.onLoadedObservable.notifyObservers(texture);
+                    texture.onLoadedObservable.clear();
+                    if (onLoad) {
+                        onLoad();
+                    }
+                }, (reason) => {
+                    onError?.("Can not upload environment levels", reason);
+                });
+            }
+            catch (e) {
+                onError?.("Can not upload environment file", e);
+            }
+        }
+        else if (onError) {
+            onError("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() {
+        // eslint-disable-next-line no-throw-literal
+        throw ".env not supported in 2d.";
+    }
+}
+
+export { _ENVTextureLoader };
+//# sourceMappingURL=envTextureLoader-CoD9RkFy.esm.js.map

package/dist/chunks/envTextureLoader-CoD9RkFy.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"envTextureLoader-CoD9RkFy.esm.js","sources":["../../../../../dev/core/dist/Materials/Textures/Loaders/envTextureLoader.js"],"sourcesContent":["import { GetEnvInfo, UploadEnvLevelsAsync, UploadEnvSpherical } from \"../../../Misc/environmentTextureTools\";\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                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":[],"mappings":";;;;AACA;AACA;AACA;AACA;AACA;AACO,MAAM,iBAAiB,CAAC;AAC/B,IAAI,WAAW,GAAG;AAClB;AACA;AACA;AACA,QAAQ,IAAI,CAAC,eAAe,GAAG,KAAK;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,OAAO,EAAE;AACpE,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;AACjC,YAAY;AACZ;AACA,QAAQ,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;AACrC,QAAQ,IAAI,IAAI,EAAE;AAClB,YAAY,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK;AACtC,YAAY,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK;AACvC,YAAY,IAAI;AAChB,gBAAgB,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC;AACjD,gBAAgB,oBAAoB,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM;AACrE,oBAAoB,OAAO,CAAC,OAAO,GAAG,IAAI;AAC1C,oBAAoB,OAAO,CAAC,kBAAkB,CAAC,eAAe,CAAC,OAAO,CAAC;AACvE,oBAAoB,OAAO,CAAC,kBAAkB,CAAC,KAAK,EAAE;AACtD,oBAAoB,IAAI,MAAM,EAAE;AAChC,wBAAwB,MAAM,EAAE;AAChC;AACA,iBAAiB,EAAE,CAAC,MAAM,KAAK;AAC/B,oBAAoB,OAAO,GAAG,mCAAmC,EAAE,MAAM,CAAC;AAC1E,iBAAiB,CAAC;AAClB;AACA,YAAY,OAAO,CAAC,EAAE;AACtB,gBAAgB,OAAO,GAAG,iCAAiC,EAAE,CAAC,CAAC;AAC/D;AACA;AACA,aAAa,IAAI,OAAO,EAAE;AAC1B,YAAY,OAAO,CAAC,oCAAoC,EAAE,IAAI,CAAC;AAC/D;AACA;AACA;AACA;AACA;AACA,IAAI,QAAQ,GAAG;AACf;AACA,QAAQ,MAAM,2BAA2B;AACzC;AACA;;;;"}

package/dist/chunks/envTextureLoader-_huqF4Iu.esm.min.js

@@ -0,0 +1,2 @@
+import{G as e,U as n,a as o}from"./environmentTextureTools-BFBrSyc_.esm.min.js";import"./index-r5IGv8fd.esm.min.js";import"./dumpTools-MGQM1tV4.esm.min.js";class t{constructor(){this.supportCascades=!1}loadCubeData(t,s,a,r,i){if(Array.isArray(t))return;const d=e(t);if(d){s.width=d.width,s.height=d.width;try{n(s,d),o(s,t,d).then((()=>{s.isReady=!0,s.onLoadedObservable.notifyObservers(s),s.onLoadedObservable.clear(),r&&r()}),(e=>{i?.("Can not upload environment levels",e)}))}catch(e){i?.("Can not upload environment file",e)}}else i&&i("Can not parse the environment file",null)}loadData(){throw".env not supported in 2d."}}export{t as _ENVTextureLoader};
+//# sourceMappingURL=envTextureLoader-_huqF4Iu.esm.min.js.map

package/dist/chunks/envTextureLoader-_huqF4Iu.esm.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"envTextureLoader-_huqF4Iu.esm.min.js","sources":["../../../../../dev/core/dist/Materials/Textures/Loaders/envTextureLoader.js"],"sourcesContent":["import { GetEnvInfo, UploadEnvLevelsAsync, UploadEnvSpherical } from \"../../../Misc/environmentTextureTools\";\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                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":["_ENVTextureLoader","constructor","this","supportCascades","loadCubeData","data","texture","createPolynomials","onLoad","onError","Array","isArray","info","GetEnvInfo","width","height","UploadEnvSpherical","UploadEnvLevelsAsync","then","isReady","onLoadedObservable","notifyObservers","clear","reason","e","loadData"],"mappings":"4JAMO,MAAMA,EACT,WAAAC,GAIIC,KAAKC,iBAAkB,CAC/B,CASI,YAAAC,CAAaC,EAAMC,EAASC,EAAmBC,EAAQC,GACnD,GAAIC,MAAMC,QAAQN,GACd,OAEJ,MAAMO,EAAOC,EAAWR,GACxB,GAAIO,EAAM,CACNN,EAAQQ,MAAQF,EAAKE,MACrBR,EAAQS,OAASH,EAAKE,MACtB,IACIE,EAAmBV,EAASM,GAC5BK,EAAqBX,EAASD,EAAMO,GAAMM,MAAK,KAC3CZ,EAAQa,SAAU,EAClBb,EAAQc,mBAAmBC,gBAAgBf,GAC3CA,EAAQc,mBAAmBE,QACvBd,GACAA,GACxB,IACoBe,IACAd,IAAU,oCAAqCc,EAAO,GAE1E,CACY,MAAOC,GACHf,IAAU,kCAAmCe,EAC7D,CACA,MACiBf,GACLA,EAAQ,qCAAsC,KAE1D,CAII,QAAAgB,GAEI,KAAM,2BACd"}

package/dist/chunks/environmentTextureTools-BFBrSyc_.esm.min.js

@@ -0,0 +1,2 @@
+import{L as e,T as t,I as r,C as n,bq as o,f as a,aj as i,u as s,y as l}from"./index-r5IGv8fd.esm.min.js";import"./dumpTools-MGQM1tV4.esm.min.js";const u="image/png",p=[134,22,135,150,246,214,150,54];function c(t){const r=new DataView(t.buffer,t.byteOffset,t.byteLength);let n=0;for(let t=0;t<p.length;t++)if(r.getUint8(n++)!==p[t])return e.Error("Not a babylon environment map"),null;let o="",a=0;for(;a=r.getUint8(n++);)o+=String.fromCharCode(a);let i=JSON.parse(o);return i=T(i),i.specular&&(i.specular.specularDataPosition=n,i.specular.lodGenerationScale=i.specular.lodGenerationScale||.8),i}function T(e){if(e.version>2)throw new Error(`Unsupported babylon environment map version "${e.version}". Latest supported version is "2".`);return 2===e.version?e:e={...e,version:2,imageType:u}}function d(e,t,r){const n=(r=T(r)).specular;if(!n)return Promise.resolve();e._lodGenerationScale=n.lodGenerationScale;const o=function(e,t){const r=(t=T(t)).specular;let n=Math.log2(t.width);if(n=Math.round(n)+1,r.mipmaps.length!==6*n)throw new Error(`Unsupported specular mipmaps number "${r.mipmaps.length}"`);const o=new Array(n);for(let t=0;t<n;t++){o[t]=new Array(6);for(let n=0;n<6;n++){const a=r.mipmaps[6*t+n];o[t][n]=new Uint8Array(e.buffer,e.byteOffset+r.specularDataPosition+a.position,a.length)}}return o}(t,r);return m(e,o,r.imageType)}function f(e,t,r,o,a,i,s,l,u,p,c){return new Promise(((T,d)=>{if(r){const r=t.createTexture(null,!0,!0,null,n.TEXTURE_NEAREST_SAMPLINGMODE,null,(e=>{d(e)}),e);o?.onEffectCreatedObservable.addOnce((n=>{n.executeWhenCompiled((()=>{o.externalTextureSamplerBinding=!0,o.onApply=n=>{n._bindTexture("textureSampler",r),n.setFloat2("scale",1,t._features.needsInvertingBitmap&&e instanceof ImageBitmap?-1:1)},t.scenes.length&&(t.scenes[0].postProcessManager.directRender([o],p,!0,i,s),t.restoreDefaultFramebuffer(),r.dispose(),URL.revokeObjectURL(a),T())}))}))}else{if(t._uploadImageToTexture(c,e,i,s),l){const r=u[s];r&&t._uploadImageToTexture(r._texture,e,i,0)}T()}}))}async function m(e,s,l=u){if(!t.IsExponentOfTwo(e.width))throw new Error("Texture size must be a power of two");const p=r(e.width)+1,c=e.getEngine();let T=!1,d=!1,m=null,_=null,y=null;const g=c.getCaps();e.format=n.TEXTUREFORMAT_RGBA,e.type=n.TEXTURETYPE_UNSIGNED_INT,e.generateMipMaps=!0,e._cachedAnisotropicFilteringLevel=null,c.updateTextureSamplingMode(n.TEXTURE_TRILINEAR_SAMPLINGMODE,e),g.textureLOD?c._features.supportRenderAndCopyToLodForFloatTextures?g.textureHalfFloatRender&&g.textureHalfFloatLinearFiltering?(T=!0,e.type=n.TEXTURETYPE_HALF_FLOAT):g.textureFloatRender&&g.textureFloatLinearFiltering&&(T=!0,e.type=n.TEXTURETYPE_FLOAT):T=!1:(T=!1,d=!0,y={});let x=0;if(T)c.isWebGPU?(x=1,await import("./rgbdDecode.fragment-CqcagT1x.esm.min.js")):await import("./rgbdDecode.fragment-C3AkoFAQ.esm.min.js"),m=new o("rgbdDecode","rgbdDecode",null,null,1,null,n.TEXTURE_TRILINEAR_SAMPLINGMODE,c,!1,void 0,e.type,void 0,null,!1,void 0,x),e._isRGBD=!1,e.invertY=!1,_=c.createRenderTargetCubeTexture(e.width,{generateDepthBuffer:!1,generateMipMaps:!0,generateStencilBuffer:!1,samplingMode:n.TEXTURE_TRILINEAR_SAMPLINGMODE,type:e.type,format:n.TEXTUREFORMAT_RGBA});else if(e._isRGBD=!0,e.invertY=!0,d){const t=3,r=e._lodGenerationScale,o=e._lodGenerationOffset;for(let s=0;s<t;s++){const l=(p-1)*r+o,u=o+(l-o)*(1-s/(t-1)),T=Math.round(Math.min(Math.max(u,0),l)),d=new a(c,2);d.isCube=!0,d.invertY=!0,d.generateMipMaps=!1,c.updateTextureSamplingMode(n.TEXTURE_LINEAR_LINEAR,d);const f=new i(null);switch(f._isCube=!0,f._texture=d,y[T]=f,s){case 0:e._lodTextureLow=f;break;case 1:e._lodTextureMid=f;break;case 2:e._lodTextureHigh=f}}}const E=[];for(let t=0;t<s.length;t++)for(let r=0;r<6;r++){const n=s[t][r],o=new Blob([n],{type:l}),a=URL.createObjectURL(o);let i;if(c._features.forceBitmapOverHTMLImageElement)i=c.createImageBitmap(o,{premultiplyAlpha:"none"}).then((n=>f(n,c,T,m,a,r,t,d,y,_,e)));else{const n=new Image;n.src=a,i=new Promise(((o,i)=>{n.onload=()=>{f(n,c,T,m,a,r,t,d,y,_,e).then((()=>o())).catch((e=>{i(e)}))},n.onerror=e=>{i(e)}}))}E.push(i)}if(s.length<p){let t;const r=Math.pow(2,p-1-s.length),o=r*r*4;switch(e.type){case n.TEXTURETYPE_UNSIGNED_INT:t=new Uint8Array(o);break;case n.TEXTURETYPE_HALF_FLOAT:t=new Uint16Array(o);break;case n.TEXTURETYPE_FLOAT:t=new Float32Array(o)}for(let r=s.length;r<p;r++)for(let n=0;n<6;n++)c._uploadArrayBufferViewToTexture(e,t,n,r)}return Promise.all(E).then((()=>{_&&(c._releaseTexture(e),_._swapAndDie(e)),m&&m.dispose(),d&&(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 _(e,t){const r=(t=T(t)).irradiance;if(!r)return;const n=new s;l.FromArrayToRef(r.x,0,n.x),l.FromArrayToRef(r.y,0,n.y),l.FromArrayToRef(r.z,0,n.z),l.FromArrayToRef(r.xx,0,n.xx),l.FromArrayToRef(r.yy,0,n.yy),l.FromArrayToRef(r.zz,0,n.zz),l.FromArrayToRef(r.yz,0,n.yz),l.FromArrayToRef(r.zx,0,n.zx),l.FromArrayToRef(r.xy,0,n.xy),e._sphericalPolynomial=n}function y(e,t,r,n,o){const a=m(e.getEngine().createRawCubeTexture(null,e.width,e.format,e.type,e.generateMipMaps,e.invertY,e.samplingMode,e._compression),t).then((()=>e));return e.onRebuildCallback=e=>({proxy:a,isReady:!0,isAsync:!0}),e._source=13,e._bufferViewArrayArray=t,e._lodGenerationScale=n,e._lodGenerationOffset=o,e._sphericalPolynomial=r,m(e,t).then((()=>(e.isReady=!0,e)))}export{c as G,_ as U,y as _,d as a};
+//# sourceMappingURL=environmentTextureTools-BFBrSyc_.esm.min.js.map

package/dist/chunks/environmentTextureTools-BFBrSyc_.esm.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"environmentTextureTools-BFBrSyc_.esm.min.js","sources":["../../../../../dev/core/dist/Misc/environmentTextureTools.js"],"sourcesContent":["import { Tools } from \"./tools\";\nimport { Vector3 } from \"../Maths/math.vector\";\nimport { ILog2 } from \"../Maths/math.scalar.functions\";\nimport { SphericalPolynomial } from \"../Maths/sphericalPolynomial\";\nimport { InternalTexture } from \"../Materials/Textures/internalTexture\";\nimport { BaseTexture } from \"../Materials/Textures/baseTexture\";\nimport { Constants } from \"../Engines/constants\";\nimport { Scene } from \"../scene\";\nimport { PostProcess } from \"../PostProcesses/postProcess\";\nimport { Logger } from \"../Misc/logger\";\nimport { RGBDTextureTools } from \"./rgbdTextureTools\";\nimport \"../Materials/Textures/baseTexture.polynomial\";\nimport { DumpDataAsync } from \"../Misc/dumpTools\";\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    if (manifest.specular) {\n        // Extend the header with the position of the payload.\n        manifest.specular.specularDataPosition = pos;\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 * @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 */\nexport async function CreateEnvTextureAsync(texture, options = {}) {\n    const internalTexture = texture.getInternalTexture();\n    if (!internalTexture) {\n        return Promise.reject(\"The cube texture is invalid.\");\n    }\n    const imageType = options.imageType ?? DefaultEnvironmentTextureImageType;\n    const engine = internalTexture.getEngine();\n    if (texture.textureType !== Constants.TEXTURETYPE_HALF_FLOAT &&\n        texture.textureType !== Constants.TEXTURETYPE_FLOAT &&\n        texture.textureType !== Constants.TEXTURETYPE_UNSIGNED_BYTE &&\n        texture.textureType !== Constants.TEXTURETYPE_UNSIGNED_BYTE &&\n        texture.textureType !== Constants.TEXTURETYPE_UNSIGNED_INTEGER &&\n        texture.textureType !== -1) {\n        return Promise.reject(\"The cube texture should allow HDR (Full Float or Half Float).\");\n    }\n    let textureType = Constants.TEXTURETYPE_FLOAT;\n    if (!engine.getCaps().textureFloatRender) {\n        textureType = Constants.TEXTURETYPE_HALF_FLOAT;\n        if (!engine.getCaps().textureHalfFloatRender) {\n            return 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    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    // 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    // 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            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 tempTexture = engine.createRawTexture(faceData, faceWidth, faceWidth, Constants.TEXTUREFORMAT_RGBA, false, true, Constants.TEXTURE_NEAREST_SAMPLINGMODE, null, textureType);\n            await RGBDTextureTools.EncodeTextureToRGBD(tempTexture, hostingScene, textureType);\n            const rgbdEncodedData = await engine._readTexturePixels(tempTexture, faceWidth, faceWidth);\n            const imageEncodedData = await DumpDataAsync(faceWidth, faceWidth, rgbdEncodedData, imageType, undefined, false, true, options.imageQuality);\n            specularTextures[i * 6 + face] = imageEncodedData;\n            tempTexture.dispose();\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    // 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 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    // Voila\n    return finalBuffer;\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 CreateImageDataArrayBufferViews(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 + specularInfo.specularDataPosition + 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 */\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 imageData = CreateImageDataArrayBufferViews(data, info);\n    return UploadLevelsAsync(texture, imageData, info.imageType);\n}\nfunction _OnImageReadyAsync(image, engine, expandTexture, rgbdPostProcess, url, face, i, generateNonLODTextures, lodTextures, cubeRtt, texture) {\n    return new Promise((resolve, reject) => {\n        if (expandTexture) {\n            const tempTexture = engine.createTexture(null, true, true, null, Constants.TEXTURE_NEAREST_SAMPLINGMODE, null, (message) => {\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 UploadLevelsAsync(texture, imageData, 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    texture.format = Constants.TEXTUREFORMAT_RGBA;\n    texture.type = Constants.TEXTURETYPE_UNSIGNED_INT;\n    texture.generateMipMaps = true;\n    texture._cachedAnisotropicFilteringLevel = null;\n    engine.updateTextureSamplingMode(Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, texture);\n    // Add extra process if texture lod is not supported\n    if (!caps.textureLOD) {\n        expandTexture = false;\n        generateNonLODTextures = true;\n        lodTextures = {};\n    }\n    // in webgl 1 there are no ways to either render or copy lod level information for float textures.\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 = Constants.TEXTURETYPE_HALF_FLOAT;\n    }\n    // If full float available we can uncompress the texture\n    else if (caps.textureFloatRender && caps.textureFloatLinearFiltering) {\n        expandTexture = true;\n        texture.type = Constants.TEXTURETYPE_FLOAT;\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\");\n        }\n        else {\n            await import(\"../Shaders/rgbdDecode.fragment\");\n        }\n        // Simply run through the decode PP\n        rgbdPostProcess = new PostProcess(\"rgbdDecode\", \"rgbdDecode\", null, null, 1, null, Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, 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: Constants.TEXTURE_TRILINEAR_SAMPLINGMODE,\n            type: texture.type,\n            format: Constants.TEXTUREFORMAT_RGBA,\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            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                const glTextureFromLod = new InternalTexture(engine, 2 /* InternalTextureSource.Temp */);\n                glTextureFromLod.isCube = true;\n                glTextureFromLod.invertY = true;\n                glTextureFromLod.generateMipMaps = false;\n                engine.updateTextureSamplingMode(Constants.TEXTURE_LINEAR_LINEAR, 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                promise = engine.createImageBitmap(blob, { premultiplyAlpha: \"none\" }).then((img) => {\n                    return _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                            .then(() => resolve())\n                            .catch((reason) => {\n                            reject(reason);\n                        });\n                    };\n                    image.onerror = (error) => {\n                        reject(error);\n                    };\n                });\n            }\n            promises.push(promise);\n        }\n    }\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 Constants.TEXTURETYPE_UNSIGNED_INT: {\n                data = new Uint8Array(dataLength);\n                break;\n            }\n            case Constants.TEXTURETYPE_HALF_FLOAT: {\n                data = new Uint16Array(dataLength);\n                break;\n            }\n            case Constants.TEXTURETYPE_FLOAT: {\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(texture, data, face, i);\n            }\n        }\n    }\n    // Once all done, finishes the cleanup and return\n    return Promise.all(promises).then(() => {\n        // Release temp RTT.\n        if (cubeRtt) {\n            engine._releaseTexture(texture);\n            cubeRtt._swapAndDie(texture);\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/**\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 */\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    const proxyPromise = UploadLevelsAsync(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    return UploadLevelsAsync(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    CreateImageDataArrayBufferViews,\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    UploadLevelsAsync,\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"],"names":["DefaultEnvironmentTextureImageType","MagicBytes","GetEnvInfo","data","dataView","DataView","buffer","byteOffset","byteLength","pos","i","length","getUint8","Logger","Error","manifestString","charCode","String","fromCharCode","manifest","JSON","parse","normalizeEnvInfo","specular","specularDataPosition","lodGenerationScale","info","version","imageType","UploadEnvLevelsAsync","texture","specularInfo","Promise","resolve","_lodGenerationScale","imageData","mipmapsCount","Math","log2","width","round","mipmaps","Array","face","imageInfo","Uint8Array","position","CreateImageDataArrayBufferViews","UploadLevelsAsync","_OnImageReadyAsync","image","engine","expandTexture","rgbdPostProcess","url","generateNonLODTextures","lodTextures","cubeRtt","reject","tempTexture","createTexture","Constants","TEXTURE_NEAREST_SAMPLINGMODE","message","onEffectCreatedObservable","addOnce","effect","executeWhenCompiled","externalTextureSamplerBinding","onApply","_bindTexture","setFloat2","_features","needsInvertingBitmap","ImageBitmap","scenes","postProcessManager","directRender","restoreDefaultFramebuffer","dispose","URL","revokeObjectURL","_uploadImageToTexture","lodTexture","_texture","async","Tools","IsExponentOfTwo","ILog2","getEngine","caps","getCaps","format","TEXTUREFORMAT_RGBA","type","TEXTURETYPE_UNSIGNED_INT","generateMipMaps","_cachedAnisotropicFilteringLevel","updateTextureSamplingMode","TEXTURE_TRILINEAR_SAMPLINGMODE","textureLOD","supportRenderAndCopyToLodForFloatTextures","textureHalfFloatRender","textureHalfFloatLinearFiltering","TEXTURETYPE_HALF_FLOAT","textureFloatRender","textureFloatLinearFiltering","TEXTURETYPE_FLOAT","shaderLanguage","isWebGPU","import","PostProcess","undefined","_isRGBD","invertY","createRenderTargetCubeTexture","generateDepthBuffer","generateStencilBuffer","samplingMode","mipSlices","scale","offset","_lodGenerationOffset","maxLODIndex","lodIndex","mipmapIndex","min","max","glTextureFromLod","InternalTexture","isCube","TEXTURE_LINEAR_LINEAR","BaseTexture","_isCube","_lodTextureLow","_lodTextureMid","_lodTextureHigh","promises","bytes","blob","Blob","createObjectURL","promise","forceBitmapOverHTMLImageElement","createImageBitmap","premultiplyAlpha","then","img","Image","src","onload","catch","reason","onerror","error","push","size","pow","dataLength","Uint16Array","Float32Array","_uploadArrayBufferViewToTexture","all","_releaseTexture","_swapAndDie","isReady","UploadEnvSpherical","irradianceInfo","irradiance","sp","SphericalPolynomial","Vector3","FromArrayToRef","x","y","z","xx","yy","zz","yz","zx","xy","_sphericalPolynomial","_UpdateRGBDAsync","internalTexture","sphericalPolynomial","lodScale","lodOffset","proxyPromise","createRawCubeTexture","_compression","onRebuildCallback","_internalTexture","proxy","isAsync","_source","_bufferViewArrayArray"],"mappings":"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"}