@babylonjs/viewer 7.25.0 → 7.25.1-alpha

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

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