@zephyr3d/scene 0.1.0

package/dist/animation/animation.js

@@ -0,0 +1,173 @@
+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){
+        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();
+    }
+    /** Disposes self */ dispose() {
+        this._model = null;
+        this._tracks = null;
+        this._skeletons?.forEach((val, key)=>key.dispose());
+        this._skeletons = null;
+    }
+    /** Gets the name of the animation */ get name() {
+        return this._name;
+    }
+    /** Gets all the tracks of this animation */ get tracks() {
+        return this._tracks;
+    }
+    /** The duration of the animation */ get timeDuration() {
+        return this._duration;
+    }
+    /**
+   * Adds a skeleton to the animation
+   * @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()
+            });
+        }
+    }
+    /**
+   * Adds an animation track to the animation
+   * @param node - The node that will be controlled by the track
+   * @param track - The track to be added
+   * @returns self
+   */ addTrack(node, track) {
+        if (!track) {
+            return;
+        }
+        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: []
+            };
+            this._tracks.set(node, trackInfo);
+        }
+        trackInfo.tracks.push(track);
+        this._duration = Math.max(this._duration, track.interpolator.maxTime);
+        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 };
+//# sourceMappingURL=animation.js.map

package/dist/animation/animation.js.map

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

package/dist/animation/animationset.js

@@ -0,0 +1,95 @@
+/**
+ * Animation set
+ * @public
+ */ class AnimationSet {
+    /** @internal */ _animations;
+    /** @internal */ _scene;
+    /**
+   * Creates an instance of AnimationSet
+   * @param scene - The scene to which the animation set belongs
+   */ constructor(scene){
+        this._scene = scene;
+        this._scene.animationSet.push(this);
+        this._animations = {};
+    }
+    /**
+   * How many animations in this set
+   */ get numAnimations() {
+        return Object.getOwnPropertyNames(this._animations).length;
+    }
+    /**
+   * Gets an animation clip by name
+   * @param name - name of the animation to get
+   */ get(name) {
+        return this._animations[name] ?? null;
+    }
+    /**
+   * Adds an animation
+   */ add(animation) {
+        this._animations[animation.name] = animation;
+    }
+    /**
+   * Gets names of all the animations of the model
+   * @returns An array of string that contains the animation names
+   */ getAnimationNames() {
+        return Object.keys(this._animations);
+    }
+    /**
+   * Updates all animations of the model
+   */ update() {
+        for(const k in this._animations){
+            this._animations[k].update();
+        }
+    }
+    /**
+   * 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;
+        }
+    }
+    /**
+   * 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) {
+        const ani = this._animations[name];
+        if (ani && !ani.isPlaying()) {
+            for (const name of this.getAnimationNames()){
+                if (this.isPlayingAnimation(name)) {
+                    this.stopAnimation(name);
+                }
+            }
+            ani.play(repeat, speedRatio);
+        }
+    }
+    /**
+   * Stops playing an animation of the model
+   * @param name - Name of the animation to stop playing
+   */ stopAnimation(name) {
+        this._animations[name]?.stop();
+    }
+    dispose() {
+        const index = this._scene.animationSet.indexOf(this);
+        if (index >= 0) {
+            this._scene.animationSet.splice(index, 1);
+        }
+        for(const k in this._animations){
+            this._animations[k].dispose();
+        }
+        this._animations = {};
+    }
+}
+
+export { AnimationSet };
+//# sourceMappingURL=animationset.js.map

package/dist/animation/animationset.js.map

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

package/dist/animation/animationtrack.js

@@ -0,0 +1,38 @@
+/**
+ * Base class for any kind of animation track
+ * @public
+ */ class AnimationTrack {
+    /** @internal */ _interpolator;
+    /** @internal */ _currentPlayTime;
+    /** @internal */ _playing;
+    /**
+   * 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;
+    }
+    /** 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;
+    }
+}
+
+export { AnimationTrack };
+//# sourceMappingURL=animationtrack.js.map

package/dist/animation/animationtrack.js.map

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

package/dist/animation/eulerrotationtrack.js

@@ -0,0 +1,33 @@
+import { Vector3, Quaternion, Interpolator } 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 {
+    /**
+   * Create an instance of EulerRotationTrack from keyframe values
+   * @param mode - The interpolation mode of keyframes
+   * @param keyFrames - Keyframe values
+   */ constructor(mode, keyFrames){
+        const inputs = new Float32Array(keyFrames.map((val)=>val.time));
+        const outputs = new Float32Array(keyFrames.length * 3);
+        for(let i = 0; i < keyFrames.length; i++){
+            outputs[i * 3 + 0] = keyFrames[i].value.x;
+            outputs[i * 3 + 1] = keyFrames[i].value.y;
+            outputs[i * 3 + 2] = keyFrames[i].value.z;
+        }
+        const interpolator = new Interpolator(mode, 'vec3', inputs, outputs);
+        super(interpolator);
+    }
+    /** {@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;
+    }
+}
+
+export { EulerRotationTrack };
+//# sourceMappingURL=eulerrotationtrack.js.map

package/dist/animation/eulerrotationtrack.js.map

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

package/dist/animation/rotationtrack.js

@@ -0,0 +1,37 @@
+import { Quaternion, Interpolator } from '@zephyr3d/base';
+import { AnimationTrack } from './animationtrack.js';
+
+// Reduce gc
+const tmpQuat = new Quaternion();
+/**
+ * Rotation animation track
+ * @public
+ */ class RotationTrack extends AnimationTrack {
+    constructor(modeOrInterpolator, keyFrames){
+        if (modeOrInterpolator instanceof Interpolator) {
+            if (modeOrInterpolator.target !== 'quat') {
+                throw new Error(`RotationTrack(): interpolator target must be 'quat'`);
+            }
+            super(modeOrInterpolator);
+        } else {
+            const inputs = new Float32Array(keyFrames.map((val)=>val.time));
+            const outputs = new Float32Array(keyFrames.length * 4);
+            for(let i = 0; i < keyFrames.length; i++){
+                outputs[i * 4 + 0] = keyFrames[i].value.x;
+                outputs[i * 4 + 1] = keyFrames[i].value.y;
+                outputs[i * 4 + 2] = keyFrames[i].value.z;
+                outputs[i * 4 + 3] = keyFrames[i].value.w;
+            }
+            const interpolator = new Interpolator(modeOrInterpolator, 'quat', inputs, outputs);
+            super(interpolator);
+        }
+    }
+    /** {@inheritDoc AnimationTrack.apply} */ apply(node, currentTime, duration) {
+        this._interpolator.interpolate(currentTime, duration, tmpQuat);
+        node.rotation.set(tmpQuat);
+        return true;
+    }
+}
+
+export { RotationTrack };
+//# sourceMappingURL=rotationtrack.js.map

package/dist/animation/rotationtrack.js.map

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

package/dist/animation/scaletrack.js

@@ -0,0 +1,36 @@
+import { Vector3, Interpolator } from '@zephyr3d/base';
+import { AnimationTrack } from './animationtrack.js';
+
+// Reduce gc
+const tmpVec3 = new Vector3();
+/**
+ * Scale animation track
+ * @public
+ */ class ScaleTrack extends AnimationTrack {
+    constructor(modeOrInterpolator, keyFrames){
+        if (modeOrInterpolator instanceof Interpolator) {
+            if (modeOrInterpolator.target !== 'vec3') {
+                throw new Error(`ScaleTrack(): interpolator target must be 'vec3'`);
+            }
+            super(modeOrInterpolator);
+        } else {
+            const inputs = new Float32Array(keyFrames.map((val)=>val.time));
+            const outputs = new Float32Array(keyFrames.length * 3);
+            for(let i = 0; i < keyFrames.length; i++){
+                outputs[i * 3 + 0] = keyFrames[i].value.x;
+                outputs[i * 3 + 1] = keyFrames[i].value.y;
+                outputs[i * 3 + 2] = keyFrames[i].value.z;
+            }
+            const interpolator = new Interpolator(modeOrInterpolator, 'vec3', inputs, outputs);
+            super(interpolator);
+        }
+    }
+    /** {@inheritDoc AnimationTrack.apply} */ apply(node, currentTime, duration) {
+        this._interpolator.interpolate(currentTime, duration, tmpVec3);
+        node.scale.set(tmpVec3);
+        return true;
+    }
+}
+
+export { ScaleTrack };
+//# sourceMappingURL=scaletrack.js.map

package/dist/animation/scaletrack.js.map

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

package/dist/animation/skeleton.js

@@ -0,0 +1,97 @@
+import { Vector3, Matrix4x4, nextPowerOf2 } from '@zephyr3d/base';
+import { Application } from '../app.js';
+
+const tmpV0 = new Vector3();
+const tmpV1 = new Vector3();
+const tmpV2 = new Vector3();
+const tmpV3 = new Vector3();
+/**
+ * Skeleton for skinned animation
+ * @public
+ */ class Skeleton {
+    /** @internal */ _joints;
+    /** @internal */ _inverseBindMatrices;
+    /** @internal */ _bindPoseMatrices;
+    /** @internal */ _jointMatrices;
+    /** @internal */ _jointMatrixArray;
+    /** @internal */ _jointTexture;
+    /**
+   * Creates an instance of skeleton
+   * @param joints - The joint nodes
+   * @param inverseBindMatrices - The inverse binding matrices of the joints
+   * @param bindPoseMatrices - The binding pose matrices of the joints
+   */ constructor(joints, inverseBindMatrices, bindPoseMatrices){
+        this._joints = joints;
+        this._inverseBindMatrices = inverseBindMatrices;
+        this._bindPoseMatrices = bindPoseMatrices;
+        this._jointMatrixArray = null;
+        this._jointMatrices = null;
+        this._jointTexture = null;
+    }
+    /**
+   * Disposes self
+   */ dispose() {
+        this._jointTexture?.dispose();
+        this._jointTexture = null;
+        this._joints = null;
+        this._inverseBindMatrices = null;
+        this._bindPoseMatrices = null;
+        this._jointMatrices = null;
+        this._jointMatrixArray = null;
+    }
+    /**
+   * The joint transform matrices
+   */ get jointMatrices() {
+        return this._jointMatrices;
+    }
+    /**
+   * The texture that contains the transform matrices of all the joints
+   */ get jointTexture() {
+        return this._jointTexture;
+    }
+    /** @internal */ updateJointMatrices(jointTransforms) {
+        if (!this._jointTexture) {
+            this._createJointTexture();
+        }
+        for(let i = 0; i < this._joints.length; i++){
+            const mat = this._jointMatrices[i];
+            Matrix4x4.multiply(jointTransforms ? jointTransforms[i] : this._joints[i].worldMatrix, this._inverseBindMatrices[i], mat);
+        }
+    }
+    /** @internal */ computeBindPose() {
+        this.updateJointMatrices(this._bindPoseMatrices);
+        this._jointTexture.update(this._jointMatrixArray, 0, 0, this._jointTexture.width, this._jointTexture.height);
+    }
+    /** @internal */ computeJoints() {
+        this.updateJointMatrices();
+        this._jointTexture.update(this._jointMatrixArray, 0, 0, this._jointTexture.width, this._jointTexture.height);
+    }
+    /** @internal */ computeBoundingBox(info, invWorldMatrix) {
+        info.boundingBox.beginExtend();
+        for(let i = 0; i < info.boundingVertices.length; i++){
+            this._jointMatrices[info.boundingVertexBlendIndices[i * 4 + 0]].transformPointAffine(info.boundingVertices[i], tmpV0).scaleBy(info.boundingVertexJointWeights[i * 4 + 0]);
+            this._jointMatrices[info.boundingVertexBlendIndices[i * 4 + 1]].transformPointAffine(info.boundingVertices[i], tmpV1).scaleBy(info.boundingVertexJointWeights[i * 4 + 1]);
+            this._jointMatrices[info.boundingVertexBlendIndices[i * 4 + 2]].transformPointAffine(info.boundingVertices[i], tmpV2).scaleBy(info.boundingVertexJointWeights[i * 4 + 2]);
+            this._jointMatrices[info.boundingVertexBlendIndices[i * 4 + 3]].transformPointAffine(info.boundingVertices[i], tmpV3).scaleBy(info.boundingVertexJointWeights[i * 4 + 3]);
+            tmpV0.addBy(tmpV1).addBy(tmpV2).addBy(tmpV3);
+            invWorldMatrix.transformPointAffine(tmpV0, tmpV0);
+            info.boundingBox.extend(tmpV0);
+        }
+    }
+    /** @internal */ _createJointTexture() {
+        const textureWidth = nextPowerOf2(Math.max(4, Math.ceil(Math.sqrt(this._joints.length * 4))));
+        this._jointTexture = Application.instance.device.createTexture2D('rgba32f', textureWidth, textureWidth, {
+            samplerOptions: {
+                magFilter: 'nearest',
+                minFilter: 'nearest',
+                mipFilter: 'none'
+            }
+        });
+        this._jointMatrixArray = new Float32Array(textureWidth * textureWidth * 4);
+        const buffer = this._jointMatrixArray.buffer;
+        this._jointMatrices = this._joints.map((val, index)=>new Matrix4x4(buffer, index * 16 * Float32Array.BYTES_PER_ELEMENT));
+    }
+}
+
+export { Skeleton };
+//# sourceMappingURL=skeleton.js.map

package/dist/animation/skeleton.js.map

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

package/dist/animation/translationtrack.js

@@ -0,0 +1,36 @@
+import { Vector3, Interpolator } from '@zephyr3d/base';
+import { AnimationTrack } from './animationtrack.js';
+
+// Reduce gc
+const tmpVec3 = new Vector3();
+/**
+ * Translate animation track
+ * @public
+ */ class TranslationTrack extends AnimationTrack {
+    constructor(modeOrInterpolator, keyFrames){
+        if (modeOrInterpolator instanceof Interpolator) {
+            if (modeOrInterpolator.target !== 'vec3') {
+                throw new Error(`TranslationTrack(): interpolator target must be 'vec3'`);
+            }
+            super(modeOrInterpolator);
+        } else {
+            const inputs = new Float32Array(keyFrames.map((val)=>val.time));
+            const outputs = new Float32Array(keyFrames.length * 3);
+            for(let i = 0; i < keyFrames.length; i++){
+                outputs[i * 3 + 0] = keyFrames[i].value.x;
+                outputs[i * 3 + 1] = keyFrames[i].value.y;
+                outputs[i * 3 + 2] = keyFrames[i].value.z;
+            }
+            const interpolator = new Interpolator(modeOrInterpolator, 'vec3', inputs, outputs);
+            super(interpolator);
+        }
+    }
+    /** {@inheritDoc AnimationTrack.apply} */ apply(node, currentTime, duration) {
+        this._interpolator.interpolate(currentTime, duration, tmpVec3);
+        node.position.set(tmpVec3);
+        return true;
+    }
+}
+
+export { TranslationTrack };
+//# sourceMappingURL=translationtrack.js.map

package/dist/animation/translationtrack.js.map

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

package/dist/animation/usertrack.js

@@ -0,0 +1,47 @@
+import { Interpolator } from '@zephyr3d/base';
+import { AnimationTrack } from './animationtrack.js';
+
+const tmpValue = new Float32Array(4);
+/**
+ * User-defined animation track
+ * @public
+ */ class UserTrack extends AnimationTrack {
+    _handler;
+    /**
+   * Create an instance of UserTrack
+   * @param mode - Interpolation mode for keyframe values
+   * @param target - Type of keyframe values
+   * @param keyFrames - Keyframe values
+   * @param handler - Handler to apply the keyframe values
+   */ constructor(mode, target, keyFrames, handler){
+        const stride = Interpolator.getTargetStride(target);
+        if (!stride) {
+            throw new Error(`UserTrack(): invalid target: ${target}`);
+        }
+        const inputs = new Float32Array(keyFrames.map((val)=>val.time));
+        const outputs = new Float32Array(keyFrames.length * stride);
+        for(let i = 0; i < keyFrames.length; i++){
+            for(let j = 0; j < stride; j++){
+                const value = keyFrames[i].value;
+                if (typeof value === 'number') {
+                    outputs[i * stride + j] = value;
+                } else if (value instanceof Float32Array) {
+                    outputs[i * stride + j] = value[j] ?? 0;
+                } else {
+                    throw new Error(`UserTrack(): invalid keyframe value: ${value}`);
+                }
+            }
+        }
+        const interpolator = new Interpolator(mode, target, inputs, outputs);
+        super(interpolator);
+        this._handler = handler;
+    }
+    /** {@inheritDoc AnimationTrack.apply} */ apply(node, currentTime, duration) {
+        this._interpolator.interpolate(currentTime, duration, tmpValue);
+        this._handler && this._handler(node, tmpValue);
+        return true;
+    }
+}
+
+export { UserTrack };
+//# sourceMappingURL=usertrack.js.map

package/dist/animation/usertrack.js.map

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