reze-engine 0.22.0 → 0.23.0

package/src/engine.ts

@@ -84,7 +84,7 @@ const PRESET_NAME_HINTS: Array<[MaterialPreset, string[]]> = [
   ],
   ["hair", ["前髪", "後髪", "髪", "髮", "头发", "頭髪", "もみあげ", "アホ毛", "ヘア", "hair", "ahoge", "bang"]],
   ["body", ["肌", "皮肤", "skin"]],
-  ["metal", ["金属", "メタル", "metal"]],
+  ["metal", ["金属", "メタル", "metal", "earring", "耳环", "耳環"]],
   [
     "cloth_smooth",
     [
@@ -103,15 +103,20 @@ const PRESET_NAME_HINTS: Array<[MaterialPreset, string[]]> = [
       "飾",
       "饰",
       "尾",
+      "套", // 外套 (coat), 手套 (gloves)
+      "腿", // 腿环 (leg ring/garter) and other leg-wear accessories
       "skirt",
       "dress",
       "ribbon",
       "sleeve",
       "shoes",
+      "shirt",
+      "short", // shorts
       "boot",
       "hat",
       "cloth",
       "accessor",
+      "trigger",
     ],
   ],
 ]
@@ -1703,13 +1708,35 @@ export class Engine {
     window.addEventListener("mouseup", this.handleGizmoMouseUp)
   }
 
-  private handleResize() {
-    const displayWidth = this.canvas.clientWidth
-    const displayHeight = this.canvas.clientHeight
+  /** When set, render resolution is pinned to this size instead of tracking the
+   *  canvas's CSS size × devicePixelRatio (see setRenderSize). */
+  private fixedRenderSize: { width: number; height: number } | null = null
+
+  /**
+   * Pin the render resolution (canvas backing store + every render target) to an
+   * explicit size, decoupled from the canvas's CSS layout size — for offline
+   * rendering at arbitrary resolution (video export). On screen the browser scales
+   * the buffer to the layout box, so the canvas may display letterboxed/stretched
+   * while pinned; hosts typically cover it with an export overlay. Pass null to
+   * return to CSS-size × devicePixelRatio tracking. Applies immediately (targets
+   * rebuild before this returns), so the next render() is at the new size.
+   */
+  setRenderSize(width: number, height: number): void
+  setRenderSize(size: null): void
+  setRenderSize(widthOrNull: number | null, height?: number): void {
+    this.fixedRenderSize =
+      widthOrNull === null
+        ? null
+        : { width: Math.max(1, Math.floor(widthOrNull)), height: Math.max(1, Math.floor(height ?? 1)) }
+    this.resizePending = false
+    this.handleResize()
+  }
 
+  private handleResize() {
+    // Fixed override (offline/video rendering) wins; otherwise track CSS size × dpr.
     const dpr = window.devicePixelRatio || 1
-    const width = Math.floor(displayWidth * dpr)
-    const height = Math.floor(displayHeight * dpr)
+    const width = this.fixedRenderSize ? this.fixedRenderSize.width : Math.floor(this.canvas.clientWidth * dpr)
+    const height = this.fixedRenderSize ? this.fixedRenderSize.height : Math.floor(this.canvas.clientHeight * dpr)
 
     if (!this.multisampleTexture || this.canvas.width !== width || this.canvas.height !== height) {
       this.canvas.width = width
@@ -3902,15 +3929,32 @@ export class Engine {
   render() {
     if (!this.multisampleTexture || !this.camera || !this.device) return
 
+    const currentTime = performance.now()
+    const deltaTime = this.lastFrameTime > 0 ? (currentTime - this.lastFrameTime) / 1000 : 0.016
+    this.lastFrameTime = currentTime
+    this.renderWithDelta(deltaTime)
+  }
+
+  /**
+   * Render one frame advancing every clock — animation, physics, tweens, and the
+   * camera VMD — by exactly `deltaSeconds`, independent of wall time. This is the
+   * offline-rendering primitive (video export): call it N times with 1/fps and the
+   * result is deterministic whether the machine renders faster or slower than
+   * realtime. Also resets the realtime clock so a later render() (returning to the
+   * live loop) doesn't see the export's wall-clock gap as one giant delta.
+   */
+  renderFrame(deltaSeconds: number) {
+    if (!this.multisampleTexture || !this.camera || !this.device) return
+    this.lastFrameTime = performance.now()
+    this.renderWithDelta(deltaSeconds)
+  }
+
+  private renderWithDelta(deltaTime: number) {
     if (this.resizePending) {
       this.resizePending = false
       this.handleResize()
     }
 
-    const currentTime = performance.now()
-    const deltaTime = this.lastFrameTime > 0 ? (currentTime - this.lastFrameTime) / 1000 : 0.016
-    this.lastFrameTime = currentTime
-
     const hasModels = this.modelInstances.size > 0
     if (hasModels) {
       this.updateInstances(deltaTime)

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/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();