@babylonjs/core 7.11.2 → 7.11.4

package/Culling/Helper/IBoundingInfoHelperPlatform.d.ts

@@ -0,0 +1,8 @@
+import type { AbstractMesh } from "../../Meshes/abstractMesh.js";
+/**
+ * Interface used to define a platform support for BoundingInfoHelper class
+ */
+export interface IBoundingInfoHelperPlatform {
+    processAsync(mesh: AbstractMesh | AbstractMesh[]): Promise<void>;
+    dispose(): void;
+}

package/Culling/Helper/IBoundingInfoHelperPlatform.js

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

package/Culling/Helper/IBoundingInfoHelperPlatform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IBoundingInfoHelperPlatform.js","sourceRoot":"","sources":["../../../../../dev/core/src/Culling/Helper/IBoundingInfoHelperPlatform.ts"],"names":[],"mappings":"","sourcesContent":["import type { AbstractMesh } from \"core/Meshes/abstractMesh\";\r\n\r\n/**\r\n * Interface used to define a platform support for BoundingInfoHelper class\r\n */\r\nexport interface IBoundingInfoHelperPlatform {\r\n    processAsync(mesh: AbstractMesh | AbstractMesh[]): Promise<void>;\r\n    dispose(): void;\r\n}\r\n"]}

package/Culling/Helper/boundingInfoHelper.d.ts

@@ -0,0 +1,32 @@
+import type { AbstractMesh } from "../../Meshes/abstractMesh.js";
+import type { AbstractEngine } from "../../Engines/abstractEngine.js";
+/**
+ * Utility class to help with bounding info management
+ * #BCNJD4#41 =\> does not use the BoundingInfoHelper class, performs calculations on the CPU
+ * #BCNJD4#37 =\> same as #41 but use the BoundingInfoHelper class
+ * #BCNJD4#40 =\> example with bones and morphs (webGL2)
+ * #BCNJD4#42 =\> example with bones and morphs (webGPU)
+ * #HPV2TZ#475 =\> only morph (webGL2)
+ * #HPV2TZ#476 =\> only morph (webGPU)
+ * #B8B8Z2#8 =\> Large scale test (webGL2)
+ * #B8B8Z2#9 =\> Large scale test (webGPU)
+ */
+export declare class BoundingInfoHelper {
+    private _platform;
+    private _engine;
+    /**
+     * Creates a new BoundingInfoHelper
+     * @param engine defines the engine to use
+     */
+    constructor(engine: AbstractEngine);
+    /**
+     * Compute the bounding info of a mesh / array of meshes using shaders
+     * @param target defines the mesh(es) to update
+     * @returns a promise that resolves when the bounding info is/are computed
+     */
+    computeAsync(target: AbstractMesh | AbstractMesh[]): Promise<void>;
+    /**
+     * Dispose and release associated resources
+     */
+    dispose(): void;
+}

package/Culling/Helper/boundingInfoHelper.js

@@ -0,0 +1,48 @@
+/**
+ * Utility class to help with bounding info management
+ * #BCNJD4#41 =\> does not use the BoundingInfoHelper class, performs calculations on the CPU
+ * #BCNJD4#37 =\> same as #41 but use the BoundingInfoHelper class
+ * #BCNJD4#40 =\> example with bones and morphs (webGL2)
+ * #BCNJD4#42 =\> example with bones and morphs (webGPU)
+ * #HPV2TZ#475 =\> only morph (webGL2)
+ * #HPV2TZ#476 =\> only morph (webGPU)
+ * #B8B8Z2#8 =\> Large scale test (webGL2)
+ * #B8B8Z2#9 =\> Large scale test (webGPU)
+ */
+export class BoundingInfoHelper {
+    /**
+     * Creates a new BoundingInfoHelper
+     * @param engine defines the engine to use
+     */
+    constructor(engine) {
+        this._engine = engine;
+    }
+    /**
+     * Compute the bounding info of a mesh / array of meshes using shaders
+     * @param target defines the mesh(es) to update
+     * @returns a promise that resolves when the bounding info is/are computed
+     */
+    async computeAsync(target) {
+        if (!this._platform) {
+            if (this._engine.getCaps().supportComputeShaders) {
+                const module = await import("./computeShaderBoundingHelper.js");
+                this._platform = new module.ComputeShaderBoundingHelper(this._engine);
+            }
+            else if (this._engine.getCaps().supportTransformFeedbacks) {
+                const module = await import("./transformFeedbackBoundingHelper.js");
+                this._platform = new module.TransformFeedbackBoundingHelper(this._engine);
+            }
+            else {
+                throw new Error("Your engine does not support Compute Shaders or Transform Feedbacks");
+            }
+        }
+        return this._platform.processAsync(target);
+    }
+    /**
+     * Dispose and release associated resources
+     */
+    dispose() {
+        this._platform.dispose();
+    }
+}
+//# sourceMappingURL=boundingInfoHelper.js.map

package/Culling/Helper/boundingInfoHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundingInfoHelper.js","sourceRoot":"","sources":["../../../../../dev/core/src/Culling/Helper/boundingInfoHelper.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,kBAAkB;IAI3B;;;OAGG;IACH,YAAmB,MAAsB;QACrC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IAC1B,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,YAAY,CAAC,MAAqC;QAC3D,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACjB,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,qBAAqB,EAAE;gBAC9C,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,+BAA+B,CAAC,CAAC;gBAC7D,IAAI,CAAC,SAAS,GAAG,IAAI,MAAM,CAAC,2BAA2B,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;aACzE;iBAAM,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,yBAAyB,EAAE;gBACzD,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,mCAAmC,CAAC,CAAC;gBACjE,IAAI,CAAC,SAAS,GAAG,IAAI,MAAM,CAAC,+BAA+B,CAAC,IAAI,CAAC,OAAqB,CAAC,CAAC;aAC3F;iBAAM;gBACH,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;aAC1F;SACJ;QAED,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAC/C,CAAC;IAED;;OAEG;IACI,OAAO;QACV,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;CACJ","sourcesContent":["import type { AbstractMesh } from \"core/Meshes/abstractMesh\";\r\nimport type { AbstractEngine } from \"core/Engines/abstractEngine\";\r\nimport type { IBoundingInfoHelperPlatform } from \"./IBoundingInfoHelperPlatform\";\r\nimport type { ThinEngine } from \"core/Engines\";\r\n\r\n/**\r\n * Utility class to help with bounding info management\r\n * #BCNJD4#41 =\\> does not use the BoundingInfoHelper class, performs calculations on the CPU\r\n * #BCNJD4#37 =\\> same as #41 but use the BoundingInfoHelper class\r\n * #BCNJD4#40 =\\> example with bones and morphs (webGL2)\r\n * #BCNJD4#42 =\\> example with bones and morphs (webGPU)\r\n * #HPV2TZ#475 =\\> only morph (webGL2)\r\n * #HPV2TZ#476 =\\> only morph (webGPU)\r\n * #B8B8Z2#8 =\\> Large scale test (webGL2)\r\n * #B8B8Z2#9 =\\> Large scale test (webGPU)\r\n */\r\nexport class BoundingInfoHelper {\r\n    private _platform: IBoundingInfoHelperPlatform;\r\n    private _engine: AbstractEngine;\r\n\r\n    /**\r\n     * Creates a new BoundingInfoHelper\r\n     * @param engine defines the engine to use\r\n     */\r\n    public constructor(engine: AbstractEngine) {\r\n        this._engine = engine;\r\n    }\r\n\r\n    /**\r\n     * Compute the bounding info of a mesh / array of meshes using shaders\r\n     * @param target defines the mesh(es) to update\r\n     * @returns a promise that resolves when the bounding info is/are computed\r\n     */\r\n    public async computeAsync(target: AbstractMesh | AbstractMesh[]): Promise<void> {\r\n        if (!this._platform) {\r\n            if (this._engine.getCaps().supportComputeShaders) {\r\n                const module = await import(\"./computeShaderBoundingHelper\");\r\n                this._platform = new module.ComputeShaderBoundingHelper(this._engine);\r\n            } else if (this._engine.getCaps().supportTransformFeedbacks) {\r\n                const module = await import(\"./transformFeedbackBoundingHelper\");\r\n                this._platform = new module.TransformFeedbackBoundingHelper(this._engine as ThinEngine);\r\n            } else {\r\n                throw new Error(\"Your engine does not support Compute Shaders or Transform Feedbacks\");\r\n            }\r\n        }\r\n\r\n        return this._platform.processAsync(target);\r\n    }\r\n\r\n    /**\r\n     * Dispose and release associated resources\r\n     */\r\n    public dispose(): void {\r\n        this._platform.dispose();\r\n    }\r\n}\r\n"]}

package/Culling/Helper/computeShaderBoundingHelper.d.ts

@@ -0,0 +1,34 @@
+import type { IBoundingInfoHelperPlatform } from "./IBoundingInfoHelperPlatform";
+import type { AbstractMesh } from "../../Meshes/abstractMesh.js";
+import type { AbstractEngine } from "../../Engines/abstractEngine.js";
+import "../../ShadersWGSL/boundingInfo.compute";
+/** @internal */
+export declare class ComputeShaderBoundingHelper implements IBoundingInfoHelperPlatform {
+    private _engine;
+    private _computeShaders;
+    private _positionBuffers;
+    private _indexBuffers;
+    private _weightBuffers;
+    private _indexExtraBuffers;
+    private _weightExtraBuffers;
+    private _morphTargetInfluenceBuffers;
+    private _morphTargetTextureIndexBuffers;
+    private _resultData;
+    private _resultBuffer;
+    private _ubos;
+    private _uboIndex;
+    /**
+     * Creates a new ComputeShaderBoundingHelper
+     * @param engine defines the engine to use
+     */
+    constructor(engine: AbstractEngine);
+    private _getComputeShader;
+    private _getUBO;
+    private _extractDataAndLink;
+    private _prepareStorage;
+    /** @internal */
+    processAsync(meshes: AbstractMesh | AbstractMesh[]): Promise<void>;
+    private _disposeCache;
+    /** @internal */
+    dispose(): void;
+}

package/Culling/Helper/computeShaderBoundingHelper.js

@@ -0,0 +1,209 @@
+import { ComputeShader } from "../../Compute/computeShader.js";
+import { StorageBuffer } from "../../Buffers/storageBuffer.js";
+import { VertexBuffer } from "../../Buffers/buffer.js";
+import { Vector3 } from "../../Maths/math.vector.js";
+import { UniformBuffer } from "../../Materials/uniformBuffer.js";
+import "../../ShadersWGSL/boundingInfo.compute.js";
+/** @internal */
+export class ComputeShaderBoundingHelper {
+    /**
+     * Creates a new ComputeShaderBoundingHelper
+     * @param engine defines the engine to use
+     */
+    constructor(engine) {
+        this._computeShaders = {};
+        this._positionBuffers = {};
+        this._indexBuffers = {};
+        this._weightBuffers = {};
+        this._indexExtraBuffers = {};
+        this._weightExtraBuffers = {};
+        this._morphTargetInfluenceBuffers = {};
+        this._morphTargetTextureIndexBuffers = {};
+        this._ubos = [];
+        this._uboIndex = 0;
+        this._engine = engine;
+    }
+    _getComputeShader(defines) {
+        let computeShader;
+        const join = defines.join("\n");
+        if (!this._computeShaders[join]) {
+            computeShader = new ComputeShader("boundingInfoCompute", this._engine, "boundingInfo", {
+                bindingsMapping: {
+                    positionBuffer: { group: 0, binding: 0 },
+                    resultBuffer: { group: 0, binding: 1 },
+                    boneSampler: { group: 0, binding: 2 },
+                    indexBuffer: { group: 0, binding: 3 },
+                    weightBuffer: { group: 0, binding: 4 },
+                    indexExtraBuffer: { group: 0, binding: 5 },
+                    weightExtraBuffer: { group: 0, binding: 6 },
+                    settings: { group: 0, binding: 7 },
+                    morphTargets: { group: 0, binding: 8 },
+                    morphTargetInfluences: { group: 0, binding: 9 },
+                    morphTargetTextureIndices: { group: 0, binding: 10 },
+                },
+                defines: defines,
+            });
+            this._computeShaders[join] = computeShader;
+        }
+        else {
+            computeShader = this._computeShaders[join];
+        }
+        return computeShader;
+    }
+    _getUBO() {
+        if (this._uboIndex >= this._ubos.length) {
+            const ubo = new UniformBuffer(this._engine);
+            ubo.addUniform("indexResult", 4);
+            ubo.addFloat3("morphTargetTextureInfo", 0, 0, 0);
+            this._ubos.push(ubo);
+        }
+        return this._ubos[this._uboIndex++];
+    }
+    _extractDataAndLink(computeShader, mesh, kind, stride, name, storageUnit) {
+        let buffer;
+        const vertexCount = mesh.getTotalVertices();
+        if (!storageUnit[mesh.uniqueId]) {
+            const dataArray = mesh.getVertexBuffer(kind)?.getFloatData(vertexCount);
+            buffer = new StorageBuffer(this._engine, Float32Array.BYTES_PER_ELEMENT * vertexCount * stride);
+            buffer.update(dataArray);
+            storageUnit[mesh.uniqueId] = buffer;
+        }
+        else {
+            buffer = storageUnit[mesh.uniqueId];
+        }
+        computeShader.setStorageBuffer(name, buffer);
+    }
+    _prepareStorage(computeShader, name, id, storageUnit, numInfluencers, data) {
+        let buffer;
+        if (!storageUnit[id]) {
+            buffer = new StorageBuffer(this._engine, Float32Array.BYTES_PER_ELEMENT * numInfluencers);
+            storageUnit[id] = buffer;
+        }
+        else {
+            buffer = storageUnit[id];
+        }
+        buffer.update(data);
+        computeShader.setStorageBuffer(name, buffer);
+    }
+    /** @internal */
+    processAsync(meshes) {
+        if (!Array.isArray(meshes)) {
+            meshes = [meshes];
+        }
+        this._uboIndex = 0;
+        // Results
+        const resultDataSize = 8 * meshes.length;
+        let resultData;
+        let resultBuffer;
+        if (!this._resultData || this._resultData.length !== resultDataSize) {
+            this._resultBuffer?.dispose();
+            resultData = new Float32Array(resultDataSize);
+            resultBuffer = new StorageBuffer(this._engine, Float32Array.BYTES_PER_ELEMENT * resultDataSize);
+            this._resultData = resultData;
+            this._resultBuffer = resultBuffer;
+        }
+        else {
+            resultData = this._resultData;
+            resultBuffer = this._resultBuffer;
+        }
+        for (let i = 0; i < meshes.length; i++) {
+            resultData[i * 8 + 0] = Number.POSITIVE_INFINITY;
+            resultData[i * 8 + 1] = Number.POSITIVE_INFINITY;
+            resultData[i * 8 + 2] = Number.POSITIVE_INFINITY;
+            resultData[i * 8 + 3] = Number.NEGATIVE_INFINITY;
+            resultData[i * 8 + 4] = Number.NEGATIVE_INFINITY;
+            resultData[i * 8 + 5] = Number.NEGATIVE_INFINITY;
+        }
+        resultBuffer.update(resultData);
+        const promises = [];
+        const processedMeshes = [];
+        for (let i = 0; i < meshes.length; i++) {
+            const mesh = meshes[i];
+            const vertexCount = mesh.getTotalVertices();
+            const defines = [""];
+            if (vertexCount === 0 || !mesh.getVertexBuffer || !mesh.getVertexBuffer(VertexBuffer.PositionKind)) {
+                continue;
+            }
+            processedMeshes.push(mesh);
+            if (mesh && mesh.useBones && mesh.computeBonesUsingShaders && mesh.skeleton) {
+                defines.push("#define NUM_BONE_INFLUENCERS " + mesh.numBoneInfluencers);
+            }
+            const manager = mesh.morphTargetManager;
+            if (manager && manager.numInfluencers > 0) {
+                defines.push("MORPHTARGETS");
+                defines.push("#define NUM_MORPH_INFLUENCERS " + manager.numInfluencers);
+            }
+            const computeShader = this._getComputeShader(defines);
+            this._extractDataAndLink(computeShader, mesh, VertexBuffer.PositionKind, 3, "positionBuffer", this._positionBuffers);
+            // UBO
+            const ubo = this._getUBO();
+            ubo.updateUInt("indexResult", processedMeshes.length - 1);
+            // Bones
+            if (mesh && mesh.useBones && mesh.computeBonesUsingShaders && mesh.skeleton && mesh.skeleton.useTextureToStoreBoneMatrices) {
+                this._extractDataAndLink(computeShader, mesh, VertexBuffer.MatricesIndicesKind, 4, "indexBuffer", this._indexBuffers);
+                this._extractDataAndLink(computeShader, mesh, VertexBuffer.MatricesWeightsKind, 4, "weightBuffer", this._weightBuffers);
+                const boneSampler = mesh.skeleton.getTransformMatrixTexture(mesh);
+                computeShader.setTexture("boneSampler", boneSampler, false);
+                if (mesh.numBoneInfluencers > 4) {
+                    this._extractDataAndLink(computeShader, mesh, VertexBuffer.MatricesIndicesExtraKind, 4, "indexExtraBuffer", this._indexExtraBuffers);
+                    this._extractDataAndLink(computeShader, mesh, VertexBuffer.MatricesWeightsExtraKind, 4, "weightExtraBuffer", this._weightExtraBuffers);
+                }
+            }
+            // Morphs
+            if (manager && manager.numInfluencers > 0) {
+                const morphTargets = manager._targetStoreTexture;
+                computeShader.setTexture("morphTargets", morphTargets, false);
+                this._prepareStorage(computeShader, "morphTargetInfluences", mesh.uniqueId, this._morphTargetInfluenceBuffers, manager.numInfluencers, manager.influences);
+                this._prepareStorage(computeShader, "morphTargetTextureIndices", mesh.uniqueId, this._morphTargetTextureIndexBuffers, manager.numInfluencers, manager._morphTargetTextureIndices);
+                ubo.updateFloat3("morphTargetTextureInfo", manager._textureVertexStride, manager._textureWidth, manager._textureHeight);
+            }
+            ubo.update();
+            computeShader.setStorageBuffer("resultBuffer", resultBuffer);
+            computeShader.setUniformBuffer("settings", ubo);
+            // Dispatch
+            promises.push(computeShader.dispatchWhenReady(Math.ceil(vertexCount / 64)));
+        }
+        if (promises.length === 0) {
+            return Promise.resolve();
+        }
+        return Promise.all(promises).then(() => {
+            return resultBuffer.read(undefined, undefined, resultData, true).then(() => {
+                for (let i = 0; i < processedMeshes.length; i++) {
+                    const mesh = processedMeshes[i];
+                    mesh._refreshBoundingInfoDirect({
+                        minimum: Vector3.FromArray(resultData, i * 8),
+                        maximum: Vector3.FromArray(resultData, i * 8 + 3),
+                    });
+                }
+            });
+        });
+    }
+    _disposeCache(storageUnit) {
+        for (const key in storageUnit) {
+            storageUnit[key].dispose();
+        }
+    }
+    /** @internal */
+    dispose() {
+        this._disposeCache(this._positionBuffers);
+        this._positionBuffers = {};
+        this._disposeCache(this._indexBuffers);
+        this._indexBuffers = {};
+        this._disposeCache(this._weightBuffers);
+        this._weightBuffers = {};
+        this._disposeCache(this._morphTargetInfluenceBuffers);
+        this._morphTargetInfluenceBuffers = {};
+        this._disposeCache(this._morphTargetTextureIndexBuffers);
+        this._morphTargetTextureIndexBuffers = {};
+        this._resultBuffer.dispose();
+        this._resultBuffer = undefined;
+        this._resultData = undefined;
+        for (const ubo of this._ubos) {
+            ubo.dispose();
+        }
+        this._ubos = [];
+        this._computeShaders = {};
+        this._engine = null;
+    }
+}
+//# sourceMappingURL=computeShaderBoundingHelper.js.map

package/Culling/Helper/computeShaderBoundingHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeShaderBoundingHelper.js","sourceRoot":"","sources":["../../../../../dev/core/src/Culling/Helper/computeShaderBoundingHelper.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IBoundingInfoHelperPlatform } from \"./IBoundingInfoHelperPlatform\";\r\nimport type { AbstractMesh } from \"core/Meshes/abstractMesh\";\r\nimport type { Nullable } from \"core/types\";\r\nimport { ComputeShader } from \"core/Compute/computeShader\";\r\nimport { StorageBuffer } from \"core/Buffers/storageBuffer\";\r\nimport type { WebGPUEngine } from \"core/Engines/webgpuEngine\";\r\nimport type { AbstractEngine } from \"core/Engines/abstractEngine\";\r\nimport type { Mesh } from \"core/Meshes/mesh\";\r\nimport { VertexBuffer } from \"core/Buffers/buffer\";\r\nimport { Vector3 } from \"core/Maths/math.vector\";\r\nimport { UniformBuffer } from \"core/Materials/uniformBuffer\";\r\n\r\nimport \"../../ShadersWGSL/boundingInfo.compute\";\r\n\r\n/** @internal */\r\nexport class ComputeShaderBoundingHelper implements IBoundingInfoHelperPlatform {\r\n    private _engine: Nullable<AbstractEngine>;\r\n    private _computeShaders: { [key: string]: ComputeShader } = {};\r\n    private _positionBuffers: { [key: number]: StorageBuffer } = {};\r\n    private _indexBuffers: { [key: number]: StorageBuffer } = {};\r\n    private _weightBuffers: { [key: number]: StorageBuffer } = {};\r\n    private _indexExtraBuffers: { [key: number]: StorageBuffer } = {};\r\n    private _weightExtraBuffers: { [key: number]: StorageBuffer } = {};\r\n    private _morphTargetInfluenceBuffers: { [key: number]: StorageBuffer } = {};\r\n    private _morphTargetTextureIndexBuffers: { [key: number]: StorageBuffer } = {};\r\n    private _resultData: Float32Array;\r\n    private _resultBuffer: StorageBuffer;\r\n    private _ubos: UniformBuffer[] = [];\r\n    private _uboIndex: number = 0;\r\n\r\n    /**\r\n     * Creates a new ComputeShaderBoundingHelper\r\n     * @param engine defines the engine to use\r\n     */\r\n    constructor(engine: AbstractEngine) {\r\n        this._engine = engine;\r\n    }\r\n\r\n    private _getComputeShader(defines: string[]) {\r\n        let computeShader: ComputeShader;\r\n        const join = defines.join(\"\\n\");\r\n\r\n        if (!this._computeShaders[join]) {\r\n            computeShader = new ComputeShader(\"boundingInfoCompute\", this._engine!, \"boundingInfo\", {\r\n                bindingsMapping: {\r\n                    positionBuffer: { group: 0, binding: 0 },\r\n                    resultBuffer: { group: 0, binding: 1 },\r\n                    boneSampler: { group: 0, binding: 2 },\r\n                    indexBuffer: { group: 0, binding: 3 },\r\n                    weightBuffer: { group: 0, binding: 4 },\r\n                    indexExtraBuffer: { group: 0, binding: 5 },\r\n                    weightExtraBuffer: { group: 0, binding: 6 },\r\n                    settings: { group: 0, binding: 7 },\r\n                    morphTargets: { group: 0, binding: 8 },\r\n                    morphTargetInfluences: { group: 0, binding: 9 },\r\n                    morphTargetTextureIndices: { group: 0, binding: 10 },\r\n                },\r\n                defines: defines,\r\n            });\r\n            this._computeShaders[join] = computeShader;\r\n        } else {\r\n            computeShader = this._computeShaders[join];\r\n        }\r\n\r\n        return computeShader;\r\n    }\r\n\r\n    private _getUBO() {\r\n        if (this._uboIndex >= this._ubos.length) {\r\n            const ubo = new UniformBuffer(this._engine!);\r\n            ubo.addUniform(\"indexResult\", 4);\r\n            ubo.addFloat3(\"morphTargetTextureInfo\", 0, 0, 0);\r\n            this._ubos.push(ubo);\r\n        }\r\n\r\n        return this._ubos[this._uboIndex++];\r\n    }\r\n\r\n    private _extractDataAndLink(computeShader: ComputeShader, mesh: Mesh, kind: string, stride: number, name: string, storageUnit: { [key: number]: StorageBuffer }) {\r\n        let buffer: StorageBuffer;\r\n        const vertexCount = mesh.getTotalVertices();\r\n        if (!storageUnit[mesh.uniqueId]) {\r\n            const dataArray = mesh.getVertexBuffer(kind)?.getFloatData(vertexCount);\r\n            buffer = new StorageBuffer(this._engine as WebGPUEngine, Float32Array.BYTES_PER_ELEMENT * vertexCount * stride);\r\n            buffer.update(dataArray!);\r\n\r\n            storageUnit[mesh.uniqueId] = buffer;\r\n        } else {\r\n            buffer = storageUnit[mesh.uniqueId];\r\n        }\r\n\r\n        computeShader.setStorageBuffer(name, buffer);\r\n    }\r\n\r\n    private _prepareStorage(computeShader: ComputeShader, name: string, id: number, storageUnit: { [key: number]: StorageBuffer }, numInfluencers: number, data: Float32Array) {\r\n        let buffer: StorageBuffer;\r\n        if (!storageUnit[id]) {\r\n            buffer = new StorageBuffer(this._engine as WebGPUEngine, Float32Array.BYTES_PER_ELEMENT * numInfluencers);\r\n\r\n            storageUnit[id] = buffer;\r\n        } else {\r\n            buffer = storageUnit[id];\r\n        }\r\n        buffer.update(data);\r\n\r\n        computeShader.setStorageBuffer(name, buffer);\r\n    }\r\n\r\n    /** @internal */\r\n    public processAsync(meshes: AbstractMesh | AbstractMesh[]): Promise<void> {\r\n        if (!Array.isArray(meshes)) {\r\n            meshes = [meshes];\r\n        }\r\n\r\n        this._uboIndex = 0;\r\n\r\n        // Results\r\n        const resultDataSize = 8 * meshes.length;\r\n        let resultData: Float32Array;\r\n        let resultBuffer: StorageBuffer;\r\n        if (!this._resultData || this._resultData.length !== resultDataSize) {\r\n            this._resultBuffer?.dispose();\r\n\r\n            resultData = new Float32Array(resultDataSize);\r\n            resultBuffer = new StorageBuffer(this._engine as WebGPUEngine, Float32Array.BYTES_PER_ELEMENT * resultDataSize);\r\n\r\n            this._resultData = resultData;\r\n            this._resultBuffer = resultBuffer;\r\n        } else {\r\n            resultData = this._resultData;\r\n            resultBuffer = this._resultBuffer;\r\n        }\r\n\r\n        for (let i = 0; i < meshes.length; i++) {\r\n            resultData[i * 8 + 0] = Number.POSITIVE_INFINITY;\r\n            resultData[i * 8 + 1] = Number.POSITIVE_INFINITY;\r\n            resultData[i * 8 + 2] = Number.POSITIVE_INFINITY;\r\n\r\n            resultData[i * 8 + 3] = Number.NEGATIVE_INFINITY;\r\n            resultData[i * 8 + 4] = Number.NEGATIVE_INFINITY;\r\n            resultData[i * 8 + 5] = Number.NEGATIVE_INFINITY;\r\n        }\r\n\r\n        resultBuffer.update(resultData);\r\n\r\n        const promises: Promise<void>[] = [];\r\n        const processedMeshes: AbstractMesh[] = [];\r\n\r\n        for (let i = 0; i < meshes.length; i++) {\r\n            const mesh = meshes[i];\r\n            const vertexCount = mesh.getTotalVertices();\r\n            const defines = [\"\"];\r\n\r\n            if (vertexCount === 0 || !(mesh as Mesh).getVertexBuffer || !(mesh as Mesh).getVertexBuffer(VertexBuffer.PositionKind)) {\r\n                continue;\r\n            }\r\n\r\n            processedMeshes.push(mesh);\r\n\r\n            if (mesh && mesh.useBones && mesh.computeBonesUsingShaders && mesh.skeleton) {\r\n                defines.push(\"#define NUM_BONE_INFLUENCERS \" + mesh.numBoneInfluencers);\r\n            }\r\n\r\n            const manager = (<Mesh>mesh).morphTargetManager;\r\n            if (manager && manager.numInfluencers > 0) {\r\n                defines.push(\"MORPHTARGETS\");\r\n                defines.push(\"#define NUM_MORPH_INFLUENCERS \" + manager.numInfluencers);\r\n            }\r\n\r\n            const computeShader = this._getComputeShader(defines);\r\n\r\n            this._extractDataAndLink(computeShader, mesh as Mesh, VertexBuffer.PositionKind, 3, \"positionBuffer\", this._positionBuffers);\r\n\r\n            // UBO\r\n            const ubo = this._getUBO();\r\n            ubo.updateUInt(\"indexResult\", processedMeshes.length - 1);\r\n\r\n            // Bones\r\n            if (mesh && mesh.useBones && mesh.computeBonesUsingShaders && mesh.skeleton && mesh.skeleton.useTextureToStoreBoneMatrices) {\r\n                this._extractDataAndLink(computeShader, mesh as Mesh, VertexBuffer.MatricesIndicesKind, 4, \"indexBuffer\", this._indexBuffers);\r\n                this._extractDataAndLink(computeShader, mesh as Mesh, VertexBuffer.MatricesWeightsKind, 4, \"weightBuffer\", this._weightBuffers);\r\n                const boneSampler = mesh.skeleton.getTransformMatrixTexture(mesh);\r\n                computeShader.setTexture(\"boneSampler\", boneSampler!, false);\r\n                if (mesh.numBoneInfluencers > 4) {\r\n                    this._extractDataAndLink(computeShader, mesh as Mesh, VertexBuffer.MatricesIndicesExtraKind, 4, \"indexExtraBuffer\", this._indexExtraBuffers);\r\n                    this._extractDataAndLink(computeShader, mesh as Mesh, VertexBuffer.MatricesWeightsExtraKind, 4, \"weightExtraBuffer\", this._weightExtraBuffers);\r\n                }\r\n            }\r\n\r\n            // Morphs\r\n            if (manager && manager.numInfluencers > 0) {\r\n                const morphTargets = manager._targetStoreTexture;\r\n                computeShader.setTexture(\"morphTargets\", morphTargets!, false);\r\n\r\n                this._prepareStorage(computeShader, \"morphTargetInfluences\", mesh.uniqueId, this._morphTargetInfluenceBuffers, manager.numInfluencers, manager.influences);\r\n                this._prepareStorage(\r\n                    computeShader,\r\n                    \"morphTargetTextureIndices\",\r\n                    mesh.uniqueId,\r\n                    this._morphTargetTextureIndexBuffers,\r\n                    manager.numInfluencers,\r\n                    manager._morphTargetTextureIndices\r\n                );\r\n                ubo.updateFloat3(\"morphTargetTextureInfo\", manager._textureVertexStride, manager._textureWidth, manager._textureHeight);\r\n            }\r\n\r\n            ubo.update();\r\n\r\n            computeShader.setStorageBuffer(\"resultBuffer\", resultBuffer);\r\n            computeShader.setUniformBuffer(\"settings\", ubo);\r\n\r\n            // Dispatch\r\n            promises.push(computeShader.dispatchWhenReady(Math.ceil(vertexCount / 64)));\r\n        }\r\n\r\n        if (promises.length === 0) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {\r\n            return resultBuffer.read(undefined, undefined, resultData, true).then(() => {\r\n                for (let i = 0; i < processedMeshes.length; i++) {\r\n                    const mesh = processedMeshes[i];\r\n                    mesh._refreshBoundingInfoDirect({\r\n                        minimum: Vector3.FromArray(resultData, i * 8),\r\n                        maximum: Vector3.FromArray(resultData, i * 8 + 3),\r\n                    });\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n    private _disposeCache(storageUnit: { [key: number]: StorageBuffer }) {\r\n        for (const key in storageUnit) {\r\n            storageUnit[key].dispose();\r\n        }\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose(): void {\r\n        this._disposeCache(this._positionBuffers);\r\n        this._positionBuffers = {};\r\n        this._disposeCache(this._indexBuffers);\r\n        this._indexBuffers = {};\r\n        this._disposeCache(this._weightBuffers);\r\n        this._weightBuffers = {};\r\n        this._disposeCache(this._morphTargetInfluenceBuffers);\r\n        this._morphTargetInfluenceBuffers = {};\r\n        this._disposeCache(this._morphTargetTextureIndexBuffers);\r\n        this._morphTargetTextureIndexBuffers = {};\r\n        this._resultBuffer.dispose();\r\n        this._resultBuffer = undefined!;\r\n        this._resultData = undefined!;\r\n        for (const ubo of this._ubos) {\r\n            ubo.dispose();\r\n        }\r\n        this._ubos = [];\r\n        this._computeShaders = {};\r\n        this._engine = null;\r\n    }\r\n}\r\n"]}

package/Culling/Helper/transformFeedbackBoundingHelper.d.ts

@@ -0,0 +1,21 @@
+import type { ThinEngine } from "../../Engines/thinEngine.js";
+import type { AbstractMesh } from "../../Meshes/abstractMesh.js";
+import type { IBoundingInfoHelperPlatform } from "./IBoundingInfoHelperPlatform";
+import "../../Shaders/gpuTransform.vertex";
+import "../../Shaders/gpuTransform.fragment";
+/** @internal */
+export declare class TransformFeedbackBoundingHelper implements IBoundingInfoHelperPlatform {
+    private _engine;
+    private _buffers;
+    private _effects;
+    /**
+     * Creates a new TransformFeedbackBoundingHelper
+     * @param engine defines the engine to use
+     */
+    constructor(engine: ThinEngine);
+    /** @internal */
+    processAsync(meshes: AbstractMesh | AbstractMesh[]): Promise<void>;
+    private _compute;
+    /** @internal */
+    dispose(): void;
+}

package/Culling/Helper/transformFeedbackBoundingHelper.js

@@ -0,0 +1,197 @@
+import { VertexBuffer, Buffer } from "../../Buffers/buffer.js";
+
+import { BindBonesParameters, BindMorphTargetParameters, PrepareAttributesForBakedVertexAnimation } from "../../Materials/materialHelper.functions.js";
+import "../../Shaders/gpuTransform.vertex.js";
+import "../../Shaders/gpuTransform.fragment.js";
+/** @internal */
+export class TransformFeedbackBoundingHelper {
+    /**
+     * Creates a new TransformFeedbackBoundingHelper
+     * @param engine defines the engine to use
+     */
+    constructor(engine) {
+        this._buffers = {};
+        this._effects = {};
+        this._engine = engine;
+    }
+    /** @internal */
+    processAsync(meshes) {
+        if (!Array.isArray(meshes)) {
+            meshes = [meshes];
+        }
+        const promises = [];
+        for (let i = 0; i < meshes.length; ++i) {
+            const mesh = meshes[i];
+            const vertexCount = mesh.getTotalVertices();
+            if (vertexCount === 0 || !mesh.getVertexBuffer || !mesh.getVertexBuffer(VertexBuffer.PositionKind)) {
+                continue;
+            }
+            // Get correct effect
+            let computeEffect;
+            let numInfluencers = 0;
+            const defines = [];
+            let uniforms = [];
+            const attribs = [VertexBuffer.PositionKind];
+            const samplers = [];
+            // Bones
+            if (mesh && mesh.useBones && mesh.computeBonesUsingShaders && mesh.skeleton) {
+                attribs.push(VertexBuffer.MatricesIndicesKind);
+                attribs.push(VertexBuffer.MatricesWeightsKind);
+                if (mesh.numBoneInfluencers > 4) {
+                    attribs.push(VertexBuffer.MatricesIndicesExtraKind);
+                    attribs.push(VertexBuffer.MatricesWeightsExtraKind);
+                }
+                const skeleton = mesh.skeleton;
+                defines.push("#define NUM_BONE_INFLUENCERS " + mesh.numBoneInfluencers);
+                if (skeleton.isUsingTextureForMatrices) {
+                    defines.push("#define BONETEXTURE");
+                    if (uniforms.indexOf("boneTextureWidth") === -1) {
+                        uniforms.push("boneTextureWidth");
+                    }
+                    if (samplers.indexOf("boneSampler") === -1) {
+                        samplers.push("boneSampler");
+                    }
+                }
+                else {
+                    defines.push("#define BonesPerMesh " + (skeleton.bones.length + 1));
+                    if (uniforms.indexOf("mBones") === -1) {
+                        uniforms.push("mBones");
+                    }
+                }
+            }
+            else {
+                defines.push("#define NUM_BONE_INFLUENCERS 0");
+            }
+            // Morph
+            const manager = mesh ? mesh.morphTargetManager : null;
+            if (manager) {
+                numInfluencers = manager.numMaxInfluencers || manager.numInfluencers;
+                if (numInfluencers > 0) {
+                    defines.push("#define MORPHTARGETS");
+                }
+                if (manager.isUsingTextureForTargets) {
+                    defines.push("#define MORPHTARGETS_TEXTURE");
+                    if (uniforms.indexOf("morphTargetTextureIndices") === -1) {
+                        uniforms.push("morphTargetTextureIndices");
+                    }
+                    if (samplers.indexOf("morphTargets") === -1) {
+                        samplers.push("morphTargets");
+                    }
+                }
+                defines.push("#define NUM_MORPH_INFLUENCERS " + numInfluencers);
+                for (let index = 0; index < numInfluencers; index++) {
+                    attribs.push(VertexBuffer.PositionKind + index);
+                }
+                if (numInfluencers > 0) {
+                    uniforms = uniforms.slice();
+                    uniforms.push("morphTargetInfluences");
+                    uniforms.push("morphTargetCount");
+                    uniforms.push("morphTargetTextureInfo");
+                    uniforms.push("morphTargetTextureIndices");
+                }
+            }
+            // Baked Vertex Animation
+            const bvaManager = mesh.bakedVertexAnimationManager;
+            if (bvaManager && bvaManager.isEnabled) {
+                defines.push("#define BAKED_VERTEX_ANIMATION_TEXTURE");
+                if (uniforms.indexOf("bakedVertexAnimationSettings") === -1) {
+                    uniforms.push("bakedVertexAnimationSettings");
+                }
+                if (uniforms.indexOf("bakedVertexAnimationTextureSizeInverted") === -1) {
+                    uniforms.push("bakedVertexAnimationTextureSizeInverted");
+                }
+                if (uniforms.indexOf("bakedVertexAnimationTime") === -1) {
+                    uniforms.push("bakedVertexAnimationTime");
+                }
+                if (samplers.indexOf("bakedVertexAnimationTexture") === -1) {
+                    samplers.push("bakedVertexAnimationTexture");
+                }
+                PrepareAttributesForBakedVertexAnimation(attribs, mesh, defines);
+            }
+            const join = defines.join("\n");
+            if (!this._effects[join]) {
+                const computeEffectOptions = {
+                    attributes: attribs,
+                    uniformsNames: uniforms,
+                    uniformBuffersNames: [],
+                    samplers: samplers,
+                    defines: join,
+                    fallbacks: null,
+                    onCompiled: null,
+                    onError: null,
+                    indexParameters: { maxSimultaneousMorphTargets: numInfluencers },
+                    maxSimultaneousLights: 0,
+                    transformFeedbackVaryings: ["outPosition"],
+                };
+                computeEffect = this._engine.createEffect("gpuTransform", computeEffectOptions, this._engine);
+                this._effects[join] = computeEffect;
+            }
+            else {
+                computeEffect = this._effects[join];
+            }
+            promises.push(new Promise((resolve) => {
+                if (computeEffect.isReady()) {
+                    this._compute(mesh, computeEffect);
+                    resolve();
+                    return;
+                }
+                computeEffect.onCompileObservable.addOnce(() => {
+                    this._compute(mesh, computeEffect);
+                    resolve();
+                });
+            }));
+        }
+        return Promise.all(promises).then(() => { });
+    }
+    _compute(mesh, effect) {
+        const engine = this._engine;
+        // Buffer
+        let targetBuffer;
+        const vertexCount = mesh.getTotalVertices();
+        if (!this._buffers[mesh.uniqueId]) {
+            const targetData = new Float32Array(vertexCount * 3);
+            targetBuffer = new Buffer(mesh.getEngine(), targetData, true, 3);
+            this._buffers[mesh.uniqueId] = targetBuffer;
+        }
+        else {
+            targetBuffer = this._buffers[mesh.uniqueId];
+        }
+        // Bind
+        effect.getEngine().enableEffect(effect);
+        mesh._bindDirect(effect, null, true);
+        // Bones
+        BindBonesParameters(mesh, effect);
+        // Morph targets
+        const manager = mesh.morphTargetManager;
+        if (manager && manager.numInfluencers > 0) {
+            BindMorphTargetParameters(mesh, effect);
+        }
+        // BVA
+        const bvaManager = mesh.bakedVertexAnimationManager;
+        if (bvaManager && bvaManager.isEnabled) {
+            mesh.bakedVertexAnimationManager?.bind(effect, false);
+        }
+        // Update
+        const arrayBuffer = targetBuffer.getData();
+        engine.bindTransformFeedbackBuffer(targetBuffer.getBuffer());
+        engine.setRasterizerState(false);
+        engine.beginTransformFeedback(true);
+        engine.drawArraysType(2, 0, vertexCount);
+        engine.endTransformFeedback();
+        engine.setRasterizerState(true);
+        engine.readTransformFeedbackBuffer(arrayBuffer);
+        engine.bindTransformFeedbackBuffer(null);
+        // Update mesh
+        mesh._refreshBoundingInfo(arrayBuffer, null);
+    }
+    /** @internal */
+    dispose() {
+        for (const key in this._buffers) {
+            this._buffers[key].dispose();
+        }
+        this._buffers = {};
+        this._effects = {};
+        this._engine = null;
+    }
+}
+//# sourceMappingURL=transformFeedbackBoundingHelper.js.map