@babylonjs/core 5.45.2 → 5.47.0

package/Engines/thinEngine.js

@@ -29,6 +29,249 @@ class BufferPointer {
  * The base engine class (root of all engines)
  */
 export class ThinEngine {
+    /**
+     * Returns the current npm package of the sdk
+     */
+    // Not mixed with Version for tooling purpose.
+    static get NpmPackage() {
+        return "babylonjs@5.47.0";
+    }
+    /**
+     * Returns the current version of the framework
+     */
+    static get Version() {
+        return "5.47.0";
+    }
+    /**
+     * Returns a string describing the current engine
+     */
+    get description() {
+        let description = this.name + this.webGLVersion;
+        if (this._caps.parallelShaderCompile) {
+            description += " - Parallel shader compilation";
+        }
+        return description;
+    }
+    /**
+     * Gets or sets the name of the engine
+     */
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    /**
+     * Returns the version of the engine
+     */
+    get version() {
+        return this._webGLVersion;
+    }
+    /**
+     * Gets or sets the relative url used to load shaders if using the engine in non-minified mode
+     */
+    static get ShadersRepository() {
+        return Effect.ShadersRepository;
+    }
+    static set ShadersRepository(value) {
+        Effect.ShadersRepository = value;
+    }
+    /**
+     * @internal
+     */
+    _getShaderProcessor(shaderLanguage) {
+        return this._shaderProcessor;
+    }
+    /**
+     * Gets or sets a boolean indicating if depth buffer should be reverse, going from far to near.
+     * This can provide greater z depth for distant objects.
+     */
+    get useReverseDepthBuffer() {
+        return this._useReverseDepthBuffer;
+    }
+    set useReverseDepthBuffer(useReverse) {
+        if (useReverse === this._useReverseDepthBuffer) {
+            return;
+        }
+        this._useReverseDepthBuffer = useReverse;
+        if (useReverse) {
+            this._depthCullingState.depthFunc = 518;
+        }
+        else {
+            this._depthCullingState.depthFunc = 515;
+        }
+    }
+    /**
+     * Gets the current frame id
+     */
+    get frameId() {
+        return this._frameId;
+    }
+    /**
+     * Gets a boolean indicating that the engine supports uniform buffers
+     * @see https://doc.babylonjs.com/setup/support/webGL2#uniform-buffer-objets
+     */
+    get supportsUniformBuffers() {
+        return this.webGLVersion > 1 && !this.disableUniformBuffers;
+    }
+    /**
+     * Gets the options used for engine creation
+     * @returns EngineOptions object
+     */
+    getCreationOptions() {
+        return this._creationOptions;
+    }
+    /** @internal */
+    get _shouldUseHighPrecisionShader() {
+        return !!(this._caps.highPrecisionShaderSupported && this._highPrecisionShadersAllowed);
+    }
+    /**
+     * Gets a boolean indicating that only power of 2 textures are supported
+     * Please note that you can still use non power of 2 textures but in this case the engine will forcefully convert them
+     */
+    get needPOTTextures() {
+        return this._webGLVersion < 2 || this.forcePOTTextures;
+    }
+    /**
+     * Gets the list of current active render loop functions
+     * @returns an array with the current render loop functions
+     */
+    get activeRenderLoops() {
+        return this._activeRenderLoops;
+    }
+    /**
+     * Gets or sets a boolean indicating if resources should be retained to be able to handle context lost events
+     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#handling-webgl-context-lost
+     */
+    get doNotHandleContextLost() {
+        return this._doNotHandleContextLost;
+    }
+    set doNotHandleContextLost(value) {
+        this._doNotHandleContextLost = value;
+    }
+    get _supportsHardwareTextureRescaling() {
+        return false;
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Gets the current viewport
+     */
+    get currentViewport() {
+        return this._cachedViewport;
+    }
+    /**
+     * Gets the default empty texture
+     */
+    get emptyTexture() {
+        if (!this._emptyTexture) {
+            this._emptyTexture = this.createRawTexture(new Uint8Array(4), 1, 1, 5, false, false, 1);
+        }
+        return this._emptyTexture;
+    }
+    /**
+     * Gets the default empty 3D texture
+     */
+    get emptyTexture3D() {
+        if (!this._emptyTexture3D) {
+            this._emptyTexture3D = this.createRawTexture3D(new Uint8Array(4), 1, 1, 1, 5, false, false, 1);
+        }
+        return this._emptyTexture3D;
+    }
+    /**
+     * Gets the default empty 2D array texture
+     */
+    get emptyTexture2DArray() {
+        if (!this._emptyTexture2DArray) {
+            this._emptyTexture2DArray = this.createRawTexture2DArray(new Uint8Array(4), 1, 1, 1, 5, false, false, 1);
+        }
+        return this._emptyTexture2DArray;
+    }
+    /**
+     * Gets the default empty cube texture
+     */
+    get emptyCubeTexture() {
+        if (!this._emptyCubeTexture) {
+            const faceData = new Uint8Array(4);
+            const cubeData = [faceData, faceData, faceData, faceData, faceData, faceData];
+            this._emptyCubeTexture = this.createRawCubeTexture(cubeData, 1, 5, 0, false, false, 1);
+        }
+        return this._emptyCubeTexture;
+    }
+    /**
+     * Gets a boolean indicating if the engine runs in WebGPU or not.
+     */
+    get isWebGPU() {
+        return this._isWebGPU;
+    }
+    /**
+     * Gets the shader platform name used by the effects.
+     */
+    get shaderPlatformName() {
+        return this._shaderPlatformName;
+    }
+    /**
+     * Enables or disables the snapshot rendering mode
+     * Note that the WebGL engine does not support snapshot rendering so setting the value won't have any effect for this engine
+     */
+    get snapshotRendering() {
+        return false;
+    }
+    set snapshotRendering(activate) {
+        // WebGL engine does not support snapshot rendering
+    }
+    /**
+     * Gets or sets the snapshot rendering mode
+     */
+    get snapshotRenderingMode() {
+        return this._snapshotRenderingMode;
+    }
+    set snapshotRenderingMode(mode) {
+        this._snapshotRenderingMode = mode;
+    }
+    /**
+     * Gets a boolean indicating if the exact sRGB conversions or faster approximations are used for converting to and from linear space.
+     */
+    get useExactSrgbConversions() {
+        return this._useExactSrgbConversions;
+    }
+    /**
+     * Creates a new snapshot at the next frame using the current snapshotRenderingMode
+     */
+    snapshotRenderingReset() {
+        this.snapshotRendering = false;
+    }
+    static _CreateCanvas(width, height) {
+        if (typeof document === "undefined") {
+            return new OffscreenCanvas(width, height);
+        }
+        const canvas = document.createElement("canvas");
+        canvas.width = width;
+        canvas.height = height;
+        return canvas;
+    }
+    /**
+     * Create a canvas. This method is overridden by other engines
+     * @param width width
+     * @param height height
+     * @returns ICanvas interface
+     */
+    createCanvas(width, height) {
+        return ThinEngine._CreateCanvas(width, height);
+    }
+    /**
+     * Create an image to use with canvas
+     * @returns IImage interface
+     */
+    createCanvasImage() {
+        return document.createElement("img");
+    }
     /**
      * 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
@@ -398,249 +641,6 @@ export class ThinEngine {
             this._renderingCanvas.setAttribute("data-engine", versionToLog);
         }
     }
-    /**
-     * Returns the current npm package of the sdk
-     */
-    // Not mixed with Version for tooling purpose.
-    static get NpmPackage() {
-        return "babylonjs@5.45.2";
-    }
-    /**
-     * Returns the current version of the framework
-     */
-    static get Version() {
-        return "5.45.2";
-    }
-    /**
-     * Returns a string describing the current engine
-     */
-    get description() {
-        let description = this.name + this.webGLVersion;
-        if (this._caps.parallelShaderCompile) {
-            description += " - Parallel shader compilation";
-        }
-        return description;
-    }
-    /**
-     * Gets or sets the name of the engine
-     */
-    get name() {
-        return this._name;
-    }
-    set name(value) {
-        this._name = value;
-    }
-    /**
-     * Returns the version of the engine
-     */
-    get version() {
-        return this._webGLVersion;
-    }
-    /**
-     * Gets or sets the relative url used to load shaders if using the engine in non-minified mode
-     */
-    static get ShadersRepository() {
-        return Effect.ShadersRepository;
-    }
-    static set ShadersRepository(value) {
-        Effect.ShadersRepository = value;
-    }
-    /**
-     * @internal
-     */
-    _getShaderProcessor(shaderLanguage) {
-        return this._shaderProcessor;
-    }
-    /**
-     * Gets or sets a boolean indicating if depth buffer should be reverse, going from far to near.
-     * This can provide greater z depth for distant objects.
-     */
-    get useReverseDepthBuffer() {
-        return this._useReverseDepthBuffer;
-    }
-    set useReverseDepthBuffer(useReverse) {
-        if (useReverse === this._useReverseDepthBuffer) {
-            return;
-        }
-        this._useReverseDepthBuffer = useReverse;
-        if (useReverse) {
-            this._depthCullingState.depthFunc = 518;
-        }
-        else {
-            this._depthCullingState.depthFunc = 515;
-        }
-    }
-    /**
-     * Gets the current frame id
-     */
-    get frameId() {
-        return this._frameId;
-    }
-    /**
-     * Gets a boolean indicating that the engine supports uniform buffers
-     * @see https://doc.babylonjs.com/setup/support/webGL2#uniform-buffer-objets
-     */
-    get supportsUniformBuffers() {
-        return this.webGLVersion > 1 && !this.disableUniformBuffers;
-    }
-    /**
-     * Gets the options used for engine creation
-     * @returns EngineOptions object
-     */
-    getCreationOptions() {
-        return this._creationOptions;
-    }
-    /** @internal */
-    get _shouldUseHighPrecisionShader() {
-        return !!(this._caps.highPrecisionShaderSupported && this._highPrecisionShadersAllowed);
-    }
-    /**
-     * Gets a boolean indicating that only power of 2 textures are supported
-     * Please note that you can still use non power of 2 textures but in this case the engine will forcefully convert them
-     */
-    get needPOTTextures() {
-        return this._webGLVersion < 2 || this.forcePOTTextures;
-    }
-    /**
-     * Gets the list of current active render loop functions
-     * @returns an array with the current render loop functions
-     */
-    get activeRenderLoops() {
-        return this._activeRenderLoops;
-    }
-    /**
-     * Gets or sets a boolean indicating if resources should be retained to be able to handle context lost events
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#handling-webgl-context-lost
-     */
-    get doNotHandleContextLost() {
-        return this._doNotHandleContextLost;
-    }
-    set doNotHandleContextLost(value) {
-        this._doNotHandleContextLost = value;
-    }
-    get _supportsHardwareTextureRescaling() {
-        return false;
-    }
-    /**
-     * 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;
-    }
-    /**
-     * Gets the current viewport
-     */
-    get currentViewport() {
-        return this._cachedViewport;
-    }
-    /**
-     * Gets the default empty texture
-     */
-    get emptyTexture() {
-        if (!this._emptyTexture) {
-            this._emptyTexture = this.createRawTexture(new Uint8Array(4), 1, 1, 5, false, false, 1);
-        }
-        return this._emptyTexture;
-    }
-    /**
-     * Gets the default empty 3D texture
-     */
-    get emptyTexture3D() {
-        if (!this._emptyTexture3D) {
-            this._emptyTexture3D = this.createRawTexture3D(new Uint8Array(4), 1, 1, 1, 5, false, false, 1);
-        }
-        return this._emptyTexture3D;
-    }
-    /**
-     * Gets the default empty 2D array texture
-     */
-    get emptyTexture2DArray() {
-        if (!this._emptyTexture2DArray) {
-            this._emptyTexture2DArray = this.createRawTexture2DArray(new Uint8Array(4), 1, 1, 1, 5, false, false, 1);
-        }
-        return this._emptyTexture2DArray;
-    }
-    /**
-     * Gets the default empty cube texture
-     */
-    get emptyCubeTexture() {
-        if (!this._emptyCubeTexture) {
-            const faceData = new Uint8Array(4);
-            const cubeData = [faceData, faceData, faceData, faceData, faceData, faceData];
-            this._emptyCubeTexture = this.createRawCubeTexture(cubeData, 1, 5, 0, false, false, 1);
-        }
-        return this._emptyCubeTexture;
-    }
-    /**
-     * Gets a boolean indicating if the engine runs in WebGPU or not.
-     */
-    get isWebGPU() {
-        return this._isWebGPU;
-    }
-    /**
-     * Gets the shader platform name used by the effects.
-     */
-    get shaderPlatformName() {
-        return this._shaderPlatformName;
-    }
-    /**
-     * Enables or disables the snapshot rendering mode
-     * Note that the WebGL engine does not support snapshot rendering so setting the value won't have any effect for this engine
-     */
-    get snapshotRendering() {
-        return false;
-    }
-    set snapshotRendering(activate) {
-        // WebGL engine does not support snapshot rendering
-    }
-    /**
-     * Gets or sets the snapshot rendering mode
-     */
-    get snapshotRenderingMode() {
-        return this._snapshotRenderingMode;
-    }
-    set snapshotRenderingMode(mode) {
-        this._snapshotRenderingMode = mode;
-    }
-    /**
-     * Gets a boolean indicating if the exact sRGB conversions or faster approximations are used for converting to and from linear space.
-     */
-    get useExactSrgbConversions() {
-        return this._useExactSrgbConversions;
-    }
-    /**
-     * Creates a new snapshot at the next frame using the current snapshotRenderingMode
-     */
-    snapshotRenderingReset() {
-        this.snapshotRendering = false;
-    }
-    static _CreateCanvas(width, height) {
-        if (typeof document === "undefined") {
-            return new OffscreenCanvas(width, height);
-        }
-        const canvas = document.createElement("canvas");
-        canvas.width = width;
-        canvas.height = height;
-        return canvas;
-    }
-    /**
-     * Create a canvas. This method is overridden by other engines
-     * @param width width
-     * @param height height
-     * @returns ICanvas interface
-     */
-    createCanvas(width, height) {
-        return ThinEngine._CreateCanvas(width, height);
-    }
-    /**
-     * Create an image to use with canvas
-     * @returns IImage interface
-     */
-    createCanvasImage() {
-        return document.createElement("img");
-    }
     _restoreEngineAfterContextLost(initEngine) {
         // Adding a timeout to avoid race condition at browser level
         setTimeout(async () => {