@babylonjs/core 9.9.1 → 9.10.0

package/Meshes/abstractMesh.pure.d.ts

@@ -3,7 +3,7 @@ import { Observable } from "../Misc/observable.pure.js";
 import { type Nullable, type FloatArray, type IndicesArray, type DeepImmutable } from "../types.js";
 import { type Camera } from "../Cameras/camera.pure.js";
 import { type Scene, type IDisposable } from "../scene.pure.js";
-import { type Vector2, Matrix, Vector3 } from "../Maths/math.vector.pure.js";
+import { type Vector2, type Vector4, Matrix, Vector3 } from "../Maths/math.vector.pure.js";
 import { type Node } from "../node.js";
 import { VertexBuffer } from "../Buffers/buffer.pure.js";
 import { type IGetSetVerticesData } from "../Meshes/mesh.vertexData.js";
@@ -48,6 +48,10 @@ export interface IMeshDataOptions {
     applySkeleton?: boolean;
     /** Apply morph when computing the bounding info. Defaults to false. */
     applyMorph?: boolean;
+    /** Apply baked vertex animation when computing data. Defaults to false. */
+    applyBakedVertexAnimation?: boolean;
+    /** Baked vertex animation settings to use instead of the manager's animationParameters. */
+    bakedVertexAnimationSettings?: DeepImmutable<Vector4>;
     /** Update the cached positions stored as a Vector3 array. Defaults to true. */
     updatePositionsArray?: boolean;
     /**

package/Meshes/abstractMesh.pure.js

@@ -16,6 +16,7 @@ import { extractMinAndMax } from "../Maths/math.functions.js";
 import { Color3, Color4 } from "../Maths/math.color.pure.js";
 import { Epsilon } from "../Maths/math.constants.js";
 import { Axis } from "../Maths/math.axis.js";
+import { Logger } from "../Misc/logger.js";
 import { nativeOverride } from "../Misc/decorators.js";
 import { AbstractEngine } from "../Engines/abstractEngine.pure.js";
 import { RegisterClass } from "../Misc/typeStore.js";
@@ -87,6 +88,81 @@ function ApplySkeleton(data, kind, skeletonMatrices, matricesIndicesData, matric
         tempVector.toArray(data, index);
     }
 }
+function BakedVertexAnimationModulo(value, divisor) {
+    return value - Math.floor(value / divisor) * divisor;
+}
+function BakedVertexAnimationHalfFloatToNumber(value) {
+    const sign = value & 0x8000 ? -1 : 1;
+    const exponent = (value & 0x7c00) >> 10;
+    const fraction = value & 0x03ff;
+    if (exponent === 0) {
+        return sign * Math.pow(2, -14) * (fraction / Math.pow(2, 10));
+    }
+    else if (exponent === 0x1f) {
+        return fraction ? NaN : sign * Infinity;
+    }
+    return sign * Math.pow(2, exponent - 15) * (1 + fraction / Math.pow(2, 10));
+}
+function GetBakedVertexAnimationFrame(animationSettings, time) {
+    const totalFrames = animationSettings.y - animationSettings.x + 1;
+    const normalizedTime = (time * animationSettings.w) / totalFrames;
+    const frameCorrection = normalizedTime < 1 ? 0 : 1;
+    const numOfFrames = totalFrames - frameCorrection;
+    let frameNum = BakedVertexAnimationModulo(normalizedTime - Math.floor(normalizedTime), 1) * numOfFrames;
+    frameNum = BakedVertexAnimationModulo(frameNum + animationSettings.z, numOfFrames);
+    return Math.floor(frameNum) + animationSettings.x + frameCorrection;
+}
+function ReadBakedVertexAnimationMatrixToRef(data, offset, matrix) {
+    if (data instanceof Float32Array) {
+        Matrix.FromArrayToRef(data, offset, matrix);
+        return;
+    }
+    matrix.copyFromFloats(BakedVertexAnimationHalfFloatToNumber(data[offset]), BakedVertexAnimationHalfFloatToNumber(data[offset + 1]), BakedVertexAnimationHalfFloatToNumber(data[offset + 2]), BakedVertexAnimationHalfFloatToNumber(data[offset + 3]), BakedVertexAnimationHalfFloatToNumber(data[offset + 4]), BakedVertexAnimationHalfFloatToNumber(data[offset + 5]), BakedVertexAnimationHalfFloatToNumber(data[offset + 6]), BakedVertexAnimationHalfFloatToNumber(data[offset + 7]), BakedVertexAnimationHalfFloatToNumber(data[offset + 8]), BakedVertexAnimationHalfFloatToNumber(data[offset + 9]), BakedVertexAnimationHalfFloatToNumber(data[offset + 10]), BakedVertexAnimationHalfFloatToNumber(data[offset + 11]), BakedVertexAnimationHalfFloatToNumber(data[offset + 12]), BakedVertexAnimationHalfFloatToNumber(data[offset + 13]), BakedVertexAnimationHalfFloatToNumber(data[offset + 14]), BakedVertexAnimationHalfFloatToNumber(data[offset + 15]));
+}
+function ApplyBakedVertexAnimation(data, kind, bakedVertexAnimationManager, animationSettings, matricesIndicesData, matricesWeightsData, matricesIndicesExtraData, matricesWeightsExtraData, numBoneInfluencers) {
+    const texture = bakedVertexAnimationManager.texture;
+    const internalTexture = texture?.getInternalTexture();
+    const textureData = internalTexture?._bufferView;
+    if (!(textureData instanceof Float32Array) && !(textureData instanceof Uint16Array)) {
+        Logger.Warn("Baked vertex animation bounding info requires CPU-readable Float32Array or Uint16Array texture data.", 1);
+        return false;
+    }
+    const textureSize = texture.getSize();
+    const frame = GetBakedVertexAnimationFrame(animationSettings, bakedVertexAnimationManager.time);
+    if (!isFinite(frame) || frame < 0 || frame >= textureSize.height) {
+        Logger.Warn("Baked vertex animation bounding info could not be refreshed because the computed frame is outside the texture.", 1);
+        return false;
+    }
+    const tempVector = TmpVectors.Vector3[0];
+    const finalMatrix = TmpVectors.Matrix[0];
+    const tempMatrix = TmpVectors.Matrix[1];
+    const textureFrameOffset = frame * textureSize.width * 4;
+    const transformFromFloatsToRef = kind === VertexBuffer.NormalKind ? Vector3.TransformNormalFromFloatsToRef : Vector3.TransformCoordinatesFromFloatsToRef;
+    for (let index = 0, matWeightIdx = 0; index < data.length; index += 3, matWeightIdx += 4) {
+        finalMatrix.reset();
+        let inf;
+        let weight;
+        for (inf = 0; inf < 4 && inf < numBoneInfluencers; inf++) {
+            weight = matricesWeightsData[matWeightIdx + inf];
+            if (weight > 0) {
+                ReadBakedVertexAnimationMatrixToRef(textureData, textureFrameOffset + Math.floor(matricesIndicesData[matWeightIdx + inf]) * 16, tempMatrix);
+                tempMatrix.scaleAndAddToRef(weight, finalMatrix);
+            }
+        }
+        if (matricesIndicesExtraData && matricesWeightsExtraData) {
+            for (inf = 0; inf < 4 && inf + 4 < numBoneInfluencers; inf++) {
+                weight = matricesWeightsExtraData[matWeightIdx + inf];
+                if (weight > 0) {
+                    ReadBakedVertexAnimationMatrixToRef(textureData, textureFrameOffset + Math.floor(matricesIndicesExtraData[matWeightIdx + inf]) * 16, tempMatrix);
+                    tempMatrix.scaleAndAddToRef(weight, finalMatrix);
+                }
+            }
+        }
+        transformFromFloatsToRef(data[index], data[index + 1], data[index + 2], finalMatrix, tempVector);
+        tempVector.toArray(data, index);
+    }
+    return true;
+}
 /** @internal */
 class _FacetDataStorage {
     constructor() {
@@ -1341,13 +1417,27 @@ export class AbstractMesh extends TransformNode {
             }
             data = cache._outputData;
         }
-        else if ((options.applyMorph && this.morphTargetManager) || (options.applySkeleton && this.skeleton)) {
+        else if ((options.applyMorph && this.morphTargetManager) ||
+            (options.applySkeleton && this.skeleton) ||
+            (options.applyBakedVertexAnimation && this.bakedVertexAnimationManager?.isEnabled)) {
             data = data.slice();
         }
         if (options.applyMorph && this.morphTargetManager) {
             ApplyMorph(data, kind, this.morphTargetManager);
         }
-        if (options.applySkeleton && this.skeleton) {
+        const bakedVertexAnimationManager = this.bakedVertexAnimationManager;
+        let bakedVertexAnimationApplied = false;
+        if (options.applyBakedVertexAnimation && bakedVertexAnimationManager?.isEnabled) {
+            const matricesIndicesData = getVertexData(VertexBuffer.MatricesIndicesKind);
+            const matricesWeightsData = getVertexData(VertexBuffer.MatricesWeightsKind);
+            if (matricesWeightsData && matricesIndicesData) {
+                const needExtras = this.numBoneInfluencers > 4;
+                const matricesIndicesExtraData = needExtras ? getVertexData(VertexBuffer.MatricesIndicesExtraKind) : null;
+                const matricesWeightsExtraData = needExtras ? getVertexData(VertexBuffer.MatricesWeightsExtraKind) : null;
+                bakedVertexAnimationApplied = ApplyBakedVertexAnimation(data, kind, bakedVertexAnimationManager, options.bakedVertexAnimationSettings ?? bakedVertexAnimationManager.animationParameters, matricesIndicesData, matricesWeightsData, matricesIndicesExtraData, matricesWeightsExtraData, this.numBoneInfluencers);
+            }
+        }
+        if (!bakedVertexAnimationApplied && options.applySkeleton && this.skeleton) {
             const matricesIndicesData = getVertexData(VertexBuffer.MatricesIndicesKind);
             const matricesWeightsData = getVertexData(VertexBuffer.MatricesWeightsKind);
             if (matricesWeightsData && matricesIndicesData) {