physics-animator 0.2.1 → 0.9.0

package/dist/cjs/three/ThreeAnimator.js

@@ -1,453 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThreeAnimator = exports.QuaternionSpringMode = void 0;
-const three_1 = require("three");
-const Animator_js_1 = require("../Animator.js");
-const Spring_js_1 = require("../Spring.js");
-var QuaternionSpringMode;
-(function (QuaternionSpringMode) {
-    QuaternionSpringMode[QuaternionSpringMode["DirectionRollCartesian"] = 0] = "DirectionRollCartesian";
-    QuaternionSpringMode[QuaternionSpringMode["YawPitchRoll"] = 1] = "YawPitchRoll";
-})(QuaternionSpringMode || (exports.QuaternionSpringMode = QuaternionSpringMode = {}));
-/**
- * Extends Animator to add support for animating vectors and quaternions
- */
-class ThreeAnimator {
-    get onAfterStep() {
-        return this.animator.onAfterStep;
-    }
-    get onBeforeStep() {
-        return this.animator.onBeforeStep;
-    }
-    constructor(animator = new Animator_js_1.Animator()) {
-        this.quaternionSprings = new Map();
-        this.animator = animator;
-        this.animator.onBeforeStep.on(e => this.stepQuaternionSprings(e.dt_s));
-    }
-    setTo(object, field, target) {
-        if (target instanceof three_1.Vector4) {
-            let v = object[field];
-            this.animator.setTo(v, 'x', target.x);
-            this.animator.setTo(v, 'y', target.y);
-            this.animator.setTo(v, 'z', target.z);
-            this.animator.setTo(v, 'w', target.w);
-        }
-        else if (target instanceof three_1.Vector3) {
-            let v = object[field];
-            this.animator.setTo(v, 'x', target.x);
-            this.animator.setTo(v, 'y', target.y);
-            this.animator.setTo(v, 'z', target.z);
-        }
-        else if (target instanceof three_1.Vector2) {
-            let v = object[field];
-            this.animator.setTo(v, 'x', target.x);
-            this.animator.setTo(v, 'y', target.y);
-        }
-        else if (target instanceof three_1.Quaternion) {
-            let q = object[field];
-            this.animator.setTo(q, 'x', target.x);
-            this.animator.setTo(q, 'y', target.y);
-            this.animator.setTo(q, 'z', target.z);
-            this.animator.setTo(q, 'w', target.w);
-        }
-        else if (target instanceof three_1.Euler) {
-            let e = object[field];
-            this.animator.setTo(e, 'x', target.x);
-            this.animator.setTo(e, 'y', target.y);
-            this.animator.setTo(e, 'z', target.z);
-            e.order = target.order;
-        }
-        else { // number
-            this.animator.setTo(object, field, target);
-        }
-    }
-    springTo(object, field, target, params = { duration_s: 0.5 }, mode) {
-        if (target instanceof three_1.Vector4) {
-            let v = object[field];
-            this.animator.springTo(v, 'x', target.x, params);
-            this.animator.springTo(v, 'y', target.y, params);
-            this.animator.springTo(v, 'z', target.z, params);
-            this.animator.springTo(v, 'w', target.w, params);
-        }
-        else if (target instanceof three_1.Vector3) {
-            let v = object[field];
-            this.animator.springTo(v, 'x', target.x, params);
-            this.animator.springTo(v, 'y', target.y, params);
-            this.animator.springTo(v, 'z', target.z, params);
-        }
-        else if (target instanceof three_1.Vector2) {
-            let v = object[field];
-            this.animator.springTo(v, 'x', target.x, params);
-            this.animator.springTo(v, 'y', target.y, params);
-        }
-        else if (target instanceof three_1.Quaternion) {
-            let q = object[field];
-            let spring = this.getQuaternionSpring(q);
-            // update
-            spring.target.copy(target).normalize();
-            spring.params = Spring_js_1.Spring.getPhysicsParameters(params);
-            spring.mode = mode ?? QuaternionSpringMode.DirectionRollCartesian;
-        }
-        else if (target instanceof three_1.Euler) {
-            let e = object[field];
-            this.animator.springTo(e, 'x', target.x, params);
-            this.animator.springTo(e, 'y', target.y, params);
-            this.animator.springTo(e, 'z', target.z, params);
-            e.order = target.order;
-        }
-        else { // number
-            this.animator.springTo(object, field, target, params);
-        }
-    }
-    customTweenTo(object, field, target, duration_s, step) {
-        if (target instanceof three_1.Vector4) {
-            let v = object[field];
-            this.animator.customTweenTo(v, 'x', target.x, duration_s, step);
-            this.animator.customTweenTo(v, 'y', target.y, duration_s, step);
-            this.animator.customTweenTo(v, 'z', target.z, duration_s, step);
-            this.animator.customTweenTo(v, 'w', target.w, duration_s, step);
-        }
-        else if (target instanceof three_1.Vector3) {
-            let v = object[field];
-            this.animator.customTweenTo(v, 'x', target.x, duration_s, step);
-            this.animator.customTweenTo(v, 'y', target.y, duration_s, step);
-            this.animator.customTweenTo(v, 'z', target.z, duration_s, step);
-        }
-        else if (target instanceof three_1.Vector2) {
-            let v = object[field];
-            this.animator.customTweenTo(v, 'x', target.x, duration_s, step);
-            this.animator.customTweenTo(v, 'y', target.y, duration_s, step);
-        }
-        else if (target instanceof three_1.Quaternion) {
-            throw new Error('Quaternion customTweenTo not yet supported, try springTo or use Euler');
-        }
-        else if (target instanceof three_1.Euler) {
-            let e = object[field];
-            this.animator.customTweenTo(e, 'x', target.x, duration_s, step);
-            this.animator.customTweenTo(e, 'y', target.y, duration_s, step);
-            this.animator.customTweenTo(e, 'z', target.z, duration_s, step);
-            e.order = target.order;
-        }
-        else { // number
-            this.animator.customTweenTo(object, field, target, duration_s, step);
-        }
-    }
-    linearTo(object, field, target, duration_s) {
-        this.customTweenTo(object, field, target, duration_s, Animator_js_1.Tween.linearStep);
-    }
-    easeInOutTo(object, field, target, duration_s) {
-        this.customTweenTo(object, field, target, duration_s, Animator_js_1.Tween.easeInOutStep);
-    }
-    easeInTo(object, field, target, duration_s) {
-        this.customTweenTo(object, field, target, duration_s, Animator_js_1.Tween.easeInStep);
-    }
-    easeOutTo(object, field, target, duration_s) {
-        this.customTweenTo(object, field, target, duration_s, Animator_js_1.Tween.easeOutStep);
-    }
-    step(dt_s) {
-        this.animator.step(dt_s);
-    }
-    tick() {
-        this.animator.tick();
-    }
-    remove(object, field) {
-        let v = object[field];
-        if (v instanceof three_1.Vector4) {
-            this.animator.remove(v, 'x');
-            this.animator.remove(v, 'y');
-            this.animator.remove(v, 'z');
-            this.animator.remove(v, 'w');
-        }
-        else if (v instanceof three_1.Vector3) {
-            this.animator.remove(v, 'x');
-            this.animator.remove(v, 'y');
-            this.animator.remove(v, 'z');
-        }
-        else if (v instanceof three_1.Vector2) {
-            this.animator.remove(v, 'x');
-            this.animator.remove(v, 'y');
-        }
-        else if (v instanceof three_1.Quaternion) {
-            this.quaternionSprings.delete(v);
-        }
-        else if (v instanceof three_1.Euler) {
-            this.animator.remove(v, 'x');
-            this.animator.remove(v, 'y');
-            this.animator.remove(v, 'z');
-        }
-        else { // number
-            this.animator.remove(object, field);
-        }
-    }
-    removeAll() {
-        this.animator.removeAll();
-        this.quaternionSprings.clear();
-    }
-    getVelocity(object, field, into) {
-        let target = object[field];
-        if (target instanceof three_1.Vector4) {
-            let i = into ?? new three_1.Vector4();
-            i.x = this.animator.getVelocity(target, 'x');
-            i.y = this.animator.getVelocity(target, 'y');
-            i.z = this.animator.getVelocity(target, 'z');
-            i.w = this.animator.getVelocity(target, 'w');
-            return i;
-        }
-        else if (target instanceof three_1.Vector3) {
-            let i = into ?? new three_1.Vector3();
-            i.x = this.animator.getVelocity(target, 'x');
-            i.y = this.animator.getVelocity(target, 'y');
-            i.z = this.animator.getVelocity(target, 'z');
-            return i;
-        }
-        else if (target instanceof three_1.Vector2) {
-            let i = into ?? new three_1.Vector2();
-            i.x = this.animator.getVelocity(target, 'x');
-            i.y = this.animator.getVelocity(target, 'y');
-            return i;
-        }
-        else if (target instanceof three_1.Quaternion) {
-            let spring = this.quaternionSprings.get(target);
-            return {
-                directionVelocity: spring?.directionVelocity ?? new three_1.Vector3(),
-                rollVelocity: spring?.rollVelocity ?? 0
-            };
-        }
-        else if (target instanceof three_1.Euler) {
-            let i = into ?? new three_1.Euler();
-            i.x = this.animator.getVelocity(target, 'x');
-            i.y = this.animator.getVelocity(target, 'y');
-            i.z = this.animator.getVelocity(target, 'z');
-            i.order = target.order;
-            return i;
-        }
-        else { // number
-            return this.animator.getVelocity(object, field);
-        }
-    }
-    startAnimationFrameLoop() {
-        return this.animator.startAnimationFrameLoop();
-    }
-    startIntervalLoop(interval_ms) {
-        return this.animator.startIntervalLoop(interval_ms);
-    }
-    stop() {
-        this.animator.stop();
-    }
-    stepQuaternionSprings(dt_s) {
-        // step quaternion springs
-        this.quaternionSprings.forEach((spring, q) => {
-            if (spring.params) {
-                if (spring.mode === QuaternionSpringMode.DirectionRollCartesian) {
-                    stepSpringQuaternion(dt_s, spring, spring.params);
-                }
-                else {
-                    stepSpringQuaternionSpherical(dt_s, spring, spring.params);
-                }
-            }
-            else {
-                // copy target
-                q.copy(spring.target);
-                // zero velocity
-                spring.directionVelocity.set(0, 0, 0);
-                spring.rollVelocity = 0;
-            }
-            // if quaternions match and velocity close to zero, remove spring
-            if (Math.abs(q.dot(spring.target)) > 0.999 && spring.directionVelocity.lengthSq() < 0.0001 && Math.abs(spring.rollVelocity) < 0.0001) {
-                this.quaternionSprings.delete(q);
-            }
-        });
-    }
-    getQuaternionSpring(q) {
-        let spring = this.quaternionSprings.get(q);
-        if (!spring) {
-            _m.makeRotationFromQuaternion(q);
-            let direction = new three_1.Vector3();
-            _m.extractBasis(new three_1.Vector3(), new three_1.Vector3(), direction);
-            spring = {
-                q: q,
-                target: new three_1.Quaternion(),
-                direction: direction,
-                directionVelocity: new three_1.Vector3(),
-                rollVelocity: 0,
-                params: null,
-                mode: QuaternionSpringMode.DirectionRollCartesian,
-            };
-            this.quaternionSprings.set(q, spring);
-        }
-        return spring;
-    }
-}
-exports.ThreeAnimator = ThreeAnimator;
-/**
- * Analytic quaternion spring
- *
- * Todo:
- * - for cameras we want to prefer rotations in xz plane rather than z
- * - animate direction in spherical space rather than cartesian
- */
-// working variables to avoid allocations
-const _m = new three_1.Matrix4();
-const _x = new three_1.Vector3();
-const _y = new three_1.Vector3();
-const _z = new three_1.Vector3();
-const _qMatrix = new three_1.Matrix4();
-const _springState = { x: 0, v: 0, targetX: 0 };
-function stepSpringQuaternion(dt_s, state, parameters) {
-    // step direction spring in cartesian space
-    // we should do this in spherical in the future
-    let targetDirection = new three_1.Vector3();
-    let targetYBasis = new three_1.Vector3();
-    _m.makeRotationFromQuaternion(state.target);
-    _m.extractBasis(_x, targetYBasis, targetDirection);
-    let directionBefore = state.direction.clone();
-    // step spring direction
-    _springState.x = state.direction.x;
-    _springState.v = state.directionVelocity.x;
-    _springState.targetX = targetDirection.x;
-    Spring_js_1.Spring.stepSpring(dt_s, _springState, parameters);
-    state.direction.x = _springState.x;
-    state.directionVelocity.x = _springState.v;
-    _springState.x = state.direction.y;
-    _springState.v = state.directionVelocity.y;
-    _springState.targetX = targetDirection.y;
-    Spring_js_1.Spring.stepSpring(dt_s, _springState, parameters);
-    state.direction.y = _springState.x;
-    state.directionVelocity.y = _springState.v;
-    _springState.x = state.direction.z;
-    _springState.v = state.directionVelocity.z;
-    _springState.targetX = targetDirection.z;
-    Spring_js_1.Spring.stepSpring(dt_s, _springState, parameters);
-    state.direction.z = _springState.x;
-    state.directionVelocity.z = _springState.v;
-    // update quaternion
-    let directionDeltaQuaternion = new three_1.Quaternion().setFromUnitVectors(_x.copy(directionBefore).normalize(), _y.copy(state.direction).normalize());
-    state.q.premultiply(directionDeltaQuaternion);
-    // this forces synchronization of direction and quaternion
-    alignQuaternion(state.q, state.direction, _qMatrix);
-    // determine roll required to align yBasis with targetYBasis
-    let directionToTargetQuaternion = new three_1.Quaternion().setFromUnitVectors(state.direction.clone().normalize(), targetDirection);
-    _m.makeRotationFromQuaternion(state.q);
-    _m.extractBasis(_x, _y, _z);
-    let newYBasis = _y.applyQuaternion(directionToTargetQuaternion).clone();
-    let rollQuaternion = new three_1.Quaternion().setFromUnitVectors(newYBasis, targetYBasis);
-    // to axis angle (clamp w)
-    let rollAngle = Math.acos(Math.min(1, Math.max(-1, rollQuaternion.w))) * 2;
-    let rollSign = _x.crossVectors(newYBasis, targetYBasis).dot(targetDirection) < 0 ? -1 : 1;
-    rollAngle = -rollSign * rollAngle;
-    // step roll spring
-    _springState.x = rollAngle;
-    _springState.v = state.rollVelocity;
-    _springState.targetX = 0;
-    Spring_js_1.Spring.stepSpring(dt_s, _springState, parameters);
-    state.rollVelocity = _springState.v;
-    let rollAfter = _springState.x;
-    let rollDelta = rollAfter - rollAngle;
-    // apply roll correction
-    let rollDeltaQuaternion = new three_1.Quaternion().setFromAxisAngle(state.direction.clone().normalize(), rollDelta /*-rollAngle * 0.1*/);
-    state.q.premultiply(rollDeltaQuaternion);
-    state.q.normalize();
-}
-function stepSpringQuaternionSpherical(dt_s, state, parameters) {
-    let azimuthVelocity = state.directionVelocity.x;
-    let elevationVelocity = state.directionVelocity.y;
-    // get quaternion in spherical coordinates
-    let elAzRoll = quaternionToPitchYawRoll(state.q);
-    // get target quaternion in spherical coordinates
-    let targetElAzRoll = quaternionToPitchYawRoll(state.target);
-    // step springs
-    _springState.x = elAzRoll.x;
-    _springState.v = elevationVelocity;
-    _springState.targetX = getAngleContinuous(targetElAzRoll.x, elAzRoll.x);
-    Spring_js_1.Spring.stepSpring(dt_s, _springState, parameters);
-    elevationVelocity = _springState.v;
-    let elevationAfter = _springState.x;
-    _springState.x = elAzRoll.y;
-    _springState.v = azimuthVelocity;
-    _springState.targetX = getAngleContinuous(targetElAzRoll.y, elAzRoll.y);
-    Spring_js_1.Spring.stepSpring(dt_s, _springState, parameters);
-    azimuthVelocity = _springState.v;
-    let azimuthAfter = _springState.x;
-    // update directionVelocity
-    state.directionVelocity.x = azimuthVelocity;
-    state.directionVelocity.y = elevationVelocity;
-    // compose quaternion from spherical coordinates
-    // direction from azimuth and elevation
-    let direction = new three_1.Vector3(Math.cos(azimuthAfter) * Math.cos(elevationAfter), Math.sin(elevationAfter), Math.sin(azimuthAfter) * Math.cos(elevationAfter)).normalize();
-    // roll alignment spring
-    _springState.x = elAzRoll.z;
-    _springState.v = state.rollVelocity;
-    _springState.targetX = getAngleContinuous(targetElAzRoll.z, elAzRoll.z);
-    Spring_js_1.Spring.stepSpring(dt_s, _springState, parameters);
-    state.rollVelocity = _springState.v;
-    let rollAfter = _springState.x;
-    // compose quaternion from direction and roll
-    alignQuaternion(state.q, direction, _qMatrix);
-    setRoll(state.q, rollAfter);
-}
-function quaternionToPitchYawRoll(q, out = new three_1.Vector3()) {
-    // // get quaternion in spherical coordinates
-    _m.makeRotationFromQuaternion(q);
-    _m.extractBasis(_x, _y, _z);
-    // // azimuth and elevation are found from z direction
-    let azimuth = Math.atan2(_z.z, _z.x);
-    let elevation = Math.atan2(_z.y, Math.sqrt(_z.x * _z.x + _z.z * _z.z));
-    let roll = getRoll(q);
-    out.set(elevation, azimuth, roll);
-    return out;
-}
-function setRoll(q, roll) {
-    let currentRoll_rad = getRoll(q);
-    let deltaRoll = roll - currentRoll_rad;
-    let objectForward = new three_1.Vector3(0, 0, -1).applyQuaternion(q);
-    let rotation = new three_1.Quaternion().setFromAxisAngle(objectForward, deltaRoll);
-    q.premultiply(rotation);
-}
-/**
- * Aligns quaternion
- */
-const _zBasis = new three_1.Vector3();
-function alignQuaternion(q, direction, outMatrix = new three_1.Matrix4()) {
-    outMatrix.makeRotationFromQuaternion(q);
-    outMatrix.extractBasis(_x, _y, _z);
-    // must ensure _x and _y are orthogonal to zBasis
-    _zBasis.copy(direction).normalize();
-    _x.crossVectors(_y, _zBasis).normalize();
-    _y.crossVectors(_zBasis, _x).normalize();
-    outMatrix.makeBasis(_x, _y, _zBasis);
-    q.setFromRotationMatrix(outMatrix);
-    return outMatrix;
-}
-function getAngleContinuous(a, lastAngle) {
-    const tau = 2 * Math.PI;
-    let u = a / tau + 0.5;
-    let uLast = fract(lastAngle / tau + 0.5);
-    let du = u - uLast;
-    let angle;
-    if (Math.abs(du) < 0.5) {
-        angle = lastAngle + du * tau;
-    }
-    else {
-        // passed through 0
-        let duSmall = 1 - Math.abs(du);
-        angle = lastAngle + -Math.sign(du) * duSmall * tau;
-    }
-    return angle;
-}
-function fract(x) {
-    return x - Math.floor(x);
-}
-function getRoll(quaternion) {
-    return getQuaternionPlaneAngle(quaternion, new three_1.Vector3(0, 1, 0), new three_1.Vector3(0, 0, -1));
-}
-function getQuaternionPlaneAngle(quaternion, basisDirection, basisPlane) {
-    let objectDirection = basisDirection.clone().applyQuaternion(quaternion);
-    let objectPlane = basisPlane.clone().applyQuaternion(quaternion);
-    let objectDirectionProjected = objectDirection.projectOnPlane(objectPlane);
-    let worldZeroProjected = basisDirection.clone().projectOnPlane(objectPlane);
-    let angle = worldZeroProjected.angleTo(objectDirectionProjected);
-    // sign of angle
-    let sign = Math.sign(worldZeroProjected.cross(objectDirectionProjected).dot(objectPlane));
-    angle *= sign;
-    return angle;
-}

package/dist/cjs/three/index.js

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ThreeAnimator.js"), exports);