@babylonjs/core 8.15.1 → 8.16.1

package/Meshes/mesh.js

@@ -30,19 +30,27 @@ export class _CreationDataStorage {
 /**
  * @internal
  **/
-class _InstanceDataStorage {
+class _InstanceDataStorageRenderPass {
     constructor() {
-        this.visibleInstances = {};
-        this.batchCache = new _InstancesBatch();
-        this.batchCacheReplacementModeInFrozenMode = new _InstancesBatch();
+        this.batchCache = new _InstancesBatch(this);
+        this.batchCacheReplacementModeInFrozenMode = new _InstancesBatch(this);
         this.instancesBufferSize = 32 * 16 * 4; // let's start with a maximum of 32 instances
     }
 }
 /**
  * @internal
  **/
-export class _InstancesBatch {
+class _InstanceDataStorage {
     constructor() {
+        this.renderPasses = {};
+    }
+}
+/**
+ * @internal
+ **/
+export class _InstancesBatch {
+    constructor(parent) {
+        this.parent = parent;
         this.mustReturn = false;
         this.visibleInstances = new Array();
         this.renderSelf = [];
@@ -217,6 +225,10 @@ export class Mesh extends AbstractMesh {
             (this._scene.useRightHandedSystem && value === 1) ||
                 (!this._scene.useRightHandedSystem && value === 0);
     }
+    /** @internal */
+    get _effectiveSideOrientation() {
+        return this._internalMeshDataInfo._effectiveSideOrientation;
+    }
     /**
      * @deprecated Please use sideOrientation instead.
      * @see https://doc.babylonjs.com/breaking-changes#7110
@@ -276,11 +288,13 @@ export class Mesh extends AbstractMesh {
     }
     /** Gets the array buffer used to store the instanced buffer used for instances' world matrices */
     get worldMatrixInstancedBuffer() {
-        return this._instanceDataStorage.instancesData;
+        const instanceDataStorage = this._instanceDataStorage.renderPasses[this._instanceDataStorage.engine.isWebGPU ? this._instanceDataStorage.engine.currentRenderPassId : 0];
+        return instanceDataStorage ? instanceDataStorage.instancesData : undefined;
     }
     /** Gets the array buffer used to store the instanced buffer used for instances' previous world matrices */
     get previousWorldMatrixInstancedBuffer() {
-        return this._instanceDataStorage.instancesPreviousData;
+        const instanceDataStorage = this._instanceDataStorage.renderPasses[this._instanceDataStorage.engine.isWebGPU ? this._instanceDataStorage.engine.currentRenderPassId : 0];
+        return instanceDataStorage ? instanceDataStorage.instancesPreviousData : undefined;
     }
     /** Gets or sets a boolean indicating that the update of the instance buffer of the world matrices is manual */
     get manualUpdateOfWorldMatrixInstancedBuffer() {
@@ -489,8 +503,6 @@ export class Mesh extends AbstractMesh {
         /** @internal */
         this._geometry = null;
         /** @internal */
-        this._instanceDataStorage = new _InstanceDataStorage();
-        /** @internal */
         this._thinInstanceDataStorage = new _ThinInstanceDataStorage();
         /** @internal */
         this._shouldGenerateFlatShading = false;
@@ -506,6 +518,8 @@ export class Mesh extends AbstractMesh {
          */
         this.ignoreCameraMaxZ = false;
         scene = this.getScene();
+        this._instanceDataStorage = new _InstanceDataStorage();
+        this._instanceDataStorage.engine = scene.getEngine();
         if (this._scene.useRightHandedSystem) {
             this.sideOrientation = 0;
         }
@@ -1080,6 +1094,16 @@ export class Mesh extends AbstractMesh {
     set overridenInstanceCount(count) {
         this._instanceDataStorage.overridenInstanceCount = count;
     }
+    /** @internal */
+    _getInstanceDataStorage() {
+        const renderPassId = this._instanceDataStorage.engine.isWebGPU ? this._instanceDataStorage.engine.currentRenderPassId : 0;
+        let instanceDataStorage = this._instanceDataStorage.renderPasses[renderPassId];
+        if (!instanceDataStorage) {
+            instanceDataStorage = new _InstanceDataStorageRenderPass();
+            this._instanceDataStorage.renderPasses[renderPassId] = instanceDataStorage;
+        }
+        return instanceDataStorage;
+    }
     // Methods
     /** @internal */
     _preActivate() {
@@ -1089,15 +1113,21 @@ export class Mesh extends AbstractMesh {
             return this;
         }
         internalDataInfo._preActivateId = sceneRenderId;
-        this._instanceDataStorage.visibleInstances = null;
+        if (this.hasInstances) {
+            this._getInstanceDataStorage().visibleInstances = null;
+        }
         return this;
     }
     /**
      * @internal
      */
     _preActivateForIntermediateRendering(renderId) {
-        if (this._instanceDataStorage.visibleInstances) {
-            this._instanceDataStorage.visibleInstances.intermediateDefaultRenderId = renderId;
+        if (!this.hasInstances) {
+            return this;
+        }
+        const instanceDataStorage = this._getInstanceDataStorage();
+        if (instanceDataStorage.visibleInstances) {
+            instanceDataStorage.visibleInstances.intermediateDefaultRenderId = renderId;
         }
         return this;
     }
@@ -1105,20 +1135,22 @@ export class Mesh extends AbstractMesh {
      * @internal
      */
     _registerInstanceForRenderId(instance, renderId) {
-        if (!this._instanceDataStorage.visibleInstances) {
-            this._instanceDataStorage.visibleInstances = {
+        const instanceDataStorage = this._getInstanceDataStorage();
+        if (!instanceDataStorage.visibleInstances) {
+            instanceDataStorage.visibleInstances = {
                 defaultRenderId: renderId,
                 selfDefaultRenderId: this._renderId,
+                intermediateDefaultRenderId: -1,
             };
         }
-        if (!this._instanceDataStorage.visibleInstances[renderId]) {
-            if (this._instanceDataStorage.previousRenderId !== undefined && this._instanceDataStorage.isFrozen) {
-                this._instanceDataStorage.visibleInstances[this._instanceDataStorage.previousRenderId] = null;
+        if (!instanceDataStorage.visibleInstances[renderId]) {
+            if (instanceDataStorage.previousRenderId !== undefined && this._instanceDataStorage.isFrozen) {
+                instanceDataStorage.visibleInstances[instanceDataStorage.previousRenderId] = null;
             }
-            this._instanceDataStorage.previousRenderId = renderId;
-            this._instanceDataStorage.visibleInstances[renderId] = new Array();
+            instanceDataStorage.previousRenderId = renderId;
+            instanceDataStorage.visibleInstances[renderId] = new Array();
         }
-        this._instanceDataStorage.visibleInstances[renderId].push(instance);
+        instanceDataStorage.visibleInstances[renderId].push(instance);
         return this;
     }
     _afterComputeWorldMatrix() {
@@ -1503,6 +1535,14 @@ export class Mesh extends AbstractMesh {
             this._geometry._bind(effect, indexToBind);
         }
         else {
+            if (this._instanceDataStorage.engine.isWebGPU &&
+                this._userInstancedBuffersStorage.renderPasses &&
+                this._userInstancedBuffersStorage.renderPasses[this._instanceDataStorage.engine.currentRenderPassId]) {
+                const vertexBuffers = this._userInstancedBuffersStorage.renderPasses[this._instanceDataStorage.engine.currentRenderPassId];
+                for (const kind in vertexBuffers) {
+                    this._userInstancedBuffersStorage.vertexBuffers[kind] = vertexBuffers[kind];
+                }
+            }
             this._geometry._bind(effect, indexToBind, this._userInstancedBuffersStorage.vertexBuffers, this._userInstancedBuffersStorage.vertexArrayObjects);
         }
         return this;
@@ -1572,14 +1612,15 @@ export class Mesh extends AbstractMesh {
      * @internal
      */
     _getInstancesRenderList(subMeshId, isReplacementMode = false) {
+        const instanceDataStorage = this._getInstanceDataStorage();
         if (this._instanceDataStorage.isFrozen) {
             if (isReplacementMode) {
-                this._instanceDataStorage.batchCacheReplacementModeInFrozenMode.hardwareInstancedRendering[subMeshId] = false;
-                this._instanceDataStorage.batchCacheReplacementModeInFrozenMode.renderSelf[subMeshId] = true;
-                return this._instanceDataStorage.batchCacheReplacementModeInFrozenMode;
+                instanceDataStorage.batchCacheReplacementModeInFrozenMode.hardwareInstancedRendering[subMeshId] = false;
+                instanceDataStorage.batchCacheReplacementModeInFrozenMode.renderSelf[subMeshId] = true;
+                return instanceDataStorage.batchCacheReplacementModeInFrozenMode;
             }
-            if (this._instanceDataStorage.previousBatch) {
-                return this._instanceDataStorage.previousBatch;
+            if (instanceDataStorage.previousBatch) {
+                return instanceDataStorage.previousBatch;
             }
         }
         const scene = this.getScene();
@@ -1587,12 +1628,12 @@ export class Mesh extends AbstractMesh {
         const onlyForInstances = isInIntermediateRendering
             ? this._internalAbstractMeshDataInfo._onlyForInstancesIntermediate
             : this._internalAbstractMeshDataInfo._onlyForInstances;
-        const batchCache = this._instanceDataStorage.batchCache;
+        const batchCache = instanceDataStorage.batchCache;
         batchCache.mustReturn = false;
         batchCache.renderSelf[subMeshId] = isReplacementMode || (!onlyForInstances && this.isEnabled() && this.isVisible);
         batchCache.visibleInstances[subMeshId] = null;
-        if (this._instanceDataStorage.visibleInstances && !isReplacementMode) {
-            const visibleInstances = this._instanceDataStorage.visibleInstances;
+        if (instanceDataStorage.visibleInstances && !isReplacementMode) {
+            const visibleInstances = instanceDataStorage.visibleInstances;
             const currentRenderId = scene.getRenderId();
             const defaultRenderId = isInIntermediateRendering ? visibleInstances.intermediateDefaultRenderId : visibleInstances.defaultRenderId;
             batchCache.visibleInstances[subMeshId] = visibleInstances[currentRenderId];
@@ -1605,7 +1646,7 @@ export class Mesh extends AbstractMesh {
                 this._instanceDataStorage.hardwareInstancedRendering &&
                 batchCache.visibleInstances[subMeshId] !== null &&
                 batchCache.visibleInstances[subMeshId] !== undefined;
-        this._instanceDataStorage.previousBatch = batchCache;
+        instanceDataStorage.previousBatch = batchCache;
         return batchCache;
     }
     /**
@@ -1615,7 +1656,8 @@ export class Mesh extends AbstractMesh {
     _updateInstancedBuffers(subMesh, batch, currentInstancesBufferSize, engine, fillMode, effect) {
         const visibleInstances = batch.visibleInstances[subMesh._id];
         const visibleInstanceCount = visibleInstances ? visibleInstances.length : 0;
-        const instanceStorage = this._instanceDataStorage;
+        const instanceStorage = batch.parent;
+        const instanceDataStorage = this._instanceDataStorage;
         let instancesBuffer = instanceStorage.instancesBuffer;
         let instancesPreviousBuffer = instanceStorage.instancesPreviousBuffer;
         let offset = 0;
@@ -1624,17 +1666,17 @@ export class Mesh extends AbstractMesh {
         const needUpdateBuffer = !instancesBuffer ||
             currentInstancesBufferSize !== instanceStorage.instancesBufferSize ||
             (this._scene.needsPreviousWorldMatrices && !instanceStorage.instancesPreviousBuffer);
-        if (!this._instanceDataStorage.manualUpdate && (!instanceStorage.isFrozen || needUpdateBuffer)) {
+        if (!this._instanceDataStorage.manualUpdate && (!instanceDataStorage.isFrozen || needUpdateBuffer)) {
             const world = this.getWorldMatrix();
             if (renderSelf) {
                 if (this._scene.needsPreviousWorldMatrices) {
-                    if (!instanceStorage.masterMeshPreviousWorldMatrix) {
-                        instanceStorage.masterMeshPreviousWorldMatrix = world.clone();
-                        instanceStorage.masterMeshPreviousWorldMatrix.copyToArray(instanceStorage.instancesPreviousData, offset);
+                    if (!instanceDataStorage.masterMeshPreviousWorldMatrix) {
+                        instanceDataStorage.masterMeshPreviousWorldMatrix = world.clone();
+                        instanceDataStorage.masterMeshPreviousWorldMatrix.copyToArray(instanceStorage.instancesPreviousData, offset);
                     }
                     else {
-                        instanceStorage.masterMeshPreviousWorldMatrix.copyToArray(instanceStorage.instancesPreviousData, offset);
-                        instanceStorage.masterMeshPreviousWorldMatrix.copyFrom(world);
+                        instanceDataStorage.masterMeshPreviousWorldMatrix.copyToArray(instanceStorage.instancesPreviousData, offset);
+                        instanceDataStorage.masterMeshPreviousWorldMatrix.copyFrom(world);
                     }
                 }
                 world.copyToArray(instanceStorage.instancesData, offset);
@@ -1692,17 +1734,31 @@ export class Mesh extends AbstractMesh {
                     vertexArrayObjects: this.getEngine().getCaps().vertexArrayObject ? {} : undefined,
                 };
             }
-            this._userInstancedBuffersStorage.vertexBuffers["world0"] = instancesBuffer.createVertexBuffer("world0", 0, 4);
-            this._userInstancedBuffersStorage.vertexBuffers["world1"] = instancesBuffer.createVertexBuffer("world1", 4, 4);
-            this._userInstancedBuffersStorage.vertexBuffers["world2"] = instancesBuffer.createVertexBuffer("world2", 8, 4);
-            this._userInstancedBuffersStorage.vertexBuffers["world3"] = instancesBuffer.createVertexBuffer("world3", 12, 4);
+            let vertexAndArrayObjectBuffers;
+            if (this._instanceDataStorage.engine.isWebGPU) {
+                if (!this._userInstancedBuffersStorage.renderPasses) {
+                    this._userInstancedBuffersStorage.renderPasses = {};
+                }
+                const currentRenderPassId = this._instanceDataStorage.engine.currentRenderPassId;
+                vertexAndArrayObjectBuffers = this._userInstancedBuffersStorage.renderPasses[currentRenderPassId];
+                if (!vertexAndArrayObjectBuffers) {
+                    this._userInstancedBuffersStorage.renderPasses[currentRenderPassId] = vertexAndArrayObjectBuffers = {};
+                }
+            }
+            else {
+                vertexAndArrayObjectBuffers = this._userInstancedBuffersStorage.vertexBuffers;
+            }
+            vertexAndArrayObjectBuffers["world0"] = instancesBuffer.createVertexBuffer("world0", 0, 4);
+            vertexAndArrayObjectBuffers["world1"] = instancesBuffer.createVertexBuffer("world1", 4, 4);
+            vertexAndArrayObjectBuffers["world2"] = instancesBuffer.createVertexBuffer("world2", 8, 4);
+            vertexAndArrayObjectBuffers["world3"] = instancesBuffer.createVertexBuffer("world3", 12, 4);
             if (this._scene.needsPreviousWorldMatrices) {
                 instancesPreviousBuffer = new Buffer(engine, instanceStorage.instancesPreviousData, true, 16, false, true);
                 instanceStorage.instancesPreviousBuffer = instancesPreviousBuffer;
-                this._userInstancedBuffersStorage.vertexBuffers["previousWorld0"] = instancesPreviousBuffer.createVertexBuffer("previousWorld0", 0, 4);
-                this._userInstancedBuffersStorage.vertexBuffers["previousWorld1"] = instancesPreviousBuffer.createVertexBuffer("previousWorld1", 4, 4);
-                this._userInstancedBuffersStorage.vertexBuffers["previousWorld2"] = instancesPreviousBuffer.createVertexBuffer("previousWorld2", 8, 4);
-                this._userInstancedBuffersStorage.vertexBuffers["previousWorld3"] = instancesPreviousBuffer.createVertexBuffer("previousWorld3", 12, 4);
+                vertexAndArrayObjectBuffers["previousWorld0"] = instancesPreviousBuffer.createVertexBuffer("previousWorld0", 0, 4);
+                vertexAndArrayObjectBuffers["previousWorld1"] = instancesPreviousBuffer.createVertexBuffer("previousWorld1", 4, 4);
+                vertexAndArrayObjectBuffers["previousWorld2"] = instancesPreviousBuffer.createVertexBuffer("previousWorld2", 8, 4);
+                vertexAndArrayObjectBuffers["previousWorld3"] = instancesPreviousBuffer.createVertexBuffer("previousWorld3", 12, 4);
             }
             this._invalidateInstanceVertexArrayObject();
         }
@@ -1742,7 +1798,7 @@ export class Mesh extends AbstractMesh {
     _renderWithInstances(subMesh, fillMode, batch, effect, engine) {
         const visibleInstances = batch.visibleInstances[subMesh._id];
         const visibleInstanceCount = visibleInstances ? visibleInstances.length : 0;
-        const instanceStorage = this._instanceDataStorage;
+        const instanceStorage = batch.parent;
         const currentInstancesBufferSize = instanceStorage.instancesBufferSize;
         const matricesCount = visibleInstanceCount + 1;
         const bufferSize = matricesCount * 16 * 4;
@@ -1844,12 +1900,15 @@ export class Mesh extends AbstractMesh {
      * @internal
      */
     _rebuild(dispose = false) {
-        if (this._instanceDataStorage.instancesBuffer) {
-            // Dispose instance buffer to be recreated in _renderWithInstances when rendered
-            if (dispose) {
-                this._instanceDataStorage.instancesBuffer.dispose();
+        for (const renderPassId in this._instanceDataStorage.renderPasses) {
+            const instanceDataStorage = this._instanceDataStorage.renderPasses[renderPassId];
+            if (instanceDataStorage.instancesBuffer) {
+                // Dispose instance buffer to be recreated in _renderWithInstances when rendered
+                if (dispose) {
+                    instanceDataStorage.instancesBuffer.dispose();
+                }
+                instanceDataStorage.instancesBuffer = null;
             }
-            this._instanceDataStorage.instancesBuffer = null;
         }
         if (this._userInstancedBuffersStorage) {
             for (const kind in this._userInstancedBuffersStorage.vertexBuffers) {
@@ -1884,7 +1943,10 @@ export class Mesh extends AbstractMesh {
     /** @internal */
     _unFreeze() {
         this._instanceDataStorage.isFrozen = false;
-        this._instanceDataStorage.previousBatch = null;
+        for (const renderPassId in this._instanceDataStorage.renderPasses) {
+            const instanceDataStorage = this._instanceDataStorage.renderPasses[renderPassId];
+            instanceDataStorage.previousBatch = null;
+        }
     }
     /**
      * Triggers the draw call for the mesh (or a submesh), for a specific render pass id
@@ -2018,7 +2080,16 @@ export class Mesh extends AbstractMesh {
         }
         // Alpha mode
         if (enableAlphaMode) {
-            engine.setAlphaMode(this._internalMeshDataInfo._effectiveMaterial.alphaMode);
+            const effectiveMaterial = this._internalMeshDataInfo._effectiveMaterial;
+            if (effectiveMaterial.alphaModes.length === 1) {
+                engine.setAlphaMode(effectiveMaterial.alphaMode);
+            }
+            else {
+                for (let i = 0; i < effectiveMaterial.alphaModes.length; i++) {
+                    const alphaMode = effectiveMaterial.alphaModes[i];
+                    engine.setAlphaMode(alphaMode !== undefined ? alphaMode : 2, false, i);
+                }
+            }
         }
         let drawWrapper;
         if (this._internalMeshDataInfo._effectiveMaterial._storeEffectOnSubMeshes) {
@@ -2050,12 +2121,12 @@ export class Mesh extends AbstractMesh {
             if (mainDeterminant < 0) {
                 sideOrientation = sideOrientation === Material.ClockWiseSideOrientation ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;
             }
-            instanceDataStorage.sideOrientation = sideOrientation;
+            this._internalMeshDataInfo._effectiveSideOrientation = sideOrientation;
         }
-        else {
-            sideOrientation = instanceDataStorage.sideOrientation;
+        else if (this.hasInstances) {
+            sideOrientation = this._internalMeshDataInfo._effectiveSideOrientation;
         }
-        const reverse = this._internalMeshDataInfo._effectiveMaterial._preBind(drawWrapper, sideOrientation);
+        const reverse = this._internalMeshDataInfo._effectiveMaterial._preBind(drawWrapper, this._internalMeshDataInfo._effectiveSideOrientation);
         if (this._internalMeshDataInfo._effectiveMaterial.forceDepthWrite) {
             engine.setDepthWrite(true);
         }
@@ -2515,7 +2586,6 @@ export class Mesh extends AbstractMesh {
             }
         }
         internalDataInfo._source = null;
-        this._instanceDataStorage.visibleInstances = {};
         // Instances
         this._disposeInstanceSpecificData();
         // Thin instances