reze-engine 0.32.1 → 0.33.0

package/src/locomotion.ts

@@ -102,6 +102,10 @@ export interface LocomotionOptions {
   turnTimeScale?: number
   /** Playback rate for stop clips (default 1.25) — same reasoning. */
   stopTimeScale?: number
+  /** Seconds a heading must be held before a release earns an authored stop
+   *  (default 0.5). Below it, weaving direction changes blend to idle instead
+   *  of skidding metres along the last-held heading. */
+  stopCommitTime?: number
   /** Tank-mode steering rate, radians/second (default 2.5 ≈ 143°/s). */
   steerRate?: number
   /** Backpedal speed as a fraction of run speed in tank mode (default 0.5). */
@@ -148,6 +152,7 @@ export class LocomotionController {
   private readonly turnClipMinAngle: number
   private readonly turnTimeScale: number
   private readonly stopTimeScale: number
+  private readonly stopCommitTime: number
   private turning: { entry: TurnClipEntry; time: number } | null = null
   private runTurning: {
     entry: RunTurnClipEntry
@@ -160,6 +165,9 @@ export class LocomotionController {
   /** An interrupted authored clip fading out OVER resumed locomotion, so breaking
    *  out of a stop is instantly responsive without a pose pop. */
   private exitGhost: { clip: string; clipTime: number; elapsed: number } | null = null
+  private headingHold = 0
+  private headingDirX = 0
+  private headingDirY = 0
   private stopping: {
     entry: StopClipEntry
     time: number
@@ -168,6 +176,8 @@ export class LocomotionController {
     dirX: number
     dirZ: number
     startLevel: number
+    /** Fraction of the authored deceleration distance this stop travels. */
+    scale: number
     /** Idle's share of the blend at release (level < 1 shows part idle) — the
      *  crossfade source keeps this exact mix or the first stop frame snaps. */
     fromIdleW: number
@@ -226,6 +236,7 @@ export class LocomotionController {
     this.turnClipMinAngle = options?.turnClipMinAngle ?? (100 * Math.PI) / 180
     this.turnTimeScale = options?.turnTimeScale ?? 1.4
     this.stopTimeScale = options?.stopTimeScale ?? 1.25
+    this.stopCommitTime = options?.stopCommitTime ?? 0.5
     this.turnEntries = [
       { name: clips.idle, time: 0, weight: 0 },
       { name: clips.idle, time: 0, weight: 1 },
@@ -353,12 +364,32 @@ export class LocomotionController {
       const m = Math.hypot(this.inputX, this.inputY)
       moving = m > 0.05
       this.recentSpeed = Math.max(this.speedLevel, this.recentSpeed - dt * 1.5)
+      // How long the CURRENT heading has been held. An authored skid is the
+      // ending of a committed run; weaving through directions (D, then S+D,
+      // then S) rebuilds throttle in each new heading but earns no such
+      // ending — playing one there slides her metres along whichever way she
+      // happened to face last, which reads as drift.
+      if (moving) {
+        const dx = this.inputX / m
+        const dy = this.inputY / m
+        this.headingHold =
+          this.headingDirX * dx + this.headingDirY * dy > 0.94 ? this.headingHold + dt : 0
+        this.headingDirX = dx
+        this.headingDirY = dy
+      }
       // Release at speed: play the authored stop instead of blending to idle.
       const stops = this.clips.stop
       // Gate on the peak-hold speed: the release decay (throttle/analog) drains the
       // instantaneous level below any threshold before `moving` goes false. The
       // small floor on the actual level keeps standstill taps from faking a skid.
-      if (!moving && stops && stops.length > 0 && this.recentSpeed >= 0.7 && this.speedLevel >= 0.35) {
+      if (
+        !moving &&
+        stops &&
+        stops.length > 0 &&
+        this.recentSpeed >= 0.7 &&
+        this.speedLevel >= 0.35 &&
+        this.headingHold >= this.stopCommitTime
+      ) {
         const gear = this.recentSpeed > 1.4 ? "sprint" : "run"
         const foot = this.gaitPhase < 0.5 ? "L" : "R"
         // Gear must match exactly: supplying stops for only one gear means the
@@ -383,6 +414,13 @@ export class LocomotionController {
             dirX: this.dirX,
             dirZ: this.dirZ,
             startLevel: Math.min(this.recentSpeed, 2),
+            // How much of the authored skid this stop has earned. Each profile
+            // was captured at ITS gear's full speed (run = level 1, sprint =
+            // level 2), so compare like with like. Entering slower — or moments
+            // after a direction change, when the peak-hold still remembers the
+            // PREVIOUS heading's sprint — must not replay the full slide.
+            // Floored so a stop always still reads as a stop.
+            scale: Math.max(0.3, Math.min(1, this.speedLevel / (best.gear === "sprint" ? 2 : 1))),
             fromIdleW: Math.max(0, 1 - this.speedLevel),
             fromClip,
             fromTime: this.gaitPhase * this.clipDuration(fromClip),
@@ -707,7 +745,7 @@ export class LocomotionController {
 
     t.time += dt * this.stopTimeScale
     const clipT = Math.min(t.time, entry.exitTime)
-    const fwd = LocomotionController.profileAt(entry.forward, clipT / entry.exitTime)
+    const fwd = LocomotionController.profileAt(entry.forward, clipT / entry.exitTime) * t.scale
     this.position.x = t.startX + t.dirX * fwd
     this.position.z = t.startZ + t.dirZ * fwd
 

package/src/physics/world.ts

@@ -93,8 +93,15 @@ export class World {
     //    it because it doesn't go through the velocity channel. Inverse-mass
     //    weighted so a kinematic body stays put and only the dynamic one
     //    translates.
-    const POS_CORRECTION_FACTOR = 0.4
-    const POS_SLOP = 0.005
+    // Softer and later than a rigid-body engine would use, deliberately. MMD
+    // cloth is a dense chain of small bodies resting on the character, and
+    // aggressive penetration recovery feeds those contacts energy that the
+    // joint springs hand straight back — the tips never settle. Measured on a
+    // 688-body model: resting peak velocity 1.79 → 1.10, and 12.9 → 6.6 under
+    // an idle animation, for a slop of two hundredths of a unit (under 2 mm at
+    // MMD scale) that no eye finds.
+    const POS_CORRECTION_FACTOR = 0.15
+    const POS_SLOP = 0.02
     for (let ci = 0; ci < contacts.count; ci++) {
       const c = contacts.get(ci)
       if (c.depth <= POS_SLOP) continue

package/src/pmx-loader.ts

@@ -84,10 +84,19 @@ export class PmxLoader {
   }
 
   private parseHeader() {
-    if (this.getString(3) !== "PMX") throw new Error("Not a PMX file")
-
-    // PMX: 1-byte alignment after signature
-    this.getUint8()
+    // The signature is four bytes. PMX 2.x writes "PMX ", but exporters in the
+    // wild also write "Pmx " — and a strict uppercase compare rejected those
+    // models outright. Compare case-insensitively and name what was actually
+    // found when it is something else, so a PMD (the older format, signature
+    // "Pmd") says so instead of "not a PMX file".
+    const signature = this.getString(4)
+    if (signature.slice(0, 3).toUpperCase() !== "PMX") {
+      const head = signature.slice(0, 3).toUpperCase()
+      if (head === "PMD") {
+        throw new Error("This is a PMD file (MMD's older format). Convert it to PMX in PMXEditor first.")
+      }
+      throw new Error(`Not a PMX file (signature "${signature.replace(/[^\x20-\x7e]/g, "?")}")`)
+    }
 
     // PMX: version (float32)
     const version = this.getFloat32()
@@ -1128,7 +1137,9 @@ export class PmxLoader {
   }
 
   private getString(len: number) {
-    const bytes = new Uint8Array(this.view.buffer, this.offset, len)
+    // byteOffset matters: a DataView built over a slice of a larger buffer has
+    // its own origin, and reading the raw buffer without it lands elsewhere.
+    const bytes = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, len)
     this.offset += len
     return String.fromCharCode(...bytes)
   }
@@ -1137,18 +1148,23 @@ export class PmxLoader {
     const len = this.getInt32()
     if (len <= 0) return ""
 
-    // Debug: log problematic string lengths
-    if (len > 1000 || len < -1000) {
-      throw new RangeError(`Suspicious string length: ${len} at offset ${this.offset - 4}`)
-    }
-
+    // No arbitrary length ceiling. A model's comment field carries credits and
+    // terms of use and routinely runs past a thousand bytes — roughly five
+    // hundred characters in UTF-16 — so a "this looks too long" heuristic
+    // rejected perfectly ordinary models from several distributors. The bounds
+    // check below is the real guard: a length that would read past the end of
+    // the file is corrupt, and any length that fits is the author's business.
     // Ensure we don't read beyond buffer bounds
-    if (this.offset + len > this.view.buffer.byteLength) {
+    if (this.offset + len > this.view.byteLength) {
       throw new RangeError(`String length ${len} exceeds buffer bounds at offset ${this.offset - 4}`)
     }
 
-    const bytes = new Uint8Array(this.view.buffer, this.offset, len)
+    let bytes = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, len)
     this.offset += len
+    // UTF-16 needs whole code units. A stray odd length (seen from a few
+    // exporters) made TextDecoder emit a replacement char and, worse, shifted
+    // nothing — better to drop the orphan byte than to carry it into the name.
+    if (this.encoding === 0 && len % 2 === 1) bytes = bytes.subarray(0, len - 1)
     return this.decoder.decode(bytes)
   }
 

package/dist/gpu-profile.d.ts

@@ -1,19 +0,0 @@
-export declare class GpuTimestamp {
-    enabled: boolean;
-    readonly supported: boolean;
-    private device;
-    private querySet;
-    private resolveBuffer;
-    private readbackBuffer;
-    private nextSlot;
-    private frameLabels;
-    private inFlight;
-    private pendingLabels;
-    constructor(device: GPUDevice);
-    private ensureCreated;
-    beginFrame(): void;
-    wrap(desc: GPURenderPassDescriptor, label: string): GPURenderPassDescriptor;
-    endFrame(encoder: GPUCommandEncoder): void;
-    afterSubmit(): void;
-}
-//# sourceMappingURL=gpu-profile.d.ts.map

package/dist/gpu-profile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gpu-profile.d.ts","sourceRoot":"","sources":["../src/gpu-profile.ts"],"names":[],"mappings":"AAoBA,qBAAa,YAAY;IACvB,OAAO,UAAQ;IACf,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,aAAa,CAAyB;IAC9C,OAAO,CAAC,cAAc,CAAyB;IAC/C,OAAO,CAAC,QAAQ,CAAI;IACpB,OAAO,CAAC,WAAW,CAAe;IAClC,OAAO,CAAC,QAAQ,CAAQ;IAKxB,OAAO,CAAC,aAAa,CAAwB;gBAEjC,MAAM,EAAE,SAAS;IAK7B,OAAO,CAAC,aAAa;IAiBrB,UAAU,IAAI,IAAI;IAWlB,IAAI,CAAC,IAAI,EAAE,uBAAuB,EAAE,KAAK,EAAE,MAAM,GAAG,uBAAuB;IAqB3E,QAAQ,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAW1C,WAAW,IAAI,IAAI;CAwBpB"}

package/dist/gpu-profile.js

@@ -1,120 +0,0 @@
-// WebGPU timestamp-query profiling. Records pass durations into the same
-// profiler module as CPU phases (so the snapshot table mixes both with a
-// "gpu." prefix). Read-only — no effect on rendering output.
-//
-// Pattern (per spec):
-//   1. Each render pass declares timestampWrites { begin, end } slot indices.
-//   2. After all passes, encoder.resolveQuerySet writes uint64 ns timestamps
-//      into a QUERY_RESOLVE buffer.
-//   3. We copy the resolve buffer into a MAP_READ readback buffer.
-//   4. Submit. After the GPU finishes, mapAsync resolves; we read durations
-//      and record them.
-//
-// One readback buffer with an in-flight gate: if mapAsync hasn't resolved
-// from a previous frame, we skip the copy this frame (no contention, just
-// one frame of dropped sampling).
-import { profiler } from "./physics/profile";
-const MAX_PASSES_PER_FRAME = 64;
-export class GpuTimestamp {
-    constructor(device) {
-        this.enabled = false;
-        this.querySet = null;
-        this.resolveBuffer = null;
-        this.readbackBuffer = null;
-        this.nextSlot = 0;
-        this.frameLabels = [];
-        this.inFlight = false;
-        // Set inside endFrame() when a copy was queued this frame; consumed by
-        // afterSubmit() to kick mapAsync. mapAsync must run AFTER queue.submit —
-        // calling it before submit puts the buffer into "mapping pending" state,
-        // which makes the copy in the encoder illegal.
-        this.pendingLabels = null;
-        this.device = device;
-        this.supported = device.features.has("timestamp-query");
-    }
-    ensureCreated() {
-        if (this.querySet || !this.supported)
-            return;
-        const slots = MAX_PASSES_PER_FRAME * 2;
-        this.querySet = this.device.createQuerySet({ type: "timestamp", count: slots });
-        this.resolveBuffer = this.device.createBuffer({
-            label: "gpu-timestamp-resolve",
-            size: slots * 8,
-            usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC,
-        });
-        this.readbackBuffer = this.device.createBuffer({
-            label: "gpu-timestamp-readback",
-            size: slots * 8,
-            usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
-        });
-    }
-    // Called once at the top of each render() before any pass wrap.
-    beginFrame() {
-        if (!this.enabled || !this.supported)
-            return;
-        this.ensureCreated();
-        this.nextSlot = 0;
-        this.frameLabels = [];
-    }
-    // Wrap a render-pass descriptor with timestampWrites for `label`. If
-    // profiling is off / unsupported / out of slots, returns desc unchanged.
-    // The same label called multiple times (e.g. each bloom mip) is fine —
-    // the profiler accumulates by label.
-    wrap(desc, label) {
-        if (!this.enabled || !this.querySet)
-            return desc;
-        if (this.nextSlot + 2 > MAX_PASSES_PER_FRAME * 2)
-            return desc;
-        const begin = this.nextSlot;
-        const end = this.nextSlot + 1;
-        this.nextSlot += 2;
-        this.frameLabels.push(label);
-        return {
-            ...desc,
-            timestampWrites: {
-                querySet: this.querySet,
-                beginningOfPassWriteIndex: begin,
-                endOfPassWriteIndex: end,
-            },
-        };
-    }
-    // Call on the encoder after all passes, BEFORE encoder.finish(). Adds
-    // resolveQuerySet + copyBufferToBuffer commands. mapAsync is deferred to
-    // afterSubmit() — calling it before submit transitions the readback buffer
-    // into "mapping pending" state, which makes the queued copy illegal.
-    endFrame(encoder) {
-        if (!this.enabled || !this.querySet || this.frameLabels.length === 0)
-            return;
-        const count = this.frameLabels.length * 2;
-        encoder.resolveQuerySet(this.querySet, 0, count, this.resolveBuffer, 0);
-        if (this.inFlight)
-            return;
-        encoder.copyBufferToBuffer(this.resolveBuffer, 0, this.readbackBuffer, 0, count * 8);
-        this.pendingLabels = this.frameLabels.slice();
-    }
-    // Call AFTER device.queue.submit(). Kicks mapAsync if a copy was queued
-    // this frame; the .then() reads durations and unmaps.
-    afterSubmit() {
-        const labels = this.pendingLabels;
-        if (!labels)
-            return;
-        this.pendingLabels = null;
-        this.inFlight = true;
-        const readback = this.readbackBuffer;
-        void readback.mapAsync(GPUMapMode.READ).then(() => {
-            const arr = new BigInt64Array(readback.getMappedRange());
-            for (let i = 0; i < labels.length; i++) {
-                const start = arr[i * 2];
-                const end = arr[i * 2 + 1];
-                // Per spec, timestamps are nanoseconds.
-                const ms = Number(end - start) / 1e6;
-                if (ms >= 0 && ms < 1000)
-                    profiler.record("gpu." + labels[i], ms);
-            }
-            readback.unmap();
-            this.inFlight = false;
-        }, () => {
-            this.inFlight = false;
-        });
-    }
-}

package/dist/physics/physics.worker.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=physics.worker.d.ts.map

package/dist/physics/physics.worker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"physics.worker.d.ts","sourceRoot":"","sources":["../../src/physics/physics.worker.ts"],"names":[],"mappings":""}

package/dist/physics/physics.worker.js

@@ -1,52 +0,0 @@
-// Physics worker: owns ONE model's RezePhysics world. The host posts the
-// frame's bone world matrices as a transferable buffer; the worker steps the
-// simulation (identical math to the main-thread path — same class, same code)
-// and returns the buffer with the dynamic bones' matrices written back, plus
-// its own step cost for the host's stats.
-//
-// The incoming buffer is COPIED into a persistent local pose (and back out)
-// rather than wrapped: transferred ArrayBuffers get a fresh identity on every
-// hop, so wrappers could never be cached against them — and two ~20KB copies
-// per frame are microseconds.
-import { RezePhysics } from "./physics";
-import { Mat4 } from "../math";
-import { RigidbodyType } from "./types";
-const ctx = self;
-let physics = null;
-let inverseBind = new Float32Array(0);
-let pose = new Float32Array(0);
-let mats = [];
-ctx.onmessage = (e) => {
-    const msg = e.data;
-    if (msg.cmd === "init") {
-        physics = new RezePhysics(msg.rigidbodies, msg.joints);
-        inverseBind = msg.inverseBind;
-        const boneCount = inverseBind.length / 16;
-        pose = new Float32Array(boneCount * 16);
-        mats = new Array(boneCount);
-        for (let i = 0; i < boneCount; i++)
-            mats[i] = new Mat4(pose.subarray(i * 16, i * 16 + 16));
-        // The host copies back only the bones physics can write — the bones of
-        // dynamic bodies. Kinematic bones must NOT round-trip: in the pipelined
-        // protocol they would drag a stale (frame-old) pose over the live one.
-        const dynamicBones = [];
-        for (const rb of msg.rigidbodies) {
-            if (rb.type === RigidbodyType.Dynamic && rb.mass > 0 && rb.boneIndex >= 0)
-                dynamicBones.push(rb.boneIndex);
-        }
-        ctx.postMessage({ cmd: "ready", dynamicBones });
-        return;
-    }
-    if (!physics)
-        return;
-    const incoming = new Float32Array(msg.bones);
-    pose.set(incoming);
-    const t0 = performance.now();
-    if (msg.cmd === "step")
-        physics.step(msg.dt, mats, inverseBind);
-    else
-        physics.reset(mats);
-    const stepMs = performance.now() - t0;
-    incoming.set(pose);
-    ctx.postMessage({ cmd: "stepped", bones: msg.bones, stepMs }, [msg.bones]);
-};

package/dist/physics/profile.d.ts

@@ -1,18 +0,0 @@
-declare class PhysicsProfiler {
-    enabled: boolean;
-    private sums;
-    private counts;
-    begin(): number;
-    end(label: string, t0: number): void;
-    record(label: string, ms: number): void;
-    snapshot(): Record<string, {
-        avgMs: number;
-        calls: number;
-        totalMs: number;
-    }>;
-    reset(): void;
-}
-export declare const profiler: PhysicsProfiler;
-export type ProfileSnapshot = ReturnType<PhysicsProfiler["snapshot"]>;
-export {};
-//# sourceMappingURL=profile.d.ts.map

package/dist/physics/profile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/physics/profile.ts"],"names":[],"mappings":"AAIA,cAAM,eAAe;IACnB,OAAO,UAAQ;IACf,OAAO,CAAC,IAAI,CAA8C;IAC1D,OAAO,CAAC,MAAM,CAA8C;IAE5D,KAAK,IAAI,MAAM;IAIf,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IASpC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAQvC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAU7E,KAAK,IAAI,IAAI;CAId;AAED,eAAO,MAAM,QAAQ,iBAAwB,CAAA;AAC7C,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAA"}

package/dist/physics/profile.js

@@ -1,44 +0,0 @@
-// Per-phase wall-clock accumulator. Off by default — when `enabled` is false,
-// begin()/end() short-circuit so production has zero overhead. Toggle via
-// `RezePhysics.setProfileEnabled(true)` and read with `getProfile()`.
-class PhysicsProfiler {
-    constructor() {
-        this.enabled = false;
-        this.sums = Object.create(null);
-        this.counts = Object.create(null);
-    }
-    begin() {
-        return this.enabled ? performance.now() : 0;
-    }
-    end(label, t0) {
-        if (!this.enabled)
-            return;
-        const dt = performance.now() - t0;
-        this.sums[label] = (this.sums[label] ?? 0) + dt;
-        this.counts[label] = (this.counts[label] ?? 0) + 1;
-    }
-    // Direct accumulator for durations not measured via begin()/end() — used by
-    // GPU timestamp readback, which arrives async after the frame has ended.
-    record(label, ms) {
-        if (!this.enabled)
-            return;
-        this.sums[label] = (this.sums[label] ?? 0) + ms;
-        this.counts[label] = (this.counts[label] ?? 0) + 1;
-    }
-    // Snapshot since last reset(). avgMs is per call; totalMs is the cumulative
-    // window cost — divide by elapsed wall time to get a "% of frame budget".
-    snapshot() {
-        const out = {};
-        for (const k in this.sums) {
-            const total = this.sums[k];
-            const calls = this.counts[k];
-            out[k] = { avgMs: calls > 0 ? total / calls : 0, calls, totalMs: total };
-        }
-        return out;
-    }
-    reset() {
-        this.sums = Object.create(null);
-        this.counts = Object.create(null);
-    }
-}
-export const profiler = new PhysicsProfiler();

package/dist/physics/worker-physics.d.ts

@@ -1,28 +0,0 @@
-import type { Rigidbody, Joint } from "./types";
-import type { Mat4 } from "../math";
-export declare class WorkerPhysics {
-    private readonly worker;
-    private dynamicBones;
-    private readonly boneCount;
-    /** Transfer buffer when idle; null while a step is in flight. */
-    private buf;
-    /** Latest completed pose from the worker (copied out of the transfer buffer). */
-    private readonly result;
-    private hasResult;
-    private pendingDt;
-    private queuedReset;
-    /** Worker-side cost of the last completed step — for engine stats. */
-    stepMs: number;
-    private constructor();
-    static supported(): boolean;
-    static create(rigidbodies: Rigidbody[], joints: Joint[], inverseBind: Float32Array): Promise<WorkerPhysics>;
-    /** Same signature as RezePhysics.step — the engine cannot tell them apart.
-     *  (inverseBind was shipped to the worker at init; the param is unused.) */
-    step(dt: number, boneWorldMatrices: Mat4[], _inverseBind: Float32Array): void;
-    /** Reset rides the same pipeline: the next posted frame carries a reset
-     *  command instead of a step, and stale results stop applying immediately. */
-    reset(boneWorldMatrices: Mat4[]): void;
-    dispose(): void;
-    private onStepped;
-}
-//# sourceMappingURL=worker-physics.d.ts.map

package/dist/physics/worker-physics.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker-physics.d.ts","sourceRoot":"","sources":["../../src/physics/worker-physics.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAYnC,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAClC,iEAAiE;IACjE,OAAO,CAAC,GAAG,CAAoB;IAC/B,iFAAiF;IACjF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,WAAW,CAAQ;IAC3B,sEAAsE;IACtE,MAAM,SAAI;IAEV,OAAO;IAOP,MAAM,CAAC,SAAS,IAAI,OAAO;IAI3B,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,SAAS,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,WAAW,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IA6B3G;gFAC4E;IAC5E,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,YAAY,EAAE,YAAY,GAAG,IAAI;IAuB7E;kFAC8E;IAC9E,KAAK,CAAC,iBAAiB,EAAE,IAAI,EAAE,GAAG,IAAI;IAOtC,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,SAAS;CAQlB"}

package/dist/physics/worker-physics.js

@@ -1,91 +0,0 @@
-export class WorkerPhysics {
-    constructor(worker, boneCount) {
-        this.dynamicBones = [];
-        this.hasResult = false;
-        this.pendingDt = 0;
-        this.queuedReset = false;
-        /** Worker-side cost of the last completed step — for engine stats. */
-        this.stepMs = 0;
-        this.worker = worker;
-        this.boneCount = boneCount;
-        this.buf = new ArrayBuffer(boneCount * 64);
-        this.result = new Float32Array(boneCount * 16);
-    }
-    static supported() {
-        return typeof Worker !== "undefined";
-    }
-    static create(rigidbodies, joints, inverseBind) {
-        return new Promise((resolve, reject) => {
-            let worker;
-            try {
-                worker = new Worker(new URL("./physics.worker.js", import.meta.url), { type: "module" });
-            }
-            catch (e) {
-                reject(e instanceof Error ? e : new Error(String(e)));
-                return;
-            }
-            const wp = new WorkerPhysics(worker, inverseBind.length / 16);
-            const fail = (message) => {
-                worker.terminate();
-                reject(new Error(message));
-            };
-            worker.onerror = (e) => fail(`physics worker failed to boot: ${e.message || "worker error"}`);
-            worker.onmessage = (ev) => {
-                if (ev.data?.cmd !== "ready")
-                    return;
-                wp.dynamicBones = ev.data.dynamicBones;
-                worker.onmessage = (m) => wp.onStepped(m);
-                worker.onerror = null;
-                resolve(wp);
-            };
-            // Rigidbody/Joint carry only data (Vec3/Mat4 fields clone as plain
-            // objects with the same fields — the physics constructor reads fields,
-            // never methods), so structuredClone is a faithful serializer.
-            worker.postMessage({ cmd: "init", rigidbodies, joints, inverseBind: inverseBind.slice() });
-        });
-    }
-    /** Same signature as RezePhysics.step — the engine cannot tell them apart.
-     *  (inverseBind was shipped to the worker at init; the param is unused.) */
-    step(dt, boneWorldMatrices, _inverseBind) {
-        this.pendingDt += dt;
-        // Apply the newest completed simulation onto this frame's pose. Dynamic
-        // bones only: kinematic bones must keep the LIVE animation pose.
-        if (this.hasResult) {
-            const r = this.result;
-            for (const bi of this.dynamicBones) {
-                boneWorldMatrices[bi].values.set(r.subarray(bi * 16, bi * 16 + 16));
-            }
-        }
-        if (this.buf === null)
-            return; // worker mid-step: dt accumulated for the next post
-        const flat = new Float32Array(this.buf);
-        const n = Math.min(this.boneCount, boneWorldMatrices.length);
-        for (let i = 0; i < n; i++)
-            flat.set(boneWorldMatrices[i].values, i * 16);
-        this.worker.postMessage({ cmd: this.queuedReset ? "reset" : "step", dt: this.pendingDt, bones: this.buf }, [this.buf]);
-        this.buf = null;
-        this.pendingDt = 0;
-        this.queuedReset = false;
-    }
-    /** Reset rides the same pipeline: the next posted frame carries a reset
-     *  command instead of a step, and stale results stop applying immediately. */
-    reset(boneWorldMatrices) {
-        this.queuedReset = true;
-        this.hasResult = false;
-        // Post right away if idle — reuse step's snapshot/post path with dt 0.
-        if (this.buf !== null)
-            this.step(0, boneWorldMatrices, undefined);
-    }
-    dispose() {
-        this.worker.terminate();
-    }
-    onStepped(ev) {
-        const d = ev.data;
-        if (d?.cmd !== "stepped")
-            return;
-        this.buf = d.bones;
-        this.stepMs = d.stepMs;
-        this.result.set(new Float32Array(this.buf));
-        this.hasResult = true;
-    }
-}