@babylonjs/core 7.13.0 → 7.13.1

package/Meshes/abstractMesh.d.ts

@@ -30,6 +30,33 @@ import type { Collider } from "../Collisions/collider";
 import type { TrianglePickingPredicate } from "../Culling/ray";
 import type { RenderingGroup } from "../Rendering/renderingGroup";
 import type { IEdgesRendererOptions } from "../Rendering/edgesRenderer";
+/**
+ * Opaque cache when computing data about a mesh
+ */
+export interface IMeshDataCache {
+    /** @internal */
+    _outputData?: Float32Array;
+    /** @internal */
+    _vertexData?: {
+        [kind: string]: Float32Array;
+    };
+}
+/**
+ * Options when computing data about a mesh
+ */
+export interface IMeshDataOptions {
+    /** Apply skeleton when computing the bounding info. Defaults to false. */
+    applySkeleton?: boolean;
+    /** Apply morph when computing the bounding info. Defaults to false. */
+    applyMorph?: boolean;
+    /** Update the cached positions stored as a Vector3 array. Defaults to true. */
+    updatePositionsArray?: boolean;
+    /**
+     * Cache to avoid redundant allocations and computations when computing the bounding info multiple times. Pass in
+     * an initial empty object and continue with subsequent calls using the same object. Caching is disabled by default.
+     */
+    cache?: IMeshDataCache;
+}
 /** @internal */
 declare class _FacetDataStorage {
     facetPositions: Vector3[];
@@ -477,7 +504,7 @@ export declare abstract class AbstractMesh extends TransformNode implements IDis
     /** Gets the list of lights affecting that mesh */
     get lightSources(): Light[];
     /** @internal */
-    get _positions(): Nullable<Vector3[]>;
+    abstract get _positions(): Nullable<Vector3[]>;
     /** @internal */
     _waitingData: {
         lods: Nullable<any>;
@@ -606,6 +633,14 @@ export declare abstract class AbstractMesh extends TransformNode implements IDis
      * @returns null
      */
     getVerticesData(kind: string): Nullable<FloatArray>;
+    /**
+     * Copies the requested vertex data kind into the given vertex data map. Float data is constructed if the map doesn't have the data.
+     * @param kind defines the vertex data kind to use
+     * @param vertexData defines the map that stores the resulting data
+     */
+    abstract copyVerticesData(kind: string, vertexData: {
+        [kind: string]: Float32Array;
+    }): void;
     /**
      * Sets the vertex data of the mesh geometry for the requested `kind`.
      * If the mesh has no geometry, a new Geometry object is set to the mesh and then passed this vertex data.
@@ -783,11 +818,18 @@ export declare abstract class AbstractMesh extends TransformNode implements IDis
     /**
      * This method recomputes and sets a new BoundingInfo to the mesh unless it is locked.
      * This means the mesh underlying bounding box and sphere are recomputed.
-     * @param applySkeleton defines whether to apply the skeleton before computing the bounding info
-     * @param applyMorph  defines whether to apply the morph target before computing the bounding info
+     * @param options defines a set of options for computing the bounding info
+     * @returns the current mesh
+     */
+    abstract refreshBoundingInfo(options: IMeshDataOptions): AbstractMesh;
+    /**
+     * This method recomputes and sets a new BoundingInfo to the mesh unless it is locked.
+     * This means the mesh underlying bounding box and sphere are recomputed.
+     * @param applySkeletonOrOptions defines whether to apply the skeleton before computing the bounding info or a set of options
+     * @param applyMorph defines whether to apply the morph target before computing the bounding info
      * @returns the current mesh
      */
-    refreshBoundingInfo(applySkeleton?: boolean, applyMorph?: boolean): AbstractMesh;
+    abstract refreshBoundingInfo(applySkeletonOrOptions: boolean | IMeshDataOptions, applyMorph: boolean): AbstractMesh;
     /**
      * @internal
      */
@@ -799,15 +841,9 @@ export declare abstract class AbstractMesh extends TransformNode implements IDis
         minimum: Vector3;
         maximum: Vector3;
     }): void;
-    /**
-     * Internal function to get buffer data and possibly apply morphs and normals
-     * @param applySkeleton
-     * @param applyMorph
-     * @param data
-     * @param kind the kind of data you want. Can be Normal or Position
-     * @returns a FloatArray of the vertex data
-     */
-    private _getData;
+    private static _ApplySkeleton;
+    /** @internal */
+    protected _getData(options: IMeshDataOptions, data: Nullable<FloatArray>, kind?: string): Nullable<FloatArray>;
     /**
      * Get the normals vertex data and optionally apply skeleton and morphing.
      * @param applySkeleton defines whether to apply the skeleton
@@ -823,10 +859,6 @@ export declare abstract class AbstractMesh extends TransformNode implements IDis
      * @returns the position data
      */
     getPositionData(applySkeleton?: boolean, applyMorph?: boolean, data?: Nullable<FloatArray>): Nullable<FloatArray>;
-    /**
-     * @internal
-     */
-    _getPositionData(applySkeleton: boolean, applyMorph: boolean): Nullable<FloatArray>;
     /** @internal */
     _updateBoundingInfo(): AbstractMesh;
     /**

package/Meshes/abstractMesh.js

@@ -1,3 +1,4 @@
+import { __decorate } from "../tslib.es6.js";
 import { Observable } from "../Misc/observable.js";
 import { Quaternion, Matrix, Vector3, TmpVectors } from "../Maths/math.vector.js";
 import { Engine } from "../Engines/engine.js";
@@ -15,6 +16,69 @@ import { Color3, Color4 } from "../Maths/math.color.js";
 import { Epsilon } from "../Maths/math.constants.js";
 import { Axis } from "../Maths/math.axis.js";
 import { RegisterClass } from "../Misc/typeStore.js";
+import { nativeOverride } from "../Misc/decorators.js";
+function applyMorph(data, kind, morphTargetManager) {
+    let getTargetData = null;
+    switch (kind) {
+        case VertexBuffer.PositionKind:
+            getTargetData = (target) => target.getPositions();
+            break;
+        case VertexBuffer.NormalKind:
+            getTargetData = (target) => target.getNormals();
+            break;
+        case VertexBuffer.TangentKind:
+            getTargetData = (target) => target.getTangents();
+            break;
+        case VertexBuffer.UVKind:
+            getTargetData = (target) => target.getUVs();
+            break;
+        default:
+            return;
+    }
+    for (let index = 0; index < data.length; index++) {
+        let value = data[index];
+        for (let targetCount = 0; targetCount < morphTargetManager.numTargets; targetCount++) {
+            const target = morphTargetManager.getTarget(targetCount);
+            const influence = target.influence;
+            if (influence !== 0) {
+                const targetData = getTargetData(target);
+                if (targetData) {
+                    value += (targetData[index] - data[index]) * influence;
+                }
+            }
+        }
+        data[index] = value;
+    }
+}
+function applySkeleton(data, kind, skeletonMatrices, matricesIndicesData, matricesWeightsData, matricesIndicesExtraData, matricesWeightsExtraData) {
+    const tempVector = TmpVectors.Vector3[0];
+    const finalMatrix = TmpVectors.Matrix[0];
+    const tempMatrix = TmpVectors.Matrix[1];
+    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++) {
+            weight = matricesWeightsData[matWeightIdx + inf];
+            if (weight > 0) {
+                Matrix.FromFloat32ArrayToRefScaled(skeletonMatrices, Math.floor(matricesIndicesData[matWeightIdx + inf] * 16), weight, tempMatrix);
+                finalMatrix.addToSelf(tempMatrix);
+            }
+        }
+        if (matricesIndicesExtraData && matricesWeightsExtraData) {
+            for (inf = 0; inf < 4; inf++) {
+                weight = matricesWeightsExtraData[matWeightIdx + inf];
+                if (weight > 0) {
+                    Matrix.FromFloat32ArrayToRefScaled(skeletonMatrices, Math.floor(matricesIndicesExtraData[matWeightIdx + inf] * 16), weight, tempMatrix);
+                    finalMatrix.addToSelf(tempMatrix);
+                }
+            }
+        }
+        transformFromFloatsToRef(data[index], data[index + 1], data[index + 2], finalMatrix, tempVector);
+        tempVector.toArray(data, index);
+    }
+}
 /** @internal */
 // eslint-disable-next-line @typescript-eslint/naming-convention
 class _FacetDataStorage {
@@ -480,10 +544,6 @@ export class AbstractMesh extends TransformNode {
     get lightSources() {
         return this._lightSources;
     }
-    /** @internal */
-    get _positions() {
-        return null;
-    }
     /**
      * Gets or sets a skeleton to apply skinning transformations
      * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/bonesSkeletons
@@ -1188,20 +1248,6 @@ export class AbstractMesh extends TransformNode {
         const defForwardMult = this.definedFacingForward ? 1 : -1;
         return new Vector3(flipBack * defForwardMult, twirlClockwise, tiltRight * defForwardMult);
     }
-    /**
-     * This method recomputes and sets a new BoundingInfo to the mesh unless it is locked.
-     * This means the mesh underlying bounding box and sphere are recomputed.
-     * @param applySkeleton defines whether to apply the skeleton before computing the bounding info
-     * @param applyMorph  defines whether to apply the morph target before computing the bounding info
-     * @returns the current mesh
-     */
-    refreshBoundingInfo(applySkeleton = false, applyMorph = false) {
-        if (this._boundingInfo && this._boundingInfo.isLocked) {
-            return this;
-        }
-        this._refreshBoundingInfo(this._getPositionData(applySkeleton, applyMorph), null);
-        return this;
-    }
     /**
      * @internal
      */
@@ -1239,101 +1285,66 @@ export class AbstractMesh extends TransformNode {
         }
         this._updateBoundingInfo();
     }
-    /**
-     * Internal function to get buffer data and possibly apply morphs and normals
-     * @param applySkeleton
-     * @param applyMorph
-     * @param data
-     * @param kind the kind of data you want. Can be Normal or Position
-     * @returns a FloatArray of the vertex data
-     */
-    _getData(applySkeleton = false, applyMorph = false, data, kind = VertexBuffer.PositionKind) {
-        data = data ?? this.getVerticesData(kind).slice();
-        if (data && applyMorph && this.morphTargetManager) {
-            let faceIndexCount = 0;
-            let positionIndex = 0;
-            for (let vertexCount = 0; vertexCount < data.length; vertexCount++) {
-                let value = data[vertexCount];
-                for (let targetCount = 0; targetCount < this.morphTargetManager.numTargets; targetCount++) {
-                    const targetMorph = this.morphTargetManager.getTarget(targetCount);
-                    const influence = targetMorph.influence;
-                    if (influence !== 0.0) {
-                        let morphTargetData = null;
-                        switch (kind) {
-                            case VertexBuffer.PositionKind:
-                                morphTargetData = targetMorph.getPositions();
-                                break;
-                            case VertexBuffer.NormalKind:
-                                morphTargetData = targetMorph.getNormals();
-                                break;
-                            case VertexBuffer.TangentKind:
-                                morphTargetData = targetMorph.getTangents();
-                                break;
-                            case VertexBuffer.UVKind:
-                                morphTargetData = targetMorph.getUVs();
-                                break;
-                        }
-                        if (morphTargetData) {
-                            value += (morphTargetData[vertexCount] - data[vertexCount]) * influence;
-                        }
-                    }
-                }
-                data[vertexCount] = value;
-                faceIndexCount++;
-                if (kind === VertexBuffer.PositionKind) {
-                    if (this._positions && faceIndexCount === 3) {
-                        // We want to merge into positions every 3 indices starting (but not 0)
-                        faceIndexCount = 0;
-                        const index = positionIndex * 3;
-                        this._positions[positionIndex++].copyFromFloats(data[index], data[index + 1], data[index + 2]);
-                    }
+    // This function is only here so we can apply the nativeOverride decorator.
+    static _ApplySkeleton(data, kind, skeletonMatrices, matricesIndicesData, matricesWeightsData, matricesIndicesExtraData, matricesWeightsExtraData) {
+        applySkeleton(data, kind, skeletonMatrices, matricesIndicesData, matricesWeightsData, matricesIndicesExtraData, matricesWeightsExtraData);
+    }
+    /** @internal */
+    _getData(options, data, kind = VertexBuffer.PositionKind) {
+        const cache = options.cache;
+        const getVertexData = (kind) => {
+            if (cache) {
+                const vertexData = (cache._vertexData || (cache._vertexData = {}));
+                if (!vertexData[kind]) {
+                    this.copyVerticesData(kind, vertexData);
                 }
+                return vertexData[kind];
+            }
+            return this.getVerticesData(kind);
+        };
+        data || (data = getVertexData(kind));
+        if (!data) {
+            return null;
+        }
+        if (cache) {
+            if (cache._outputData) {
+                cache._outputData.set(data);
+            }
+            else {
+                cache._outputData = new Float32Array(data);
             }
+            data = cache._outputData;
         }
-        if (data && applySkeleton && this.skeleton) {
-            const matricesIndicesData = this.getVerticesData(VertexBuffer.MatricesIndicesKind);
-            const matricesWeightsData = this.getVerticesData(VertexBuffer.MatricesWeightsKind);
+        else if ((options.applyMorph && this.morphTargetManager) || (options.applySkeleton && this.skeleton)) {
+            data = data.slice();
+        }
+        if (options.applyMorph && this.morphTargetManager) {
+            applyMorph(data, kind, this.morphTargetManager);
+        }
+        if (options.applySkeleton && this.skeleton) {
+            const matricesIndicesData = getVertexData(VertexBuffer.MatricesIndicesKind);
+            const matricesWeightsData = getVertexData(VertexBuffer.MatricesWeightsKind);
             if (matricesWeightsData && matricesIndicesData) {
                 const needExtras = this.numBoneInfluencers > 4;
-                const matricesIndicesExtraData = needExtras ? this.getVerticesData(VertexBuffer.MatricesIndicesExtraKind) : null;
-                const matricesWeightsExtraData = needExtras ? this.getVerticesData(VertexBuffer.MatricesWeightsExtraKind) : null;
+                const matricesIndicesExtraData = needExtras ? getVertexData(VertexBuffer.MatricesIndicesExtraKind) : null;
+                const matricesWeightsExtraData = needExtras ? getVertexData(VertexBuffer.MatricesWeightsExtraKind) : null;
                 const skeletonMatrices = this.skeleton.getTransformMatrices(this);
-                const tempVector = TmpVectors.Vector3[0];
-                const finalMatrix = TmpVectors.Matrix[0];
-                const tempMatrix = TmpVectors.Matrix[1];
-                let matWeightIdx = 0;
-                for (let index = 0; index < data.length; index += 3, matWeightIdx += 4) {
-                    finalMatrix.reset();
-                    let inf;
-                    let weight;
-                    for (inf = 0; inf < 4; inf++) {
-                        weight = matricesWeightsData[matWeightIdx + inf];
-                        if (weight > 0) {
-                            Matrix.FromFloat32ArrayToRefScaled(skeletonMatrices, Math.floor(matricesIndicesData[matWeightIdx + inf] * 16), weight, tempMatrix);
-                            finalMatrix.addToSelf(tempMatrix);
-                        }
-                    }
-                    if (needExtras) {
-                        for (inf = 0; inf < 4; inf++) {
-                            weight = matricesWeightsExtraData[matWeightIdx + inf];
-                            if (weight > 0) {
-                                Matrix.FromFloat32ArrayToRefScaled(skeletonMatrices, Math.floor(matricesIndicesExtraData[matWeightIdx + inf] * 16), weight, tempMatrix);
-                                finalMatrix.addToSelf(tempMatrix);
-                            }
-                        }
-                    }
-                    if (kind === VertexBuffer.NormalKind) {
-                        Vector3.TransformNormalFromFloatsToRef(data[index], data[index + 1], data[index + 2], finalMatrix, tempVector);
-                    }
-                    else {
-                        Vector3.TransformCoordinatesFromFloatsToRef(data[index], data[index + 1], data[index + 2], finalMatrix, tempVector);
-                    }
-                    tempVector.toArray(data, index);
-                    if (kind === VertexBuffer.PositionKind && this._positions) {
-                        this._positions[index / 3].copyFrom(tempVector);
-                    }
+                AbstractMesh._ApplySkeleton(data, kind, skeletonMatrices, matricesIndicesData, matricesWeightsData, matricesIndicesExtraData, matricesWeightsExtraData);
+            }
+        }
+        if (options.updatePositionsArray !== false && kind === VertexBuffer.PositionKind) {
+            const positions = this._internalAbstractMeshDataInfo._positions || [];
+            const previousLength = positions.length;
+            positions.length = data.length / 3;
+            if (previousLength < positions.length) {
+                for (let positionIndex = previousLength; positionIndex < positions.length; positionIndex++) {
+                    positions[positionIndex] = new Vector3();
                 }
             }
+            for (let positionIndex = 0, dataIndex = 0; positionIndex < positions.length; positionIndex++, dataIndex += 3) {
+                positions[positionIndex].copyFromFloats(data[dataIndex], data[dataIndex + 1], data[dataIndex + 2]);
+            }
+            this._internalAbstractMeshDataInfo._positions = positions;
         }
         return data;
     }
@@ -1344,7 +1355,7 @@ export class AbstractMesh extends TransformNode {
      * @returns the normals data
      */
     getNormalsData(applySkeleton = false, applyMorph = false) {
-        return this._getData(applySkeleton, applyMorph, null, VertexBuffer.NormalKind);
+        return this._getData({ applySkeleton, applyMorph, updatePositionsArray: false }, null, VertexBuffer.NormalKind);
     }
     /**
      * Get the position vertex data and optionally apply skeleton and morphing.
@@ -1353,30 +1364,8 @@ export class AbstractMesh extends TransformNode {
      * @param data defines the position data to apply the skeleton and morph to
      * @returns the position data
      */
-    getPositionData(applySkeleton = false, applyMorph = false, data) {
-        return this._getData(applySkeleton, applyMorph, data, VertexBuffer.PositionKind);
-    }
-    /**
-     * @internal
-     */
-    _getPositionData(applySkeleton, applyMorph) {
-        let data = this.getVerticesData(VertexBuffer.PositionKind);
-        if (this._internalAbstractMeshDataInfo._positions) {
-            this._internalAbstractMeshDataInfo._positions = null;
-        }
-        if (data && ((applySkeleton && this.skeleton) || (applyMorph && this.morphTargetManager))) {
-            data = data.slice();
-            this._generatePointsArray();
-            if (this._positions) {
-                const pos = this._positions;
-                this._internalAbstractMeshDataInfo._positions = new Array(pos.length);
-                for (let i = 0; i < pos.length; i++) {
-                    this._internalAbstractMeshDataInfo._positions[i] = pos[i]?.clone() || new Vector3();
-                }
-            }
-            return this.getPositionData(applySkeleton, applyMorph, data);
-        }
-        return data;
+    getPositionData(applySkeleton = false, applyMorph = false, data = null) {
+        return this._getData({ applySkeleton, applyMorph, updatePositionsArray: false }, data, VertexBuffer.PositionKind);
     }
     /** @internal */
     _updateBoundingInfo() {
@@ -2285,5 +2274,12 @@ AbstractMesh.CULLINGSTRATEGY_OPTIMISTIC_INCLUSION = 2;
  *  If not, apply the Bounding Sphere Only strategy. No Bounding Box is tested here.
  */
 AbstractMesh.CULLINGSTRATEGY_OPTIMISTIC_INCLUSION_THEN_BSPHERE_ONLY = 3;
+__decorate([
+    nativeOverride.filter((...[data, matricesIndicesData, matricesWeightsData, matricesIndicesExtraData, matricesWeightsExtraData]) => !Array.isArray(data) &&
+        !Array.isArray(matricesIndicesData) &&
+        !Array.isArray(matricesWeightsData) &&
+        !Array.isArray(matricesIndicesExtraData) &&
+        !Array.isArray(matricesWeightsExtraData))
+], AbstractMesh, "_ApplySkeleton", null);
 RegisterClass("BABYLON.AbstractMesh", AbstractMesh);
 //# sourceMappingURL=abstractMesh.js.map