@babylonjs/viewer 7.25.1 → 7.25.2-alpha

package/dist/chunks/engine-sFOTJhn4.esm.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-sFOTJhn4.esm.min.js","sources":["../../../../../dev/core/dist/Misc/performanceMonitor.js","../../../../../dev/core/dist/Engines/engine.common.js","../../../../../dev/core/dist/Engines/Extensions/engine.alpha.js","../../../../../dev/core/dist/Engines/Extensions/engine.dynamicBuffer.js","../../../../../dev/core/dist/Engines/AbstractEngine/abstractEngine.loadingScreen.js","../../../../../dev/core/dist/Engines/AbstractEngine/abstractEngine.dom.js","../../../../../dev/core/dist/Engines/AbstractEngine/abstractEngine.alpha.js","../../../../../dev/core/dist/Engines/AbstractEngine/abstractEngine.states.js","../../../../../dev/core/dist/Engines/AbstractEngine/abstractEngine.renderPass.js","../../../../../dev/core/dist/Engines/engine.js"],"sourcesContent":["import { PrecisionDate } from \"./precisionDate\";\n/**\n * Performance monitor tracks rolling average frame-time and frame-time variance over a user defined sliding-window\n */\nexport class PerformanceMonitor {\n    /**\n     * constructor\n     * @param frameSampleSize The number of samples required to saturate the sliding window\n     */\n    constructor(frameSampleSize = 30) {\n        this._enabled = true;\n        this._rollingFrameTime = new RollingAverage(frameSampleSize);\n    }\n    /**\n     * Samples current frame\n     * @param timeMs A timestamp in milliseconds of the current frame to compare with other frames\n     */\n    sampleFrame(timeMs = PrecisionDate.Now) {\n        if (!this._enabled) {\n            return;\n        }\n        if (this._lastFrameTimeMs != null) {\n            const dt = timeMs - this._lastFrameTimeMs;\n            this._rollingFrameTime.add(dt);\n        }\n        this._lastFrameTimeMs = timeMs;\n    }\n    /**\n     * Returns the average frame time in milliseconds over the sliding window (or the subset of frames sampled so far)\n     */\n    get averageFrameTime() {\n        return this._rollingFrameTime.average;\n    }\n    /**\n     * Returns the variance frame time in milliseconds over the sliding window (or the subset of frames sampled so far)\n     */\n    get averageFrameTimeVariance() {\n        return this._rollingFrameTime.variance;\n    }\n    /**\n     * Returns the frame time of the most recent frame\n     */\n    get instantaneousFrameTime() {\n        return this._rollingFrameTime.history(0);\n    }\n    /**\n     * Returns the average framerate in frames per second over the sliding window (or the subset of frames sampled so far)\n     */\n    get averageFPS() {\n        return 1000.0 / this._rollingFrameTime.average;\n    }\n    /**\n     * Returns the average framerate in frames per second using the most recent frame time\n     */\n    get instantaneousFPS() {\n        const history = this._rollingFrameTime.history(0);\n        if (history === 0) {\n            return 0;\n        }\n        return 1000.0 / history;\n    }\n    /**\n     * Returns true if enough samples have been taken to completely fill the sliding window\n     */\n    get isSaturated() {\n        return this._rollingFrameTime.isSaturated();\n    }\n    /**\n     * Enables contributions to the sliding window sample set\n     */\n    enable() {\n        this._enabled = true;\n    }\n    /**\n     * Disables contributions to the sliding window sample set\n     * Samples will not be interpolated over the disabled period\n     */\n    disable() {\n        this._enabled = false;\n        //clear last sample to avoid interpolating over the disabled period when next enabled\n        this._lastFrameTimeMs = null;\n    }\n    /**\n     * Returns true if sampling is enabled\n     */\n    get isEnabled() {\n        return this._enabled;\n    }\n    /**\n     * Resets performance monitor\n     */\n    reset() {\n        //clear last sample to avoid interpolating over the disabled period when next enabled\n        this._lastFrameTimeMs = null;\n        //wipe record\n        this._rollingFrameTime.reset();\n    }\n}\n/**\n * RollingAverage\n *\n * Utility to efficiently compute the rolling average and variance over a sliding window of samples\n */\nexport class RollingAverage {\n    /**\n     * constructor\n     * @param length The number of samples required to saturate the sliding window\n     */\n    constructor(length) {\n        this._samples = new Array(length);\n        this.reset();\n    }\n    /**\n     * Adds a sample to the sample set\n     * @param v The sample value\n     */\n    add(v) {\n        //http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance\n        let delta;\n        //we need to check if we've already wrapped round\n        if (this.isSaturated()) {\n            //remove bottom of stack from mean\n            const bottomValue = this._samples[this._pos];\n            delta = bottomValue - this.average;\n            this.average -= delta / (this._sampleCount - 1);\n            this._m2 -= delta * (bottomValue - this.average);\n        }\n        else {\n            this._sampleCount++;\n        }\n        //add new value to mean\n        delta = v - this.average;\n        this.average += delta / this._sampleCount;\n        this._m2 += delta * (v - this.average);\n        //set the new variance\n        this.variance = this._m2 / (this._sampleCount - 1);\n        this._samples[this._pos] = v;\n        this._pos++;\n        this._pos %= this._samples.length; //positive wrap around\n    }\n    /**\n     * Returns previously added values or null if outside of history or outside the sliding window domain\n     * @param i Index in history. For example, pass 0 for the most recent value and 1 for the value before that\n     * @returns Value previously recorded with add() or null if outside of range\n     */\n    history(i) {\n        if (i >= this._sampleCount || i >= this._samples.length) {\n            return 0;\n        }\n        const i0 = this._wrapPosition(this._pos - 1.0);\n        return this._samples[this._wrapPosition(i0 - i)];\n    }\n    /**\n     * Returns true if enough samples have been taken to completely fill the sliding window\n     * @returns true if sample-set saturated\n     */\n    isSaturated() {\n        return this._sampleCount >= this._samples.length;\n    }\n    /**\n     * Resets the rolling average (equivalent to 0 samples taken so far)\n     */\n    reset() {\n        this.average = 0;\n        this.variance = 0;\n        this._sampleCount = 0;\n        this._pos = 0;\n        this._m2 = 0;\n    }\n    /**\n     * Wraps a value around the sample range boundaries\n     * @param i Position in sample range, for example if the sample length is 5, and i is -3, then 2 will be returned.\n     * @returns Wrapped position in sample range\n     */\n    _wrapPosition(i) {\n        const max = this._samples.length;\n        return ((i % max) + max) % max;\n    }\n}\n//# sourceMappingURL=performanceMonitor.js.map","import { IsDocumentAvailable } from \"../Misc/domManagement\";\nimport { AbstractEngine } from \"./abstractEngine\";\nimport { EngineStore } from \"./engineStore\";\n/** @internal */\nfunction _DisableTouchAction(canvas) {\n    if (!canvas || !canvas.setAttribute) {\n        return;\n    }\n    canvas.setAttribute(\"touch-action\", \"none\");\n    canvas.style.touchAction = \"none\";\n    canvas.style.webkitTapHighlightColor = \"transparent\";\n}\n/** @internal */\nexport function _CommonInit(commonEngine, canvas, creationOptions) {\n    commonEngine._onCanvasFocus = () => {\n        commonEngine.onCanvasFocusObservable.notifyObservers(commonEngine);\n    };\n    commonEngine._onCanvasBlur = () => {\n        commonEngine.onCanvasBlurObservable.notifyObservers(commonEngine);\n    };\n    commonEngine._onCanvasContextMenu = (evt) => {\n        if (commonEngine.disableContextMenu) {\n            evt.preventDefault();\n        }\n    };\n    canvas.addEventListener(\"focus\", commonEngine._onCanvasFocus);\n    canvas.addEventListener(\"blur\", commonEngine._onCanvasBlur);\n    canvas.addEventListener(\"contextmenu\", commonEngine._onCanvasContextMenu);\n    commonEngine._onBlur = () => {\n        if (commonEngine.disablePerformanceMonitorInBackground) {\n            commonEngine.performanceMonitor.disable();\n        }\n        commonEngine._windowIsBackground = true;\n    };\n    commonEngine._onFocus = () => {\n        if (commonEngine.disablePerformanceMonitorInBackground) {\n            commonEngine.performanceMonitor.enable();\n        }\n        commonEngine._windowIsBackground = false;\n    };\n    commonEngine._onCanvasPointerOut = (ev) => {\n        // Check that the element at the point of the pointer out isn't the canvas and if it isn't, notify observers\n        // Note: This is a workaround for a bug with Safari\n        if (document.elementFromPoint(ev.clientX, ev.clientY) !== canvas) {\n            commonEngine.onCanvasPointerOutObservable.notifyObservers(ev);\n        }\n    };\n    const hostWindow = commonEngine.getHostWindow(); // it calls IsWindowObjectExist()\n    if (hostWindow && typeof hostWindow.addEventListener === \"function\") {\n        hostWindow.addEventListener(\"blur\", commonEngine._onBlur);\n        hostWindow.addEventListener(\"focus\", commonEngine._onFocus);\n    }\n    canvas.addEventListener(\"pointerout\", commonEngine._onCanvasPointerOut);\n    if (!creationOptions.doNotHandleTouchAction) {\n        _DisableTouchAction(canvas);\n    }\n    // Create Audio Engine if needed.\n    if (!AbstractEngine.audioEngine && creationOptions.audioEngine && AbstractEngine.AudioEngineFactory) {\n        AbstractEngine.audioEngine = AbstractEngine.AudioEngineFactory(commonEngine.getRenderingCanvas(), commonEngine.getAudioContext(), commonEngine.getAudioDestination());\n    }\n    if (IsDocumentAvailable()) {\n        // Fullscreen\n        commonEngine._onFullscreenChange = () => {\n            commonEngine.isFullscreen = !!document.fullscreenElement;\n            // Pointer lock\n            if (commonEngine.isFullscreen && commonEngine._pointerLockRequested && canvas) {\n                RequestPointerlock(canvas);\n            }\n        };\n        document.addEventListener(\"fullscreenchange\", commonEngine._onFullscreenChange, false);\n        document.addEventListener(\"webkitfullscreenchange\", commonEngine._onFullscreenChange, false);\n        // Pointer lock\n        commonEngine._onPointerLockChange = () => {\n            commonEngine.isPointerLock = document.pointerLockElement === canvas;\n        };\n        document.addEventListener(\"pointerlockchange\", commonEngine._onPointerLockChange, false);\n        document.addEventListener(\"webkitpointerlockchange\", commonEngine._onPointerLockChange, false);\n    }\n    commonEngine.enableOfflineSupport = AbstractEngine.OfflineProviderFactory !== undefined;\n    commonEngine._deterministicLockstep = !!creationOptions.deterministicLockstep;\n    commonEngine._lockstepMaxSteps = creationOptions.lockstepMaxSteps || 0;\n    commonEngine._timeStep = creationOptions.timeStep || 1 / 60;\n}\n/** @internal */\nexport function _CommonDispose(commonEngine, canvas) {\n    // Release audio engine\n    if (EngineStore.Instances.length === 1 && AbstractEngine.audioEngine) {\n        AbstractEngine.audioEngine.dispose();\n        AbstractEngine.audioEngine = null;\n    }\n    // Events\n    const hostWindow = commonEngine.getHostWindow(); // it calls IsWindowObjectExist()\n    if (hostWindow && typeof hostWindow.removeEventListener === \"function\") {\n        hostWindow.removeEventListener(\"blur\", commonEngine._onBlur);\n        hostWindow.removeEventListener(\"focus\", commonEngine._onFocus);\n    }\n    if (canvas) {\n        canvas.removeEventListener(\"focus\", commonEngine._onCanvasFocus);\n        canvas.removeEventListener(\"blur\", commonEngine._onCanvasBlur);\n        canvas.removeEventListener(\"pointerout\", commonEngine._onCanvasPointerOut);\n        canvas.removeEventListener(\"contextmenu\", commonEngine._onCanvasContextMenu);\n    }\n    if (IsDocumentAvailable()) {\n        document.removeEventListener(\"fullscreenchange\", commonEngine._onFullscreenChange);\n        document.removeEventListener(\"mozfullscreenchange\", commonEngine._onFullscreenChange);\n        document.removeEventListener(\"webkitfullscreenchange\", commonEngine._onFullscreenChange);\n        document.removeEventListener(\"msfullscreenchange\", commonEngine._onFullscreenChange);\n        document.removeEventListener(\"pointerlockchange\", commonEngine._onPointerLockChange);\n        document.removeEventListener(\"mspointerlockchange\", commonEngine._onPointerLockChange);\n        document.removeEventListener(\"mozpointerlockchange\", commonEngine._onPointerLockChange);\n        document.removeEventListener(\"webkitpointerlockchange\", commonEngine._onPointerLockChange);\n    }\n}\n/**\n * Get Font size information\n * @param font font name\n * @returns an object containing ascent, height and descent\n */\nexport function GetFontOffset(font) {\n    const text = document.createElement(\"span\");\n    text.textContent = \"Hg\";\n    text.style.font = font;\n    const block = document.createElement(\"div\");\n    block.style.display = \"inline-block\";\n    block.style.width = \"1px\";\n    block.style.height = \"0px\";\n    block.style.verticalAlign = \"bottom\";\n    const div = document.createElement(\"div\");\n    div.style.whiteSpace = \"nowrap\";\n    div.appendChild(text);\n    div.appendChild(block);\n    document.body.appendChild(div);\n    let fontAscent = 0;\n    let fontHeight = 0;\n    try {\n        fontHeight = block.getBoundingClientRect().top - text.getBoundingClientRect().top;\n        block.style.verticalAlign = \"baseline\";\n        fontAscent = block.getBoundingClientRect().top - text.getBoundingClientRect().top;\n    }\n    finally {\n        document.body.removeChild(div);\n    }\n    return { ascent: fontAscent, height: fontHeight, descent: fontHeight - fontAscent };\n}\n/** @internal */\nexport function CreateImageBitmapFromSource(engine, imageSource, options) {\n    const promise = new Promise((resolve, reject) => {\n        const image = new Image();\n        image.onload = () => {\n            image.decode().then(() => {\n                engine.createImageBitmap(image, options).then((imageBitmap) => {\n                    resolve(imageBitmap);\n                });\n            });\n        };\n        image.onerror = () => {\n            reject(`Error loading image ${image.src}`);\n        };\n        image.src = imageSource;\n    });\n    return promise;\n}\n/** @internal */\nexport function ResizeImageBitmap(engine, image, bufferWidth, bufferHeight) {\n    const canvas = engine.createCanvas(bufferWidth, bufferHeight);\n    const context = canvas.getContext(\"2d\");\n    if (!context) {\n        throw new Error(\"Unable to get 2d context for resizeImageBitmap\");\n    }\n    context.drawImage(image, 0, 0);\n    // Create VertexData from map data\n    // Cast is due to wrong definition in lib.d.ts from ts 1.3 - https://github.com/Microsoft/TypeScript/issues/949\n    const buffer = context.getImageData(0, 0, bufferWidth, bufferHeight).data;\n    return buffer;\n}\n/**\n * Ask the browser to promote the current element to fullscreen rendering mode\n * @param element defines the DOM element to promote\n */\nexport function RequestFullscreen(element) {\n    const requestFunction = element.requestFullscreen || element.webkitRequestFullscreen;\n    if (!requestFunction) {\n        return;\n    }\n    requestFunction.call(element);\n}\n/**\n * Asks the browser to exit fullscreen mode\n */\nexport function ExitFullscreen() {\n    const anyDoc = document;\n    if (document.exitFullscreen) {\n        document.exitFullscreen();\n    }\n    else if (anyDoc.webkitCancelFullScreen) {\n        anyDoc.webkitCancelFullScreen();\n    }\n}\n/**\n * Ask the browser to promote the current element to pointerlock mode\n * @param element defines the DOM element to promote\n */\nexport function RequestPointerlock(element) {\n    if (element.requestPointerLock) {\n        // In some browsers, requestPointerLock returns a promise.\n        // Handle possible rejections to avoid an unhandled top-level exception.\n        const promise = element.requestPointerLock();\n        if (promise instanceof Promise)\n            promise\n                .then(() => {\n                element.focus();\n            })\n                .catch(() => { });\n        else\n            element.focus();\n    }\n}\n/**\n * Asks the browser to exit pointerlock mode\n */\nexport function ExitPointerlock() {\n    if (document.exitPointerLock) {\n        document.exitPointerLock();\n    }\n}\n//# sourceMappingURL=engine.common.js.map","import { ThinEngine } from \"../../Engines/thinEngine\";\nimport { Constants } from \"../constants\";\nThinEngine.prototype.setAlphaMode = function (mode, noDepthWriteChange = false) {\n    if (this._alphaMode === mode) {\n        if (!noDepthWriteChange) {\n            // Make sure we still have the correct depth mask according to the alpha mode (a transparent material could have forced writting to the depth buffer, for instance)\n            const depthMask = mode === Constants.ALPHA_DISABLE;\n            if (this.depthCullingState.depthMask !== depthMask) {\n                this.depthCullingState.depthMask = depthMask;\n            }\n        }\n        return;\n    }\n    switch (mode) {\n        case Constants.ALPHA_DISABLE:\n            this._alphaState.alphaBlend = false;\n            break;\n        case Constants.ALPHA_PREMULTIPLIED:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_PREMULTIPLIED_PORTERDUFF:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_COMBINE:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.SRC_ALPHA, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_ONEONE:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE, this._gl.ZERO, this._gl.ONE);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_ADD:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.SRC_ALPHA, this._gl.ONE, this._gl.ZERO, this._gl.ONE);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_SUBTRACT:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ZERO, this._gl.ONE_MINUS_SRC_COLOR, this._gl.ONE, this._gl.ONE);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_MULTIPLY:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.DST_COLOR, this._gl.ZERO, this._gl.ONE, this._gl.ONE);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_MAXIMIZED:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.SRC_ALPHA, this._gl.ONE_MINUS_SRC_COLOR, this._gl.ONE, this._gl.ONE);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_INTERPOLATE:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.CONSTANT_COLOR, this._gl.ONE_MINUS_CONSTANT_COLOR, this._gl.CONSTANT_ALPHA, this._gl.ONE_MINUS_CONSTANT_ALPHA);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_SCREENMODE:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE_MINUS_SRC_COLOR, this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_ONEONE_ONEONE:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE, this._gl.ONE, this._gl.ONE);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_ALPHATOCOLOR:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.DST_ALPHA, this._gl.ONE, this._gl.ZERO, this._gl.ZERO);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_REVERSEONEMINUS:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE_MINUS_DST_COLOR, this._gl.ONE_MINUS_SRC_COLOR, this._gl.ONE_MINUS_DST_ALPHA, this._gl.ONE_MINUS_SRC_ALPHA);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_SRC_DSTONEMINUSSRCALPHA:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_ONEONE_ONEZERO:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE, this._gl.ONE, this._gl.ZERO);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_EXCLUSION:\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE_MINUS_DST_COLOR, this._gl.ONE_MINUS_SRC_COLOR, this._gl.ZERO, this._gl.ONE);\n            this._alphaState.alphaBlend = true;\n            break;\n        case Constants.ALPHA_LAYER_ACCUMULATE:\n            // Same as ALPHA_COMBINE but accumulates (1 - alpha) values in the alpha channel for a later readout in order independant transparency\n            this._alphaState.setAlphaBlendFunctionParameters(this._gl.SRC_ALPHA, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA);\n            this._alphaState.alphaBlend = true;\n            break;\n    }\n    if (!noDepthWriteChange) {\n        this.depthCullingState.depthMask = mode === Constants.ALPHA_DISABLE;\n    }\n    this._alphaMode = mode;\n};\n//# sourceMappingURL=engine.alpha.js.map","import { ThinEngine } from \"../../Engines/thinEngine\";\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nThinEngine.prototype.updateDynamicIndexBuffer = function (indexBuffer, indices, offset = 0) {\n    // Force cache update\n    this._currentBoundBuffer[this._gl.ELEMENT_ARRAY_BUFFER] = null;\n    this.bindIndexBuffer(indexBuffer);\n    let view;\n    if (indexBuffer.is32Bits) {\n        // anything else than Uint32Array needs to be converted to Uint32Array\n        view = indices instanceof Uint32Array ? indices : new Uint32Array(indices);\n    }\n    else {\n        // anything else than Uint16Array needs to be converted to Uint16Array\n        view = indices instanceof Uint16Array ? indices : new Uint16Array(indices);\n    }\n    this._gl.bufferData(this._gl.ELEMENT_ARRAY_BUFFER, view, this._gl.DYNAMIC_DRAW);\n    this._resetIndexBufferBinding();\n};\nThinEngine.prototype.updateDynamicVertexBuffer = function (vertexBuffer, data, byteOffset, byteLength) {\n    this.bindArrayBuffer(vertexBuffer);\n    if (byteOffset === undefined) {\n        byteOffset = 0;\n    }\n    const dataLength = data.byteLength || data.length;\n    if (byteLength === undefined || (byteLength >= dataLength && byteOffset === 0)) {\n        if (data instanceof Array) {\n            this._gl.bufferSubData(this._gl.ARRAY_BUFFER, byteOffset, new Float32Array(data));\n        }\n        else {\n            this._gl.bufferSubData(this._gl.ARRAY_BUFFER, byteOffset, data);\n        }\n    }\n    else {\n        if (data instanceof Array) {\n            this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, new Float32Array(data).subarray(byteOffset, byteOffset + byteLength));\n        }\n        else {\n            if (data instanceof ArrayBuffer) {\n                data = new Uint8Array(data, byteOffset, byteLength);\n            }\n            else {\n                data = new Uint8Array(data.buffer, data.byteOffset + byteOffset, byteLength);\n            }\n            this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, data);\n        }\n    }\n    this._resetVertexBufferBinding();\n};\n//# sourceMappingURL=engine.dynamicBuffer.js.map","import { IsWindowObjectExist } from \"../../Misc/domManagement\";\nimport { AbstractEngine } from \"../abstractEngine\";\nAbstractEngine.prototype.displayLoadingUI = function () {\n    if (!IsWindowObjectExist()) {\n        return;\n    }\n    const loadingScreen = this.loadingScreen;\n    if (loadingScreen) {\n        loadingScreen.displayLoadingUI();\n    }\n};\nAbstractEngine.prototype.hideLoadingUI = function () {\n    if (!IsWindowObjectExist()) {\n        return;\n    }\n    const loadingScreen = this._loadingScreen;\n    if (loadingScreen) {\n        loadingScreen.hideLoadingUI();\n    }\n};\nObject.defineProperty(AbstractEngine.prototype, \"loadingScreen\", {\n    get: function () {\n        if (!this._loadingScreen && this._renderingCanvas) {\n            this._loadingScreen = AbstractEngine.DefaultLoadingScreenFactory(this._renderingCanvas);\n        }\n        return this._loadingScreen;\n    },\n    set: function (value) {\n        this._loadingScreen = value;\n    },\n    enumerable: true,\n    configurable: true,\n});\nObject.defineProperty(AbstractEngine.prototype, \"loadingUIText\", {\n    set: function (value) {\n        this.loadingScreen.loadingUIText = value;\n    },\n    enumerable: true,\n    configurable: true,\n});\nObject.defineProperty(AbstractEngine.prototype, \"loadingUIBackgroundColor\", {\n    set: function (value) {\n        this.loadingScreen.loadingUIBackgroundColor = value;\n    },\n    enumerable: true,\n    configurable: true,\n});\n//# sourceMappingURL=abstractEngine.loadingScreen.js.map","import { AbstractEngine } from \"../abstractEngine\";\nAbstractEngine.prototype.getInputElement = function () {\n    return this._renderingCanvas;\n};\nAbstractEngine.prototype.getRenderingCanvasClientRect = function () {\n    if (!this._renderingCanvas) {\n        return null;\n    }\n    return this._renderingCanvas.getBoundingClientRect();\n};\nAbstractEngine.prototype.getInputElementClientRect = function () {\n    if (!this._renderingCanvas) {\n        return null;\n    }\n    return this.getInputElement().getBoundingClientRect();\n};\nAbstractEngine.prototype.getAspectRatio = function (viewportOwner, useScreen = false) {\n    const viewport = viewportOwner.viewport;\n    return (this.getRenderWidth(useScreen) * viewport.width) / (this.getRenderHeight(useScreen) * viewport.height);\n};\nAbstractEngine.prototype.getScreenAspectRatio = function () {\n    return this.getRenderWidth(true) / this.getRenderHeight(true);\n};\nAbstractEngine.prototype._verifyPointerLock = function () {\n    this._onPointerLockChange?.();\n};\n//# sourceMappingURL=abstractEngine.dom.js.map","import { AbstractEngine } from \"../abstractEngine\";\nimport { Constants } from \"../constants\";\nAbstractEngine.prototype.setAlphaEquation = function (equation) {\n    if (this._alphaEquation === equation) {\n        return;\n    }\n    switch (equation) {\n        case Constants.ALPHA_EQUATION_ADD:\n            this._alphaState.setAlphaEquationParameters(Constants.GL_ALPHA_EQUATION_ADD, Constants.GL_ALPHA_EQUATION_ADD);\n            break;\n        case Constants.ALPHA_EQUATION_SUBSTRACT:\n            this._alphaState.setAlphaEquationParameters(Constants.GL_ALPHA_EQUATION_SUBTRACT, Constants.GL_ALPHA_EQUATION_SUBTRACT);\n            break;\n        case Constants.ALPHA_EQUATION_REVERSE_SUBTRACT:\n            this._alphaState.setAlphaEquationParameters(Constants.GL_ALPHA_EQUATION_REVERSE_SUBTRACT, Constants.GL_ALPHA_EQUATION_REVERSE_SUBTRACT);\n            break;\n        case Constants.ALPHA_EQUATION_MAX:\n            this._alphaState.setAlphaEquationParameters(Constants.GL_ALPHA_EQUATION_MAX, Constants.GL_ALPHA_EQUATION_MAX);\n            break;\n        case Constants.ALPHA_EQUATION_MIN:\n            this._alphaState.setAlphaEquationParameters(Constants.GL_ALPHA_EQUATION_MIN, Constants.GL_ALPHA_EQUATION_MIN);\n            break;\n        case Constants.ALPHA_EQUATION_DARKEN:\n            this._alphaState.setAlphaEquationParameters(Constants.GL_ALPHA_EQUATION_MIN, Constants.GL_ALPHA_EQUATION_ADD);\n            break;\n    }\n    this._alphaEquation = equation;\n};\n//# sourceMappingURL=abstractEngine.alpha.js.map","import { AbstractEngine } from \"../abstractEngine\";\nimport { Constants } from \"../constants\";\nimport \"./abstractEngine.alpha\";\nAbstractEngine.prototype.getInputElement = function () {\n    return this._renderingCanvas;\n};\nAbstractEngine.prototype.getDepthFunction = function () {\n    return this._depthCullingState.depthFunc;\n};\nAbstractEngine.prototype.setDepthFunction = function (depthFunc) {\n    this._depthCullingState.depthFunc = depthFunc;\n};\nAbstractEngine.prototype.setDepthFunctionToGreater = function () {\n    this.setDepthFunction(Constants.GREATER);\n};\nAbstractEngine.prototype.setDepthFunctionToGreaterOrEqual = function () {\n    this.setDepthFunction(Constants.GEQUAL);\n};\nAbstractEngine.prototype.setDepthFunctionToLess = function () {\n    this.setDepthFunction(Constants.LESS);\n};\nAbstractEngine.prototype.setDepthFunctionToLessOrEqual = function () {\n    this.setDepthFunction(Constants.LEQUAL);\n};\nAbstractEngine.prototype.getDepthWrite = function () {\n    return this._depthCullingState.depthMask;\n};\nAbstractEngine.prototype.setDepthWrite = function (enable) {\n    this._depthCullingState.depthMask = enable;\n};\nAbstractEngine.prototype.getStencilBuffer = function () {\n    return this._stencilState.stencilTest;\n};\nAbstractEngine.prototype.setStencilBuffer = function (enable) {\n    this._stencilState.stencilTest = enable;\n};\nAbstractEngine.prototype.getStencilMask = function () {\n    return this._stencilState.stencilMask;\n};\nAbstractEngine.prototype.setStencilMask = function (mask) {\n    this._stencilState.stencilMask = mask;\n};\nAbstractEngine.prototype.getStencilFunction = function () {\n    return this._stencilState.stencilFunc;\n};\nAbstractEngine.prototype.getStencilFunctionReference = function () {\n    return this._stencilState.stencilFuncRef;\n};\nAbstractEngine.prototype.getStencilFunctionMask = function () {\n    return this._stencilState.stencilFuncMask;\n};\nAbstractEngine.prototype.setStencilFunction = function (stencilFunc) {\n    this._stencilState.stencilFunc = stencilFunc;\n};\nAbstractEngine.prototype.setStencilFunctionReference = function (reference) {\n    this._stencilState.stencilFuncRef = reference;\n};\nAbstractEngine.prototype.setStencilFunctionMask = function (mask) {\n    this._stencilState.stencilFuncMask = mask;\n};\nAbstractEngine.prototype.getStencilOperationFail = function () {\n    return this._stencilState.stencilOpStencilFail;\n};\nAbstractEngine.prototype.getStencilOperationDepthFail = function () {\n    return this._stencilState.stencilOpDepthFail;\n};\nAbstractEngine.prototype.getStencilOperationPass = function () {\n    return this._stencilState.stencilOpStencilDepthPass;\n};\nAbstractEngine.prototype.setStencilOperationFail = function (operation) {\n    this._stencilState.stencilOpStencilFail = operation;\n};\nAbstractEngine.prototype.setStencilOperationDepthFail = function (operation) {\n    this._stencilState.stencilOpDepthFail = operation;\n};\nAbstractEngine.prototype.setStencilOperationPass = function (operation) {\n    this._stencilState.stencilOpStencilDepthPass = operation;\n};\nAbstractEngine.prototype.cacheStencilState = function () {\n    this._cachedStencilBuffer = this.getStencilBuffer();\n    this._cachedStencilFunction = this.getStencilFunction();\n    this._cachedStencilMask = this.getStencilMask();\n    this._cachedStencilOperationPass = this.getStencilOperationPass();\n    this._cachedStencilOperationFail = this.getStencilOperationFail();\n    this._cachedStencilOperationDepthFail = this.getStencilOperationDepthFail();\n    this._cachedStencilReference = this.getStencilFunctionReference();\n};\nAbstractEngine.prototype.restoreStencilState = function () {\n    this.setStencilFunction(this._cachedStencilFunction);\n    this.setStencilMask(this._cachedStencilMask);\n    this.setStencilBuffer(this._cachedStencilBuffer);\n    this.setStencilOperationPass(this._cachedStencilOperationPass);\n    this.setStencilOperationFail(this._cachedStencilOperationFail);\n    this.setStencilOperationDepthFail(this._cachedStencilOperationDepthFail);\n    this.setStencilFunctionReference(this._cachedStencilReference);\n};\nAbstractEngine.prototype.setAlphaConstants = function (r, g, b, a) {\n    this._alphaState.setAlphaBlendConstants(r, g, b, a);\n};\nAbstractEngine.prototype.getAlphaMode = function () {\n    return this._alphaMode;\n};\nAbstractEngine.prototype.getAlphaEquation = function () {\n    return this._alphaEquation;\n};\n//# sourceMappingURL=abstractEngine.states.js.map","import { AbstractEngine } from \"../abstractEngine\";\nAbstractEngine.prototype.getRenderPassNames = function () {\n    return this._renderPassNames;\n};\nAbstractEngine.prototype.getCurrentRenderPassName = function () {\n    return this._renderPassNames[this.currentRenderPassId];\n};\nAbstractEngine.prototype.createRenderPassId = function (name) {\n    // Note: render pass id == 0 is always for the main render pass\n    const id = ++AbstractEngine._RenderPassIdCounter;\n    this._renderPassNames[id] = name ?? \"NONAME\";\n    return id;\n};\nAbstractEngine.prototype.releaseRenderPassId = function (id) {\n    this._renderPassNames[id] = undefined;\n    for (let s = 0; s < this.scenes.length; ++s) {\n        const scene = this.scenes[s];\n        for (let m = 0; m < scene.meshes.length; ++m) {\n            const mesh = scene.meshes[m];\n            if (mesh.subMeshes) {\n                for (let b = 0; b < mesh.subMeshes.length; ++b) {\n                    const subMesh = mesh.subMeshes[b];\n                    subMesh._removeDrawWrapper(id);\n                }\n            }\n        }\n    }\n};\n//# sourceMappingURL=abstractEngine.renderPass.js.map","import { InternalTexture } from \"../Materials/Textures/internalTexture\";\nimport { EngineStore } from \"./engineStore\";\nimport { ThinEngine } from \"./thinEngine\";\nimport { Constants } from \"./constants\";\nimport { PerformanceMonitor } from \"../Misc/performanceMonitor\";\nimport { WebGLDataBuffer } from \"../Meshes/WebGL/webGLDataBuffer\";\nimport { Logger } from \"../Misc/logger\";\nimport { WebGLHardwareTexture } from \"./WebGL/webGLHardwareTexture\";\nimport \"./Extensions/engine.alpha\";\nimport \"./Extensions/engine.readTexture\";\nimport \"./Extensions/engine.dynamicBuffer\";\nimport \"./AbstractEngine/abstractEngine.loadingScreen\";\nimport \"./AbstractEngine/abstractEngine.dom\";\nimport \"./AbstractEngine/abstractEngine.states\";\nimport \"./AbstractEngine/abstractEngine.renderPass\";\nimport \"./AbstractEngine/abstractEngine.texture\";\nimport { AbstractEngine } from \"./abstractEngine\";\nimport { CreateImageBitmapFromSource, ExitFullscreen, ExitPointerlock, GetFontOffset, RequestFullscreen, RequestPointerlock, ResizeImageBitmap, _CommonDispose, _CommonInit, } from \"./engine.common\";\nimport { PerfCounter } from \"../Misc/perfCounter\";\nimport \"../Audio/audioEngine\";\n/**\n * The engine class is responsible for interfacing with all lower-level APIs such as WebGL and Audio\n */\nexport class Engine extends ThinEngine {\n    /**\n     * Returns the current npm package of the sdk\n     */\n    // Not mixed with Version for tooling purpose.\n    static get NpmPackage() {\n        return AbstractEngine.NpmPackage;\n    }\n    /**\n     * Returns the current version of the framework\n     */\n    static get Version() {\n        return AbstractEngine.Version;\n    }\n    /** Gets the list of created engines */\n    static get Instances() {\n        return EngineStore.Instances;\n    }\n    /**\n     * Gets the latest created engine\n     */\n    static get LastCreatedEngine() {\n        return EngineStore.LastCreatedEngine;\n    }\n    /**\n     * Gets the latest created scene\n     */\n    static get LastCreatedScene() {\n        return EngineStore.LastCreatedScene;\n    }\n    /** @internal */\n    // eslint-disable-next-line jsdoc/require-returns-check\n    /**\n     * Method called to create the default loading screen.\n     * This can be overridden in your own app.\n     * @param canvas The rendering canvas element\n     * @returns The loading screen\n     */\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    static DefaultLoadingScreenFactory(canvas) {\n        return AbstractEngine.DefaultLoadingScreenFactory(canvas);\n    }\n    get _supportsHardwareTextureRescaling() {\n        return !!Engine._RescalePostProcessFactory;\n    }\n    _measureFps() {\n        this._performanceMonitor.sampleFrame();\n        this._fps = this._performanceMonitor.averageFPS;\n        this._deltaTime = this._performanceMonitor.instantaneousFrameTime || 0;\n    }\n    /**\n     * Gets the performance monitor attached to this engine\n     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#engineinstrumentation\n     */\n    get performanceMonitor() {\n        return this._performanceMonitor;\n    }\n    // Events\n    /**\n     * Creates a new engine\n     * @param canvasOrContext defines the canvas or WebGL context to use for rendering. If you provide a WebGL context, Babylon.js will not hook events on the canvas (like pointers, keyboards, etc...) so no event observables will be available. This is mostly used when Babylon.js is used as a plugin on a system which already used the WebGL context\n     * @param antialias defines enable antialiasing (default: false)\n     * @param options defines further options to be sent to the getContext() function\n     * @param adaptToDeviceRatio defines whether to adapt to the device's viewport characteristics (default: false)\n     */\n    constructor(canvasOrContext, antialias, options, adaptToDeviceRatio = false) {\n        super(canvasOrContext, antialias, options, adaptToDeviceRatio);\n        // Members\n        /**\n         * If set, will be used to request the next animation frame for the render loop\n         */\n        this.customAnimationFrameRequester = null;\n        this._performanceMonitor = new PerformanceMonitor();\n        this._drawCalls = new PerfCounter();\n        if (!canvasOrContext) {\n            return;\n        }\n        this._features.supportRenderPasses = true;\n        options = this._creationOptions;\n        if (canvasOrContext.getContext) {\n            const canvas = canvasOrContext;\n            this._sharedInit(canvas);\n        }\n    }\n    _initGLContext() {\n        super._initGLContext();\n        this._rescalePostProcess = null;\n    }\n    /**\n     * Shared initialization across engines types.\n     * @param canvas The canvas associated with this instance of the engine.\n     */\n    _sharedInit(canvas) {\n        super._sharedInit(canvas);\n        _CommonInit(this, canvas, this._creationOptions);\n    }\n    /**\n     * Resize an image and returns the image data as an uint8array\n     * @param image image to resize\n     * @param bufferWidth destination buffer width\n     * @param bufferHeight destination buffer height\n     * @returns an uint8array containing RGBA values of bufferWidth * bufferHeight size\n     */\n    resizeImageBitmap(image, bufferWidth, bufferHeight) {\n        return ResizeImageBitmap(this, image, bufferWidth, bufferHeight);\n    }\n    /**\n     * Engine abstraction for loading and creating an image bitmap from a given source string.\n     * @param imageSource source to load the image from.\n     * @param options An object that sets options for the image's extraction.\n     * @returns ImageBitmap\n     */\n    _createImageBitmapFromSource(imageSource, options) {\n        return CreateImageBitmapFromSource(this, imageSource, options);\n    }\n    /**\n     * Toggle full screen mode\n     * @param requestPointerLock defines if a pointer lock should be requested from the user\n     */\n    switchFullscreen(requestPointerLock) {\n        if (this.isFullscreen) {\n            this.exitFullscreen();\n        }\n        else {\n            this.enterFullscreen(requestPointerLock);\n        }\n    }\n    /**\n     * Enters full screen mode\n     * @param requestPointerLock defines if a pointer lock should be requested from the user\n     */\n    enterFullscreen(requestPointerLock) {\n        if (!this.isFullscreen) {\n            this._pointerLockRequested = requestPointerLock;\n            if (this._renderingCanvas) {\n                RequestFullscreen(this._renderingCanvas);\n            }\n        }\n    }\n    /**\n     * Exits full screen mode\n     */\n    exitFullscreen() {\n        if (this.isFullscreen) {\n            ExitFullscreen();\n        }\n    }\n    /** States */\n    /**\n     * Sets a boolean indicating if the dithering state is enabled or disabled\n     * @param value defines the dithering state\n     */\n    setDitheringState(value) {\n        if (value) {\n            this._gl.enable(this._gl.DITHER);\n        }\n        else {\n            this._gl.disable(this._gl.DITHER);\n        }\n    }\n    /**\n     * Sets a boolean indicating if the rasterizer state is enabled or disabled\n     * @param value defines the rasterizer state\n     */\n    setRasterizerState(value) {\n        if (value) {\n            this._gl.disable(this._gl.RASTERIZER_DISCARD);\n        }\n        else {\n            this._gl.enable(this._gl.RASTERIZER_DISCARD);\n        }\n    }\n    /**\n     * Directly set the WebGL Viewport\n     * @param x defines the x coordinate of the viewport (in screen space)\n     * @param y defines the y coordinate of the viewport (in screen space)\n     * @param width defines the width of the viewport (in screen space)\n     * @param height defines the height of the viewport (in screen space)\n     * @returns the current viewport Object (if any) that is being replaced by this call. You can restore this viewport later on to go back to the original state\n     */\n    setDirectViewport(x, y, width, height) {\n        const currentViewport = this._cachedViewport;\n        this._cachedViewport = null;\n        this._viewport(x, y, width, height);\n        return currentViewport;\n    }\n    /**\n     * Executes a scissor clear (ie. a clear on a specific portion of the screen)\n     * @param x defines the x-coordinate of the bottom left corner of the clear rectangle\n     * @param y defines the y-coordinate of the corner of the clear rectangle\n     * @param width defines the width of the clear rectangle\n     * @param height defines the height of the clear rectangle\n     * @param clearColor defines the clear color\n     */\n    scissorClear(x, y, width, height, clearColor) {\n        this.enableScissor(x, y, width, height);\n        this.clear(clearColor, true, true, true);\n        this.disableScissor();\n    }\n    /**\n     * Enable scissor test on a specific rectangle (ie. render will only be executed on a specific portion of the screen)\n     * @param x defines the x-coordinate of the bottom left corner of the clear rectangle\n     * @param y defines the y-coordinate of the corner of the clear rectangle\n     * @param width defines the width of the clear rectangle\n     * @param height defines the height of the clear rectangle\n     */\n    enableScissor(x, y, width, height) {\n        const gl = this._gl;\n        // Change state\n        gl.enable(gl.SCISSOR_TEST);\n        gl.scissor(x, y, width, height);\n    }\n    /**\n     * Disable previously set scissor test rectangle\n     */\n    disableScissor() {\n        const gl = this._gl;\n        gl.disable(gl.SCISSOR_TEST);\n    }\n    /**\n     * @internal\n     */\n    _loadFileAsync(url, offlineProvider, useArrayBuffer) {\n        return new Promise((resolve, reject) => {\n            this._loadFile(url, (data) => {\n                resolve(data);\n            }, undefined, offlineProvider, useArrayBuffer, (request, exception) => {\n                reject(exception);\n            });\n        });\n    }\n    /**\n     * Gets the source code of the vertex shader associated with a specific webGL program\n     * @param program defines the program to use\n     * @returns a string containing the source code of the vertex shader associated with the program\n     */\n    getVertexShaderSource(program) {\n        const shaders = this._gl.getAttachedShaders(program);\n        if (!shaders) {\n            return null;\n        }\n        return this._gl.getShaderSource(shaders[0]);\n    }\n    /**\n     * Gets the source code of the fragment shader associated with a specific webGL program\n     * @param program defines the program to use\n     * @returns a string containing the source code of the fragment shader associated with the program\n     */\n    getFragmentShaderSource(program) {\n        const shaders = this._gl.getAttachedShaders(program);\n        if (!shaders) {\n            return null;\n        }\n        return this._gl.getShaderSource(shaders[1]);\n    }\n    /**\n     * sets the object from which width and height will be taken from when getting render width and height\n     * Will fallback to the gl object\n     * @param dimensions the framebuffer width and height that will be used.\n     */\n    set framebufferDimensionsObject(dimensions) {\n        this._framebufferDimensionsObject = dimensions;\n        if (this._framebufferDimensionsObject) {\n            this.onResizeObservable.notifyObservers(this);\n        }\n    }\n    _rebuildBuffers() {\n        // Index / Vertex\n        for (const scene of this.scenes) {\n            scene.resetCachedMaterial();\n            scene._rebuildGeometries();\n        }\n        for (const scene of this._virtualScenes) {\n            scene.resetCachedMaterial();\n            scene._rebuildGeometries();\n        }\n        super._rebuildBuffers();\n    }\n    /**\n     * Get Font size information\n     * @param font font name\n     * @returns an object containing ascent, height and descent\n     */\n    getFontOffset(font) {\n        return GetFontOffset(font);\n    }\n    _cancelFrame() {\n        if (this.customAnimationFrameRequester) {\n            if (this._frameHandler !== 0) {\n                this._frameHandler = 0;\n                const { cancelAnimationFrame } = this.customAnimationFrameRequester;\n                if (cancelAnimationFrame) {\n                    cancelAnimationFrame(this.customAnimationFrameRequester.requestID);\n                }\n            }\n        }\n        else {\n            super._cancelFrame();\n        }\n    }\n    _renderLoop() {\n        // Reset the frame handler before rendering a frame to determine if a new frame has been queued.\n        this._frameHandler = 0;\n        if (!this._contextWasLost) {\n            let shouldRender = true;\n            if (this.isDisposed || (!this.renderEvenInBackground && this._windowIsBackground)) {\n                shouldRender = false;\n            }\n            if (shouldRender) {\n                // Start new frame\n                this.beginFrame();\n                // Child canvases\n                if (!this._renderViews()) {\n                    // Main frame\n                    this._renderFrame();\n                }\n                // Present\n                this.endFrame();\n            }\n        }\n        // The first condition prevents queuing another frame if we no longer have active render loops (e.g., if\n        // `stopRenderLoop` is called mid frame). The second condition prevents queuing another frame if one has\n        // already been queued (e.g., if `stopRenderLoop` and `runRenderLoop` is called mid frame).\n        if (this._activeRenderLoops.length > 0 && this._frameHandler === 0) {\n            if (this.customAnimationFrameRequester) {\n                this.customAnimationFrameRequester.requestID = this._queueNewFrame(this.customAnimationFrameRequester.renderFunction || this._boundRenderFunction, this.customAnimationFrameRequester);\n                this._frameHandler = this.customAnimationFrameRequester.requestID;\n            }\n            else {\n                this._frameHandler = this._queueNewFrame(this._boundRenderFunction, this.getHostWindow());\n            }\n        }\n    }\n    /**\n     * Enters Pointerlock mode\n     */\n    enterPointerlock() {\n        if (this._renderingCanvas) {\n            RequestPointerlock(this._renderingCanvas);\n        }\n    }\n    /**\n     * Exits Pointerlock mode\n     */\n    exitPointerlock() {\n        ExitPointerlock();\n    }\n    /**\n     * Begin a new frame\n     */\n    beginFrame() {\n        this._measureFps();\n        super.beginFrame();\n    }\n    _deletePipelineContext(pipelineContext) {\n        const webGLPipelineContext = pipelineContext;\n        if (webGLPipelineContext && webGLPipelineContext.program) {\n            if (webGLPipelineContext.transformFeedback) {\n                this.deleteTransformFeedback(webGLPipelineContext.transformFeedback);\n                webGLPipelineContext.transformFeedback = null;\n            }\n        }\n        super._deletePipelineContext(pipelineContext);\n    }\n    createShaderProgram(pipelineContext, vertexCode, fragmentCode, defines, context, transformFeedbackVaryings = null) {\n        context = context || this._gl;\n        this.onBeforeShaderCompilationObservable.notifyObservers(this);\n        const program = super.createShaderProgram(pipelineContext, vertexCode, fragmentCode, defines, context, transformFeedbackVaryings);\n        this.onAfterShaderCompilationObservable.notifyObservers(this);\n        return program;\n    }\n    _createShaderProgram(pipelineContext, vertexShader, fragmentShader, context, transformFeedbackVaryings = null) {\n        const shaderProgram = context.createProgram();\n        pipelineContext.program = shaderProgram;\n        if (!shaderProgram) {\n            throw new Error(\"Unable to create program\");\n        }\n        context.attachShader(shaderProgram, vertexShader);\n        context.attachShader(shaderProgram, fragmentShader);\n        if (this.webGLVersion > 1 && transformFeedbackVaryings) {\n            const transformFeedback = this.createTransformFeedback();\n            this.bindTransformFeedback(transformFeedback);\n            this.setTranformFeedbackVaryings(shaderProgram, transformFeedbackVaryings);\n            pipelineContext.transformFeedback = transformFeedback;\n        }\n        context.linkProgram(shaderProgram);\n        if (this.webGLVersion > 1 && transformFeedbackVaryings) {\n            this.bindTransformFeedback(null);\n        }\n        pipelineContext.context = context;\n        pipelineContext.vertexShader = vertexShader;\n        pipelineContext.fragmentShader = fragmentShader;\n        if (!pipelineContext.isParallelCompiled) {\n            this._finalizePipelineContext(pipelineContext);\n        }\n        return shaderProgram;\n    }\n    /**\n     * @internal\n     */\n    _releaseTexture(texture) {\n        super._releaseTexture(texture);\n    }\n    /**\n     * @internal\n     */\n    _releaseRenderTargetWrapper(rtWrapper) {\n        super._releaseRenderTargetWrapper(rtWrapper);\n        // Set output texture of post process to null if the framebuffer has been released/disposed\n        this.scenes.forEach((scene) => {\n            scene.postProcesses.forEach((postProcess) => {\n                if (postProcess._outputTexture === rtWrapper) {\n                    postProcess._outputTexture = null;\n                }\n            });\n            scene.cameras.forEach((camera) => {\n                camera._postProcesses.forEach((postProcess) => {\n                    if (postProcess) {\n                        if (postProcess._outputTexture === rtWrapper) {\n                            postProcess._outputTexture = null;\n                        }\n                    }\n                });\n            });\n        });\n    }\n    /**\n     * @internal\n     * Rescales a texture\n     * @param source input texture\n     * @param destination destination texture\n     * @param scene scene to use to render the resize\n     * @param internalFormat format to use when resizing\n     * @param onComplete callback to be called when resize has completed\n     */\n    _rescaleTexture(source, destination, scene, internalFormat, onComplete) {\n        this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_MAG_FILTER, this._gl.LINEAR);\n        this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_MIN_FILTER, this._gl.LINEAR);\n        this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_WRAP_S, this._gl.CLAMP_TO_EDGE);\n        this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_WRAP_T, this._gl.CLAMP_TO_EDGE);\n        const rtt = this.createRenderTargetTexture({\n            width: destination.width,\n            height: destination.height,\n        }, {\n            generateMipMaps: false,\n            type: Constants.TEXTURETYPE_UNSIGNED_INT,\n            samplingMode: Constants.TEXTURE_BILINEAR_SAMPLINGMODE,\n            generateDepthBuffer: false,\n            generateStencilBuffer: false,\n        });\n        if (!this._rescalePostProcess && Engine._RescalePostProcessFactory) {\n            this._rescalePostProcess = Engine._RescalePostProcessFactory(this);\n        }\n        if (this._rescalePostProcess) {\n            this._rescalePostProcess.externalTextureSamplerBinding = true;\n            const onCompiled = () => {\n                this._rescalePostProcess.onApply = function (effect) {\n                    effect._bindTexture(\"textureSampler\", source);\n                };\n                let hostingScene = scene;\n                if (!hostingScene) {\n                    hostingScene = this.scenes[this.scenes.length - 1];\n                }\n                hostingScene.postProcessManager.directRender([this._rescalePostProcess], rtt, true);\n                this._bindTextureDirectly(this._gl.TEXTURE_2D, destination, true);\n                this._gl.copyTexImage2D(this._gl.TEXTURE_2D, 0, internalFormat, 0, 0, destination.width, destination.height, 0);\n                this.unBindFramebuffer(rtt);\n                rtt.dispose();\n                if (onComplete) {\n                    onComplete();\n                }\n            };\n            const effect = this._rescalePostProcess.getEffect();\n            if (effect) {\n                effect.executeWhenCompiled(onCompiled);\n            }\n            else {\n                this._rescalePostProcess.onEffectCreatedObservable.addOnce((effect) => {\n                    effect.executeWhenCompiled(onCompiled);\n                });\n            }\n        }\n    }\n    /**\n     * Wraps an external web gl texture in a Babylon texture.\n     * @param texture defines the external texture\n     * @param hasMipMaps defines whether the external texture has mip maps (default: false)\n     * @param samplingMode defines the sampling mode for the external texture (default: Constants.TEXTURE_TRILINEAR_SAMPLINGMODE)\n     * @param width defines the width for the external texture (default: 0)\n     * @param height defines the height for the external texture (default: 0)\n     * @returns the babylon internal texture\n     */\n    wrapWebGLTexture(texture, hasMipMaps = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, width = 0, height = 0) {\n        const hardwareTexture = new WebGLHardwareTexture(texture, this._gl);\n        const internalTexture = new InternalTexture(this, 0 /* InternalTextureSource.Unknown */, true);\n        internalTexture._hardwareTexture = hardwareTexture;\n        internalTexture.baseWidth = width;\n        internalTexture.baseHeight = height;\n        internalTexture.width = width;\n        internalTexture.height = height;\n        internalTexture.isReady = true;\n        internalTexture.useMipMaps = hasMipMaps;\n        this.updateTextureSamplingMode(samplingMode, internalTexture);\n        return internalTexture;\n    }\n    /**\n     * @internal\n     */\n    _uploadImageToTexture(texture, image, faceIndex = 0, lod = 0) {\n        const gl = this._gl;\n        const textureType = this._getWebGLTextureType(texture.type);\n        const format = this._getInternalFormat(texture.format);\n        const internalFormat = this._getRGBABufferInternalSizedFormat(texture.type, format);\n        const bindTarget = texture.isCube ? gl.TEXTURE_CUBE_MAP : gl.TEXTURE_2D;\n        this._bindTextureDirectly(bindTarget, texture, true);\n        this._unpackFlipY(texture.invertY);\n        let target = gl.TEXTURE_2D;\n        if (texture.isCube) {\n            target = gl.TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex;\n        }\n        gl.texImage2D(target, lod, internalFormat, format, textureType, image);\n        this._bindTextureDirectly(bindTarget, null, true);\n    }\n    /**\n     * Updates a depth texture Comparison Mode and Function.\n     * If the comparison Function is equal to 0, the mode will be set to none.\n     * Otherwise, this only works in webgl 2 and requires a shadow sampler in the shader.\n     * @param texture The texture to set the comparison function for\n     * @param comparisonFunction The comparison function to set, 0 if no comparison required\n     */\n    updateTextureComparisonFunction(texture, comparisonFunction) {\n        if (this.webGLVersion === 1) {\n            Logger.Error(\"WebGL 1 does not support texture comparison.\");\n            return;\n        }\n        const gl = this._gl;\n        if (texture.isCube) {\n            this._bindTextureDirectly(this._gl.TEXTURE_CUBE_MAP, texture, true);\n            if (comparisonFunction === 0) {\n                gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_COMPARE_FUNC, Constants.LEQUAL);\n                gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_COMPARE_MODE, gl.NONE);\n            }\n            else {\n                gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_COMPARE_FUNC, comparisonFunction);\n                gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE);\n            }\n            this._bindTextureDirectly(this._gl.TEXTURE_CUBE_MAP, null);\n        }\n        else {\n            this._bindTextureDirectly(this._gl.TEXTURE_2D, texture, true);\n            if (comparisonFunction === 0) {\n                gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_FUNC, Constants.LEQUAL);\n                gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_MODE, gl.NONE);\n            }\n            else {\n                gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_FUNC, comparisonFunction);\n                gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE);\n            }\n            this._bindTextureDirectly(this._gl.TEXTURE_2D, null);\n        }\n        texture._comparisonFunction = comparisonFunction;\n    }\n    /**\n     * Creates a webGL buffer to use with instantiation\n     * @param capacity defines the size of the buffer\n     * @returns the webGL buffer\n     */\n    createInstancesBuffer(capacity) {\n        const buffer = this._gl.createBuffer();\n        if (!buffer) {\n            throw new Error(\"Unable to create instance buffer\");\n        }\n        const result = new WebGLDataBuffer(buffer);\n        result.capacity = capacity;\n        this.bindArrayBuffer(result);\n        this._gl.bufferData(this._gl.ARRAY_BUFFER, capacity, this._gl.DYNAMIC_DRAW);\n        result.references = 1;\n        return result;\n    }\n    /**\n     * Delete a webGL buffer used with instantiation\n     * @param buffer defines the webGL buffer to delete\n     */\n    deleteInstancesBuffer(buffer) {\n        this._gl.deleteBuffer(buffer);\n    }\n    _clientWaitAsync(sync, flags = 0, intervalms = 10) {\n        const gl = this._gl;\n        return new Promise((resolve, reject) => {\n            const check = () => {\n                const res = gl.clientWaitSync(sync, flags, 0);\n                if (res == gl.WAIT_FAILED) {\n                    reject();\n                    return;\n                }\n                if (res == gl.TIMEOUT_EXPIRED) {\n                    setTimeout(check, intervalms);\n                    return;\n                }\n                resolve();\n            };\n            check();\n        });\n    }\n    /**\n     * @internal\n     */\n    _readPixelsAsync(x, y, w, h, format, type, outputBuffer) {\n        if (this._webGLVersion < 2) {\n            throw new Error(\"_readPixelsAsync only work on WebGL2+\");\n        }\n        const gl = this._gl;\n        const buf = gl.createBuffer();\n        gl.bindBuffer(gl.PIXEL_PACK_BUFFER, buf);\n        gl.bufferData(gl.PIXEL_PACK_BUFFER, outputBuffer.byteLength, gl.STREAM_READ);\n        gl.readPixels(x, y, w, h, format, type, 0);\n        gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);\n        const sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);\n        if (!sync) {\n            return null;\n        }\n        gl.flush();\n        return this._clientWaitAsync(sync, 0, 10).then(() => {\n            gl.deleteSync(sync);\n            gl.bindBuffer(gl.PIXEL_PACK_BUFFER, buf);\n            gl.getBufferSubData(gl.PIXEL_PACK_BUFFER, 0, outputBuffer);\n            gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);\n            gl.deleteBuffer(buf);\n            return outputBuffer;\n        });\n    }\n    dispose() {\n        this.hideLoadingUI();\n        // Rescale PP\n        if (this._rescalePostProcess) {\n            this._rescalePostProcess.dispose();\n        }\n        _CommonDispose(this, this._renderingCanvas);\n        super.dispose();\n    }\n}\n// Const statics\n/** Defines that alpha blending is disabled */\nEngine.ALPHA_DISABLE = Constants.ALPHA_DISABLE;\n/** Defines that alpha blending to SRC ALPHA * SRC + DEST */\nEngine.ALPHA_ADD = Constants.ALPHA_ADD;\n/** Defines that alpha blending to SRC ALPHA * SRC + (1 - SRC ALPHA) * DEST */\nEngine.ALPHA_COMBINE = Constants.ALPHA_COMBINE;\n/** Defines that alpha blending to DEST - SRC * DEST */\nEngine.ALPHA_SUBTRACT = Constants.ALPHA_SUBTRACT;\n/** Defines that alpha blending to SRC * DEST */\nEngine.ALPHA_MULTIPLY = Constants.ALPHA_MULTIPLY;\n/** Defines that alpha blending to SRC ALPHA * SRC + (1 - SRC) * DEST */\nEngine.ALPHA_MAXIMIZED = Constants.ALPHA_MAXIMIZED;\n/** Defines that alpha blending to SRC + DEST */\nEngine.ALPHA_ONEONE = Constants.ALPHA_ONEONE;\n/** Defines that alpha blending to SRC + (1 - SRC ALPHA) * DEST */\nEngine.ALPHA_PREMULTIPLIED = Constants.ALPHA_PREMULTIPLIED;\n/**\n * Defines that alpha blending to SRC + (1 - SRC ALPHA) * DEST\n * Alpha will be set to (1 - SRC ALPHA) * DEST ALPHA\n */\nEngine.ALPHA_PREMULTIPLIED_PORTERDUFF = Constants.ALPHA_PREMULTIPLIED_PORTERDUFF;\n/** Defines that alpha blending to CST * SRC + (1 - CST) * DEST */\nEngine.ALPHA_INTERPOLATE = Constants.ALPHA_INTERPOLATE;\n/**\n * Defines that alpha blending to SRC + (1 - SRC) * DEST\n * Alpha will be set to SRC ALPHA + (1 - SRC ALPHA) * DEST ALPHA\n */\nEngine.ALPHA_SCREENMODE = Constants.ALPHA_SCREENMODE;\n/** Defines that the resource is not delayed*/\nEngine.DELAYLOADSTATE_NONE = Constants.DELAYLOADSTATE_NONE;\n/** Defines that the resource was successfully delay loaded */\nEngine.DELAYLOADSTATE_LOADED = Constants.DELAYLOADSTATE_LOADED;\n/** Defines that the resource is currently delay loading */\nEngine.DELAYLOADSTATE_LOADING = Constants.DELAYLOADSTATE_LOADING;\n/** Defines that the resource is delayed and has not started loading */\nEngine.DELAYLOADSTATE_NOTLOADED = Constants.DELAYLOADSTATE_NOTLOADED;\n// Depht or Stencil test Constants.\n/** Passed to depthFunction or stencilFunction to specify depth or stencil tests will never pass. i.e. Nothing will be drawn */\nEngine.NEVER = Constants.NEVER;\n/** Passed to depthFunction or stencilFunction to specify depth or stencil tests will always pass. i.e. Pixels will be drawn in the order they are drawn */\nEngine.ALWAYS = Constants.ALWAYS;\n/** Passed to depthFunction or stencilFunction to specify depth or stencil tests will pass if the new depth value is less than the stored value */\nEngine.LESS = Constants.LESS;\n/** Passed to depthFunction or stencilFunction to specify depth or stencil tests will pass if the new depth value is equals to the stored value */\nEngine.EQUAL = Constants.EQUAL;\n/** Passed to depthFunction or stencilFunction to specify depth or stencil tests will pass if the new depth value is less than or equal to the stored value */\nEngine.LEQUAL = Constants.LEQUAL;\n/** Passed to depthFunction or stencilFunction to specify depth or stencil tests will pass if the new depth value is greater than the stored value */\nEngine.GREATER = Constants.GREATER;\n/** Passed to depthFunction or stencilFunction to specify depth or stencil tests will pass if the new depth value is greater than or equal to the stored value */\nEngine.GEQUAL = Constants.GEQUAL;\n/** Passed to depthFunction or stencilFunction to specify depth or stencil tests will pass if the new depth value is not equal to the stored value */\nEngine.NOTEQUAL = Constants.NOTEQUAL;\n// Stencil Actions Constants.\n/** Passed to stencilOperation to specify that stencil value must be kept */\nEngine.KEEP = Constants.KEEP;\n/** Passed to stencilOperation to specify that stencil value must be replaced */\nEngine.REPLACE = Constants.REPLACE;\n/** Passed to stencilOperation to specify that stencil value must be incremented */\nEngine.INCR = Constants.INCR;\n/** Passed to stencilOperation to specify that stencil value must be decremented */\nEngine.DECR = Constants.DECR;\n/** Passed to stencilOperation to specify that stencil value must be inverted */\nEngine.INVERT = Constants.INVERT;\n/** Passed to stencilOperation to specify that stencil value must be incremented with wrapping */\nEngine.INCR_WRAP = Constants.INCR_WRAP;\n/** Passed to stencilOperation to specify that stencil value must be decremented with wrapping */\nEngine.DECR_WRAP = Constants.DECR_WRAP;\n/** Texture is not repeating outside of 0..1 UVs */\nEngine.TEXTURE_CLAMP_ADDRESSMODE = Constants.TEXTURE_CLAMP_ADDRESSMODE;\n/** Texture is repeating outside of 0..1 UVs */\nEngine.TEXTURE_WRAP_ADDRESSMODE = Constants.TEXTURE_WRAP_ADDRESSMODE;\n/** Texture is repeating and mirrored */\nEngine.TEXTURE_MIRROR_ADDRESSMODE = Constants.TEXTURE_MIRROR_ADDRESSMODE;\n/** ALPHA */\nEngine.TEXTUREFORMAT_ALPHA = Constants.TEXTUREFORMAT_ALPHA;\n/** LUMINANCE */\nEngine.TEXTUREFORMAT_LUMINANCE = Constants.TEXTUREFORMAT_LUMINANCE;\n/** LUMINANCE_ALPHA */\nEngine.TEXTUREFORMAT_LUMINANCE_ALPHA = Constants.TEXTUREFORMAT_LUMINANCE_ALPHA;\n/** RGB */\nEngine.TEXTUREFORMAT_RGB = Constants.TEXTUREFORMAT_RGB;\n/** RGBA */\nEngine.TEXTUREFORMAT_RGBA = Constants.TEXTUREFORMAT_RGBA;\n/** RED */\nEngine.TEXTUREFORMAT_RED = Constants.TEXTUREFORMAT_RED;\n/** RED (2nd reference) */\nEngine.TEXTUREFORMAT_R = Constants.TEXTUREFORMAT_R;\n/** RG */\nEngine.TEXTUREFORMAT_RG = Constants.TEXTUREFORMAT_RG;\n/** RED_INTEGER */\nEngine.TEXTUREFORMAT_RED_INTEGER = Constants.TEXTUREFORMAT_RED_INTEGER;\n/** RED_INTEGER (2nd reference) */\nEngine.TEXTUREFORMAT_R_INTEGER = Constants.TEXTUREFORMAT_R_INTEGER;\n/** RG_INTEGER */\nEngine.TEXTUREFORMAT_RG_INTEGER = Constants.TEXTUREFORMAT_RG_INTEGER;\n/** RGB_INTEGER */\nEngine.TEXTUREFORMAT_RGB_INTEGER = Constants.TEXTUREFORMAT_RGB_INTEGER;\n/** RGBA_INTEGER */\nEngine.TEXTUREFORMAT_RGBA_INTEGER = Constants.TEXTUREFORMAT_RGBA_INTEGER;\n/** UNSIGNED_BYTE */\nEngine.TEXTURETYPE_UNSIGNED_BYTE = Constants.TEXTURETYPE_UNSIGNED_BYTE;\n/** UNSIGNED_BYTE (2nd reference) */\nEngine.TEXTURETYPE_UNSIGNED_INT = Constants.TEXTURETYPE_UNSIGNED_INT;\n/** FLOAT */\nEngine.TEXTURETYPE_FLOAT = Constants.TEXTURETYPE_FLOAT;\n/** HALF_FLOAT */\nEngine.TEXTURETYPE_HALF_FLOAT = Constants.TEXTURETYPE_HALF_FLOAT;\n/** BYTE */\nEngine.TEXTURETYPE_BYTE = Constants.TEXTURETYPE_BYTE;\n/** SHORT */\nEngine.TEXTURETYPE_SHORT = Constants.TEXTURETYPE_SHORT;\n/** UNSIGNED_SHORT */\nEngine.TEXTURETYPE_UNSIGNED_SHORT = Constants.TEXTURETYPE_UNSIGNED_SHORT;\n/** INT */\nEngine.TEXTURETYPE_INT = Constants.TEXTURETYPE_INT;\n/** UNSIGNED_INT */\nEngine.TEXTURETYPE_UNSIGNED_INTEGER = Constants.TEXTURETYPE_UNSIGNED_INTEGER;\n/** UNSIGNED_SHORT_4_4_4_4 */\nEngine.TEXTURETYPE_UNSIGNED_SHORT_4_4_4_4 = Constants.TEXTURETYPE_UNSIGNED_SHORT_4_4_4_4;\n/** UNSIGNED_SHORT_5_5_5_1 */\nEngine.TEXTURETYPE_UNSIGNED_SHORT_5_5_5_1 = Constants.TEXTURETYPE_UNSIGNED_SHORT_5_5_5_1;\n/** UNSIGNED_SHORT_5_6_5 */\nEngine.TEXTURETYPE_UNSIGNED_SHORT_5_6_5 = Constants.TEXTURETYPE_UNSIGNED_SHORT_5_6_5;\n/** UNSIGNED_INT_2_10_10_10_REV */\nEngine.TEXTURETYPE_UNSIGNED_INT_2_10_10_10_REV = Constants.TEXTURETYPE_UNSIGNED_INT_2_10_10_10_REV;\n/** UNSIGNED_INT_24_8 */\nEngine.TEXTURETYPE_UNSIGNED_INT_24_8 = Constants.TEXTURETYPE_UNSIGNED_INT_24_8;\n/** UNSIGNED_INT_10F_11F_11F_REV */\nEngine.TEXTURETYPE_UNSIGNED_INT_10F_11F_11F_REV = Constants.TEXTURETYPE_UNSIGNED_INT_10F_11F_11F_REV;\n/** UNSIGNED_INT_5_9_9_9_REV */\nEngine.TEXTURETYPE_UNSIGNED_INT_5_9_9_9_REV = Constants.TEXTURETYPE_UNSIGNED_INT_5_9_9_9_REV;\n/** FLOAT_32_UNSIGNED_INT_24_8_REV */\nEngine.TEXTURETYPE_FLOAT_32_UNSIGNED_INT_24_8_REV = Constants.TEXTURETYPE_FLOAT_32_UNSIGNED_INT_24_8_REV;\n/** nearest is mag = nearest and min = nearest and mip = none */\nEngine.TEXTURE_NEAREST_SAMPLINGMODE = Constants.TEXTURE_NEAREST_SAMPLINGMODE;\n/** Bilinear is mag = linear and min = linear and mip = nearest */\nEngine.TEXTURE_BILINEAR_SAMPLINGMODE = Constants.TEXTURE_BILINEAR_SAMPLINGMODE;\n/** Trilinear is mag = linear and min = linear and mip = linear */\nEngine.TEXTURE_TRILINEAR_SAMPLINGMODE = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE;\n/** nearest is mag = nearest and min = nearest and mip = linear */\nEngine.TEXTURE_NEAREST_NEAREST_MIPLINEAR = Constants.TEXTURE_NEAREST_NEAREST_MIPLINEAR;\n/** Bilinear is mag = linear and min = linear and mip = nearest */\nEngine.TEXTURE_LINEAR_LINEAR_MIPNEAREST = Constants.TEXTURE_LINEAR_LINEAR_MIPNEAREST;\n/** Trilinear is mag = linear and min = linear and mip = linear */\nEngine.TEXTURE_LINEAR_LINEAR_MIPLINEAR = Constants.TEXTURE_LINEAR_LINEAR_MIPLINEAR;\n/** mag = nearest and min = nearest and mip = nearest */\nEngine.TEXTURE_NEAREST_NEAREST_MIPNEAREST = Constants.TEXTURE_NEAREST_NEAREST_MIPNEAREST;\n/** mag = nearest and min = linear and mip = nearest */\nEngine.TEXTURE_NEAREST_LINEAR_MIPNEAREST = Constants.TEXTURE_NEAREST_LINEAR_MIPNEAREST;\n/** mag = nearest and min = linear and mip = linear */\nEngine.TEXTURE_NEAREST_LINEAR_MIPLINEAR = Constants.TEXTURE_NEAREST_LINEAR_MIPLINEAR;\n/** mag = nearest and min = linear and mip = none */\nEngine.TEXTURE_NEAREST_LINEAR = Constants.TEXTURE_NEAREST_LINEAR;\n/** mag = nearest and min = nearest and mip = none */\nEngine.TEXTURE_NEAREST_NEAREST = Constants.TEXTURE_NEAREST_NEAREST;\n/** mag = linear and min = nearest and mip = nearest */\nEngine.TEXTURE_LINEAR_NEAREST_MIPNEAREST = Constants.TEXTURE_LINEAR_NEAREST_MIPNEAREST;\n/** mag = linear and min = nearest and mip = linear */\nEngine.TEXTURE_LINEAR_NEAREST_MIPLINEAR = Constants.TEXTURE_LINEAR_NEAREST_MIPLINEAR;\n/** mag = linear and min = linear and mip = none */\nEngine.TEXTURE_LINEAR_LINEAR = Constants.TEXTURE_LINEAR_LINEAR;\n/** mag = linear and min = nearest and mip = none */\nEngine.TEXTURE_LINEAR_NEAREST = Constants.TEXTURE_LINEAR_NEAREST;\n/** Explicit coordinates mode */\nEngine.TEXTURE_EXPLICIT_MODE = Constants.TEXTURE_EXPLICIT_MODE;\n/** Spherical coordinates mode */\nEngine.TEXTURE_SPHERICAL_MODE = Constants.TEXTURE_SPHERICAL_MODE;\n/** Planar coordinates mode */\nEngine.TEXTURE_PLANAR_MODE = Constants.TEXTURE_PLANAR_MODE;\n/** Cubic coordinates mode */\nEngine.TEXTURE_CUBIC_MODE = Constants.TEXTURE_CUBIC_MODE;\n/** Projection coordinates mode */\nEngine.TEXTURE_PROJECTION_MODE = Constants.TEXTURE_PROJECTION_MODE;\n/** Skybox coordinates mode */\nEngine.TEXTURE_SKYBOX_MODE = Constants.TEXTURE_SKYBOX_MODE;\n/** Inverse Cubic coordinates mode */\nEngine.TEXTURE_INVCUBIC_MODE = Constants.TEXTURE_INVCUBIC_MODE;\n/** Equirectangular coordinates mode */\nEngine.TEXTURE_EQUIRECTANGULAR_MODE = Constants.TEXTURE_EQUIRECTANGULAR_MODE;\n/** Equirectangular Fixed coordinates mode */\nEngine.TEXTURE_FIXED_EQUIRECTANGULAR_MODE = Constants.TEXTURE_FIXED_EQUIRECTANGULAR_MODE;\n/** Equirectangular Fixed Mirrored coordinates mode */\nEngine.TEXTURE_FIXED_EQUIRECTANGULAR_MIRRORED_MODE = Constants.TEXTURE_FIXED_EQUIRECTANGULAR_MIRRORED_MODE;\n// Texture rescaling mode\n/** Defines that texture rescaling will use a floor to find the closer power of 2 size */\nEngine.SCALEMODE_FLOOR = Constants.SCALEMODE_FLOOR;\n/** Defines that texture rescaling will look for the nearest power of 2 size */\nEngine.SCALEMODE_NEAREST = Constants.SCALEMODE_NEAREST;\n/** Defines that texture rescaling will use a ceil to find the closer power of 2 size */\nEngine.SCALEMODE_CEILING = Constants.SCALEMODE_CEILING;\n//# sourceMappingURL=engine.js.map"],"names":["PerformanceMonitor","constructor","frameSampleSize","this","_enabled","_rollingFrameTime","RollingAverage","sampleFrame","timeMs","PrecisionDate","Now","_lastFrameTimeMs","dt","add","averageFrameTime","average","averageFrameTimeVariance","variance","instantaneousFrameTime","history","averageFPS","instantaneousFPS","isSaturated","enable","disable","isEnabled","reset","length","_samples","Array","v","delta","bottomValue","_pos","_sampleCount","_m2","i","i0","_wrapPosition","max","RequestPointerlock","element","requestPointerLock","promise","Promise","then","focus","catch","ThinEngine","prototype","setAlphaMode","mode","noDepthWriteChange","_alphaMode","Constants","ALPHA_DISABLE","_alphaState","alphaBlend","ALPHA_PREMULTIPLIED","setAlphaBlendFunctionParameters","_gl","ONE","ONE_MINUS_SRC_ALPHA","ALPHA_PREMULTIPLIED_PORTERDUFF","ALPHA_COMBINE","SRC_ALPHA","ALPHA_ONEONE","ZERO","ALPHA_ADD","ALPHA_SUBTRACT","ONE_MINUS_SRC_COLOR","ALPHA_MULTIPLY","DST_COLOR","ALPHA_MAXIMIZED","ALPHA_INTERPOLATE","CONSTANT_COLOR","ONE_MINUS_CONSTANT_COLOR","CONSTANT_ALPHA","ONE_MINUS_CONSTANT_ALPHA","ALPHA_SCREENMODE","ALPHA_ONEONE_ONEONE","ALPHA_ALPHATOCOLOR","DST_ALPHA","ALPHA_REVERSEONEMINUS","ONE_MINUS_DST_COLOR","ONE_MINUS_DST_ALPHA","ALPHA_SRC_DSTONEMINUSSRCALPHA","ALPHA_ONEONE_ONEZERO","ALPHA_EXCLUSION","ALPHA_LAYER_ACCUMULATE","depthCullingState","depthMask","updateDynamicIndexBuffer","indexBuffer","indices","offset","view","_currentBoundBuffer","ELEMENT_ARRAY_BUFFER","bindIndexBuffer","is32Bits","Uint32Array","Uint16Array","bufferData","DYNAMIC_DRAW","_resetIndexBufferBinding","updateDynamicVertexBuffer","vertexBuffer","data","byteOffset","byteLength","bindArrayBuffer","undefined","dataLength","bufferSubData","ARRAY_BUFFER","Float32Array","subarray","ArrayBuffer","Uint8Array","buffer","_resetVertexBufferBinding","AbstractEngine","displayLoadingUI","IsWindowObjectExist","loadingScreen","hideLoadingUI","_loadingScreen","Object","defineProperty","get","_renderingCanvas","DefaultLoadingScreenFactory","set","value","enumerable","configurable","loadingUIText","loadingUIBackgroundColor","getInputElement","getRenderingCanvasClientRect","getBoundingClientRect","getInputElementClientRect","getAspectRatio","viewportOwner","useScreen","viewport","getRenderWidth","width","getRenderHeight","height","getScreenAspectRatio","_verifyPointerLock","_onPointerLockChange","setAlphaEquation","equation","_alphaEquation","ALPHA_EQUATION_ADD","setAlphaEquationParameters","GL_ALPHA_EQUATION_ADD","ALPHA_EQUATION_SUBSTRACT","GL_ALPHA_EQUATION_SUBTRACT","ALPHA_EQUATION_REVERSE_SUBTRACT","GL_ALPHA_EQUATION_REVERSE_SUBTRACT","ALPHA_EQUATION_MAX","GL_ALPHA_EQUATION_MAX","ALPHA_EQUATION_MIN","GL_ALPHA_EQUATION_MIN","ALPHA_EQUATION_DARKEN","getDepthFunction","_depthCullingState","depthFunc","setDepthFunction","setDepthFunctionToGreater","GREATER","setDepthFunctionToGreaterOrEqual","GEQUAL","setDepthFunctionToLess","LESS","setDepthFunctionToLessOrEqual","LEQUAL","getDepthWrite","setDepthWrite","getStencilBuffer","_stencilState","stencilTest","setStencilBuffer","getStencilMask","stencilMask","setStencilMask","mask","getStencilFunction","stencilFunc","getStencilFunctionReference","stencilFuncRef","getStencilFunctionMask","stencilFuncMask","setStencilFunction","setStencilFunctionReference","reference","setStencilFunctionMask","getStencilOperationFail","stencilOpStencilFail","getStencilOperationDepthFail","stencilOpDepthFail","getStencilOperationPass","stencilOpStencilDepthPass","setStencilOperationFail","operation","setStencilOperationDepthFail","setStencilOperationPass","cacheStencilState","_cachedStencilBuffer","_cachedStencilFunction","_cachedStencilMask","_cachedStencilOperationPass","_cachedStencilOperationFail","_cachedStencilOperationDepthFail","_cachedStencilReference","restoreStencilState","setAlphaConstants","r","g","b","a","setAlphaBlendConstants","getAlphaMode","getAlphaEquation","getRenderPassNames","_renderPassNames","getCurrentRenderPassName","currentRenderPassId","createRenderPassId","name","id","_RenderPassIdCounter","releaseRenderPassId","s","scenes","scene","m","meshes","mesh","subMeshes","_removeDrawWrapper","Engine","NpmPackage","Version","Instances","EngineStore","LastCreatedEngine","LastCreatedScene","canvas","_supportsHardwareTextureRescaling","_RescalePostProcessFactory","_measureFps","_performanceMonitor","_fps","_deltaTime","performanceMonitor","canvasOrContext","antialias","options","adaptToDeviceRatio","super","customAnimationFrameRequester","_drawCalls","PerfCounter","_features","supportRenderPasses","_creationOptions","getContext","_sharedInit","_initGLContext","_rescalePostProcess","commonEngine","creationOptions","_onCanvasFocus","onCanvasFocusObservable","notifyObservers","_onCanvasBlur","onCanvasBlurObservable","_onCanvasContextMenu","evt","disableContextMenu","preventDefault","addEventListener","_onBlur","disablePerformanceMonitorInBackground","_windowIsBackground","_onFocus","_onCanvasPointerOut","ev","document","elementFromPoint","clientX","clientY","onCanvasPointerOutObservable","hostWindow","getHostWindow","doNotHandleTouchAction","setAttribute","style","touchAction","webkitTapHighlightColor","_DisableTouchAction","audioEngine","AudioEngineFactory","getRenderingCanvas","getAudioContext","getAudioDestination","IsDocumentAvailable","_onFullscreenChange","isFullscreen","fullscreenElement","_pointerLockRequested","isPointerLock","pointerLockElement","enableOfflineSupport","OfflineProviderFactory","_deterministicLockstep","deterministicLockstep","_lockstepMaxSteps","lockstepMaxSteps","_timeStep","timeStep","_CommonInit","resizeImageBitmap","image","bufferWidth","bufferHeight","engine","context","createCanvas","Error","drawImage","getImageData","ResizeImageBitmap","_createImageBitmapFromSource","imageSource","resolve","reject","Image","onload","decode","createImageBitmap","imageBitmap","onerror","src","CreateImageBitmapFromSource","switchFullscreen","exitFullscreen","enterFullscreen","requestFunction","requestFullscreen","webkitRequestFullscreen","call","RequestFullscreen","anyDoc","webkitCancelFullScreen","ExitFullscreen","setDitheringState","DITHER","setRasterizerState","RASTERIZER_DISCARD","setDirectViewport","x","y","currentViewport","_cachedViewport","_viewport","scissorClear","clearColor","enableScissor","clear","disableScissor","gl","SCISSOR_TEST","scissor","_loadFileAsync","url","offlineProvider","useArrayBuffer","_loadFile","request","exception","getVertexShaderSource","program","shaders","getAttachedShaders","getShaderSource","getFragmentShaderSource","framebufferDimensionsObject","dimensions","_framebufferDimensionsObject","onResizeObservable","_rebuildBuffers","resetCachedMaterial","_rebuildGeometries","_virtualScenes","getFontOffset","font","text","createElement","textContent","block","display","verticalAlign","div","whiteSpace","appendChild","body","fontAscent","fontHeight","top","removeChild","ascent","descent","GetFontOffset","_cancelFrame","_frameHandler","cancelAnimationFrame","requestID","_renderLoop","_contextWasLost","shouldRender","isDisposed","renderEvenInBackground","beginFrame","_renderViews","_renderFrame","endFrame","_activeRenderLoops","_queueNewFrame","renderFunction","_boundRenderFunction","enterPointerlock","exitPointerlock","exitPointerLock","_deletePipelineContext","pipelineContext","webGLPipelineContext","transformFeedback","deleteTransformFeedback","createShaderProgram","vertexCode","fragmentCode","defines","transformFeedbackVaryings","onBeforeShaderCompilationObservable","onAfterShaderCompilationObservable","_createShaderProgram","vertexShader","fragmentShader","shaderProgram","createProgram","attachShader","webGLVersion","createTransformFeedback","bindTransformFeedback","setTranformFeedbackVaryings","linkProgram","isParallelCompiled","_finalizePipelineContext","_releaseTexture","texture","_releaseRenderTargetWrapper","rtWrapper","forEach","postProcesses","postProcess","_outputTexture","cameras","camera","_postProcesses","_rescaleTexture","source","destination","internalFormat","onComplete","texParameteri","TEXTURE_2D","TEXTURE_MAG_FILTER","LINEAR","TEXTURE_MIN_FILTER","TEXTURE_WRAP_S","CLAMP_TO_EDGE","TEXTURE_WRAP_T","rtt","createRenderTargetTexture","generateMipMaps","type","TEXTURETYPE_UNSIGNED_INT","samplingMode","TEXTURE_BILINEAR_SAMPLINGMODE","generateDepthBuffer","generateStencilBuffer","externalTextureSamplerBinding","onCompiled","onApply","effect","_bindTexture","hostingScene","postProcessManager","directRender","_bindTextureDirectly","copyTexImage2D","unBindFramebuffer","dispose","getEffect","executeWhenCompiled","onEffectCreatedObservable","addOnce","wrapWebGLTexture","hasMipMaps","TEXTURE_TRILINEAR_SAMPLINGMODE","hardwareTexture","WebGLHardwareTexture","internalTexture","InternalTexture","_hardwareTexture","baseWidth","baseHeight","isReady","useMipMaps","updateTextureSamplingMode","_uploadImageToTexture","faceIndex","lod","textureType","_getWebGLTextureType","format","_getInternalFormat","_getRGBABufferInternalSizedFormat","bindTarget","isCube","TEXTURE_CUBE_MAP","_unpackFlipY","invertY","target","TEXTURE_CUBE_MAP_POSITIVE_X","texImage2D","updateTextureComparisonFunction","comparisonFunction","Logger","TEXTURE_COMPARE_FUNC","TEXTURE_COMPARE_MODE","NONE","COMPARE_REF_TO_TEXTURE","_comparisonFunction","createInstancesBuffer","capacity","createBuffer","result","WebGLDataBuffer","references","deleteInstancesBuffer","deleteBuffer","_clientWaitAsync","sync","flags","intervalms","check","res","clientWaitSync","WAIT_FAILED","TIMEOUT_EXPIRED","setTimeout","_readPixelsAsync","w","h","outputBuffer","_webGLVersion","buf","bindBuffer","PIXEL_PACK_BUFFER","STREAM_READ","readPixels","fenceSync","SYNC_GPU_COMMANDS_COMPLETE","flush","deleteSync","getBufferSubData","removeEventListener","_CommonDispose","DELAYLOADSTATE_NONE","DELAYLOADSTATE_LOADED","DELAYLOADSTATE_LOADING","DELAYLOADSTATE_NOTLOADED","NEVER","ALWAYS","EQUAL","NOTEQUAL","KEEP","REPLACE","INCR","DECR","INVERT","INCR_WRAP","DECR_WRAP","TEXTURE_CLAMP_ADDRESSMODE","TEXTURE_WRAP_ADDRESSMODE","TEXTURE_MIRROR_ADDRESSMODE","TEXTUREFORMAT_ALPHA","TEXTUREFORMAT_LUMINANCE","TEXTUREFORMAT_LUMINANCE_ALPHA","TEXTUREFORMAT_RGB","TEXTUREFORMAT_RGBA","TEXTUREFORMAT_RED","TEXTUREFORMAT_R","TEXTUREFORMAT_RG","TEXTUREFORMAT_RED_INTEGER","TEXTUREFORMAT_R_INTEGER","TEXTUREFORMAT_RG_INTEGER","TEXTUREFORMAT_RGB_INTEGER","TEXTUREFORMAT_RGBA_INTEGER","TEXTURETYPE_UNSIGNED_BYTE","TEXTURETYPE_FLOAT","TEXTURETYPE_HALF_FLOAT","TEXTURETYPE_BYTE","TEXTURETYPE_SHORT","TEXTURETYPE_UNSIGNED_SHORT","TEXTURETYPE_INT","TEXTURETYPE_UNSIGNED_INTEGER","TEXTURETYPE_UNSIGNED_SHORT_4_4_4_4","TEXTURETYPE_UNSIGNED_SHORT_5_5_5_1","TEXTURETYPE_UNSIGNED_SHORT_5_6_5","TEXTURETYPE_UNSIGNED_INT_2_10_10_10_REV","TEXTURETYPE_UNSIGNED_INT_24_8","TEXTURETYPE_UNSIGNED_INT_10F_11F_11F_REV","TEXTURETYPE_UNSIGNED_INT_5_9_9_9_REV","TEXTURETYPE_FLOAT_32_UNSIGNED_INT_24_8_REV","TEXTURE_NEAREST_SAMPLINGMODE","TEXTURE_NEAREST_NEAREST_MIPLINEAR","TEXTURE_LINEAR_LINEAR_MIPNEAREST","TEXTURE_LINEAR_LINEAR_MIPLINEAR","TEXTURE_NEAREST_NEAREST_MIPNEAREST","TEXTURE_NEAREST_LINEAR_MIPNEAREST","TEXTURE_NEAREST_LINEAR_MIPLINEAR","TEXTURE_NEAREST_LINEAR","TEXTURE_NEAREST_NEAREST","TEXTURE_LINEAR_NEAREST_MIPNEAREST","TEXTURE_LINEAR_NEAREST_MIPLINEAR","TEXTURE_LINEAR_LINEAR","TEXTURE_LINEAR_NEAREST","TEXTURE_EXPLICIT_MODE","TEXTURE_SPHERICAL_MODE","TEXTURE_PLANAR_MODE","TEXTURE_CUBIC_MODE","TEXTURE_PROJECTION_MODE","TEXTURE_SKYBOX_MODE","TEXTURE_INVCUBIC_MODE","TEXTURE_EQUIRECTANGULAR_MODE","TEXTURE_FIXED_EQUIRECTANGULAR_MODE","TEXTURE_FIXED_EQUIRECTANGULAR_MIRRORED_MODE","SCALEMODE_FLOOR","SCALEMODE_NEAREST","SCALEMODE_CEILING"],"mappings":"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"}

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

@@ -0,0 +1,2 @@
+import{G as e,U as n,a as t}from"./environmentTextureTools-CiyJLBbf.esm.min.js";import"./index-RwQCgcf4.esm.min.js";class o{constructor(){this.supportCascades=!1}loadCubeData(o,a,r,s,i){if(Array.isArray(o))return;const d=e(o);if(d){a.width=d.width,a.height=d.width;try{n(a,d),t(a,o,d).then((()=>{a.isReady=!0,a.onLoadedObservable.notifyObservers(a),a.onLoadedObservable.clear(),s&&s()}),(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{o as _ENVTextureLoader};
+//# sourceMappingURL=envTextureLoader-DLAJXIl8.esm.min.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"envTextureLoader-DLAJXIl8.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":"oHAMO,MAAMA,EACT,WAAAC,GAIIC,KAAKC,iBAAkB,CAC1B,CASD,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,GACH,IACDe,IACAd,IAAU,oCAAqCc,EAAO,GAE7D,CACD,MAAOC,GACHf,IAAU,kCAAmCe,EAChD,CACJ,MACQf,GACLA,EAAQ,qCAAsC,KAErD,CAID,QAAAgB,GAEI,KAAM,2BACT"}

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

@@ -0,0 +1,63 @@
+import { G as GetEnvInfo, U as UploadEnvSpherical, a as UploadEnvLevelsAsync } from './environmentTextureTools-bPqq81in.esm.js';
+import './index-5EaMDaGg.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-DpLIoFjS.esm.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"envTextureLoader-DpLIoFjS.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,CAAC;AACrC,KAAK;AACL;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,OAAO;AACnB,SAAS;AACT,QAAQ,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;AACtC,QAAQ,IAAI,IAAI,EAAE;AAClB,YAAY,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;AACvC,YAAY,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC;AACxC,YAAY,IAAI;AAChB,gBAAgB,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAClD,gBAAgB,oBAAoB,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM;AACrE,oBAAoB,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;AAC3C,oBAAoB,OAAO,CAAC,kBAAkB,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;AACxE,oBAAoB,OAAO,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;AACvD,oBAAoB,IAAI,MAAM,EAAE;AAChC,wBAAwB,MAAM,EAAE,CAAC;AACjC,qBAAqB;AACrB,iBAAiB,EAAE,CAAC,MAAM,KAAK;AAC/B,oBAAoB,OAAO,GAAG,mCAAmC,EAAE,MAAM,CAAC,CAAC;AAC3E,iBAAiB,CAAC,CAAC;AACnB,aAAa;AACb,YAAY,OAAO,CAAC,EAAE;AACtB,gBAAgB,OAAO,GAAG,iCAAiC,EAAE,CAAC,CAAC,CAAC;AAChE,aAAa;AACb,SAAS;AACT,aAAa,IAAI,OAAO,EAAE;AAC1B,YAAY,OAAO,CAAC,oCAAoC,EAAE,IAAI,CAAC,CAAC;AAChE,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA,IAAI,QAAQ,GAAG;AACf;AACA,QAAQ,MAAM,2BAA2B,CAAC;AAC1C,KAAK;AACL;;;;"}

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

@@ -0,0 +1,2 @@
+import{L as e,k as t,b3 as r,C as n,b4 as o,c as a,Y as i,as as s,h as l}from"./index-RwQCgcf4.esm.min.js";const u="image/png",p=2,c=[134,22,135,150,246,214,150,54];function T(t){const r=new DataView(t.buffer,t.byteOffset,t.byteLength);let n=0;for(let t=0;t<c.length;t++)if(r.getUint8(n++)!==c[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=d(i),i.specular&&(i.specular.specularDataPosition=n,i.specular.lodGenerationScale=i.specular.lodGenerationScale||.8),i}function d(e){if(e.version>p)throw new Error(`Unsupported babylon environment map version "${e.version}". Latest supported version is "${p}".`);return 2===e.version?e:e={...e,version:2,imageType:u}}function f(e,t,r){const n=(r=d(r)).specular;if(!n)return Promise.resolve();e._lodGenerationScale=n.lodGenerationScale;const o=function(e,t){const r=(t=d(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 _(e,o,r.imageType)}function m(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 _(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,f=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-DSa_xyAA.esm.min.js")):await import("./rgbdDecode.fragment-B97s0YHK.esm.min.js"),f=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=>m(n,c,T,f,a,r,t,d,y,_,e)));else{const n=new Image;n.src=a,i=new Promise(((o,i)=>{n.onload=()=>{m(n,c,T,f,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)),f&&f.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 y(e,t){const r=(t=d(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 g(e,t,r,n,o){const a=_(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,_(e,t).then((()=>(e.isReady=!0,e)))}export{T as G,y as U,g as _,f as a};
+//# sourceMappingURL=environmentTextureTools-CiyJLBbf.esm.min.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"environmentTextureTools-CiyJLBbf.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 \"../Engines/Extensions/engine.renderTargetCube\";\nimport \"../Engines/Extensions/engine.readTexture\";\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_INT &&\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","CurrentVersion","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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"}