reze-engine 0.42.0 → 0.42.2

package/src/engine.ts

@@ -905,7 +905,9 @@ export class Engine {
   private bgParamsDummyBuffer!: GPUBuffer
   private compositePipelineLayout!: GPUPipelineLayout
   /** time=0 origin for the active effect — reset each setEffect. */
-  private effectEpochMs = 0
+  /** Scene-clock reading when the current effect was installed. The effect's
+   *  `time` is measured from here — see where it is written. */
+  private effectEpochScene = 0
   private compositeBloomView: GPUTextureView | null = null
 
   // EEVEE-style bloom pyramid (mirrors Blender 3.6 effect_bloom_frag.glsl):
@@ -1495,7 +1497,7 @@ export class Engine {
     this.anchorTrail.clear()
     this.compositePipelineIdentity = identity
     this.compositePipelineGamma = gamma
-    this.effectEpochMs = performance.now()
+    this.effectEpochScene = this.sceneClock
     this.rebuildCompositeBindGroup()
     this.writeCompositeViewUniforms()
     return { ok: true, diagnostics: [], mounts }
@@ -6271,7 +6273,16 @@ export class Engine {
       u[22] = v[10]
       u[23] = 0
       // Effect clock + canvas size (viewU[6]) — written on the same refresh.
-      u[24] = (performance.now() - this.effectEpochMs) / 1000
+      // The effect clock, on the SCENE's time rather than the wall's.
+      //
+      // renderFrame() drives offline export as fast as the encoder will take
+      // frames, so wall time races ahead of the video's own time — a rain effect
+      // fell at the wrong rate in the export, a twinkle blinked at the wrong
+      // speed, and none of it matched what the editor had shown. Measured
+      // against the accumulated frame delta, an effect animates identically in
+      // the editor, in an export, and in a re-export, which is the same rule the
+      // trails already followed.
+      u[24] = this.sceneClock - this.effectEpochScene
       u[26] = this.canvas.width
       u[27] = this.canvas.height
       // Camera world position (viewU[10]) — the other half of bgWorldPos. It

package/src/physics/physics.ts

@@ -28,8 +28,28 @@ export class RezePhysics {
   private readonly maxSubSteps = 6
   /** EMA of one world.step's CPU cost; drives catch-up load shedding. */
   private stepCostEmaMs = 0.5
-  /** Max ms a single frame may spend catching up physics before shedding. */
-  private readonly stepBudgetMs = 8
+  /**
+   * Share of the frame a single frame may spend catching physics up before it
+   * sheds the backlog instead.
+   *
+   * A FRACTION, not a fixed millisecond count, and that distinction is the whole
+   * point. It used to be a flat 8ms — about half a frame at 60Hz, which is what
+   * it was tuned against. The moment anything else made frames longer (a heavy
+   * effect, a weak GPU) the frame grew and the budget did not, so at 30Hz
+   * physics was allowed a QUARTER of the frame while needing twice the
+   * substeps. It shed work it could easily afford, and shedding discards time —
+   * so physics ran fractionally slow-motion against a character moving at full
+   * speed, which is exactly what hair and skirts lagging behind the body looks
+   * like.
+   *
+   * At 60Hz this reproduces the old 8ms almost exactly, so nothing that was
+   * tuned against it moves.
+   */
+  private readonly stepBudgetFraction = 0.5
+  /** Floor and ceiling on that share: a very short frame still gets enough to
+   *  make progress, and a very long one must not spend all of itself here. */
+  private readonly stepBudgetMinMs = 8
+  private readonly stepBudgetMaxMs = 24
 
   // Fixed-timestep render interpolation ("Fix Your Timestep"): the dynamic body pose is
   // rendered as lerp(prev, curr, alpha) between the last two completed substeps, where
@@ -260,7 +280,11 @@ export class RezePhysics {
     // state (6× step cost every frame; iOS "starts smooth, then stays slow").
     // Catching up must never cost more than a frame-budget slice: shed the backlog
     // instead (physics runs fractionally slow-motion for a beat; framerate holds).
-    const affordable = Math.max(1, Math.floor(this.stepBudgetMs / Math.max(0.05, this.stepCostEmaMs)))
+    const budgetMs = Math.min(
+      this.stepBudgetMaxMs,
+      Math.max(this.stepBudgetMinMs, dt * 1000 * this.stepBudgetFraction),
+    )
+    const affordable = Math.max(1, Math.floor(budgetMs / Math.max(0.05, this.stepCostEmaMs)))
     if (nSub > affordable) nSub = affordable
     for (let k = 0; k < nSub; k++) {
       this.savePrevState()

package/src/vmd-writer.ts

@@ -1,4 +1,4 @@
-import { AnimationClip, BoneInterpolation } from "./animation"
+import { AnimationClip, BoneInterpolation, ControlPoint } from "./animation"
 
 const VMD_HEADER = "Vocaloid Motion Data 0002"
 const HEADER_SIZE = 30
@@ -189,34 +189,34 @@ function writeFixedShiftJIS(buffer: ArrayBuffer, offset: number, str: string, ma
 
 /**
  * Convert BoneInterpolation back to the 64-byte raw VMD interpolation table.
- * Exact inverse of rawInterpolationToBoneInterpolation in animation.ts.
+ * Exact inverse of rawInterpolationToBoneInterpolation in animation.ts — see the
+ * layout note there for why the record is written four times.
  */
 function boneInterpolationToRaw(interp: BoneInterpolation): Uint8Array {
-  const raw = new Uint8Array(64)
+  // The one 16-byte record: each channel's x1 / y1 / x2 / y2, interleaved.
+  const record = new Uint8Array(16)
+  const put = (c: number, cp: ControlPoint[]): void => {
+    record[c] = cp[0].x
+    record[c + 4] = cp[0].y
+    record[c + 8] = cp[1].x
+    record[c + 12] = cp[1].y
+  }
+  put(0, interp.translationX)
+  put(1, interp.translationY)
+  put(2, interp.translationZ)
+  put(3, interp.rotation)
 
-  // Rotation: [{x: raw[0], y: raw[2]}, {x: raw[1], y: raw[3]}]
-  raw[0] = interp.rotation[0].x
-  raw[1] = interp.rotation[1].x
-  raw[2] = interp.rotation[0].y
-  raw[3] = interp.rotation[1].y
-
-  // TranslationX: [{x: raw[0], y: raw[4]}, {x: raw[8], y: raw[12]}]
-  // raw[0] already set by rotation (shared byte)
-  raw[4] = interp.translationX[0].y
-  raw[8] = interp.translationX[1].x
-  raw[12] = interp.translationX[1].y
-
-  // TranslationY: [{x: raw[16], y: raw[20]}, {x: raw[24], y: raw[28]}]
-  raw[16] = interp.translationY[0].x
-  raw[20] = interp.translationY[0].y
-  raw[24] = interp.translationY[1].x
-  raw[28] = interp.translationY[1].y
-
-  // TranslationZ: [{x: raw[32], y: raw[36]}, {x: raw[40], y: raw[44]}]
-  raw[32] = interp.translationZ[0].x
-  raw[36] = interp.translationZ[0].y
-  raw[40] = interp.translationZ[1].x
-  raw[44] = interp.translationZ[1].y
+  // Copy `r` starts at byte r * 16 and holds record[r..15], so channel r's own
+  // bytes land where the reader (and MMD, and babylon-mmd) look for them.
+  const raw = new Uint8Array(64)
+  for (let r = 0; r < 4; r++) {
+    for (let i = r; i < 16; i++) raw[r * 16 + (i - r)] = record[i]
+  }
+  // Bytes 2 and 3 of the first copy are not interpolation — they are the physics
+  // toggle. 0x0000 is "physics on", which is what both reference motions carry and
+  // the only state a clip can round-trip: BoneInterpolation does not model the flag.
+  raw[2] = 0
+  raw[3] = 0
 
   return raw
 }

package/dist/physics/autofit.d.ts

@@ -1,147 +0,0 @@
-import { type Rigidbody } from "./types";
-import type { Skinning } from "../model";
-/**
- * Supplementary colliders fitted to the mesh a PMX rigid body fails to cover.
- *
- * PMX body proxies are bodies of revolution — 下半身 is a capsule lying
- * transversely across the hips, so its cross-section is a circle. A pelvis seen
- * from the side is not a circle, and across every rig measured the butt sits
- * 0.18–0.71 units OUTSIDE that capsule while the front is flush or inside. That
- * gap is where a skirt goes through a character: the cloth is resting correctly
- * on the collider it was given, and the collider stops half a unit short of the
- * skin.
- *
- * A rest offset cannot close it (see RigidBodyStore.restOffset) — it is one
- * scalar on a radially symmetric shape, and the error is asymmetric. Measured
- * on 托特's run cycle, the offset that clears the butt is 0.5, which is simply
- * the size of the missing geometry, and at that value the skirt stands off the
- * front and hips by the same 0.5.
- *
- * So fit the missing piece instead: take each bone-following body's own skinned
- * vertices, find the ones that escape its shape in a concentrated lobe, and fit
- * a capsule to that lobe. That is the fix riggers apply by hand, derived from
- * the mesh rather than guessed.
- *
- * Measured on 托特's run cycle, counting butt vertices swallowed by a cloth
- * body: 32.4 per frame with nothing, 30.9 with a 0.02 rest offset, 12.4 with
- * this pass, 10.4 with both.
- */
-export interface AutoFitOptions {
-    /** A vertex counts as protruding past this much (model units). Below it the
-     *  mesh is within authoring tolerance of the proxy and needs no help. */
-    minProtrusion?: number;
-    /**
-     * Ignore vertices further out than this multiple of the source shape's
-     * RADIUS (its smallest characteristic dimension).
-     *
-     * A coarse first cut at keeping hair and loose clothing out — anything
-     * standing further off the proxy than the proxy is wide is not skin. The
-     * discriminator that actually does the work is minConcentration.
-     */
-    maxProtrusionRatio?: number;
-    /** Fewer protruding vertices than this and it is a spike, not a region. */
-    minVertices?: number;
-    /**
-     * Per-axis quantile the fitted lobe's extent is clipped to, each end. A
-     * handful of stray vertices (a weight-painting slip, a seam) would otherwise
-     * stretch the capsule far past the surface everyone can see.
-     */
-    quantile?: number;
-    /** Skip the fit unless the capsule actually reaches this far past what is
-     *  already covered — otherwise it adds solver rows for nothing. */
-    minGain?: number;
-    /** How tightly the kept lobe's outward directions must agree, 0–1. A loose
-     *  sanity check; the real discriminator is minConcentration. */
-    minDirectionality?: number;
-    /** Vertices outside the dominant lobe, by this cosine, are not part of the
-     *  feature being fitted. */
-    lobeCos?: number;
-    /**
-     * How much deeper the fitted lobe must be than protrusion typically is on
-     * this body, averaged over the vertices that protrude at all.
-     *
-     * This is the guard that separates "the proxy is missing a lobe" from "the
-     * proxy is not a proxy for this mesh at all". A pelvis escapes its capsule by
-     * 0.53 at the back and 0.14 at the front, so the back lobe stands well clear
-     * of the average. Hair escapes the skull by a similar depth in every
-     * direction, so its deepest lobe is no deeper than typical and the ratio sits
-     * near 1. See the note at the meanProtrusion computation for what this
-     * deliberately refuses to fit.
-     *
-     * Without it the pass fits the hairstyle — measured on 托特, 頭 reports
-     * 3653 of 4669 vertices outside its capsule, and the fitted shape was a crate
-     * around the whole head. No threshold on depth or vertex count tells those
-     * two cases apart; concentration does.
-     */
-    minConcentration?: number;
-    /**
-     * How many capsules may be fitted to one body, each against what the previous
-     * ones already cover.
-     *
-     * One capsule inscribed in a lobe does not fill it — on 托特's butt a single
-     * fit removed 58% of the clipping and left the rest at the edges the capsule
-     * could not reach. Each further pass re-measures protrusion against the
-     * original shape UNION everything fitted so far, so it lands on whatever is
-     * still exposed instead of re-fitting the same bulge.
-     */
-    maxShapesPerBody?: number;
-    /**
-     * Quantile of the lobe's perpendicular spread used as the capsule radius.
-     *
-     * The clip-versus-float dial, and the one to reach for if a result looks
-     * wrong. Lower hugs the body: less standoff in idle, more clipping left. 1.0
-     * encloses the lobe entirely, which is what produced a visibly hovering
-     * skirt on 托特.
-     */
-    radiusQuantile?: number;
-    /**
-     * Fit only the deepest part of each lobe: points at least this fraction of
-     * the lobe's own maximum protrusion.
-     *
-     * A lobe tapers to nothing at its edges, and a capsule sized to span the
-     * whole thing has to be fat enough to reach the edges too. Fitting the deep
-     * core keeps each capsule small and lets a later pass handle the shallows
-     * with its own, which is both tighter and closer to what the surface is
-     * actually doing.
-     */
-    lobeDepthFraction?: number;
-}
-/** What the pass decided for one source body — surfaced so a rig can be
- *  inspected rather than silently rebuilt underneath its author. */
-export interface AutoFitResult {
-    /** Index of the body in the input array that this supplements. */
-    sourceIndex: number;
-    sourceName: string;
-    /** Vertices dominated by that body's bone, and how many were outside it. */
-    vertexCount: number;
-    protrudingCount: number;
-    /** Furthest any kept vertex sat outside the source shape. */
-    maxProtrusion: number;
-    /** How far the fitted capsule reaches past what was already covered. */
-    gain: number;
-    /** Length of the kept lobe's mean outward direction, 0–1. */
-    directionality: number;
-    /** Lobe depth over the body's average protrusion. See minConcentration. */
-    concentration: number;
-    /**
-     * Furthest the capsule's newly exposed surface sits from the skin it was
-     * fitted to — the amount cloth resting on it will stand off the body at the
-     * worst point, and the number to watch if a result looks puffy. Only the part
-     * reaching outside the source shape is measured; the rest is buried.
-     */
-    overshoot: number;
-    body: Rigidbody;
-}
-/**
- * Fit supplementary colliders for every bone-following body whose own mesh
- * escapes it.
- *
- * `vertices` is the model's interleaved vertex buffer (stride 8, position
- * first) and `skinning` its joints/weights — both in PMX bind pose, the same
- * space as `shapePosition` / `shapeRotation`, so nothing has to be skinned.
- *
- * Returns one entry per body it chose to supplement; the caller appends
- * `.body` to the rigid body list before constructing RezePhysics.
- */
-export declare function fitSupplementaryColliders(rigidbodies: Rigidbody[], vertices: Float32Array, skinning: Skinning, options?: AutoFitOptions): AutoFitResult[];
-//# sourceMappingURL=autofit.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"autofit.d.ts","sourceRoot":"","sources":["../../src/physics/autofit.ts"],"names":[],"mappings":"AACA,OAAO,EAAiC,KAAK,SAAS,EAAE,MAAM,SAAS,CAAA;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,cAAc;IAC7B;6EACyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;uEACmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;oEACgE;IAChE,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;gCAC4B;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;;;;;;;OASG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AA2BD;oEACoE;AACpE,MAAM,WAAW,aAAa;IAC5B,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,6DAA6D;IAC7D,aAAa,EAAE,MAAM,CAAA;IACrB,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAA;IACZ,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAA;IACtB,2EAA2E;IAC3E,aAAa,EAAE,MAAM,CAAA;IACrB;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,SAAS,CAAA;CAChB;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,SAAS,EAAE,EACxB,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,cAAmB,GAC3B,aAAa,EAAE,CA4CjB"}