@babylonjs/viewer 7.40.3 → 7.40.4-alpha

package/dist/chunks/engine-D9Sn-BC6.esm.js

@@ -0,0 +1,2213 @@
+import { C as Constants, I as InternalTexture, L as Logger, a as IsExponentOfTwo, b as allocateAndCopyTypedBuffer, G as GetExponentOfTwo, H as HasStencilAspect, S as SphericalPolynomial, B as BaseTexture, A as AbstractEngine, E as EngineStore, P as PerfCounter, _ as _retryWithInterval } from './index-5L5wXyrx.esm.js';
+import { T as ThinEngine, W as WebGLDataBuffer, a as WebGLHardwareTexture } from './thinEngine-DGyFDxzW.esm.js';
+import { R as RenderTargetWrapper, P as PerformanceMonitor, _ as _CommonInit, a as ResizeImageBitmap, C as CreateImageBitmapFromSource, b as RequestFullscreen, E as ExitFullscreen, G as GetFontOffset, c as RequestPointerlock, d as ExitPointerlock, e as _CommonDispose } from './engine.common-BM1GAef8.esm.js';
+import './audioEngine-BZB34VjD.esm.js';
+import './drawWrapper.functions-CKg3_9x4.esm.js';
+
+ThinEngine.prototype.setAlphaMode = function (mode, noDepthWriteChange = false) {
+    if (this._alphaMode === mode) {
+        if (!noDepthWriteChange) {
+            // 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)
+            const depthMask = mode === Constants.ALPHA_DISABLE;
+            if (this.depthCullingState.depthMask !== depthMask) {
+                this.depthCullingState.depthMask = depthMask;
+            }
+        }
+        return;
+    }
+    switch (mode) {
+        case Constants.ALPHA_DISABLE:
+            this._alphaState.alphaBlend = false;
+            break;
+        case Constants.ALPHA_PREMULTIPLIED:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_PREMULTIPLIED_PORTERDUFF:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_COMBINE:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.SRC_ALPHA, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_ONEONE:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE, this._gl.ZERO, this._gl.ONE);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_ADD:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.SRC_ALPHA, this._gl.ONE, this._gl.ZERO, this._gl.ONE);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_SUBTRACT:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ZERO, this._gl.ONE_MINUS_SRC_COLOR, this._gl.ONE, this._gl.ONE);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_MULTIPLY:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.DST_COLOR, this._gl.ZERO, this._gl.ONE, this._gl.ONE);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_MAXIMIZED:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.SRC_ALPHA, this._gl.ONE_MINUS_SRC_COLOR, this._gl.ONE, this._gl.ONE);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_INTERPOLATE:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.CONSTANT_COLOR, this._gl.ONE_MINUS_CONSTANT_COLOR, this._gl.CONSTANT_ALPHA, this._gl.ONE_MINUS_CONSTANT_ALPHA);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_SCREENMODE:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE_MINUS_SRC_COLOR, this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_ONEONE_ONEONE:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE, this._gl.ONE, this._gl.ONE);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_ALPHATOCOLOR:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.DST_ALPHA, this._gl.ONE, this._gl.ZERO, this._gl.ZERO);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_REVERSEONEMINUS:
+            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);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_SRC_DSTONEMINUSSRCALPHA:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_ONEONE_ONEZERO:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE, this._gl.ONE, this._gl.ZERO);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_EXCLUSION:
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE_MINUS_DST_COLOR, this._gl.ONE_MINUS_SRC_COLOR, this._gl.ZERO, this._gl.ONE);
+            this._alphaState.alphaBlend = true;
+            break;
+        case Constants.ALPHA_LAYER_ACCUMULATE:
+            // Same as ALPHA_COMBINE but accumulates (1 - alpha) values in the alpha channel for a later readout in order independant transparency
+            this._alphaState.setAlphaBlendFunctionParameters(this._gl.SRC_ALPHA, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE_MINUS_SRC_ALPHA);
+            this._alphaState.alphaBlend = true;
+            break;
+    }
+    if (!noDepthWriteChange) {
+        this.depthCullingState.depthMask = mode === Constants.ALPHA_DISABLE;
+    }
+    this._alphaMode = mode;
+};
+
+ThinEngine.prototype.updateRawTexture = function (texture, data, format, invertY, compression = null, type = Constants.TEXTURETYPE_UNSIGNED_BYTE, useSRGBBuffer = false) {
+    if (!texture) {
+        return;
+    }
+    // Babylon's internalSizedFomat but gl's texImage2D internalFormat
+    const internalSizedFomat = this._getRGBABufferInternalSizedFormat(type, format, useSRGBBuffer);
+    // Babylon's internalFormat but gl's texImage2D format
+    const internalFormat = this._getInternalFormat(format);
+    const textureType = this._getWebGLTextureType(type);
+    this._bindTextureDirectly(this._gl.TEXTURE_2D, texture, true);
+    this._unpackFlipY(invertY === undefined ? true : invertY ? true : false);
+    if (!this._doNotHandleContextLost) {
+        texture._bufferView = data;
+        texture.format = format;
+        texture.type = type;
+        texture.invertY = invertY;
+        texture._compression = compression;
+    }
+    if (texture.width % 4 !== 0) {
+        this._gl.pixelStorei(this._gl.UNPACK_ALIGNMENT, 1);
+    }
+    if (compression && data) {
+        this._gl.compressedTexImage2D(this._gl.TEXTURE_2D, 0, this.getCaps().s3tc[compression], texture.width, texture.height, 0, data);
+    }
+    else {
+        this._gl.texImage2D(this._gl.TEXTURE_2D, 0, internalSizedFomat, texture.width, texture.height, 0, internalFormat, textureType, data);
+    }
+    if (texture.generateMipMaps) {
+        this._gl.generateMipmap(this._gl.TEXTURE_2D);
+    }
+    this._bindTextureDirectly(this._gl.TEXTURE_2D, null);
+    //  this.resetTextureCache();
+    texture.isReady = true;
+};
+ThinEngine.prototype.createRawTexture = function (data, width, height, format, generateMipMaps, invertY, samplingMode, compression = null, type = Constants.TEXTURETYPE_UNSIGNED_BYTE, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+creationFlags = 0, useSRGBBuffer = false) {
+    const texture = new InternalTexture(this, 3 /* InternalTextureSource.Raw */);
+    texture.baseWidth = width;
+    texture.baseHeight = height;
+    texture.width = width;
+    texture.height = height;
+    texture.format = format;
+    texture.generateMipMaps = generateMipMaps;
+    texture.samplingMode = samplingMode;
+    texture.invertY = invertY;
+    texture._compression = compression;
+    texture.type = type;
+    texture._useSRGBBuffer = this._getUseSRGBBuffer(useSRGBBuffer, !generateMipMaps);
+    if (!this._doNotHandleContextLost) {
+        texture._bufferView = data;
+    }
+    this.updateRawTexture(texture, data, format, invertY, compression, type, texture._useSRGBBuffer);
+    this._bindTextureDirectly(this._gl.TEXTURE_2D, texture, true);
+    // Filters
+    const filters = this._getSamplingParameters(samplingMode, generateMipMaps);
+    this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_MAG_FILTER, filters.mag);
+    this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_MIN_FILTER, filters.min);
+    if (generateMipMaps) {
+        this._gl.generateMipmap(this._gl.TEXTURE_2D);
+    }
+    this._bindTextureDirectly(this._gl.TEXTURE_2D, null);
+    this._internalTexturesCache.push(texture);
+    return texture;
+};
+ThinEngine.prototype.createRawCubeTexture = function (data, size, format, type, generateMipMaps, invertY, samplingMode, compression = null) {
+    const gl = this._gl;
+    const texture = new InternalTexture(this, 8 /* InternalTextureSource.CubeRaw */);
+    texture.isCube = true;
+    texture.format = format;
+    texture.type = type;
+    if (!this._doNotHandleContextLost) {
+        texture._bufferViewArray = data;
+    }
+    const textureType = this._getWebGLTextureType(type);
+    let internalFormat = this._getInternalFormat(format);
+    if (internalFormat === gl.RGB) {
+        internalFormat = gl.RGBA;
+    }
+    // Mipmap generation needs a sized internal format that is both color-renderable and texture-filterable
+    if (textureType === gl.FLOAT && !this._caps.textureFloatLinearFiltering) {
+        generateMipMaps = false;
+        samplingMode = Constants.TEXTURE_NEAREST_SAMPLINGMODE;
+        Logger.Warn("Float texture filtering is not supported. Mipmap generation and sampling mode are forced to false and TEXTURE_NEAREST_SAMPLINGMODE, respectively.");
+    }
+    else if (textureType === this._gl.HALF_FLOAT_OES && !this._caps.textureHalfFloatLinearFiltering) {
+        generateMipMaps = false;
+        samplingMode = Constants.TEXTURE_NEAREST_SAMPLINGMODE;
+        Logger.Warn("Half float texture filtering is not supported. Mipmap generation and sampling mode are forced to false and TEXTURE_NEAREST_SAMPLINGMODE, respectively.");
+    }
+    else if (textureType === gl.FLOAT && !this._caps.textureFloatRender) {
+        generateMipMaps = false;
+        Logger.Warn("Render to float textures is not supported. Mipmap generation forced to false.");
+    }
+    else if (textureType === gl.HALF_FLOAT && !this._caps.colorBufferFloat) {
+        generateMipMaps = false;
+        Logger.Warn("Render to half float textures is not supported. Mipmap generation forced to false.");
+    }
+    const width = size;
+    const height = width;
+    texture.width = width;
+    texture.height = height;
+    texture.invertY = invertY;
+    texture._compression = compression;
+    // Double check on POT to generate Mips.
+    const isPot = !this.needPOTTextures || (IsExponentOfTwo(texture.width) && IsExponentOfTwo(texture.height));
+    if (!isPot) {
+        generateMipMaps = false;
+    }
+    // Upload data if needed. The texture won't be ready until then.
+    if (data) {
+        this.updateRawCubeTexture(texture, data, format, type, invertY, compression);
+    }
+    else {
+        const internalSizedFomat = this._getRGBABufferInternalSizedFormat(type);
+        const level = 0;
+        this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, texture, true);
+        for (let faceIndex = 0; faceIndex < 6; faceIndex++) {
+            if (compression) {
+                gl.compressedTexImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, level, this.getCaps().s3tc[compression], texture.width, texture.height, 0, undefined);
+            }
+            else {
+                gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, level, internalSizedFomat, texture.width, texture.height, 0, internalFormat, textureType, null);
+            }
+        }
+        this._bindTextureDirectly(this._gl.TEXTURE_CUBE_MAP, null);
+    }
+    this._bindTextureDirectly(this._gl.TEXTURE_CUBE_MAP, texture, true);
+    // Filters
+    if (data && generateMipMaps) {
+        this._gl.generateMipmap(this._gl.TEXTURE_CUBE_MAP);
+    }
+    const filters = this._getSamplingParameters(samplingMode, generateMipMaps);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, filters.mag);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, filters.min);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, null);
+    texture.generateMipMaps = generateMipMaps;
+    texture.samplingMode = samplingMode;
+    texture.isReady = true;
+    return texture;
+};
+ThinEngine.prototype.updateRawCubeTexture = function (texture, data, format, type, invertY, compression = null, level = 0) {
+    texture._bufferViewArray = data;
+    texture.format = format;
+    texture.type = type;
+    texture.invertY = invertY;
+    texture._compression = compression;
+    const gl = this._gl;
+    const textureType = this._getWebGLTextureType(type);
+    let internalFormat = this._getInternalFormat(format);
+    const internalSizedFomat = this._getRGBABufferInternalSizedFormat(type);
+    let needConversion = false;
+    if (internalFormat === gl.RGB) {
+        internalFormat = gl.RGBA;
+        needConversion = true;
+    }
+    this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, texture, true);
+    this._unpackFlipY(invertY === undefined ? true : invertY ? true : false);
+    if (texture.width % 4 !== 0) {
+        gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+    }
+    // Data are known to be in +X +Y +Z -X -Y -Z
+    for (let faceIndex = 0; faceIndex < 6; faceIndex++) {
+        let faceData = data[faceIndex];
+        if (compression) {
+            gl.compressedTexImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, level, this.getCaps().s3tc[compression], texture.width, texture.height, 0, faceData);
+        }
+        else {
+            if (needConversion) {
+                faceData = _convertRGBtoRGBATextureData(faceData, texture.width, texture.height, type);
+            }
+            gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, level, internalSizedFomat, texture.width, texture.height, 0, internalFormat, textureType, faceData);
+        }
+    }
+    const isPot = !this.needPOTTextures || (IsExponentOfTwo(texture.width) && IsExponentOfTwo(texture.height));
+    if (isPot && texture.generateMipMaps && level === 0) {
+        this._gl.generateMipmap(this._gl.TEXTURE_CUBE_MAP);
+    }
+    this._bindTextureDirectly(this._gl.TEXTURE_CUBE_MAP, null);
+    // this.resetTextureCache();
+    texture.isReady = true;
+};
+ThinEngine.prototype.createRawCubeTextureFromUrl = function (url, scene, size, format, type, noMipmap, callback, mipmapGenerator, onLoad = null, onError = null, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, invertY = false) {
+    const gl = this._gl;
+    const texture = this.createRawCubeTexture(null, size, format, type, !noMipmap, invertY, samplingMode, null);
+    scene?.addPendingData(texture);
+    texture.url = url;
+    texture.isReady = false;
+    this._internalTexturesCache.push(texture);
+    const onerror = (request, exception) => {
+        scene?.removePendingData(texture);
+        if (onError && request) {
+            onError(request.status + " " + request.statusText, exception);
+        }
+    };
+    const internalCallback = (data) => {
+        const width = texture.width;
+        const faceDataArrays = callback(data);
+        if (!faceDataArrays) {
+            return;
+        }
+        if (mipmapGenerator) {
+            const textureType = this._getWebGLTextureType(type);
+            let internalFormat = this._getInternalFormat(format);
+            const internalSizedFomat = this._getRGBABufferInternalSizedFormat(type);
+            let needConversion = false;
+            if (internalFormat === gl.RGB) {
+                internalFormat = gl.RGBA;
+                needConversion = true;
+            }
+            this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, texture, true);
+            this._unpackFlipY(false);
+            const mipData = mipmapGenerator(faceDataArrays);
+            for (let level = 0; level < mipData.length; level++) {
+                const mipSize = width >> level;
+                for (let faceIndex = 0; faceIndex < 6; faceIndex++) {
+                    let mipFaceData = mipData[level][faceIndex];
+                    if (needConversion) {
+                        mipFaceData = _convertRGBtoRGBATextureData(mipFaceData, mipSize, mipSize, type);
+                    }
+                    gl.texImage2D(faceIndex, level, internalSizedFomat, mipSize, mipSize, 0, internalFormat, textureType, mipFaceData);
+                }
+            }
+            this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, null);
+        }
+        else {
+            this.updateRawCubeTexture(texture, faceDataArrays, format, type, invertY);
+        }
+        texture.isReady = true;
+        // this.resetTextureCache();
+        scene?.removePendingData(texture);
+        texture.onLoadedObservable.notifyObservers(texture);
+        texture.onLoadedObservable.clear();
+        if (onLoad) {
+            onLoad();
+        }
+    };
+    this._loadFile(url, (data) => {
+        internalCallback(data);
+    }, undefined, scene?.offlineProvider, true, onerror);
+    return texture;
+};
+/**
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function _convertRGBtoRGBATextureData(rgbData, width, height, textureType) {
+    // Create new RGBA data container.
+    let rgbaData;
+    let val1 = 1;
+    if (textureType === Constants.TEXTURETYPE_FLOAT) {
+        rgbaData = new Float32Array(width * height * 4);
+    }
+    else if (textureType === Constants.TEXTURETYPE_HALF_FLOAT) {
+        rgbaData = new Uint16Array(width * height * 4);
+        val1 = 15360; // 15360 is the encoding of 1 in half float
+    }
+    else if (textureType === Constants.TEXTURETYPE_UNSIGNED_INTEGER) {
+        rgbaData = new Uint32Array(width * height * 4);
+    }
+    else {
+        rgbaData = new Uint8Array(width * height * 4);
+    }
+    // Convert each pixel.
+    for (let x = 0; x < width; x++) {
+        for (let y = 0; y < height; y++) {
+            const index = (y * width + x) * 3;
+            const newIndex = (y * width + x) * 4;
+            // Map Old Value to new value.
+            rgbaData[newIndex + 0] = rgbData[index + 0];
+            rgbaData[newIndex + 1] = rgbData[index + 1];
+            rgbaData[newIndex + 2] = rgbData[index + 2];
+            // Add fully opaque alpha channel.
+            rgbaData[newIndex + 3] = val1;
+        }
+    }
+    return rgbaData;
+}
+/**
+ * Create a function for createRawTexture3D/createRawTexture2DArray
+ * @param is3D true for TEXTURE_3D and false for TEXTURE_2D_ARRAY
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function _makeCreateRawTextureFunction(is3D) {
+    return function (data, width, height, depth, format, generateMipMaps, invertY, samplingMode, compression = null, textureType = Constants.TEXTURETYPE_UNSIGNED_BYTE) {
+        const target = is3D ? this._gl.TEXTURE_3D : this._gl.TEXTURE_2D_ARRAY;
+        const source = is3D ? 10 /* InternalTextureSource.Raw3D */ : 11 /* InternalTextureSource.Raw2DArray */;
+        const texture = new InternalTexture(this, source);
+        texture.baseWidth = width;
+        texture.baseHeight = height;
+        texture.baseDepth = depth;
+        texture.width = width;
+        texture.height = height;
+        texture.depth = depth;
+        texture.format = format;
+        texture.type = textureType;
+        texture.generateMipMaps = generateMipMaps;
+        texture.samplingMode = samplingMode;
+        if (is3D) {
+            texture.is3D = true;
+        }
+        else {
+            texture.is2DArray = true;
+        }
+        if (!this._doNotHandleContextLost) {
+            texture._bufferView = data;
+        }
+        if (is3D) {
+            this.updateRawTexture3D(texture, data, format, invertY, compression, textureType);
+        }
+        else {
+            this.updateRawTexture2DArray(texture, data, format, invertY, compression, textureType);
+        }
+        this._bindTextureDirectly(target, texture, true);
+        // Filters
+        const filters = this._getSamplingParameters(samplingMode, generateMipMaps);
+        this._gl.texParameteri(target, this._gl.TEXTURE_MAG_FILTER, filters.mag);
+        this._gl.texParameteri(target, this._gl.TEXTURE_MIN_FILTER, filters.min);
+        if (generateMipMaps) {
+            this._gl.generateMipmap(target);
+        }
+        this._bindTextureDirectly(target, null);
+        this._internalTexturesCache.push(texture);
+        return texture;
+    };
+}
+ThinEngine.prototype.createRawTexture2DArray = _makeCreateRawTextureFunction(false);
+ThinEngine.prototype.createRawTexture3D = _makeCreateRawTextureFunction(true);
+/**
+ * Create a function for updateRawTexture3D/updateRawTexture2DArray
+ * @param is3D true for TEXTURE_3D and false for TEXTURE_2D_ARRAY
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function _makeUpdateRawTextureFunction(is3D) {
+    return function (texture, data, format, invertY, compression = null, textureType = Constants.TEXTURETYPE_UNSIGNED_BYTE) {
+        const target = is3D ? this._gl.TEXTURE_3D : this._gl.TEXTURE_2D_ARRAY;
+        const internalType = this._getWebGLTextureType(textureType);
+        const internalFormat = this._getInternalFormat(format);
+        const internalSizedFomat = this._getRGBABufferInternalSizedFormat(textureType, format);
+        this._bindTextureDirectly(target, texture, true);
+        this._unpackFlipY(invertY === undefined ? true : invertY ? true : false);
+        if (!this._doNotHandleContextLost) {
+            texture._bufferView = data;
+            texture.format = format;
+            texture.invertY = invertY;
+            texture._compression = compression;
+        }
+        if (texture.width % 4 !== 0) {
+            this._gl.pixelStorei(this._gl.UNPACK_ALIGNMENT, 1);
+        }
+        if (compression && data) {
+            this._gl.compressedTexImage3D(target, 0, this.getCaps().s3tc[compression], texture.width, texture.height, texture.depth, 0, data);
+        }
+        else {
+            this._gl.texImage3D(target, 0, internalSizedFomat, texture.width, texture.height, texture.depth, 0, internalFormat, internalType, data);
+        }
+        if (texture.generateMipMaps) {
+            this._gl.generateMipmap(target);
+        }
+        this._bindTextureDirectly(target, null);
+        // this.resetTextureCache();
+        texture.isReady = true;
+    };
+}
+ThinEngine.prototype.updateRawTexture2DArray = _makeUpdateRawTextureFunction(false);
+ThinEngine.prototype.updateRawTexture3D = _makeUpdateRawTextureFunction(true);
+
+ThinEngine.prototype._readTexturePixelsSync = function (texture, width, height, faceIndex = -1, level = 0, buffer = null, flushRenderer = true, noDataConversion = false, x = 0, y = 0) {
+    const gl = this._gl;
+    if (!gl) {
+        throw new Error("Engine does not have gl rendering context.");
+    }
+    if (!this._dummyFramebuffer) {
+        const dummy = gl.createFramebuffer();
+        if (!dummy) {
+            throw new Error("Unable to create dummy framebuffer");
+        }
+        this._dummyFramebuffer = dummy;
+    }
+    gl.bindFramebuffer(gl.FRAMEBUFFER, this._dummyFramebuffer);
+    if (faceIndex > -1) {
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, texture._hardwareTexture?.underlyingResource, level);
+    }
+    else {
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture._hardwareTexture?.underlyingResource, level);
+    }
+    let readType = texture.type !== undefined ? this._getWebGLTextureType(texture.type) : gl.UNSIGNED_BYTE;
+    if (!noDataConversion) {
+        switch (readType) {
+            case gl.UNSIGNED_BYTE:
+                if (!buffer) {
+                    buffer = new Uint8Array(4 * width * height);
+                }
+                readType = gl.UNSIGNED_BYTE;
+                break;
+            default:
+                if (!buffer) {
+                    buffer = new Float32Array(4 * width * height);
+                }
+                readType = gl.FLOAT;
+                break;
+        }
+    }
+    else if (!buffer) {
+        buffer = allocateAndCopyTypedBuffer(texture.type, 4 * width * height);
+    }
+    if (flushRenderer) {
+        this.flushFramebuffer();
+    }
+    gl.readPixels(x, y, width, height, gl.RGBA, readType, buffer);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, this._currentFramebuffer);
+    return buffer;
+};
+ThinEngine.prototype._readTexturePixels = function (texture, width, height, faceIndex = -1, level = 0, buffer = null, flushRenderer = true, noDataConversion = false, x = 0, y = 0) {
+    return Promise.resolve(this._readTexturePixelsSync(texture, width, height, faceIndex, level, buffer, flushRenderer, noDataConversion, x, y));
+};
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+ThinEngine.prototype.updateDynamicIndexBuffer = function (indexBuffer, indices, offset = 0) {
+    // Force cache update
+    this._currentBoundBuffer[this._gl.ELEMENT_ARRAY_BUFFER] = null;
+    this.bindIndexBuffer(indexBuffer);
+    let view;
+    if (indexBuffer.is32Bits) {
+        // anything else than Uint32Array needs to be converted to Uint32Array
+        view = indices instanceof Uint32Array ? indices : new Uint32Array(indices);
+    }
+    else {
+        // anything else than Uint16Array needs to be converted to Uint16Array
+        view = indices instanceof Uint16Array ? indices : new Uint16Array(indices);
+    }
+    this._gl.bufferData(this._gl.ELEMENT_ARRAY_BUFFER, view, this._gl.DYNAMIC_DRAW);
+    this._resetIndexBufferBinding();
+};
+ThinEngine.prototype.updateDynamicVertexBuffer = function (vertexBuffer, data, byteOffset, byteLength) {
+    this.bindArrayBuffer(vertexBuffer);
+    if (byteOffset === undefined) {
+        byteOffset = 0;
+    }
+    const dataLength = data.byteLength || data.length;
+    if (byteLength === undefined || (byteLength >= dataLength && byteOffset === 0)) {
+        if (data instanceof Array) {
+            this._gl.bufferSubData(this._gl.ARRAY_BUFFER, byteOffset, new Float32Array(data));
+        }
+        else {
+            this._gl.bufferSubData(this._gl.ARRAY_BUFFER, byteOffset, data);
+        }
+    }
+    else {
+        if (data instanceof Array) {
+            this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, new Float32Array(data).subarray(byteOffset, byteOffset + byteLength));
+        }
+        else {
+            if (data instanceof ArrayBuffer) {
+                data = new Uint8Array(data, byteOffset, byteLength);
+            }
+            else {
+                data = new Uint8Array(data.buffer, data.byteOffset + byteOffset, byteLength);
+            }
+            this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, data);
+        }
+    }
+    this._resetVertexBufferBinding();
+};
+
+ThinEngine.prototype._createDepthStencilCubeTexture = function (size, options) {
+    const internalTexture = new InternalTexture(this, 12 /* InternalTextureSource.DepthStencil */);
+    internalTexture.isCube = true;
+    if (this.webGLVersion === 1) {
+        Logger.Error("Depth cube texture is not supported by WebGL 1.");
+        return internalTexture;
+    }
+    const internalOptions = {
+        bilinearFiltering: false,
+        comparisonFunction: 0,
+        generateStencil: false,
+        ...options,
+    };
+    const gl = this._gl;
+    this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, internalTexture, true);
+    this._setupDepthStencilTexture(internalTexture, size, internalOptions.bilinearFiltering, internalOptions.comparisonFunction);
+    // Create the depth/stencil buffer
+    for (let face = 0; face < 6; face++) {
+        if (internalOptions.generateStencil) {
+            gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, 0, gl.DEPTH24_STENCIL8, size, size, 0, gl.DEPTH_STENCIL, gl.UNSIGNED_INT_24_8, null);
+        }
+        else {
+            gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, 0, gl.DEPTH_COMPONENT24, size, size, 0, gl.DEPTH_COMPONENT, gl.UNSIGNED_INT, null);
+        }
+    }
+    this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, null);
+    this._internalTexturesCache.push(internalTexture);
+    return internalTexture;
+};
+ThinEngine.prototype._setCubeMapTextureParams = function (texture, loadMipmap, maxLevel) {
+    const gl = this._gl;
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, loadMipmap ? gl.LINEAR_MIPMAP_LINEAR : gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    texture.samplingMode = loadMipmap ? Constants.TEXTURE_TRILINEAR_SAMPLINGMODE : Constants.TEXTURE_LINEAR_LINEAR;
+    if (loadMipmap && this.getCaps().textureMaxLevel && maxLevel !== undefined && maxLevel > 0) {
+        gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAX_LEVEL, maxLevel);
+        texture._maxLodLevel = maxLevel;
+    }
+    this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, null);
+};
+ThinEngine.prototype.createCubeTexture = function (rootUrl, scene, files, noMipmap, onLoad = null, onError = null, format, forcedExtension = null, createPolynomials = false, lodScale = 0, lodOffset = 0, fallback = null, loaderOptions, useSRGBBuffer = false, buffer = null) {
+    const gl = this._gl;
+    return this.createCubeTextureBase(rootUrl, scene, files, !!noMipmap, onLoad, onError, format, forcedExtension, createPolynomials, lodScale, lodOffset, fallback, (texture) => this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, texture, true), (texture, imgs) => {
+        const width = this.needPOTTextures ? GetExponentOfTwo(imgs[0].width, this._caps.maxCubemapTextureSize) : imgs[0].width;
+        const height = width;
+        const faces = [
+            gl.TEXTURE_CUBE_MAP_POSITIVE_X,
+            gl.TEXTURE_CUBE_MAP_POSITIVE_Y,
+            gl.TEXTURE_CUBE_MAP_POSITIVE_Z,
+            gl.TEXTURE_CUBE_MAP_NEGATIVE_X,
+            gl.TEXTURE_CUBE_MAP_NEGATIVE_Y,
+            gl.TEXTURE_CUBE_MAP_NEGATIVE_Z,
+        ];
+        this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, texture, true);
+        this._unpackFlipY(false);
+        const internalFormat = format ? this._getInternalFormat(format, texture._useSRGBBuffer) : texture._useSRGBBuffer ? this._glSRGBExtensionValues.SRGB8_ALPHA8 : gl.RGBA;
+        let texelFormat = format ? this._getInternalFormat(format) : gl.RGBA;
+        if (texture._useSRGBBuffer && this.webGLVersion === 1) {
+            texelFormat = internalFormat;
+        }
+        for (let index = 0; index < faces.length; index++) {
+            if (imgs[index].width !== width || imgs[index].height !== height) {
+                this._prepareWorkingCanvas();
+                if (!this._workingCanvas || !this._workingContext) {
+                    Logger.Warn("Cannot create canvas to resize texture.");
+                    return;
+                }
+                this._workingCanvas.width = width;
+                this._workingCanvas.height = height;
+                this._workingContext.drawImage(imgs[index], 0, 0, imgs[index].width, imgs[index].height, 0, 0, width, height);
+                gl.texImage2D(faces[index], 0, internalFormat, texelFormat, gl.UNSIGNED_BYTE, this._workingCanvas);
+            }
+            else {
+                gl.texImage2D(faces[index], 0, internalFormat, texelFormat, gl.UNSIGNED_BYTE, imgs[index]);
+            }
+        }
+        if (!noMipmap) {
+            gl.generateMipmap(gl.TEXTURE_CUBE_MAP);
+        }
+        this._setCubeMapTextureParams(texture, !noMipmap);
+        texture.width = width;
+        texture.height = height;
+        texture.isReady = true;
+        if (format) {
+            texture.format = format;
+        }
+        texture.onLoadedObservable.notifyObservers(texture);
+        texture.onLoadedObservable.clear();
+        if (onLoad) {
+            onLoad();
+        }
+    }, !!useSRGBBuffer, buffer);
+};
+ThinEngine.prototype.generateMipMapsForCubemap = function (texture, unbind = true) {
+    if (texture.generateMipMaps) {
+        const gl = this._gl;
+        this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, texture, true);
+        gl.generateMipmap(gl.TEXTURE_CUBE_MAP);
+        if (unbind) {
+            this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, null);
+        }
+    }
+};
+
+/** @internal */
+class WebGLRenderTargetWrapper extends RenderTargetWrapper {
+    setDepthStencilTexture(texture, disposeExisting = true) {
+        super.setDepthStencilTexture(texture, disposeExisting);
+        if (!texture) {
+            return;
+        }
+        const engine = this._engine;
+        const gl = this._context;
+        const hardwareTexture = texture._hardwareTexture;
+        if (hardwareTexture && texture._autoMSAAManagement && this._MSAAFramebuffer) {
+            const currentFB = engine._currentFramebuffer;
+            engine._bindUnboundFramebuffer(this._MSAAFramebuffer);
+            gl.framebufferRenderbuffer(gl.FRAMEBUFFER, HasStencilAspect(texture.format) ? gl.DEPTH_STENCIL_ATTACHMENT : gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, hardwareTexture.getMSAARenderBuffer());
+            engine._bindUnboundFramebuffer(currentFB);
+        }
+    }
+    constructor(isMulti, isCube, size, engine, context) {
+        super(isMulti, isCube, size, engine);
+        /**
+         * @internal
+         */
+        this._framebuffer = null;
+        /**
+         * @internal
+         */
+        this._depthStencilBuffer = null;
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        /**
+         * @internal
+         */
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        this._MSAAFramebuffer = null;
+        // Multiview
+        /**
+         * @internal
+         */
+        this._colorTextureArray = null;
+        /**
+         * @internal
+         */
+        this._depthStencilTextureArray = null;
+        /**
+         * @internal
+         */
+        this._disposeOnlyFramebuffers = false;
+        /**
+         * @internal
+         */
+        this._currentLOD = 0;
+        this._context = context;
+    }
+    _cloneRenderTargetWrapper() {
+        let rtw = null;
+        if (this._colorTextureArray && this._depthStencilTextureArray) {
+            rtw = this._engine.createMultiviewRenderTargetTexture(this.width, this.height);
+            rtw.texture.isReady = true;
+        }
+        else {
+            rtw = super._cloneRenderTargetWrapper();
+        }
+        return rtw;
+    }
+    _swapRenderTargetWrapper(target) {
+        super._swapRenderTargetWrapper(target);
+        target._framebuffer = this._framebuffer;
+        target._depthStencilBuffer = this._depthStencilBuffer;
+        target._MSAAFramebuffer = this._MSAAFramebuffer;
+        target._colorTextureArray = this._colorTextureArray;
+        target._depthStencilTextureArray = this._depthStencilTextureArray;
+        this._framebuffer = this._depthStencilBuffer = this._MSAAFramebuffer = this._colorTextureArray = this._depthStencilTextureArray = null;
+    }
+    /**
+     * Creates the depth/stencil texture
+     * @param comparisonFunction Comparison function to use for the texture
+     * @param bilinearFiltering true if bilinear filtering should be used when sampling the texture
+     * @param generateStencil true if the stencil aspect should also be created
+     * @param samples sample count to use when creating the texture
+     * @param format format of the depth texture
+     * @param label defines the label to use for the texture (for debugging purpose only)
+     * @returns the depth/stencil created texture
+     */
+    createDepthStencilTexture(comparisonFunction = 0, bilinearFiltering = true, generateStencil = false, samples = 1, format = Constants.TEXTUREFORMAT_DEPTH32_FLOAT, label) {
+        if (this._depthStencilBuffer) {
+            const engine = this._engine;
+            // Dispose previous depth/stencil render buffers and clear the corresponding attachment.
+            // Next time this framebuffer is bound, the new depth/stencil texture will be attached.
+            const currentFrameBuffer = engine._currentFramebuffer;
+            const gl = this._context;
+            engine._bindUnboundFramebuffer(this._framebuffer);
+            gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, null);
+            gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, null);
+            gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.RENDERBUFFER, null);
+            engine._bindUnboundFramebuffer(currentFrameBuffer);
+            gl.deleteRenderbuffer(this._depthStencilBuffer);
+            this._depthStencilBuffer = null;
+        }
+        return super.createDepthStencilTexture(comparisonFunction, bilinearFiltering, generateStencil, samples, format, label);
+    }
+    /**
+     * Shares the depth buffer of this render target with another render target.
+     * @param renderTarget Destination renderTarget
+     */
+    shareDepth(renderTarget) {
+        super.shareDepth(renderTarget);
+        const gl = this._context;
+        const depthbuffer = this._depthStencilBuffer;
+        const framebuffer = renderTarget._MSAAFramebuffer || renderTarget._framebuffer;
+        const engine = this._engine;
+        if (renderTarget._depthStencilBuffer && renderTarget._depthStencilBuffer !== depthbuffer) {
+            gl.deleteRenderbuffer(renderTarget._depthStencilBuffer);
+        }
+        renderTarget._depthStencilBuffer = depthbuffer;
+        const attachment = renderTarget._generateStencilBuffer ? gl.DEPTH_STENCIL_ATTACHMENT : gl.DEPTH_ATTACHMENT;
+        engine._bindUnboundFramebuffer(framebuffer);
+        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment, gl.RENDERBUFFER, depthbuffer);
+        engine._bindUnboundFramebuffer(null);
+    }
+    /**
+     * Binds a texture to this render target on a specific attachment
+     * @param texture The texture to bind to the framebuffer
+     * @param attachmentIndex Index of the attachment
+     * @param faceIndexOrLayer The face or layer of the texture to render to in case of cube texture or array texture
+     * @param lodLevel defines the lod level to bind to the frame buffer
+     */
+    _bindTextureRenderTarget(texture, attachmentIndex = 0, faceIndexOrLayer, lodLevel = 0) {
+        const hardwareTexture = texture._hardwareTexture;
+        if (!hardwareTexture) {
+            return;
+        }
+        const framebuffer = this._framebuffer;
+        const engine = this._engine;
+        const currentFB = engine._currentFramebuffer;
+        engine._bindUnboundFramebuffer(framebuffer);
+        let attachment;
+        if (engine.webGLVersion > 1) {
+            const gl = this._context;
+            attachment = gl["COLOR_ATTACHMENT" + attachmentIndex];
+            if (texture.is2DArray || texture.is3D) {
+                faceIndexOrLayer = faceIndexOrLayer ?? this.layerIndices?.[attachmentIndex] ?? 0;
+                gl.framebufferTextureLayer(gl.FRAMEBUFFER, attachment, hardwareTexture.underlyingResource, lodLevel, faceIndexOrLayer);
+            }
+            else if (texture.isCube) {
+                // if face index is not specified, try to query it from faceIndices
+                // default is face 0
+                faceIndexOrLayer = faceIndexOrLayer ?? this.faceIndices?.[attachmentIndex] ?? 0;
+                gl.framebufferTexture2D(gl.FRAMEBUFFER, attachment, gl.TEXTURE_CUBE_MAP_POSITIVE_X + faceIndexOrLayer, hardwareTexture.underlyingResource, lodLevel);
+            }
+            else {
+                gl.framebufferTexture2D(gl.FRAMEBUFFER, attachment, gl.TEXTURE_2D, hardwareTexture.underlyingResource, lodLevel);
+            }
+        }
+        else {
+            // Default behavior (WebGL)
+            const gl = this._context;
+            attachment = gl["COLOR_ATTACHMENT" + attachmentIndex + "_WEBGL"];
+            const target = faceIndexOrLayer !== undefined ? gl.TEXTURE_CUBE_MAP_POSITIVE_X + faceIndexOrLayer : gl.TEXTURE_2D;
+            gl.framebufferTexture2D(gl.FRAMEBUFFER, attachment, target, hardwareTexture.underlyingResource, lodLevel);
+        }
+        if (texture._autoMSAAManagement && this._MSAAFramebuffer) {
+            const gl = this._context;
+            engine._bindUnboundFramebuffer(this._MSAAFramebuffer);
+            gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment, gl.RENDERBUFFER, hardwareTexture.getMSAARenderBuffer());
+        }
+        engine._bindUnboundFramebuffer(currentFB);
+    }
+    /**
+     * Set a texture in the textures array
+     * @param texture the texture to set
+     * @param index the index in the textures array to set
+     * @param disposePrevious If this function should dispose the previous texture
+     */
+    setTexture(texture, index = 0, disposePrevious = true) {
+        super.setTexture(texture, index, disposePrevious);
+        this._bindTextureRenderTarget(texture, index);
+    }
+    /**
+     * Sets the layer and face indices of every render target texture
+     * @param layers The layer of the texture to be set (make negative to not modify)
+     * @param faces The face of the texture to be set (make negative to not modify)
+     */
+    setLayerAndFaceIndices(layers, faces) {
+        super.setLayerAndFaceIndices(layers, faces);
+        if (!this.textures || !this.layerIndices || !this.faceIndices) {
+            return;
+        }
+        // the length of this._attachments is the right one as it does not count the depth texture, in case we generated it
+        const textureCount = this._attachments?.length ?? this.textures.length;
+        for (let index = 0; index < textureCount; index++) {
+            const texture = this.textures[index];
+            if (!texture) {
+                // The target type was probably -1 at creation time and setTexture has not been called yet for this index
+                continue;
+            }
+            if (texture.is2DArray || texture.is3D) {
+                this._bindTextureRenderTarget(texture, index, this.layerIndices[index]);
+            }
+            else if (texture.isCube) {
+                this._bindTextureRenderTarget(texture, index, this.faceIndices[index]);
+            }
+            else {
+                this._bindTextureRenderTarget(texture, index);
+            }
+        }
+    }
+    /**
+     * Set the face and layer indices of a texture in the textures array
+     * @param index The index of the texture in the textures array to modify
+     * @param layer The layer of the texture to be set
+     * @param face The face of the texture to be set
+     */
+    setLayerAndFaceIndex(index = 0, layer, face) {
+        super.setLayerAndFaceIndex(index, layer, face);
+        if (!this.textures || !this.layerIndices || !this.faceIndices) {
+            return;
+        }
+        const texture = this.textures[index];
+        if (texture.is2DArray || texture.is3D) {
+            this._bindTextureRenderTarget(this.textures[index], index, this.layerIndices[index]);
+        }
+        else if (texture.isCube) {
+            this._bindTextureRenderTarget(this.textures[index], index, this.faceIndices[index]);
+        }
+    }
+    resolveMSAATextures() {
+        const engine = this._engine;
+        const currentFramebuffer = engine._currentFramebuffer;
+        engine._bindUnboundFramebuffer(this._MSAAFramebuffer);
+        super.resolveMSAATextures();
+        engine._bindUnboundFramebuffer(currentFramebuffer);
+    }
+    dispose(disposeOnlyFramebuffers = this._disposeOnlyFramebuffers) {
+        const gl = this._context;
+        if (!disposeOnlyFramebuffers) {
+            if (this._colorTextureArray) {
+                this._context.deleteTexture(this._colorTextureArray);
+                this._colorTextureArray = null;
+            }
+            if (this._depthStencilTextureArray) {
+                this._context.deleteTexture(this._depthStencilTextureArray);
+                this._depthStencilTextureArray = null;
+            }
+        }
+        if (this._framebuffer) {
+            gl.deleteFramebuffer(this._framebuffer);
+            this._framebuffer = null;
+        }
+        if (this._depthStencilBuffer) {
+            gl.deleteRenderbuffer(this._depthStencilBuffer);
+            this._depthStencilBuffer = null;
+        }
+        if (this._MSAAFramebuffer) {
+            gl.deleteFramebuffer(this._MSAAFramebuffer);
+            this._MSAAFramebuffer = null;
+        }
+        super.dispose(disposeOnlyFramebuffers);
+    }
+}
+
+ThinEngine.prototype._createHardwareRenderTargetWrapper = function (isMulti, isCube, size) {
+    const rtWrapper = new WebGLRenderTargetWrapper(isMulti, isCube, size, this, this._gl);
+    this._renderTargetWrapperCache.push(rtWrapper);
+    return rtWrapper;
+};
+ThinEngine.prototype.createRenderTargetTexture = function (size, options) {
+    const rtWrapper = this._createHardwareRenderTargetWrapper(false, false, size);
+    let generateDepthBuffer = true;
+    let generateStencilBuffer = false;
+    let noColorAttachment = false;
+    let colorAttachment = undefined;
+    let samples = 1;
+    let label = undefined;
+    if (options !== undefined && typeof options === "object") {
+        generateDepthBuffer = options.generateDepthBuffer ?? true;
+        generateStencilBuffer = !!options.generateStencilBuffer;
+        noColorAttachment = !!options.noColorAttachment;
+        colorAttachment = options.colorAttachment;
+        samples = options.samples ?? 1;
+        label = options.label;
+    }
+    const texture = colorAttachment || (noColorAttachment ? null : this._createInternalTexture(size, options, true, 5 /* InternalTextureSource.RenderTarget */));
+    const width = size.width || size;
+    const height = size.height || size;
+    const currentFrameBuffer = this._currentFramebuffer;
+    const gl = this._gl;
+    // Create the framebuffer
+    const framebuffer = gl.createFramebuffer();
+    this._bindUnboundFramebuffer(framebuffer);
+    rtWrapper._depthStencilBuffer = this._setupFramebufferDepthAttachments(generateStencilBuffer, generateDepthBuffer, width, height);
+    // No need to rebind on every frame
+    if (texture && !texture.is2DArray && !texture.is3D) {
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture._hardwareTexture.underlyingResource, 0);
+    }
+    this._bindUnboundFramebuffer(currentFrameBuffer);
+    rtWrapper.label = label ?? "RenderTargetWrapper";
+    rtWrapper._framebuffer = framebuffer;
+    rtWrapper._generateDepthBuffer = generateDepthBuffer;
+    rtWrapper._generateStencilBuffer = generateStencilBuffer;
+    rtWrapper.setTextures(texture);
+    if (!colorAttachment) {
+        this.updateRenderTargetTextureSampleCount(rtWrapper, samples);
+    }
+    else {
+        rtWrapper._samples = colorAttachment.samples;
+        if (colorAttachment.samples > 1) {
+            const msaaRenderBuffer = colorAttachment._hardwareTexture.getMSAARenderBuffer(0);
+            rtWrapper._MSAAFramebuffer = gl.createFramebuffer();
+            this._bindUnboundFramebuffer(rtWrapper._MSAAFramebuffer);
+            gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, msaaRenderBuffer);
+            this._bindUnboundFramebuffer(null);
+        }
+    }
+    return rtWrapper;
+};
+ThinEngine.prototype._createDepthStencilTexture = function (size, options, rtWrapper) {
+    const gl = this._gl;
+    const layers = size.layers || 0;
+    const depth = size.depth || 0;
+    let target = gl.TEXTURE_2D;
+    if (layers !== 0) {
+        target = gl.TEXTURE_2D_ARRAY;
+    }
+    else if (depth !== 0) {
+        target = gl.TEXTURE_3D;
+    }
+    const internalTexture = new InternalTexture(this, 12 /* InternalTextureSource.DepthStencil */);
+    internalTexture.label = options.label;
+    if (!this._caps.depthTextureExtension) {
+        Logger.Error("Depth texture is not supported by your browser or hardware.");
+        return internalTexture;
+    }
+    const internalOptions = {
+        bilinearFiltering: false,
+        comparisonFunction: 0,
+        generateStencil: false,
+        ...options,
+    };
+    this._bindTextureDirectly(target, internalTexture, true);
+    this._setupDepthStencilTexture(internalTexture, size, internalOptions.comparisonFunction === 0 ? false : internalOptions.bilinearFiltering, internalOptions.comparisonFunction, internalOptions.samples);
+    if (internalOptions.depthTextureFormat !== undefined) {
+        if (internalOptions.depthTextureFormat !== Constants.TEXTUREFORMAT_DEPTH16 &&
+            internalOptions.depthTextureFormat !== Constants.TEXTUREFORMAT_DEPTH24 &&
+            internalOptions.depthTextureFormat !== Constants.TEXTUREFORMAT_DEPTH24UNORM_STENCIL8 &&
+            internalOptions.depthTextureFormat !== Constants.TEXTUREFORMAT_DEPTH24_STENCIL8 &&
+            internalOptions.depthTextureFormat !== Constants.TEXTUREFORMAT_DEPTH32_FLOAT &&
+            internalOptions.depthTextureFormat !== Constants.TEXTUREFORMAT_DEPTH32FLOAT_STENCIL8) {
+            Logger.Error(`Depth texture ${internalOptions.depthTextureFormat} format is not supported.`);
+            return internalTexture;
+        }
+        internalTexture.format = internalOptions.depthTextureFormat;
+    }
+    else {
+        internalTexture.format = internalOptions.generateStencil ? Constants.TEXTUREFORMAT_DEPTH24_STENCIL8 : Constants.TEXTUREFORMAT_DEPTH24;
+    }
+    const hasStencil = internalTexture.format === Constants.TEXTUREFORMAT_DEPTH24UNORM_STENCIL8 ||
+        internalTexture.format === Constants.TEXTUREFORMAT_DEPTH24_STENCIL8 ||
+        internalTexture.format === Constants.TEXTUREFORMAT_DEPTH32FLOAT_STENCIL8;
+    const type = this._getWebGLTextureTypeFromDepthTextureFormat(internalTexture.format);
+    const format = hasStencil ? gl.DEPTH_STENCIL : gl.DEPTH_COMPONENT;
+    const internalFormat = this._getInternalFormatFromDepthTextureFormat(internalTexture.format, true, hasStencil);
+    if (internalTexture.is2DArray) {
+        gl.texImage3D(target, 0, internalFormat, internalTexture.width, internalTexture.height, layers, 0, format, type, null);
+    }
+    else if (internalTexture.is3D) {
+        gl.texImage3D(target, 0, internalFormat, internalTexture.width, internalTexture.height, depth, 0, format, type, null);
+    }
+    else {
+        gl.texImage2D(target, 0, internalFormat, internalTexture.width, internalTexture.height, 0, format, type, null);
+    }
+    this._bindTextureDirectly(target, null);
+    this._internalTexturesCache.push(internalTexture);
+    if (rtWrapper._depthStencilBuffer) {
+        gl.deleteRenderbuffer(rtWrapper._depthStencilBuffer);
+        rtWrapper._depthStencilBuffer = null;
+    }
+    this._bindUnboundFramebuffer(rtWrapper._MSAAFramebuffer ?? rtWrapper._framebuffer);
+    rtWrapper._generateStencilBuffer = hasStencil;
+    rtWrapper._depthStencilTextureWithStencil = hasStencil;
+    rtWrapper._depthStencilBuffer = this._setupFramebufferDepthAttachments(rtWrapper._generateStencilBuffer, rtWrapper._generateDepthBuffer, rtWrapper.width, rtWrapper.height, rtWrapper.samples, internalTexture.format);
+    this._bindUnboundFramebuffer(null);
+    return internalTexture;
+};
+ThinEngine.prototype.updateRenderTargetTextureSampleCount = function (rtWrapper, samples) {
+    if (this.webGLVersion < 2 || !rtWrapper) {
+        return 1;
+    }
+    if (rtWrapper.samples === samples) {
+        return samples;
+    }
+    const gl = this._gl;
+    samples = Math.min(samples, this.getCaps().maxMSAASamples);
+    // Dispose previous render buffers
+    if (rtWrapper._depthStencilBuffer) {
+        gl.deleteRenderbuffer(rtWrapper._depthStencilBuffer);
+        rtWrapper._depthStencilBuffer = null;
+    }
+    if (rtWrapper._MSAAFramebuffer) {
+        gl.deleteFramebuffer(rtWrapper._MSAAFramebuffer);
+        rtWrapper._MSAAFramebuffer = null;
+    }
+    const hardwareTexture = rtWrapper.texture?._hardwareTexture;
+    hardwareTexture?.releaseMSAARenderBuffers();
+    if (rtWrapper.texture && samples > 1 && typeof gl.renderbufferStorageMultisample === "function") {
+        const framebuffer = gl.createFramebuffer();
+        if (!framebuffer) {
+            throw new Error("Unable to create multi sampled framebuffer");
+        }
+        rtWrapper._MSAAFramebuffer = framebuffer;
+        this._bindUnboundFramebuffer(rtWrapper._MSAAFramebuffer);
+        const colorRenderbuffer = this._createRenderBuffer(rtWrapper.texture.width, rtWrapper.texture.height, samples, -1 /* not used */, this._getRGBABufferInternalSizedFormat(rtWrapper.texture.type, rtWrapper.texture.format, rtWrapper.texture._useSRGBBuffer), gl.COLOR_ATTACHMENT0, false);
+        if (!colorRenderbuffer) {
+            throw new Error("Unable to create multi sampled framebuffer");
+        }
+        hardwareTexture?.addMSAARenderBuffer(colorRenderbuffer);
+    }
+    this._bindUnboundFramebuffer(rtWrapper._MSAAFramebuffer ?? rtWrapper._framebuffer);
+    if (rtWrapper.texture) {
+        rtWrapper.texture.samples = samples;
+    }
+    rtWrapper._samples = samples;
+    const depthFormat = rtWrapper._depthStencilTexture ? rtWrapper._depthStencilTexture.format : undefined;
+    rtWrapper._depthStencilBuffer = this._setupFramebufferDepthAttachments(rtWrapper._generateStencilBuffer, rtWrapper._generateDepthBuffer, rtWrapper.width, rtWrapper.height, samples, depthFormat);
+    this._bindUnboundFramebuffer(null);
+    return samples;
+};
+ThinEngine.prototype._setupDepthStencilTexture = function (internalTexture, size, bilinearFiltering, comparisonFunction, samples = 1) {
+    const width = size.width ?? size;
+    const height = size.height ?? size;
+    const layers = size.layers || 0;
+    const depth = size.depth || 0;
+    internalTexture.baseWidth = width;
+    internalTexture.baseHeight = height;
+    internalTexture.width = width;
+    internalTexture.height = height;
+    internalTexture.is2DArray = layers > 0;
+    internalTexture.depth = layers || depth;
+    internalTexture.isReady = true;
+    internalTexture.samples = samples;
+    internalTexture.generateMipMaps = false;
+    internalTexture.samplingMode = bilinearFiltering ? Constants.TEXTURE_BILINEAR_SAMPLINGMODE : Constants.TEXTURE_NEAREST_SAMPLINGMODE;
+    internalTexture.type = Constants.TEXTURETYPE_UNSIGNED_BYTE;
+    internalTexture._comparisonFunction = comparisonFunction;
+    const gl = this._gl;
+    const target = this._getTextureTarget(internalTexture);
+    const samplingParameters = this._getSamplingParameters(internalTexture.samplingMode, false);
+    gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, samplingParameters.mag);
+    gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, samplingParameters.min);
+    gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    // TEXTURE_COMPARE_FUNC/MODE are only availble in WebGL2.
+    if (this.webGLVersion > 1) {
+        if (comparisonFunction === 0) {
+            gl.texParameteri(target, gl.TEXTURE_COMPARE_FUNC, Constants.LEQUAL);
+            gl.texParameteri(target, gl.TEXTURE_COMPARE_MODE, gl.NONE);
+        }
+        else {
+            gl.texParameteri(target, gl.TEXTURE_COMPARE_FUNC, comparisonFunction);
+            gl.texParameteri(target, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE);
+        }
+    }
+};
+
+ThinEngine.prototype.setDepthStencilTexture = function (channel, uniform, texture, name) {
+    if (channel === undefined) {
+        return;
+    }
+    if (uniform) {
+        this._boundUniforms[channel] = uniform;
+    }
+    if (!texture || !texture.depthStencilTexture) {
+        this._setTexture(channel, null, undefined, undefined, name);
+    }
+    else {
+        this._setTexture(channel, texture, false, true, name);
+    }
+};
+
+ThinEngine.prototype.createRenderTargetCubeTexture = function (size, options) {
+    const rtWrapper = this._createHardwareRenderTargetWrapper(false, true, size);
+    const fullOptions = {
+        generateMipMaps: true,
+        generateDepthBuffer: true,
+        generateStencilBuffer: false,
+        type: Constants.TEXTURETYPE_UNSIGNED_BYTE,
+        samplingMode: Constants.TEXTURE_TRILINEAR_SAMPLINGMODE,
+        format: Constants.TEXTUREFORMAT_RGBA,
+        ...options,
+    };
+    fullOptions.generateStencilBuffer = fullOptions.generateDepthBuffer && fullOptions.generateStencilBuffer;
+    if (fullOptions.type === Constants.TEXTURETYPE_FLOAT && !this._caps.textureFloatLinearFiltering) {
+        // if floating point linear (gl.FLOAT) then force to NEAREST_SAMPLINGMODE
+        fullOptions.samplingMode = Constants.TEXTURE_NEAREST_SAMPLINGMODE;
+    }
+    else if (fullOptions.type === Constants.TEXTURETYPE_HALF_FLOAT && !this._caps.textureHalfFloatLinearFiltering) {
+        // if floating point linear (HALF_FLOAT) then force to NEAREST_SAMPLINGMODE
+        fullOptions.samplingMode = Constants.TEXTURE_NEAREST_SAMPLINGMODE;
+    }
+    const gl = this._gl;
+    const texture = new InternalTexture(this, 5 /* InternalTextureSource.RenderTarget */);
+    this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, texture, true);
+    const filters = this._getSamplingParameters(fullOptions.samplingMode, fullOptions.generateMipMaps);
+    if (fullOptions.type === Constants.TEXTURETYPE_FLOAT && !this._caps.textureFloat) {
+        fullOptions.type = Constants.TEXTURETYPE_UNSIGNED_BYTE;
+        Logger.Warn("Float textures are not supported. Cube render target forced to TEXTURETYPE_UNESIGNED_BYTE type");
+    }
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, filters.mag);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, filters.min);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    for (let face = 0; face < 6; face++) {
+        gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, 0, this._getRGBABufferInternalSizedFormat(fullOptions.type, fullOptions.format), size, size, 0, this._getInternalFormat(fullOptions.format), this._getWebGLTextureType(fullOptions.type), null);
+    }
+    // Create the framebuffer
+    const framebuffer = gl.createFramebuffer();
+    this._bindUnboundFramebuffer(framebuffer);
+    rtWrapper._depthStencilBuffer = this._setupFramebufferDepthAttachments(fullOptions.generateStencilBuffer, fullOptions.generateDepthBuffer, size, size);
+    // MipMaps
+    if (fullOptions.generateMipMaps) {
+        gl.generateMipmap(gl.TEXTURE_CUBE_MAP);
+    }
+    // Unbind
+    this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, null);
+    this._bindUnboundFramebuffer(null);
+    rtWrapper._framebuffer = framebuffer;
+    rtWrapper._generateDepthBuffer = fullOptions.generateDepthBuffer;
+    rtWrapper._generateStencilBuffer = fullOptions.generateStencilBuffer;
+    texture.width = size;
+    texture.height = size;
+    texture.isReady = true;
+    texture.isCube = true;
+    texture.samples = 1;
+    texture.generateMipMaps = fullOptions.generateMipMaps;
+    texture.samplingMode = fullOptions.samplingMode;
+    texture.type = fullOptions.type;
+    texture.format = fullOptions.format;
+    this._internalTexturesCache.push(texture);
+    rtWrapper.setTextures(texture);
+    return rtWrapper;
+};
+
+ThinEngine.prototype.createPrefilteredCubeTexture = function (rootUrl, scene, lodScale, lodOffset, onLoad = null, onError = null, format, forcedExtension = null, createPolynomials = true) {
+    const callback = async (loadData) => {
+        if (!loadData) {
+            if (onLoad) {
+                onLoad(null);
+            }
+            return;
+        }
+        const texture = loadData.texture;
+        if (!createPolynomials) {
+            texture._sphericalPolynomial = new SphericalPolynomial();
+        }
+        else if (loadData.info.sphericalPolynomial) {
+            texture._sphericalPolynomial = loadData.info.sphericalPolynomial;
+        }
+        texture._source = 9 /* InternalTextureSource.CubePrefiltered */;
+        if (this.getCaps().textureLOD) {
+            // Do not add extra process if texture lod is supported.
+            if (onLoad) {
+                onLoad(texture);
+            }
+            return;
+        }
+        const mipSlices = 3;
+        const gl = this._gl;
+        const width = loadData.width;
+        if (!width) {
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        const { DDSTools } = await import('./dds-zApWiwah.esm.js');
+        const textures = [];
+        for (let i = 0; i < mipSlices; i++) {
+            //compute LOD from even spacing in smoothness (matching shader calculation)
+            const smoothness = i / (mipSlices - 1);
+            const roughness = 1 - smoothness;
+            const minLODIndex = lodOffset; // roughness = 0
+            const maxLODIndex = Math.log2(width) * lodScale + lodOffset; // roughness = 1
+            const lodIndex = minLODIndex + (maxLODIndex - minLODIndex) * roughness;
+            const mipmapIndex = Math.round(Math.min(Math.max(lodIndex, 0), maxLODIndex));
+            const glTextureFromLod = new InternalTexture(this, 2 /* InternalTextureSource.Temp */);
+            glTextureFromLod.type = texture.type;
+            glTextureFromLod.format = texture.format;
+            glTextureFromLod.width = Math.pow(2, Math.max(Math.log2(width) - mipmapIndex, 0));
+            glTextureFromLod.height = glTextureFromLod.width;
+            glTextureFromLod.isCube = true;
+            glTextureFromLod._cachedWrapU = Constants.TEXTURE_CLAMP_ADDRESSMODE;
+            glTextureFromLod._cachedWrapV = Constants.TEXTURE_CLAMP_ADDRESSMODE;
+            this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, glTextureFromLod, true);
+            glTextureFromLod.samplingMode = Constants.TEXTURE_LINEAR_LINEAR;
+            gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+            gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+            gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+            gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+            if (loadData.isDDS) {
+                const info = loadData.info;
+                const data = loadData.data;
+                this._unpackFlipY(info.isCompressed);
+                DDSTools.UploadDDSLevels(this, glTextureFromLod, data, info, true, 6, mipmapIndex);
+            }
+            else {
+                Logger.Warn("DDS is the only prefiltered cube map supported so far.");
+            }
+            this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, null);
+            // Wrap in a base texture for easy binding.
+            const lodTexture = new BaseTexture(scene);
+            lodTexture._isCube = true;
+            lodTexture._texture = glTextureFromLod;
+            glTextureFromLod.isReady = true;
+            textures.push(lodTexture);
+        }
+        texture._lodTextureHigh = textures[2];
+        texture._lodTextureMid = textures[1];
+        texture._lodTextureLow = textures[0];
+        if (onLoad) {
+            onLoad(texture);
+        }
+    };
+    return this.createCubeTexture(rootUrl, scene, null, false, callback, onError, format, forcedExtension, createPolynomials, lodScale, lodOffset);
+};
+
+ThinEngine.prototype.createUniformBuffer = function (elements, _label) {
+    const ubo = this._gl.createBuffer();
+    if (!ubo) {
+        throw new Error("Unable to create uniform buffer");
+    }
+    const result = new WebGLDataBuffer(ubo);
+    this.bindUniformBuffer(result);
+    if (elements instanceof Float32Array) {
+        this._gl.bufferData(this._gl.UNIFORM_BUFFER, elements, this._gl.STATIC_DRAW);
+    }
+    else {
+        this._gl.bufferData(this._gl.UNIFORM_BUFFER, new Float32Array(elements), this._gl.STATIC_DRAW);
+    }
+    this.bindUniformBuffer(null);
+    result.references = 1;
+    return result;
+};
+ThinEngine.prototype.createDynamicUniformBuffer = function (elements, _label) {
+    const ubo = this._gl.createBuffer();
+    if (!ubo) {
+        throw new Error("Unable to create dynamic uniform buffer");
+    }
+    const result = new WebGLDataBuffer(ubo);
+    this.bindUniformBuffer(result);
+    if (elements instanceof Float32Array) {
+        this._gl.bufferData(this._gl.UNIFORM_BUFFER, elements, this._gl.DYNAMIC_DRAW);
+    }
+    else {
+        this._gl.bufferData(this._gl.UNIFORM_BUFFER, new Float32Array(elements), this._gl.DYNAMIC_DRAW);
+    }
+    this.bindUniformBuffer(null);
+    result.references = 1;
+    return result;
+};
+ThinEngine.prototype.updateUniformBuffer = function (uniformBuffer, elements, offset, count) {
+    this.bindUniformBuffer(uniformBuffer);
+    if (offset === undefined) {
+        offset = 0;
+    }
+    if (count === undefined) {
+        if (elements instanceof Float32Array) {
+            this._gl.bufferSubData(this._gl.UNIFORM_BUFFER, offset, elements);
+        }
+        else {
+            this._gl.bufferSubData(this._gl.UNIFORM_BUFFER, offset, new Float32Array(elements));
+        }
+    }
+    else {
+        if (elements instanceof Float32Array) {
+            this._gl.bufferSubData(this._gl.UNIFORM_BUFFER, 0, elements.subarray(offset, offset + count));
+        }
+        else {
+            this._gl.bufferSubData(this._gl.UNIFORM_BUFFER, 0, new Float32Array(elements).subarray(offset, offset + count));
+        }
+    }
+    this.bindUniformBuffer(null);
+};
+ThinEngine.prototype.bindUniformBuffer = function (buffer) {
+    this._gl.bindBuffer(this._gl.UNIFORM_BUFFER, buffer ? buffer.underlyingResource : null);
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+ThinEngine.prototype.bindUniformBufferBase = function (buffer, location, name) {
+    this._gl.bindBufferBase(this._gl.UNIFORM_BUFFER, location, buffer ? buffer.underlyingResource : null);
+};
+ThinEngine.prototype.bindUniformBlock = function (pipelineContext, blockName, index) {
+    const program = pipelineContext.program;
+    const uniformLocation = this._gl.getUniformBlockIndex(program, blockName);
+    if (uniformLocation !== 0xffffffff) {
+        this._gl.uniformBlockBinding(program, uniformLocation, index);
+    }
+};
+
+/**
+ * The engine class is responsible for interfacing with all lower-level APIs such as WebGL and Audio
+ */
+class Engine extends ThinEngine {
+    /**
+     * Returns the current npm package of the sdk
+     */
+    // Not mixed with Version for tooling purpose.
+    static get NpmPackage() {
+        return AbstractEngine.NpmPackage;
+    }
+    /**
+     * Returns the current version of the framework
+     */
+    static get Version() {
+        return AbstractEngine.Version;
+    }
+    /** Gets the list of created engines */
+    static get Instances() {
+        return EngineStore.Instances;
+    }
+    /**
+     * Gets the latest created engine
+     */
+    static get LastCreatedEngine() {
+        return EngineStore.LastCreatedEngine;
+    }
+    /**
+     * Gets the latest created scene
+     */
+    static get LastCreatedScene() {
+        return EngineStore.LastCreatedScene;
+    }
+    /** @internal */
+    // eslint-disable-next-line jsdoc/require-returns-check
+    /**
+     * Method called to create the default loading screen.
+     * This can be overridden in your own app.
+     * @param canvas The rendering canvas element
+     * @returns The loading screen
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static DefaultLoadingScreenFactory(canvas) {
+        return AbstractEngine.DefaultLoadingScreenFactory(canvas);
+    }
+    get _supportsHardwareTextureRescaling() {
+        return !!Engine._RescalePostProcessFactory;
+    }
+    _measureFps() {
+        this._performanceMonitor.sampleFrame();
+        this._fps = this._performanceMonitor.averageFPS;
+        this._deltaTime = this._performanceMonitor.instantaneousFrameTime || 0;
+    }
+    /**
+     * Gets the performance monitor attached to this engine
+     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#engineinstrumentation
+     */
+    get performanceMonitor() {
+        return this._performanceMonitor;
+    }
+    // Events
+    /**
+     * Creates a new engine
+     * @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
+     * @param antialias defines enable antialiasing (default: false)
+     * @param options defines further options to be sent to the getContext() function
+     * @param adaptToDeviceRatio defines whether to adapt to the device's viewport characteristics (default: false)
+     */
+    constructor(canvasOrContext, antialias, options, adaptToDeviceRatio = false) {
+        super(canvasOrContext, antialias, options, adaptToDeviceRatio);
+        // Members
+        /**
+         * If set, will be used to request the next animation frame for the render loop
+         */
+        this.customAnimationFrameRequester = null;
+        this._performanceMonitor = new PerformanceMonitor();
+        this._drawCalls = new PerfCounter();
+        if (!canvasOrContext) {
+            return;
+        }
+        this._features.supportRenderPasses = true;
+        options = this._creationOptions;
+    }
+    _initGLContext() {
+        super._initGLContext();
+        this._rescalePostProcess = null;
+    }
+    /**
+     * Shared initialization across engines types.
+     * @param canvas The canvas associated with this instance of the engine.
+     */
+    _sharedInit(canvas) {
+        super._sharedInit(canvas);
+        _CommonInit(this, canvas, this._creationOptions);
+    }
+    /**
+     * Resize an image and returns the image data as an uint8array
+     * @param image image to resize
+     * @param bufferWidth destination buffer width
+     * @param bufferHeight destination buffer height
+     * @returns an uint8array containing RGBA values of bufferWidth * bufferHeight size
+     */
+    resizeImageBitmap(image, bufferWidth, bufferHeight) {
+        return ResizeImageBitmap(this, image, bufferWidth, bufferHeight);
+    }
+    /**
+     * Engine abstraction for loading and creating an image bitmap from a given source string.
+     * @param imageSource source to load the image from.
+     * @param options An object that sets options for the image's extraction.
+     * @returns ImageBitmap
+     */
+    _createImageBitmapFromSource(imageSource, options) {
+        return CreateImageBitmapFromSource(this, imageSource, options);
+    }
+    /**
+     * Toggle full screen mode
+     * @param requestPointerLock defines if a pointer lock should be requested from the user
+     */
+    switchFullscreen(requestPointerLock) {
+        if (this.isFullscreen) {
+            this.exitFullscreen();
+        }
+        else {
+            this.enterFullscreen(requestPointerLock);
+        }
+    }
+    /**
+     * Enters full screen mode
+     * @param requestPointerLock defines if a pointer lock should be requested from the user
+     */
+    enterFullscreen(requestPointerLock) {
+        if (!this.isFullscreen) {
+            this._pointerLockRequested = requestPointerLock;
+            if (this._renderingCanvas) {
+                RequestFullscreen(this._renderingCanvas);
+            }
+        }
+    }
+    /**
+     * Exits full screen mode
+     */
+    exitFullscreen() {
+        if (this.isFullscreen) {
+            ExitFullscreen();
+        }
+    }
+    /** States */
+    /**
+     * Sets a boolean indicating if the dithering state is enabled or disabled
+     * @param value defines the dithering state
+     */
+    setDitheringState(value) {
+        if (value) {
+            this._gl.enable(this._gl.DITHER);
+        }
+        else {
+            this._gl.disable(this._gl.DITHER);
+        }
+    }
+    /**
+     * Sets a boolean indicating if the rasterizer state is enabled or disabled
+     * @param value defines the rasterizer state
+     */
+    setRasterizerState(value) {
+        if (value) {
+            this._gl.disable(this._gl.RASTERIZER_DISCARD);
+        }
+        else {
+            this._gl.enable(this._gl.RASTERIZER_DISCARD);
+        }
+    }
+    /**
+     * Directly set the WebGL Viewport
+     * @param x defines the x coordinate of the viewport (in screen space)
+     * @param y defines the y coordinate of the viewport (in screen space)
+     * @param width defines the width of the viewport (in screen space)
+     * @param height defines the height of the viewport (in screen space)
+     * @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
+     */
+    setDirectViewport(x, y, width, height) {
+        const currentViewport = this._cachedViewport;
+        this._cachedViewport = null;
+        this._viewport(x, y, width, height);
+        return currentViewport;
+    }
+    /**
+     * Executes a scissor clear (ie. a clear on a specific portion of the screen)
+     * @param x defines the x-coordinate of the bottom left corner of the clear rectangle
+     * @param y defines the y-coordinate of the corner of the clear rectangle
+     * @param width defines the width of the clear rectangle
+     * @param height defines the height of the clear rectangle
+     * @param clearColor defines the clear color
+     */
+    scissorClear(x, y, width, height, clearColor) {
+        this.enableScissor(x, y, width, height);
+        this.clear(clearColor, true, true, true);
+        this.disableScissor();
+    }
+    /**
+     * Enable scissor test on a specific rectangle (ie. render will only be executed on a specific portion of the screen)
+     * @param x defines the x-coordinate of the bottom left corner of the clear rectangle
+     * @param y defines the y-coordinate of the corner of the clear rectangle
+     * @param width defines the width of the clear rectangle
+     * @param height defines the height of the clear rectangle
+     */
+    enableScissor(x, y, width, height) {
+        const gl = this._gl;
+        // Change state
+        gl.enable(gl.SCISSOR_TEST);
+        gl.scissor(x, y, width, height);
+    }
+    /**
+     * Disable previously set scissor test rectangle
+     */
+    disableScissor() {
+        const gl = this._gl;
+        gl.disable(gl.SCISSOR_TEST);
+    }
+    /**
+     * @internal
+     */
+    _loadFileAsync(url, offlineProvider, useArrayBuffer) {
+        return new Promise((resolve, reject) => {
+            this._loadFile(url, (data) => {
+                resolve(data);
+            }, undefined, offlineProvider, useArrayBuffer, (request, exception) => {
+                reject(exception);
+            });
+        });
+    }
+    /**
+     * Gets the source code of the vertex shader associated with a specific webGL program
+     * @param program defines the program to use
+     * @returns a string containing the source code of the vertex shader associated with the program
+     */
+    getVertexShaderSource(program) {
+        const shaders = this._gl.getAttachedShaders(program);
+        if (!shaders) {
+            return null;
+        }
+        return this._gl.getShaderSource(shaders[0]);
+    }
+    /**
+     * Gets the source code of the fragment shader associated with a specific webGL program
+     * @param program defines the program to use
+     * @returns a string containing the source code of the fragment shader associated with the program
+     */
+    getFragmentShaderSource(program) {
+        const shaders = this._gl.getAttachedShaders(program);
+        if (!shaders) {
+            return null;
+        }
+        return this._gl.getShaderSource(shaders[1]);
+    }
+    /**
+     * sets the object from which width and height will be taken from when getting render width and height
+     * Will fallback to the gl object
+     * @param dimensions the framebuffer width and height that will be used.
+     */
+    set framebufferDimensionsObject(dimensions) {
+        this._framebufferDimensionsObject = dimensions;
+        if (this._framebufferDimensionsObject) {
+            this.onResizeObservable.notifyObservers(this);
+        }
+    }
+    _rebuildBuffers() {
+        // Index / Vertex
+        for (const scene of this.scenes) {
+            scene.resetCachedMaterial();
+            scene._rebuildGeometries();
+        }
+        for (const scene of this._virtualScenes) {
+            scene.resetCachedMaterial();
+            scene._rebuildGeometries();
+        }
+        super._rebuildBuffers();
+    }
+    /**
+     * Get Font size information
+     * @param font font name
+     * @returns an object containing ascent, height and descent
+     */
+    getFontOffset(font) {
+        return GetFontOffset(font);
+    }
+    _cancelFrame() {
+        if (this.customAnimationFrameRequester) {
+            if (this._frameHandler !== 0) {
+                this._frameHandler = 0;
+                const { cancelAnimationFrame } = this.customAnimationFrameRequester;
+                if (cancelAnimationFrame) {
+                    cancelAnimationFrame(this.customAnimationFrameRequester.requestID);
+                }
+            }
+        }
+        else {
+            super._cancelFrame();
+        }
+    }
+    _renderLoop() {
+        // Reset the frame handler before rendering a frame to determine if a new frame has been queued.
+        this._frameHandler = 0;
+        if (!this._contextWasLost) {
+            let shouldRender = true;
+            if (this.isDisposed || (!this.renderEvenInBackground && this._windowIsBackground)) {
+                shouldRender = false;
+            }
+            if (shouldRender) {
+                // Start new frame
+                this.beginFrame();
+                // Child canvases
+                if (!this._renderViews()) {
+                    // Main frame
+                    this._renderFrame();
+                }
+                // Present
+                this.endFrame();
+            }
+        }
+        // The first condition prevents queuing another frame if we no longer have active render loops (e.g., if
+        // `stopRenderLoop` is called mid frame). The second condition prevents queuing another frame if one has
+        // already been queued (e.g., if `stopRenderLoop` and `runRenderLoop` is called mid frame).
+        if (this._activeRenderLoops.length > 0 && this._frameHandler === 0) {
+            if (this.customAnimationFrameRequester) {
+                this.customAnimationFrameRequester.requestID = this._queueNewFrame(this.customAnimationFrameRequester.renderFunction || this._boundRenderFunction, this.customAnimationFrameRequester);
+                this._frameHandler = this.customAnimationFrameRequester.requestID;
+            }
+            else {
+                this._frameHandler = this._queueNewFrame(this._boundRenderFunction, this.getHostWindow());
+            }
+        }
+    }
+    /**
+     * Enters Pointerlock mode
+     */
+    enterPointerlock() {
+        if (this._renderingCanvas) {
+            RequestPointerlock(this._renderingCanvas);
+        }
+    }
+    /**
+     * Exits Pointerlock mode
+     */
+    exitPointerlock() {
+        ExitPointerlock();
+    }
+    /**
+     * Begin a new frame
+     */
+    beginFrame() {
+        this._measureFps();
+        super.beginFrame();
+    }
+    _deletePipelineContext(pipelineContext) {
+        const webGLPipelineContext = pipelineContext;
+        if (webGLPipelineContext && webGLPipelineContext.program) {
+            if (webGLPipelineContext.transformFeedback) {
+                this.deleteTransformFeedback(webGLPipelineContext.transformFeedback);
+                webGLPipelineContext.transformFeedback = null;
+            }
+        }
+        super._deletePipelineContext(pipelineContext);
+    }
+    createShaderProgram(pipelineContext, vertexCode, fragmentCode, defines, context, transformFeedbackVaryings = null) {
+        context = context || this._gl;
+        this.onBeforeShaderCompilationObservable.notifyObservers(this);
+        const program = super.createShaderProgram(pipelineContext, vertexCode, fragmentCode, defines, context, transformFeedbackVaryings);
+        this.onAfterShaderCompilationObservable.notifyObservers(this);
+        return program;
+    }
+    _createShaderProgram(pipelineContext, vertexShader, fragmentShader, context, transformFeedbackVaryings = null) {
+        const shaderProgram = context.createProgram();
+        pipelineContext.program = shaderProgram;
+        if (!shaderProgram) {
+            throw new Error("Unable to create program");
+        }
+        context.attachShader(shaderProgram, vertexShader);
+        context.attachShader(shaderProgram, fragmentShader);
+        if (this.webGLVersion > 1 && transformFeedbackVaryings) {
+            const transformFeedback = this.createTransformFeedback();
+            this.bindTransformFeedback(transformFeedback);
+            this.setTranformFeedbackVaryings(shaderProgram, transformFeedbackVaryings);
+            pipelineContext.transformFeedback = transformFeedback;
+        }
+        context.linkProgram(shaderProgram);
+        if (this.webGLVersion > 1 && transformFeedbackVaryings) {
+            this.bindTransformFeedback(null);
+        }
+        pipelineContext.context = context;
+        pipelineContext.vertexShader = vertexShader;
+        pipelineContext.fragmentShader = fragmentShader;
+        if (!pipelineContext.isParallelCompiled) {
+            this._finalizePipelineContext(pipelineContext);
+        }
+        return shaderProgram;
+    }
+    /**
+     * @internal
+     */
+    _releaseTexture(texture) {
+        super._releaseTexture(texture);
+    }
+    /**
+     * @internal
+     */
+    _releaseRenderTargetWrapper(rtWrapper) {
+        super._releaseRenderTargetWrapper(rtWrapper);
+        // Set output texture of post process to null if the framebuffer has been released/disposed
+        this.scenes.forEach((scene) => {
+            scene.postProcesses.forEach((postProcess) => {
+                if (postProcess._outputTexture === rtWrapper) {
+                    postProcess._outputTexture = null;
+                }
+            });
+            scene.cameras.forEach((camera) => {
+                camera._postProcesses.forEach((postProcess) => {
+                    if (postProcess) {
+                        if (postProcess._outputTexture === rtWrapper) {
+                            postProcess._outputTexture = null;
+                        }
+                    }
+                });
+            });
+        });
+    }
+    /**
+     * @internal
+     * Rescales a texture
+     * @param source input texture
+     * @param destination destination texture
+     * @param scene scene to use to render the resize
+     * @param internalFormat format to use when resizing
+     * @param onComplete callback to be called when resize has completed
+     */
+    _rescaleTexture(source, destination, scene, internalFormat, onComplete) {
+        this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_MAG_FILTER, this._gl.LINEAR);
+        this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_MIN_FILTER, this._gl.LINEAR);
+        this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_WRAP_S, this._gl.CLAMP_TO_EDGE);
+        this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_WRAP_T, this._gl.CLAMP_TO_EDGE);
+        const rtt = this.createRenderTargetTexture({
+            width: destination.width,
+            height: destination.height,
+        }, {
+            generateMipMaps: false,
+            type: Constants.TEXTURETYPE_UNSIGNED_INT,
+            samplingMode: Constants.TEXTURE_BILINEAR_SAMPLINGMODE,
+            generateDepthBuffer: false,
+            generateStencilBuffer: false,
+        });
+        if (!this._rescalePostProcess && Engine._RescalePostProcessFactory) {
+            this._rescalePostProcess = Engine._RescalePostProcessFactory(this);
+        }
+        if (this._rescalePostProcess) {
+            this._rescalePostProcess.externalTextureSamplerBinding = true;
+            const onCompiled = () => {
+                this._rescalePostProcess.onApply = function (effect) {
+                    effect._bindTexture("textureSampler", source);
+                };
+                let hostingScene = scene;
+                if (!hostingScene) {
+                    hostingScene = this.scenes[this.scenes.length - 1];
+                }
+                hostingScene.postProcessManager.directRender([this._rescalePostProcess], rtt, true);
+                this._bindTextureDirectly(this._gl.TEXTURE_2D, destination, true);
+                this._gl.copyTexImage2D(this._gl.TEXTURE_2D, 0, internalFormat, 0, 0, destination.width, destination.height, 0);
+                this.unBindFramebuffer(rtt);
+                rtt.dispose();
+                if (onComplete) {
+                    onComplete();
+                }
+            };
+            const effect = this._rescalePostProcess.getEffect();
+            if (effect) {
+                effect.executeWhenCompiled(onCompiled);
+            }
+            else {
+                this._rescalePostProcess.onEffectCreatedObservable.addOnce((effect) => {
+                    effect.executeWhenCompiled(onCompiled);
+                });
+            }
+        }
+    }
+    /**
+     * Wraps an external web gl texture in a Babylon texture.
+     * @param texture defines the external texture
+     * @param hasMipMaps defines whether the external texture has mip maps (default: false)
+     * @param samplingMode defines the sampling mode for the external texture (default: Constants.TEXTURE_TRILINEAR_SAMPLINGMODE)
+     * @param width defines the width for the external texture (default: 0)
+     * @param height defines the height for the external texture (default: 0)
+     * @returns the babylon internal texture
+     */
+    wrapWebGLTexture(texture, hasMipMaps = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, width = 0, height = 0) {
+        const hardwareTexture = new WebGLHardwareTexture(texture, this._gl);
+        const internalTexture = new InternalTexture(this, 0 /* InternalTextureSource.Unknown */, true);
+        internalTexture._hardwareTexture = hardwareTexture;
+        internalTexture.baseWidth = width;
+        internalTexture.baseHeight = height;
+        internalTexture.width = width;
+        internalTexture.height = height;
+        internalTexture.isReady = true;
+        internalTexture.useMipMaps = hasMipMaps;
+        this.updateTextureSamplingMode(samplingMode, internalTexture);
+        return internalTexture;
+    }
+    /**
+     * @internal
+     */
+    _uploadImageToTexture(texture, image, faceIndex = 0, lod = 0) {
+        const gl = this._gl;
+        const textureType = this._getWebGLTextureType(texture.type);
+        const format = this._getInternalFormat(texture.format);
+        const internalFormat = this._getRGBABufferInternalSizedFormat(texture.type, format);
+        const bindTarget = texture.isCube ? gl.TEXTURE_CUBE_MAP : gl.TEXTURE_2D;
+        this._bindTextureDirectly(bindTarget, texture, true);
+        this._unpackFlipY(texture.invertY);
+        let target = gl.TEXTURE_2D;
+        if (texture.isCube) {
+            target = gl.TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex;
+        }
+        gl.texImage2D(target, lod, internalFormat, format, textureType, image);
+        this._bindTextureDirectly(bindTarget, null, true);
+    }
+    /**
+     * Updates a depth texture Comparison Mode and Function.
+     * If the comparison Function is equal to 0, the mode will be set to none.
+     * Otherwise, this only works in webgl 2 and requires a shadow sampler in the shader.
+     * @param texture The texture to set the comparison function for
+     * @param comparisonFunction The comparison function to set, 0 if no comparison required
+     */
+    updateTextureComparisonFunction(texture, comparisonFunction) {
+        if (this.webGLVersion === 1) {
+            Logger.Error("WebGL 1 does not support texture comparison.");
+            return;
+        }
+        const gl = this._gl;
+        if (texture.isCube) {
+            this._bindTextureDirectly(this._gl.TEXTURE_CUBE_MAP, texture, true);
+            if (comparisonFunction === 0) {
+                gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_COMPARE_FUNC, Constants.LEQUAL);
+                gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_COMPARE_MODE, gl.NONE);
+            }
+            else {
+                gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_COMPARE_FUNC, comparisonFunction);
+                gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE);
+            }
+            this._bindTextureDirectly(this._gl.TEXTURE_CUBE_MAP, null);
+        }
+        else {
+            this._bindTextureDirectly(this._gl.TEXTURE_2D, texture, true);
+            if (comparisonFunction === 0) {
+                gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_FUNC, Constants.LEQUAL);
+                gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_MODE, gl.NONE);
+            }
+            else {
+                gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_FUNC, comparisonFunction);
+                gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE);
+            }
+            this._bindTextureDirectly(this._gl.TEXTURE_2D, null);
+        }
+        texture._comparisonFunction = comparisonFunction;
+    }
+    /**
+     * Creates a webGL buffer to use with instantiation
+     * @param capacity defines the size of the buffer
+     * @returns the webGL buffer
+     */
+    createInstancesBuffer(capacity) {
+        const buffer = this._gl.createBuffer();
+        if (!buffer) {
+            throw new Error("Unable to create instance buffer");
+        }
+        const result = new WebGLDataBuffer(buffer);
+        result.capacity = capacity;
+        this.bindArrayBuffer(result);
+        this._gl.bufferData(this._gl.ARRAY_BUFFER, capacity, this._gl.DYNAMIC_DRAW);
+        result.references = 1;
+        return result;
+    }
+    /**
+     * Delete a webGL buffer used with instantiation
+     * @param buffer defines the webGL buffer to delete
+     */
+    deleteInstancesBuffer(buffer) {
+        this._gl.deleteBuffer(buffer);
+    }
+    _clientWaitAsync(sync, flags = 0, intervalms = 10) {
+        const gl = this._gl;
+        return new Promise((resolve, reject) => {
+            _retryWithInterval(() => {
+                const res = gl.clientWaitSync(sync, flags, 0);
+                if (res == gl.WAIT_FAILED) {
+                    throw new Error("clientWaitSync failed");
+                }
+                if (res == gl.TIMEOUT_EXPIRED) {
+                    return false;
+                }
+                return true;
+            }, resolve, reject, intervalms);
+        });
+    }
+    /**
+     * @internal
+     */
+    _readPixelsAsync(x, y, w, h, format, type, outputBuffer) {
+        if (this._webGLVersion < 2) {
+            throw new Error("_readPixelsAsync only work on WebGL2+");
+        }
+        const gl = this._gl;
+        const buf = gl.createBuffer();
+        gl.bindBuffer(gl.PIXEL_PACK_BUFFER, buf);
+        gl.bufferData(gl.PIXEL_PACK_BUFFER, outputBuffer.byteLength, gl.STREAM_READ);
+        gl.readPixels(x, y, w, h, format, type, 0);
+        gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
+        const sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
+        if (!sync) {
+            return null;
+        }
+        gl.flush();
+        return this._clientWaitAsync(sync, 0, 10).then(() => {
+            gl.deleteSync(sync);
+            gl.bindBuffer(gl.PIXEL_PACK_BUFFER, buf);
+            gl.getBufferSubData(gl.PIXEL_PACK_BUFFER, 0, outputBuffer);
+            gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
+            gl.deleteBuffer(buf);
+            return outputBuffer;
+        });
+    }
+    dispose() {
+        this.hideLoadingUI();
+        // Rescale PP
+        if (this._rescalePostProcess) {
+            this._rescalePostProcess.dispose();
+        }
+        _CommonDispose(this, this._renderingCanvas);
+        super.dispose();
+    }
+}
+// Const statics
+/** Defines that alpha blending is disabled */
+Engine.ALPHA_DISABLE = Constants.ALPHA_DISABLE;
+/** Defines that alpha blending to SRC ALPHA * SRC + DEST */
+Engine.ALPHA_ADD = Constants.ALPHA_ADD;
+/** Defines that alpha blending to SRC ALPHA * SRC + (1 - SRC ALPHA) * DEST */
+Engine.ALPHA_COMBINE = Constants.ALPHA_COMBINE;
+/** Defines that alpha blending to DEST - SRC * DEST */
+Engine.ALPHA_SUBTRACT = Constants.ALPHA_SUBTRACT;
+/** Defines that alpha blending to SRC * DEST */
+Engine.ALPHA_MULTIPLY = Constants.ALPHA_MULTIPLY;
+/** Defines that alpha blending to SRC ALPHA * SRC + (1 - SRC) * DEST */
+Engine.ALPHA_MAXIMIZED = Constants.ALPHA_MAXIMIZED;
+/** Defines that alpha blending to SRC + DEST */
+Engine.ALPHA_ONEONE = Constants.ALPHA_ONEONE;
+/** Defines that alpha blending to SRC + (1 - SRC ALPHA) * DEST */
+Engine.ALPHA_PREMULTIPLIED = Constants.ALPHA_PREMULTIPLIED;
+/**
+ * Defines that alpha blending to SRC + (1 - SRC ALPHA) * DEST
+ * Alpha will be set to (1 - SRC ALPHA) * DEST ALPHA
+ */
+Engine.ALPHA_PREMULTIPLIED_PORTERDUFF = Constants.ALPHA_PREMULTIPLIED_PORTERDUFF;
+/** Defines that alpha blending to CST * SRC + (1 - CST) * DEST */
+Engine.ALPHA_INTERPOLATE = Constants.ALPHA_INTERPOLATE;
+/**
+ * Defines that alpha blending to SRC + (1 - SRC) * DEST
+ * Alpha will be set to SRC ALPHA + (1 - SRC ALPHA) * DEST ALPHA
+ */
+Engine.ALPHA_SCREENMODE = Constants.ALPHA_SCREENMODE;
+/** Defines that the resource is not delayed*/
+Engine.DELAYLOADSTATE_NONE = Constants.DELAYLOADSTATE_NONE;
+/** Defines that the resource was successfully delay loaded */
+Engine.DELAYLOADSTATE_LOADED = Constants.DELAYLOADSTATE_LOADED;
+/** Defines that the resource is currently delay loading */
+Engine.DELAYLOADSTATE_LOADING = Constants.DELAYLOADSTATE_LOADING;
+/** Defines that the resource is delayed and has not started loading */
+Engine.DELAYLOADSTATE_NOTLOADED = Constants.DELAYLOADSTATE_NOTLOADED;
+// Depht or Stencil test Constants.
+/** Passed to depthFunction or stencilFunction to specify depth or stencil tests will never pass. i.e. Nothing will be drawn */
+Engine.NEVER = Constants.NEVER;
+/** 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 */
+Engine.ALWAYS = Constants.ALWAYS;
+/** Passed to depthFunction or stencilFunction to specify depth or stencil tests will pass if the new depth value is less than the stored value */
+Engine.LESS = Constants.LESS;
+/** Passed to depthFunction or stencilFunction to specify depth or stencil tests will pass if the new depth value is equals to the stored value */
+Engine.EQUAL = Constants.EQUAL;
+/** 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 */
+Engine.LEQUAL = Constants.LEQUAL;
+/** Passed to depthFunction or stencilFunction to specify depth or stencil tests will pass if the new depth value is greater than the stored value */
+Engine.GREATER = Constants.GREATER;
+/** 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 */
+Engine.GEQUAL = Constants.GEQUAL;
+/** 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 */
+Engine.NOTEQUAL = Constants.NOTEQUAL;
+// Stencil Actions Constants.
+/** Passed to stencilOperation to specify that stencil value must be kept */
+Engine.KEEP = Constants.KEEP;
+/** Passed to stencilOperation to specify that stencil value must be replaced */
+Engine.REPLACE = Constants.REPLACE;
+/** Passed to stencilOperation to specify that stencil value must be incremented */
+Engine.INCR = Constants.INCR;
+/** Passed to stencilOperation to specify that stencil value must be decremented */
+Engine.DECR = Constants.DECR;
+/** Passed to stencilOperation to specify that stencil value must be inverted */
+Engine.INVERT = Constants.INVERT;
+/** Passed to stencilOperation to specify that stencil value must be incremented with wrapping */
+Engine.INCR_WRAP = Constants.INCR_WRAP;
+/** Passed to stencilOperation to specify that stencil value must be decremented with wrapping */
+Engine.DECR_WRAP = Constants.DECR_WRAP;
+/** Texture is not repeating outside of 0..1 UVs */
+Engine.TEXTURE_CLAMP_ADDRESSMODE = Constants.TEXTURE_CLAMP_ADDRESSMODE;
+/** Texture is repeating outside of 0..1 UVs */
+Engine.TEXTURE_WRAP_ADDRESSMODE = Constants.TEXTURE_WRAP_ADDRESSMODE;
+/** Texture is repeating and mirrored */
+Engine.TEXTURE_MIRROR_ADDRESSMODE = Constants.TEXTURE_MIRROR_ADDRESSMODE;
+/** ALPHA */
+Engine.TEXTUREFORMAT_ALPHA = Constants.TEXTUREFORMAT_ALPHA;
+/** LUMINANCE */
+Engine.TEXTUREFORMAT_LUMINANCE = Constants.TEXTUREFORMAT_LUMINANCE;
+/** LUMINANCE_ALPHA */
+Engine.TEXTUREFORMAT_LUMINANCE_ALPHA = Constants.TEXTUREFORMAT_LUMINANCE_ALPHA;
+/** RGB */
+Engine.TEXTUREFORMAT_RGB = Constants.TEXTUREFORMAT_RGB;
+/** RGBA */
+Engine.TEXTUREFORMAT_RGBA = Constants.TEXTUREFORMAT_RGBA;
+/** RED */
+Engine.TEXTUREFORMAT_RED = Constants.TEXTUREFORMAT_RED;
+/** RED (2nd reference) */
+Engine.TEXTUREFORMAT_R = Constants.TEXTUREFORMAT_R;
+/** RED unsigned short normed to [0, 1] **/
+Engine.TEXTUREFORMAT_R16_UNORM = Constants.TEXTUREFORMAT_R16_UNORM;
+/** RG unsigned short normed to [0, 1] **/
+Engine.TEXTUREFORMAT_RG16_UNORM = Constants.TEXTUREFORMAT_RG16_UNORM;
+/** RGB unsigned short normed to [0, 1] **/
+Engine.TEXTUREFORMAT_RGB16_UNORM = Constants.TEXTUREFORMAT_RGB16_UNORM;
+/** RGBA unsigned short normed to [0, 1] **/
+Engine.TEXTUREFORMAT_RGBA16_UNORM = Constants.TEXTUREFORMAT_RGBA16_UNORM;
+/** RED signed short normed to [-1, 1] **/
+Engine.TEXTUREFORMAT_R16_SNORM = Constants.TEXTUREFORMAT_R16_SNORM;
+/** RG signed short normed to [-1, 1] **/
+Engine.TEXTUREFORMAT_RG16_SNORM = Constants.TEXTUREFORMAT_RG16_SNORM;
+/** RGB signed short normed to [-1, 1] **/
+Engine.TEXTUREFORMAT_RGB16_SNORM = Constants.TEXTUREFORMAT_RGB16_SNORM;
+/** RGBA signed short normed to [-1, 1] **/
+Engine.TEXTUREFORMAT_RGBA16_SNORM = Constants.TEXTUREFORMAT_RGBA16_SNORM;
+/** RG */
+Engine.TEXTUREFORMAT_RG = Constants.TEXTUREFORMAT_RG;
+/** RED_INTEGER */
+Engine.TEXTUREFORMAT_RED_INTEGER = Constants.TEXTUREFORMAT_RED_INTEGER;
+/** RED_INTEGER (2nd reference) */
+Engine.TEXTUREFORMAT_R_INTEGER = Constants.TEXTUREFORMAT_R_INTEGER;
+/** RG_INTEGER */
+Engine.TEXTUREFORMAT_RG_INTEGER = Constants.TEXTUREFORMAT_RG_INTEGER;
+/** RGB_INTEGER */
+Engine.TEXTUREFORMAT_RGB_INTEGER = Constants.TEXTUREFORMAT_RGB_INTEGER;
+/** RGBA_INTEGER */
+Engine.TEXTUREFORMAT_RGBA_INTEGER = Constants.TEXTUREFORMAT_RGBA_INTEGER;
+/** UNSIGNED_BYTE */
+Engine.TEXTURETYPE_UNSIGNED_BYTE = Constants.TEXTURETYPE_UNSIGNED_BYTE;
+/** @deprecated use more explicit TEXTURETYPE_UNSIGNED_BYTE instead. Use TEXTURETYPE_UNSIGNED_INTEGER for 32bits values.*/
+Engine.TEXTURETYPE_UNSIGNED_INT = Constants.TEXTURETYPE_UNSIGNED_INT;
+/** FLOAT */
+Engine.TEXTURETYPE_FLOAT = Constants.TEXTURETYPE_FLOAT;
+/** HALF_FLOAT */
+Engine.TEXTURETYPE_HALF_FLOAT = Constants.TEXTURETYPE_HALF_FLOAT;
+/** BYTE */
+Engine.TEXTURETYPE_BYTE = Constants.TEXTURETYPE_BYTE;
+/** SHORT */
+Engine.TEXTURETYPE_SHORT = Constants.TEXTURETYPE_SHORT;
+/** UNSIGNED_SHORT */
+Engine.TEXTURETYPE_UNSIGNED_SHORT = Constants.TEXTURETYPE_UNSIGNED_SHORT;
+/** INT */
+Engine.TEXTURETYPE_INT = Constants.TEXTURETYPE_INT;
+/** UNSIGNED_INT */
+Engine.TEXTURETYPE_UNSIGNED_INTEGER = Constants.TEXTURETYPE_UNSIGNED_INTEGER;
+/** UNSIGNED_SHORT_4_4_4_4 */
+Engine.TEXTURETYPE_UNSIGNED_SHORT_4_4_4_4 = Constants.TEXTURETYPE_UNSIGNED_SHORT_4_4_4_4;
+/** UNSIGNED_SHORT_5_5_5_1 */
+Engine.TEXTURETYPE_UNSIGNED_SHORT_5_5_5_1 = Constants.TEXTURETYPE_UNSIGNED_SHORT_5_5_5_1;
+/** UNSIGNED_SHORT_5_6_5 */
+Engine.TEXTURETYPE_UNSIGNED_SHORT_5_6_5 = Constants.TEXTURETYPE_UNSIGNED_SHORT_5_6_5;
+/** UNSIGNED_INT_2_10_10_10_REV */
+Engine.TEXTURETYPE_UNSIGNED_INT_2_10_10_10_REV = Constants.TEXTURETYPE_UNSIGNED_INT_2_10_10_10_REV;
+/** UNSIGNED_INT_24_8 */
+Engine.TEXTURETYPE_UNSIGNED_INT_24_8 = Constants.TEXTURETYPE_UNSIGNED_INT_24_8;
+/** UNSIGNED_INT_10F_11F_11F_REV */
+Engine.TEXTURETYPE_UNSIGNED_INT_10F_11F_11F_REV = Constants.TEXTURETYPE_UNSIGNED_INT_10F_11F_11F_REV;
+/** UNSIGNED_INT_5_9_9_9_REV */
+Engine.TEXTURETYPE_UNSIGNED_INT_5_9_9_9_REV = Constants.TEXTURETYPE_UNSIGNED_INT_5_9_9_9_REV;
+/** FLOAT_32_UNSIGNED_INT_24_8_REV */
+Engine.TEXTURETYPE_FLOAT_32_UNSIGNED_INT_24_8_REV = Constants.TEXTURETYPE_FLOAT_32_UNSIGNED_INT_24_8_REV;
+/** nearest is mag = nearest and min = nearest and mip = none */
+Engine.TEXTURE_NEAREST_SAMPLINGMODE = Constants.TEXTURE_NEAREST_SAMPLINGMODE;
+/** Bilinear is mag = linear and min = linear and mip = nearest */
+Engine.TEXTURE_BILINEAR_SAMPLINGMODE = Constants.TEXTURE_BILINEAR_SAMPLINGMODE;
+/** Trilinear is mag = linear and min = linear and mip = linear */
+Engine.TEXTURE_TRILINEAR_SAMPLINGMODE = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE;
+/** nearest is mag = nearest and min = nearest and mip = linear */
+Engine.TEXTURE_NEAREST_NEAREST_MIPLINEAR = Constants.TEXTURE_NEAREST_NEAREST_MIPLINEAR;
+/** Bilinear is mag = linear and min = linear and mip = nearest */
+Engine.TEXTURE_LINEAR_LINEAR_MIPNEAREST = Constants.TEXTURE_LINEAR_LINEAR_MIPNEAREST;
+/** Trilinear is mag = linear and min = linear and mip = linear */
+Engine.TEXTURE_LINEAR_LINEAR_MIPLINEAR = Constants.TEXTURE_LINEAR_LINEAR_MIPLINEAR;
+/** mag = nearest and min = nearest and mip = nearest */
+Engine.TEXTURE_NEAREST_NEAREST_MIPNEAREST = Constants.TEXTURE_NEAREST_NEAREST_MIPNEAREST;
+/** mag = nearest and min = linear and mip = nearest */
+Engine.TEXTURE_NEAREST_LINEAR_MIPNEAREST = Constants.TEXTURE_NEAREST_LINEAR_MIPNEAREST;
+/** mag = nearest and min = linear and mip = linear */
+Engine.TEXTURE_NEAREST_LINEAR_MIPLINEAR = Constants.TEXTURE_NEAREST_LINEAR_MIPLINEAR;
+/** mag = nearest and min = linear and mip = none */
+Engine.TEXTURE_NEAREST_LINEAR = Constants.TEXTURE_NEAREST_LINEAR;
+/** mag = nearest and min = nearest and mip = none */
+Engine.TEXTURE_NEAREST_NEAREST = Constants.TEXTURE_NEAREST_NEAREST;
+/** mag = linear and min = nearest and mip = nearest */
+Engine.TEXTURE_LINEAR_NEAREST_MIPNEAREST = Constants.TEXTURE_LINEAR_NEAREST_MIPNEAREST;
+/** mag = linear and min = nearest and mip = linear */
+Engine.TEXTURE_LINEAR_NEAREST_MIPLINEAR = Constants.TEXTURE_LINEAR_NEAREST_MIPLINEAR;
+/** mag = linear and min = linear and mip = none */
+Engine.TEXTURE_LINEAR_LINEAR = Constants.TEXTURE_LINEAR_LINEAR;
+/** mag = linear and min = nearest and mip = none */
+Engine.TEXTURE_LINEAR_NEAREST = Constants.TEXTURE_LINEAR_NEAREST;
+/** Explicit coordinates mode */
+Engine.TEXTURE_EXPLICIT_MODE = Constants.TEXTURE_EXPLICIT_MODE;
+/** Spherical coordinates mode */
+Engine.TEXTURE_SPHERICAL_MODE = Constants.TEXTURE_SPHERICAL_MODE;
+/** Planar coordinates mode */
+Engine.TEXTURE_PLANAR_MODE = Constants.TEXTURE_PLANAR_MODE;
+/** Cubic coordinates mode */
+Engine.TEXTURE_CUBIC_MODE = Constants.TEXTURE_CUBIC_MODE;
+/** Projection coordinates mode */
+Engine.TEXTURE_PROJECTION_MODE = Constants.TEXTURE_PROJECTION_MODE;
+/** Skybox coordinates mode */
+Engine.TEXTURE_SKYBOX_MODE = Constants.TEXTURE_SKYBOX_MODE;
+/** Inverse Cubic coordinates mode */
+Engine.TEXTURE_INVCUBIC_MODE = Constants.TEXTURE_INVCUBIC_MODE;
+/** Equirectangular coordinates mode */
+Engine.TEXTURE_EQUIRECTANGULAR_MODE = Constants.TEXTURE_EQUIRECTANGULAR_MODE;
+/** Equirectangular Fixed coordinates mode */
+Engine.TEXTURE_FIXED_EQUIRECTANGULAR_MODE = Constants.TEXTURE_FIXED_EQUIRECTANGULAR_MODE;
+/** Equirectangular Fixed Mirrored coordinates mode */
+Engine.TEXTURE_FIXED_EQUIRECTANGULAR_MIRRORED_MODE = Constants.TEXTURE_FIXED_EQUIRECTANGULAR_MIRRORED_MODE;
+// Texture rescaling mode
+/** Defines that texture rescaling will use a floor to find the closer power of 2 size */
+Engine.SCALEMODE_FLOOR = Constants.SCALEMODE_FLOOR;
+/** Defines that texture rescaling will look for the nearest power of 2 size */
+Engine.SCALEMODE_NEAREST = Constants.SCALEMODE_NEAREST;
+/** Defines that texture rescaling will use a ceil to find the closer power of 2 size */
+Engine.SCALEMODE_CEILING = Constants.SCALEMODE_CEILING;
+
+export { Engine };
+//# sourceMappingURL=engine-D9Sn-BC6.esm.js.map