reze-engine 0.50.2 → 0.50.3

package/src/engine.ts

@@ -1232,6 +1232,8 @@ interface EffectInstance {
   lights: {
     pipeline: GPUComputePipeline
     bind: GPUBindGroup
+    /** Kept so `bind` can be rebuilt when a shared buffer it names is replaced. */
+    layout: GPUBindGroupLayout
     uniform: GPUBuffer
     data: Float32Array<ArrayBuffer>
     /** How many slots it asked for. Its base is assigned by the engine and can
@@ -1387,6 +1389,24 @@ export class Engine {
   // the fragment shader and treats missing dst.a as 1, so the blend math is
   // unchanged).
   private hdrFormat: GPUTextureFormat = "rgba16float"
+  /**
+   * Force the HDR format instead of taking the device's answer. Null = probe,
+   * which is what ships.
+   *
+   * A diagnostic, and deliberately a coarse one. The choice above is the ONE
+   * render-target difference between a Safari device and a desktop Chrome that
+   * lacks the feature, which makes it the first thing to eliminate when
+   * something renders correctly on one and not the other — and specifically when
+   * the something involves alpha, because rg11b10ufloat is the path with no
+   * alpha channel to carry it. Setting this to "rgba16float" on the device puts
+   * Safari back on the desktop's path at the cost of the tile-memory win, so a
+   * symptom that survives is not about the format and a symptom that vanishes
+   * is.
+   *
+   * Static, like MRT_IDS: read once in init(), before any texture or pipeline
+   * exists, so there is no such thing as changing it on a live engine.
+   */
+  static HDR_FORMAT_OVERRIDE: GPUTextureFormat | null = null
   /** Main-pass depth. Float when the adapter offers depth32float-stencil8, which
    *  is also what makes reversed-Z worth switching on. */
   private depthFormat: GPUTextureFormat = "depth24plus-stencil8"
@@ -2216,11 +2236,10 @@ export class Engine {
    * sibling of addGround's own options. False when there is no ground.
    *
    * ON OR OFF, deliberately not a strength: the reflection is an independent
-   * LAYER over the floor surface, and it shows whatever the ground's opacity
-   * is — a mirror you can hide by making the floor solid is not a switch, it
-   * is a second strength dial wearing a boolean's clothes. Blur 0 is a
-   * polished mirror; 1 samples the softest level, scaled by how far the
-   * reflected geometry sits behind the surface.
+   * LAYER beneath the floor surface, and how much of it shows is the ground's
+   * own opacity covering it. Blur 0 is a polished mirror; 1 samples the
+   * softest level, scaled by how far the reflected geometry sits behind the
+   * surface.
    */
   setGroundMirror(on: boolean, blur?: number): boolean {
     if (!this.groundShadowMaterialBuffer) return false
@@ -2542,6 +2561,72 @@ export class Engine {
     }
   }
 
+  /**
+   * The grid mount's bind group for one parity.
+   *
+   * A method rather than a closure at the creation site because the SET of
+   * buffers in here is a contract with two parties: the grid is built once, and
+   * rebuilt whenever a shared buffer it names is replaced (see
+   * rebindSharedBuffers). Written twice, the rebuild silently keeps a binding
+   * the creation grew — and a bind group that names a destroyed buffer does not
+   * fail where it was written, it fails at the next submit.
+   */
+  private gridBindGroup(
+    g: { layout: GPUBindGroupLayout; uniform: GPUBuffer; read: [GPUTextureView, GPUTextureView]; textures: [GPUTexture, GPUTexture] },
+    i: number,
+  ): GPUBindGroup {
+    return this.device.createBindGroup({
+      layout: g.layout,
+      entries: [
+        { binding: 0, resource: { buffer: g.uniform } },
+        { binding: 1, resource: g.read[i] },
+        { binding: 2, resource: this.simSampler },
+        { binding: 3, resource: g.textures[1 - i].createView() },
+        { binding: 4, resource: { buffer: this.castBuffer } },
+        { binding: 5, resource: { buffer: this.audioBuffer } },
+        { binding: 6, resource: { buffer: this.compositeUniformBuffer } },
+        { binding: 7, resource: { buffer: this.midiBuffer } },
+        { binding: 8, resource: { buffer: this.lyricsBuffer } },
+      ],
+    })
+  }
+
+  /**
+   * Re-point EVERY bind group that names a shared scene buffer at the buffer
+   * that is there NOW.
+   *
+   * setAudioData and setMidiNotes do not write their buffer, they REPLACE it:
+   * the payload is a different length each time, so the old one is destroyed and
+   * a new one takes its place. Every bind group built before that moment still
+   * names the dead buffer, and a bind group is not re-read — it holds the
+   * resource it was given. The failure is therefore not at the swap but one
+   * frame later, as `[Buffer "score"] used in submit while destroyed`, with the
+   * scene dead and nothing pointing at the setter that did it.
+   *
+   * Both setters used to rebind three of the six families that hold these
+   * buffers — composite, ribbons, particles — and miss the field mount, the grid
+   * mount and the light emitter. Which is to say it worked for every effect that
+   * happened not to have a field, and a falling-note effect is exactly the kind
+   * that does. So the list lives HERE, once, and both setters call it: the
+   * question "who holds this buffer?" now has one place to be answered, and the
+   * next binding added is added to a list that everything already consults.
+   */
+  private rebindSharedBuffers(): void {
+    this.rebuildCompositeBindGroup()
+    this.rebindTrails()
+    this.rebuildFieldBindGroup()
+    for (const e of this.effects) {
+      if (e.particles) {
+        const b = e.particles.rebind()
+        e.particles.computeBind = b.computeBind
+        e.particles.renderBind = b.renderBind
+        e.particles.mirrorRenderBind = b.mirrorRenderBind
+      }
+      if (e.grid) e.grid.binds = [this.gridBindGroup(e.grid, 0), this.gridBindGroup(e.grid, 1)]
+      if (e.lights) e.lights.bind = this.lightEmitBindGroup(e.lights.layout, e.lights.uniform)
+    }
+  }
+
   /**
    * Set a 360° backdrop from an equirectangular (2:1) image — a PhotoDome-style
    * skybox at infinity, sampled per-pixel by view direction so it follows the
@@ -3402,7 +3487,16 @@ export class Engine {
       uniform.destroy()
       return { ok: false, diagnostics: [scoped.message] }
     }
-    const bind = this.device.createBindGroup({
+    const bind = this.lightEmitBindGroup(layout, uniform)
+    // The layout travels with the state so the emitter can be rebound when a
+    // shared buffer under it is replaced — see rebindSharedBuffers.
+    return { ok: true, state: { pipeline, bind, layout, uniform, data, count } }
+  }
+
+  /** The light emitter's bind group. One author, for the reason gridBindGroup
+   *  gives: it is built once and rebuilt on every shared-buffer swap. */
+  private lightEmitBindGroup(layout: GPUBindGroupLayout, uniform: GPUBuffer): GPUBindGroup {
+    return this.device.createBindGroup({
       label: "light emit bind",
       layout,
       entries: [
@@ -3415,7 +3509,6 @@ export class Engine {
         { binding: 6, resource: { buffer: this.lyricsBuffer } },
       ],
     })
-    return { ok: true, state: { pipeline, bind, uniform, data, count } }
   }
 
   /**
@@ -3851,21 +3944,7 @@ export class Engine {
         return { ok: false, diagnostics: [scoped.message] }
       }
       // One per parity: binds[i] READS textures[i] and WRITES the other.
-      const bindFor = (i: number) =>
-        this.device.createBindGroup({
-          layout,
-          entries: [
-            { binding: 0, resource: { buffer: uniform } },
-            { binding: 1, resource: read[i] },
-            { binding: 2, resource: this.simSampler },
-            { binding: 3, resource: textures[1 - i].createView() },
-            { binding: 4, resource: { buffer: this.castBuffer } },
-            { binding: 5, resource: { buffer: this.audioBuffer } },
-            { binding: 6, resource: { buffer: this.compositeUniformBuffer } },
-            { binding: 7, resource: { buffer: this.midiBuffer } },
-            { binding: 8, resource: { buffer: this.lyricsBuffer } },
-          ],
-        })
+      const bindFor = (i: number) => this.gridBindGroup({ layout, uniform, read, textures }, i)
       return {
         ok: true,
         state: {
@@ -4109,6 +4188,16 @@ export class Engine {
     }
     this.device = device
     if (hasRg11b10) this.hdrFormat = "rg11b10ufloat"
+    // The override has the last word, including over a device that would have
+    // been left on the fallback anyway — asking for the format you are already
+    // getting is a no-op, not a contradiction. See HDR_FORMAT_OVERRIDE.
+    if (Engine.HDR_FORMAT_OVERRIDE) {
+      this.hdrFormat = Engine.HDR_FORMAT_OVERRIDE
+      // Only when forced. The probed answer is the normal one and does not need
+      // announcing on every boot; a forced one is a state someone set and will
+      // want confirmed, and is the state they will forget they left on.
+      console.info(`[reze] HDR target forced to ${this.hdrFormat}`)
+    }
     // The id attachment, if this device will multisample a uint texture at the
     // pass's sample count. Probed by ASKING — creating one inside an error
     // scope — rather than by reading a feature flag, because there is no
@@ -6137,17 +6226,7 @@ export class Engine {
     }
     // Every consumer holds the buffer by reference in a bind group; all of them
     // re-bind so audio arriving after an effect (or before one) both work.
-    this.rebuildCompositeBindGroup()
-    this.rebindTrails()
-    // EVERY effect: a buffer arriving after install must reach all of them, or
-    // the ones installed earlier keep reading the buffer this replaced.
-    for (const e of this.effects) {
-      if (!e.particles) continue
-      const b = e.particles.rebind()
-      e.particles.computeBind = b.computeBind
-      e.particles.renderBind = b.renderBind
-      e.particles.mirrorRenderBind = b.mirrorRenderBind
-    }
+    this.rebindSharedBuffers()
   }
 
   /**
@@ -6248,17 +6327,7 @@ export class Engine {
     // Same reason as setAudioData: every consumer holds the buffer by reference,
     // so all of them re-bind and a score arriving before or after an effect both
     // work.
-    this.rebuildCompositeBindGroup()
-    this.rebindTrails()
-    // EVERY effect: a buffer arriving after install must reach all of them, or
-    // the ones installed earlier keep reading the buffer this replaced.
-    for (const e of this.effects) {
-      if (!e.particles) continue
-      const b = e.particles.rebind()
-      e.particles.computeBind = b.computeBind
-      e.particles.renderBind = b.renderBind
-      e.particles.mirrorRenderBind = b.mirrorRenderBind
-    }
+    this.rebindSharedBuffers()
   }
 
   /**

package/src/shaders/passes/ground.ts

@@ -186,8 +186,8 @@ ${sceneFsOutWgsl()}@fragment fn fs(i: VO) -> FSOut {
   // reflection was rendered by the MIRROR camera, so projecting this
   // fragment's world position through that camera yields exactly the texel
   // where its reflection landed — projective mapping, no screen-space guess.
-  // There is deliberately NO strength dial, and no dependence on the floor's
-  // opacity either: mirror is on or off, and when it is on it SHOWS — the same
+  // There is deliberately NO strength dial: mirror is on or off, and how much
+  // of it shows is the SURFACE's own opacity covering it — the same
   // independence the grid won earlier. The branch is on a uniform, so the
   // whole cost vanishes for the scenes that leave it off.
   var reflShadowed = vec3f(0.0);
@@ -250,28 +250,18 @@ ${sceneFsOutWgsl()}@fragment fn fs(i: VO) -> FSOut {
   // and a catcher stacked on top would darken the same shadow twice.
   let catchA = dark * 0.65 * edgeFade * (1.0 - material.opacity) * (1.0 - material.mirror);
 
-  // FOUR LAYERS, premultiplied, bottom to top: received shadow, ground
-  // surface, reflection, grid. Each with its own coverage, none scaling
-  // another.
-  //
-  // THE MIRROR SITS ABOVE THE SURFACE, and that ordering is the whole rule.
-  // Underneath it, the floor's own opacity covered the reflection — and did it
-  // inconsistently, because BOTH layers carry the radial edgeFade: at opacity
-  // 1 the surface stopped covering wherever the plane fades out, so the
-  // reflection returned along the rim and read as a bug that came and went
-  // with the camera angle. What a mirror shows cannot depend on how solid the
-  // thing it is made of happens to be.
-  //
-  // The catcher's order against it no longer matters — catchA already carries
-  // (1 - mirror), so the two are never both present.
-  var pm = vec3f(0.0);
-  var cov = catchA;
-  // Surface over the received shadow.
+  // FOUR LAYERS, premultiplied, bottom to top: reflection, received shadow,
+  // ground surface, grid. Each with its own coverage, none scaling another —
+  // ground opacity REVEALS the mirror rather than the mirror carrying a
+  // strength of its own.
+  var pm = reflShadowed * mirrA;
+  var cov = mirrA;
+  // Shadow catcher over the reflection-or-nothing: black, it covers.
+  pm = pm * (1.0 - catchA);
+  cov = catchA + cov * (1.0 - catchA);
+  // Surface over shadow.
   pm = baseColor * surfA + pm * (1.0 - surfA);
   cov = surfA + cov * (1.0 - surfA);
-  // The reflection over the surface, at full strength whatever the opacity.
-  pm = reflShadowed * mirrA + pm * (1.0 - mirrA);
-  cov = mirrA + cov * (1.0 - mirrA);
   // Grid over surface. Unshadowed, as it has always been — a painted line reads
   // as paint, and darkening it was never what the mix did either.
   pm = material.gridLineColor * gridA + pm * (1.0 - gridA);

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"}