@zephyr3d/scene 0.3.1 → 0.5.0

package/dist/animation/morphtrack.js

@@ -0,0 +1,68 @@
+import { AnimationTrack } from './animationtrack.js';
+import '../utility/pmrem.js';
+import '../utility/panorama.js';
+import '../utility/shprojection.js';
+import { Vector3 } from '@zephyr3d/base';
+import { BoundingBox } from '../utility/bounding_volume.js';
+import { MAX_MORPH_TARGETS } from '../values.js';
+import { calculateMorphBoundingBox } from './morphtarget.js';
+
+/**
+ * Morph target track
+ * @public
+ */ class MorphTargetTrack extends AnimationTrack {
+    _state;
+    _boundingBox;
+    _defaultWeights;
+    /**
+   * Create an instance of MorphTargetTrack
+   */ constructor(assetTrack, subMesh){
+        super(assetTrack.interpolator);
+        this._state = {
+            numTargets: assetTrack.interpolator.stride,
+            boundingBox: new BoundingBox(),
+            weights: new Float32Array(MAX_MORPH_TARGETS)
+        };
+        this._boundingBox = subMesh.targetBox;
+        this._defaultWeights = assetTrack.defaultMorphWeights ?? Array.from({
+            length: this._state.numTargets
+        }).map(()=>0);
+    }
+    calculateState(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);
+        const animatedBoundingBox = new BoundingBox();
+        const originBoundingBox = node.getBoundingVolume().toAABB();
+        animatedBoundingBox.minPoint = Vector3.add(originBoundingBox.minPoint, state.boundingBox.minPoint);
+        animatedBoundingBox.maxPoint = Vector3.add(originBoundingBox.maxPoint, state.boundingBox.maxPoint);
+        node.setAnimatedBoundingBox(animatedBoundingBox);
+    }
+    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';
+    }
+    reset(node) {
+        // apply default weights
+        this._state.weights.set(this._defaultWeights);
+        this.applyState(node, this._state);
+    }
+}
+
+export { MorphTargetTrack };
+//# sourceMappingURL=morphtrack.js.map

package/dist/animation/morphtrack.js.map

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

package/dist/animation/rotationtrack.js

@@ -1,12 +1,11 @@
-import { Quaternion, Interpolator } from '@zephyr3d/base';
+import { Interpolator, Quaternion } from '@zephyr3d/base';
 import { AnimationTrack } from './animationtrack.js';
 
-// Reduce gc
-const tmpQuat = new Quaternion();
 /**
  * Rotation animation track
  * @public
  */ class RotationTrack extends AnimationTrack {
+    _state;
     constructor(modeOrInterpolator, keyFrames){
         if (modeOrInterpolator instanceof Interpolator) {
             if (modeOrInterpolator.target !== 'quat') {
@@ -25,11 +24,20 @@ const tmpQuat = new Quaternion();
             const interpolator = new Interpolator(modeOrInterpolator, 'quat', inputs, outputs);
             super(interpolator);
         }
+        this._state = new Quaternion();
     }
-    /** {@inheritDoc AnimationTrack.apply} */ apply(node, currentTime, duration) {
-        this._interpolator.interpolate(currentTime, duration, tmpQuat);
-        node.rotation.set(tmpQuat);
-        return true;
+    calculateState(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';
     }
 }
 

package/dist/animation/rotationtrack.js.map

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

package/dist/animation/scaletrack.js

@@ -1,12 +1,11 @@
-import { Vector3, Interpolator } from '@zephyr3d/base';
+import { Interpolator, Vector3 } from '@zephyr3d/base';
 import { AnimationTrack } from './animationtrack.js';
 
-// Reduce gc
-const tmpVec3 = new Vector3();
 /**
  * Scale animation track
  * @public
  */ class ScaleTrack extends AnimationTrack {
+    _state;
     constructor(modeOrInterpolator, keyFrames){
         if (modeOrInterpolator instanceof Interpolator) {
             if (modeOrInterpolator.target !== 'vec3') {
@@ -24,11 +23,20 @@ const tmpVec3 = new Vector3();
             const interpolator = new Interpolator(modeOrInterpolator, 'vec3', inputs, outputs);
             super(interpolator);
         }
+        this._state = new Vector3();
     }
-    /** {@inheritDoc AnimationTrack.apply} */ apply(node, currentTime, duration) {
-        this._interpolator.interpolate(currentTime, duration, tmpVec3);
-        node.scale.set(tmpVec3);
-        return true;
+    calculateState(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';
     }
 }
 

package/dist/animation/scaletrack.js.map

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

package/dist/animation/skeleton.js

@@ -1,5 +1,9 @@
 import { Vector3, Matrix4x4, nextPowerOf2 } from '@zephyr3d/base';
 import { Application } from '../app.js';
+import '../utility/pmrem.js';
+import '../utility/panorama.js';
+import '../utility/shprojection.js';
+import { BoundingBox } from '../utility/bounding_volume.js';
 
 const tmpV0 = new Vector3();
 const tmpV1 = new Vector3();
@@ -9,6 +13,7 @@ const tmpV3 = new Vector3();
  * Skeleton for skinned animation
  * @public
  */ class Skeleton {
+    /** @internal */ _meshes;
     /** @internal */ _joints;
     /** @internal */ _inverseBindMatrices;
     /** @internal */ _bindPoseMatrices;
@@ -20,13 +25,21 @@ const tmpV3 = new Vector3();
    * @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){
+   */ constructor(joints, inverseBindMatrices, bindPoseMatrices, meshes, bounding){
         this._joints = joints;
         this._inverseBindMatrices = inverseBindMatrices;
         this._bindPoseMatrices = bindPoseMatrices;
         this._jointMatrixArray = null;
         this._jointMatrices = null;
         this._jointTexture = null;
+        this.updateJointMatrices();
+        this._meshes = meshes.map((mesh, index)=>{
+            return {
+                mesh,
+                bounding: this.getBoundingInfo(bounding[index]),
+                box: new BoundingBox()
+            };
+        });
     }
     /**
    * Disposes self
@@ -66,6 +79,25 @@ const tmpV3 = new Vector3();
         this.updateJointMatrices();
         this._jointTexture.update(this._jointMatrixArray, 0, 0, this._jointTexture.width, this._jointTexture.height);
     }
+    /** @internal */ apply() {
+        this.computeJoints();
+        for (const mesh of this._meshes){
+            this.computeBoundingBox(mesh.bounding, mesh.mesh.invWorldMatrix);
+            mesh.mesh.setBoneMatrices(this.jointTexture);
+            mesh.mesh.setInvBindMatrix(mesh.mesh.invWorldMatrix);
+            mesh.mesh.setAnimatedBoundingBox(mesh.bounding.boundingBox);
+        }
+    }
+    /** @internal */ reset(model) {
+        this.computeBindPose();
+        for (const mesh of this._meshes){
+            const invWorldMatrix = Matrix4x4.multiply(mesh.mesh.invWorldMatrix, model.worldMatrix);
+            this.computeBoundingBox(mesh.bounding, invWorldMatrix);
+            mesh.mesh.setBoneMatrices(this.jointTexture);
+            mesh.mesh.setInvBindMatrix(invWorldMatrix);
+            mesh.mesh.setAnimatedBoundingBox(mesh.bounding.boundingBox);
+        }
+    }
     /** @internal */ computeBoundingBox(info, invWorldMatrix) {
         info.boundingBox.beginExtend();
         for(let i = 0; i < info.boundingVertices.length; i++){
@@ -91,6 +123,74 @@ const tmpV3 = new Vector3();
         const buffer = this._jointMatrixArray.buffer;
         this._jointMatrices = this._joints.map((val, index)=>new Matrix4x4(buffer, index * 16 * Float32Array.BYTES_PER_ELEMENT));
     }
+    /** @internal */ getBoundingInfo(meshData) {
+        const indices = [
+            0,
+            0,
+            0,
+            0,
+            0,
+            0
+        ];
+        let minx = Number.MAX_VALUE;
+        let maxx = -Number.MAX_VALUE;
+        let miny = Number.MAX_VALUE;
+        let maxy = -Number.MAX_VALUE;
+        let minz = Number.MAX_VALUE;
+        let maxz = -Number.MAX_VALUE;
+        const v = meshData.rawPositions;
+        const vert = new Vector3();
+        const tmpV0 = new Vector3();
+        const tmpV1 = new Vector3();
+        const tmpV2 = new Vector3();
+        const tmpV3 = new Vector3();
+        const numVertices = Math.floor(v.length / 3);
+        for(let i = 0; i < numVertices; i++){
+            vert.setXYZ(v[i * 3], v[i * 3 + 1], v[i * 3 + 2]);
+            this.jointMatrices[meshData.rawBlendIndices[i * 4 + 0]].transformPointAffine(vert, tmpV0).scaleBy(meshData.rawJointWeights[i * 4 + 0]);
+            this.jointMatrices[meshData.rawBlendIndices[i * 4 + 1]].transformPointAffine(vert, tmpV1).scaleBy(meshData.rawJointWeights[i * 4 + 1]);
+            this.jointMatrices[meshData.rawBlendIndices[i * 4 + 2]].transformPointAffine(vert, tmpV2).scaleBy(meshData.rawJointWeights[i * 4 + 2]);
+            this.jointMatrices[meshData.rawBlendIndices[i * 4 + 3]].transformPointAffine(vert, tmpV3).scaleBy(meshData.rawJointWeights[i * 4 + 3]);
+            tmpV0.addBy(tmpV1).addBy(tmpV2).addBy(tmpV3);
+            if (tmpV0.x < minx) {
+                minx = tmpV0.x;
+                indices[0] = i;
+            }
+            if (tmpV0.x > maxx) {
+                maxx = tmpV0.x;
+                indices[1] = i;
+            }
+            if (tmpV0.y < miny) {
+                miny = tmpV0.y;
+                indices[2] = i;
+            }
+            if (tmpV0.y > maxy) {
+                maxy = tmpV0.y;
+                indices[3] = i;
+            }
+            if (tmpV0.z < minz) {
+                minz = tmpV0.z;
+                indices[4] = i;
+            }
+            if (tmpV0.z > maxz) {
+                maxz = tmpV0.z;
+                indices[5] = i;
+            }
+        }
+        const info = {
+            boundingVertexBlendIndices: new Float32Array(Array.from({
+                length: 6 * 4
+            }).map((val, index)=>meshData.rawBlendIndices[indices[index >> 2] * 4 + index % 4])),
+            boundingVertexJointWeights: new Float32Array(Array.from({
+                length: 6 * 4
+            }).map((val, index)=>meshData.rawJointWeights[indices[index >> 2] * 4 + index % 4])),
+            boundingVertices: Array.from({
+                length: 6
+            }).map((val, index)=>new Vector3(meshData.rawPositions[indices[index] * 3], meshData.rawPositions[indices[index] * 3 + 1], meshData.rawPositions[indices[index] * 3 + 2])),
+            boundingBox: new BoundingBox()
+        };
+        return info;
+    }
 }
 
 export { Skeleton };

package/dist/animation/skeleton.js.map

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

package/dist/animation/translationtrack.js

@@ -1,12 +1,11 @@
-import { Vector3, Interpolator } from '@zephyr3d/base';
+import { Interpolator, Vector3 } from '@zephyr3d/base';
 import { AnimationTrack } from './animationtrack.js';
 
-// Reduce gc
-const tmpVec3 = new Vector3();
 /**
  * Translate animation track
  * @public
  */ class TranslationTrack extends AnimationTrack {
+    _state;
     constructor(modeOrInterpolator, keyFrames){
         if (modeOrInterpolator instanceof Interpolator) {
             if (modeOrInterpolator.target !== 'vec3') {
@@ -24,11 +23,20 @@ const tmpVec3 = new Vector3();
             const interpolator = new Interpolator(modeOrInterpolator, 'vec3', inputs, outputs);
             super(interpolator);
         }
+        this._state = new Vector3();
     }
-    /** {@inheritDoc AnimationTrack.apply} */ apply(node, currentTime, duration) {
-        this._interpolator.interpolate(currentTime, duration, tmpVec3);
-        node.position.set(tmpVec3);
-        return true;
+    calculateState(currentTime) {
+        this._interpolator.interpolate(currentTime, this._state);
+        return this._state;
+    }
+    applyState(node, state) {
+        node.position.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-translation';
     }
 }
 

package/dist/animation/translationtrack.js.map

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

package/dist/animation/usertrack.js

@@ -36,8 +36,8 @@ const tmpValue = new Float32Array(4);
         super(interpolator);
         this._handler = handler;
     }
-    /** {@inheritDoc AnimationTrack.apply} */ apply(node, currentTime, duration) {
-        this._interpolator.interpolate(currentTime, duration, tmpValue);
+    /** {@inheritDoc AnimationTrack.apply} */ apply(node, currentTime) {
+        this._interpolator.interpolate(currentTime, tmpValue);
         this._handler && this._handler(node, tmpValue);
         return true;
     }

package/dist/app.js

@@ -39,9 +39,7 @@ import { makeEventTarget } from '@zephyr3d/base';
     _options;
     _device;
     _inputManager;
-    _running;
     _ready;
-    _canRender;
     _drawEvent;
     _logger;
     _elapsed;
@@ -62,9 +60,7 @@ import { makeEventTarget } from '@zephyr3d/base';
             canvas: opt.canvas
         };
         this._inputManager = new InputManager(this);
-        this._running = null;
         this._ready = false;
-        this._canRender = false;
         this._elapsed = 0;
         this._drawEvent = new AppTickEvent();
         this._logger = {
@@ -90,14 +86,6 @@ import { makeEventTarget } from '@zephyr3d/base';
         return this._options;
     }
     /**
-   * Query if the device is ok to render objects now.
-   *
-   * @remarks
-   * False will be returned if the device is lost.
-   */ get canRender() {
-        return this._canRender;
-    }
-    /**
    * Query time elapsed since last frame in seconds
    */ get timeElapsedInSeconds() {
         return this._elapsed;
@@ -139,30 +127,20 @@ import { makeEventTarget } from '@zephyr3d/base';
     }
     /** Render one frame */ frame() {
         if (this._ready) {
-            this._canRender = this.device.beginFrame();
             this._elapsed = this.device.frameInfo.elapsedFrame * 0.001;
             this.device.setFramebuffer(null);
             this.device.setViewport(null);
             this.device.setScissor(null);
             this.dispatchEvent(this._drawEvent);
-            this.device.endFrame();
         }
     }
     /** Start running the rendering loop */ run() {
-        if (this._running) {
-            return;
-        }
-        const that = this;
-        (function entry() {
-            that._running = requestAnimationFrame(entry);
-            that.frame();
-        })();
+        this.device.runLoop(()=>{
+            this.frame();
+        });
     }
     /** Stop running the rendering loop */ stop() {
-        if (this._running) {
-            cancelAnimationFrame(this._running);
-            this._running = null;
-        }
+        this.device.exitLoop();
     }
     /** Message log */ log(text, mode) {
         this._logger?.log(text, mode);

package/dist/app.js.map

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