@zephyr3d/scene 0.4.0 → 0.5.0

package/dist/animation/animation.js

@@ -1,47 +1,22 @@
-import { Quaternion, Vector3, Matrix4x4 } from '@zephyr3d/base';
-import { BoundingBox } from '../utility/bounding_volume.js';
-import { Application } from '../app.js';
-
 /**
  * Animation that contains multiple tracks
  * @public
  */ class AnimationClip {
     /** @internal */ _name;
-    /** @internal */ _model;
-    /** @internal */ _repeat;
-    /** @internal */ _speedRatio;
-    /** @internal */ _repeatCounter;
     /** @internal */ _duration;
-    /** @internal */ _isPlaying;
-    /** @internal */ _lastUpdateFrame;
-    /** @internal */ _currentPlayTime;
     /** @internal */ _tracks;
     /** @internal */ _skeletons;
-    /** @internal */ _tmpPosition;
-    /** @internal */ _tmpRotation;
-    /** @internal */ _tmpScale;
     /**
    * Creates an animation instance
    * @param name - Name of the animation
    * @param model - Parent node if this is a skeleton animation
-   */ constructor(name, model){
+   */ constructor(name){
         this._name = name;
-        this._model = model ?? null;
         this._tracks = new Map();
         this._duration = 0;
-        this._repeat = 0;
-        this._repeatCounter = 0;
-        this._speedRatio = 1;
-        this._isPlaying = false;
-        this._currentPlayTime = 0;
-        this._lastUpdateFrame = 0;
-        this._skeletons = new Map();
-        this._tmpRotation = new Quaternion();
-        this._tmpPosition = new Vector3();
-        this._tmpScale = new Vector3();
+        this._skeletons = new Set();
     }
     /** Disposes self */ dispose() {
-        this._model = null;
         this._tracks = null;
         this._skeletons?.forEach((val, key)=>key.dispose());
         this._skeletons = null;
@@ -52,6 +27,9 @@ import { Application } from '../app.js';
     /** Gets all the tracks of this animation */ get tracks() {
         return this._tracks;
     }
+    /** Gets all skeletons */ get skeletons() {
+        return this._skeletons;
+    }
     /** The duration of the animation */ get timeDuration() {
         return this._duration;
     }
@@ -60,19 +38,8 @@ import { Application } from '../app.js';
    * @param skeleton - The skeleton to be added
    * @param meshList - The meshes controlled by the skeleton
    * @param boundingBoxInfo - Bounding box information for the skeleton
-   */ addSkeleton(skeleton, meshList, boundingBoxInfo) {
-        let meshes = this._skeletons.get(skeleton);
-        if (!meshes) {
-            meshes = [];
-            this._skeletons.set(skeleton, meshes);
-        }
-        for(let i = 0; i < meshList.length; i++){
-            meshes.push({
-                mesh: meshList[i],
-                bounding: boundingBoxInfo[i],
-                box: new BoundingBox()
-            });
-        }
+   */ addSkeleton(skeleton) {
+        this._skeletons.add(skeleton);
     }
     /**
    * Adds an animation track to the animation
@@ -83,90 +50,31 @@ import { Application } from '../app.js';
         if (!track) {
             return;
         }
+        if (track.animation) {
+            if (track.animation === this) {
+                return;
+            } else {
+                console.error('Track is already in another animation');
+                return;
+            }
+        }
+        const blendId = track.getBlendId();
+        const tracks = this._tracks.get(node);
+        if (tracks && tracks.findIndex((track)=>track.getBlendId() === blendId) >= 0) {
+            console.error('Tracks with same BlendId could not be added to same animation');
+            return;
+        }
+        track.animation = this;
         let trackInfo = this._tracks.get(node);
         if (!trackInfo) {
-            trackInfo = {
-                poseTranslation: new Vector3(node.position),
-                poseRotation: new Quaternion(node.rotation),
-                poseScaling: new Vector3(node.scale),
-                tracks: []
-            };
+            trackInfo = [];
             this._tracks.set(node, trackInfo);
         }
-        trackInfo.tracks.push(track);
+        trackInfo.push(track);
         this._duration = Math.max(this._duration, track.interpolator.maxTime);
+        track.reset(node);
         return this;
     }
-    /**
-   * Check if the animation is playing
-   * @returns true if the animation is playing, otherwise false
-   */ isPlaying() {
-        return this._isPlaying;
-    }
-    /**
-   * Updates the animation state
-   */ update() {
-        const device = Application.instance.device;
-        if (!this._isPlaying || this._lastUpdateFrame === device.frameInfo.frameCounter) {
-            return;
-        }
-        this._lastUpdateFrame = device.frameInfo.frameCounter;
-        this._tracks.forEach((trackInfo, node)=>{
-            for (const track of trackInfo.tracks){
-                track.apply(node, this._currentPlayTime, this._duration);
-            }
-        });
-        this._skeletons.forEach((meshes, skeleton)=>{
-            skeleton.computeJoints();
-            for (const mesh of meshes){
-                skeleton.computeBoundingBox(mesh.bounding, mesh.mesh.invWorldMatrix);
-                mesh.mesh.setBoneMatrices(skeleton.jointTexture);
-                mesh.mesh.setInvBindMatrix(mesh.mesh.invWorldMatrix);
-                mesh.mesh.setAnimatedBoundingBox(mesh.bounding.boundingBox);
-            }
-        });
-        const timeAdvance = device.frameInfo.elapsedFrame * 0.001 * this._speedRatio;
-        this._currentPlayTime += timeAdvance;
-        if (this._currentPlayTime > this._duration) {
-            this._repeatCounter++;
-            this._currentPlayTime = 0;
-        } else if (this._currentPlayTime < 0) {
-            this._repeatCounter++;
-            this._currentPlayTime = this._duration;
-        }
-        if (this._repeat !== 0 && this._repeatCounter >= this._repeat) {
-            this.stop();
-        }
-    }
-    /**
-   * Starts playing the animation
-   */ play(repeat, speedRatio) {
-        this._isPlaying = true;
-        this._repeat = repeat;
-        this._speedRatio = speedRatio;
-        this._currentPlayTime = speedRatio < 0 ? this._duration : 0;
-        this.update();
-    }
-    /**
-   * Stops the animation
-   */ stop() {
-        this._isPlaying = false;
-        this._skeletons.forEach((meshes, skeleton)=>{
-            skeleton.computeBindPose();
-            for (const mesh of meshes){
-                const invWorldMatrix = Matrix4x4.multiply(mesh.mesh.invWorldMatrix, this._model.worldMatrix);
-                skeleton.computeBoundingBox(mesh.bounding, invWorldMatrix);
-                mesh.mesh.setBoneMatrices(skeleton.jointTexture);
-                mesh.mesh.setInvBindMatrix(invWorldMatrix);
-                mesh.mesh.setAnimatedBoundingBox(mesh.bounding.boundingBox);
-            }
-        });
-    }
-    /**
-   * Rewind the animation to the first frame
-   */ rewind() {
-        this._currentPlayTime = 0;
-    }
 }
 
 export { AnimationClip };

package/dist/animation/animation.js.map

@@ -1 +1 @@
-{"version":3,"file":"animation.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"animation.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/animation/animationset.js

@@ -1,16 +1,27 @@
+import { weightedAverage } from '@zephyr3d/base';
+import { Application } from '../app.js';
+
 /**
  * Animation set
  * @public
  */ class AnimationSet {
+    /** @internal */ _model;
     /** @internal */ _animations;
     /** @internal */ _scene;
+    /** @internal */ _activeTracks;
+    /** @internal */ _activeSkeletons;
+    /** @internal */ _activeAnimations;
     /**
    * Creates an instance of AnimationSet
    * @param scene - The scene to which the animation set belongs
-   */ constructor(scene){
+   */ constructor(scene, model){
         this._scene = scene;
+        this._model = model;
         this._scene.animationSet.push(this);
         this._animations = {};
+        this._activeTracks = new Map();
+        this._activeSkeletons = new Map();
+        this._activeAnimations = new Map();
     }
     /**
    * How many animations in this set
@@ -37,47 +48,173 @@
     /**
    * Updates all animations of the model
    */ update() {
-        for(const k in this._animations){
-            this._animations[k].update();
-        }
+        this._activeAnimations.forEach((v, k)=>{
+            if (v.fadeOut > 0 && v.fadeOutStart < 0) {
+                v.fadeOutStart = v.animateTime;
+            }
+            // Update animation time
+            if (v.firstFrame) {
+                v.firstFrame = false;
+            } else {
+                const timeAdvance = Application.instance.device.frameInfo.elapsedFrame * 0.001 * v.speedRatio;
+                v.currentTime += timeAdvance;
+                v.animateTime += timeAdvance;
+                if (v.currentTime > k.timeDuration) {
+                    v.repeatCounter++;
+                    v.currentTime = 0;
+                } else if (v.currentTime < 0) {
+                    v.repeatCounter++;
+                    v.currentTime = k.timeDuration;
+                }
+                if (v.repeat !== 0 && v.repeatCounter >= v.repeat) {
+                    this.stopAnimation(k.name);
+                } else if (v.fadeOut > 0) {
+                    if (v.animateTime - v.fadeOutStart >= v.fadeOut) {
+                        this.stopAnimation(k.name);
+                    }
+                }
+            }
+        });
+        // Update tracks
+        this._activeTracks.forEach((v, k)=>{
+            v.forEach((tracks)=>{
+                if (tracks.length > 0) {
+                    const weights = tracks.map((track)=>{
+                        const info = this._activeAnimations.get(track.animation);
+                        const weight = info.weight;
+                        const fadeIn = info.fadeIn === 0 ? 1 : Math.min(1, info.animateTime / info.fadeIn);
+                        let fadeOut = 1;
+                        if (info.fadeOut !== 0) {
+                            fadeOut = 1 - (info.animateTime - info.fadeOutStart) / info.fadeOut;
+                        }
+                        return weight * fadeIn * fadeOut;
+                    });
+                    const states = tracks.map((track)=>track.calculateState(this._activeAnimations.get(track.animation).currentTime));
+                    const state = weightedAverage(weights, states, (a, b, t)=>{
+                        return tracks[0].mixState(a, b, t);
+                    });
+                    tracks[0].applyState(k, state);
+                }
+            });
+        });
+        // Update skeletons
+        this._activeSkeletons.forEach((v, k)=>{
+            k.apply();
+        });
     }
     /**
    * Checks whether an animation is playing
    * @param name - Name of the animation to be checked
    * @returns true if the animation is playing, otherwise false
    */ isPlayingAnimation(name) {
-        if (name) {
-            return this._animations[name]?.isPlaying();
-        } else {
-            for(const k in this._animations){
-                if (this._animations[k].isPlaying()) {
-                    return true;
-                }
-            }
-            return false;
+        return name ? this._activeAnimations.has(this._animations[name]) : this._activeAnimations.size > 0;
+    }
+    /**
+   * Gets the weight of specific animation which is currently playing
+   * @param name - Name of the animation
+   * @returns Weight of the animation or 0 if this animation is not playing
+   */ getAnimationWeight(name) {
+        const ani = this._animations[name];
+        const info = this._activeAnimations.get(ani);
+        return info?.weight ?? 0;
+    }
+    /**
+   * Sets the weight of specific animation which is currently playing
+   * @param name - Name of the animation
+   * @param weight - New weight value
+   */ setAnimationWeight(name, weight) {
+        const ani = this._animations[name];
+        const info = this._activeAnimations.get(ani);
+        if (info) {
+            info.weight = weight;
         }
     }
     /**
    * Starts playing an animation of the model
    * @param name - Name of the animation to play
-   * @param repeat - The repeat times, 0 for always repeating, default is 1
-   * @param ratio - The speed ratio, default is 1. Use negative value to play backwards
-   */ playAnimation(name, repeat = 0, speedRatio = 1) {
+   * @param options - Playing options
+   */ playAnimation(name, options) {
         const ani = this._animations[name];
-        if (ani && !ani.isPlaying()) {
-            for (const name of this.getAnimationNames()){
-                if (this.isPlayingAnimation(name)) {
-                    this.stopAnimation(name);
+        if (!ani) {
+            console.error(`Animation ${name} not exists`);
+            return;
+        }
+        const fadeIn = Math.max(options?.fadeIn ?? 0, 0);
+        const info = this._activeAnimations.get(ani);
+        if (info) {
+            info.fadeOut = 0;
+            info.fadeIn = fadeIn;
+        } else {
+            const repeat = options?.repeat ?? 0;
+            const speedRatio = options?.speedRatio ?? 1;
+            const weight = options?.weight ?? 1;
+            this._activeAnimations.set(ani, {
+                repeat,
+                weight,
+                speedRatio,
+                fadeIn,
+                fadeOut: 0,
+                repeatCounter: 0,
+                currentTime: speedRatio < 0 ? ani.timeDuration : 0,
+                animateTime: 0,
+                fadeOutStart: 0,
+                firstFrame: true
+            });
+            ani.tracks?.forEach((v, k)=>{
+                let nodeTracks = this._activeTracks.get(k);
+                if (!nodeTracks) {
+                    nodeTracks = new Map();
+                    this._activeTracks.set(k, nodeTracks);
                 }
-            }
-            ani.play(repeat, speedRatio);
+                for (const track of v){
+                    const blendId = track.getBlendId();
+                    let blendedTracks = nodeTracks.get(blendId);
+                    if (!blendedTracks) {
+                        blendedTracks = [];
+                        nodeTracks.set(blendId, blendedTracks);
+                    }
+                    blendedTracks.push(track);
+                }
+            });
+            ani.skeletons?.forEach((v, k)=>{
+                const refcount = this._activeSkeletons.get(k);
+                if (refcount) {
+                    this._activeSkeletons.set(k, refcount + 1);
+                } else {
+                    this._activeSkeletons.set(k, 1);
+                }
+            });
         }
     }
     /**
    * Stops playing an animation of the model
    * @param name - Name of the animation to stop playing
-   */ stopAnimation(name) {
-        this._animations[name]?.stop();
+   */ stopAnimation(name, options) {
+        const ani = this._animations[name];
+        const info = this._activeAnimations.get(ani);
+        if (info) {
+            const fadeOut = Math.max(options?.fadeOut ?? 0, 0);
+            if (fadeOut !== 0) {
+                info.fadeOut = fadeOut;
+                info.fadeOutStart = -1;
+            } else {
+                this._activeAnimations.delete(ani);
+                this._activeTracks.forEach((v, k)=>{
+                    v.forEach((tracks, id)=>{
+                        v.set(id, tracks.filter((track)=>track.animation !== ani));
+                    });
+                });
+                ani.skeletons?.forEach((v, k)=>{
+                    const refcount = this._activeSkeletons.get(k);
+                    if (refcount === 1) {
+                        k.reset(this._model);
+                        this._activeSkeletons.delete(k);
+                    } else {
+                        this._activeSkeletons.set(k, refcount - 1);
+                    }
+                });
+            }
+        }
     }
     dispose() {
         const index = this._scene.animationSet.indexOf(this);
@@ -88,6 +225,9 @@
             this._animations[k].dispose();
         }
         this._animations = {};
+        this._activeAnimations.clear();
+        this._activeSkeletons.clear();
+        this._activeTracks.clear();
     }
 }
 

package/dist/animation/animationset.js.map

@@ -1 +1 @@
-{"version":3,"file":"animationset.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"animationset.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/animation/animationtrack.js

@@ -3,35 +3,23 @@
  * @public
  */ class AnimationTrack {
     /** @internal */ _interpolator;
-    /** @internal */ _currentPlayTime;
-    /** @internal */ _playing;
+    /** @internal */ _animation;
     /**
    * Creates a new animation track
    * @param interpolator - Interpolator for the track
    */ constructor(interpolator){
-        this._currentPlayTime = 0;
-        this._playing = false;
         this._interpolator = interpolator;
     }
     /** Gets the interpolator of the track */ get interpolator() {
         return this._interpolator;
     }
-    /** Return true if the track is playing, otherwise false */ get playing() {
-        return this._playing;
+    /** Animation this track belongs to */ get animation() {
+        return this._animation;
     }
-    /** Starts playing the track */ start() {
-        this._playing = true;
-    }
-    /** Stops playing the track */ stop() {
-        this._playing = false;
-    }
-    /** Rewinds the track to the first frame */ rewind() {
-        this._currentPlayTime = 0;
-    }
-    /** Stops playing the track and rewind to the first frame */ reset() {
-        this.stop();
-        this._currentPlayTime = 0;
+    set animation(ani) {
+        this._animation = ani;
     }
+    /** Stops playing the track and rewind to the first frame */ reset(node) {}
 }
 
 export { AnimationTrack };

package/dist/animation/animationtrack.js.map

@@ -1 +1 @@
-{"version":3,"file":"animationtrack.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"animationtrack.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/animation/eulerrotationtrack.js

@@ -1,12 +1,12 @@
-import { Vector3, Quaternion, Interpolator } from '@zephyr3d/base';
+import { Vector3, Interpolator, Quaternion } from '@zephyr3d/base';
 import { AnimationTrack } from './animationtrack.js';
 
 const tmpVec3 = new Vector3();
-const tmpQuat = new Quaternion();
 /**
  * Euler angle rotation animation track
  * @public
  */ class EulerRotationTrack extends AnimationTrack {
+    _state;
     /**
    * Create an instance of EulerRotationTrack from keyframe values
    * @param mode - The interpolation mode of keyframes
@@ -21,11 +21,21 @@ const tmpQuat = new Quaternion();
         }
         const interpolator = new Interpolator(mode, 'vec3', inputs, outputs);
         super(interpolator);
+        this._state = new Quaternion();
     }
-    /** {@inheritDoc AnimationTrack.apply} */ apply(node, currentTime, duration) {
-        this._interpolator.interpolate(currentTime, duration, tmpVec3);
-        node.rotation.set(tmpQuat.fromEulerAngle(tmpVec3.x, tmpVec3.y, tmpVec3.z, 'ZYX'));
-        return true;
+    calculateState(currentTime) {
+        this._interpolator.interpolate(currentTime, tmpVec3);
+        this._state.fromEulerAngle(tmpVec3.x, tmpVec3.y, tmpVec3.z, 'ZYX');
+        return this._state;
+    }
+    applyState(node, state) {
+        node.rotation.set(state);
+    }
+    mixState(a, b, t) {
+        return Quaternion.slerp(a, b, t);
+    }
+    getBlendId() {
+        return 'node-rotation';
     }
 }
 

package/dist/animation/eulerrotationtrack.js.map

@@ -1 +1 @@
-{"version":3,"file":"eulerrotationtrack.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"eulerrotationtrack.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/animation/morphtarget.js

@@ -0,0 +1,104 @@
+import { PBStructTypeInfo, PBArrayTypeInfo, PBPrimitiveTypeInfo, PBPrimitiveType } from '@zephyr3d/device';
+import { Application } from '../app.js';
+import { MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MORPH_WEIGHTS_VECTOR_COUNT, MORPH_ATTRIBUTE_VECTOR_COUNT } from '../values.js';
+import { ShaderHelper } from '../material/shader/helper.js';
+import '../material/lambert.js';
+import '../material/blinn.js';
+import '../material/unlit.js';
+import '../material/meshmaterial.js';
+import '../material/grassmaterial.js';
+import '../material/terrainmaterial.js';
+import '../material/pbrmr.js';
+import '../material/pbrsg.js';
+import '@zephyr3d/base';
+import '../utility/pmrem.js';
+import '../utility/panorama.js';
+import '../utility/shprojection.js';
+import { BoundingBox } from '../utility/bounding_volume.js';
+
+function processMorphData(subMesh, morphWeights) {
+    const numTargets = subMesh.numTargets;
+    if (numTargets === 0) {
+        return;
+    }
+    const attributes = Object.getOwnPropertyNames(subMesh.targets);
+    const numVertices = subMesh.primitive.getNumVertices();
+    const weightsAndOffsets = new Float32Array(4 + MAX_MORPH_TARGETS + MAX_MORPH_ATTRIBUTES);
+    for(let i = 0; i < numTargets; i++){
+        weightsAndOffsets[4 + i] = morphWeights?.[i] ?? 0;
+    }
+    const textureSize = Math.ceil(Math.sqrt(numVertices * attributes.length * numTargets));
+    if (textureSize > Application.instance.device.getDeviceCaps().textureCaps.maxTextureSize) {
+        // TODO: reduce morph attributes
+        throw new Error(`Morph target data too large`);
+    }
+    weightsAndOffsets[0] = textureSize;
+    weightsAndOffsets[1] = textureSize;
+    weightsAndOffsets[2] = numVertices;
+    weightsAndOffsets[3] = numTargets;
+    let offset = 0;
+    const textureData = new Float32Array(textureSize * textureSize * 4);
+    for(let attrib = 0; attrib < MAX_MORPH_ATTRIBUTES; attrib++){
+        const index = attributes.indexOf(String(attrib));
+        if (index < 0) {
+            weightsAndOffsets[4 + MAX_MORPH_TARGETS + attrib] = -1;
+            continue;
+        }
+        weightsAndOffsets[4 + MAX_MORPH_TARGETS + attrib] = offset >> 2;
+        const info = subMesh.targets[attrib];
+        if (info.data.length !== numTargets) {
+            console.error(`Invalid morph target data`);
+            return;
+        }
+        for(let t = 0; t < numTargets; t++){
+            const data = info.data[t];
+            for(let i = 0; i < numVertices; i++){
+                for(let j = 0; j < 4; j++){
+                    textureData[offset++] = j < info.numComponents ? data[i * info.numComponents + j] : 1;
+                }
+            }
+        }
+    }
+    const morphTexture = Application.instance.device.createTexture2D('rgba32f', textureSize, textureSize, {
+        samplerOptions: {
+            minFilter: 'nearest',
+            magFilter: 'nearest',
+            mipFilter: 'none'
+        }
+    });
+    morphTexture.update(textureData, 0, 0, textureSize, textureSize);
+    const bufferType = new PBStructTypeInfo('dummy', 'std140', [
+        {
+            name: ShaderHelper.getMorphInfoUniformName(),
+            type: new PBArrayTypeInfo(new PBPrimitiveTypeInfo(PBPrimitiveType.F32VEC4), 1 + MORPH_WEIGHTS_VECTOR_COUNT + MORPH_ATTRIBUTE_VECTOR_COUNT)
+        }
+    ]);
+    const morphUniformBuffer = Application.instance.device.createStructuredBuffer(bufferType, {
+        usage: 'uniform'
+    }, weightsAndOffsets);
+    const morphBoundingBox = new BoundingBox();
+    calculateMorphBoundingBox(morphBoundingBox, subMesh.targetBox, weightsAndOffsets.subarray(4, 4 + MAX_MORPH_TARGETS), numTargets);
+    const meshAABB = subMesh.mesh.getBoundingVolume().toAABB();
+    morphBoundingBox.minPoint.addBy(meshAABB.minPoint);
+    morphBoundingBox.maxPoint.addBy(meshAABB.maxPoint);
+    subMesh.mesh.setMorphData(morphTexture);
+    subMesh.mesh.setMorphInfo(morphUniformBuffer);
+    subMesh.mesh.setAnimatedBoundingBox(morphBoundingBox);
+}
+/** @internal */ function calculateMorphBoundingBox(morphBoundingBox, keyframeBoundingBox, weights, numTargets) {
+    morphBoundingBox.minPoint.setXYZ(0, 0, 0);
+    morphBoundingBox.maxPoint.setXYZ(0, 0, 0);
+    for(let i = 0; i < numTargets; i++){
+        const weight = weights[i];
+        const keyframeBox = keyframeBoundingBox[i];
+        morphBoundingBox.minPoint.x += keyframeBox.minPoint.x * weight;
+        morphBoundingBox.minPoint.y += keyframeBox.minPoint.y * weight;
+        morphBoundingBox.minPoint.y += keyframeBox.minPoint.z * weight;
+        morphBoundingBox.maxPoint.x += keyframeBox.maxPoint.x * weight;
+        morphBoundingBox.maxPoint.y += keyframeBox.maxPoint.y * weight;
+        morphBoundingBox.maxPoint.y += keyframeBox.maxPoint.z * weight;
+    }
+}
+
+export { calculateMorphBoundingBox, processMorphData };
+//# sourceMappingURL=morphtarget.js.map

package/dist/animation/morphtarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"morphtarget.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}