@zephyr3d/scene 0.9.2 → 0.9.3

package/dist/src/animation/eulerrotationtrack.js

@@ -0,0 +1,52 @@
+import { Vector3, Interpolator, Quaternion } from '@zephyr3d/base';
+import { AnimationTrack } from './animationtrack.js';
+
+const tmpVec3 = new Vector3();
+/**
+ * Euler angle rotation animation track
+ * @public
+ */ class NodeEulerRotationTrack extends AnimationTrack {
+    _state;
+    _interpolator;
+    constructor(modeOrInterpolator, keyFramesOrEmbedded, embedded){
+        if (modeOrInterpolator instanceof Interpolator) {
+            if (modeOrInterpolator.target !== 'vec3') {
+                throw new Error(`TranslationTrack(): interpolator target must be 'vec3'`);
+            }
+            super(keyFramesOrEmbedded ?? false);
+            this._interpolator = modeOrInterpolator;
+        } else {
+            const keyFrames = keyFramesOrEmbedded;
+            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;
+            }
+            super(embedded ?? false);
+            this._interpolator = new Interpolator(modeOrInterpolator, 'vec3', inputs, outputs);
+        }
+        this._state = new Quaternion();
+    }
+    calculateState(target, currentTime) {
+        this._interpolator.interpolate(currentTime, tmpVec3);
+        this._state.fromEulerAngle(tmpVec3.x, tmpVec3.y, tmpVec3.z);
+        return this._state;
+    }
+    applyState(node, state) {
+        node.rotation.set(state);
+    }
+    mixState(a, b, t) {
+        return Quaternion.slerp(a, b, t);
+    }
+    getBlendId() {
+        return 'node-rotation';
+    }
+    getDuration() {
+        return this._interpolator.maxTime;
+    }
+}
+
+export { NodeEulerRotationTrack };
+//# sourceMappingURL=eulerrotationtrack.js.map

package/dist/src/animation/eulerrotationtrack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eulerrotationtrack.js","sources":["../../../src/animation/eulerrotationtrack.ts"],"sourcesContent":["import type { InterpolationMode } from '@zephyr3d/base';\r\nimport { Interpolator, Quaternion, Vector3 } from '@zephyr3d/base';\r\nimport { AnimationTrack } from './animationtrack';\r\nimport type { SceneNode } from '../scene';\r\n\r\nconst tmpVec3 = new Vector3();\r\n\r\n/**\r\n * Euler angle rotation animation track\r\n * @public\r\n */\r\nexport class NodeEulerRotationTrack extends AnimationTrack<Quaternion> {\r\n  private readonly _state: Quaternion;\r\n  private readonly _interpolator: Interpolator;\r\n  /**\r\n   * Create an instance of EulerRotationTrack from keyframe values\r\n   * @param interpolator - Interpolator object that contains the keyframe values\r\n   * @param embedded - Whether this track be an embedded track\r\n   */\r\n  constructor(interpolator: Interpolator, embedded?: boolean);\r\n  /**\r\n   * Create an instance of EulerRotationTrack from keyframe values\r\n   * @param mode - The interpolation mode of keyframes\r\n   * @param keyFrames - Keyframe values\r\n   * @param embedded - Whether this track be an embedded track\r\n   */\r\n  constructor(mode: InterpolationMode, keyFrames: { time: number; value: Vector3 }[], embedded?: boolean);\r\n  constructor(\r\n    modeOrInterpolator?: Interpolator | InterpolationMode,\r\n    keyFramesOrEmbedded?: { time: number; value: Vector3 }[] | boolean,\r\n    embedded?: boolean\r\n  ) {\r\n    if (modeOrInterpolator instanceof Interpolator) {\r\n      if (modeOrInterpolator.target !== 'vec3') {\r\n        throw new Error(`TranslationTrack(): interpolator target must be 'vec3'`);\r\n      }\r\n      super((keyFramesOrEmbedded as boolean) ?? false);\r\n      this._interpolator = modeOrInterpolator;\r\n    } else {\r\n      const keyFrames = keyFramesOrEmbedded as { time: number; value: Vector3 }[];\r\n      const inputs = new Float32Array(keyFrames.map((val) => val.time));\r\n      const outputs = new Float32Array(keyFrames.length * 3);\r\n      for (let i = 0; i < keyFrames.length; i++) {\r\n        outputs[i * 3 + 0] = keyFrames[i].value.x;\r\n        outputs[i * 3 + 1] = keyFrames[i].value.y;\r\n        outputs[i * 3 + 2] = keyFrames[i].value.z;\r\n      }\r\n      super(embedded ?? false);\r\n      this._interpolator = new Interpolator(modeOrInterpolator, 'vec3', inputs, outputs);\r\n    }\r\n    this._state = new Quaternion();\r\n  }\r\n  calculateState(target: object, currentTime: number): Quaternion {\r\n    this._interpolator.interpolate(currentTime, tmpVec3);\r\n    this._state.fromEulerAngle(tmpVec3.x, tmpVec3.y, tmpVec3.z);\r\n    return this._state;\r\n  }\r\n  applyState(node: SceneNode, state: Quaternion) {\r\n    node.rotation.set(state);\r\n  }\r\n  mixState(a: Quaternion, b: Quaternion, t: number): Quaternion {\r\n    return Quaternion.slerp(a, b, t);\r\n  }\r\n  getBlendId(): unknown {\r\n    return 'node-rotation';\r\n  }\r\n  getDuration(): number {\r\n    return this._interpolator.maxTime;\r\n  }\r\n}\r\n"],"names":["tmpVec3","Vector3","NodeEulerRotationTrack","AnimationTrack","_state","_interpolator","modeOrInterpolator","keyFramesOrEmbedded","embedded","Interpolator","target","Error","keyFrames","inputs","Float32Array","map","val","time","outputs","length","i","value","x","y","z","Quaternion","calculateState","currentTime","interpolate","fromEulerAngle","applyState","node","state","rotation","set","mixState","a","b","t","slerp","getBlendId","getDuration","maxTime"],"mappings":";;;AAKA,MAAMA,UAAU,IAAIC,OAAAA,EAAAA;AAEpB;;;IAIO,MAAMC,sBAA+BC,SAAAA,cAAAA,CAAAA;IACzBC,MAAmB;IACnBC,aAA4B;AAc7C,IAAA,WAAA,CACEC,kBAAqD,EACrDC,mBAAkE,EAClEC,QAAkB,CAClB;AACA,QAAA,IAAIF,8BAA8BG,YAAc,EAAA;YAC9C,IAAIH,kBAAAA,CAAmBI,MAAM,KAAK,MAAQ,EAAA;AACxC,gBAAA,MAAM,IAAIC,KAAAA,CAAM,CAAC,sDAAsD,CAAC,CAAA;AAC1E;YACA,KAAK,CAAC,mBAAoC,IAAA,KAAA,CAAA;YAC1C,IAAI,CAACN,aAAa,GAAGC,kBAAAA;SAChB,MAAA;AACL,YAAA,MAAMM,SAAYL,GAAAA,mBAAAA;YAClB,MAAMM,MAAAA,GAAS,IAAIC,YAAaF,CAAAA,SAAAA,CAAUG,GAAG,CAAC,CAACC,GAAQA,GAAAA,GAAAA,CAAIC,IAAI,CAAA,CAAA;AAC/D,YAAA,MAAMC,OAAU,GAAA,IAAIJ,YAAaF,CAAAA,SAAAA,CAAUO,MAAM,GAAG,CAAA,CAAA;AACpD,YAAA,IAAK,IAAIC,CAAI,GAAA,CAAA,EAAGA,IAAIR,SAAUO,CAAAA,MAAM,EAAEC,CAAK,EAAA,CAAA;gBACzCF,OAAO,CAACE,CAAI,GAAA,CAAA,GAAI,CAAE,CAAA,GAAGR,SAAS,CAACQ,CAAE,CAAA,CAACC,KAAK,CAACC,CAAC;gBACzCJ,OAAO,CAACE,CAAI,GAAA,CAAA,GAAI,CAAE,CAAA,GAAGR,SAAS,CAACQ,CAAE,CAAA,CAACC,KAAK,CAACE,CAAC;gBACzCL,OAAO,CAACE,CAAI,GAAA,CAAA,GAAI,CAAE,CAAA,GAAGR,SAAS,CAACQ,CAAE,CAAA,CAACC,KAAK,CAACG,CAAC;AAC3C;AACA,YAAA,KAAK,CAAChB,QAAY,IAAA,KAAA,CAAA;AAClB,YAAA,IAAI,CAACH,aAAa,GAAG,IAAII,YAAaH,CAAAA,kBAAAA,EAAoB,QAAQO,MAAQK,EAAAA,OAAAA,CAAAA;AAC5E;QACA,IAAI,CAACd,MAAM,GAAG,IAAIqB,UAAAA,EAAAA;AACpB;IACAC,cAAehB,CAAAA,MAAc,EAAEiB,WAAmB,EAAc;AAC9D,QAAA,IAAI,CAACtB,aAAa,CAACuB,WAAW,CAACD,WAAa3B,EAAAA,OAAAA,CAAAA;AAC5C,QAAA,IAAI,CAACI,MAAM,CAACyB,cAAc,CAAC7B,OAAAA,CAAQsB,CAAC,EAAEtB,OAAQuB,CAAAA,CAAC,EAAEvB,OAAAA,CAAQwB,CAAC,CAAA;QAC1D,OAAO,IAAI,CAACpB,MAAM;AACpB;IACA0B,UAAWC,CAAAA,IAAe,EAAEC,KAAiB,EAAE;QAC7CD,IAAKE,CAAAA,QAAQ,CAACC,GAAG,CAACF,KAAAA,CAAAA;AACpB;AACAG,IAAAA,QAAAA,CAASC,CAAa,EAAEC,CAAa,EAAEC,CAAS,EAAc;AAC5D,QAAA,OAAOb,UAAWc,CAAAA,KAAK,CAACH,CAAAA,EAAGC,CAAGC,EAAAA,CAAAA,CAAAA;AAChC;IACAE,UAAsB,GAAA;QACpB,OAAO,eAAA;AACT;IACAC,WAAsB,GAAA;AACpB,QAAA,OAAO,IAAI,CAACpC,aAAa,CAACqC,OAAO;AACnC;AACF;;;;"}

package/dist/src/animation/morphtarget.js

@@ -0,0 +1,93 @@
+import { PBStructTypeInfo, PBArrayTypeInfo, PBPrimitiveTypeInfo, PBPrimitiveType } from '@zephyr3d/device';
+import { Application } from '../app/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 { BoundingBox } from '../utility/bounding_volume.js';
+
+function processMorphData(subMesh, morphWeights) {
+    const device = Application.instance.device;
+    const numTargets = subMesh.numTargets;
+    if (numTargets === 0) {
+        return;
+    }
+    const attributes = Object.getOwnPropertyNames(subMesh.targets);
+    const numVertices = subMesh.primitive.get().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 > 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 = 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 = 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/src/animation/morphtarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"morphtarget.js","sources":["../../../src/animation/morphtarget.ts"],"sourcesContent":["import { PBArrayTypeInfo, PBPrimitiveType, PBPrimitiveTypeInfo, PBStructTypeInfo } from '@zephyr3d/device';\r\nimport { Application } from '../app/app';\r\nimport type { AssetSubMeshData } from '../asset';\r\nimport {\r\n  MAX_MORPH_ATTRIBUTES,\r\n  MAX_MORPH_TARGETS,\r\n  MORPH_ATTRIBUTE_VECTOR_COUNT,\r\n  MORPH_WEIGHTS_VECTOR_COUNT\r\n} from '../values';\r\nimport { ShaderHelper } from '../material/shader/helper';\r\nimport { BoundingBox } from '../utility/bounding_volume';\r\n\r\nexport function processMorphData(subMesh: AssetSubMeshData, morphWeights: number[]) {\r\n  const device = Application.instance.device;\r\n  const numTargets = subMesh.numTargets;\r\n  if (numTargets === 0) {\r\n    return;\r\n  }\r\n  const attributes = Object.getOwnPropertyNames(subMesh.targets);\r\n  const numVertices = subMesh.primitive.get().getNumVertices();\r\n  const weightsAndOffsets = new Float32Array(4 + MAX_MORPH_TARGETS + MAX_MORPH_ATTRIBUTES);\r\n  for (let i = 0; i < numTargets; i++) {\r\n    weightsAndOffsets[4 + i] = morphWeights?.[i] ?? 0;\r\n  }\r\n  const textureSize = Math.ceil(Math.sqrt(numVertices * attributes.length * numTargets));\r\n  if (textureSize > device.getDeviceCaps().textureCaps.maxTextureSize) {\r\n    // TODO: reduce morph attributes\r\n    throw new Error(`Morph target data too large`);\r\n  }\r\n  weightsAndOffsets[0] = textureSize;\r\n  weightsAndOffsets[1] = textureSize;\r\n  weightsAndOffsets[2] = numVertices;\r\n  weightsAndOffsets[3] = numTargets;\r\n  let offset = 0;\r\n  const textureData = new Float32Array(textureSize * textureSize * 4);\r\n  for (let attrib = 0; attrib < MAX_MORPH_ATTRIBUTES; attrib++) {\r\n    const index = attributes.indexOf(String(attrib));\r\n    if (index < 0) {\r\n      weightsAndOffsets[4 + MAX_MORPH_TARGETS + attrib] = -1;\r\n      continue;\r\n    }\r\n    weightsAndOffsets[4 + MAX_MORPH_TARGETS + attrib] = offset >> 2;\r\n    const info = subMesh.targets[attrib];\r\n    if (info.data.length !== numTargets) {\r\n      console.error(`Invalid morph target data`);\r\n      return;\r\n    }\r\n    for (let t = 0; t < numTargets; t++) {\r\n      const data = info.data[t];\r\n      for (let i = 0; i < numVertices; i++) {\r\n        for (let j = 0; j < 4; j++) {\r\n          textureData[offset++] = j < info.numComponents ? data[i * info.numComponents + j] : 1;\r\n        }\r\n      }\r\n    }\r\n  }\r\n  const morphTexture = device.createTexture2D('rgba32f', textureSize, textureSize, {\r\n    samplerOptions: {\r\n      minFilter: 'nearest',\r\n      magFilter: 'nearest',\r\n      mipFilter: 'none'\r\n    }\r\n  });\r\n  morphTexture.update(textureData, 0, 0, textureSize, textureSize);\r\n  const bufferType = new PBStructTypeInfo('dummy', 'std140', [\r\n    {\r\n      name: ShaderHelper.getMorphInfoUniformName(),\r\n      type: new PBArrayTypeInfo(\r\n        new PBPrimitiveTypeInfo(PBPrimitiveType.F32VEC4),\r\n        1 + MORPH_WEIGHTS_VECTOR_COUNT + MORPH_ATTRIBUTE_VECTOR_COUNT\r\n      )\r\n    }\r\n  ]);\r\n  const morphUniformBuffer = device.createStructuredBuffer(\r\n    bufferType,\r\n    {\r\n      usage: 'uniform'\r\n    },\r\n    weightsAndOffsets\r\n  );\r\n  const morphBoundingBox = new BoundingBox();\r\n  calculateMorphBoundingBox(\r\n    morphBoundingBox,\r\n    subMesh.targetBox,\r\n    weightsAndOffsets.subarray(4, 4 + MAX_MORPH_TARGETS),\r\n    numTargets\r\n  );\r\n  const meshAABB = subMesh.mesh.getBoundingVolume().toAABB();\r\n  morphBoundingBox.minPoint.addBy(meshAABB.minPoint);\r\n  morphBoundingBox.maxPoint.addBy(meshAABB.maxPoint);\r\n\r\n  subMesh.mesh.setMorphData(morphTexture);\r\n  subMesh.mesh.setMorphInfo(morphUniformBuffer);\r\n  subMesh.mesh.setAnimatedBoundingBox(morphBoundingBox);\r\n}\r\n\r\n/** @internal */\r\nexport function calculateMorphBoundingBox(\r\n  morphBoundingBox: BoundingBox,\r\n  keyframeBoundingBox: BoundingBox[],\r\n  weights: Float32Array,\r\n  numTargets: number\r\n) {\r\n  morphBoundingBox.minPoint.setXYZ(0, 0, 0);\r\n  morphBoundingBox.maxPoint.setXYZ(0, 0, 0);\r\n  for (let i = 0; i < numTargets; i++) {\r\n    const weight = weights[i];\r\n    const keyframeBox = keyframeBoundingBox[i];\r\n    morphBoundingBox.minPoint.x += keyframeBox.minPoint.x * weight;\r\n    morphBoundingBox.minPoint.y += keyframeBox.minPoint.y * weight;\r\n    morphBoundingBox.minPoint.y += keyframeBox.minPoint.z * weight;\r\n    morphBoundingBox.maxPoint.x += keyframeBox.maxPoint.x * weight;\r\n    morphBoundingBox.maxPoint.y += keyframeBox.maxPoint.y * weight;\r\n    morphBoundingBox.maxPoint.y += keyframeBox.maxPoint.z * weight;\r\n  }\r\n}\r\n"],"names":["processMorphData","subMesh","morphWeights","device","Application","instance","numTargets","attributes","Object","getOwnPropertyNames","targets","numVertices","primitive","get","getNumVertices","weightsAndOffsets","Float32Array","MAX_MORPH_TARGETS","MAX_MORPH_ATTRIBUTES","i","textureSize","Math","ceil","sqrt","length","getDeviceCaps","textureCaps","maxTextureSize","Error","offset","textureData","attrib","index","indexOf","String","info","data","console","error","t","j","numComponents","morphTexture","createTexture2D","samplerOptions","minFilter","magFilter","mipFilter","update","bufferType","PBStructTypeInfo","name","ShaderHelper","getMorphInfoUniformName","type","PBArrayTypeInfo","PBPrimitiveTypeInfo","PBPrimitiveType","F32VEC4","MORPH_WEIGHTS_VECTOR_COUNT","MORPH_ATTRIBUTE_VECTOR_COUNT","morphUniformBuffer","createStructuredBuffer","usage","morphBoundingBox","BoundingBox","calculateMorphBoundingBox","targetBox","subarray","meshAABB","mesh","getBoundingVolume","toAABB","minPoint","addBy","maxPoint","setMorphData","setMorphInfo","setAnimatedBoundingBox","keyframeBoundingBox","weights","setXYZ","weight","keyframeBox","x","y","z"],"mappings":";;;;;;AAYO,SAASA,gBAAAA,CAAiBC,OAAyB,EAAEC,YAAsB,EAAA;AAChF,IAAA,MAAMC,MAASC,GAAAA,WAAAA,CAAYC,QAAQ,CAACF,MAAM;IAC1C,MAAMG,UAAAA,GAAaL,QAAQK,UAAU;AACrC,IAAA,IAAIA,eAAe,CAAG,EAAA;AACpB,QAAA;AACF;AACA,IAAA,MAAMC,UAAaC,GAAAA,MAAAA,CAAOC,mBAAmB,CAACR,QAAQS,OAAO,CAAA;AAC7D,IAAA,MAAMC,cAAcV,OAAQW,CAAAA,SAAS,CAACC,GAAG,GAAGC,cAAc,EAAA;AAC1D,IAAA,MAAMC,iBAAoB,GAAA,IAAIC,YAAa,CAAA,CAAA,GAAIC,iBAAoBC,GAAAA,oBAAAA,CAAAA;AACnE,IAAA,IAAK,IAAIC,CAAAA,GAAI,CAAGA,EAAAA,CAAAA,GAAIb,YAAYa,CAAK,EAAA,CAAA;AACnCJ,QAAAA,iBAAiB,CAAC,CAAII,GAAAA,CAAAA,CAAE,GAAGjB,YAAc,GAACiB,EAAE,IAAI,CAAA;AAClD;IACA,MAAMC,WAAAA,GAAcC,IAAKC,CAAAA,IAAI,CAACD,IAAAA,CAAKE,IAAI,CAACZ,WAAAA,GAAcJ,UAAWiB,CAAAA,MAAM,GAAGlB,UAAAA,CAAAA,CAAAA;AAC1E,IAAA,IAAIc,cAAcjB,MAAOsB,CAAAA,aAAa,GAAGC,WAAW,CAACC,cAAc,EAAE;;AAEnE,QAAA,MAAM,IAAIC,KAAAA,CAAM,CAAC,2BAA2B,CAAC,CAAA;AAC/C;IACAb,iBAAiB,CAAC,EAAE,GAAGK,WAAAA;IACvBL,iBAAiB,CAAC,EAAE,GAAGK,WAAAA;IACvBL,iBAAiB,CAAC,EAAE,GAAGJ,WAAAA;IACvBI,iBAAiB,CAAC,EAAE,GAAGT,UAAAA;AACvB,IAAA,IAAIuB,MAAS,GAAA,CAAA;AACb,IAAA,MAAMC,WAAc,GAAA,IAAId,YAAaI,CAAAA,WAAAA,GAAcA,WAAc,GAAA,CAAA,CAAA;AACjE,IAAA,IAAK,IAAIW,MAAAA,GAAS,CAAGA,EAAAA,MAAAA,GAASb,sBAAsBa,MAAU,EAAA,CAAA;AAC5D,QAAA,MAAMC,KAAQzB,GAAAA,UAAAA,CAAW0B,OAAO,CAACC,MAAOH,CAAAA,MAAAA,CAAAA,CAAAA;AACxC,QAAA,IAAIC,QAAQ,CAAG,EAAA;AACbjB,YAAAA,iBAAiB,CAAC,CAAA,GAAIE,iBAAoBc,GAAAA,MAAAA,CAAO,GAAG,EAAC;AACrD,YAAA;AACF;AACAhB,QAAAA,iBAAiB,CAAC,CAAA,GAAIE,iBAAoBc,GAAAA,MAAAA,CAAO,GAAGF,MAAU,IAAA,CAAA;AAC9D,QAAA,MAAMM,IAAOlC,GAAAA,OAAAA,CAAQS,OAAO,CAACqB,MAAO,CAAA;AACpC,QAAA,IAAII,IAAKC,CAAAA,IAAI,CAACZ,MAAM,KAAKlB,UAAY,EAAA;AACnC+B,YAAAA,OAAAA,CAAQC,KAAK,CAAC,CAAC,yBAAyB,CAAC,CAAA;AACzC,YAAA;AACF;AACA,QAAA,IAAK,IAAIC,CAAAA,GAAI,CAAGA,EAAAA,CAAAA,GAAIjC,YAAYiC,CAAK,EAAA,CAAA;AACnC,YAAA,MAAMH,IAAOD,GAAAA,IAAAA,CAAKC,IAAI,CAACG,CAAE,CAAA;AACzB,YAAA,IAAK,IAAIpB,CAAAA,GAAI,CAAGA,EAAAA,CAAAA,GAAIR,aAAaQ,CAAK,EAAA,CAAA;AACpC,gBAAA,IAAK,IAAIqB,CAAAA,GAAI,CAAGA,EAAAA,CAAAA,GAAI,GAAGA,CAAK,EAAA,CAAA;AAC1BV,oBAAAA,WAAW,CAACD,MAAAA,EAAAA,CAAS,GAAGW,CAAAA,GAAIL,KAAKM,aAAa,GAAGL,IAAI,CAACjB,CAAIgB,GAAAA,IAAAA,CAAKM,aAAa,GAAGD,EAAE,GAAG,CAAA;AACtF;AACF;AACF;AACF;AACA,IAAA,MAAME,eAAevC,MAAOwC,CAAAA,eAAe,CAAC,SAAA,EAAWvB,aAAaA,WAAa,EAAA;QAC/EwB,cAAgB,EAAA;YACdC,SAAW,EAAA,SAAA;YACXC,SAAW,EAAA,SAAA;YACXC,SAAW,EAAA;AACb;AACF,KAAA,CAAA;AACAL,IAAAA,YAAAA,CAAaM,MAAM,CAAClB,WAAa,EAAA,CAAA,EAAG,GAAGV,WAAaA,EAAAA,WAAAA,CAAAA;AACpD,IAAA,MAAM6B,UAAa,GAAA,IAAIC,gBAAiB,CAAA,OAAA,EAAS,QAAU,EAAA;AACzD,QAAA;AACEC,YAAAA,IAAAA,EAAMC,aAAaC,uBAAuB,EAAA;YAC1CC,IAAM,EAAA,IAAIC,gBACR,IAAIC,mBAAAA,CAAoBC,gBAAgBC,OAAO,CAAA,EAC/C,IAAIC,0BAA6BC,GAAAA,4BAAAA;AAErC;AACD,KAAA,CAAA;AACD,IAAA,MAAMC,kBAAqB1D,GAAAA,MAAAA,CAAO2D,sBAAsB,CACtDb,UACA,EAAA;QACEc,KAAO,EAAA;KAEThD,EAAAA,iBAAAA,CAAAA;AAEF,IAAA,MAAMiD,mBAAmB,IAAIC,WAAAA,EAAAA;IAC7BC,yBACEF,CAAAA,gBAAAA,EACA/D,QAAQkE,SAAS,EACjBpD,kBAAkBqD,QAAQ,CAAC,CAAG,EAAA,CAAA,GAAInD,iBAClCX,CAAAA,EAAAA,UAAAA,CAAAA;AAEF,IAAA,MAAM+D,WAAWpE,OAAQqE,CAAAA,IAAI,CAACC,iBAAiB,GAAGC,MAAM,EAAA;AACxDR,IAAAA,gBAAAA,CAAiBS,QAAQ,CAACC,KAAK,CAACL,SAASI,QAAQ,CAAA;AACjDT,IAAAA,gBAAAA,CAAiBW,QAAQ,CAACD,KAAK,CAACL,SAASM,QAAQ,CAAA;IAEjD1E,OAAQqE,CAAAA,IAAI,CAACM,YAAY,CAAClC,YAAAA,CAAAA;IAC1BzC,OAAQqE,CAAAA,IAAI,CAACO,YAAY,CAAChB,kBAAAA,CAAAA;IAC1B5D,OAAQqE,CAAAA,IAAI,CAACQ,sBAAsB,CAACd,gBAAAA,CAAAA;AACtC;AAEA,iBACO,SAASE,yBACdF,CAAAA,gBAA6B,EAC7Be,mBAAkC,EAClCC,OAAqB,EACrB1E,UAAkB,EAAA;AAElB0D,IAAAA,gBAAAA,CAAiBS,QAAQ,CAACQ,MAAM,CAAC,GAAG,CAAG,EAAA,CAAA,CAAA;AACvCjB,IAAAA,gBAAAA,CAAiBW,QAAQ,CAACM,MAAM,CAAC,GAAG,CAAG,EAAA,CAAA,CAAA;AACvC,IAAA,IAAK,IAAI9D,CAAAA,GAAI,CAAGA,EAAAA,CAAAA,GAAIb,YAAYa,CAAK,EAAA,CAAA;QACnC,MAAM+D,MAAAA,GAASF,OAAO,CAAC7D,CAAE,CAAA;QACzB,MAAMgE,WAAAA,GAAcJ,mBAAmB,CAAC5D,CAAE,CAAA;QAC1C6C,gBAAiBS,CAAAA,QAAQ,CAACW,CAAC,IAAID,YAAYV,QAAQ,CAACW,CAAC,GAAGF,MAAAA;QACxDlB,gBAAiBS,CAAAA,QAAQ,CAACY,CAAC,IAAIF,YAAYV,QAAQ,CAACY,CAAC,GAAGH,MAAAA;QACxDlB,gBAAiBS,CAAAA,QAAQ,CAACY,CAAC,IAAIF,YAAYV,QAAQ,CAACa,CAAC,GAAGJ,MAAAA;QACxDlB,gBAAiBW,CAAAA,QAAQ,CAACS,CAAC,IAAID,YAAYR,QAAQ,CAACS,CAAC,GAAGF,MAAAA;QACxDlB,gBAAiBW,CAAAA,QAAQ,CAACU,CAAC,IAAIF,YAAYR,QAAQ,CAACU,CAAC,GAAGH,MAAAA;QACxDlB,gBAAiBW,CAAAA,QAAQ,CAACU,CAAC,IAAIF,YAAYR,QAAQ,CAACW,CAAC,GAAGJ,MAAAA;AAC1D;AACF;;;;"}

package/dist/src/animation/morphtrack.js

@@ -0,0 +1,70 @@
+import { AnimationTrack } from './animationtrack.js';
+import { BoundingBox } from '../utility/bounding_volume.js';
+import { MAX_MORPH_TARGETS } from '../values.js';
+import { calculateMorphBoundingBox } from './morphtarget.js';
+import { Vector3 } from '@zephyr3d/base';
+
+/**
+ * Morph target track
+ * @public
+ */ class MorphTargetTrack extends AnimationTrack {
+    _state;
+    _originBox;
+    _boundingBox;
+    _defaultWeights;
+    _interpolator;
+    /**
+   * Create an instance of MorphTargetTrack
+   */ constructor(assetTrack, subMesh, embedded){
+        super(embedded);
+        this._interpolator = assetTrack.interpolator;
+        this._state = {
+            numTargets: assetTrack.interpolator.stride,
+            boundingBox: new BoundingBox(),
+            weights: new Float32Array(MAX_MORPH_TARGETS)
+        };
+        this._boundingBox = subMesh.targetBox;
+        this._originBox = subMesh.mesh.getBoundingVolume().toAABB();
+        this._defaultWeights = assetTrack.defaultMorphWeights ?? Array.from({
+            length: this._state.numTargets
+        }).map(()=>0);
+    }
+    calculateState(target, currentTime) {
+        this._interpolator.interpolate(currentTime, this._state.weights);
+        calculateMorphBoundingBox(this._state.boundingBox, this._boundingBox, this._state.weights, this._state.numTargets);
+        return this._state;
+    }
+    applyState(node, state) {
+        node.getMorphInfo().bufferSubData(4 * 4, state.weights);
+        state.boundingBox.minPoint.addBy(this._originBox.minPoint);
+        state.boundingBox.maxPoint.addBy(this._originBox.maxPoint);
+        node.setAnimatedBoundingBox(state.boundingBox);
+    }
+    mixState(a, b, t) {
+        const state = {
+            weights: new Float32Array(a.numTargets),
+            boundingBox: new BoundingBox(),
+            numTargets: a.numTargets
+        };
+        for(let i = 0; i < a.numTargets; i++){
+            state.weights[i] = a.weights[i] + (b.weights[i] - a.weights[i]) * t;
+            state.boundingBox.minPoint = Vector3.min(a.boundingBox.minPoint, b.boundingBox.minPoint);
+            state.boundingBox.maxPoint = Vector3.max(a.boundingBox.maxPoint, b.boundingBox.maxPoint);
+        }
+        return state;
+    }
+    getBlendId() {
+        return 'node-morph';
+    }
+    getDuration() {
+        return this._interpolator.maxTime;
+    }
+    reset(node) {
+        // apply default weights
+        this._state.weights.set(this._defaultWeights);
+        this.applyState(node, this._state);
+    }
+}
+
+export { MorphTargetTrack };
+//# sourceMappingURL=morphtrack.js.map

package/dist/src/animation/morphtrack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"morphtrack.js","sources":["../../../src/animation/morphtrack.ts"],"sourcesContent":["import { AnimationTrack } from './animationtrack';\nimport type { Mesh, SceneNode } from '../scene';\nimport type { AssetAnimationTrack, AssetSubMeshData } from '../asset';\nimport { BoundingBox } from '../utility/bounding_volume';\nimport { MAX_MORPH_TARGETS } from '../values';\nimport { calculateMorphBoundingBox } from './morphtarget';\nimport type { AABB, Interpolator } from '@zephyr3d/base';\nimport { Vector3 } from '@zephyr3d/base';\n\n/** Morph animation state */\nexport type MorphState = {\n  numTargets: number;\n  weights: Float32Array<ArrayBuffer>;\n  boundingBox: BoundingBox;\n};\n\n/**\n * Morph target track\n * @public\n */\nexport class MorphTargetTrack extends AnimationTrack<MorphState> {\n  private readonly _state: MorphState;\n  private readonly _originBox: AABB;\n  private readonly _boundingBox: BoundingBox[];\n  private readonly _defaultWeights: number[];\n  private readonly _interpolator: Interpolator;\n  /**\n   * Create an instance of MorphTargetTrack\n   */\n  constructor(assetTrack: AssetAnimationTrack, subMesh: AssetSubMeshData, embedded?: boolean) {\n    super(embedded);\n    this._interpolator = assetTrack.interpolator;\n    this._state = {\n      numTargets: assetTrack.interpolator.stride,\n      boundingBox: new BoundingBox(),\n      weights: new Float32Array(MAX_MORPH_TARGETS)\n    };\n    this._boundingBox = subMesh.targetBox;\n    this._originBox = subMesh.mesh.getBoundingVolume().toAABB();\n    this._defaultWeights =\n      assetTrack.defaultMorphWeights ?? Array.from({ length: this._state.numTargets }).map(() => 0);\n  }\n  calculateState(target: object, currentTime: number): MorphState {\n    this._interpolator.interpolate(currentTime, this._state.weights);\n    calculateMorphBoundingBox(\n      this._state.boundingBox,\n      this._boundingBox,\n      this._state.weights,\n      this._state.numTargets\n    );\n    return this._state;\n  }\n  applyState(node: SceneNode, state: MorphState) {\n    (node as Mesh).getMorphInfo().bufferSubData(4 * 4, state.weights);\n    state.boundingBox.minPoint.addBy(this._originBox.minPoint);\n    state.boundingBox.maxPoint.addBy(this._originBox.maxPoint);\n    (node as Mesh).setAnimatedBoundingBox(state.boundingBox);\n  }\n  mixState(a: MorphState, b: MorphState, t: number): MorphState {\n    const state: MorphState = {\n      weights: new Float32Array(a.numTargets),\n      boundingBox: new BoundingBox(),\n      numTargets: a.numTargets\n    };\n    for (let i = 0; i < a.numTargets; i++) {\n      state.weights[i] = a.weights[i] + (b.weights[i] - a.weights[i]) * t;\n      state.boundingBox.minPoint = Vector3.min(a.boundingBox.minPoint, b.boundingBox.minPoint);\n      state.boundingBox.maxPoint = Vector3.max(a.boundingBox.maxPoint, b.boundingBox.maxPoint);\n    }\n    return state;\n  }\n  getBlendId(): unknown {\n    return 'node-morph';\n  }\n  getDuration(): number {\n    return this._interpolator.maxTime;\n  }\n  reset(node: SceneNode) {\n    // apply default weights\n    this._state.weights.set(this._defaultWeights);\n    this.applyState(node, this._state);\n  }\n}\n"],"names":["MorphTargetTrack","AnimationTrack","_state","_originBox","_boundingBox","_defaultWeights","_interpolator","assetTrack","subMesh","embedded","interpolator","numTargets","stride","boundingBox","BoundingBox","weights","Float32Array","MAX_MORPH_TARGETS","targetBox","mesh","getBoundingVolume","toAABB","defaultMorphWeights","Array","from","length","map","calculateState","target","currentTime","interpolate","calculateMorphBoundingBox","applyState","node","state","getMorphInfo","bufferSubData","minPoint","addBy","maxPoint","setAnimatedBoundingBox","mixState","a","b","t","i","Vector3","min","max","getBlendId","getDuration","maxTime","reset","set"],"mappings":"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"}

package/dist/src/animation/proptrack.js

@@ -0,0 +1,161 @@
+import { AnimationTrack } from './animationtrack.js';
+import { Interpolator } from '@zephyr3d/base';
+
+/**
+ * Translate animation track
+ * @public
+ */ class PropertyTrack extends AnimationTrack {
+    _state;
+    _stateAlpha;
+    _target;
+    _prop;
+    _count;
+    _interpolator;
+    _interpolatorAlpha;
+    /**
+   * Create an instance of TranslationTrack from keyframe values
+   * @param prop - Property to be animated
+   */ constructor(prop, value, embedded){
+        super(embedded);
+        this._prop = prop;
+        this._target = '';
+        this._state = {
+            num: [
+                0,
+                0,
+                0,
+                0
+            ]
+        };
+        this._stateAlpha = null;
+        this._interpolator = null;
+        this._interpolatorAlpha = null;
+        if (value) {
+            this._state.num = value.slice();
+        }
+        switch(this._prop.type){
+            case 'float':
+                this._count = 1;
+                this._interpolator = new Interpolator('cubicspline-natural', 'number', new Float32Array([
+                    0,
+                    1
+                ]), new Float32Array([
+                    this._state.num[0],
+                    this._state.num[0]
+                ]));
+                break;
+            case 'vec2':
+                this._count = 2;
+                this._interpolator = new Interpolator('cubicspline-natural', 'vec2', new Float32Array([
+                    0,
+                    1
+                ]), new Float32Array([
+                    ...this._state.num.slice(0, 2),
+                    ...this._state.num.slice(0, 2)
+                ]));
+                break;
+            case 'rgb':
+            case 'vec3':
+                this._count = 3;
+                this._interpolator = new Interpolator('cubicspline-natural', 'vec3', new Float32Array([
+                    0,
+                    1
+                ]), new Float32Array([
+                    ...this._state.num.slice(0, 3),
+                    ...this._state.num.slice(0, 3)
+                ]));
+                break;
+            case 'vec4':
+                this._count = 4;
+                this._interpolator = new Interpolator('cubicspline-natural', 'vec4', new Float32Array([
+                    0,
+                    1
+                ]), new Float32Array([
+                    ...this._state.num.slice(0, 4),
+                    ...this._state.num.slice(0, 4)
+                ]));
+                break;
+            case 'rgba':
+                this._count = 4;
+                this._interpolator = new Interpolator('linear', 'vec3', new Float32Array([
+                    0,
+                    1
+                ]), new Float32Array([
+                    ...this._state.num.slice(0, 3),
+                    ...this._state.num.slice(0, 3)
+                ]));
+                this._interpolatorAlpha = new Interpolator('linear', 'number', new Float32Array([
+                    0,
+                    1
+                ]), new Float32Array([
+                    this._state.num[3],
+                    this._state.num[3]
+                ]));
+                this._stateAlpha = {
+                    num: [
+                        this._state.num[3]
+                    ]
+                };
+                break;
+            default:
+                throw new Error(`Property '${this._prop.name}' cannot be animated`);
+        }
+    }
+    get target() {
+        return this._target;
+    }
+    set target(val) {
+        this._target = val;
+    }
+    get interpolator() {
+        return this._interpolator;
+    }
+    set interpolator(interpolator) {
+        this._interpolator = interpolator;
+    }
+    get interpolatorAlpha() {
+        return this._interpolatorAlpha;
+    }
+    set interpolatorAlpha(interpolator) {
+        this._interpolatorAlpha = interpolator ?? null;
+        if (!this._stateAlpha && this._interpolatorAlpha) {
+            this._stateAlpha = {
+                num: [
+                    0
+                ]
+            };
+        }
+    }
+    calculateState(target, currentTime) {
+        this._interpolator.interpolate(currentTime, this._state.num);
+        if (this._interpolatorAlpha) {
+            this._interpolatorAlpha.interpolate(currentTime, this._stateAlpha.num);
+            this._state.num[3] = this._stateAlpha.num[0];
+        }
+        return this._state;
+    }
+    applyState(target, state) {
+        this._prop.set.call(target, state);
+    }
+    mixState(a, b, t) {
+        const v = [];
+        for(let i = 0; i < this._count; i++){
+            v[i] = a.num[i] + t * (b.num[i] - a.num[i]);
+        }
+        return {
+            num: v
+        };
+    }
+    getBlendId() {
+        return this._prop;
+    }
+    getDuration() {
+        return this._interpolator.maxTime;
+    }
+    getProp() {
+        return this._prop;
+    }
+}
+
+export { PropertyTrack };
+//# sourceMappingURL=proptrack.js.map

package/dist/src/animation/proptrack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proptrack.js","sources":["../../../src/animation/proptrack.ts"],"sourcesContent":["import { AnimationTrack } from './animationtrack';\r\nimport type { PropertyAccessor, PropertyValue } from '../utility';\r\nimport { Interpolator } from '@zephyr3d/base';\r\n\r\n/**\r\n * Translate animation track\r\n * @public\r\n */\r\nexport class PropertyTrack extends AnimationTrack<PropertyValue> {\r\n  private readonly _state: PropertyValue;\r\n  private _stateAlpha: PropertyValue;\r\n  private _target: string;\r\n  private readonly _prop: PropertyAccessor;\r\n  private readonly _count: number;\r\n  private _interpolator: Interpolator;\r\n  private _interpolatorAlpha: Interpolator;\r\n  /**\r\n   * Create an instance of TranslationTrack from keyframe values\r\n   * @param prop - Property to be animated\r\n   */\r\n  constructor(prop: PropertyAccessor, value?: number[], embedded?: boolean) {\r\n    super(embedded);\r\n    this._prop = prop;\r\n    this._target = '';\r\n    this._state = { num: [0, 0, 0, 0] };\r\n    this._stateAlpha = null;\r\n    this._interpolator = null;\r\n    this._interpolatorAlpha = null;\r\n    if (value) {\r\n      this._state.num = value.slice();\r\n    }\r\n    switch (this._prop.type) {\r\n      case 'float':\r\n        this._count = 1;\r\n        this._interpolator = new Interpolator(\r\n          'cubicspline-natural',\r\n          'number',\r\n          new Float32Array([0, 1]),\r\n          new Float32Array([this._state.num[0], this._state.num[0]])\r\n        );\r\n        break;\r\n      case 'vec2':\r\n        this._count = 2;\r\n        this._interpolator = new Interpolator(\r\n          'cubicspline-natural',\r\n          'vec2',\r\n          new Float32Array([0, 1]),\r\n          new Float32Array([...this._state.num.slice(0, 2), ...this._state.num.slice(0, 2)])\r\n        );\r\n        break;\r\n      case 'rgb':\r\n      case 'vec3':\r\n        this._count = 3;\r\n        this._interpolator = new Interpolator(\r\n          'cubicspline-natural',\r\n          'vec3',\r\n          new Float32Array([0, 1]),\r\n          new Float32Array([...this._state.num.slice(0, 3), ...this._state.num.slice(0, 3)])\r\n        );\r\n        break;\r\n      case 'vec4':\r\n        this._count = 4;\r\n        this._interpolator = new Interpolator(\r\n          'cubicspline-natural',\r\n          'vec4',\r\n          new Float32Array([0, 1]),\r\n          new Float32Array([...this._state.num.slice(0, 4), ...this._state.num.slice(0, 4)])\r\n        );\r\n        break;\r\n      case 'rgba':\r\n        this._count = 4;\r\n        this._interpolator = new Interpolator(\r\n          'linear',\r\n          'vec3',\r\n          new Float32Array([0, 1]),\r\n          new Float32Array([...this._state.num.slice(0, 3), ...this._state.num.slice(0, 3)])\r\n        );\r\n        this._interpolatorAlpha = new Interpolator(\r\n          'linear',\r\n          'number',\r\n          new Float32Array([0, 1]),\r\n          new Float32Array([this._state.num[3], this._state.num[3]])\r\n        );\r\n        this._stateAlpha = { num: [this._state.num[3]] };\r\n        break;\r\n      default:\r\n        throw new Error(`Property '${this._prop.name}' cannot be animated`);\r\n    }\r\n  }\r\n  get target() {\r\n    return this._target;\r\n  }\r\n  set target(val: string) {\r\n    this._target = val;\r\n  }\r\n  get interpolator() {\r\n    return this._interpolator;\r\n  }\r\n  set interpolator(interpolator: Interpolator) {\r\n    this._interpolator = interpolator;\r\n  }\r\n  get interpolatorAlpha() {\r\n    return this._interpolatorAlpha;\r\n  }\r\n  set interpolatorAlpha(interpolator: Interpolator) {\r\n    this._interpolatorAlpha = interpolator ?? null;\r\n    if (!this._stateAlpha && this._interpolatorAlpha) {\r\n      this._stateAlpha = { num: [0] };\r\n    }\r\n  }\r\n  calculateState(target: unknown, currentTime: number): PropertyValue {\r\n    this._interpolator.interpolate(currentTime, this._state.num);\r\n    if (this._interpolatorAlpha) {\r\n      this._interpolatorAlpha.interpolate(currentTime, this._stateAlpha.num);\r\n      this._state.num[3] = this._stateAlpha.num[0];\r\n    }\r\n    return this._state;\r\n  }\r\n  applyState(target: object, state: PropertyValue) {\r\n    this._prop.set.call(target, state);\r\n  }\r\n  mixState(a: PropertyValue, b: PropertyValue, t: number): PropertyValue {\r\n    const v: number[] = [];\r\n    for (let i = 0; i < this._count; i++) {\r\n      v[i] = a.num[i] + t * (b.num[i] - a.num[i]);\r\n    }\r\n    return { num: v };\r\n  }\r\n  getBlendId(): unknown {\r\n    return this._prop;\r\n  }\r\n  getDuration(): number {\r\n    return this._interpolator.maxTime;\r\n  }\r\n  getProp(): PropertyAccessor {\r\n    return this._prop;\r\n  }\r\n}\r\n"],"names":["PropertyTrack","AnimationTrack","_state","_stateAlpha","_target","_prop","_count","_interpolator","_interpolatorAlpha","prop","value","embedded","num","slice","type","Interpolator","Float32Array","Error","name","target","val","interpolator","interpolatorAlpha","calculateState","currentTime","interpolate","applyState","state","set","call","mixState","a","b","t","v","i","getBlendId","getDuration","maxTime","getProp"],"mappings":"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"}

package/dist/src/animation/rotationtrack.js

@@ -0,0 +1,51 @@
+import { Interpolator, Quaternion } from '@zephyr3d/base';
+import { AnimationTrack } from './animationtrack.js';
+
+/**
+ * Rotation animation track
+ * @public
+ */ class NodeRotationTrack extends AnimationTrack {
+    _state;
+    _interpolator;
+    constructor(modeOrInterpolator, keyFramesOrEmbedded, embedded){
+        if (modeOrInterpolator instanceof Interpolator) {
+            if (modeOrInterpolator.target !== 'quat') {
+                throw new Error(`RotationTrack(): interpolator target must be 'quat'`);
+            }
+            super(keyFramesOrEmbedded ?? false);
+            this._interpolator = modeOrInterpolator;
+        } else {
+            const keyFrames = keyFramesOrEmbedded;
+            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;
+            }
+            super(embedded ?? false);
+            this._interpolator = new Interpolator(modeOrInterpolator, 'quat', inputs, outputs);
+        }
+        this._state = new Quaternion();
+    }
+    calculateState(target, currentTime) {
+        this._interpolator.interpolate(currentTime, this._state);
+        return this._state;
+    }
+    applyState(node, state) {
+        node.rotation.set(state);
+    }
+    mixState(a, b, t) {
+        return Quaternion.slerp(a, b, t);
+    }
+    getBlendId() {
+        return 'node-rotation';
+    }
+    getDuration() {
+        return this._interpolator.maxTime;
+    }
+}
+
+export { NodeRotationTrack };
+//# sourceMappingURL=rotationtrack.js.map

package/dist/src/animation/rotationtrack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotationtrack.js","sources":["../../../src/animation/rotationtrack.ts"],"sourcesContent":["import type { InterpolationMode } from '@zephyr3d/base';\r\nimport { Interpolator, Quaternion } from '@zephyr3d/base';\r\nimport { AnimationTrack } from './animationtrack';\r\nimport type { SceneNode } from '../scene';\r\n\r\n/**\r\n * Rotation animation track\r\n * @public\r\n */\r\nexport class NodeRotationTrack extends AnimationTrack<Quaternion> {\r\n  private readonly _state: Quaternion;\r\n  private readonly _interpolator: Interpolator;\r\n  /**\r\n   * Create an instance of RotationTrack from keyframe values\r\n   * @param interpolator - Interpolator object that contains keyframe values\r\n   * @param embedded - Whether this track be an embedded track\r\n   */\r\n  constructor(interpolator: Interpolator, embedded?: boolean);\r\n  /**\r\n   * Create an instance of RotationTrack from keyframe values\r\n   * @param mode - The interpolation mode of keyframes\r\n   * @param keyFrames - Keyframe values\r\n   * @param embedded - Whether this track be an embedded track\r\n   */\r\n  constructor(mode: InterpolationMode, keyFrames: { time: number; value: Quaternion }[], embedded?: boolean);\r\n  constructor(\r\n    modeOrInterpolator: Interpolator | InterpolationMode,\r\n    keyFramesOrEmbedded?: { time: number; value: Quaternion }[] | boolean,\r\n    embedded?: boolean\r\n  ) {\r\n    if (modeOrInterpolator instanceof Interpolator) {\r\n      if (modeOrInterpolator.target !== 'quat') {\r\n        throw new Error(`RotationTrack(): interpolator target must be 'quat'`);\r\n      }\r\n      super((keyFramesOrEmbedded as boolean) ?? false);\r\n      this._interpolator = modeOrInterpolator;\r\n    } else {\r\n      const keyFrames = keyFramesOrEmbedded as { time: number; value: Quaternion }[];\r\n      const inputs = new Float32Array(keyFrames.map((val) => val.time));\r\n      const outputs = new Float32Array(keyFrames.length * 4);\r\n      for (let i = 0; i < keyFrames.length; i++) {\r\n        outputs[i * 4 + 0] = keyFrames[i].value.x;\r\n        outputs[i * 4 + 1] = keyFrames[i].value.y;\r\n        outputs[i * 4 + 2] = keyFrames[i].value.z;\r\n        outputs[i * 4 + 3] = keyFrames[i].value.w;\r\n      }\r\n      super(embedded ?? false);\r\n      this._interpolator = new Interpolator(modeOrInterpolator, 'quat', inputs, outputs);\r\n    }\r\n    this._state = new Quaternion();\r\n  }\r\n  calculateState(target: object, currentTime: number): Quaternion {\r\n    this._interpolator.interpolate(currentTime, this._state);\r\n    return this._state;\r\n  }\r\n  applyState(node: SceneNode, state: Quaternion) {\r\n    node.rotation.set(state);\r\n  }\r\n  mixState(a: Quaternion, b: Quaternion, t: number): Quaternion {\r\n    return Quaternion.slerp(a, b, t);\r\n  }\r\n  getBlendId(): unknown {\r\n    return 'node-rotation';\r\n  }\r\n  getDuration(): number {\r\n    return this._interpolator.maxTime;\r\n  }\r\n}\r\n"],"names":["NodeRotationTrack","AnimationTrack","_state","_interpolator","modeOrInterpolator","keyFramesOrEmbedded","embedded","Interpolator","target","Error","keyFrames","inputs","Float32Array","map","val","time","outputs","length","i","value","x","y","z","w","Quaternion","calculateState","currentTime","interpolate","applyState","node","state","rotation","set","mixState","a","b","t","slerp","getBlendId","getDuration","maxTime"],"mappings":";;;AAKA;;;IAIO,MAAMA,iBAA0BC,SAAAA,cAAAA,CAAAA;IACpBC,MAAmB;IACnBC,aAA4B;AAc7C,IAAA,WAAA,CACEC,kBAAoD,EACpDC,mBAAqE,EACrEC,QAAkB,CAClB;AACA,QAAA,IAAIF,8BAA8BG,YAAc,EAAA;YAC9C,IAAIH,kBAAAA,CAAmBI,MAAM,KAAK,MAAQ,EAAA;AACxC,gBAAA,MAAM,IAAIC,KAAAA,CAAM,CAAC,mDAAmD,CAAC,CAAA;AACvE;YACA,KAAK,CAAC,mBAAoC,IAAA,KAAA,CAAA;YAC1C,IAAI,CAACN,aAAa,GAAGC,kBAAAA;SAChB,MAAA;AACL,YAAA,MAAMM,SAAYL,GAAAA,mBAAAA;YAClB,MAAMM,MAAAA,GAAS,IAAIC,YAAaF,CAAAA,SAAAA,CAAUG,GAAG,CAAC,CAACC,GAAQA,GAAAA,GAAAA,CAAIC,IAAI,CAAA,CAAA;AAC/D,YAAA,MAAMC,OAAU,GAAA,IAAIJ,YAAaF,CAAAA,SAAAA,CAAUO,MAAM,GAAG,CAAA,CAAA;AACpD,YAAA,IAAK,IAAIC,CAAI,GAAA,CAAA,EAAGA,IAAIR,SAAUO,CAAAA,MAAM,EAAEC,CAAK,EAAA,CAAA;gBACzCF,OAAO,CAACE,CAAI,GAAA,CAAA,GAAI,CAAE,CAAA,GAAGR,SAAS,CAACQ,CAAE,CAAA,CAACC,KAAK,CAACC,CAAC;gBACzCJ,OAAO,CAACE,CAAI,GAAA,CAAA,GAAI,CAAE,CAAA,GAAGR,SAAS,CAACQ,CAAE,CAAA,CAACC,KAAK,CAACE,CAAC;gBACzCL,OAAO,CAACE,CAAI,GAAA,CAAA,GAAI,CAAE,CAAA,GAAGR,SAAS,CAACQ,CAAE,CAAA,CAACC,KAAK,CAACG,CAAC;gBACzCN,OAAO,CAACE,CAAI,GAAA,CAAA,GAAI,CAAE,CAAA,GAAGR,SAAS,CAACQ,CAAE,CAAA,CAACC,KAAK,CAACI,CAAC;AAC3C;AACA,YAAA,KAAK,CAACjB,QAAY,IAAA,KAAA,CAAA;AAClB,YAAA,IAAI,CAACH,aAAa,GAAG,IAAII,YAAaH,CAAAA,kBAAAA,EAAoB,QAAQO,MAAQK,EAAAA,OAAAA,CAAAA;AAC5E;QACA,IAAI,CAACd,MAAM,GAAG,IAAIsB,UAAAA,EAAAA;AACpB;IACAC,cAAejB,CAAAA,MAAc,EAAEkB,WAAmB,EAAc;QAC9D,IAAI,CAACvB,aAAa,CAACwB,WAAW,CAACD,WAAa,EAAA,IAAI,CAACxB,MAAM,CAAA;QACvD,OAAO,IAAI,CAACA,MAAM;AACpB;IACA0B,UAAWC,CAAAA,IAAe,EAAEC,KAAiB,EAAE;QAC7CD,IAAKE,CAAAA,QAAQ,CAACC,GAAG,CAACF,KAAAA,CAAAA;AACpB;AACAG,IAAAA,QAAAA,CAASC,CAAa,EAAEC,CAAa,EAAEC,CAAS,EAAc;AAC5D,QAAA,OAAOZ,UAAWa,CAAAA,KAAK,CAACH,CAAAA,EAAGC,CAAGC,EAAAA,CAAAA,CAAAA;AAChC;IACAE,UAAsB,GAAA;QACpB,OAAO,eAAA;AACT;IACAC,WAAsB,GAAA;AACpB,QAAA,OAAO,IAAI,CAACpC,aAAa,CAACqC,OAAO;AACnC;AACF;;;;"}

package/dist/src/animation/scaletrack.js

@@ -0,0 +1,50 @@
+import { Interpolator, Vector3 } from '@zephyr3d/base';
+import { AnimationTrack } from './animationtrack.js';
+
+/**
+ * Scale animation track
+ * @public
+ */ class NodeScaleTrack extends AnimationTrack {
+    _state;
+    _interpolator;
+    constructor(modeOrInterpolator, keyFramesOrEmbedded, embedded){
+        if (modeOrInterpolator instanceof Interpolator) {
+            if (modeOrInterpolator.target !== 'vec3') {
+                throw new Error(`ScaleTrack(): interpolator target must be 'vec3'`);
+            }
+            super(keyFramesOrEmbedded ?? false);
+            this._interpolator = modeOrInterpolator;
+        } else {
+            const keyFrames = keyFramesOrEmbedded;
+            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;
+            }
+            super(embedded ?? false);
+            this._interpolator = new Interpolator(modeOrInterpolator, 'vec3', inputs, outputs);
+        }
+        this._state = new Vector3();
+    }
+    calculateState(target, currentTime) {
+        this._interpolator.interpolate(currentTime, this._state);
+        return this._state;
+    }
+    applyState(node, state) {
+        node.scale.set(state);
+    }
+    mixState(a, b, t) {
+        return new Vector3(a.x + t * (b.x - a.x), a.y + t * (b.y - a.y), a.z + t * (b.z - a.z));
+    }
+    getBlendId() {
+        return 'node-scale';
+    }
+    getDuration() {
+        return this._interpolator.maxTime;
+    }
+}
+
+export { NodeScaleTrack };
+//# sourceMappingURL=scaletrack.js.map

package/dist/src/animation/scaletrack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaletrack.js","sources":["../../../src/animation/scaletrack.ts"],"sourcesContent":["import type { InterpolationMode } from '@zephyr3d/base';\r\nimport { Interpolator, Vector3 } from '@zephyr3d/base';\r\nimport { AnimationTrack } from './animationtrack';\r\nimport type { SceneNode } from '../scene';\r\n\r\n/**\r\n * Scale animation track\r\n * @public\r\n */\r\nexport class NodeScaleTrack extends AnimationTrack<Vector3> {\r\n  private readonly _state: Vector3;\r\n  private readonly _interpolator: Interpolator;\r\n  /**\r\n   * Create an instance of ScaleTrack from keyframe values\r\n   * @param interpolator - Interpolator object that contains keyframe values\r\n   * @param embedded - Whether this track be an embedded track\r\n   */\r\n  constructor(interpolator: Interpolator, embedded?: boolean);\r\n  /**\r\n   * Create an instance of ScaleTrack from keyframe values\r\n   * @param mode - The interpolation mode of keyframes\r\n   * @param keyFrames - Keyframe values\r\n   * @param embedded - Whether this track be an embedded track\r\n   */\r\n  constructor(mode: InterpolationMode, keyFrames: { time: number; value: Vector3 }[], embedded?: boolean);\r\n  constructor(\r\n    modeOrInterpolator?: Interpolator | InterpolationMode,\r\n    keyFramesOrEmbedded?: { time: number; value: Vector3 }[] | boolean,\r\n    embedded?: boolean\r\n  ) {\r\n    if (modeOrInterpolator instanceof Interpolator) {\r\n      if (modeOrInterpolator.target !== 'vec3') {\r\n        throw new Error(`ScaleTrack(): interpolator target must be 'vec3'`);\r\n      }\r\n      super((keyFramesOrEmbedded as boolean) ?? false);\r\n      this._interpolator = modeOrInterpolator;\r\n    } else {\r\n      const keyFrames = keyFramesOrEmbedded as { time: number; value: Vector3 }[];\r\n      const inputs = new Float32Array(keyFrames.map((val) => val.time));\r\n      const outputs = new Float32Array(keyFrames.length * 3);\r\n      for (let i = 0; i < keyFrames.length; i++) {\r\n        outputs[i * 3 + 0] = keyFrames[i].value.x;\r\n        outputs[i * 3 + 1] = keyFrames[i].value.y;\r\n        outputs[i * 3 + 2] = keyFrames[i].value.z;\r\n      }\r\n      super(embedded ?? false);\r\n      this._interpolator = new Interpolator(modeOrInterpolator, 'vec3', inputs, outputs);\r\n    }\r\n    this._state = new Vector3();\r\n  }\r\n  calculateState(target: object, currentTime: number): Vector3 {\r\n    this._interpolator.interpolate(currentTime, this._state);\r\n    return this._state;\r\n  }\r\n  applyState(node: SceneNode, state: Vector3) {\r\n    node.scale.set(state);\r\n  }\r\n  mixState(a: Vector3, b: Vector3, t: number): Vector3 {\r\n    return new Vector3(a.x + t * (b.x - a.x), a.y + t * (b.y - a.y), a.z + t * (b.z - a.z));\r\n  }\r\n  getBlendId(): unknown {\r\n    return 'node-scale';\r\n  }\r\n  getDuration(): number {\r\n    return this._interpolator.maxTime;\r\n  }\r\n}\r\n"],"names":["NodeScaleTrack","AnimationTrack","_state","_interpolator","modeOrInterpolator","keyFramesOrEmbedded","embedded","Interpolator","target","Error","keyFrames","inputs","Float32Array","map","val","time","outputs","length","i","value","x","y","z","Vector3","calculateState","currentTime","interpolate","applyState","node","state","scale","set","mixState","a","b","t","getBlendId","getDuration","maxTime"],"mappings":";;;AAKA;;;IAIO,MAAMA,cAAuBC,SAAAA,cAAAA,CAAAA;IACjBC,MAAgB;IAChBC,aAA4B;AAc7C,IAAA,WAAA,CACEC,kBAAqD,EACrDC,mBAAkE,EAClEC,QAAkB,CAClB;AACA,QAAA,IAAIF,8BAA8BG,YAAc,EAAA;YAC9C,IAAIH,kBAAAA,CAAmBI,MAAM,KAAK,MAAQ,EAAA;AACxC,gBAAA,MAAM,IAAIC,KAAAA,CAAM,CAAC,gDAAgD,CAAC,CAAA;AACpE;YACA,KAAK,CAAC,mBAAoC,IAAA,KAAA,CAAA;YAC1C,IAAI,CAACN,aAAa,GAAGC,kBAAAA;SAChB,MAAA;AACL,YAAA,MAAMM,SAAYL,GAAAA,mBAAAA;YAClB,MAAMM,MAAAA,GAAS,IAAIC,YAAaF,CAAAA,SAAAA,CAAUG,GAAG,CAAC,CAACC,GAAQA,GAAAA,GAAAA,CAAIC,IAAI,CAAA,CAAA;AAC/D,YAAA,MAAMC,OAAU,GAAA,IAAIJ,YAAaF,CAAAA,SAAAA,CAAUO,MAAM,GAAG,CAAA,CAAA;AACpD,YAAA,IAAK,IAAIC,CAAI,GAAA,CAAA,EAAGA,IAAIR,SAAUO,CAAAA,MAAM,EAAEC,CAAK,EAAA,CAAA;gBACzCF,OAAO,CAACE,CAAI,GAAA,CAAA,GAAI,CAAE,CAAA,GAAGR,SAAS,CAACQ,CAAE,CAAA,CAACC,KAAK,CAACC,CAAC;gBACzCJ,OAAO,CAACE,CAAI,GAAA,CAAA,GAAI,CAAE,CAAA,GAAGR,SAAS,CAACQ,CAAE,CAAA,CAACC,KAAK,CAACE,CAAC;gBACzCL,OAAO,CAACE,CAAI,GAAA,CAAA,GAAI,CAAE,CAAA,GAAGR,SAAS,CAACQ,CAAE,CAAA,CAACC,KAAK,CAACG,CAAC;AAC3C;AACA,YAAA,KAAK,CAAChB,QAAY,IAAA,KAAA,CAAA;AAClB,YAAA,IAAI,CAACH,aAAa,GAAG,IAAII,YAAaH,CAAAA,kBAAAA,EAAoB,QAAQO,MAAQK,EAAAA,OAAAA,CAAAA;AAC5E;QACA,IAAI,CAACd,MAAM,GAAG,IAAIqB,OAAAA,EAAAA;AACpB;IACAC,cAAehB,CAAAA,MAAc,EAAEiB,WAAmB,EAAW;QAC3D,IAAI,CAACtB,aAAa,CAACuB,WAAW,CAACD,WAAa,EAAA,IAAI,CAACvB,MAAM,CAAA;QACvD,OAAO,IAAI,CAACA,MAAM;AACpB;IACAyB,UAAWC,CAAAA,IAAe,EAAEC,KAAc,EAAE;QAC1CD,IAAKE,CAAAA,KAAK,CAACC,GAAG,CAACF,KAAAA,CAAAA;AACjB;AACAG,IAAAA,QAAAA,CAASC,CAAU,EAAEC,CAAU,EAAEC,CAAS,EAAW;AACnD,QAAA,OAAO,IAAIZ,OAAQU,CAAAA,CAAAA,CAAEb,CAAC,GAAGe,KAAKD,CAAAA,CAAEd,CAAC,GAAGa,EAAEb,CAAAA,CAAIa,EAAAA,CAAAA,CAAEZ,CAAC,GAAGc,CAAAA,IAAKD,CAAAA,CAAEb,CAAC,GAAGY,CAAAA,CAAEZ,CAAAA,GAAIY,CAAEX,CAAAA,CAAC,GAAGa,CAAAA,IAAKD,CAAEZ,CAAAA,CAAC,GAAGW,CAAAA,CAAEX,CAAC,CAADA,CAAAA;AACtF;IACAc,UAAsB,GAAA;QACpB,OAAO,YAAA;AACT;IACAC,WAAsB,GAAA;AACpB,QAAA,OAAO,IAAI,CAAClC,aAAa,CAACmC,OAAO;AACnC;AACF;;;;"}