lecodes-sdk 0.20.2 → 1.1.0

package/dist/types/gl/IK.d.ts

@@ -1,53 +0,0 @@
-import { Aspect } from "../core/Aspect";
-import { type Vec3Like } from "../math/vec";
-import { Quat } from "../math/quat";
-import type { Node } from "./Node";
-type Target = Node | Vec3Like;
-/** Two-bone analytic IK (limbs). Attach to the END bone: `foot.aspect(IK.TwoBone, { target })`
- *  solves upper (grandparent) + mid (parent) so the end reaches `target`; `pole` steers the bend
- *  (knee/elbow) — a Node or world point. */
-declare class TwoBone extends Aspect<"ik", Node> {
-    static readonly aspect = "ik";
-    /** Where the end bone should be (Node or world position). */
-    target?: Target;
-    /** Bend hint — the mid joint is pulled toward it (Node or world position). */
-    pole?: Target;
-    /** World rotation the END bone takes after the solve — a Node (its world rotation) or a Quat.
-     *  Unset = the end bone keeps its animated local rotation (a hand on a grip, a foot on a slope
-     *  want it set). Blended by `weight · rotationWeight`. */
-    rotation?: Node | Quat;
-    /** 0–1 contribution of `rotation` (on top of `weight`). */
-    rotationWeight: number;
-    /** 0–1 contribution (blend in/out, e.g. foot planting only while grounded). */
-    weight: number;
-    /** Solve every frame (default). Set false to drive `solve()` yourself. */
-    enabled: boolean;
-    update(): void;
-    /** One solve at the current pose. Safe to call manually (e.g. from a later-ordered aspect). */
-    solve(): void;
-}
-/** Aim a bone at a target (head / eyes / turret). Attach to the bone itself:
- *  `head.aspect(IK.LookAt, { target: camera, limit: 70 })`. `axis` is the bone's LOCAL forward
- *  (the direction that should point at the target) — rigs differ; default −Z, Mixamo heads look
- *  along +Z of the head bone in most exports, so pass `axis: [0, 0, 1]` there if it faces backwards. */
-declare class LookAt extends Aspect<"lookAt", Node> {
-    static readonly aspect = "lookAt";
-    target?: Target;
-    /** The bone's local axis that should point at the target. */
-    axis: Vec3Like;
-    /** Max deflection from the animated direction, in degrees (default 80). */
-    limit: number;
-    /** 0–1 contribution. */
-    weight: number;
-    enabled: boolean;
-    update(): void;
-    solve(): void;
-}
-/** Inverse kinematics aspects — attach to bones (see file header). */
-export declare const IK: {
-    TwoBone: typeof TwoBone;
-    LookAt: typeof LookAt;
-};
-export type IKTwoBone = TwoBone;
-export type IKLookAt = LookAt;
-export {};

package/dist/types/gl/Ragdoll.d.ts

@@ -1,86 +0,0 @@
-import { Aspect } from "../core/Aspect";
-import type { FieldMeta } from "../core/fields";
-import { type Vec3Like } from "../math/vec";
-import { Node } from "./Node";
-export interface RagdollHinge {
-    /** The hinge axis in the MODEL's space (its rest pose: +Z forward, +Y up, +X the model's left in
-     *  glTF). Perpendicular to the bone; the engine drops any component along it. */
-    axis: Vec3Like;
-    /** The bend range about `axis` in degrees, relative to the pose the ragdoll was built in — a knee
-     *  is `{ axis: [1, 0, 0], min: 0, max: 140 }`: it folds one way only. */
-    min: number;
-    max: number;
-}
-export interface RagdollPart {
-    /** The bone the body sits on — its origin is the joint. */
-    bone: string;
-    /** The bone the capsule points at (the next joint down). Omitted = a leaf: `length` along the line
-     *  from the parent part's origin (a head, a hand, a foot without toes). */
-    to?: string;
-    /** The bone of the part this one hangs from (default: the previous part in the list). The root
-     *  has none. */
-    parent?: string;
-    /** Capsule radius in metres (default 0.05). */
-    radius?: number;
-    /** Length in metres: a leaf's, or an override of the distance to `to`. */
-    length?: number;
-    /** This part's share of the ragdoll's `mass` (relative weight, default 1). */
-    mass?: number;
-    /** Cone half-angle in degrees the part may swing off its parent (default 30). Ignored with `hinge`. */
-    swing?: number;
-    /** Twist half-angle in degrees about its own axis (default 20). */
-    twist?: number;
-    /** A one-way joint instead of the cone. */
-    hinge?: RagdollHinge;
-}
-export declare class Ragdoll extends Aspect<"ragdoll", Node> {
-    static readonly aspect = "ragdoll";
-    /** The parts: `'humanoid'` (default) finds the standard bones by name; a list places bodies on any
-     *  bones — parents before children. */
-    parts: RagdollPart[] | "humanoid";
-    /** Total mass in kg (default 70), split between the parts by their `mass` shares. */
-    mass: number;
-    /** Friction of every part (default 0.6 — the physics default). */
-    friction: number;
-    /** Linear / angular damping of every part; 0 = Jolt's own 0.05. More angular damping settles a
-     *  flailing body sooner. */
-    linearDamping: number;
-    angularDamping: number;
-    /** What the parts collide with. `'static'` (default): the static geometry and other such ragdolls
-     *  only — dynamic bodies, character controllers and vehicles pass through a fallen body, which then
-     *  never shoves or blocks anything and costs nothing when they meet. `'all'`: a regular dynamic
-     *  body that bumps into everything (and gets kicked awake by everything). */
-    collide: "static" | "all";
-    /** Once every part has come to rest the parts turn static where they lie (default true): the pose
-     *  holds, nothing can wake a settled body and it costs the solver nothing — `deactivate()` /
-     *  `activate()` still work (activate makes it dynamic again). */
-    freeze: boolean;
-    /** Seconds after `activate()` at which the body freezes whatever it is doing — a twitch on a slope
-     *  or a pile never sleeps on its own. 0 (default) = no cap. */
-    freezeAfter: number;
-    static fields: FieldMeta<Ragdoll>;
-    private _id;
-    private _active;
-    private _bones;
-    onAttach(): void;
-    onDetach(): void;
-    /** Hand the bones to physics from the pose they are in right now. `velocity` (world m/s) is given
-     *  to every part — pass the character's, so a running body keeps travelling. */
-    activate(opts?: {
-        velocity?: Vec3Like;
-    }): boolean;
-    /** Take the bones back: the animator's pose shows again from the next frame. */
-    deactivate(): void;
-    /** Physics owns the bones right now. */
-    get active(): boolean;
-    /** Active and every part asleep (or frozen) — the body has come to rest. */
-    get settled(): boolean;
-    /** The root part's bone (the hips): where the body is. */
-    get root(): Node | null;
-    /** The bones that carry a part, in order. */
-    get bones(): string[];
-    /** The rigid-body id of a part (0 if none) — for the plain body calls. */
-    bodyOf(bone: string): number;
-    /** Push one part: an impulse in N·s, at a world point (a hit) or through its centre. Wakes the body. */
-    impulse(bone: string, v: Vec3Like, at?: Vec3Like): boolean;
-}

package/dist/types/gl/Vehicle.d.ts

@@ -1,191 +0,0 @@
-import { Aspect } from "../core/Aspect";
-import type { FieldMeta } from "../core/fields";
-import { Vec3, type Vec3Like } from "../math/vec";
-import { type QuatLike } from "../math/quat";
-import { Node } from "./Node";
-import { Wheel } from "./Wheel";
-/** Which axle the engine drives. A wheel's own `drive` overrides it. */
-export type DriveLayout = "rear" | "front" | "all";
-/**
- * How an axle's two wheels share torque.
- *  - `lsd` — limited slip (Jolt's 1.4 ratio), the sane default.
- *  - `open` — fully open: a lifted or spinning wheel takes ALL the torque.
- *  - `locked` — both wheels forced to the same speed. Breaks traction predictably: the drift diff.
- *  A number is the raw max/min wheel-speed ratio (> 1; smaller is more locked).
- */
-export type DifferentialMode = "lsd" | "open" | "locked";
-export interface EngineConfig {
-    /** Peak torque in N·m (default 500). The single biggest "how fast is it" knob. */
-    torque?: number;
-    /** Redline in RPM (default 6000). */
-    maxRpm?: number;
-    /** Idle RPM (default 1000) — the engine never falls below it. */
-    idleRpm?: number;
-    /**
-     * The engine's CHARACTER: a flat list `[rpm, torque, rpm, torque, …]` in NORMALISED units — x is
-     * a fraction of the redline, y a fraction of `torque`. Left out, Jolt's own broad curve is used.
-     *
-     * `[0, 0.8, 0.66, 1, 1, 0.8]` is an ordinary petrol engine (peak two thirds up, falling to the
-     * redline); `[0, 1, 1, 1]` is flat, which is what an electric motor feels like.
-     */
-    curve?: number[];
-    /** Moment of inertia in kg·m² (default 0.5) — how eagerly it revs when the clutch is out. */
-    inertia?: number;
-    /** Engine braking: angular damping of the engine itself (default 0.2). */
-    braking?: number;
-}
-export interface SteeringConfig {
-    /** Steering lock in degrees at a standstill (default 35). */
-    lock?: number;
-    /**
-     * The lock still available, in degrees, once the car reaches `speed` (default 10) — what stops a
-     * car over-driving its own front tires.
-     *
-     * A tire makes its peak grip at a few degrees of slip angle, and the steering angle a corner needs
-     * falls with the SQUARE of speed. Holding full lock at 100 km/h therefore asks the front for
-     * several times what it can give: the tires saturate, the car ploughs on, and the wheel stops
-     * answering. In between the lock eases on `(1 − v/speed)²`, which tracks the real curve closely.
-     * `0` turns the taper off — full lock at any speed.
-     */
-    atSpeed?: number;
-    /** The speed in m/s at which the lock has fallen to `atSpeed` (default 30 ≈ 108 km/h). */
-    speed?: number;
-    /** How fast the front wheels may turn, in degrees per second (default 220). A keyboard asks for
-     *  full lock in one frame, which no steering wheel can do, and that step alone snaps a tire past
-     *  its peak. `0` = instantly. */
-    rate?: number;
-}
-/**
- * Aerodynamics. Both numbers are quoted the same way — **a fraction of the car's own weight at
- * 30 m/s (108 km/h)** — and both grow with the SQUARE of speed from there, so `0.5` at 30 m/s is
- * `2.0` at 60 m/s. One mental model for both, and no drag coefficients or frontal areas to invent.
- */
-export interface AeroConfig {
-    /**
-     * Downforce (default 0 — a car with no wing). The knob that decides whether a car corners better
-     * or worse the faster it goes: tire grip is a constant, but the force a corner demands grows with
-     * v², so with no downforce every car runs out of road at speed. `0.6` roughly doubles a car's
-     * cornering at 150 km/h; a road car is nearer `0.1`, a race car well past `1`.
-     *
-     * It presses along the CHASSIS' own down axis (that is what keeps a car planted over a crest) and
-     * only while a wheel is on the ground — a car on its roof is never launched by its own wing.
-     */
-    downforce?: number;
-    /** Air resistance (default 0.03 — an ordinary car). What gives a car a top speed at all. */
-    drag?: number;
-}
-export declare class Vehicle extends Aspect<"vehicle", Node> {
-    static readonly aspect = "vehicle";
-    /** Chassis mass in kg (default 1200). Wheels are massless in this model. */
-    mass: number;
-    /** Centre of mass height in chassis space (metres, negative = lower). Left out, it drops to halfway
-     *  down the chassis shape — a car with its mass at the shape's centre tips over. */
-    centerOfMass?: number;
-    /** Which axle the engine drives (default "rear"). A wheel's own `drive` overrides it. */
-    driveAxle: DriveLayout;
-    /** Differential lock across each driven axle. `locked` is the drift setup — both wheels turn
-     *  together, so the pair lets go as a pair. Live: re-configure the aspect to switch it mid-drive. */
-    differential: DifferentialMode | number;
-    /**
-     * Anti-roll bars between each axle's wheels — what stops a car rolling onto its inside wheels in a
-     * fast corner. `true` (default) is a bar 0.01 as stiff as the wheel's own spring; a number is that
-     * ratio directly, and `0` / `false` removes the bars.
-     *
-     * **The numbers are far smaller than they look and the gain is steep** — Jolt's bar feeds
-     * `lengthDifference × stiffness × dt` as a bias into the suspension's own soft constraint, so 4%
-     * of the spring already flattens the body. Measured on a 1250 kg car: `0` → 1.3° of roll at 0.86 g,
-     * `0.01` → 0.6°, `0.15` → 0.2° (flat), `0.5` → the car HOPS.
-     *
-     * This is the knob for how much a car visibly LEANS, not for wheel lift: bars change how far the
-     * body tips, not how much load transfers. For lift, lower `centerOfMass`.
-     */
-    antiRoll: boolean | number;
-    /** Pitch/roll limit in degrees (default 60) before the constraint rights the car. 180 turns it off. */
-    maxTilt: number;
-    /** Friction of the CHASSIS body itself — how it slides when it lands on its roof or side. Nothing
-     *  to do with the tires; those are the `Wheel`'s `tire.grip` × the ground's friction. */
-    friction: number;
-    /** Strength of the clutch when fully engaged (default 10). Small values slip; large ones weld the
-     *  engine to the wheels. The `Gearbox` scales it 0..1 while shifting. */
-    clutchStrength: number;
-    engine: EngineConfig;
-    steering: SteeringConfig;
-    aero: AeroConfig;
-    /** Scene-editor inspector: the flat, tunable half. The grouped objects are edited in code. */
-    static fields: FieldMeta<Vehicle>;
-    static editor: {
-        rebuild: boolean;
-    };
-    private _id;
-    private _bodyId;
-    private _builtMass;
-    private _wheels;
-    private _state;
-    private _stateFrame;
-    private _throttle;
-    private _steer;
-    private _brake;
-    private _handbrake;
-    onAttach(): void;
-    onDetach(): void;
-    /**
-     * Re-configuring an attached vehicle retunes it in place — the way a drift button switches the
-     * differential without the car so much as blinking:
-     *
-     *   car.aspect(Vehicle, { differential: drift ? 'locked' : 'lsd' })
-     *
-     * Live: `differential`, `engine`, `steering`, `aero`, `maxTilt`, `friction`, `clutchStrength`, and
-     * every `Wheel`'s `tire.grip` and brake torques. Everything else describes the car's STRUCTURE —
-     * `mass`, `centerOfMass`, which wheels exist and where, their suspension, `driveAxle`, `antiRoll` — and
-     * is baked into the constraint at attach; to change one of those, re-attach the aspect.
-     */
-    onReconfigure(): void;
-    /** Native vehicle id (0 until attached / no physics support). */
-    get id(): number;
-    /** The chassis rigid-body id — the same handle the plain body calls take. */
-    get bodyId(): number;
-    /** The wheels, in blob order (front axle first). */
-    get wheels(): readonly Wheel[];
-    /**
-     * The driver's controls, all in [-1, 1] (brakes in [0, 1]). Sticky: the last values keep applying
-     * until the next call, so a held key does not need re-sending. `forward < 0` asks for reverse; the
-     * `Gearbox` engages it once the car has stopped.
-     */
-    drive(forward: number, steer?: number, brake?: number, handbrake?: number): this;
-    /** Teleport upright and clear all motion (velocity, engine, gearbox, wheel spin). Defaults to the
-     *  chassis node's current pose — `reset()` alone un-flips a car where it lies. */
-    reset(position?: Vec3Like, rotation?: QuatLike): this;
-    /** Push the chassis (a boost pad, an explosion) — an instantaneous impulse in kg·m/s. */
-    applyImpulse(v: Vec3Like): this;
-    private _read;
-    /** Speed along the car's forward axis in m/s — negative when reversing (× 3.6 for km/h). */
-    get speed(): number;
-    /** Engine revolutions per minute. */
-    get rpm(): number;
-    /** How many wheels are touching the ground. */
-    get wheelsOnGround(): number;
-    /** Any wheel on the ground — false while airborne. */
-    get grounded(): boolean;
-    /** Chassis velocity in world units/s (fresh Vec3). */
-    get velocity(): Vec3;
-    /** The last throttle handed to `drive()` — what the gearbox reads to know which way you want to go. */
-    get throttle(): number;
-    /** The last steer input handed to `drive()`, [-1, 1]. */
-    get steerInput(): number;
-    /** The last foot-brake input handed to `drive()`, [0, 1] — the pedal, not the resulting force. */
-    get brake(): number;
-    /** The last handbrake input handed to `drive()`, [0, 1]. */
-    get handbrake(): number;
-    /** Current gear from the attached `Gearbox`: −1 reverse, 0 neutral, 1… forward. */
-    get gear(): number;
-    /** The steering lock, in degrees, the car is allowed at its current speed — the full lock at rest,
-     *  falling to `steering.atSpeed`. The same curve the engine applies; useful on a HUD. */
-    get steerLock(): number;
-    /** Every Wheel under the chassis, ordered front axle first, with its axle group resolved. */
-    private _collectWheels;
-    /** Pack the whole configuration into the one blob the host ABI takes (see bridges.d.ts). */
-    private _buildSettings;
-    /** Edit mode: which way the chassis faces. Each wheel draws its own circle and travel range — see
-     *  `Wheel.rebuild()`. Play mode never calls this. */
-    rebuild(): void;
-}

package/dist/types/gl/Wheel.d.ts

@@ -1,95 +0,0 @@
-import { Aspect } from "../core/Aspect";
-import type { FieldMeta } from "../core/fields";
-import { type Vec3Like } from "../math/vec";
-import { Node } from "./Node";
-/** Floats `vehicleGetState` writes before the per-wheel block: speed, rpm, contacts, vx, vy, vz. */
-export declare const STATE_HEADER = 6;
-/** Floats per wheel: contact, slip, slipAngle, suspensionLength, steerDeg, spin. */
-export declare const WHEEL_STATE = 6;
-/** How a tire behaves past its grip peak. `road` is Jolt's own curve — grip falls off after the peak,
- *  so the car can be made to let go. `arcade` holds the peak all the way out: much harder to spin. */
-export type TireCurve = "road" | "arcade";
-export interface WheelSuspension {
-    /** Total travel in metres, full droop to fully compressed (default 0.4). */
-    travel?: number;
-    /** Spring frequency in Hz — bigger is stiffer (default 1.4; a race car ~2.5, a truck ~1). It also
-     *  sets the ride-height sag, and the sag is how far the wheel can still extend DOWN. */
-    stiffness?: number;
-    /** Damping ratio 0..1 (default 0.5). Low values pogo. */
-    damping?: number;
-}
-export interface WheelTire {
-    /** Grip multiplier on the friction curves (default 1). The grip a wheel actually gets is combined
-     *  with the ground it stands on as `sqrt(tire × groundFriction)`, and a body's friction defaults to
-     *  0.6 — so a road a car should really corner on wants `Physics { friction: 1 }`. */
-    grip?: number;
-    /** Which friction curve (default `road`). */
-    curve?: TireCurve;
-}
-export interface WheelVisual {
-    /** The MODEL's axle direction in its own space (default `[1, 0, 0]`). Set it instead of parenting
-     *  the mesh under a corrective node when the art points another way. */
-    axis?: Vec3Like;
-    /** Drawn radius, if the art is not exactly the physical `radius` — sinks a wheel into its arch or
-     *  lets a fat tire overhang, with no effect on the simulation. Default: the physical radius. */
-    radius?: number;
-    /** Let the model spin (default true). `false` keeps the steer angle and suspension travel but not
-     *  the rotation — a brake caliper. */
-    spin?: boolean;
-}
-export declare class Wheel extends Aspect<"wheel", Node> {
-    static readonly aspect = "wheel";
-    /** Wheel radius in metres. Default: measured from the node's rendered bounds, else 0.35. Too small
-     *  and the car scrapes, too large and it floats. */
-    radius?: number;
-    /** Wheel width in metres. Default: measured, else 0.25. */
-    width?: number;
-    /** Does this wheel steer? Default: the wheels on the front axle. */
-    steer?: boolean;
-    /** Does the engine drive it? Default: from the vehicle's `drive` layout. */
-    drive?: boolean;
-    /** Foot brake on this wheel. */
-    brake: boolean;
-    /** Handbrake on this wheel. Default: every non-steering wheel (locking the front wheels of a moving
-     *  car is not a handbrake turn, it is a crash). */
-    handbrake?: boolean;
-    /** Axle group, front to back. Default: derived from Z. Set it for a car whose wheels are not in neat
-     *  left/right pairs — an axle's wheels are paired for the differential and the anti-roll bar. */
-    axle?: number;
-    /** Foot-brake torque in N·m (default 1500); the handbrake pulls 3× on the wheels that have it. */
-    brakeTorque: number;
-    suspension: WheelSuspension;
-    tire: WheelTire;
-    visual: WheelVisual;
-    /** Scene-editor inspector. `steer` / `drive` / `handbrake` are deliberately absent: they are
-     *  tri-state (undefined = derive it from the axle), which a switch cannot express. */
-    static fields: FieldMeta<Wheel>;
-    static editor: {
-        rebuild: boolean;
-    };
-    private _angle;
-    private _scale;
-    private _local;
-    onAttach(): void;
-    onDetach(): void;
-    private _state;
-    /** Touching the ground this step. */
-    get contact(): boolean;
-    /** Longitudinal slip RATIO: 0 = rolling in sync with the ground, ~1 = spinning up or locked.
-     *  Unsigned — smoke, tire marks and wheelspin sound key off this. */
-    get slip(): number;
-    /** Slip ANGLE in degrees: how far the tire's travel direction is off from where it points.
-     *  Unsigned, 0..90 — past the curve's peak (~3°) the tire is sliding sideways. Drift particles. */
-    get slipAngle(): number;
-    /** Steer angle in degrees, positive to the right. */
-    get steerAngle(): number;
-    /** Wheel spin in rad/s (× radius ≈ the speed the tire is laying down). */
-    get spin(): number;
-    /** Suspension compression, 0 = fully extended (drooping) … 1 = fully compressed. */
-    get compression(): number;
-    /** LATE phase: after the step and the transform sync, right before the frame draws. */
-    update(dt: number): void;
-    /** Edit mode: this wheel's own circle at its resting height, its travel range, and a mark when the
-     *  engine drives it — enough to place a wheel without running the game. */
-    rebuild(): void;
-}

package/src/animate/animate.ts

@@ -1,238 +0,0 @@
-// animate self-implements its matrix decompose/recompose; these are just the numeric-array shapes.
-type mat4 = Float32Array | number[]
-type quat = Float32Array | number[]
-type vec2 = Float32Array | number[]
-type vec3 = Float32Array | number[]
-import type { Easing } from "./easings"
-
-type AnimateProps = number | string | vec2 | vec3 | quat
-
-export type AnimateOptions<T> = {
-  from: T,
-  to: T,
-  duration: number,
-  onUpdate(val: T): void,
-  onComplete?(): void,
-  easing?: Easing,
-}
-
-export const animate = <T extends AnimateProps>(options: AnimateOptions<T>): number => {
-  
-  let onRawUpdate
-  if (typeof options.to === "number") {
-    const { onUpdate, from, to } = options as AnimateOptions<number>
-    onRawUpdate = (t: number) => onUpdate(from + (to - from) * t)
-  } else if (options.to === "string") {
-    // TODO: Make color animate here
-    const { onUpdate, from, to } = options as AnimateOptions<string>
-    onRawUpdate = (t: number) => onUpdate(from)
-    
-    // onRawUpdate = (val: number) => onUpdate(from + (to - from) * val)
-  } else if (options.to.length === 2) {
-    const { onUpdate, from, to } = options as AnimateOptions<vec2>
-    const tempVec = new Float32Array(3)
-    onRawUpdate = (t: number) => onUpdate(lerp2(tempVec, from, to, t))
-
-  } else if (options.to.length === 3) {
-    const { onUpdate, from, to } = options as AnimateOptions<vec3>
-    const tempVec = new Float32Array(3)
-
-    onRawUpdate = (t: number) => onUpdate(lerp(tempVec, from, to, t))
-  } else if (options.to.length === 4) { 
-    const { onUpdate, from, to } = options as AnimateOptions<quat>
-
-    const tempQuat = new Float32Array(4)
-    onRawUpdate = (t: number) => onUpdate(slerp(tempQuat, from, to, t))
-  } else {
-    onRawUpdate = () => {}
-  }
-
-  const animationId = _creatorUtils.animate(val => {
-    const _val = options.easing? options.easing(val): val
-    onRawUpdate(_val)
-    if (val === 1 && options.onComplete) {
-      options.onComplete()
-    }
-  }, options.duration)
-
-  return animationId
-}
-
-export const stopAnimation = (id: number): void =>  _creatorUtils.stopAnimation(id)
-export const pauseAnimation = (id: number): void => _creatorUtils.pauseAnimation(id)
-export const resumeAnimation = (id: number): void => _creatorUtils.resumeAnimation(id)
-
-export const animateMat4 = (options: AnimateOptions<mat4>): number => {
-  const fromPosition = new Float32Array(3)
-  const fromQuaternion = new Float32Array(4)
-  const fromScale = new Float32Array(3)
-  const toPosition = new Float32Array(3)
-  const toQuaternion = new Float32Array(4)
-  const toScale = new Float32Array(3)
-  decompose(fromQuaternion, fromPosition, fromScale, (options as AnimateOptions<mat4>).from)
-  decompose(toQuaternion, toPosition, toScale, (options as AnimateOptions<mat4>).to)
-
-  const tempPosition = new Float32Array(3)
-  const tempQuat = new Float32Array(4)
-  const tempScale = new Float32Array(3)
-  const tempMat = new Float32Array(16)
-
-  const onUpdate = (options as AnimateOptions<mat4>).onUpdate
-  const onRawUpdate = (t: number) => {
-    lerp(tempPosition, fromPosition, toPosition, t)
-    slerp(tempQuat, fromQuaternion, toQuaternion, t)
-    lerp(tempScale, fromScale, toScale, t)
-
-    onUpdate(fromRotationTranslationScale(tempMat, tempQuat, tempPosition, tempScale))
-  }
-
-  const animationId = _creatorUtils.animate(val => {
-    const _val = options.easing? options.easing(val): val
-    onRawUpdate(_val)
-    if (val === 1 && options.onComplete) {
-      options.onComplete()
-    }
-  }, options.duration)
-
-  return animationId
-}
-
-const EPSILON = 1e-6;
-function slerp(out: quat, a: quat, b: quat, t: number) {
-  const ax = a[0], ay = a[1], az = a[2], aw = a[3];
-  let bx = b[0], by = b[1], bz = b[2], bw = b[3];
-  let omega, cosom, sinom, scale0, scale1;
-  cosom = ax * bx + ay * by + az * bz + aw * bw;
-  if (cosom < 0) {
-    cosom = -cosom;
-    bx = -bx;
-    by = -by;
-    bz = -bz;
-    bw = -bw;
-  }
-  if (1 - cosom > EPSILON) {
-    omega = Math.acos(cosom);
-    sinom = Math.sin(omega);
-    scale0 = Math.sin((1 - t) * omega) / sinom;
-    scale1 = Math.sin(t * omega) / sinom;
-  } else {
-    scale0 = 1 - t;
-    scale1 = t;
-  }
-  out[0] = scale0 * ax + scale1 * bx;
-  out[1] = scale0 * ay + scale1 * by;
-  out[2] = scale0 * az + scale1 * bz;
-  out[3] = scale0 * aw + scale1 * bw;
-  return out;
-}
-function lerp(out: vec3, a: vec3, b: vec3, t: number) {
-  const ax = a[0];
-  const ay = a[1];
-  const az = a[2];
-  out[0] = ax + t * (b[0] - ax);
-  out[1] = ay + t * (b[1] - ay);
-  out[2] = az + t * (b[2] - az);
-  return out;
-}
-
-function lerp2(out: vec2, a: vec2, b: vec2, t: number) {
-  const ax = a[0];
-  const ay = a[1];
-  const az = a[2];
-  out[0] = ax + t * (b[0] - ax);
-  out[1] = ay + t * (b[1] - ay);
-  return out;
-}
-function fromRotationTranslationScale(out: mat4, q: quat, v: vec3, s: vec3) {
-  const x = q[0], y = q[1], z = q[2], w = q[3];
-  const x2 = x + x;
-  const y2 = y + y;
-  const z2 = z + z;
-  const xx = x * x2;
-  const xy = x * y2;
-  const xz = x * z2;
-  const yy = y * y2;
-  const yz = y * z2;
-  const zz = z * z2;
-  const wx = w * x2;
-  const wy = w * y2;
-  const wz = w * z2;
-  const sx = s[0];
-  const sy = s[1];
-  const sz = s[2];
-  out[0] = (1 - (yy + zz)) * sx;
-  out[1] = (xy + wz) * sx;
-  out[2] = (xz - wy) * sx;
-  out[3] = 0;
-  out[4] = (xy - wz) * sy;
-  out[5] = (1 - (xx + zz)) * sy;
-  out[6] = (yz + wx) * sy;
-  out[7] = 0;
-  out[8] = (xz + wy) * sz;
-  out[9] = (yz - wx) * sz;
-  out[10] = (1 - (xx + yy)) * sz;
-  out[11] = 0;
-  out[12] = v[0];
-  out[13] = v[1];
-  out[14] = v[2];
-  out[15] = 1;
-  return out;
-}
-
-function decompose(out_r: mat4, out_t: vec3, out_s: vec3, mat: mat4) {
-  out_t[0] = mat[12];
-  out_t[1] = mat[13];
-  out_t[2] = mat[14];
-  const m11 = mat[0];
-  const m12 = mat[1];
-  const m13 = mat[2];
-  const m21 = mat[4];
-  const m22 = mat[5];
-  const m23 = mat[6];
-  const m31 = mat[8];
-  const m32 = mat[9];
-  const m33 = mat[10];
-  out_s[0] = Math.hypot(m11, m12, m13);
-  out_s[1] = Math.hypot(m21, m22, m23);
-  out_s[2] = Math.hypot(m31, m32, m33);
-  const is1 = 1 / out_s[0];
-  const is2 = 1 / out_s[1];
-  const is3 = 1 / out_s[2];
-  const sm11 = m11 * is1;
-  const sm12 = m12 * is2;
-  const sm13 = m13 * is3;
-  const sm21 = m21 * is1;
-  const sm22 = m22 * is2;
-  const sm23 = m23 * is3;
-  const sm31 = m31 * is1;
-  const sm32 = m32 * is2;
-  const sm33 = m33 * is3;
-  const trace = sm11 + sm22 + sm33;
-  let S = 0;
-  if (trace > 0) {
-    S = Math.sqrt(trace + 1) * 2;
-    out_r[3] = 0.25 * S;
-    out_r[0] = (sm23 - sm32) / S;
-    out_r[1] = (sm31 - sm13) / S;
-    out_r[2] = (sm12 - sm21) / S;
-  } else if (sm11 > sm22 && sm11 > sm33) {
-    S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2;
-    out_r[3] = (sm23 - sm32) / S;
-    out_r[0] = 0.25 * S;
-    out_r[1] = (sm12 + sm21) / S;
-    out_r[2] = (sm31 + sm13) / S;
-  } else if (sm22 > sm33) {
-    S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2;
-    out_r[3] = (sm31 - sm13) / S;
-    out_r[0] = (sm12 + sm21) / S;
-    out_r[1] = 0.25 * S;
-    out_r[2] = (sm23 + sm32) / S;
-  } else {
-    S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2;
-    out_r[3] = (sm12 - sm21) / S;
-    out_r[0] = (sm31 + sm13) / S;
-    out_r[1] = (sm23 + sm32) / S;
-    out_r[2] = 0.25 * S;
-  }
-  return out_r;
-}