@galfus/engine 0.0.0-stage → 0.31.0-alpha

package/src/anchors/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Anchor and spatial hierarchy subsystem.
+ */
+export * from './cache';
+export * from './component';
+export * from './hierarchy';
+export * from './solver';
+export * from './strategy';

package/src/anchors/solver.ts

@@ -0,0 +1,247 @@
+/**
+ * Anchor and hierarchical transform solver system.
+ *
+ * Runs during the `preRender` stage to calculate local and world matrices
+ * directly into Model3D/Model2D components and the persistent AnchorMatrixCache,
+ * resolving dependencies topologically with cycle detection, incremental dirty propagation,
+ * and SpatialDirtyFlags transitions.
+ */
+
+import type { EntityId } from '../ecs/entity';
+import type { System, SystemContext } from '../ecs/system';
+import type { EcsWorld } from '../ecs/world';
+import { mat2d, type Mat2d, mat4, type Mat4 } from '../math/index';
+import type { Model2DComponent } from '../realm2d/components';
+import type { Model3DComponent } from '../realm3d/components';
+import { SpatialDirtyFlags } from '../spatial/flags';
+import { AnchorMatrixCache } from './cache';
+import type { AnchorComponent } from './component';
+import { AnchorStrategyRegistry } from './strategy';
+
+export class AnchorSolveSystem {
+  readonly cache = new AnchorMatrixCache();
+  readonly strategies = new AnchorStrategyRegistry();
+
+  /**
+   * Resolves all 2D and 3D transforms for entities in the given world.
+   */
+  solve(world: EcsWorld, context: SystemContext): void {
+    this.solve2D(world, context);
+    this.solve3D(world, context);
+  }
+
+  // ---------------------------------------------------------------------------
+  // 2D Solving
+  // ---------------------------------------------------------------------------
+  private solve2D(world: EcsWorld, context: SystemContext): void {
+    const all2DEntities = world.query('Model2D');
+
+    const visiting = new Set<EntityId>();
+    const resolved = new Set<EntityId>();
+    const dirtyTargets = new Set<EntityId>();
+
+    for (const id of all2DEntities) {
+      this.resolveEntity2D(id, world, context, visiting, resolved, dirtyTargets);
+    }
+  }
+
+  private resolveEntity2D(
+    id: EntityId,
+    world: EcsWorld,
+    context: SystemContext,
+    visiting: Set<EntityId>,
+    resolved: Set<EntityId>,
+    dirtyTargets: Set<EntityId>
+  ): Mat2d {
+    const worldMatrix = this.cache.getOrCreateWorld2D(id);
+    if (resolved.has(id)) {
+      return worldMatrix;
+    }
+
+    const model = world.getComponent<Model2DComponent>(id, 'Model2D');
+    if (!model) {
+      return worldMatrix;
+    }
+
+    const localMatrix = this.cache.getOrCreateLocal2D(id);
+    mat2d.copy(localMatrix, model.localMatrix);
+
+    const anchor = world.getComponent<AnchorComponent>(id, 'Anchor');
+    if (!anchor || !anchor.active) {
+      const isLocalDirty = (model.flags & SpatialDirtyFlags.LocalDirty) !== 0;
+      if (isLocalDirty) {
+        mat2d.copy(worldMatrix, localMatrix);
+        mat2d.copy(model.worldMatrix, worldMatrix);
+        model.flags = (model.flags & ~SpatialDirtyFlags.LocalDirty) | SpatialDirtyFlags.WorldDirty;
+        dirtyTargets.add(id);
+      } else {
+        mat2d.copy(worldMatrix, model.worldMatrix);
+      }
+      resolved.add(id);
+      return worldMatrix;
+    }
+
+    // Cycle detection fallback
+    if (visiting.has(id)) {
+      console.warn(
+        `[AnchorSolveSystem] Cycle detected at entity ${id} in 2D anchor hierarchy. Falling back to local transform.`
+      );
+      mat2d.copy(worldMatrix, localMatrix);
+      mat2d.copy(model.worldMatrix, worldMatrix);
+      model.flags = (model.flags & ~SpatialDirtyFlags.LocalDirty) | SpatialDirtyFlags.WorldDirty;
+      dirtyTargets.add(id);
+      resolved.add(id);
+      return worldMatrix;
+    }
+
+    visiting.add(id);
+    const targetWorld = this.resolveEntity2D(
+      anchor.targetEntityId,
+      world,
+      context,
+      visiting,
+      resolved,
+      dirtyTargets
+    );
+    visiting.delete(id);
+
+    const isTargetDirty = dirtyTargets.has(anchor.targetEntityId);
+    const isLocalDirty = model ? (model.flags & SpatialDirtyFlags.LocalDirty) !== 0 : true;
+
+    // Incremental optimization: skip re-multiplication if neither target nor local changed
+    if (!isTargetDirty && !isLocalDirty) {
+      if (model) {
+        mat2d.copy(worldMatrix, model.worldMatrix);
+      }
+      resolved.add(id);
+      return worldMatrix;
+    }
+
+    if (anchor.callback2d) {
+      anchor.callback2d(targetWorld, localMatrix, worldMatrix, context);
+    } else {
+      const strategy = this.strategies.get2D(anchor.strategy);
+      strategy.apply(targetWorld, localMatrix, worldMatrix, anchor.offset2d, context);
+    }
+
+    if (model) {
+      mat2d.copy(model.worldMatrix, worldMatrix);
+      model.flags = (model.flags & ~SpatialDirtyFlags.LocalDirty) | SpatialDirtyFlags.WorldDirty;
+      dirtyTargets.add(id);
+    }
+
+    resolved.add(id);
+    return worldMatrix;
+  }
+
+  // ---------------------------------------------------------------------------
+  // 3D Solving
+  // ---------------------------------------------------------------------------
+  private solve3D(world: EcsWorld, context: SystemContext): void {
+    const all3DEntities = world.query('Model3D');
+
+    const visiting = new Set<EntityId>();
+    const resolved = new Set<EntityId>();
+    const dirtyTargets = new Set<EntityId>();
+
+    for (const id of all3DEntities) {
+      this.resolveEntity3D(id, world, context, visiting, resolved, dirtyTargets);
+    }
+  }
+
+  private resolveEntity3D(
+    id: EntityId,
+    world: EcsWorld,
+    context: SystemContext,
+    visiting: Set<EntityId>,
+    resolved: Set<EntityId>,
+    dirtyTargets: Set<EntityId>
+  ): Mat4 {
+    const worldMatrix = this.cache.getOrCreateWorld3D(id);
+    if (resolved.has(id)) {
+      return worldMatrix;
+    }
+
+    const model = world.getComponent<Model3DComponent>(id, 'Model3D');
+    if (!model) {
+      return worldMatrix;
+    }
+
+    const localMatrix = this.cache.getOrCreateLocal3D(id);
+    mat4.copy(localMatrix, model.localMatrix);
+
+    const anchor = world.getComponent<AnchorComponent>(id, 'Anchor');
+    if (!anchor || !anchor.active) {
+      const isLocalDirty = (model.flags & SpatialDirtyFlags.LocalDirty) !== 0;
+      if (isLocalDirty) {
+        mat4.copy(worldMatrix, localMatrix);
+        mat4.copy(model.worldMatrix, worldMatrix);
+        model.flags = (model.flags & ~SpatialDirtyFlags.LocalDirty) | SpatialDirtyFlags.WorldDirty;
+        dirtyTargets.add(id);
+      } else {
+        mat4.copy(worldMatrix, model.worldMatrix);
+      }
+      resolved.add(id);
+      return worldMatrix;
+    }
+
+    // Cycle detection fallback
+    if (visiting.has(id)) {
+      console.warn(
+        `[AnchorSolveSystem] Cycle detected at entity ${id} in 3D anchor hierarchy. Falling back to local transform.`
+      );
+      mat4.copy(worldMatrix, localMatrix);
+      mat4.copy(model.worldMatrix, worldMatrix);
+      model.flags = (model.flags & ~SpatialDirtyFlags.LocalDirty) | SpatialDirtyFlags.WorldDirty;
+      dirtyTargets.add(id);
+      resolved.add(id);
+      return worldMatrix;
+    }
+
+    visiting.add(id);
+    const targetWorld = this.resolveEntity3D(
+      anchor.targetEntityId,
+      world,
+      context,
+      visiting,
+      resolved,
+      dirtyTargets
+    );
+    visiting.delete(id);
+
+    const isTargetDirty = dirtyTargets.has(anchor.targetEntityId);
+    const isLocalDirty = model ? (model.flags & SpatialDirtyFlags.LocalDirty) !== 0 : true;
+
+    // Incremental optimization: skip re-multiplication if neither target nor local changed
+    if (!isTargetDirty && !isLocalDirty) {
+      if (model) {
+        mat4.copy(worldMatrix, model.worldMatrix);
+      }
+      resolved.add(id);
+      return worldMatrix;
+    }
+
+    if (anchor.callback3d) {
+      anchor.callback3d(targetWorld, localMatrix, worldMatrix, context);
+    } else {
+      const strategy = this.strategies.get3D(anchor.strategy);
+      strategy.apply(targetWorld, localMatrix, worldMatrix, anchor.offset3d, context);
+    }
+
+    if (model) {
+      mat4.copy(model.worldMatrix, worldMatrix);
+      model.flags = (model.flags & ~SpatialDirtyFlags.LocalDirty) | SpatialDirtyFlags.WorldDirty;
+      dirtyTargets.add(id);
+    }
+
+    resolved.add(id);
+    return worldMatrix;
+  }
+
+  /**
+   * Helper function creating an ECS System instance running this solver in `preRender`.
+   */
+  createSystem(): System<EcsWorld> {
+    return (world, context) => this.solve(world, context);
+  }
+}

package/src/anchors/strategy.ts

@@ -0,0 +1,142 @@
+/**
+ * Extensible Anchor strategies for 2D and 3D hierarchical solving.
+ */
+
+import { mat2d, type Mat2d, mat4, type Mat4 } from '../math/index';
+
+export interface AnchorContext {
+  /** Delta time of the frame in seconds. */
+  dt: number;
+  /** Total elapsed time in seconds. */
+  time: number;
+}
+
+export type AnchorConstraintCallback2D = (
+  targetWorld: Mat2d,
+  local: Mat2d,
+  outWorld: Mat2d,
+  context: AnchorContext
+) => void;
+
+export type AnchorConstraintCallback3D = (
+  targetWorld: Mat4,
+  local: Mat4,
+  outWorld: Mat4,
+  context: AnchorContext
+) => void;
+
+/**
+ * 2D Anchor resolution strategy contract.
+ */
+export interface AnchorStrategy2D {
+  readonly name: string;
+  apply(
+    targetWorld: Mat2d,
+    local: Mat2d,
+    outWorld: Mat2d,
+    offset: Mat2d | undefined,
+    context: AnchorContext
+  ): void;
+}
+
+/**
+ * 3D Anchor resolution strategy contract.
+ */
+export interface AnchorStrategy3D {
+  readonly name: string;
+  apply(
+    targetWorld: Mat4,
+    local: Mat4,
+    outWorld: Mat4,
+    offset: Mat4 | undefined,
+    context: AnchorContext
+  ): void;
+}
+
+/**
+ * Default 'static' 2D strategy: multiplies targetWorld * (offset ? offset * local : local).
+ */
+export const StaticAnchorStrategy2D: AnchorStrategy2D = {
+  name: 'static',
+  apply(targetWorld, local, outWorld, offset) {
+    if (offset) {
+      const temp = mat2d.create();
+      mat2d.multiply(temp, offset, local);
+      mat2d.multiply(outWorld, targetWorld, temp);
+    } else {
+      mat2d.multiply(outWorld, targetWorld, local);
+    }
+  }
+};
+
+/**
+ * Default 'static' 3D strategy: multiplies targetWorld * (offset ? offset * local : local).
+ */
+export const StaticAnchorStrategy3D: AnchorStrategy3D = {
+  name: 'static',
+  apply(targetWorld, local, outWorld, offset) {
+    if (offset) {
+      const temp = mat4.create();
+      mat4.multiply(temp, offset, local);
+      mat4.multiply(outWorld, targetWorld, temp);
+    } else {
+      mat4.multiply(outWorld, targetWorld, local);
+    }
+  }
+};
+
+/**
+ * Pure 'translation' 2D strategy: follows targetWorld translation only without inheriting orientation or scale.
+ */
+export const TranslationAnchorStrategy2D: AnchorStrategy2D = {
+  name: 'translation',
+  apply(targetWorld, local, outWorld, offset) {
+    mat2d.copy(outWorld, local);
+    outWorld[4] += targetWorld[4] + (offset ? offset[4] : 0);
+    outWorld[5] += targetWorld[5] + (offset ? offset[5] : 0);
+  }
+};
+
+/**
+ * Pure 'translation' 3D strategy: follows targetWorld translation only without inheriting orientation or scale.
+ */
+export const TranslationAnchorStrategy3D: AnchorStrategy3D = {
+  name: 'translation',
+  apply(targetWorld, local, outWorld, offset) {
+    mat4.copy(outWorld, local);
+    outWorld[12] += targetWorld[12] + (offset ? offset[12] : 0);
+    outWorld[13] += targetWorld[13] + (offset ? offset[13] : 0);
+    outWorld[14] += targetWorld[14] + (offset ? offset[14] : 0);
+  }
+};
+
+/**
+ * Registry holding custom Anchor strategies.
+ */
+export class AnchorStrategyRegistry {
+  private readonly _strategies2D = new Map<string, AnchorStrategy2D>();
+  private readonly _strategies3D = new Map<string, AnchorStrategy3D>();
+
+  constructor() {
+    this.register2D(StaticAnchorStrategy2D);
+    this.register2D(TranslationAnchorStrategy2D);
+    this.register3D(StaticAnchorStrategy3D);
+    this.register3D(TranslationAnchorStrategy3D);
+  }
+
+  register2D(strategy: AnchorStrategy2D): void {
+    this._strategies2D.set(strategy.name, strategy);
+  }
+
+  register3D(strategy: AnchorStrategy3D): void {
+    this._strategies3D.set(strategy.name, strategy);
+  }
+
+  get2D(name: string): AnchorStrategy2D {
+    return this._strategies2D.get(name) ?? StaticAnchorStrategy2D;
+  }
+
+  get3D(name: string): AnchorStrategy3D {
+    return this._strategies3D.get(name) ?? StaticAnchorStrategy3D;
+  }
+}

package/src/animation/blending.ts

@@ -0,0 +1,163 @@
+/**
+ * Pose extraction, blending, and crossfading routines.
+ */
+
+import type { EntityId } from '../ecs/entity';
+import { common, quat, vec3 } from '../math/index';
+import { type AnimationClip, sampleTrack } from './clip';
+
+export interface AnimationPose {
+  translations: Map<EntityId, [number, number, number]>;
+  rotations: Map<EntityId, [number, number, number, number]>;
+  scales: Map<EntityId, [number, number, number]>;
+  weights: Map<EntityId, Float32Array>;
+}
+
+export function createAnimationPose(): AnimationPose {
+  return {
+    translations: new Map(),
+    rotations: new Map(),
+    scales: new Map(),
+    weights: new Map()
+  };
+}
+
+export function clearAnimationPose(pose: AnimationPose): void {
+  pose.translations.clear();
+  pose.rotations.clear();
+  pose.scales.clear();
+  pose.weights.clear();
+}
+
+export function copyAnimationPose(from: AnimationPose, to: AnimationPose): void {
+  clearAnimationPose(to);
+  for (const [id, val] of from.translations) to.translations.set(id, [val[0], val[1], val[2]]);
+  for (const [id, val] of from.rotations) to.rotations.set(id, [val[0], val[1], val[2], val[3]]);
+  for (const [id, val] of from.scales) to.scales.set(id, [val[0], val[1], val[2]]);
+  for (const [id, val] of from.weights) to.weights.set(id, new Float32Array(val));
+}
+
+// Reusable sampling and interpolation buffers; pose entries own their values.
+const SCRATCH_VEC3 = new Float32Array(3);
+const SCRATCH_VEC4 = new Float32Array(4);
+const SCRATCH_BLEND_VEC3 = vec3.create();
+const SCRATCH_BLEND_QUAT = quat.create();
+
+function blendVectors(
+  out: Map<EntityId, [number, number, number]>,
+  poseA: Map<EntityId, [number, number, number]>,
+  poseB: Map<EntityId, [number, number, number]>,
+  t: number
+): void {
+  for (const [id, a] of poseA) {
+    const b = poseB.get(id);
+    if (b) {
+      vec3.lerp(SCRATCH_BLEND_VEC3, a, b, t);
+      out.set(id, [SCRATCH_BLEND_VEC3[0], SCRATCH_BLEND_VEC3[1], SCRATCH_BLEND_VEC3[2]]);
+    } else out.set(id, [a[0], a[1], a[2]]);
+  }
+  for (const [id, b] of poseB) if (!poseA.has(id)) out.set(id, [b[0], b[1], b[2]]);
+}
+
+/**
+ * Evaluates an AnimationClip at a specific timestamp and writes the resulting pose into `outPose`.
+ */
+export function evaluateClip(clip: AnimationClip, time: number, outPose: AnimationPose): void {
+  for (const track of clip.tracks) {
+    const id = track.targetEntity;
+
+    switch (track.path) {
+      case 'translation':
+        sampleTrack(track, time, SCRATCH_VEC3);
+        outPose.translations.set(id, [SCRATCH_VEC3[0]!, SCRATCH_VEC3[1]!, SCRATCH_VEC3[2]!]);
+        break;
+
+      case 'rotation':
+        sampleTrack(track, time, SCRATCH_VEC4);
+        outPose.rotations.set(id, [
+          SCRATCH_VEC4[0]!,
+          SCRATCH_VEC4[1]!,
+          SCRATCH_VEC4[2]!,
+          SCRATCH_VEC4[3]!
+        ]);
+        break;
+
+      case 'scale':
+        sampleTrack(track, time, SCRATCH_VEC3);
+        outPose.scales.set(id, [SCRATCH_VEC3[0]!, SCRATCH_VEC3[1]!, SCRATCH_VEC3[2]!]);
+        break;
+
+      case 'weights': {
+        const records = track.timestamps.length * (track.interpolation === 'cubicspline' ? 3 : 1);
+        const weightCount = Math.floor(track.values.length / Math.max(1, records));
+        let weightsBuf = outPose.weights.get(id);
+        if (!weightsBuf || weightsBuf.length !== weightCount) {
+          weightsBuf = new Float32Array(weightCount);
+          outPose.weights.set(id, weightsBuf);
+        }
+        sampleTrack(track, time, weightsBuf);
+        break;
+      }
+    }
+  }
+}
+
+/**
+ * Linearly and spherically blends two poses according to weight alpha (0.0 = poseA, 1.0 = poseB).
+ */
+export function blendPoses(
+  out: AnimationPose,
+  poseA: AnimationPose,
+  poseB: AnimationPose,
+  alpha: number
+): void {
+  const t = common.clamp(alpha, 0, 1);
+
+  if (t === 0) {
+    copyAnimationPose(poseA, out);
+    return;
+  }
+  if (t === 1) {
+    copyAnimationPose(poseB, out);
+    return;
+  }
+
+  clearAnimationPose(out);
+
+  blendVectors(out.translations, poseA.translations, poseB.translations, t);
+
+  // Blend rotations with quaternion SLERP.
+  for (const [id, a] of poseA.rotations) {
+    const b = poseB.rotations.get(id);
+    if (b) {
+      quat.slerp(SCRATCH_BLEND_QUAT, a, b, t);
+      out.rotations.set(id, [
+        SCRATCH_BLEND_QUAT[0],
+        SCRATCH_BLEND_QUAT[1],
+        SCRATCH_BLEND_QUAT[2],
+        SCRATCH_BLEND_QUAT[3]
+      ]);
+    } else out.rotations.set(id, [a[0], a[1], a[2], a[3]]);
+  }
+  for (const [id, b] of poseB.rotations)
+    if (!poseA.rotations.has(id)) out.rotations.set(id, [b[0], b[1], b[2], b[3]]);
+
+  // Blend scales.
+  blendVectors(out.scales, poseA.scales, poseB.scales, t);
+
+  // Blend weights.
+  for (const [id, a] of poseA.weights) {
+    const b = poseB.weights.get(id);
+    if (b && a.length === b.length) {
+      const blended = new Float32Array(a.length);
+      for (let i = 0; i < a.length; i++) {
+        blended[i] = common.lerp(a[i]!, b[i]!, t);
+      }
+      out.weights.set(id, blended);
+    } else {
+      out.weights.set(id, new Float32Array(a));
+    }
+  }
+  for (const [id, b] of poseB.weights)
+    if (!poseA.weights.has(id)) out.weights.set(id, new Float32Array(b));
+}

package/src/animation/clip.ts

@@ -0,0 +1,132 @@
+/**
+ * Animation track and clip structures supporting keyframe sampling for glTF animations.
+ */
+
+import type { EntityId } from '../ecs/entity';
+import { common, quat, type Quat } from '../math/index';
+
+export type InterpolationMode = 'step' | 'linear' | 'cubicspline';
+export type AnimationPath = 'translation' | 'rotation' | 'scale' | 'weights';
+
+export interface KeyframeTrack {
+  targetEntity: EntityId;
+  path: AnimationPath;
+  /** Monotonically increasing keyframe timestamps in seconds */
+  timestamps: Float32Array;
+  /** Flattened keyframe values: 3 floats per key for pos/scale, 4 for quat, N for weights */
+  values: Float32Array;
+  interpolation: InterpolationMode;
+}
+
+export interface AnimationClip {
+  name: string;
+  duration: number;
+  tracks: KeyframeTrack[];
+}
+
+/**
+ * Samples an individual keyframe track at a given time and outputs interpolated values into `out`.
+ */
+export function sampleTrack(track: KeyframeTrack, time: number, out: Float32Array): void {
+  const times = track.timestamps;
+  const values = track.values;
+  const count = times.length;
+  if (count === 0) return;
+
+  const isCubic = track.interpolation === 'cubicspline';
+  const stride = track.path === 'rotation' ? 4 : track.path === 'weights' ? out.length : 3;
+
+  // In glTF cubic spline, each keyframe stores 3 values: [in-tangent, value, out-tangent]
+  const recordSize = isCubic ? stride * 3 : stride;
+
+  // Edge case 1: Before or at first keyframe
+  if (time <= times[0]!) {
+    const valOffset = isCubic ? stride : 0;
+    for (let i = 0; i < stride; i++) {
+      out[i] = values[valOffset + i] ?? 0;
+    }
+    return;
+  }
+
+  // Edge case 2: After or at last keyframe
+  if (time >= times[count - 1]!) {
+    const valOffset = (count - 1) * recordSize + (isCubic ? stride : 0);
+    for (let i = 0; i < stride; i++) {
+      out[i] = values[valOffset + i] ?? 0;
+    }
+    return;
+  }
+
+  // Binary search for keyframe interval [k, k + 1] such that times[k] <= time < times[k + 1]
+  let low = 0;
+  let high = count - 1;
+  while (low <= high) {
+    const mid = (low + high) >> 1;
+    if (times[mid]! <= time) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  const k = Math.max(0, low - 1);
+  const t0 = times[k]!;
+  const t1 = times[k + 1]!;
+  const deltaT = t1 - t0;
+  const factor = deltaT > 0 ? common.clamp((time - t0) / deltaT, 0, 1) : 0;
+
+  // 1. STEP interpolation
+  if (track.interpolation === 'step') {
+    const valOffset = k * recordSize + (isCubic ? stride : 0);
+    for (let i = 0; i < stride; i++) {
+      out[i] = values[valOffset + i] ?? 0;
+    }
+    return;
+  }
+
+  // 2. LINEAR interpolation
+  if (track.interpolation === 'linear') {
+    const offset0 = k * recordSize;
+    const offset1 = (k + 1) * recordSize;
+
+    if (track.path === 'rotation') {
+      const q0 = values.subarray(offset0, offset0 + 4) as unknown as Quat;
+      const q1 = values.subarray(offset1, offset1 + 4) as unknown as Quat;
+      quat.slerp(out as unknown as Quat, q0, q1, factor);
+    } else {
+      for (let i = 0; i < stride; i++) {
+        const v0 = values[offset0 + i] ?? 0;
+        const v1 = values[offset1 + i] ?? 0;
+        out[i] = common.lerp(v0, v1, factor);
+      }
+    }
+    return;
+  }
+
+  // 3. CUBIC SPLINE interpolation
+  // Hermite polynomial coefficients:
+  // p(tau) = (2*tau^3 - 3*tau^2 + 1)*p0 + (tau^3 - 2*tau^2 + tau)*dt*m0 + (-2*tau^3 + 3*tau^2)*p1 + (tau^3 - tau^2)*dt*m1
+  const tau = factor;
+  const tau2 = tau * tau;
+  const tau3 = tau2 * tau;
+
+  const h00 = 2 * tau3 - 3 * tau2 + 1;
+  const h10 = (tau3 - 2 * tau2 + tau) * deltaT;
+  const h01 = -2 * tau3 + 3 * tau2;
+  const h11 = (tau3 - tau2) * deltaT;
+
+  const base0 = k * recordSize;
+  const base1 = (k + 1) * recordSize;
+
+  for (let i = 0; i < stride; i++) {
+    const p0 = values[base0 + stride + i] ?? 0;
+    const m0 = values[base0 + 2 * stride + i] ?? 0; // out-tangent of k
+    const p1 = values[base1 + stride + i] ?? 0;
+    const m1 = values[base1 + i] ?? 0; // in-tangent of k + 1
+
+    out[i] = h00 * p0 + h10 * m0 + h01 * p1 + h11 * m1;
+  }
+
+  if (track.path === 'rotation') {
+    quat.normalize(out as unknown as Quat, out as unknown as Quat);
+  }
+}