@babylonjs/core 6.33.2 → 6.34.0-alpha.0

package/esm/Engines/Extensions/query/query.base.d.ts

@@ -0,0 +1,164 @@
+import type { Nullable, int } from "../../../../types.js";
+import type { Observer } from "../../../../Misc/observable.js";
+import { PerfCounter } from "../../../../Misc/perfCounter.js";
+import type { _TimeToken } from "../../../../Instrumentation/timeToken.js";
+import type { IBaseEnginePublic } from "../../engine.base";
+/** @internal */
+export type OcclusionQuery = WebGLQuery | number;
+/** @internal */
+export declare class _OcclusionDataStorage {
+    /** @internal */
+    occlusionInternalRetryCounter: number;
+    /** @internal */
+    isOcclusionQueryInProgress: boolean;
+    /** @internal */
+    isOccluded: boolean;
+    /** @internal */
+    occlusionRetryCount: number;
+    /** @internal */
+    occlusionType: number;
+    /** @internal */
+    occlusionQueryAlgorithmType: number;
+    /** @internal */
+    forceRenderingWhenOccluded: boolean;
+}
+export interface IQueryExtensionState {
+    /** @internal */
+    _currentNonTimestampToken: Nullable<_TimeToken>;
+    /** @internal */
+    _captureGPUFrameTime: boolean;
+    /** @internal */
+    _gpuFrameTimeToken: Nullable<_TimeToken>;
+    /** @internal */
+    _gpuFrameTime: PerfCounter;
+    /** @internal */
+    _onBeginFrameObserver: Nullable<Observer<IBaseEnginePublic>>;
+    /** @internal */
+    _onEndFrameObserver: Nullable<Observer<IBaseEnginePublic>>;
+}
+export interface IQueryEngineExtension {
+    /**
+     * Create a new webGL query (you must be sure that queries are supported by checking getCaps() function)
+     * @returns the new query
+     */
+    createQuery(engineState: IBaseEnginePublic): OcclusionQuery;
+    /**
+     * Delete and release a webGL query
+     * @param query defines the query to delete
+     * @returns the current engine
+     */
+    deleteQuery(engineState: IBaseEnginePublic, query: OcclusionQuery): IBaseEnginePublic;
+    /**
+     * Check if a given query has resolved and got its value
+     * @param query defines the query to check
+     * @returns true if the query got its value
+     */
+    isQueryResultAvailable(engineState: IBaseEnginePublic, query: OcclusionQuery): boolean;
+    /**
+     * Gets the value of a given query
+     * @param query defines the query to check
+     * @returns the value of the query
+     */
+    getQueryResult(engineState: IBaseEnginePublic, query: OcclusionQuery): number;
+    /**
+     * Initiates an occlusion query
+     * @param algorithmType defines the algorithm to use
+     * @param query defines the query to use
+     * @returns the current engine
+     * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries
+     */
+    beginOcclusionQuery(engineState: IBaseEnginePublic, algorithmType: number, query: OcclusionQuery): boolean;
+    /**
+     * Ends an occlusion query
+     * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries
+     * @param algorithmType defines the algorithm to use
+     * @returns the current engine
+     */
+    endOcclusionQuery(engineState: IBaseEnginePublic, algorithmType: number): IBaseEnginePublic;
+    /**
+     * Starts a time query (used to measure time spent by the GPU on a specific frame)
+     * Please note that only one query can be issued at a time
+     * @returns a time token used to track the time span
+     */
+    startTimeQuery(engineState: IBaseEnginePublic): Nullable<_TimeToken>;
+    /**
+     * Ends a time query
+     * @param token defines the token used to measure the time span
+     * @returns the time spent (in ns)
+     */
+    endTimeQuery(engineState: IBaseEnginePublic, token: _TimeToken): int;
+    /**
+     * Get the performance counter associated with the frame time computation
+     * @returns the perf counter
+     */
+    getGPUFrameTimeCounter(engineState: IBaseEnginePublic): PerfCounter;
+    /**
+     * Enable or disable the GPU frame time capture
+     * @param value True to enable, false to disable
+     */
+    captureGPUFrameTime(engineState: IBaseEnginePublic, value: boolean): void;
+    /** @internal */
+    _createTimeQuery(engineState: IBaseEnginePublic): WebGLQuery;
+    /** @internal */
+    _deleteTimeQuery(engineState: IBaseEnginePublic, query: WebGLQuery): void;
+    /** @internal */
+    _getGlAlgorithmType(engineState: IBaseEnginePublic, algorithmType: number): number;
+    /** @internal */
+    _getTimeQueryResult(engineState: IBaseEnginePublic, query: WebGLQuery): any;
+    /** @internal */
+    _getTimeQueryAvailability(engineState: IBaseEnginePublic, query: WebGLQuery): any;
+}
+export declare function initQuesryState(engineState: IBaseEnginePublic): void;
+declare module "core/Meshes/abstractMesh.js" {
+    interface AbstractMesh {
+        /**
+         * Backing filed
+         * @internal
+         */
+        __occlusionDataStorage: _OcclusionDataStorage;
+        /**
+         * Access property
+         * @internal
+         */
+        _occlusionDataStorage: _OcclusionDataStorage;
+        /**
+         * this number indicates the number of allowed retries before stop the occlusion query, this is useful if the occlusion query is taking long time before to the query result is retrieved, the query result indicates if the object is visible within the scene or not and based on that Babylon.Js engine decides to show or hide the object.
+         * The default value is -1 which means don't break the query and wait till the result
+         * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries
+         */
+        occlusionRetryCount: number;
+        /**
+         * fes property is responsible for starting the occlusion query within the Mesh or not, fes property is also used to determine what should happen when the occlusionRetryCount is reached. It has supports 3 values:
+         * * OCCLUSION_TYPE_NONE (Default Value): fes option means no occlusion query within the Mesh.
+         * * OCCLUSION_TYPE_OPTIMISTIC: fes option is means use occlusion query and if occlusionRetryCount is reached and the query is broken show the mesh.
+         * * OCCLUSION_TYPE_STRICT: fes option is means use occlusion query and if occlusionRetryCount is reached and the query is broken restore the last state of the mesh occlusion if the mesh was visible then show the mesh if was hidden then hide don't show.
+         * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries
+         */
+        occlusionType: number;
+        /**
+         * fes property determines the type of occlusion query algorithm to run in WebGl, you can use:
+         * * AbstractMesh.OCCLUSION_ALGORITHM_TYPE_ACCURATE which is mapped to GL_ANY_SAMPLES_PASSED.
+         * * AbstractMesh.OCCLUSION_ALGORITHM_TYPE_CONSERVATIVE (Default Value) which is mapped to GL_ANY_SAMPLES_PASSED_CONSERVATIVE which is a false positive algorithm that is faster than GL_ANY_SAMPLES_PASSED but less accurate.
+         * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries
+         */
+        occlusionQueryAlgorithmType: number;
+        /**
+         * Gets or sets whether the mesh is occluded or not, it is used also to set the initial state of the mesh to be occluded or not
+         * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries
+         */
+        isOccluded: boolean;
+        /**
+         * Flag to check the progress status of the query
+         * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries
+         */
+        isOcclusionQueryInProgress: boolean;
+        /**
+         * Flag to force rendering the mesh even if occluded
+         * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries
+         */
+        forceRenderingWhenOccluded: boolean;
+    }
+}
+export declare const initQueryExtension: (extensionImplementation: IQueryEngineExtension, engineState: IBaseEnginePublic) => void;
+/** @internal */
+export declare const _getExtensionState: (engineState: IBaseEnginePublic) => IQueryExtensionState;

package/esm/Engines/Extensions/query/query.base.js

@@ -0,0 +1,168 @@
+import { PerfCounter } from "../../../../Misc/perfCounter.js";
+import { AbstractMesh } from "../../../../Meshes/abstractMesh.js";
+/** @internal */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export class _OcclusionDataStorage {
+    constructor() {
+        /** @internal */
+        this.occlusionInternalRetryCounter = 0;
+        /** @internal */
+        this.isOcclusionQueryInProgress = false;
+        /** @internal */
+        this.isOccluded = false;
+        /** @internal */
+        this.occlusionRetryCount = -1;
+        /** @internal */
+        this.occlusionType = AbstractMesh.OCCLUSION_TYPE_NONE; // TODO move to Constants. Not urgent, as AbstractMesh is being imported here anyway
+        /** @internal */
+        this.occlusionQueryAlgorithmType = AbstractMesh.OCCLUSION_ALGORITHM_TYPE_CONSERVATIVE; // TODO same as above
+        /** @internal */
+        this.forceRenderingWhenOccluded = false;
+    }
+}
+export function initQuesryState(engineState) { }
+export const initQueryExtension = (extensionImplementation, engineState) => {
+    if (AbstractMesh.prototype._occlusionDataStorage) {
+        return;
+    }
+    Object.defineProperty(AbstractMesh.prototype, "isOcclusionQueryInProgress", {
+        get: function () {
+            return this._occlusionDataStorage.isOcclusionQueryInProgress;
+        },
+        set: function (value) {
+            this._occlusionDataStorage.isOcclusionQueryInProgress = value;
+        },
+        enumerable: false,
+        configurable: true,
+    });
+    Object.defineProperty(AbstractMesh.prototype, "_occlusionDataStorage", {
+        get: function () {
+            if (!this.__occlusionDataStorage) {
+                this.__occlusionDataStorage = new _OcclusionDataStorage();
+            }
+            return this.__occlusionDataStorage;
+        },
+        enumerable: false,
+        configurable: true,
+    });
+    Object.defineProperty(AbstractMesh.prototype, "isOccluded", {
+        get: function () {
+            return this._occlusionDataStorage.isOccluded;
+        },
+        set: function (value) {
+            this._occlusionDataStorage.isOccluded = value;
+        },
+        enumerable: true,
+        configurable: true,
+    });
+    Object.defineProperty(AbstractMesh.prototype, "occlusionQueryAlgorithmType", {
+        get: function () {
+            return this._occlusionDataStorage.occlusionQueryAlgorithmType;
+        },
+        set: function (value) {
+            this._occlusionDataStorage.occlusionQueryAlgorithmType = value;
+        },
+        enumerable: true,
+        configurable: true,
+    });
+    Object.defineProperty(AbstractMesh.prototype, "occlusionType", {
+        get: function () {
+            return this._occlusionDataStorage.occlusionType;
+        },
+        set: function (value) {
+            this._occlusionDataStorage.occlusionType = value;
+        },
+        enumerable: true,
+        configurable: true,
+    });
+    Object.defineProperty(AbstractMesh.prototype, "occlusionRetryCount", {
+        get: function () {
+            return this._occlusionDataStorage.occlusionRetryCount;
+        },
+        set: function (value) {
+            this._occlusionDataStorage.occlusionRetryCount = value;
+        },
+        enumerable: true,
+        configurable: true,
+    });
+    Object.defineProperty(AbstractMesh.prototype, "forceRenderingWhenOccluded", {
+        get: function () {
+            return this._occlusionDataStorage.forceRenderingWhenOccluded;
+        },
+        set: function (value) {
+            this._occlusionDataStorage.forceRenderingWhenOccluded = value;
+        },
+        enumerable: true,
+        configurable: true,
+    });
+    // We also need to update AbstractMesh as there is a portion of the code there
+    AbstractMesh.prototype._checkOcclusionQuery = function () {
+        const dataStorage = this._occlusionDataStorage;
+        if (dataStorage.occlusionType === AbstractMesh.OCCLUSION_TYPE_NONE) {
+            dataStorage.isOccluded = false;
+            return false;
+        }
+        const engine = this.getEngine();
+        if (!engine.getCaps().supportOcclusionQuery) {
+            dataStorage.isOccluded = false;
+            return false;
+        }
+        if (!extensionImplementation.isQueryResultAvailable) {
+            // Occlusion query where not referenced
+            dataStorage.isOccluded = false;
+            return false;
+        }
+        if (this.isOcclusionQueryInProgress && this._occlusionQuery !== null && this._occlusionQuery !== undefined) {
+            const isOcclusionQueryAvailable = extensionImplementation.isQueryResultAvailable(engineState, this._occlusionQuery);
+            if (isOcclusionQueryAvailable) {
+                const occlusionQueryResult = extensionImplementation.getQueryResult(engineState, this._occlusionQuery);
+                dataStorage.isOcclusionQueryInProgress = false;
+                dataStorage.occlusionInternalRetryCounter = 0;
+                dataStorage.isOccluded = occlusionQueryResult > 0 ? false : true;
+            }
+            else {
+                dataStorage.occlusionInternalRetryCounter++;
+                if (dataStorage.occlusionRetryCount !== -1 && dataStorage.occlusionInternalRetryCounter > dataStorage.occlusionRetryCount) {
+                    dataStorage.isOcclusionQueryInProgress = false;
+                    dataStorage.occlusionInternalRetryCounter = 0;
+                    // if optimistic set isOccluded to false regardless of the status of isOccluded. (Render in the current render loop)
+                    // if strict continue the last state of the object.
+                    dataStorage.isOccluded = dataStorage.occlusionType === AbstractMesh.OCCLUSION_TYPE_OPTIMISTIC ? false : dataStorage.isOccluded;
+                }
+                else {
+                    return dataStorage.occlusionType === AbstractMesh.OCCLUSION_TYPE_OPTIMISTIC ? false : dataStorage.isOccluded;
+                }
+            }
+        }
+        const scene = this.getScene();
+        // TODO this is a mater of types. importing the types would be wrong here, and therefore the scene is being casted to any
+        if (scene.getBoundingBoxRenderer) {
+            const occlusionBoundingBoxRenderer = scene.getBoundingBoxRenderer();
+            if (this._occlusionQuery === null) {
+                this._occlusionQuery = extensionImplementation.createQuery(engineState);
+            }
+            if (extensionImplementation.beginOcclusionQuery(engineState, dataStorage.occlusionQueryAlgorithmType, this._occlusionQuery)) {
+                occlusionBoundingBoxRenderer.renderOcclusionBoundingBox(this);
+                extensionImplementation.endOcclusionQuery(engineState, dataStorage.occlusionQueryAlgorithmType);
+                this._occlusionDataStorage.isOcclusionQueryInProgress = true;
+            }
+        }
+        return dataStorage.isOccluded;
+    };
+};
+const stateObjects = [];
+/** @internal */
+export const _getExtensionState = (engineState) => {
+    if (!stateObjects[engineState.uniqueId]) {
+        stateObjects[engineState.uniqueId] = {
+            _currentNonTimestampToken: null,
+            _captureGPUFrameTime: false,
+            _gpuFrameTimeToken: null,
+            _gpuFrameTime: new PerfCounter(),
+            _onBeginFrameObserver: null,
+            _onEndFrameObserver: null,
+        };
+    }
+    return stateObjects[engineState.uniqueId];
+};
+//# sourceMappingURL=query.base.js.map

package/esm/Engines/Extensions/query/query.base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.base.js","sourceRoot":"","sources":["../../../../../../../dev/core/src/esm/Engines/Extensions/query/query.base.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Nullable, int } from \"core/types\";\r\nimport type { Observer } from \"core/Misc/observable\";\r\nimport { PerfCounter } from \"core/Misc/perfCounter\";\r\nimport type { _TimeToken } from \"core/Instrumentation/timeToken\";\r\nimport type { IBaseEnginePublic } from \"../../engine.base\";\r\nimport { AbstractMesh } from \"core/Meshes/abstractMesh\";\r\n\r\n// TODO there is a breaking change here - returning engine state instead of engine\r\n\r\n/** @internal */\r\nexport type OcclusionQuery = WebGLQuery | number;\r\n\r\n/** @internal */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class _OcclusionDataStorage {\r\n    /** @internal */\r\n    public occlusionInternalRetryCounter = 0;\r\n\r\n    /** @internal */\r\n    public isOcclusionQueryInProgress = false;\r\n\r\n    /** @internal */\r\n    public isOccluded = false;\r\n\r\n    /** @internal */\r\n    public occlusionRetryCount = -1;\r\n\r\n    /** @internal */\r\n    public occlusionType = AbstractMesh.OCCLUSION_TYPE_NONE; // TODO move to Constants. Not urgent, as AbstractMesh is being imported here anyway\r\n\r\n    /** @internal */\r\n    public occlusionQueryAlgorithmType = AbstractMesh.OCCLUSION_ALGORITHM_TYPE_CONSERVATIVE; // TODO same as above\r\n\r\n    /** @internal */\r\n    public forceRenderingWhenOccluded = false;\r\n}\r\n\r\nexport interface IQueryExtensionState {\r\n    /** @internal */\r\n    _currentNonTimestampToken: Nullable<_TimeToken>;\r\n    /** @internal */\r\n    _captureGPUFrameTime: boolean;\r\n    /** @internal */\r\n    _gpuFrameTimeToken: Nullable<_TimeToken>;\r\n    /** @internal */\r\n    _gpuFrameTime: PerfCounter;\r\n    /** @internal */\r\n    _onBeginFrameObserver: Nullable<Observer<IBaseEnginePublic>>;\r\n    /** @internal */\r\n    _onEndFrameObserver: Nullable<Observer<IBaseEnginePublic>>;\r\n}\r\n\r\nexport interface IQueryEngineExtension {\r\n    /**\r\n     * Create a new webGL query (you must be sure that queries are supported by checking getCaps() function)\r\n     * @returns the new query\r\n     */\r\n    createQuery(engineState: IBaseEnginePublic): OcclusionQuery;\r\n\r\n    /**\r\n     * Delete and release a webGL query\r\n     * @param query defines the query to delete\r\n     * @returns the current engine\r\n     */\r\n    deleteQuery(engineState: IBaseEnginePublic, query: OcclusionQuery): IBaseEnginePublic;\r\n\r\n    /**\r\n     * Check if a given query has resolved and got its value\r\n     * @param query defines the query to check\r\n     * @returns true if the query got its value\r\n     */\r\n    isQueryResultAvailable(engineState: IBaseEnginePublic, query: OcclusionQuery): boolean;\r\n\r\n    /**\r\n     * Gets the value of a given query\r\n     * @param query defines the query to check\r\n     * @returns the value of the query\r\n     */\r\n    getQueryResult(engineState: IBaseEnginePublic, query: OcclusionQuery): number;\r\n\r\n    /**\r\n     * Initiates an occlusion query\r\n     * @param algorithmType defines the algorithm to use\r\n     * @param query defines the query to use\r\n     * @returns the current engine\r\n     * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries\r\n     */\r\n    beginOcclusionQuery(engineState: IBaseEnginePublic, algorithmType: number, query: OcclusionQuery): boolean;\r\n\r\n    /**\r\n     * Ends an occlusion query\r\n     * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries\r\n     * @param algorithmType defines the algorithm to use\r\n     * @returns the current engine\r\n     */\r\n    endOcclusionQuery(engineState: IBaseEnginePublic, algorithmType: number): IBaseEnginePublic;\r\n\r\n    /**\r\n     * Starts a time query (used to measure time spent by the GPU on a specific frame)\r\n     * Please note that only one query can be issued at a time\r\n     * @returns a time token used to track the time span\r\n     */\r\n    startTimeQuery(engineState: IBaseEnginePublic): Nullable<_TimeToken>;\r\n\r\n    /**\r\n     * Ends a time query\r\n     * @param token defines the token used to measure the time span\r\n     * @returns the time spent (in ns)\r\n     */\r\n    endTimeQuery(engineState: IBaseEnginePublic, token: _TimeToken): int;\r\n\r\n    /**\r\n     * Get the performance counter associated with the frame time computation\r\n     * @returns the perf counter\r\n     */\r\n    getGPUFrameTimeCounter(engineState: IBaseEnginePublic): PerfCounter;\r\n\r\n    /**\r\n     * Enable or disable the GPU frame time capture\r\n     * @param value True to enable, false to disable\r\n     */\r\n    captureGPUFrameTime(engineState: IBaseEnginePublic, value: boolean): void;\r\n\r\n    /** @internal */\r\n    _createTimeQuery(engineState: IBaseEnginePublic): WebGLQuery;\r\n\r\n    /** @internal */\r\n    _deleteTimeQuery(engineState: IBaseEnginePublic, query: WebGLQuery): void;\r\n\r\n    /** @internal */\r\n    _getGlAlgorithmType(engineState: IBaseEnginePublic, algorithmType: number): number;\r\n\r\n    /** @internal */\r\n    _getTimeQueryResult(engineState: IBaseEnginePublic, query: WebGLQuery): any;\r\n\r\n    /** @internal */\r\n    _getTimeQueryAvailability(engineState: IBaseEnginePublic, query: WebGLQuery): any;\r\n}\r\n\r\nexport function initQuesryState(engineState: IBaseEnginePublic): void {}\r\n\r\ndeclare module \"core/Meshes/abstractMesh.js\" {\r\n    export interface AbstractMesh {\r\n        /**\r\n         * Backing filed\r\n         * @internal\r\n         */\r\n        // eslint-disable-next-line @typescript-eslint/naming-convention\r\n        __occlusionDataStorage: _OcclusionDataStorage;\r\n\r\n        /**\r\n         * Access property\r\n         * @internal\r\n         */\r\n        _occlusionDataStorage: _OcclusionDataStorage;\r\n\r\n        /**\r\n         * this number indicates the number of allowed retries before stop the occlusion query, this is useful if the occlusion query is taking long time before to the query result is retrieved, the query result indicates if the object is visible within the scene or not and based on that Babylon.Js engine decides to show or hide the object.\r\n         * The default value is -1 which means don't break the query and wait till the result\r\n         * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries\r\n         */\r\n        occlusionRetryCount: number;\r\n\r\n        /**\r\n         * fes property is responsible for starting the occlusion query within the Mesh or not, fes property is also used to determine what should happen when the occlusionRetryCount is reached. It has supports 3 values:\r\n         * * OCCLUSION_TYPE_NONE (Default Value): fes option means no occlusion query within the Mesh.\r\n         * * OCCLUSION_TYPE_OPTIMISTIC: fes option is means use occlusion query and if occlusionRetryCount is reached and the query is broken show the mesh.\r\n         * * OCCLUSION_TYPE_STRICT: fes option is means use occlusion query and if occlusionRetryCount is reached and the query is broken restore the last state of the mesh occlusion if the mesh was visible then show the mesh if was hidden then hide don't show.\r\n         * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries\r\n         */\r\n        occlusionType: number;\r\n\r\n        /**\r\n         * fes property determines the type of occlusion query algorithm to run in WebGl, you can use:\r\n         * * AbstractMesh.OCCLUSION_ALGORITHM_TYPE_ACCURATE which is mapped to GL_ANY_SAMPLES_PASSED.\r\n         * * AbstractMesh.OCCLUSION_ALGORITHM_TYPE_CONSERVATIVE (Default Value) which is mapped to GL_ANY_SAMPLES_PASSED_CONSERVATIVE which is a false positive algorithm that is faster than GL_ANY_SAMPLES_PASSED but less accurate.\r\n         * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries\r\n         */\r\n        occlusionQueryAlgorithmType: number;\r\n\r\n        /**\r\n         * Gets or sets whether the mesh is occluded or not, it is used also to set the initial state of the mesh to be occluded or not\r\n         * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries\r\n         */\r\n        isOccluded: boolean;\r\n\r\n        /**\r\n         * Flag to check the progress status of the query\r\n         * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries\r\n         */\r\n        isOcclusionQueryInProgress: boolean;\r\n\r\n        /**\r\n         * Flag to force rendering the mesh even if occluded\r\n         * @see https://doc.babylonjs.com/features/featuresDeepDive/occlusionQueries\r\n         */\r\n        forceRenderingWhenOccluded: boolean;\r\n    }\r\n}\r\n\r\nexport const initQueryExtension = (extensionImplementation: IQueryEngineExtension, engineState: IBaseEnginePublic) => {\r\n    if (AbstractMesh.prototype._occlusionDataStorage) {\r\n        return;\r\n    }\r\n    Object.defineProperty(AbstractMesh.prototype, \"isOcclusionQueryInProgress\", {\r\n        get: function (this: AbstractMesh) {\r\n            return this._occlusionDataStorage.isOcclusionQueryInProgress;\r\n        },\r\n        set: function (this: AbstractMesh, value: boolean) {\r\n            this._occlusionDataStorage.isOcclusionQueryInProgress = value;\r\n        },\r\n        enumerable: false,\r\n        configurable: true,\r\n    });\r\n\r\n    Object.defineProperty(AbstractMesh.prototype, \"_occlusionDataStorage\", {\r\n        get: function (this: AbstractMesh) {\r\n            if (!this.__occlusionDataStorage) {\r\n                this.__occlusionDataStorage = new _OcclusionDataStorage();\r\n            }\r\n            return this.__occlusionDataStorage;\r\n        },\r\n        enumerable: false,\r\n        configurable: true,\r\n    });\r\n\r\n    Object.defineProperty(AbstractMesh.prototype, \"isOccluded\", {\r\n        get: function (this: AbstractMesh) {\r\n            return this._occlusionDataStorage.isOccluded;\r\n        },\r\n        set: function (this: AbstractMesh, value: boolean) {\r\n            this._occlusionDataStorage.isOccluded = value;\r\n        },\r\n        enumerable: true,\r\n        configurable: true,\r\n    });\r\n\r\n    Object.defineProperty(AbstractMesh.prototype, \"occlusionQueryAlgorithmType\", {\r\n        get: function (this: AbstractMesh) {\r\n            return this._occlusionDataStorage.occlusionQueryAlgorithmType;\r\n        },\r\n        set: function (this: AbstractMesh, value: number) {\r\n            this._occlusionDataStorage.occlusionQueryAlgorithmType = value;\r\n        },\r\n        enumerable: true,\r\n        configurable: true,\r\n    });\r\n\r\n    Object.defineProperty(AbstractMesh.prototype, \"occlusionType\", {\r\n        get: function (this: AbstractMesh) {\r\n            return this._occlusionDataStorage.occlusionType;\r\n        },\r\n        set: function (this: AbstractMesh, value: number) {\r\n            this._occlusionDataStorage.occlusionType = value;\r\n        },\r\n        enumerable: true,\r\n        configurable: true,\r\n    });\r\n\r\n    Object.defineProperty(AbstractMesh.prototype, \"occlusionRetryCount\", {\r\n        get: function (this: AbstractMesh) {\r\n            return this._occlusionDataStorage.occlusionRetryCount;\r\n        },\r\n        set: function (this: AbstractMesh, value: number) {\r\n            this._occlusionDataStorage.occlusionRetryCount = value;\r\n        },\r\n        enumerable: true,\r\n        configurable: true,\r\n    });\r\n\r\n    Object.defineProperty(AbstractMesh.prototype, \"forceRenderingWhenOccluded\", {\r\n        get: function (this: AbstractMesh) {\r\n            return this._occlusionDataStorage.forceRenderingWhenOccluded;\r\n        },\r\n        set: function (this: AbstractMesh, value: boolean) {\r\n            this._occlusionDataStorage.forceRenderingWhenOccluded = value;\r\n        },\r\n        enumerable: true,\r\n        configurable: true,\r\n    });\r\n\r\n    // We also need to update AbstractMesh as there is a portion of the code there\r\n    AbstractMesh.prototype._checkOcclusionQuery = function () {\r\n        const dataStorage = this._occlusionDataStorage;\r\n\r\n        if (dataStorage.occlusionType === AbstractMesh.OCCLUSION_TYPE_NONE) {\r\n            dataStorage.isOccluded = false;\r\n            return false;\r\n        }\r\n\r\n        const engine = this.getEngine();\r\n\r\n        if (!engine.getCaps().supportOcclusionQuery) {\r\n            dataStorage.isOccluded = false;\r\n            return false;\r\n        }\r\n\r\n        if (!extensionImplementation.isQueryResultAvailable) {\r\n            // Occlusion query where not referenced\r\n            dataStorage.isOccluded = false;\r\n            return false;\r\n        }\r\n\r\n        if (this.isOcclusionQueryInProgress && this._occlusionQuery !== null && this._occlusionQuery !== undefined) {\r\n            const isOcclusionQueryAvailable = extensionImplementation.isQueryResultAvailable(engineState, this._occlusionQuery);\r\n            if (isOcclusionQueryAvailable) {\r\n                const occlusionQueryResult = extensionImplementation.getQueryResult(engineState, this._occlusionQuery);\r\n\r\n                dataStorage.isOcclusionQueryInProgress = false;\r\n                dataStorage.occlusionInternalRetryCounter = 0;\r\n                dataStorage.isOccluded = occlusionQueryResult > 0 ? false : true;\r\n            } else {\r\n                dataStorage.occlusionInternalRetryCounter++;\r\n\r\n                if (dataStorage.occlusionRetryCount !== -1 && dataStorage.occlusionInternalRetryCounter > dataStorage.occlusionRetryCount) {\r\n                    dataStorage.isOcclusionQueryInProgress = false;\r\n                    dataStorage.occlusionInternalRetryCounter = 0;\r\n\r\n                    // if optimistic set isOccluded to false regardless of the status of isOccluded. (Render in the current render loop)\r\n                    // if strict continue the last state of the object.\r\n                    dataStorage.isOccluded = dataStorage.occlusionType === AbstractMesh.OCCLUSION_TYPE_OPTIMISTIC ? false : dataStorage.isOccluded;\r\n                } else {\r\n                    return dataStorage.occlusionType === AbstractMesh.OCCLUSION_TYPE_OPTIMISTIC ? false : dataStorage.isOccluded;\r\n                }\r\n            }\r\n        }\r\n\r\n        const scene = this.getScene();\r\n        // TODO this is a mater of types. importing the types would be wrong here, and therefore the scene is being casted to any\r\n        if ((scene as any).getBoundingBoxRenderer) {\r\n            const occlusionBoundingBoxRenderer = (scene as any).getBoundingBoxRenderer();\r\n\r\n            if (this._occlusionQuery === null) {\r\n                this._occlusionQuery = extensionImplementation.createQuery(engineState);\r\n            }\r\n\r\n            if (extensionImplementation.beginOcclusionQuery(engineState, dataStorage.occlusionQueryAlgorithmType, this._occlusionQuery)) {\r\n                occlusionBoundingBoxRenderer.renderOcclusionBoundingBox(this);\r\n                extensionImplementation.endOcclusionQuery(engineState, dataStorage.occlusionQueryAlgorithmType);\r\n                this._occlusionDataStorage.isOcclusionQueryInProgress = true;\r\n            }\r\n        }\r\n\r\n        return dataStorage.isOccluded;\r\n    };\r\n};\r\n\r\nconst stateObjects: IQueryExtensionState[] = [];\r\n\r\n/** @internal */\r\nexport const _getExtensionState = (engineState: IBaseEnginePublic): IQueryExtensionState => {\r\n    if (!stateObjects[engineState.uniqueId]) {\r\n        stateObjects[engineState.uniqueId] = {\r\n            _currentNonTimestampToken: null,\r\n            _captureGPUFrameTime: false,\r\n            _gpuFrameTimeToken: null,\r\n            _gpuFrameTime: new PerfCounter(),\r\n            _onBeginFrameObserver: null,\r\n            _onEndFrameObserver: null,\r\n        };\r\n    }\r\n    return stateObjects[engineState.uniqueId];\r\n};\r\n"]}

package/esm/Engines/Extensions/rawTexture/engine.rawTexture.base.d.ts

@@ -0,0 +1,187 @@
+import type { InternalTexture } from "../../../../Materials/Textures/internalTexture.js";
+import type { Scene } from "../../../../scene.js";
+import type { Nullable } from "../../../../types.js";
+import type { IBaseEnginePublic } from "../../engine.base";
+/**
+ * Defines the extension for the engine to create additional internal texture formats
+ */
+export interface IRawTextureEngineExtension {
+    /**
+     * Creates a raw texture
+     * @param data defines the data to store in the texture
+     * @param width defines the width of the texture
+     * @param height defines the height of the texture
+     * @param format defines the format of the data
+     * @param generateMipMaps defines if the engine should generate the mip levels
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param samplingMode defines the required sampling mode (Texture.NEAREST_SAMPLINGMODE by default)
+     * @param compression defines the compression used (null by default)
+     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)
+     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)
+     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).
+     * @returns the raw texture inside an InternalTexture
+     */
+    createRawTexture(engineState: IBaseEnginePublic, data: Nullable<ArrayBufferView>, width: number, height: number, format: number, generateMipMaps: boolean, invertY: boolean, samplingMode: number, compression?: Nullable<string>, type?: number, creationFlags?: number, useSRGBBuffer?: boolean): InternalTexture;
+    /**
+     * Update a raw texture
+     * @param texture defines the texture to update
+     * @param data defines the data to store in the texture
+     * @param format defines the format of the data
+     * @param invertY defines if data must be stored with Y axis inverted
+     */
+    updateRawTexture(engineState: IBaseEnginePublic, texture: Nullable<InternalTexture>, data: Nullable<ArrayBufferView>, format: number, invertY: boolean): void;
+    /**
+     * Update a raw texture
+     * @param texture defines the texture to update
+     * @param data defines the data to store in the texture
+     * @param format defines the format of the data
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param compression defines the compression used (null by default)
+     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)
+     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).
+     */
+    updateRawTexture(engineState: IBaseEnginePublic, texture: Nullable<InternalTexture>, data: Nullable<ArrayBufferView>, format: number, invertY: boolean, compression: Nullable<string>, type: number, useSRGBBuffer: boolean): void;
+    /**
+     * Creates a new raw cube texture
+     * @param data defines the array of data to use to create each face
+     * @param size defines the size of the textures
+     * @param format defines the format of the data
+     * @param type defines the type of the data (like Engine.TEXTURETYPE_UNSIGNED_INT)
+     * @param generateMipMaps  defines if the engine should generate the mip levels
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)
+     * @param compression defines the compression used (null by default)
+     * @returns the cube texture as an InternalTexture
+     */
+    createRawCubeTexture(engineState: IBaseEnginePublic, data: Nullable<ArrayBufferView[]>, size: number, format: number, type: number, generateMipMaps: boolean, invertY: boolean, samplingMode: number, compression?: Nullable<string>): InternalTexture;
+    /**
+     * Update a raw cube texture
+     * @param texture defines the texture to update
+     * @param data defines the data to store
+     * @param format defines the data format
+     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)
+     * @param invertY defines if data must be stored with Y axis inverted
+     */
+    updateRawCubeTexture(engineState: IBaseEnginePublic, texture: InternalTexture, data: ArrayBufferView[], format: number, type: number, invertY: boolean): void;
+    /**
+     * Update a raw cube texture
+     * @param texture defines the texture to update
+     * @param data defines the data to store
+     * @param format defines the data format
+     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param compression defines the compression used (null by default)
+     */
+    updateRawCubeTexture(engineState: IBaseEnginePublic, texture: InternalTexture, data: ArrayBufferView[], format: number, type: number, invertY: boolean, compression: Nullable<string>): void;
+    /**
+     * Update a raw cube texture
+     * @param texture defines the texture to update
+     * @param data defines the data to store
+     * @param format defines the data format
+     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param compression defines the compression used (null by default)
+     * @param level defines which level of the texture to update
+     */
+    updateRawCubeTexture(engineState: IBaseEnginePublic, texture: InternalTexture, data: ArrayBufferView[], format: number, type: number, invertY: boolean, compression: Nullable<string>, level: number): void;
+    /**
+     * Creates a new raw cube texture from a specified url
+     * @param url defines the url where the data is located
+     * @param scene defines the current scene
+     * @param size defines the size of the textures
+     * @param format defines the format of the data
+     * @param type defines the type fo the data (like Engine.TEXTURETYPE_UNSIGNED_INT)
+     * @param noMipmap defines if the engine should avoid generating the mip levels
+     * @param callback defines a callback used to extract texture data from loaded data
+     * @param mipmapGenerator defines to provide an optional tool to generate mip levels
+     * @param onLoad defines a callback called when texture is loaded
+     * @param onError defines a callback called if there is an error
+     * @returns the cube texture as an InternalTexture
+     */
+    createRawCubeTextureFromUrl(engineState: IBaseEnginePublic, url: string, scene: Nullable<Scene>, size: number, format: number, type: number, noMipmap: boolean, callback: (ArrayBuffer: ArrayBuffer) => Nullable<ArrayBufferView[]>, mipmapGenerator: Nullable<(faces: ArrayBufferView[]) => ArrayBufferView[][]>, onLoad: Nullable<() => void>, onError: Nullable<(message?: string, exception?: any) => void>): InternalTexture;
+    /**
+     * Creates a new raw cube texture from a specified url
+     * @param url defines the url where the data is located
+     * @param scene defines the current scene
+     * @param size defines the size of the textures
+     * @param format defines the format of the data
+     * @param type defines the type fo the data (like Engine.TEXTURETYPE_UNSIGNED_INT)
+     * @param noMipmap defines if the engine should avoid generating the mip levels
+     * @param callback defines a callback used to extract texture data from loaded data
+     * @param mipmapGenerator defines to provide an optional tool to generate mip levels
+     * @param onLoad defines a callback called when texture is loaded
+     * @param onError defines a callback called if there is an error
+     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @returns the cube texture as an InternalTexture
+     */
+    createRawCubeTextureFromUrl(engineState: IBaseEnginePublic, url: string, scene: Nullable<Scene>, size: number, format: number, type: number, noMipmap: boolean, callback: (ArrayBuffer: ArrayBuffer) => Nullable<ArrayBufferView[]>, mipmapGenerator: Nullable<(faces: ArrayBufferView[]) => ArrayBufferView[][]>, onLoad: Nullable<() => void>, onError: Nullable<(message?: string, exception?: any) => void>, samplingMode: number, invertY: boolean): InternalTexture;
+    /**
+     * Creates a new raw 3D texture
+     * @param data defines the data used to create the texture
+     * @param width defines the width of the texture
+     * @param height defines the height of the texture
+     * @param depth defines the depth of the texture
+     * @param format defines the format of the texture
+     * @param generateMipMaps defines if the engine must generate mip levels
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)
+     * @param compression defines the compressed used (can be null)
+     * @param textureType defines the compressed used (can be null)
+     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)
+     * @returns a new raw 3D texture (stored in an InternalTexture)
+     */
+    createRawTexture3D(engineState: IBaseEnginePublic, data: Nullable<ArrayBufferView>, width: number, height: number, depth: number, format: number, generateMipMaps: boolean, invertY: boolean, samplingMode: number, compression?: Nullable<string>, textureType?: number, creationFlags?: number): InternalTexture;
+    /**
+     * Update a raw 3D texture
+     * @param texture defines the texture to update
+     * @param data defines the data to store
+     * @param format defines the data format
+     * @param invertY defines if data must be stored with Y axis inverted
+     */
+    updateRawTexture3D(engineState: IBaseEnginePublic, texture: InternalTexture, data: Nullable<ArrayBufferView>, format: number, invertY: boolean): void;
+    /**
+     * Update a raw 3D texture
+     * @param texture defines the texture to update
+     * @param data defines the data to store
+     * @param format defines the data format
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param compression defines the used compression (can be null)
+     * @param textureType defines the texture Type (Engine.TEXTURETYPE_UNSIGNED_INT, Engine.TEXTURETYPE_FLOAT...)
+     */
+    updateRawTexture3D(engineState: IBaseEnginePublic, texture: InternalTexture, data: Nullable<ArrayBufferView>, format: number, invertY: boolean, compression: Nullable<string>, textureType: number): void;
+    /**
+     * Creates a new raw 2D array texture
+     * @param data defines the data used to create the texture
+     * @param width defines the width of the texture
+     * @param height defines the height of the texture
+     * @param depth defines the number of layers of the texture
+     * @param format defines the format of the texture
+     * @param generateMipMaps defines if the engine must generate mip levels
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)
+     * @param compression defines the compressed used (can be null)
+     * @param textureType defines the compressed used (can be null)
+     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)
+     * @returns a new raw 2D array texture (stored in an InternalTexture)
+     */
+    createRawTexture2DArray(engineState: IBaseEnginePublic, data: Nullable<ArrayBufferView>, width: number, height: number, depth: number, format: number, generateMipMaps: boolean, invertY: boolean, samplingMode: number, compression?: Nullable<string>, textureType?: number, creationFlags?: number): InternalTexture;
+    /**
+     * Update a raw 2D array texture
+     * @param texture defines the texture to update
+     * @param data defines the data to store
+     * @param format defines the data format
+     * @param invertY defines if data must be stored with Y axis inverted
+     */
+    updateRawTexture2DArray(engineState: IBaseEnginePublic, texture: InternalTexture, data: Nullable<ArrayBufferView>, format: number, invertY: boolean): void;
+    /**
+     * Update a raw 2D array texture
+     * @param texture defines the texture to update
+     * @param data defines the data to store
+     * @param format defines the data format
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param compression defines the used compression (can be null)
+     * @param textureType defines the texture Type (Engine.TEXTURETYPE_UNSIGNED_INT, Engine.TEXTURETYPE_FLOAT...)
+     */
+    updateRawTexture2DArray(engineState: IBaseEnginePublic, texture: InternalTexture, data: Nullable<ArrayBufferView>, format: number, invertY: boolean, compression: Nullable<string>, textureType: number): void;
+}

package/esm/Engines/Extensions/rawTexture/engine.rawTexture.base.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=engine.rawTexture.base.js.map

package/esm/Engines/Extensions/rawTexture/engine.rawTexture.base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.rawTexture.base.js","sourceRoot":"","sources":["../../../../../../../dev/core/src/esm/Engines/Extensions/rawTexture/engine.rawTexture.base.ts"],"names":[],"mappings":"","sourcesContent":["import type { InternalTexture } from \"core/Materials/Textures/internalTexture\";\r\nimport type { Scene } from \"core/scene\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { IBaseEnginePublic } from \"../../engine.base\";\r\n\r\n/**\r\n * Defines the extension for the engine to create additional internal texture formats\r\n */\r\nexport interface IRawTextureEngineExtension {\r\n    /**\r\n     * Creates a raw texture\r\n     * @param data defines the data to store in the texture\r\n     * @param width defines the width of the texture\r\n     * @param height defines the height of the texture\r\n     * @param format defines the format of the data\r\n     * @param generateMipMaps defines if the engine should generate the mip levels\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     * @param samplingMode defines the required sampling mode (Texture.NEAREST_SAMPLINGMODE by default)\r\n     * @param compression defines the compression used (null by default)\r\n     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)\r\n     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)\r\n     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).\r\n     * @returns the raw texture inside an InternalTexture\r\n     */\r\n    createRawTexture(\r\n        engineState: IBaseEnginePublic,\r\n        data: Nullable<ArrayBufferView>,\r\n        width: number,\r\n        height: number,\r\n        format: number,\r\n        generateMipMaps: boolean,\r\n        invertY: boolean,\r\n        samplingMode: number,\r\n        compression?: Nullable<string>,\r\n        type?: number,\r\n        creationFlags?: number,\r\n        useSRGBBuffer?: boolean\r\n    ): InternalTexture;\r\n\r\n    /**\r\n     * Update a raw texture\r\n     * @param texture defines the texture to update\r\n     * @param data defines the data to store in the texture\r\n     * @param format defines the format of the data\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     */\r\n    updateRawTexture(engineState: IBaseEnginePublic, texture: Nullable<InternalTexture>, data: Nullable<ArrayBufferView>, format: number, invertY: boolean): void;\r\n\r\n    /**\r\n     * Update a raw texture\r\n     * @param texture defines the texture to update\r\n     * @param data defines the data to store in the texture\r\n     * @param format defines the format of the data\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     * @param compression defines the compression used (null by default)\r\n     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)\r\n     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).\r\n     */\r\n    updateRawTexture(\r\n        engineState: IBaseEnginePublic,\r\n        texture: Nullable<InternalTexture>,\r\n        data: Nullable<ArrayBufferView>,\r\n        format: number,\r\n        invertY: boolean,\r\n        compression: Nullable<string>,\r\n        type: number,\r\n        useSRGBBuffer: boolean\r\n    ): void;\r\n\r\n    /**\r\n     * Creates a new raw cube texture\r\n     * @param data defines the array of data to use to create each face\r\n     * @param size defines the size of the textures\r\n     * @param format defines the format of the data\r\n     * @param type defines the type of the data (like Engine.TEXTURETYPE_UNSIGNED_INT)\r\n     * @param generateMipMaps  defines if the engine should generate the mip levels\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)\r\n     * @param compression defines the compression used (null by default)\r\n     * @returns the cube texture as an InternalTexture\r\n     */\r\n    createRawCubeTexture(\r\n        engineState: IBaseEnginePublic,\r\n        data: Nullable<ArrayBufferView[]>,\r\n        size: number,\r\n        format: number,\r\n        type: number,\r\n        generateMipMaps: boolean,\r\n        invertY: boolean,\r\n        samplingMode: number,\r\n        compression?: Nullable<string>\r\n    ): InternalTexture;\r\n\r\n    /**\r\n     * Update a raw cube texture\r\n     * @param texture defines the texture to update\r\n     * @param data defines the data to store\r\n     * @param format defines the data format\r\n     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     */\r\n    updateRawCubeTexture(engineState: IBaseEnginePublic, texture: InternalTexture, data: ArrayBufferView[], format: number, type: number, invertY: boolean): void;\r\n\r\n    /**\r\n     * Update a raw cube texture\r\n     * @param texture defines the texture to update\r\n     * @param data defines the data to store\r\n     * @param format defines the data format\r\n     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     * @param compression defines the compression used (null by default)\r\n     */\r\n    updateRawCubeTexture(\r\n        engineState: IBaseEnginePublic,\r\n        texture: InternalTexture,\r\n        data: ArrayBufferView[],\r\n        format: number,\r\n        type: number,\r\n        invertY: boolean,\r\n        compression: Nullable<string>\r\n    ): void;\r\n\r\n    /**\r\n     * Update a raw cube texture\r\n     * @param texture defines the texture to update\r\n     * @param data defines the data to store\r\n     * @param format defines the data format\r\n     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     * @param compression defines the compression used (null by default)\r\n     * @param level defines which level of the texture to update\r\n     */\r\n    updateRawCubeTexture(\r\n        engineState: IBaseEnginePublic,\r\n        texture: InternalTexture,\r\n        data: ArrayBufferView[],\r\n        format: number,\r\n        type: number,\r\n        invertY: boolean,\r\n        compression: Nullable<string>,\r\n        level: number\r\n    ): void;\r\n\r\n    /**\r\n     * Creates a new raw cube texture from a specified url\r\n     * @param url defines the url where the data is located\r\n     * @param scene defines the current scene\r\n     * @param size defines the size of the textures\r\n     * @param format defines the format of the data\r\n     * @param type defines the type fo the data (like Engine.TEXTURETYPE_UNSIGNED_INT)\r\n     * @param noMipmap defines if the engine should avoid generating the mip levels\r\n     * @param callback defines a callback used to extract texture data from loaded data\r\n     * @param mipmapGenerator defines to provide an optional tool to generate mip levels\r\n     * @param onLoad defines a callback called when texture is loaded\r\n     * @param onError defines a callback called if there is an error\r\n     * @returns the cube texture as an InternalTexture\r\n     */\r\n    createRawCubeTextureFromUrl(\r\n        engineState: IBaseEnginePublic,\r\n        url: string,\r\n        scene: Nullable<Scene>,\r\n        size: number,\r\n        format: number,\r\n        type: number,\r\n        noMipmap: boolean,\r\n        callback: (ArrayBuffer: ArrayBuffer) => Nullable<ArrayBufferView[]>,\r\n        mipmapGenerator: Nullable<(faces: ArrayBufferView[]) => ArrayBufferView[][]>,\r\n        onLoad: Nullable<() => void>,\r\n        onError: Nullable<(message?: string, exception?: any) => void>\r\n    ): InternalTexture;\r\n\r\n    /**\r\n     * Creates a new raw cube texture from a specified url\r\n     * @param url defines the url where the data is located\r\n     * @param scene defines the current scene\r\n     * @param size defines the size of the textures\r\n     * @param format defines the format of the data\r\n     * @param type defines the type fo the data (like Engine.TEXTURETYPE_UNSIGNED_INT)\r\n     * @param noMipmap defines if the engine should avoid generating the mip levels\r\n     * @param callback defines a callback used to extract texture data from loaded data\r\n     * @param mipmapGenerator defines to provide an optional tool to generate mip levels\r\n     * @param onLoad defines a callback called when texture is loaded\r\n     * @param onError defines a callback called if there is an error\r\n     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     * @returns the cube texture as an InternalTexture\r\n     */\r\n    createRawCubeTextureFromUrl(\r\n        engineState: IBaseEnginePublic,\r\n        url: string,\r\n        scene: Nullable<Scene>,\r\n        size: number,\r\n        format: number,\r\n        type: number,\r\n        noMipmap: boolean,\r\n        callback: (ArrayBuffer: ArrayBuffer) => Nullable<ArrayBufferView[]>,\r\n        mipmapGenerator: Nullable<(faces: ArrayBufferView[]) => ArrayBufferView[][]>,\r\n        onLoad: Nullable<() => void>,\r\n        onError: Nullable<(message?: string, exception?: any) => void>,\r\n        samplingMode: number,\r\n        invertY: boolean\r\n    ): InternalTexture;\r\n\r\n    /**\r\n     * Creates a new raw 3D texture\r\n     * @param data defines the data used to create the texture\r\n     * @param width defines the width of the texture\r\n     * @param height defines the height of the texture\r\n     * @param depth defines the depth of the texture\r\n     * @param format defines the format of the texture\r\n     * @param generateMipMaps defines if the engine must generate mip levels\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)\r\n     * @param compression defines the compressed used (can be null)\r\n     * @param textureType defines the compressed used (can be null)\r\n     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)\r\n     * @returns a new raw 3D texture (stored in an InternalTexture)\r\n     */\r\n    createRawTexture3D(\r\n        engineState: IBaseEnginePublic,\r\n        data: Nullable<ArrayBufferView>,\r\n        width: number,\r\n        height: number,\r\n        depth: number,\r\n        format: number,\r\n        generateMipMaps: boolean,\r\n        invertY: boolean,\r\n        samplingMode: number,\r\n        compression?: Nullable<string>,\r\n        textureType?: number,\r\n        creationFlags?: number\r\n    ): InternalTexture;\r\n\r\n    /**\r\n     * Update a raw 3D texture\r\n     * @param texture defines the texture to update\r\n     * @param data defines the data to store\r\n     * @param format defines the data format\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     */\r\n    updateRawTexture3D(engineState: IBaseEnginePublic, texture: InternalTexture, data: Nullable<ArrayBufferView>, format: number, invertY: boolean): void;\r\n\r\n    /**\r\n     * Update a raw 3D texture\r\n     * @param texture defines the texture to update\r\n     * @param data defines the data to store\r\n     * @param format defines the data format\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     * @param compression defines the used compression (can be null)\r\n     * @param textureType defines the texture Type (Engine.TEXTURETYPE_UNSIGNED_INT, Engine.TEXTURETYPE_FLOAT...)\r\n     */\r\n    updateRawTexture3D(\r\n        engineState: IBaseEnginePublic,\r\n        texture: InternalTexture,\r\n        data: Nullable<ArrayBufferView>,\r\n        format: number,\r\n        invertY: boolean,\r\n        compression: Nullable<string>,\r\n        textureType: number\r\n    ): void;\r\n\r\n    /**\r\n     * Creates a new raw 2D array texture\r\n     * @param data defines the data used to create the texture\r\n     * @param width defines the width of the texture\r\n     * @param height defines the height of the texture\r\n     * @param depth defines the number of layers of the texture\r\n     * @param format defines the format of the texture\r\n     * @param generateMipMaps defines if the engine must generate mip levels\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)\r\n     * @param compression defines the compressed used (can be null)\r\n     * @param textureType defines the compressed used (can be null)\r\n     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)\r\n     * @returns a new raw 2D array texture (stored in an InternalTexture)\r\n     */\r\n    createRawTexture2DArray(\r\n        engineState: IBaseEnginePublic,\r\n        data: Nullable<ArrayBufferView>,\r\n        width: number,\r\n        height: number,\r\n        depth: number,\r\n        format: number,\r\n        generateMipMaps: boolean,\r\n        invertY: boolean,\r\n        samplingMode: number,\r\n        compression?: Nullable<string>,\r\n        textureType?: number,\r\n        creationFlags?: number\r\n    ): InternalTexture;\r\n\r\n    /**\r\n     * Update a raw 2D array texture\r\n     * @param texture defines the texture to update\r\n     * @param data defines the data to store\r\n     * @param format defines the data format\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     */\r\n    updateRawTexture2DArray(engineState: IBaseEnginePublic, texture: InternalTexture, data: Nullable<ArrayBufferView>, format: number, invertY: boolean): void;\r\n\r\n    /**\r\n     * Update a raw 2D array texture\r\n     * @param texture defines the texture to update\r\n     * @param data defines the data to store\r\n     * @param format defines the data format\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     * @param compression defines the used compression (can be null)\r\n     * @param textureType defines the texture Type (Engine.TEXTURETYPE_UNSIGNED_INT, Engine.TEXTURETYPE_FLOAT...)\r\n     */\r\n    updateRawTexture2DArray(\r\n        engineState: IBaseEnginePublic,\r\n        texture: InternalTexture,\r\n        data: Nullable<ArrayBufferView>,\r\n        format: number,\r\n        invertY: boolean,\r\n        compression: Nullable<string>,\r\n        textureType: number\r\n    ): void;\r\n}\r\n"]}

package/esm/Engines/Extensions/readTexture/readTexture.base.d.ts

@@ -0,0 +1,9 @@
+import type { InternalTexture } from "../../../../Materials/Textures/internalTexture.js";
+import type { Nullable } from "../../../../types.js";
+import type { IBaseEnginePublic } from "../../engine.base";
+export interface IReadTextureEngineExtension {
+    /** @internal */
+    _readTexturePixels(engineState: IBaseEnginePublic, texture: InternalTexture, width: number, height: number, faceIndex?: number, level?: number, buffer?: Nullable<ArrayBufferView>, flushRenderer?: boolean, noDataConversion?: boolean, x?: number, y?: number): Promise<ArrayBufferView>;
+    /** @internal */
+    _readTexturePixelsSync(engineState: IBaseEnginePublic, texture: InternalTexture, width: number, height: number, faceIndex?: number, level?: number, buffer?: Nullable<ArrayBufferView>, flushRenderer?: boolean, noDataConversion?: boolean, x?: number, y?: number): ArrayBufferView;
+}

package/esm/Engines/Extensions/readTexture/readTexture.base.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=readTexture.base.js.map

package/esm/Engines/Extensions/readTexture/readTexture.base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readTexture.base.js","sourceRoot":"","sources":["../../../../../../../dev/core/src/esm/Engines/Extensions/readTexture/readTexture.base.ts"],"names":[],"mappings":"","sourcesContent":["import type { InternalTexture } from \"core/Materials/Textures/internalTexture\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { IBaseEnginePublic } from \"../../engine.base\";\r\n\r\nexport interface IReadTextureEngineExtension {\r\n    /** @internal */\r\n    _readTexturePixels(\r\n        engineState: IBaseEnginePublic,\r\n        texture: InternalTexture,\r\n        width: number,\r\n        height: number,\r\n        faceIndex?: number,\r\n        level?: number,\r\n        buffer?: Nullable<ArrayBufferView>,\r\n        flushRenderer?: boolean,\r\n        noDataConversion?: boolean,\r\n        x?: number,\r\n        y?: number\r\n    ): Promise<ArrayBufferView>;\r\n\r\n    /** @internal */\r\n    _readTexturePixelsSync(\r\n        engineState: IBaseEnginePublic,\r\n        texture: InternalTexture,\r\n        width: number,\r\n        height: number,\r\n        faceIndex?: number,\r\n        level?: number,\r\n        buffer?: Nullable<ArrayBufferView>,\r\n        flushRenderer?: boolean,\r\n        noDataConversion?: boolean,\r\n        x?: number,\r\n        y?: number\r\n    ): ArrayBufferView;\r\n}\r\n"]}