reze-engine 0.50.3 → 0.50.5

package/src/model.ts

@@ -30,6 +30,10 @@ const _animSlerp = new Quat(0, 0, 0, 1)
 const _animInterpT = new Vec3(0, 0, 0)
 const _convOut = new Vec3(0, 0, 0)
 const _convMat = new Float32Array(16)
+// Scratch for the post-physics append recovery — see applyPhysicsAppend.
+const _appendBasisX = new Vec3(0, 0, 0)
+const _appendBasisY = new Vec3(0, 0, 0)
+const _appendBasisZ = new Vec3(0, 0, 0)
 // Blend-path scratch: per-entry sample target and the crossfade's two fixed entries.
 const _blendQ = new Quat(0, 0, 0, 1)
 const _blendT = new Vec3(0, 0, 0)
@@ -388,6 +392,15 @@ export class Model {
   // visited-array + closure. Order depends only on parentIndex (static), so this
   // reproduces the old recursion's finishing order exactly. See buildDeformOrder.
   private deformOrder!: Int32Array
+  /** 1 where the simulation overwrites the bone's world matrix. See setPhysicsDrivenBones. */
+  private physicsDriven: Uint8Array | null = null
+  /** Bones to recompute after a step, in deform order — null when no rig needs it. */
+  private physicsAppendOrder: Int32Array | null = null
+  /** Simulated bones something inherits from; their local rotation is recovered. */
+  private physicsAppendSources: Int32Array | null = null
+  /** Recovered post-step local rotations, kept OUT of localRotations on purpose. */
+  private appendRotOverride: Quat[] | null = null
+  private appendRotOverrideSet: Uint8Array | null = null
 
   // Bind-pose absolute (world) position per bone, xyz packed. Static (bindTranslation
   // accumulated down the hierarchy). Precomputed once so convertVMDTranslationToLocal
@@ -2612,7 +2625,141 @@ export class Model {
     }
   }
 
-  computeWorldMatrices(): void {
+  /**
+   * Which bones the physics simulation overwrites, and what that costs the
+   * append (付与) pass — the 胸 problem.
+   *
+   * PMX lets a bone inherit a fraction of another bone's rotation (付与親 /
+   * append parent). The pipeline computes that inheritance inside
+   * computeWorldMatrices, which runs BEFORE physics — and it reads the
+   * parent's LOCAL rotation, which physics never writes: the simulation
+   * publishes world matrices only. So when a rig hangs a bone off a simulated
+   * one, the inheritance saw the animated pose and nothing else, and the
+   * dependent bone sat still no matter how much the parent swung. Rigs that
+   * drive a chest this way — a simulated bone with the visible bones
+   * appending from it — produced no motion at all.
+   *
+   * The engine calls this once, after building the simulation, and it
+   * precomputes the whole answer: WHICH bones need revisiting after a step,
+   * in deform order. Everything downstream is a walk over that list.
+   */
+  setPhysicsDrivenBones(boneIndices: number[]): void {
+    const bones = this.skeleton.bones
+    const n = bones.length
+    this.physicsDriven = new Uint8Array(n)
+    for (const b of boneIndices) if (b >= 0 && b < n) this.physicsDriven[b] = 1
+
+    // Bones to recompute after a step: anything that INHERITS from a simulated
+    // bone, everything under it, and anything inheriting from those in turn.
+    // Simulated bones themselves are deliberately excluded — their world matrix
+    // IS the simulation's output, and recomputing it from a local pose the
+    // simulation never wrote would throw the step away.
+    const affected = new Uint8Array(n)
+    let changed = true
+    while (changed) {
+      changed = false
+      for (let k = 0; k < n; k++) {
+        const i = this.deformOrder[k]
+        if (affected[i] || this.physicsDriven[i]) continue
+        const b = bones[i]
+        const ap = b.appendParentIndex
+        const inheritsAffected =
+          (b.appendRotate || b.appendMove) && ap !== undefined && ap >= 0 && ap < n && (this.physicsDriven[ap] || affected[ap])
+        const parentAffected = b.parentIndex >= 0 && affected[b.parentIndex]
+        if (inheritsAffected || parentAffected) {
+          affected[i] = 1
+          changed = true
+        }
+      }
+    }
+
+    const order: number[] = []
+    for (let k = 0; k < n; k++) {
+      const i = this.deformOrder[k]
+      if (affected[i]) order.push(i)
+    }
+    this.physicsAppendOrder = order.length > 0 ? Int32Array.from(order) : null
+    // The simulated bones something actually inherits from — the only ones
+    // whose post-step local rotation has to be recovered below.
+    const sources = new Set<number>()
+    for (const i of order) {
+      const ap = bones[i].appendParentIndex
+      if (ap !== undefined && ap >= 0 && ap < n && this.physicsDriven[ap]) sources.add(ap)
+    }
+    this.physicsAppendSources = sources.size > 0 ? Int32Array.from(sources) : null
+    if (this.appendRotOverride === null && this.physicsAppendOrder) {
+      this.appendRotOverride = Array.from({ length: n }, () => Quat.identity())
+      this.appendRotOverrideSet = new Uint8Array(n)
+    }
+  }
+
+  /** The simulated bones that visible bones INHERIT from — the chest rig, in
+   *  one list. Empty unless setPhysicsDrivenBones found such a relationship. */
+  getAppendSourceBones(): number[] {
+    return this.physicsAppendSources ? Array.from(this.physicsAppendSources) : []
+  }
+
+  /**
+   * Re-run the append pass against the simulation's result. Call after a step.
+   *
+   * Two halves. First the simulated bones an append parent list names get their
+   * post-step LOCAL rotation recovered — physics published only world matrices,
+   * and the append math speaks local. The recovery is the ordinary change of
+   * basis: local = parentWorld⁻¹ · world, read back as a quaternion off the
+   * relative basis, which is exact for the rigid transforms these are.
+   *
+   * Then the dependent bones recompute, in deform order, reading that recovered
+   * rotation instead of the animated one. The recovered value lives in its OWN
+   * array rather than in localRotations, deliberately: localRotations is what
+   * next frame's pose blends against and what the simulation reads to build
+   * kinematic targets, and writing a simulation result back into it would make
+   * the animation chase its own tail.
+   */
+  applyPhysicsAppend(): void {
+    const order = this.physicsAppendOrder
+    const sources = this.physicsAppendSources
+    if (!order || !sources || !this.appendRotOverride || !this.appendRotOverrideSet) return
+    const bones = this.skeleton.bones
+    const worldMats = this.runtimeSkeleton.worldMatrices
+
+    this.appendRotOverrideSet.fill(0)
+    for (let s = 0; s < sources.length; s++) {
+      const i = sources[s]
+      const w = worldMats[i].values
+      const p = bones[i].parentIndex
+      // Columns of the bone's own basis, expressed in its parent's frame. With
+      // no parent the world basis already IS the local one.
+      let bx0 = w[0], bx1 = w[1], bx2 = w[2]
+      let by0 = w[4], by1 = w[5], by2 = w[6]
+      let bz0 = w[8], bz1 = w[9], bz2 = w[10]
+      if (p >= 0) {
+        const pm = worldMats[p].values
+        // parentᵀ · child, the rotation half of parentWorld⁻¹ · world: the
+        // parent basis is orthonormal, so its inverse is its transpose.
+        const r0 = bx0, r1 = bx1, r2 = bx2
+        bx0 = pm[0] * r0 + pm[1] * r1 + pm[2] * r2
+        bx1 = pm[4] * r0 + pm[5] * r1 + pm[6] * r2
+        bx2 = pm[8] * r0 + pm[9] * r1 + pm[10] * r2
+        const g0 = by0, g1 = by1, g2 = by2
+        by0 = pm[0] * g0 + pm[1] * g1 + pm[2] * g2
+        by1 = pm[4] * g0 + pm[5] * g1 + pm[6] * g2
+        by2 = pm[8] * g0 + pm[9] * g1 + pm[10] * g2
+        const b0 = bz0, b1 = bz1, b2 = bz2
+        bz0 = pm[0] * b0 + pm[1] * b1 + pm[2] * b2
+        bz1 = pm[4] * b0 + pm[5] * b1 + pm[6] * b2
+        bz2 = pm[8] * b0 + pm[9] * b1 + pm[10] * b2
+      }
+      _appendBasisX.setXYZ(bx0, bx1, bx2)
+      _appendBasisY.setXYZ(by0, by1, by2)
+      _appendBasisZ.setXYZ(bz0, bz1, bz2)
+      Quat.fromBasisInto(_appendBasisX, _appendBasisY, _appendBasisZ, this.appendRotOverride[i])
+      this.appendRotOverrideSet[i] = 1
+    }
+
+    this.computeWorldMatrices(order)
+  }
+
+  computeWorldMatrices(subset?: Int32Array): void {
     const bones = this.skeleton.bones
     const localRot = this.runtimeSkeleton.localRotations
     const localTrans = this.runtimeSkeleton.localTranslations
@@ -2624,8 +2771,15 @@ export class Model {
     // Flat traversal in precomputed order: every bone's parent is already done, so no
     // per-bone visited check, no recursion, and no per-call allocation. Same per-bone
     // math as before. Scratch slots are safe to reuse since there's no reentrancy now.
-    const order = this.deformOrder
-    for (let k = 0; k < boneCount; k++) {
+    //
+    // A SUBSET is the post-physics pass (applyPhysicsAppend): the same walk over
+    // the bones that inherit from a simulated one, in the same relative order,
+    // leaving every other bone — the simulated ones above all — untouched.
+    const order = subset ?? this.deformOrder
+    const count = subset ? subset.length : boneCount
+    const override = this.appendRotOverride
+    const overrideSet = this.appendRotOverrideSet
+    for (let k = 0; k < count; k++) {
       const i = order[k]
       const b = bones[i]
 
@@ -2643,7 +2797,12 @@ export class Model {
 
         if (hasRatio) {
           if (b.appendRotate) {
-            const appendRot = localRot[appendParentIdx]
+            // The simulated parent's RECOVERED rotation when there is one — the
+            // whole point of the post-physics pass. localRotations still holds
+            // the animated pose for that bone, which is exactly what must not
+            // be inherited here.
+            const appendRot =
+              override && overrideSet && overrideSet[appendParentIdx] ? override[appendParentIdx] : localRot[appendParentIdx]
             let ax = appendRot.x, ay = appendRot.y, az = appendRot.z
             const aw = appendRot.w
             const absRatio = ratio < 0 ? -ratio : ratio

package/src/physics/physics.ts

@@ -706,6 +706,69 @@ export class RezePhysics {
   //   boneWorld = bodyWorld × bodyOffsetInverse.
   // The body pose is the render-interpolated pose between the previous and current
   // substep states (alpha = fraction into the next step), which removes fixed-step judder.
+  /**
+   * Let the bodies carrying these bones swing longer, by damping them less.
+   *
+   * DAMPING, and not solver iterations, and the difference is the whole point.
+   * Under-converging a joint does make it swing further — it also stops it ever
+   * reaching equilibrium, so the body hangs visibly low at rest. Sag and swing
+   * come as a pair there and no amount of tuning separates them. Damping does
+   * separate them: for m·x″ + c·x′ + k·x = mg the rest position is mg/k, which
+   * c does not appear in. Less damping is a longer, larger oscillation about
+   * exactly the same resting height.
+   *
+   * Scoped to the bones asked for, because it is a look and not a correction —
+   * rigs whose visible bones inherit from a simulated one (付与親) are authored
+   * against an MMD that lets them move more than a faithfully damped
+   * simulation does. Hair and skirt keep their authored damping.
+   *
+   * `scale` multiplies the AUTHORED damping: 1 restores it, 0.5 halves it,
+   * 0 leaves the body undamped and ringing. Idempotent — the authored values
+   * are snapshotted on first use, so repeated calls set rather than compound.
+   */
+  setJiggleDamping(boneIndices: number[], scale: number): void {
+    const wanted = new Set(boneIndices.filter((b) => b >= 0))
+    if (wanted.size === 0) return
+    if (!this.authoredLinDamp || !this.authoredAngDamp) {
+      this.authoredLinDamp = Float32Array.from(this.store.linearDamping)
+      this.authoredAngDamp = Float32Array.from(this.store.angularDamping)
+    }
+    const s = Math.max(0, Math.min(1, scale))
+    const boneOf = this.store.boneIndex
+    for (let i = 0; i < this.store.count; i++) {
+      const b = boneOf[i]
+      if (b < 0 || !wanted.has(b)) continue
+      this.store.linearDamping[i] = this.authoredLinDamp[i] * s
+      this.store.angularDamping[i] = this.authoredAngDamp[i] * s
+    }
+    // The factors are cached against dt, which has not changed.
+    this.world.invalidateDampingCache()
+  }
+
+  /** Authored damping, kept so setJiggleDamping sets rather than compounds. */
+  private authoredLinDamp: Float32Array | null = null
+  private authoredAngDamp: Float32Array | null = null
+
+  /**
+   * Bones whose world matrix this simulation OVERWRITES each step.
+   *
+   * The same test applyDynamicsToBones runs — a Dynamic body bound to a real
+   * bone — exposed because the pose pipeline has to know. PMX lets a bone
+   * inherit rotation from an 付与親 (append parent), and when that parent is
+   * simulated the inheritance has to consume the SIMULATED result, not the
+   * animated pose the frame started with. Nothing else can answer which bones
+   * those are: the mapping lives in this store.
+   */
+  getPhysicsDrivenBones(): number[] {
+    const out: number[] = []
+    for (let i = 0; i < this.store.count; i++) {
+      if (this.store.type[i] !== RigidbodyType.Dynamic) continue
+      const b = this.store.boneIndex[i]
+      if (b >= 0) out.push(b)
+    }
+    return out
+  }
+
   private applyDynamicsToBones(boneWorldMatrices: Mat4[], alpha: number): void {
     const N = this.store.count
     const inv = this.store.bodyOffsetInverse

package/src/physics/world.ts

@@ -45,6 +45,13 @@ export class World {
   // Per-body damping factors pow(1−damping, dt), cached because damping and
   // the fixed dt never change — two Math.pow per body per substep otherwise.
   private dampCacheDt = -1
+
+  /** Drop the cached damping factors. The cache is keyed on dt alone, because
+   *  authored damping never changed — until a rig asked for softer jiggle (see
+   *  RezePhysics.setJiggleDamping), which rewrites the store's values. */
+  invalidateDampingCache(): void {
+    this.dampCacheDt = -1
+  }
   private linDampFactor: Float32Array | null = null
   private angDampFactor: Float32Array | null = null
 

package/src/shaders/cast-layout.ts

@@ -14,7 +14,50 @@
  * the whole engine failing to start on an import order nobody chose.
  */
 export const EFFECT_SUBJECTS = 4
-export const EFFECT_ANCHORS = 8
+/**
+ * Bone anchors, for the WHOLE SCENE rather than per effect — this is an address
+ * space that every installed effect draws slots from, and an effect asking for
+ * one the table has already given away is told so and has it dropped.
+ *
+ * 8 was reachable, and quietly: two effects each wanting two hands, two feet and
+ * a head is ten, so the second one silently lost its ribbons to a diagnostic
+ * nobody was reading. 16 is double the headroom for 131KB of storage buffer,
+ * where 8 cost 66KB.
+ *
+ * The cost really is only that. The per-frame upload is bounded by the last
+ * TRAILED slot, not by this cap (see the writeBuffer in updateCastBuffer), so a
+ * scene using three anchors uploads three anchors' worth whatever this says.
+ * The CPU-side path rings are keyed by (model, slot) and allocated on use. And
+ * effects never index this directly — they loop to rzTrailCount / rzSubjectCount
+ * and read through rzAnchor/rzTrail, both of which bounds-check against it.
+ *
+ * It stays a compile-time constant because the accessors in cast-api.ts are
+ * interpolated into every effect module as WGSL literals; making it dynamic
+ * means resizing the buffer and recompiling every installed effect whenever the
+ * scene's anchor count grows, which is a different feature from raising a number
+ * that was never load-bearing.
+ */
+export const EFFECT_ANCHORS = 16
+/**
+ * Path samples kept per trailed anchor — 128 at the 60Hz sampling rate is a
+ * ~2.1 second ribbon.
+ *
+ * Briefly 256, and reverted with the reason, because the reason is the useful
+ * part: a ribbon's cost is not its geometry, it is its FRAGMENTS. It is a wide
+ * translucent strip blended additively into the HDR target at the pass's sample
+ * count, and it overlaps itself — so its cost tracks the screen AREA it covers,
+ * and a twice-as-long ribbon covers roughly twice as much.
+ *
+ * That lands very differently on the two backends. Overdraw and blend bandwidth
+ * are what a tile-based GPU pays for most and what an immediate-mode desktop GPU
+ * absorbs, which is why ribbons were reported as costing far more on Safari than
+ * on Chrome for the same scene. Doubling this doubles the one thing already
+ * known to be the bottleneck there.
+ *
+ * Raising it is still SAFE — effects loop to rzTrailCount and nothing breaks —
+ * it is simply not cheap, and the cost shows up on the slower of the two
+ * browsers rather than the one it would be measured on.
+ */
 export const EFFECT_TRAIL_SAMPLES = 128
 /** vec4 slot where the trails begin — after the subjects and the anchors. */
 export const EFFECT_TRAIL_BASE = EFFECT_SUBJECTS * 3 + EFFECT_ANCHORS * EFFECT_SUBJECTS * 3

package/src/shaders/materials/common.ts

@@ -73,7 +73,13 @@ struct MaterialUniforms {
 };
 
 struct VertexOutput {
-  @builtin(position) position: vec4f,
+  // @invariant: the opaque depth prepass rasterises this same skinned position
+  // through a DIFFERENT shader module, and the colour pass then depth-tests
+  // less-equal against what it wrote. Without invariance a backend is free to
+  // optimise the two position computations differently, and a one-ulp
+  // disagreement is a pixel of missing character. Invariance pins both to the
+  // same result; it costs only that freedom.
+  @builtin(position) @invariant position: vec4f,
   @location(0) normal: vec3f,
   @location(1) uv: vec2f,
   @location(2) worldPos: vec3f,

package/src/shaders/materials/nodes.ts

@@ -216,18 +216,26 @@ fn curve5(t0: f32, y0: f32, y1: f32, y2: f32, y3: f32, y4: f32) -> f32 {
   let t = clamp(t0, 0.0, 1.0) * 4.0;
   let i = min(floor(t), 3.0);
   let f = t - i;
-  // A var, not a let: WGSL only allows a dynamic index on a REFERENCE, and a
-  // let-bound array is a value. Indexing it with a runtime k is a compile error —
-  // and because this file is concatenated into every material shader, that error
-  // took every graph in the library down with it, not just curves.
-  var ys = array<f32, 5>(y0, y1, y2, y3, y4);
+  // NO local array, deliberately. This used to build array<f32, 5> and index it
+  // with the runtime k — and a dynamic index on function-local memory is the one
+  // construct this codebase has already caught Metal lowering to a
+  // per-invocation copy plus a switch (the filmic LUT note in composite.ts).
+  // rgb_curve calls this three times per node per pixel, so on a graph-heavy
+  // close-up that lowering was paid in the hottest loop the frame has. Four
+  // segments select cleanly: the values below are the SAME subtractions the
+  // array indexing produced, chosen by k instead of loaded through it —
+  // bit-identical results, no local memory, nothing for the backend to spill.
   let k = i32(i);
-  let pa = ys[k];
-  let pb = ys[k + 1];
+  let s0 = y1 - y0;
+  let s1 = y2 - y1;
+  let s2 = y3 - y2;
+  let s3 = y4 - y3;
+  let pa = select(select(y0, y1, k == 1), select(y2, y3, k == 3), k >= 2);
+  let pb = select(select(y1, y2, k == 1), select(y3, y4, k == 3), k >= 2);
   // Secants either side of each knot, clamped at the ends.
-  let dPrev = select(ys[max(k, 1)] - ys[max(k, 1) - 1], pb - pa, k == 0);
   let dHere = pb - pa;
-  let dNext = select(ys[min(k + 2, 4)] - ys[min(k + 1, 3)], pb - pa, k == 3);
+  let dPrev = select(s0, select(s1, s2, k == 3), k >= 2);
+  let dNext = select(select(s1, s2, k == 1), s3, k >= 2);
   let m0 = curve_slope(dPrev, dHere);
   let m1 = curve_slope(dHere, dNext);
   let f2 = f * f;

package/src/shaders/passes/depth-prepass.ts

@@ -1,17 +1,36 @@
-// Depth-only prepass for the TRANSPARENT bucket. Transparent color draws keep
-// depth write OFF so self-overlapping sheer cloth blends both layers instead of
-// a triangle-order patchwork — but that leaves no depth record, so anything
-// drawn later (the outline hulls) shows straight through the fabric as black
-// shapes. This pass re-draws the transparent geometry depth-only AFTER its
-// color pass: solid-enough texels (alpha ≥ 0.5) write depth, so outlines get
-// occluded behind fabric exactly like they are behind opaque cloth, while
-// truly sheer texels (a veil) stay non-occluding.
+// The depth-only prime, one module behind four pipelines.
+//
+// The oldest fps complaint the engine had — zoom close and the frame drops, in
+// every material generation — was per-fragment shading TIMES layering: an MMD
+// model at close-up is cloth over body over face under hair, author-order drawn,
+// every buried layer fully shaded and then covered. This module lets depth go
+// down FIRST so the colour passes shade each pixel once:
+//
+//   · opaque prepass  (CUTOFF 0.5) — plain auto-class opaque draws, before the
+//     opaque colour walk. See drawOpaqueDepthPrepass for who is in and why.
+//   · hair prime      (CUTOFF 1.0, stencil not-equal) — between the non-hair and
+//     hair colour walks, fenced off the eye silhouette the see-through-hair
+//     stencil pass needs. See drawHairDepthPrime.
+//   · transparent solid prime (CUTOFF 1.0) — a translucent material's alpha-1
+//     texels, where over-blending is plain replacement and the buried work
+//     provably never shows. See drawTransparentSolidPrepass.
+//   · transparent depth prepass (CUTOFF 0.5, AFTER colour) — the original
+//     occupant, dormant: re-records sheer fabric's depth so outline hulls are
+//     occluded behind it. Kept for a future OIT path.
 //
 // Reuses mainPipelineLayout: camera g0b0, diffuseSampler g0b2, skinMats g1b0,
 // diffuse texture g2b0, material uniforms g2b1 — the same bind groups the
 // color draws already set, so drawing it costs no extra binding work.
+//
+// A FUNCTION rather than the constant it was, for the reason commonFsOutWgsl is
+// one: the fragment outputs below depend on whether the device carries the id
+// attachment, and that answer does not exist at import time. The constant could
+// not have taken the outputs at all, which is most of why it did not have them.
 
-export const TRANSPARENT_DEPTH_PREPASS_WGSL = /* wgsl */ `
+import { sceneFsOutWgsl, sceneIdPadWgsl } from "./scene-contract"
+
+export function transparentDepthPrepassWgsl(): string {
+  return /* wgsl */ `
 struct CameraUniforms { view: mat4x4f, projection: mat4x4f, viewPos: vec3f, _p: f32, };
 struct MaterialUniforms {
   diffuseColor: vec3f,
@@ -25,7 +44,9 @@ struct MaterialUniforms {
 @group(2) @binding(1) var<uniform> material: MaterialUniforms;
 
 struct VSOut {
-  @builtin(position) position: vec4f,
+  // @invariant, to the same end as the material VertexOutput: the colour pass
+  // must land on exactly the depths this wrote.
+  @builtin(position) @invariant position: vec4f,
   @location(0) uv: vec2f,
 };
 
@@ -50,8 +71,28 @@ struct VSOut {
   return o;
 }
 
-@fragment fn fs(in: VSOut) {
+// Every attachment the pass carries, declared and then not written: the
+// pipeline takes all of them at writeMask 0 (see sceneTargets), so what this
+// returns is discarded by the hardware and only the depth write survives — which
+// is the entire purpose of the pass. Declaring them anyway is what keeps the
+// pipeline valid on a browser that requires an output per target rather than
+// per WRITTEN target. Costs one dead struct store on a fragment that already
+// runs, because the alpha test below needs it to.
+${sceneFsOutWgsl({ name: "PrepassOut", aux: "mask" })}
+// The cutout threshold, per pipeline. 0.5 is the OPAQUE prime's "solid enough"
+// — safe there because opaque colour replaces rather than blends. The
+// TRANSPARENT prime overrides it to 1.0: a translucent fragment's blend reads
+// what is behind it, so only a texel at EXACTLY alpha 1 — where over-blending
+// collapses to plain replacement and the destination stops mattering — may
+// claim depth ahead of its buried layers without changing the pixel.
+override CUTOFF: f32 = 0.5;
+@fragment fn fs(in: VSOut) -> PrepassOut {
   let a = material.alpha * textureSample(diffuseTexture, diffuseSampler, in.uv).a;
-  if (a < 0.5) { discard; }
+  if (a < CUTOFF) { discard; }
+  var out: PrepassOut;
+  out.color = vec4f(0.0);
+  out.mask = vec4f(0.0);
+${sceneIdPadWgsl("out")}  return out;
 }
 `
+}