@babylonjs/viewer 7.35.0-alpha → 7.35.0

package/dist/chunks/engine-DoMoX317.esm.js

@@ -1,2186 +0,0 @@
-import { C as Constants, I as InternalTexture, L as Logger, a as IsExponentOfTwo, b as allocateAndCopyTypedBuffer, G as GetExponentOfTwo, S as SphericalPolynomial, B as BaseTexture, A as AbstractEngine, E as EngineStore, P as PerfCounter } from './index-Dd2GiZLW.esm.js';
-import { T as ThinEngine, W as WebGLDataBuffer, a as WebGLHardwareTexture } from './thinEngine-BFufvZnC.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-DKF75ctB.esm.js';
-import { D as DDSTools } from './dds-Dyxx6BnX.esm.js';
-import './audioEngine-Csyz3M0f.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_INT, 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_INT, 
-// 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_INT) {
-        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_INT) {
-        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 {
-    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) {
-        if (!texture._hardwareTexture) {
-            return;
-        }
-        const framebuffer = this._framebuffer;
-        const engine = this._engine;
-        const currentFB = engine._currentFramebuffer;
-        engine._bindUnboundFramebuffer(framebuffer);
-        if (engine.webGLVersion > 1) {
-            const gl = this._context;
-            const attachment = gl["COLOR_ATTACHMENT" + attachmentIndex];
-            if (texture.is2DArray || texture.is3D) {
-                faceIndexOrLayer = faceIndexOrLayer ?? this.layerIndices?.[attachmentIndex] ?? 0;
-                gl.framebufferTextureLayer(gl.FRAMEBUFFER, attachment, texture._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, texture._hardwareTexture.underlyingResource, lodLevel);
-            }
-            else {
-                gl.framebufferTexture2D(gl.FRAMEBUFFER, attachment, gl.TEXTURE_2D, texture._hardwareTexture.underlyingResource, lodLevel);
-            }
-        }
-        else {
-            // Default behavior (WebGL)
-            const gl = this._context;
-            const 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, texture._hardwareTexture.underlyingResource, lodLevel);
-        }
-        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]);
-        }
-    }
-    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;
-    let type = gl.UNSIGNED_INT;
-    if (internalTexture.format === Constants.TEXTUREFORMAT_DEPTH16) {
-        type = gl.UNSIGNED_SHORT;
-    }
-    else if (internalTexture.format === Constants.TEXTUREFORMAT_DEPTH24UNORM_STENCIL8 || internalTexture.format === Constants.TEXTUREFORMAT_DEPTH24_STENCIL8) {
-        type = gl.UNSIGNED_INT_24_8;
-    }
-    else if (internalTexture.format === Constants.TEXTUREFORMAT_DEPTH32_FLOAT) {
-        type = gl.FLOAT;
-    }
-    else if (internalTexture.format === Constants.TEXTUREFORMAT_DEPTH32FLOAT_STENCIL8) {
-        type = gl.FLOAT_32_UNSIGNED_INT_24_8_REV;
-    }
-    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_INT;
-    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_INT,
-        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_INT;
-        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 = (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;
-        }
-        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;
-        if (canvasOrContext.getContext) {
-            const canvas = canvasOrContext;
-            this._sharedInit(canvas);
-        }
-    }
-    _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) => {
-            const check = () => {
-                const res = gl.clientWaitSync(sync, flags, 0);
-                if (res == gl.WAIT_FAILED) {
-                    reject();
-                    return;
-                }
-                if (res == gl.TIMEOUT_EXPIRED) {
-                    setTimeout(check, intervalms);
-                    return;
-                }
-                resolve();
-            };
-            check();
-        });
-    }
-    /**
-     * @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;
-/** 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;
-/** UNSIGNED_BYTE (2nd reference) */
-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-DoMoX317.esm.js.map