@spiffcommerce/preview 3.6.2-rc.8 → 4.0.0

package/dist/variants.esm2.js

@@ -1,3097 +0,0 @@
-import { _ as __awaiter } from './_tslib.esm.js';
-import { S as SceneLoader, g as getAssetContainer } from './assetCache.esm2.js';
-import { T as ThinEngine, I as InternalTexture, a as InternalTextureSource, L as Logger, q as RandomGUID, r as LoadImage, c as Tools, e as ShaderStore } from './engine.esm.js';
-import { _ as __decorate, M as Matrix, O as Observable, V as Vector3, T as TmpVectors, S as SerializationHelper, s as serialize, d as serializeAsVector3, k as serializeAsMatrix, E as EngineStore } from './webRequest.esm.js';
-import { T as Texture, B as BaseTexture, E as EffectWrapper, a as EffectRenderer } from './helperFunctions.esm.js';
-import { G as GetClass, R as RegisterClass, S as Scalar, b as ToGammaSpace } from './math.color.esm.js';
-import { C as CubeMapToSphericalPolynomialTools, T as ToHalfFloat } from './hdrFilteringFunctions.esm.js';
-import './math.axis.esm.js';
-import './math.path.esm.js';
-import './pbrBRDFFunctions.esm.js';
-import { calculateMaterialProperties, applyDownloadedTexture } from './material.esm.js';
-
-ThinEngine.prototype._createDepthStencilCubeTexture = function (size, options, rtWrapper) {
-    const internalTexture = new InternalTexture(this, InternalTextureSource.DepthStencil);
-    internalTexture.isCube = true;
-    if (this.webGLVersion === 1) {
-        Logger.Error("Depth cube texture is not supported by WebGL 1.");
-        return internalTexture;
-    }
-    const internalOptions = Object.assign({ bilinearFiltering: false, comparisonFunction: 0, generateStencil: false }, options);
-    const gl = this._gl;
-    this._bindTextureDirectly(gl.TEXTURE_CUBE_MAP, internalTexture, true);
-    this._setupDepthStencilTexture(internalTexture, size, internalOptions.generateStencil, internalOptions.bilinearFiltering, internalOptions.comparisonFunction);
-    rtWrapper._depthStencilTexture = internalTexture;
-    rtWrapper._depthStencilTextureWithStencil = internalOptions.generateStencil;
-    // 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._partialLoadFile = function (url, index, loadedFiles, onfinish, onErrorCallBack = null) {
-    const onload = (data) => {
-        loadedFiles[index] = data;
-        loadedFiles._internalCount++;
-        if (loadedFiles._internalCount === 6) {
-            onfinish(loadedFiles);
-        }
-    };
-    const onerror = (request, exception) => {
-        if (onErrorCallBack && request) {
-            onErrorCallBack(request.status + " " + request.statusText, exception);
-        }
-    };
-    this._loadFile(url, onload, undefined, undefined, true, onerror);
-};
-ThinEngine.prototype._cascadeLoadFiles = function (scene, onfinish, files, onError = null) {
-    const loadedFiles = [];
-    loadedFiles._internalCount = 0;
-    for (let index = 0; index < 6; index++) {
-        this._partialLoadFile(files[index], index, loadedFiles, onfinish, onError);
-    }
-};
-ThinEngine.prototype._cascadeLoadImgs = function (scene, texture, onfinish, files, onError = null, mimeType) {
-    const loadedImages = [];
-    loadedImages._internalCount = 0;
-    for (let index = 0; index < 6; index++) {
-        this._partialLoadImg(files[index], index, loadedImages, scene, texture, onfinish, onError, mimeType);
-    }
-};
-ThinEngine.prototype._partialLoadImg = function (url, index, loadedImages, scene, texture, onfinish, onErrorCallBack = null, mimeType) {
-    const tokenPendingData = RandomGUID();
-    const onload = (img) => {
-        loadedImages[index] = img;
-        loadedImages._internalCount++;
-        if (scene) {
-            scene.removePendingData(tokenPendingData);
-        }
-        if (loadedImages._internalCount === 6 && onfinish) {
-            onfinish(texture, loadedImages);
-        }
-    };
-    const onerror = (message, exception) => {
-        if (scene) {
-            scene.removePendingData(tokenPendingData);
-        }
-        if (onErrorCallBack) {
-            onErrorCallBack(message, exception);
-        }
-    };
-    LoadImage(url, onload, onerror, scene ? scene.offlineProvider : null, mimeType);
-    if (scene) {
-        scene.addPendingData(tokenPendingData);
-    }
-};
-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 ? 3 : 2;
-    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.createCubeTextureBase = function (rootUrl, scene, files, noMipmap, onLoad = null, onError = null, format, forcedExtension = null, createPolynomials = false, lodScale = 0, lodOffset = 0, fallback = null, beforeLoadCubeDataCallback = null, imageHandler = null, useSRGBBuffer = false) {
-    const texture = fallback ? fallback : new InternalTexture(this, InternalTextureSource.Cube);
-    texture.isCube = true;
-    texture.url = rootUrl;
-    texture.generateMipMaps = !noMipmap;
-    texture._lodGenerationScale = lodScale;
-    texture._lodGenerationOffset = lodOffset;
-    texture._useSRGBBuffer = !!useSRGBBuffer && this._caps.supportSRGBBuffers && (this.webGLVersion > 1 || this.isWebGPU || !!noMipmap);
-    if (texture !== fallback) {
-        texture.label = rootUrl.substring(0, 60); // default label, can be overriden by the caller
-    }
-    if (!this._doNotHandleContextLost) {
-        texture._extension = forcedExtension;
-        texture._files = files;
-    }
-    const originalRootUrl = rootUrl;
-    if (this._transformTextureUrl && !fallback) {
-        rootUrl = this._transformTextureUrl(rootUrl);
-    }
-    const rootUrlWithoutUriParams = rootUrl.split("?")[0];
-    const lastDot = rootUrlWithoutUriParams.lastIndexOf(".");
-    const extension = forcedExtension ? forcedExtension : lastDot > -1 ? rootUrlWithoutUriParams.substring(lastDot).toLowerCase() : "";
-    let loader = null;
-    for (const availableLoader of ThinEngine._TextureLoaders) {
-        if (availableLoader.canLoad(extension)) {
-            loader = availableLoader;
-            break;
-        }
-    }
-    const onInternalError = (request, exception) => {
-        if (rootUrl === originalRootUrl) {
-            if (onError && request) {
-                onError(request.status + " " + request.statusText, exception);
-            }
-        }
-        else {
-            // fall back to the original url if the transformed url fails to load
-            Logger.Warn(`Failed to load ${rootUrl}, falling back to the ${originalRootUrl}`);
-            this.createCubeTextureBase(originalRootUrl, scene, files, !!noMipmap, onLoad, onError, format, forcedExtension, createPolynomials, lodScale, lodOffset, texture, beforeLoadCubeDataCallback, imageHandler, useSRGBBuffer);
-        }
-    };
-    if (loader) {
-        const onloaddata = (data) => {
-            if (beforeLoadCubeDataCallback) {
-                beforeLoadCubeDataCallback(texture, data);
-            }
-            loader.loadCubeData(data, texture, createPolynomials, onLoad, onError);
-        };
-        if (files && files.length === 6) {
-            if (loader.supportCascades) {
-                this._cascadeLoadFiles(scene, (images) => onloaddata(images.map((image) => new Uint8Array(image))), files, onError);
-            }
-            else {
-                if (onError) {
-                    onError("Textures type does not support cascades.");
-                }
-                else {
-                    Logger.Warn("Texture loader does not support cascades.");
-                }
-            }
-        }
-        else {
-            this._loadFile(rootUrl, (data) => onloaddata(new Uint8Array(data)), undefined, undefined, true, onInternalError);
-        }
-    }
-    else {
-        if (!files) {
-            throw new Error("Cannot load cubemap because files were not defined");
-        }
-        this._cascadeLoadImgs(scene, texture, (texture, imgs) => {
-            if (imageHandler) {
-                imageHandler(texture, imgs);
-            }
-        }, files, onError);
-    }
-    this._internalTexturesCache.push(texture);
-    return texture;
-};
-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) {
-    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 ? ThinEngine.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);
-};
-
-/**
- * Class for creating a cube texture
- */
-class CubeTexture extends BaseTexture {
-    /**
-     * Gets or sets the size of the bounding box associated with the cube texture
-     * When defined, the cubemap will switch to local mode
-     * @see https://community.arm.com/graphics/b/blog/posts/reflections-based-on-local-cubemaps-in-unity
-     * @example https://www.babylonjs-playground.com/#RNASML
-     */
-    set boundingBoxSize(value) {
-        if (this._boundingBoxSize && this._boundingBoxSize.equals(value)) {
-            return;
-        }
-        this._boundingBoxSize = value;
-        const scene = this.getScene();
-        if (scene) {
-            scene.markAllMaterialsAsDirty(1);
-        }
-    }
-    /**
-     * Returns the bounding box size
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#using-local-cubemap-mode
-     */
-    get boundingBoxSize() {
-        return this._boundingBoxSize;
-    }
-    /**
-     * Sets texture matrix rotation angle around Y axis in radians.
-     */
-    set rotationY(value) {
-        this._rotationY = value;
-        this.setReflectionTextureMatrix(Matrix.RotationY(this._rotationY));
-    }
-    /**
-     * Gets texture matrix rotation angle around Y axis radians.
-     */
-    get rotationY() {
-        return this._rotationY;
-    }
-    /**
-     * Are mip maps generated for this texture or not.
-     */
-    get noMipmap() {
-        return this._noMipmap;
-    }
-    /**
-     * Gets the forced extension (if any)
-     */
-    get forcedExtension() {
-        return this._forcedExtension;
-    }
-    /**
-     * Creates a cube texture from an array of image urls
-     * @param files defines an array of image urls
-     * @param scene defines the hosting scene
-     * @param noMipmap specifies if mip maps are not used
-     * @returns a cube texture
-     */
-    static CreateFromImages(files, scene, noMipmap) {
-        let rootUrlKey = "";
-        files.forEach((url) => (rootUrlKey += url));
-        return new CubeTexture(rootUrlKey, scene, null, noMipmap, files);
-    }
-    /**
-     * Creates and return a texture created from prefilterd data by tools like IBL Baker or Lys.
-     * @param url defines the url of the prefiltered texture
-     * @param scene defines the scene the texture is attached to
-     * @param forcedExtension defines the extension of the file if different from the url
-     * @param createPolynomials defines whether or not to create polynomial harmonics from the texture data if necessary
-     * @returns the prefiltered texture
-     */
-    static CreateFromPrefilteredData(url, scene, forcedExtension = null, createPolynomials = true) {
-        const oldValue = scene.useDelayedTextureLoading;
-        scene.useDelayedTextureLoading = false;
-        const result = new CubeTexture(url, scene, null, false, null, null, null, undefined, true, forcedExtension, createPolynomials);
-        scene.useDelayedTextureLoading = oldValue;
-        return result;
-    }
-    /**
-     * Creates a cube texture to use with reflection for instance. It can be based upon dds or six images as well
-     * as prefiltered data.
-     * @param rootUrl defines the url of the texture or the root name of the six images
-     * @param sceneOrEngine defines the scene or engine the texture is attached to
-     * @param extensions defines the suffixes add to the picture name in case six images are in use like _px.jpg...
-     * @param noMipmap defines if mipmaps should be created or not
-     * @param files defines the six files to load for the different faces in that order: px, py, pz, nx, ny, nz
-     * @param onLoad defines a callback triggered at the end of the file load if no errors occurred
-     * @param onError defines a callback triggered in case of error during load
-     * @param format defines the internal format to use for the texture once loaded
-     * @param prefiltered defines whether or not the texture is created from prefiltered data
-     * @param forcedExtension defines the extensions to use (force a special type of file to load) in case it is different from the file name
-     * @param createPolynomials defines whether or not to create polynomial harmonics from the texture data if necessary
-     * @param lodScale defines the scale applied to environment texture. This manages the range of LOD level used for IBL according to the roughness
-     * @param lodOffset defines the offset applied to environment texture. This manages first LOD level used for IBL according to the roughness
-     * @param loaderOptions options to be passed to the loader
-     * @param useSRGBBuffer Defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU) (default: false)
-     * @returns the cube texture
-     */
-    constructor(rootUrl, sceneOrEngine, extensions = null, noMipmap = false, files = null, onLoad = null, onError = null, format = 5, prefiltered = false, forcedExtension = null, createPolynomials = false, lodScale = 0.8, lodOffset = 0, loaderOptions, useSRGBBuffer) {
-        var _a;
-        super(sceneOrEngine);
-        this._lodScale = 0.8;
-        this._lodOffset = 0;
-        /**
-         * Observable triggered once the texture has been loaded.
-         */
-        this.onLoadObservable = new Observable();
-        /**
-         * Gets or sets the center of the bounding box associated with the cube texture.
-         * It must define where the camera used to render the texture was set
-         * @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#using-local-cubemap-mode
-         */
-        this.boundingBoxPosition = Vector3.Zero();
-        this._rotationY = 0;
-        /** @internal */
-        this._files = null;
-        this._forcedExtension = null;
-        this._extensions = null;
-        this._textureMatrixRefraction = new Matrix();
-        this.name = rootUrl;
-        this.url = rootUrl;
-        this._noMipmap = noMipmap;
-        this.hasAlpha = false;
-        this._format = format;
-        this.isCube = true;
-        this._textureMatrix = Matrix.Identity();
-        this._createPolynomials = createPolynomials;
-        this.coordinatesMode = Texture.CUBIC_MODE;
-        this._extensions = extensions;
-        this._files = files;
-        this._forcedExtension = forcedExtension;
-        this._loaderOptions = loaderOptions;
-        this._useSRGBBuffer = useSRGBBuffer;
-        this._lodScale = lodScale;
-        this._lodOffset = lodOffset;
-        if (!rootUrl && !files) {
-            return;
-        }
-        this.updateURL(rootUrl, forcedExtension, onLoad, prefiltered, onError, extensions, (_a = this.getScene()) === null || _a === void 0 ? void 0 : _a.useDelayedTextureLoading, files);
-    }
-    /**
-     * Get the current class name of the texture useful for serialization or dynamic coding.
-     * @returns "CubeTexture"
-     */
-    getClassName() {
-        return "CubeTexture";
-    }
-    /**
-     * Update the url (and optional buffer) of this texture if url was null during construction.
-     * @param url the url of the texture
-     * @param forcedExtension defines the extension to use
-     * @param onLoad callback called when the texture is loaded  (defaults to null)
-     * @param prefiltered Defines whether the updated texture is prefiltered or not
-     * @param onError callback called if there was an error during the loading process (defaults to null)
-     * @param extensions defines the suffixes add to the picture name in case six images are in use like _px.jpg...
-     * @param delayLoad defines if the texture should be loaded now (false by default)
-     * @param files defines the six files to load for the different faces in that order: px, py, pz, nx, ny, nz
-     */
-    updateURL(url, forcedExtension, onLoad = null, prefiltered = false, onError = null, extensions = null, delayLoad = false, files = null) {
-        if (!this.name || this.name.startsWith("data:")) {
-            this.name = url;
-        }
-        this.url = url;
-        if (forcedExtension) {
-            this._forcedExtension = forcedExtension;
-        }
-        const lastDot = url.lastIndexOf(".");
-        const extension = forcedExtension ? forcedExtension : lastDot > -1 ? url.substring(lastDot).toLowerCase() : "";
-        const isDDS = extension.indexOf(".dds") === 0;
-        const isEnv = extension.indexOf(".env") === 0;
-        const isBasis = extension.indexOf(".basis") === 0;
-        if (isEnv) {
-            this.gammaSpace = false;
-            this._prefiltered = false;
-            this.anisotropicFilteringLevel = 1;
-        }
-        else {
-            this._prefiltered = prefiltered;
-            if (prefiltered) {
-                this.gammaSpace = false;
-                this.anisotropicFilteringLevel = 1;
-            }
-        }
-        if (files) {
-            this._files = files;
-        }
-        else {
-            if (!isBasis && !isEnv && !isDDS && !extensions) {
-                extensions = ["_px.jpg", "_py.jpg", "_pz.jpg", "_nx.jpg", "_ny.jpg", "_nz.jpg"];
-            }
-            this._files = this._files || [];
-            this._files.length = 0;
-            if (extensions) {
-                for (let index = 0; index < extensions.length; index++) {
-                    this._files.push(url + extensions[index]);
-                }
-                this._extensions = extensions;
-            }
-        }
-        if (delayLoad) {
-            this.delayLoadState = 4;
-            this._delayedOnLoad = onLoad;
-            this._delayedOnError = onError;
-        }
-        else {
-            this._loadTexture(onLoad, onError);
-        }
-    }
-    /**
-     * Delays loading of the cube texture
-     * @param forcedExtension defines the extension to use
-     */
-    delayLoad(forcedExtension) {
-        if (this.delayLoadState !== 4) {
-            return;
-        }
-        if (forcedExtension) {
-            this._forcedExtension = forcedExtension;
-        }
-        this.delayLoadState = 1;
-        this._loadTexture(this._delayedOnLoad, this._delayedOnError);
-    }
-    /**
-     * Returns the reflection texture matrix
-     * @returns the reflection texture matrix
-     */
-    getReflectionTextureMatrix() {
-        return this._textureMatrix;
-    }
-    /**
-     * Sets the reflection texture matrix
-     * @param value Reflection texture matrix
-     */
-    setReflectionTextureMatrix(value) {
-        var _a, _b;
-        if (value.updateFlag === this._textureMatrix.updateFlag) {
-            return;
-        }
-        if (value.isIdentity() !== this._textureMatrix.isIdentity()) {
-            (_a = this.getScene()) === null || _a === void 0 ? void 0 : _a.markAllMaterialsAsDirty(1, (mat) => mat.getActiveTextures().indexOf(this) !== -1);
-        }
-        this._textureMatrix = value;
-        if (!((_b = this.getScene()) === null || _b === void 0 ? void 0 : _b.useRightHandedSystem)) {
-            return;
-        }
-        const scale = TmpVectors.Vector3[0];
-        const quat = TmpVectors.Quaternion[0];
-        const trans = TmpVectors.Vector3[1];
-        this._textureMatrix.decompose(scale, quat, trans);
-        quat.z *= -1; // these two operations correspond to negating the x and y euler angles
-        quat.w *= -1;
-        Matrix.ComposeToRef(scale, quat, trans, this._textureMatrixRefraction);
-    }
-    /**
-     * Gets a suitable rotate/transform matrix when the texture is used for refraction.
-     * There's a separate function from getReflectionTextureMatrix because refraction requires a special configuration of the matrix in right-handed mode.
-     * @returns The refraction matrix
-     */
-    getRefractionTextureMatrix() {
-        var _a;
-        return ((_a = this.getScene()) === null || _a === void 0 ? void 0 : _a.useRightHandedSystem) ? this._textureMatrixRefraction : this._textureMatrix;
-    }
-    _loadTexture(onLoad = null, onError = null) {
-        var _a;
-        const scene = this.getScene();
-        const oldTexture = this._texture;
-        this._texture = this._getFromCache(this.url, this._noMipmap, undefined, undefined, this._useSRGBBuffer, this.isCube);
-        const onLoadProcessing = () => {
-            var _a;
-            this.onLoadObservable.notifyObservers(this);
-            if (oldTexture) {
-                oldTexture.dispose();
-                (_a = this.getScene()) === null || _a === void 0 ? void 0 : _a.markAllMaterialsAsDirty(1);
-            }
-            if (onLoad) {
-                onLoad();
-            }
-        };
-        const errorHandler = (message, exception) => {
-            this._loadingError = true;
-            this._errorObject = { message, exception };
-            if (onError) {
-                onError(message, exception);
-            }
-            Texture.OnTextureLoadErrorObservable.notifyObservers(this);
-        };
-        if (!this._texture) {
-            if (this._prefiltered) {
-                this._texture = this._getEngine().createPrefilteredCubeTexture(this.url, scene, this._lodScale, this._lodOffset, onLoad, errorHandler, this._format, this._forcedExtension, this._createPolynomials);
-            }
-            else {
-                this._texture = this._getEngine().createCubeTexture(this.url, scene, this._files, this._noMipmap, onLoad, errorHandler, this._format, this._forcedExtension, false, this._lodScale, this._lodOffset, null, this._loaderOptions, !!this._useSRGBBuffer);
-            }
-            (_a = this._texture) === null || _a === void 0 ? void 0 : _a.onLoadedObservable.add(() => this.onLoadObservable.notifyObservers(this));
-        }
-        else {
-            if (this._texture.isReady) {
-                Tools.SetImmediate(() => onLoadProcessing());
-            }
-            else {
-                this._texture.onLoadedObservable.add(() => onLoadProcessing());
-            }
-        }
-    }
-    /**
-     * Parses text to create a cube texture
-     * @param parsedTexture define the serialized text to read from
-     * @param scene defines the hosting scene
-     * @param rootUrl defines the root url of the cube texture
-     * @returns a cube texture
-     */
-    static Parse(parsedTexture, scene, rootUrl) {
-        const texture = SerializationHelper.Parse(() => {
-            var _a;
-            let prefiltered = false;
-            if (parsedTexture.prefiltered) {
-                prefiltered = parsedTexture.prefiltered;
-            }
-            return new CubeTexture(rootUrl + ((_a = parsedTexture.url) !== null && _a !== void 0 ? _a : parsedTexture.name), scene, parsedTexture.extensions, false, parsedTexture.files || null, null, null, undefined, prefiltered, parsedTexture.forcedExtension);
-        }, parsedTexture, scene);
-        // Local Cubemaps
-        if (parsedTexture.boundingBoxPosition) {
-            texture.boundingBoxPosition = Vector3.FromArray(parsedTexture.boundingBoxPosition);
-        }
-        if (parsedTexture.boundingBoxSize) {
-            texture.boundingBoxSize = Vector3.FromArray(parsedTexture.boundingBoxSize);
-        }
-        // Animations
-        if (parsedTexture.animations) {
-            for (let animationIndex = 0; animationIndex < parsedTexture.animations.length; animationIndex++) {
-                const parsedAnimation = parsedTexture.animations[animationIndex];
-                const internalClass = GetClass("BABYLON.Animation");
-                if (internalClass) {
-                    texture.animations.push(internalClass.Parse(parsedAnimation));
-                }
-            }
-        }
-        return texture;
-    }
-    /**
-     * Makes a clone, or deep copy, of the cube texture
-     * @returns a new cube texture
-     */
-    clone() {
-        let uniqueId = 0;
-        const newCubeTexture = SerializationHelper.Clone(() => {
-            const cubeTexture = new CubeTexture(this.url, this.getScene() || this._getEngine(), this._extensions, this._noMipmap, this._files);
-            uniqueId = cubeTexture.uniqueId;
-            return cubeTexture;
-        }, this);
-        newCubeTexture.uniqueId = uniqueId;
-        return newCubeTexture;
-    }
-}
-__decorate([
-    serialize()
-], CubeTexture.prototype, "url", void 0);
-__decorate([
-    serializeAsVector3()
-], CubeTexture.prototype, "boundingBoxPosition", void 0);
-__decorate([
-    serializeAsVector3()
-], CubeTexture.prototype, "boundingBoxSize", null);
-__decorate([
-    serialize("rotationY")
-], CubeTexture.prototype, "rotationY", null);
-__decorate([
-    serialize("files")
-], CubeTexture.prototype, "_files", void 0);
-__decorate([
-    serialize("forcedExtension")
-], CubeTexture.prototype, "_forcedExtension", void 0);
-__decorate([
-    serialize("extensions")
-], CubeTexture.prototype, "_extensions", void 0);
-__decorate([
-    serializeAsMatrix("textureMatrix")
-], CubeTexture.prototype, "_textureMatrix", void 0);
-__decorate([
-    serializeAsMatrix("textureMatrixRefraction")
-], CubeTexture.prototype, "_textureMatrixRefraction", void 0);
-Texture._CubeTextureParser = CubeTexture.Parse;
-// Some exporters relies on Tools.Instantiate
-RegisterClass("BABYLON.CubeTexture", CubeTexture);
-
-ThinEngine.prototype.updateRawTexture = function (texture, data, format, invertY, compression = null, type = 0, 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 = 0, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-creationFlags = 0, useSRGBBuffer = false) {
-    const texture = new InternalTexture(this, 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, 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 = 1;
-        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 = 1;
-        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 || (Tools.IsExponentOfTwo(texture.width) && Tools.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 || (Tools.IsExponentOfTwo(texture.width) && Tools.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 = 3, invertY = false) {
-    const gl = this._gl;
-    const texture = this.createRawCubeTexture(null, size, format, type, !noMipmap, invertY, samplingMode, null);
-    scene === null || scene === void 0 ? void 0 : scene.addPendingData(texture);
-    texture.url = url;
-    texture.isReady = false;
-    this._internalTexturesCache.push(texture);
-    const onerror = (request, exception) => {
-        scene === null || scene === void 0 ? void 0 : 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 === null || scene === void 0 ? void 0 : scene.removePendingData(texture);
-        texture.onLoadedObservable.notifyObservers(texture);
-        texture.onLoadedObservable.clear();
-        if (onLoad) {
-            onLoad();
-        }
-    };
-    this._loadFile(url, (data) => {
-        internalCallback(data);
-    }, undefined, scene === null || scene === void 0 ? void 0 : 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 === 1) {
-        rgbaData = new Float32Array(width * height * 4);
-    }
-    else if (textureType === 2) {
-        rgbaData = new Uint16Array(width * height * 4);
-        val1 = 15360; // 15360 is the encoding of 1 in half float
-    }
-    else if (textureType === 7) {
-        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 = 0) {
-        const target = is3D ? this._gl.TEXTURE_3D : this._gl.TEXTURE_2D_ARRAY;
-        const source = is3D ? InternalTextureSource.Raw3D : 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 = 0) {
-        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);
-
-/**
- * Helper class useful to convert panorama picture to their cubemap representation in 6 faces.
- */
-class PanoramaToCubeMapTools {
-    /**
-     * Converts a panorama stored in RGB right to left up to down format into a cubemap (6 faces).
-     *
-     * @param float32Array The source data.
-     * @param inputWidth The width of the input panorama.
-     * @param inputHeight The height of the input panorama.
-     * @param size The willing size of the generated cubemap (each faces will be size * size pixels)
-     * @returns The cubemap data
-     */
-    static ConvertPanoramaToCubemap(float32Array, inputWidth, inputHeight, size, supersample = false) {
-        if (!float32Array) {
-            throw "ConvertPanoramaToCubemap: input cannot be null";
-        }
-        if (float32Array.length != inputWidth * inputHeight * 3) {
-            throw "ConvertPanoramaToCubemap: input size is wrong";
-        }
-        const textureFront = this.CreateCubemapTexture(size, this.FACE_FRONT, float32Array, inputWidth, inputHeight, supersample);
-        const textureBack = this.CreateCubemapTexture(size, this.FACE_BACK, float32Array, inputWidth, inputHeight, supersample);
-        const textureLeft = this.CreateCubemapTexture(size, this.FACE_LEFT, float32Array, inputWidth, inputHeight, supersample);
-        const textureRight = this.CreateCubemapTexture(size, this.FACE_RIGHT, float32Array, inputWidth, inputHeight, supersample);
-        const textureUp = this.CreateCubemapTexture(size, this.FACE_UP, float32Array, inputWidth, inputHeight, supersample);
-        const textureDown = this.CreateCubemapTexture(size, this.FACE_DOWN, float32Array, inputWidth, inputHeight, supersample);
-        return {
-            front: textureFront,
-            back: textureBack,
-            left: textureLeft,
-            right: textureRight,
-            up: textureUp,
-            down: textureDown,
-            size: size,
-            type: 1,
-            format: 4,
-            gammaSpace: false,
-        };
-    }
-    static CreateCubemapTexture(texSize, faceData, float32Array, inputWidth, inputHeight, supersample = false) {
-        const buffer = new ArrayBuffer(texSize * texSize * 4 * 3);
-        const textureArray = new Float32Array(buffer);
-        // If supersampling, determine number of samples needed when source texture width is divided for 4 cube faces
-        const samples = supersample ? Math.max(1, Math.round(inputWidth / 4 / texSize)) : 1;
-        const sampleFactor = 1 / samples;
-        const sampleFactorSqr = sampleFactor * sampleFactor;
-        const rotDX1 = faceData[1].subtract(faceData[0]).scale(sampleFactor / texSize);
-        const rotDX2 = faceData[3].subtract(faceData[2]).scale(sampleFactor / texSize);
-        const dy = 1 / texSize;
-        let fy = 0;
-        for (let y = 0; y < texSize; y++) {
-            for (let sy = 0; sy < samples; sy++) {
-                let xv1 = faceData[0];
-                let xv2 = faceData[2];
-                for (let x = 0; x < texSize; x++) {
-                    for (let sx = 0; sx < samples; sx++) {
-                        const v = xv2.subtract(xv1).scale(fy).add(xv1);
-                        v.normalize();
-                        const color = this.CalcProjectionSpherical(v, float32Array, inputWidth, inputHeight);
-                        // 3 channels per pixels
-                        textureArray[y * texSize * 3 + x * 3 + 0] += color.r * sampleFactorSqr;
-                        textureArray[y * texSize * 3 + x * 3 + 1] += color.g * sampleFactorSqr;
-                        textureArray[y * texSize * 3 + x * 3 + 2] += color.b * sampleFactorSqr;
-                        xv1 = xv1.add(rotDX1);
-                        xv2 = xv2.add(rotDX2);
-                    }
-                }
-                fy += dy * sampleFactor;
-            }
-        }
-        return textureArray;
-    }
-    static CalcProjectionSpherical(vDir, float32Array, inputWidth, inputHeight) {
-        let theta = Math.atan2(vDir.z, vDir.x);
-        const phi = Math.acos(vDir.y);
-        while (theta < -Math.PI) {
-            theta += 2 * Math.PI;
-        }
-        while (theta > Math.PI) {
-            theta -= 2 * Math.PI;
-        }
-        let dx = theta / Math.PI;
-        const dy = phi / Math.PI;
-        // recenter.
-        dx = dx * 0.5 + 0.5;
-        let px = Math.round(dx * inputWidth);
-        if (px < 0) {
-            px = 0;
-        }
-        else if (px >= inputWidth) {
-            px = inputWidth - 1;
-        }
-        let py = Math.round(dy * inputHeight);
-        if (py < 0) {
-            py = 0;
-        }
-        else if (py >= inputHeight) {
-            py = inputHeight - 1;
-        }
-        const inputY = inputHeight - py - 1;
-        const r = float32Array[inputY * inputWidth * 3 + px * 3 + 0];
-        const g = float32Array[inputY * inputWidth * 3 + px * 3 + 1];
-        const b = float32Array[inputY * inputWidth * 3 + px * 3 + 2];
-        return {
-            r: r,
-            g: g,
-            b: b,
-        };
-    }
-}
-PanoramaToCubeMapTools.FACE_LEFT = [new Vector3(-1.0, -1.0, -1.0), new Vector3(1.0, -1.0, -1.0), new Vector3(-1.0, 1.0, -1.0), new Vector3(1.0, 1.0, -1.0)];
-PanoramaToCubeMapTools.FACE_RIGHT = [new Vector3(1.0, -1.0, 1.0), new Vector3(-1.0, -1.0, 1.0), new Vector3(1.0, 1.0, 1.0), new Vector3(-1.0, 1.0, 1.0)];
-PanoramaToCubeMapTools.FACE_FRONT = [new Vector3(1.0, -1.0, -1.0), new Vector3(1.0, -1.0, 1.0), new Vector3(1.0, 1.0, -1.0), new Vector3(1.0, 1.0, 1.0)];
-PanoramaToCubeMapTools.FACE_BACK = [new Vector3(-1.0, -1.0, 1.0), new Vector3(-1.0, -1.0, -1.0), new Vector3(-1.0, 1.0, 1.0), new Vector3(-1.0, 1.0, -1.0)];
-PanoramaToCubeMapTools.FACE_DOWN = [new Vector3(1.0, 1.0, -1.0), new Vector3(1.0, 1.0, 1.0), new Vector3(-1.0, 1.0, -1.0), new Vector3(-1.0, 1.0, 1.0)];
-PanoramaToCubeMapTools.FACE_UP = [new Vector3(-1.0, -1.0, -1.0), new Vector3(-1.0, -1.0, 1.0), new Vector3(1.0, -1.0, -1.0), new Vector3(1.0, -1.0, 1.0)];
-
-/**
- * This groups tools to convert HDR texture to native colors array.
- */
-class HDRTools {
-    static _Ldexp(mantissa, exponent) {
-        if (exponent > 1023) {
-            return mantissa * Math.pow(2, 1023) * Math.pow(2, exponent - 1023);
-        }
-        if (exponent < -1074) {
-            return mantissa * Math.pow(2, -1074) * Math.pow(2, exponent + 1074);
-        }
-        return mantissa * Math.pow(2, exponent);
-    }
-    static _Rgbe2float(float32array, red, green, blue, exponent, index) {
-        if (exponent > 0) {
-            /*nonzero pixel*/
-            exponent = this._Ldexp(1.0, exponent - (128 + 8));
-            float32array[index + 0] = red * exponent;
-            float32array[index + 1] = green * exponent;
-            float32array[index + 2] = blue * exponent;
-        }
-        else {
-            float32array[index + 0] = 0;
-            float32array[index + 1] = 0;
-            float32array[index + 2] = 0;
-        }
-    }
-    static _ReadStringLine(uint8array, startIndex) {
-        let line = "";
-        let character = "";
-        for (let i = startIndex; i < uint8array.length - startIndex; i++) {
-            character = String.fromCharCode(uint8array[i]);
-            if (character == "\n") {
-                break;
-            }
-            line += character;
-        }
-        return line;
-    }
-    /**
-     * Reads header information from an RGBE texture stored in a native array.
-     * More information on this format are available here:
-     * https://en.wikipedia.org/wiki/RGBE_image_format
-     *
-     * @param uint8array The binary file stored in  native array.
-     * @returns The header information.
-     */
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    static RGBE_ReadHeader(uint8array) {
-        let height = 0;
-        let width = 0;
-        let line = this._ReadStringLine(uint8array, 0);
-        if (line[0] != "#" || line[1] != "?") {
-            throw "Bad HDR Format.";
-        }
-        let endOfHeader = false;
-        let findFormat = false;
-        let lineIndex = 0;
-        do {
-            lineIndex += line.length + 1;
-            line = this._ReadStringLine(uint8array, lineIndex);
-            if (line == "FORMAT=32-bit_rle_rgbe") {
-                findFormat = true;
-            }
-            else if (line.length == 0) {
-                endOfHeader = true;
-            }
-        } while (!endOfHeader);
-        if (!findFormat) {
-            throw "HDR Bad header format, unsupported FORMAT";
-        }
-        lineIndex += line.length + 1;
-        line = this._ReadStringLine(uint8array, lineIndex);
-        const sizeRegexp = /^-Y (.*) \+X (.*)$/g;
-        const match = sizeRegexp.exec(line);
-        // TODO. Support +Y and -X if needed.
-        if (!match || match.length < 3) {
-            throw "HDR Bad header format, no size";
-        }
-        width = parseInt(match[2]);
-        height = parseInt(match[1]);
-        if (width < 8 || width > 0x7fff) {
-            throw "HDR Bad header format, unsupported size";
-        }
-        lineIndex += line.length + 1;
-        return {
-            height: height,
-            width: width,
-            dataPosition: lineIndex,
-        };
-    }
-    /**
-     * Returns the cubemap information (each faces texture data) extracted from an RGBE texture.
-     * This RGBE texture needs to store the information as a panorama.
-     *
-     * More information on this format are available here:
-     * https://en.wikipedia.org/wiki/RGBE_image_format
-     *
-     * @param buffer The binary file stored in an array buffer.
-     * @param size The expected size of the extracted cubemap.
-     * @returns The Cube Map information.
-     */
-    static GetCubeMapTextureData(buffer, size, supersample = false) {
-        const uint8array = new Uint8Array(buffer);
-        const hdrInfo = this.RGBE_ReadHeader(uint8array);
-        const data = this.RGBE_ReadPixels(uint8array, hdrInfo);
-        const cubeMapData = PanoramaToCubeMapTools.ConvertPanoramaToCubemap(data, hdrInfo.width, hdrInfo.height, size, supersample);
-        return cubeMapData;
-    }
-    /**
-     * Returns the pixels data extracted from an RGBE texture.
-     * This pixels will be stored left to right up to down in the R G B order in one array.
-     *
-     * More information on this format are available here:
-     * https://en.wikipedia.org/wiki/RGBE_image_format
-     *
-     * @param uint8array The binary file stored in an array buffer.
-     * @param hdrInfo The header information of the file.
-     * @returns The pixels data in RGB right to left up to down order.
-     */
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    static RGBE_ReadPixels(uint8array, hdrInfo) {
-        return this._RGBEReadPixelsRLE(uint8array, hdrInfo);
-    }
-    static _RGBEReadPixelsRLE(uint8array, hdrInfo) {
-        let num_scanlines = hdrInfo.height;
-        const scanline_width = hdrInfo.width;
-        let a, b, c, d, count;
-        let dataIndex = hdrInfo.dataPosition;
-        let index = 0, endIndex = 0, i = 0;
-        const scanLineArrayBuffer = new ArrayBuffer(scanline_width * 4); // four channel R G B E
-        const scanLineArray = new Uint8Array(scanLineArrayBuffer);
-        // 3 channels of 4 bytes per pixel in float.
-        const resultBuffer = new ArrayBuffer(hdrInfo.width * hdrInfo.height * 4 * 3);
-        const resultArray = new Float32Array(resultBuffer);
-        // read in each successive scanline
-        while (num_scanlines > 0) {
-            a = uint8array[dataIndex++];
-            b = uint8array[dataIndex++];
-            c = uint8array[dataIndex++];
-            d = uint8array[dataIndex++];
-            if (a != 2 || b != 2 || c & 0x80 || hdrInfo.width < 8 || hdrInfo.width > 32767) {
-                return this._RGBEReadPixelsNOTRLE(uint8array, hdrInfo);
-            }
-            if (((c << 8) | d) != scanline_width) {
-                throw "HDR Bad header format, wrong scan line width";
-            }
-            index = 0;
-            // read each of the four channels for the scanline into the buffer
-            for (i = 0; i < 4; i++) {
-                endIndex = (i + 1) * scanline_width;
-                while (index < endIndex) {
-                    a = uint8array[dataIndex++];
-                    b = uint8array[dataIndex++];
-                    if (a > 128) {
-                        // a run of the same value
-                        count = a - 128;
-                        if (count == 0 || count > endIndex - index) {
-                            throw "HDR Bad Format, bad scanline data (run)";
-                        }
-                        while (count-- > 0) {
-                            scanLineArray[index++] = b;
-                        }
-                    }
-                    else {
-                        // a non-run
-                        count = a;
-                        if (count == 0 || count > endIndex - index) {
-                            throw "HDR Bad Format, bad scanline data (non-run)";
-                        }
-                        scanLineArray[index++] = b;
-                        if (--count > 0) {
-                            for (let j = 0; j < count; j++) {
-                                scanLineArray[index++] = uint8array[dataIndex++];
-                            }
-                        }
-                    }
-                }
-            }
-            // now convert data from buffer into floats
-            for (i = 0; i < scanline_width; i++) {
-                a = scanLineArray[i];
-                b = scanLineArray[i + scanline_width];
-                c = scanLineArray[i + 2 * scanline_width];
-                d = scanLineArray[i + 3 * scanline_width];
-                this._Rgbe2float(resultArray, a, b, c, d, (hdrInfo.height - num_scanlines) * scanline_width * 3 + i * 3);
-            }
-            num_scanlines--;
-        }
-        return resultArray;
-    }
-    static _RGBEReadPixelsNOTRLE(uint8array, hdrInfo) {
-        // this file is not run length encoded
-        // read values sequentially
-        let num_scanlines = hdrInfo.height;
-        const scanline_width = hdrInfo.width;
-        let a, b, c, d, i;
-        let dataIndex = hdrInfo.dataPosition;
-        // 3 channels of 4 bytes per pixel in float.
-        const resultBuffer = new ArrayBuffer(hdrInfo.width * hdrInfo.height * 4 * 3);
-        const resultArray = new Float32Array(resultBuffer);
-        // read in each successive scanline
-        while (num_scanlines > 0) {
-            for (i = 0; i < hdrInfo.width; i++) {
-                a = uint8array[dataIndex++];
-                b = uint8array[dataIndex++];
-                c = uint8array[dataIndex++];
-                d = uint8array[dataIndex++];
-                this._Rgbe2float(resultArray, a, b, c, d, (hdrInfo.height - num_scanlines) * scanline_width * 3 + i * 3);
-            }
-            num_scanlines--;
-        }
-        return resultArray;
-    }
-}
-
-// Do not edit.
-const name$1 = "hdrFilteringVertexShader";
-const shader$1 = `attribute vec2 position;
-void main(void) {
-mat3 view=mat3(up,right,front);
-}`;
-// Sideeffect
-ShaderStore.ShadersStore[name$1] = shader$1;
-
-// Do not edit.
-const name = "hdrFilteringPixelShader";
-const shader = `#include<helperFunctions>
-#include<importanceSampling>
-#include<pbrBRDFFunctions>
-#include<hdrFilteringFunctions>
-uniform float alphaG;
-// Sideeffect
-ShaderStore.ShadersStore[name] = shader;
-
-/**
- * Filters HDR maps to get correct renderings of PBR reflections
- */
-class HDRFiltering {
-    /**
-     * Instantiates HDR filter for reflection maps
-     *
-     * @param engine Thin engine
-     * @param options Options
-     */
-    constructor(engine, options = {}) {
-        this._lodGenerationOffset = 0;
-        this._lodGenerationScale = 0.8;
-        /**
-         * Quality switch for prefiltering. Should be set to `4096` unless
-         * you care about baking speed.
-         */
-        this.quality = 4096;
-        /**
-         * Scales pixel intensity for the input HDR map.
-         */
-        this.hdrScale = 1;
-        // pass
-        this._engine = engine;
-        this.hdrScale = options.hdrScale || this.hdrScale;
-        this.quality = options.quality || this.quality;
-    }
-    _createRenderTarget(size) {
-        let textureType = 0;
-        if (this._engine.getCaps().textureHalfFloatRender) {
-            textureType = 2;
-        }
-        else if (this._engine.getCaps().textureFloatRender) {
-            textureType = 1;
-        }
-        const rtWrapper = this._engine.createRenderTargetCubeTexture(size, {
-            format: 5,
-            type: textureType,
-            createMipMaps: true,
-            generateMipMaps: false,
-            generateDepthBuffer: false,
-            generateStencilBuffer: false,
-            samplingMode: 1,
-        });
-        this._engine.updateTextureWrappingMode(rtWrapper.texture, 0, 0, 0);
-        this._engine.updateTextureSamplingMode(3, rtWrapper.texture, true);
-        return rtWrapper;
-    }
-    _prefilterInternal(texture) {
-        const width = texture.getSize().width;
-        const mipmapsCount = Scalar.ILog2(width) + 1;
-        const effect = this._effectWrapper.effect;
-        const outputTexture = this._createRenderTarget(width);
-        this._effectRenderer.setViewport();
-        const intTexture = texture.getInternalTexture();
-        if (intTexture) {
-            // Just in case generate fresh clean mips.
-            this._engine.updateTextureSamplingMode(3, intTexture, true);
-        }
-        this._effectRenderer.applyEffectWrapper(this._effectWrapper);
-        const directions = [
-            [new Vector3(0, 0, -1), new Vector3(0, -1, 0), new Vector3(1, 0, 0)],
-            [new Vector3(0, 0, 1), new Vector3(0, -1, 0), new Vector3(-1, 0, 0)],
-            [new Vector3(1, 0, 0), new Vector3(0, 0, 1), new Vector3(0, 1, 0)],
-            [new Vector3(1, 0, 0), new Vector3(0, 0, -1), new Vector3(0, -1, 0)],
-            [new Vector3(1, 0, 0), new Vector3(0, -1, 0), new Vector3(0, 0, 1)],
-            [new Vector3(-1, 0, 0), new Vector3(0, -1, 0), new Vector3(0, 0, -1)], // NegativeZ
-        ];
-        effect.setFloat("hdrScale", this.hdrScale);
-        effect.setFloat2("vFilteringInfo", texture.getSize().width, mipmapsCount);
-        effect.setTexture("inputTexture", texture);
-        for (let face = 0; face < 6; face++) {
-            effect.setVector3("up", directions[face][0]);
-            effect.setVector3("right", directions[face][1]);
-            effect.setVector3("front", directions[face][2]);
-            for (let lod = 0; lod < mipmapsCount; lod++) {
-                this._engine.bindFramebuffer(outputTexture, face, undefined, undefined, true, lod);
-                this._effectRenderer.applyEffectWrapper(this._effectWrapper);
-                let alpha = Math.pow(2, (lod - this._lodGenerationOffset) / this._lodGenerationScale) / width;
-                if (lod === 0) {
-                    alpha = 0;
-                }
-                effect.setFloat("alphaG", alpha);
-                this._effectRenderer.draw();
-            }
-        }
-        // Cleanup
-        this._effectRenderer.restoreStates();
-        this._engine.restoreDefaultFramebuffer();
-        this._engine._releaseTexture(texture._texture);
-        // Internal Swap
-        const type = outputTexture.texture.type;
-        const format = outputTexture.texture.format;
-        outputTexture._swapAndDie(texture._texture);
-        texture._texture.type = type;
-        texture._texture.format = format;
-        // New settings
-        texture.gammaSpace = false;
-        texture.lodGenerationOffset = this._lodGenerationOffset;
-        texture.lodGenerationScale = this._lodGenerationScale;
-        texture._prefiltered = true;
-        return texture;
-    }
-    _createEffect(texture, onCompiled) {
-        const defines = [];
-        if (texture.gammaSpace) {
-            defines.push("#define GAMMA_INPUT");
-        }
-        defines.push("#define NUM_SAMPLES " + this.quality + "u"); // unsigned int
-        const effectWrapper = new EffectWrapper({
-            engine: this._engine,
-            name: "hdrFiltering",
-            vertexShader: "hdrFiltering",
-            fragmentShader: "hdrFiltering",
-            samplerNames: ["inputTexture"],
-            uniformNames: ["vSampleDirections", "vWeights", "up", "right", "front", "vFilteringInfo", "hdrScale", "alphaG"],
-            useShaderStore: true,
-            defines,
-            onCompiled: onCompiled,
-        });
-        return effectWrapper;
-    }
-    /**
-     * Get a value indicating if the filter is ready to be used
-     * @param texture Texture to filter
-     * @returns true if the filter is ready
-     */
-    isReady(texture) {
-        return texture.isReady() && this._effectWrapper.effect.isReady();
-    }
-    /**
-     * Prefilters a cube texture to have mipmap levels representing roughness values.
-     * Prefiltering will be invoked at the end of next rendering pass.
-     * This has to be done once the map is loaded, and has not been prefiltered by a third party software.
-     * See http://blog.selfshadow.com/publications/s2013-shading-course/karis/s2013_pbs_epic_notes_v2.pdf for more information
-     * @param texture Texture to filter
-     * @param onFinished Callback when filtering is done
-     * @returns Promise called when prefiltering is done
-     */
-    prefilter(texture, onFinished = null) {
-        if (!this._engine._features.allowTexturePrefiltering) {
-            Logger.Warn("HDR prefiltering is not available in WebGL 1., you can use real time filtering instead.");
-            return Promise.reject("HDR prefiltering is not available in WebGL 1., you can use real time filtering instead.");
-        }
-        return new Promise((resolve) => {
-            this._effectRenderer = new EffectRenderer(this._engine);
-            this._effectWrapper = this._createEffect(texture);
-            this._effectWrapper.effect.executeWhenCompiled(() => {
-                this._prefilterInternal(texture);
-                this._effectRenderer.dispose();
-                this._effectWrapper.dispose();
-                resolve();
-                if (onFinished) {
-                    onFinished();
-                }
-            });
-        });
-    }
-}
-
-/**
- * This represents a texture coming from an HDR input.
- *
- * The only supported format is currently panorama picture stored in RGBE format.
- * Example of such files can be found on Poly Haven: https://polyhaven.com/hdris
- */
-class HDRCubeTexture extends BaseTexture {
-    /**
-     * Sets whether or not the texture is blocking during loading.
-     */
-    set isBlocking(value) {
-        this._isBlocking = value;
-    }
-    /**
-     * Gets whether or not the texture is blocking during loading.
-     */
-    get isBlocking() {
-        return this._isBlocking;
-    }
-    /**
-     * Sets texture matrix rotation angle around Y axis in radians.
-     */
-    set rotationY(value) {
-        this._rotationY = value;
-        this.setReflectionTextureMatrix(Matrix.RotationY(this._rotationY));
-    }
-    /**
-     * Gets texture matrix rotation angle around Y axis radians.
-     */
-    get rotationY() {
-        return this._rotationY;
-    }
-    /**
-     * Gets or sets the size of the bounding box associated with the cube texture
-     * When defined, the cubemap will switch to local mode
-     * @see https://community.arm.com/graphics/b/blog/posts/reflections-based-on-local-cubemaps-in-unity
-     * @example https://www.babylonjs-playground.com/#RNASML
-     */
-    set boundingBoxSize(value) {
-        if (this._boundingBoxSize && this._boundingBoxSize.equals(value)) {
-            return;
-        }
-        this._boundingBoxSize = value;
-        const scene = this.getScene();
-        if (scene) {
-            scene.markAllMaterialsAsDirty(1);
-        }
-    }
-    get boundingBoxSize() {
-        return this._boundingBoxSize;
-    }
-    /**
-     * Instantiates an HDRTexture from the following parameters.
-     *
-     * @param url The location of the HDR raw data (Panorama stored in RGBE format)
-     * @param sceneOrEngine The scene or engine the texture will be used in
-     * @param size The cubemap desired size (the more it increases the longer the generation will be)
-     * @param noMipmap Forces to not generate the mipmap if true
-     * @param generateHarmonics Specifies whether you want to extract the polynomial harmonics during the generation process
-     * @param gammaSpace Specifies if the texture will be use in gamma or linear space (the PBR material requires those texture in linear space, but the standard material would require them in Gamma space)
-     * @param prefilterOnLoad Prefilters HDR texture to allow use of this texture as a PBR reflection texture.
-     * @param onLoad
-     * @param onError
-     */
-    constructor(url, sceneOrEngine, size, noMipmap = false, generateHarmonics = true, gammaSpace = false, prefilterOnLoad = false, onLoad = null, onError = null, supersample = false) {
-        var _a;
-        super(sceneOrEngine);
-        this._generateHarmonics = true;
-        this._onError = null;
-        this._isBlocking = true;
-        this._rotationY = 0;
-        /**
-         * Gets or sets the center of the bounding box associated with the cube texture
-         * It must define where the camera used to render the texture was set
-         */
-        this.boundingBoxPosition = Vector3.Zero();
-        /**
-         * Observable triggered once the texture has been loaded.
-         */
-        this.onLoadObservable = new Observable();
-        if (!url) {
-            return;
-        }
-        this._coordinatesMode = Texture.CUBIC_MODE;
-        this.name = url;
-        this.url = url;
-        this.hasAlpha = false;
-        this.isCube = true;
-        this._textureMatrix = Matrix.Identity();
-        this._prefilterOnLoad = prefilterOnLoad;
-        this._onLoad = () => {
-            this.onLoadObservable.notifyObservers(this);
-            if (onLoad) {
-                onLoad();
-            }
-        };
-        this._onError = onError;
-        this.gammaSpace = gammaSpace;
-        this._noMipmap = noMipmap;
-        this._size = size;
-        this._supersample = supersample;
-        this._generateHarmonics = generateHarmonics;
-        this._texture = this._getFromCache(url, this._noMipmap, undefined, undefined, undefined, this.isCube);
-        if (!this._texture) {
-            if (!((_a = this.getScene()) === null || _a === void 0 ? void 0 : _a.useDelayedTextureLoading)) {
-                this._loadTexture();
-            }
-            else {
-                this.delayLoadState = 4;
-            }
-        }
-        else {
-            if (this._texture.isReady) {
-                Tools.SetImmediate(() => this._onLoad());
-            }
-            else {
-                this._texture.onLoadedObservable.add(this._onLoad);
-            }
-        }
-    }
-    /**
-     * Get the current class name of the texture useful for serialization or dynamic coding.
-     * @returns "HDRCubeTexture"
-     */
-    getClassName() {
-        return "HDRCubeTexture";
-    }
-    /**
-     * Occurs when the file is raw .hdr file.
-     */
-    _loadTexture() {
-        const engine = this._getEngine();
-        const caps = engine.getCaps();
-        let textureType = 0;
-        if (caps.textureFloat && caps.textureFloatLinearFiltering) {
-            textureType = 1;
-        }
-        else if (caps.textureHalfFloat && caps.textureHalfFloatLinearFiltering) {
-            textureType = 2;
-        }
-        const callback = (buffer) => {
-            this.lodGenerationOffset = 0.0;
-            this.lodGenerationScale = 0.8;
-            // Extract the raw linear data.
-            const data = HDRTools.GetCubeMapTextureData(buffer, this._size, this._supersample);
-            // Generate harmonics if needed.
-            if (this._generateHarmonics) {
-                const sphericalPolynomial = CubeMapToSphericalPolynomialTools.ConvertCubeMapToSphericalPolynomial(data);
-                this.sphericalPolynomial = sphericalPolynomial;
-            }
-            const results = [];
-            let byteArray = null;
-            let shortArray = null;
-            // Push each faces.
-            for (let j = 0; j < 6; j++) {
-                // Create fallback array
-                if (textureType === 2) {
-                    shortArray = new Uint16Array(this._size * this._size * 3);
-                }
-                else if (textureType === 0) {
-                    // 3 channels of 1 bytes per pixel in bytes.
-                    byteArray = new Uint8Array(this._size * this._size * 3);
-                }
-                const dataFace = data[HDRCubeTexture._FacesMapping[j]];
-                // If special cases.
-                if (this.gammaSpace || shortArray || byteArray) {
-                    for (let i = 0; i < this._size * this._size; i++) {
-                        // Put in gamma space if requested.
-                        if (this.gammaSpace) {
-                            dataFace[i * 3 + 0] = Math.pow(dataFace[i * 3 + 0], ToGammaSpace);
-                            dataFace[i * 3 + 1] = Math.pow(dataFace[i * 3 + 1], ToGammaSpace);
-                            dataFace[i * 3 + 2] = Math.pow(dataFace[i * 3 + 2], ToGammaSpace);
-                        }
-                        // Convert to half float texture for fallback.
-                        if (shortArray) {
-                            shortArray[i * 3 + 0] = ToHalfFloat(dataFace[i * 3 + 0]);
-                            shortArray[i * 3 + 1] = ToHalfFloat(dataFace[i * 3 + 1]);
-                            shortArray[i * 3 + 2] = ToHalfFloat(dataFace[i * 3 + 2]);
-                        }
-                        // Convert to int texture for fallback.
-                        if (byteArray) {
-                            let r = Math.max(dataFace[i * 3 + 0] * 255, 0);
-                            let g = Math.max(dataFace[i * 3 + 1] * 255, 0);
-                            let b = Math.max(dataFace[i * 3 + 2] * 255, 0);
-                            // May use luminance instead if the result is not accurate.
-                            const max = Math.max(Math.max(r, g), b);
-                            if (max > 255) {
-                                const scale = 255 / max;
-                                r *= scale;
-                                g *= scale;
-                                b *= scale;
-                            }
-                            byteArray[i * 3 + 0] = r;
-                            byteArray[i * 3 + 1] = g;
-                            byteArray[i * 3 + 2] = b;
-                        }
-                    }
-                }
-                if (shortArray) {
-                    results.push(shortArray);
-                }
-                else if (byteArray) {
-                    results.push(byteArray);
-                }
-                else {
-                    results.push(dataFace);
-                }
-            }
-            return results;
-        };
-        if (engine._features.allowTexturePrefiltering && this._prefilterOnLoad) {
-            const previousOnLoad = this._onLoad;
-            const hdrFiltering = new HDRFiltering(engine);
-            this._onLoad = () => {
-                hdrFiltering.prefilter(this, previousOnLoad);
-            };
-        }
-        this._texture = engine.createRawCubeTextureFromUrl(this.url, this.getScene(), this._size, 4, textureType, this._noMipmap, callback, null, this._onLoad, this._onError);
-    }
-    clone() {
-        const newTexture = new HDRCubeTexture(this.url, this.getScene() || this._getEngine(), this._size, this._noMipmap, this._generateHarmonics, this.gammaSpace);
-        // Base texture
-        newTexture.level = this.level;
-        newTexture.wrapU = this.wrapU;
-        newTexture.wrapV = this.wrapV;
-        newTexture.coordinatesIndex = this.coordinatesIndex;
-        newTexture.coordinatesMode = this.coordinatesMode;
-        return newTexture;
-    }
-    // Methods
-    delayLoad() {
-        if (this.delayLoadState !== 4) {
-            return;
-        }
-        this.delayLoadState = 1;
-        this._texture = this._getFromCache(this.url, this._noMipmap);
-        if (!this._texture) {
-            this._loadTexture();
-        }
-    }
-    /**
-     * Get the texture reflection matrix used to rotate/transform the reflection.
-     * @returns the reflection matrix
-     */
-    getReflectionTextureMatrix() {
-        return this._textureMatrix;
-    }
-    /**
-     * Set the texture reflection matrix used to rotate/transform the reflection.
-     * @param value Define the reflection matrix to set
-     */
-    setReflectionTextureMatrix(value) {
-        var _a;
-        this._textureMatrix = value;
-        if (value.updateFlag === this._textureMatrix.updateFlag) {
-            return;
-        }
-        if (value.isIdentity() !== this._textureMatrix.isIdentity()) {
-            (_a = this.getScene()) === null || _a === void 0 ? void 0 : _a.markAllMaterialsAsDirty(1, (mat) => mat.getActiveTextures().indexOf(this) !== -1);
-        }
-    }
-    /**
-     * Dispose the texture and release its associated resources.
-     */
-    dispose() {
-        this.onLoadObservable.clear();
-        super.dispose();
-    }
-    /**
-     * Parses a JSON representation of an HDR Texture in order to create the texture
-     * @param parsedTexture Define the JSON representation
-     * @param scene Define the scene the texture should be created in
-     * @param rootUrl Define the root url in case we need to load relative dependencies
-     * @returns the newly created texture after parsing
-     */
-    static Parse(parsedTexture, scene, rootUrl) {
-        let texture = null;
-        if (parsedTexture.name && !parsedTexture.isRenderTarget) {
-            texture = new HDRCubeTexture(rootUrl + parsedTexture.name, scene, parsedTexture.size, parsedTexture.noMipmap, parsedTexture.generateHarmonics, parsedTexture.useInGammaSpace);
-            texture.name = parsedTexture.name;
-            texture.hasAlpha = parsedTexture.hasAlpha;
-            texture.level = parsedTexture.level;
-            texture.coordinatesMode = parsedTexture.coordinatesMode;
-            texture.isBlocking = parsedTexture.isBlocking;
-        }
-        if (texture) {
-            if (parsedTexture.boundingBoxPosition) {
-                texture.boundingBoxPosition = Vector3.FromArray(parsedTexture.boundingBoxPosition);
-            }
-            if (parsedTexture.boundingBoxSize) {
-                texture.boundingBoxSize = Vector3.FromArray(parsedTexture.boundingBoxSize);
-            }
-            if (parsedTexture.rotationY) {
-                texture.rotationY = parsedTexture.rotationY;
-            }
-        }
-        return texture;
-    }
-    serialize() {
-        if (!this.name) {
-            return null;
-        }
-        const serializationObject = {};
-        serializationObject.name = this.name;
-        serializationObject.hasAlpha = this.hasAlpha;
-        serializationObject.isCube = true;
-        serializationObject.level = this.level;
-        serializationObject.size = this._size;
-        serializationObject.coordinatesMode = this.coordinatesMode;
-        serializationObject.useInGammaSpace = this.gammaSpace;
-        serializationObject.generateHarmonics = this._generateHarmonics;
-        serializationObject.customType = "BABYLON.HDRCubeTexture";
-        serializationObject.noMipmap = this._noMipmap;
-        serializationObject.isBlocking = this._isBlocking;
-        serializationObject.rotationY = this._rotationY;
-        return serializationObject;
-    }
-}
-HDRCubeTexture._FacesMapping = ["right", "left", "up", "down", "front", "back"];
-RegisterClass("BABYLON.HDRCubeTexture", HDRCubeTexture);
-
-/**
- * This represents a texture coming from an equirectangular image supported by the web browser canvas.
- */
-class EquiRectangularCubeTexture extends BaseTexture {
-    /**
-     * Instantiates an EquiRectangularCubeTexture from the following parameters.
-     * @param url The location of the image
-     * @param scene The scene the texture will be used in
-     * @param size The cubemap desired size (the more it increases the longer the generation will be)
-     * @param noMipmap Forces to not generate the mipmap if true
-     * @param gammaSpace Specifies if the texture will be used in gamma or linear space
-     * (the PBR material requires those textures in linear space, but the standard material would require them in Gamma space)
-     * @param onLoad — defines a callback called when texture is loaded
-     * @param onError — defines a callback called if there is an error
-     */
-    constructor(url, scene, size, noMipmap = false, gammaSpace = true, onLoad = null, onError = null, supersample = false) {
-        super(scene);
-        this._onLoad = null;
-        this._onError = null;
-        if (!url) {
-            throw new Error("Image url is not set");
-        }
-        this._coordinatesMode = Texture.CUBIC_MODE;
-        this.name = url;
-        this.url = url;
-        this._size = size;
-        this._supersample = supersample;
-        this._noMipmap = noMipmap;
-        this.gammaSpace = gammaSpace;
-        this._onLoad = onLoad;
-        this._onError = onError;
-        this.hasAlpha = false;
-        this.isCube = true;
-        this._texture = this._getFromCache(url, this._noMipmap, undefined, undefined, undefined, this.isCube);
-        if (!this._texture) {
-            if (!scene.useDelayedTextureLoading) {
-                this._loadImage(this._loadTexture.bind(this), this._onError);
-            }
-            else {
-                this.delayLoadState = 4;
-            }
-        }
-        else if (onLoad) {
-            if (this._texture.isReady) {
-                Tools.SetImmediate(() => onLoad());
-            }
-            else {
-                this._texture.onLoadedObservable.add(onLoad);
-            }
-        }
-    }
-    /**
-     * Load the image data, by putting the image on a canvas and extracting its buffer.
-     * @param loadTextureCallback
-     * @param onError
-     */
-    _loadImage(loadTextureCallback, onError) {
-        const canvas = document.createElement("canvas");
-        LoadImage(this.url, (image) => {
-            this._width = image.width;
-            this._height = image.height;
-            canvas.width = this._width;
-            canvas.height = this._height;
-            const ctx = canvas.getContext("2d");
-            ctx.drawImage(image, 0, 0);
-            const imageData = ctx.getImageData(0, 0, image.width, image.height);
-            this._buffer = imageData.data.buffer;
-            canvas.remove();
-            loadTextureCallback();
-        }, (_, e) => {
-            if (onError) {
-                onError(`${this.getClassName()} could not be loaded`, e);
-            }
-        }, null);
-    }
-    /**
-     * Convert the image buffer into a cubemap and create a CubeTexture.
-     */
-    _loadTexture() {
-        const scene = this.getScene();
-        const callback = () => {
-            const imageData = this._getFloat32ArrayFromArrayBuffer(this._buffer);
-            // Extract the raw linear data.
-            const data = PanoramaToCubeMapTools.ConvertPanoramaToCubemap(imageData, this._width, this._height, this._size, this._supersample);
-            const results = [];
-            // Push each faces.
-            for (let i = 0; i < 6; i++) {
-                const dataFace = data[EquiRectangularCubeTexture._FacesMapping[i]];
-                results.push(dataFace);
-            }
-            return results;
-        };
-        if (!scene) {
-            return;
-        }
-        this._texture = scene
-            .getEngine()
-            .createRawCubeTextureFromUrl(this.url, scene, this._size, 4, scene.getEngine().getCaps().textureFloat ? 1 : 7, this._noMipmap, callback, null, this._onLoad, this._onError);
-    }
-    /**
-     * Convert the ArrayBuffer into a Float32Array and drop the transparency channel.
-     * @param buffer The ArrayBuffer that should be converted.
-     * @returns The buffer as Float32Array.
-     */
-    _getFloat32ArrayFromArrayBuffer(buffer) {
-        const dataView = new DataView(buffer);
-        const floatImageData = new Float32Array((buffer.byteLength * 3) / 4);
-        let k = 0;
-        for (let i = 0; i < buffer.byteLength; i++) {
-            // We drop the transparency channel, because we do not need/want it
-            if ((i + 1) % 4 !== 0) {
-                floatImageData[k++] = dataView.getUint8(i) / 255;
-            }
-        }
-        return floatImageData;
-    }
-    /**
-     * Get the current class name of the texture useful for serialization or dynamic coding.
-     * @returns "EquiRectangularCubeTexture"
-     */
-    getClassName() {
-        return "EquiRectangularCubeTexture";
-    }
-    /**
-     * Create a clone of the current EquiRectangularCubeTexture and return it.
-     * @returns A clone of the current EquiRectangularCubeTexture.
-     */
-    clone() {
-        const scene = this.getScene();
-        if (!scene) {
-            return this;
-        }
-        const newTexture = new EquiRectangularCubeTexture(this.url, scene, this._size, this._noMipmap, this.gammaSpace);
-        // Base texture
-        newTexture.level = this.level;
-        newTexture.wrapU = this.wrapU;
-        newTexture.wrapV = this.wrapV;
-        newTexture.coordinatesIndex = this.coordinatesIndex;
-        newTexture.coordinatesMode = this.coordinatesMode;
-        return newTexture;
-    }
-}
-/** The six faces of the cube. */
-EquiRectangularCubeTexture._FacesMapping = ["right", "left", "up", "down", "front", "back"];
-
-/**
- * Defines the list of states available for a task inside a AssetsManager
- */
-var AssetTaskState;
-(function (AssetTaskState) {
-    /**
-     * Initialization
-     */
-    AssetTaskState[AssetTaskState["INIT"] = 0] = "INIT";
-    /**
-     * Running
-     */
-    AssetTaskState[AssetTaskState["RUNNING"] = 1] = "RUNNING";
-    /**
-     * Done
-     */
-    AssetTaskState[AssetTaskState["DONE"] = 2] = "DONE";
-    /**
-     * Error
-     */
-    AssetTaskState[AssetTaskState["ERROR"] = 3] = "ERROR";
-})(AssetTaskState || (AssetTaskState = {}));
-/**
- * Define an abstract asset task used with a AssetsManager class to load assets into a scene
- */
-class AbstractAssetTask {
-    /**
-     * Creates a new AssetsManager
-     * @param name defines the name of the task
-     */
-    constructor(
-    /**
-     * Task name
-     */ name) {
-        this.name = name;
-        this._isCompleted = false;
-        this._taskState = AssetTaskState.INIT;
-    }
-    /**
-     * Get if the task is completed
-     */
-    get isCompleted() {
-        return this._isCompleted;
-    }
-    /**
-     * Gets the current state of the task
-     */
-    get taskState() {
-        return this._taskState;
-    }
-    /**
-     * Gets the current error object (if task is in error)
-     */
-    get errorObject() {
-        return this._errorObject;
-    }
-    /**
-     * Internal only
-     * @internal
-     */
-    _setErrorObject(message, exception) {
-        if (this._errorObject) {
-            return;
-        }
-        this._errorObject = {
-            message: message,
-            exception: exception,
-        };
-    }
-    /**
-     * Execute the current task
-     * @param scene defines the scene where you want your assets to be loaded
-     * @param onSuccess is a callback called when the task is successfully executed
-     * @param onError is a callback called if an error occurs
-     */
-    run(scene, onSuccess, onError) {
-        this._taskState = AssetTaskState.RUNNING;
-        this.runTask(scene, () => {
-            this._onDoneCallback(onSuccess, onError);
-        }, (msg, exception) => {
-            this._onErrorCallback(onError, msg, exception);
-        });
-    }
-    /**
-     * Execute the current task
-     * @param scene defines the scene where you want your assets to be loaded
-     * @param onSuccess is a callback called when the task is successfully executed
-     * @param onError is a callback called if an error occurs
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    runTask(scene, onSuccess, onError) {
-        throw new Error("runTask is not implemented");
-    }
-    /**
-     * Reset will set the task state back to INIT, so the next load call of the assets manager will execute this task again.
-     * This can be used with failed tasks that have the reason for failure fixed.
-     */
-    reset() {
-        this._taskState = AssetTaskState.INIT;
-    }
-    _onErrorCallback(onError, message, exception) {
-        this._taskState = AssetTaskState.ERROR;
-        this._errorObject = {
-            message: message,
-            exception: exception,
-        };
-        if (this.onError) {
-            this.onError(this, message, exception);
-        }
-        onError();
-    }
-    _onDoneCallback(onSuccess, onError) {
-        try {
-            this._taskState = AssetTaskState.DONE;
-            this._isCompleted = true;
-            if (this.onSuccess) {
-                this.onSuccess(this);
-            }
-            onSuccess();
-        }
-        catch (e) {
-            this._onErrorCallback(onError, "Task is done, error executing success callback(s)", e);
-        }
-    }
-}
-/**
- * Class used to share progress information about assets loading
- */
-class AssetsProgressEvent {
-    /**
-     * Creates a AssetsProgressEvent
-     * @param remainingCount defines the number of remaining tasks to process
-     * @param totalCount defines the total number of tasks
-     * @param task defines the task that was just processed
-     */
-    constructor(remainingCount, totalCount, task) {
-        this.remainingCount = remainingCount;
-        this.totalCount = totalCount;
-        this.task = task;
-    }
-}
-/**
- * Define a task used by AssetsManager to load assets into a container
- */
-class ContainerAssetTask extends AbstractAssetTask {
-    /**
-     * Creates a new ContainerAssetTask
-     * @param name defines the name of the task
-     * @param meshesNames defines the list of mesh's names you want to load
-     * @param rootUrl defines the root url to use as a base to load your meshes and associated resources
-     * @param sceneFilename defines the filename or File of the scene to load from
-     */
-    constructor(
-    /**
-     * Defines the name of the task
-     */
-    name, 
-    /**
-     * Defines the list of mesh's names you want to load
-     */
-    meshesNames, 
-    /**
-     * Defines the root url to use as a base to load your meshes and associated resources
-     */
-    rootUrl, 
-    /**
-     * Defines the filename or File of the scene to load from
-     */
-    sceneFilename, 
-    /**
-     * Defines the extension to use to load the scene (if not defined, ".babylon" will be used)
-     */
-    extension) {
-        super(name);
-        this.name = name;
-        this.meshesNames = meshesNames;
-        this.rootUrl = rootUrl;
-        this.sceneFilename = sceneFilename;
-        this.extension = extension;
-    }
-    /**
-     * Execute the current task
-     * @param scene defines the scene where you want your assets to be loaded
-     * @param onSuccess is a callback called when the task is successfully executed
-     * @param onError is a callback called if an error occurs
-     */
-    runTask(scene, onSuccess, onError) {
-        SceneLoader.LoadAssetContainer(this.rootUrl, this.sceneFilename, scene, (container) => {
-            this.loadedContainer = container;
-            this.loadedMeshes = container.meshes;
-            this.loadedTransformNodes = container.transformNodes;
-            this.loadedParticleSystems = container.particleSystems;
-            this.loadedSkeletons = container.skeletons;
-            this.loadedAnimationGroups = container.animationGroups;
-            onSuccess();
-        }, null, (scene, message, exception) => {
-            onError(message, exception);
-        }, this.extension);
-    }
-}
-/**
- * Define a task used by AssetsManager to load meshes
- */
-class MeshAssetTask extends AbstractAssetTask {
-    /**
-     * Creates a new MeshAssetTask
-     * @param name defines the name of the task
-     * @param meshesNames defines the list of mesh's names you want to load
-     * @param rootUrl defines the root url to use as a base to load your meshes and associated resources
-     * @param sceneFilename defines the filename or File of the scene to load from
-     */
-    constructor(
-    /**
-     * Defines the name of the task
-     */
-    name, 
-    /**
-     * Defines the list of mesh's names you want to load
-     */
-    meshesNames, 
-    /**
-     * Defines the root url to use as a base to load your meshes and associated resources
-     */
-    rootUrl, 
-    /**
-     * Defines the filename or File of the scene to load from
-     */
-    sceneFilename, 
-    /**
-     * Defines the extension to use to load the scene (if not defined, ".babylon" will be used)
-     */
-    extension) {
-        super(name);
-        this.name = name;
-        this.meshesNames = meshesNames;
-        this.rootUrl = rootUrl;
-        this.sceneFilename = sceneFilename;
-        this.extension = extension;
-    }
-    /**
-     * Execute the current task
-     * @param scene defines the scene where you want your assets to be loaded
-     * @param onSuccess is a callback called when the task is successfully executed
-     * @param onError is a callback called if an error occurs
-     */
-    runTask(scene, onSuccess, onError) {
-        SceneLoader.ImportMesh(this.meshesNames, this.rootUrl, this.sceneFilename, scene, (meshes, particleSystems, skeletons, animationGroups, transformNodes) => {
-            this.loadedMeshes = meshes;
-            this.loadedTransformNodes = transformNodes;
-            this.loadedParticleSystems = particleSystems;
-            this.loadedSkeletons = skeletons;
-            this.loadedAnimationGroups = animationGroups;
-            onSuccess();
-        }, null, (scene, message, exception) => {
-            onError(message, exception);
-        }, this.extension);
-    }
-}
-/**
- * Define a task used by AssetsManager to load text content
- */
-class TextFileAssetTask extends AbstractAssetTask {
-    /**
-     * Creates a new TextFileAssetTask object
-     * @param name defines the name of the task
-     * @param url defines the location of the file to load
-     */
-    constructor(
-    /**
-     * Defines the name of the task
-     */
-    name, 
-    /**
-     * Defines the location of the file to load
-     */
-    url) {
-        super(name);
-        this.name = name;
-        this.url = url;
-    }
-    /**
-     * Execute the current task
-     * @param scene defines the scene where you want your assets to be loaded
-     * @param onSuccess is a callback called when the task is successfully executed
-     * @param onError is a callback called if an error occurs
-     */
-    runTask(scene, onSuccess, onError) {
-        scene._loadFile(this.url, (data) => {
-            this.text = data;
-            onSuccess();
-        }, undefined, false, false, (request, exception) => {
-            if (request) {
-                onError(request.status + " " + request.statusText, exception);
-            }
-        });
-    }
-}
-/**
- * Define a task used by AssetsManager to load binary data
- */
-class BinaryFileAssetTask extends AbstractAssetTask {
-    /**
-     * Creates a new BinaryFileAssetTask object
-     * @param name defines the name of the new task
-     * @param url defines the location of the file to load
-     */
-    constructor(
-    /**
-     * Defines the name of the task
-     */
-    name, 
-    /**
-     * Defines the location of the file to load
-     */
-    url) {
-        super(name);
-        this.name = name;
-        this.url = url;
-    }
-    /**
-     * Execute the current task
-     * @param scene defines the scene where you want your assets to be loaded
-     * @param onSuccess is a callback called when the task is successfully executed
-     * @param onError is a callback called if an error occurs
-     */
-    runTask(scene, onSuccess, onError) {
-        scene._loadFile(this.url, (data) => {
-            this.data = data;
-            onSuccess();
-        }, undefined, true, true, (request, exception) => {
-            if (request) {
-                onError(request.status + " " + request.statusText, exception);
-            }
-        });
-    }
-}
-/**
- * Define a task used by AssetsManager to load images
- */
-class ImageAssetTask extends AbstractAssetTask {
-    /**
-     * Creates a new ImageAssetTask
-     * @param name defines the name of the task
-     * @param url defines the location of the image to load
-     */
-    constructor(
-    /**
-     * Defines the name of the task
-     */
-    name, 
-    /**
-     * Defines the location of the image to load
-     */
-    url) {
-        super(name);
-        this.name = name;
-        this.url = url;
-    }
-    /**
-     * Execute the current task
-     * @param scene defines the scene where you want your assets to be loaded
-     * @param onSuccess is a callback called when the task is successfully executed
-     * @param onError is a callback called if an error occurs
-     */
-    runTask(scene, onSuccess, onError) {
-        const img = new Image();
-        Tools.SetCorsBehavior(this.url, img);
-        img.onload = () => {
-            this.image = img;
-            onSuccess();
-        };
-        img.onerror = (err) => {
-            onError("Error loading image", err);
-        };
-        img.src = this.url;
-    }
-}
-/**
- * Define a task used by AssetsManager to load 2D textures
- */
-class TextureAssetTask extends AbstractAssetTask {
-    /**
-     * Creates a new TextureAssetTask object
-     * @param name defines the name of the task
-     * @param url defines the location of the file to load
-     * @param noMipmap defines if mipmap should not be generated (default is false)
-     * @param invertY defines if texture must be inverted on Y axis (default is true)
-     * @param samplingMode defines the sampling mode to use (default is Texture.TRILINEAR_SAMPLINGMODE)
-     */
-    constructor(
-    /**
-     * Defines the name of the task
-     */
-    name, 
-    /**
-     * Defines the location of the file to load
-     */
-    url, 
-    /**
-     * Defines if mipmap should not be generated (default is false)
-     */
-    noMipmap, 
-    /**
-     * Defines if texture must be inverted on Y axis (default is true)
-     */
-    invertY = true, 
-    /**
-     * Defines the sampling mode to use (default is Texture.TRILINEAR_SAMPLINGMODE)
-     */
-    samplingMode = Texture.TRILINEAR_SAMPLINGMODE) {
-        super(name);
-        this.name = name;
-        this.url = url;
-        this.noMipmap = noMipmap;
-        this.invertY = invertY;
-        this.samplingMode = samplingMode;
-    }
-    /**
-     * Execute the current task
-     * @param scene defines the scene where you want your assets to be loaded
-     * @param onSuccess is a callback called when the task is successfully executed
-     * @param onError is a callback called if an error occurs
-     */
-    runTask(scene, onSuccess, onError) {
-        const onload = () => {
-            onSuccess();
-        };
-        const onerror = (message, exception) => {
-            onError(message, exception);
-        };
-        this.texture = new Texture(this.url, scene, this.noMipmap, this.invertY, this.samplingMode, onload, onerror);
-    }
-}
-/**
- * Define a task used by AssetsManager to load cube textures
- */
-class CubeTextureAssetTask extends AbstractAssetTask {
-    /**
-     * Creates a new CubeTextureAssetTask
-     * @param name defines the name of the task
-     * @param url defines the location of the files to load (You have to specify the folder where the files are + filename with no extension)
-     * @param extensions defines the extensions to use to load files (["_px", "_py", "_pz", "_nx", "_ny", "_nz"] by default)
-     * @param noMipmap defines if mipmaps should not be generated (default is false)
-     * @param files defines the explicit list of files (undefined by default)
-     * @param prefiltered
-     */
-    constructor(
-    /**
-     * Defines the name of the task
-     */
-    name, 
-    /**
-     * Defines the location of the files to load (You have to specify the folder where the files are + filename with no extension)
-     */
-    url, 
-    /**
-     * Defines the extensions to use to load files (["_px", "_py", "_pz", "_nx", "_ny", "_nz"] by default)
-     */
-    extensions, 
-    /**
-     * Defines if mipmaps should not be generated (default is false)
-     */
-    noMipmap, 
-    /**
-     * Defines the explicit list of files (undefined by default)
-     */
-    files, 
-    /**
-     * Defines the prefiltered texture option (default is false)
-     */
-    prefiltered) {
-        super(name);
-        this.name = name;
-        this.url = url;
-        this.extensions = extensions;
-        this.noMipmap = noMipmap;
-        this.files = files;
-        this.prefiltered = prefiltered;
-    }
-    /**
-     * Execute the current task
-     * @param scene defines the scene where you want your assets to be loaded
-     * @param onSuccess is a callback called when the task is successfully executed
-     * @param onError is a callback called if an error occurs
-     */
-    runTask(scene, onSuccess, onError) {
-        const onload = () => {
-            onSuccess();
-        };
-        const onerror = (message, exception) => {
-            onError(message, exception);
-        };
-        this.texture = new CubeTexture(this.url, scene, this.extensions, this.noMipmap, this.files, onload, onerror, undefined, this.prefiltered);
-    }
-}
-/**
- * Define a task used by AssetsManager to load HDR cube textures
- */
-class HDRCubeTextureAssetTask extends AbstractAssetTask {
-    /**
-     * Creates a new HDRCubeTextureAssetTask object
-     * @param name defines the name of the task
-     * @param url defines the location of the file to load
-     * @param size defines the desired size (the more it increases the longer the generation will be) If the size is omitted this implies you are using a preprocessed cubemap.
-     * @param noMipmap defines if mipmaps should not be generated (default is false)
-     * @param generateHarmonics specifies whether you want to extract the polynomial harmonics during the generation process (default is true)
-     * @param gammaSpace specifies if the texture will be use in gamma or linear space (the PBR material requires those texture in linear space, but the standard material would require them in Gamma space) (default is false)
-     * @param reserved Internal use only
-     */
-    constructor(
-    /**
-     * Defines the name of the task
-     */
-    name, 
-    /**
-     * Defines the location of the file to load
-     */
-    url, 
-    /**
-     * Defines the desired size (the more it increases the longer the generation will be)
-     */
-    size, 
-    /**
-     * Defines if mipmaps should not be generated (default is false)
-     */
-    noMipmap = false, 
-    /**
-     * Specifies whether you want to extract the polynomial harmonics during the generation process (default is true)
-     */
-    generateHarmonics = true, 
-    /**
-     * Specifies if the texture will be use in gamma or linear space (the PBR material requires those texture in linear space, but the standard material would require them in Gamma space) (default is false)
-     */
-    gammaSpace = false, 
-    /**
-     * Internal Use Only
-     */
-    reserved = false) {
-        super(name);
-        this.name = name;
-        this.url = url;
-        this.size = size;
-        this.noMipmap = noMipmap;
-        this.generateHarmonics = generateHarmonics;
-        this.gammaSpace = gammaSpace;
-        this.reserved = reserved;
-    }
-    /**
-     * Execute the current task
-     * @param scene defines the scene where you want your assets to be loaded
-     * @param onSuccess is a callback called when the task is successfully executed
-     * @param onError is a callback called if an error occurs
-     */
-    runTask(scene, onSuccess, onError) {
-        const onload = () => {
-            onSuccess();
-        };
-        const onerror = (message, exception) => {
-            onError(message, exception);
-        };
-        this.texture = new HDRCubeTexture(this.url, scene, this.size, this.noMipmap, this.generateHarmonics, this.gammaSpace, this.reserved, onload, onerror);
-    }
-}
-/**
- * Define a task used by AssetsManager to load Equirectangular cube textures
- */
-class EquiRectangularCubeTextureAssetTask extends AbstractAssetTask {
-    /**
-     * Creates a new EquiRectangularCubeTextureAssetTask object
-     * @param name defines the name of the task
-     * @param url defines the location of the file to load
-     * @param size defines the desired size (the more it increases the longer the generation will be)
-     * If the size is omitted this implies you are using a preprocessed cubemap.
-     * @param noMipmap defines if mipmaps should not be generated (default is false)
-     * @param gammaSpace specifies if the texture will be used in gamma or linear space
-     * (the PBR material requires those texture in linear space, but the standard material would require them in Gamma space)
-     * (default is true)
-     */
-    constructor(
-    /**
-     * Defines the name of the task
-     */
-    name, 
-    /**
-     * Defines the location of the file to load
-     */
-    url, 
-    /**
-     * Defines the desired size (the more it increases the longer the generation will be)
-     */
-    size, 
-    /**
-     * Defines if mipmaps should not be generated (default is false)
-     */
-    noMipmap = false, 
-    /**
-     * Specifies if the texture will be use in gamma or linear space (the PBR material requires those texture in linear space,
-     * but the standard material would require them in Gamma space) (default is true)
-     */
-    gammaSpace = true) {
-        super(name);
-        this.name = name;
-        this.url = url;
-        this.size = size;
-        this.noMipmap = noMipmap;
-        this.gammaSpace = gammaSpace;
-    }
-    /**
-     * Execute the current task
-     * @param scene defines the scene where you want your assets to be loaded
-     * @param onSuccess is a callback called when the task is successfully executed
-     * @param onError is a callback called if an error occurs
-     */
-    runTask(scene, onSuccess, onError) {
-        const onload = () => {
-            onSuccess();
-        };
-        const onerror = (message, exception) => {
-            onError(message, exception);
-        };
-        this.texture = new EquiRectangularCubeTexture(this.url, scene, this.size, this.noMipmap, this.gammaSpace, onload, onerror);
-    }
-}
-/**
- * This class can be used to easily import assets into a scene
- * @see https://doc.babylonjs.com/features/featuresDeepDive/importers/assetManager
- */
-class AssetsManager {
-    /**
-     * Creates a new AssetsManager
-     * @param scene defines the scene to work on
-     */
-    constructor(scene) {
-        this._isLoading = false;
-        this._tasks = new Array();
-        this._waitingTasksCount = 0;
-        this._totalTasksCount = 0;
-        /**
-         * Observable called when all tasks are processed
-         */
-        this.onTaskSuccessObservable = new Observable();
-        /**
-         * Observable called when a task had an error
-         */
-        this.onTaskErrorObservable = new Observable();
-        /**
-         * Observable called when all tasks were executed
-         */
-        this.onTasksDoneObservable = new Observable();
-        /**
-         * Observable called when a task is done (whatever the result is)
-         */
-        this.onProgressObservable = new Observable();
-        /**
-         * Gets or sets a boolean defining if the AssetsManager should use the default loading screen
-         * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/customLoadingScreen
-         */
-        this.useDefaultLoadingScreen = true;
-        /**
-         * Gets or sets a boolean defining if the AssetsManager should automatically hide the loading screen
-         * when all assets have been downloaded.
-         * If set to false, you need to manually call in hideLoadingUI() once your scene is ready.
-         */
-        this.autoHideLoadingUI = true;
-        this._scene = scene || EngineStore.LastCreatedScene;
-    }
-    /**
-     * Add a ContainerAssetTask to the list of active tasks
-     * @param taskName defines the name of the new task
-     * @param meshesNames defines the name of meshes to load
-     * @param rootUrl defines the root url to use to locate files
-     * @param sceneFilename defines the filename of the scene file or the File itself
-     * @param extension defines the extension to use to load the file
-     * @returns a new ContainerAssetTask object
-     */
-    addContainerTask(taskName, meshesNames, rootUrl, sceneFilename, extension) {
-        const task = new ContainerAssetTask(taskName, meshesNames, rootUrl, sceneFilename, extension);
-        this._tasks.push(task);
-        return task;
-    }
-    /**
-     * Add a MeshAssetTask to the list of active tasks
-     * @param taskName defines the name of the new task
-     * @param meshesNames defines the name of meshes to load
-     * @param rootUrl defines the root url to use to locate files
-     * @param sceneFilename defines the filename of the scene file or the File itself
-     * @param extension defines the extension to use to load the file
-     * @returns a new MeshAssetTask object
-     */
-    addMeshTask(taskName, meshesNames, rootUrl, sceneFilename, extension) {
-        const task = new MeshAssetTask(taskName, meshesNames, rootUrl, sceneFilename, extension);
-        this._tasks.push(task);
-        return task;
-    }
-    /**
-     * Add a TextFileAssetTask to the list of active tasks
-     * @param taskName defines the name of the new task
-     * @param url defines the url of the file to load
-     * @returns a new TextFileAssetTask object
-     */
-    addTextFileTask(taskName, url) {
-        const task = new TextFileAssetTask(taskName, url);
-        this._tasks.push(task);
-        return task;
-    }
-    /**
-     * Add a BinaryFileAssetTask to the list of active tasks
-     * @param taskName defines the name of the new task
-     * @param url defines the url of the file to load
-     * @returns a new BinaryFileAssetTask object
-     */
-    addBinaryFileTask(taskName, url) {
-        const task = new BinaryFileAssetTask(taskName, url);
-        this._tasks.push(task);
-        return task;
-    }
-    /**
-     * Add a ImageAssetTask to the list of active tasks
-     * @param taskName defines the name of the new task
-     * @param url defines the url of the file to load
-     * @returns a new ImageAssetTask object
-     */
-    addImageTask(taskName, url) {
-        const task = new ImageAssetTask(taskName, url);
-        this._tasks.push(task);
-        return task;
-    }
-    /**
-     * Add a TextureAssetTask to the list of active tasks
-     * @param taskName defines the name of the new task
-     * @param url defines the url of the file to load
-     * @param noMipmap defines if the texture must not receive mipmaps (false by default)
-     * @param invertY defines if you want to invert Y axis of the loaded texture (true by default)
-     * @param samplingMode defines the sampling mode to use (Texture.TRILINEAR_SAMPLINGMODE by default)
-     * @returns a new TextureAssetTask object
-     */
-    addTextureTask(taskName, url, noMipmap, invertY, samplingMode = Texture.TRILINEAR_SAMPLINGMODE) {
-        const task = new TextureAssetTask(taskName, url, noMipmap, invertY, samplingMode);
-        this._tasks.push(task);
-        return task;
-    }
-    /**
-     * Add a CubeTextureAssetTask to the list of active tasks
-     * @param taskName defines the name of the new task
-     * @param url defines the url of the file to load
-     * @param extensions defines the extension to use to load the cube map (can be null)
-     * @param noMipmap defines if the texture must not receive mipmaps (false by default)
-     * @param files defines the list of files to load (can be null)
-     * @param prefiltered defines the prefiltered texture option (default is false)
-     * @returns a new CubeTextureAssetTask object
-     */
-    addCubeTextureTask(taskName, url, extensions, noMipmap, files, prefiltered) {
-        const task = new CubeTextureAssetTask(taskName, url, extensions, noMipmap, files, prefiltered);
-        this._tasks.push(task);
-        return task;
-    }
-    /**
-     *
-     * Add a HDRCubeTextureAssetTask to the list of active tasks
-     * @param taskName defines the name of the new task
-     * @param url defines the url of the file to load
-     * @param size defines the size you want for the cubemap (can be null)
-     * @param noMipmap defines if the texture must not receive mipmaps (false by default)
-     * @param generateHarmonics defines if you want to automatically generate (true by default)
-     * @param gammaSpace specifies if the texture will be use in gamma or linear space (the PBR material requires those texture in linear space, but the standard material would require them in Gamma space) (default is false)
-     * @param reserved Internal use only
-     * @returns a new HDRCubeTextureAssetTask object
-     */
-    addHDRCubeTextureTask(taskName, url, size, noMipmap = false, generateHarmonics = true, gammaSpace = false, reserved = false) {
-        const task = new HDRCubeTextureAssetTask(taskName, url, size, noMipmap, generateHarmonics, gammaSpace, reserved);
-        this._tasks.push(task);
-        return task;
-    }
-    /**
-     *
-     * Add a EquiRectangularCubeTextureAssetTask to the list of active tasks
-     * @param taskName defines the name of the new task
-     * @param url defines the url of the file to load
-     * @param size defines the size you want for the cubemap (can be null)
-     * @param noMipmap defines if the texture must not receive mipmaps (false by default)
-     * @param gammaSpace Specifies if the texture will be used in gamma or linear space
-     * (the PBR material requires those textures in linear space, but the standard material would require them in Gamma space)
-     * @returns a new EquiRectangularCubeTextureAssetTask object
-     */
-    addEquiRectangularCubeTextureAssetTask(taskName, url, size, noMipmap = false, gammaSpace = true) {
-        const task = new EquiRectangularCubeTextureAssetTask(taskName, url, size, noMipmap, gammaSpace);
-        this._tasks.push(task);
-        return task;
-    }
-    /**
-     * Remove a task from the assets manager.
-     * @param task the task to remove
-     */
-    removeTask(task) {
-        const index = this._tasks.indexOf(task);
-        if (index > -1) {
-            this._tasks.splice(index, 1);
-        }
-    }
-    _decreaseWaitingTasksCount(task) {
-        this._waitingTasksCount--;
-        try {
-            if (this.onProgress) {
-                this.onProgress(this._waitingTasksCount, this._totalTasksCount, task);
-            }
-            this.onProgressObservable.notifyObservers(new AssetsProgressEvent(this._waitingTasksCount, this._totalTasksCount, task));
-        }
-        catch (e) {
-            Logger.Error("Error running progress callbacks.");
-            console.log(e);
-        }
-        if (this._waitingTasksCount === 0) {
-            try {
-                const currentTasks = this._tasks.slice();
-                if (this.onFinish) {
-                    // Calling onFinish with immutable array of tasks
-                    this.onFinish(currentTasks);
-                }
-                // Let's remove successful tasks
-                for (const task of currentTasks) {
-                    if (task.taskState === AssetTaskState.DONE) {
-                        const index = this._tasks.indexOf(task);
-                        if (index > -1) {
-                            this._tasks.splice(index, 1);
-                        }
-                    }
-                }
-                this.onTasksDoneObservable.notifyObservers(this._tasks);
-            }
-            catch (e) {
-                Logger.Error("Error running tasks-done callbacks.");
-                console.log(e);
-            }
-            this._isLoading = false;
-            if (this.autoHideLoadingUI) {
-                this._scene.getEngine().hideLoadingUI();
-            }
-        }
-    }
-    _runTask(task) {
-        const done = () => {
-            try {
-                if (this.onTaskSuccess) {
-                    this.onTaskSuccess(task);
-                }
-                this.onTaskSuccessObservable.notifyObservers(task);
-                this._decreaseWaitingTasksCount(task);
-            }
-            catch (e) {
-                error("Error executing task success callbacks", e);
-            }
-        };
-        const error = (message, exception) => {
-            task._setErrorObject(message, exception);
-            if (this.onTaskError) {
-                this.onTaskError(task);
-            }
-            else if (!task.onError) {
-                Logger.Error(this._formatTaskErrorMessage(task));
-            }
-            this.onTaskErrorObservable.notifyObservers(task);
-            this._decreaseWaitingTasksCount(task);
-        };
-        task.run(this._scene, done, error);
-    }
-    _formatTaskErrorMessage(task) {
-        let errorMessage = "Unable to complete task " + task.name;
-        if (task.errorObject.message) {
-            errorMessage += `: ${task.errorObject.message}`;
-        }
-        if (task.errorObject.exception) {
-            errorMessage += `: ${task.errorObject.exception}`;
-        }
-        return errorMessage;
-    }
-    /**
-     * Reset the AssetsManager and remove all tasks
-     * @returns the current instance of the AssetsManager
-     */
-    reset() {
-        this._isLoading = false;
-        this._tasks = new Array();
-        return this;
-    }
-    /**
-     * Start the loading process
-     * @returns the current instance of the AssetsManager
-     */
-    load() {
-        if (this._isLoading) {
-            return this;
-        }
-        this._isLoading = true;
-        this._waitingTasksCount = this._tasks.length;
-        this._totalTasksCount = this._tasks.length;
-        if (this._waitingTasksCount === 0) {
-            this._isLoading = false;
-            if (this.onFinish) {
-                this.onFinish(this._tasks);
-            }
-            this.onTasksDoneObservable.notifyObservers(this._tasks);
-            return this;
-        }
-        if (this.useDefaultLoadingScreen) {
-            this._scene.getEngine().displayLoadingUI();
-        }
-        for (let index = 0; index < this._tasks.length; index++) {
-            const task = this._tasks[index];
-            if (task.taskState === AssetTaskState.INIT) {
-                this._runTask(task);
-            }
-        }
-        return this;
-    }
-    /**
-     * Start the loading process as an async operation
-     * @returns a promise returning the list of failed tasks
-     */
-    loadAsync() {
-        return new Promise((resolve, reject) => {
-            if (this._isLoading) {
-                resolve();
-                return;
-            }
-            this.onTasksDoneObservable.addOnce((remainingTasks) => {
-                if (remainingTasks && remainingTasks.length) {
-                    reject(remainingTasks);
-                }
-                else {
-                    resolve();
-                }
-            });
-            this.load();
-        });
-    }
-}
-
-/**
- * Management object used to manage model and material variants
- * for a specific instance of the 3D preview. This class should exist for
- * the lifetime of any preview to track state relating to variant changes.
- */
-class VariantManager {
-    constructor(scene, renameClonedAsset, setBaseModelEnabled) {
-        /**
-         * Store encountered materials
-         */
-        this.materialVariantMap = new Map();
-        /**
-         * A list of model variant applications that replaced the base model,
-         * we store these internally to avoid having to lookup and pass in the
-         * flag from step data.
-         */
-        this.keysThatRemovedBaseModel = [];
-        /**
-         * A map of string to asset container which represents the currently loaded
-         * asset container for a given key. This allows us to know what data to unload when loading
-         * new data for a key.
-         */
-        this.loadedContainerForKey = new Map();
-        /**
-         * A map of string to material array which represents the currently loaded
-         * materials for a given key. This allows us to know what materials are in use by
-         * a given key.
-         */
-        this.loadedMaterialsForKey = new Map();
-        this.scene = scene;
-        this.renameClonedAsset = renameClonedAsset;
-        this.setBaseModelEnabled = setBaseModelEnabled;
-    }
-    /**
-     * Apply a material variant to a given scene.
-     * @param targetMaterial The name of the material in the scene we should be targeting.
-     * @param material The material variant to apply.
-     * @param onProgress A progress callback function for loading bars and event timing.
-     * @param removeWhenUndefined material application is an additive process, setting this bool to true will
-     * instead remove material textures when they aren't defined. this is useful for material editor applications
-     * where we want to undo changes are remove effects from display.
-     */
-    applyMaterial(targetMaterial, material, onProgress, removeWhenUndefined) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve) => {
-                // Keep track of material changes
-                const existingMaterialResource = this.materialVariantMap.get(targetMaterial);
-                this.materialVariantMap.set(targetMaterial, Object.assign(Object.assign({}, existingMaterialResource), material));
-                // Rename the target to match this instance.
-                const targetMaterialName = this.renameClonedAsset(targetMaterial);
-                // Attempt to find the requested material on this object.
-                const targetedMaterials = this.scene.materials.filter((mat) => mat.name === targetMaterialName);
-                // At this point we know the scene has been loaded. If the target material doesn't exist then
-                // the step wasn't configured correctly to begin with so just ignore the request.
-                if (targetedMaterials.length === 0) {
-                    resolve();
-                    return;
-                }
-                // Create an async task for each type of available texture given.
-                const assetsManager = new AssetsManager(this.scene);
-                assetsManager.useDefaultLoadingScreen = false;
-                // Loop through the materials found in scene that match our target material name and
-                // notify the asset manager of the various material values that need to change on each.
-                targetedMaterials.forEach((targetedMaterial) => calculateMaterialProperties(material, targetedMaterial, assetsManager, removeWhenUndefined));
-                // Notify caller on progress towards loading material changes.
-                assetsManager.onProgress = (remaining, total, task) => {
-                    onProgress && onProgress((remaining / total) * 100, 100, task.name);
-                };
-                // Execute the configured texture tasks. For each task received, we iterate ver each targeted material and
-                // apply the requirements of the task.
-                assetsManager.onFinish = (tasks) => {
-                    tasks.forEach((task) => {
-                        const textureTask = task;
-                        onProgress && onProgress(100, 100, task.name);
-                        targetedMaterials.forEach((targetMat) => applyDownloadedTexture(task.name, targetMat, material, textureTask.texture));
-                    });
-                    resolve();
-                };
-                assetsManager.loadAsync();
-            });
-        });
-    }
-    /**
-     * Applies a model variant.
-     * @param key The key to uniquely identify this model variant application.
-     * @param replaceProductModel When true, we should replace the base product model.
-     * @param model The details for the new model, when undefined we should remove the variant associated to the given key.
-     * @param onProgress A load progress callback that can be used for loading bars and event timing.
-     */
-    applyModel(key, replaceProductModel, model, onProgress) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            /**
-             * If we're adding a new model to the scene and the key hasn't been
-             * encountered before and the product model is being replaced, let's
-             * store the key so we know to replace the product model when encountered later.
-             */
-            if (model &&
-                replaceProductModel &&
-                !this.keysThatRemovedBaseModel.includes(key)) {
-                this.keysThatRemovedBaseModel.push(key);
-            }
-            // When no model details are provided that means
-            // the model variant has been requested to be removed entirely. We remove that
-            // and also re-add any base model if it was removed to fit this variant.
-            if (!model) {
-                if (this.keysThatRemovedBaseModel.includes(key)) {
-                    this.setBaseModelEnabled(true);
-                }
-                (_a = this.loadedContainerForKey.get(key)) === null || _a === void 0 ? void 0 : _a.dispose();
-                this.loadedContainerForKey.delete(key);
-                this.loadedMaterialsForKey.delete(key);
-                return Promise.resolve(undefined);
-            }
-            // Remove any existing asset for the given key.
-            if (this.loadedContainerForKey.has(key)) {
-                (_b = this.loadedContainerForKey.get(key)) === null || _b === void 0 ? void 0 : _b.dispose();
-                this.loadedContainerForKey.delete(key);
-                this.loadedMaterialsForKey.delete(key);
-            }
-            // Remove product base model if required.
-            if (replaceProductModel) {
-                this.setBaseModelEnabled(false);
-            }
-            // Add new model to scene.
-            const container = yield getAssetContainer(model, this.scene, onProgress);
-            const instance = container.instantiateModelsToScene(this.renameClonedAsset, true);
-            this.loadedContainerForKey.set(key, instance);
-            // Store all materials used by this model.
-            this.loadedMaterialsForKey.set(key, getAllMaterialsForInstance(instance));
-            // Reapply any encountered material variants to the scene, this ensures
-            // no material information is lost.
-            const promiseList = [];
-            this.materialVariantMap.forEach((value, key) => __awaiter(this, void 0, void 0, function* () {
-                promiseList.push(this.applyMaterial(key, value));
-            }));
-            yield Promise.all(promiseList);
-            return instance;
-        });
-    }
-    dispose() {
-        this.loadedContainerForKey.forEach((value) => value === null || value === void 0 ? void 0 : value.dispose());
-        this.loadedContainerForKey.clear();
-        this.loadedMaterialsForKey.forEach((value) => value.forEach((mat) => mat === null || mat === void 0 ? void 0 : mat.dispose()));
-        this.loadedMaterialsForKey.clear();
-        this.materialVariantMap.clear();
-        this.keysThatRemovedBaseModel = [];
-    }
-    getAllMaterials() {
-        const materials = [];
-        this.loadedMaterialsForKey.forEach((value) => {
-            value.forEach((mat) => {
-                if (!materials.includes(mat)) {
-                    materials.push(mat);
-                }
-            });
-        });
-        return materials;
-    }
-    getAnimationGroups() {
-        const animationGroups = [];
-        this.loadedContainerForKey.forEach((value) => {
-            animationGroups.push(...value.animationGroups);
-        });
-        return animationGroups;
-    }
-}
-function getAllMaterialsForInstance(modelInstance) {
-    const materials = [];
-    modelInstance.rootNodes.forEach((node) => {
-        node.getChildMeshes().forEach((mesh) => {
-            if (mesh.material && !materials.includes(mesh.material)) {
-                materials.push(mesh.material);
-            }
-            if (mesh.subMeshes) {
-                mesh.subMeshes.forEach((subMesh) => {
-                    const mat = subMesh.getMaterial(false);
-                    if (mat && !materials.includes(mat)) {
-                        materials.push(mat);
-                    }
-                });
-            }
-        });
-    });
-    return materials;
-}
-
-export { CubeTexture as C, VariantManager as V, getAllMaterialsForInstance as g };