reze-engine 0.50.3 → 0.50.5

package/src/shaders/passes/ground.ts

@@ -20,7 +20,13 @@ struct GroundShadowMat {
   fadeEnd: f32, shadowStrength: f32, pcfTexel: f32, gridSpacing: f32,
   gridLineWidth: f32, gridLineOpacity: f32, noiseStrength: f32, opacity: f32,
   gridLineColor: vec3f, mirror: f32,
-  mirrorBlur: f32, _mb0: f32, _mb1: f32, _mb2: f32,
+  // farCascade: 1 while a stage is loaded, 0 otherwise. See the branch below —
+  // with no stage the far map is never drawn into, so its taps are known.
+  mirrorBlur: f32, farCascade: f32, _mb1: f32, _mb2: f32,
+  // Every shadow caster in one sphere, refreshed per frame. w = radius; 0 means
+  // nothing casts, negative means "do not use this" (a rigid caster has no
+  // sphere, so a scene with a stage keeps the taps). See rzShadowPossible.
+  casterSphere: vec4f,
 };
 // One view-projection per shadow cascade, inner to outer — same buffer and
 // same order the materials read.
@@ -42,33 +48,12 @@ struct MirrorVP { viewProj: mat4x4f, params: vec4f, };
 @group(0) @binding(9) var mirrorTex: texture_2d<f32>;
 @group(0) @binding(10) var linearSampler: sampler;
 @group(0) @binding(11) var mirrorDepth: texture_depth_multisampled_2d;
+// The frost noise, PRE-BAKED — see GROUND_NOISE_BAKE_WGSL below. Sampled with
+// the repeat sampler already at binding 10.
+@group(0) @binding(12) var noiseTex: texture_2d<f32>;
 ${WORLD_AMBIENT_WGSL}
 ${lightsApi(0, 6)}
 
-fn hash2(p: vec2f) -> f32 {
-  var p3 = fract(vec3f(p.x, p.y, p.x) * 0.1031);
-  p3 += dot(p3, vec3f(p3.y + 33.33, p3.z + 33.33, p3.x + 33.33));
-  return fract((p3.x + p3.y) * p3.z);
-}
-fn valueNoise(p: vec2f) -> f32 {
-  let i = floor(p);
-  let f = fract(p);
-  let u = f * f * (3.0 - 2.0 * f);
-  return mix(mix(hash2(i), hash2(i + vec2f(1.0, 0.0)), u.x),
-             mix(hash2(i + vec2f(0.0, 1.0)), hash2(i + vec2f(1.0, 1.0)), u.x), u.y);
-}
-fn fbmNoise(p: vec2f) -> f32 {
-  var v = 0.0;
-  var a = 0.5;
-  var pp = p;
-  for (var i = 0; i < 4; i++) {
-    v += a * valueNoise(pp);
-    pp *= 2.0;
-    a *= 0.5;
-  }
-  return v;
-}
-
 struct VO { @builtin(position) position: vec4f, @location(0) worldPos: vec3f, @location(1) normal: vec3f, };
 @vertex fn vs(@location(0) position: vec3f, @location(1) normal: vec3f, @location(2) uv: vec2f) -> VO {
   var o: VO; o.worldPos = position; o.normal = normal;
@@ -121,8 +106,63 @@ ${sceneFsOutWgsl()}@fragment fn fs(i: VO) -> FSOut {
   // The far cascade's taps run ONLY where the near one is fading or absent
   // (frustum < 1), so a pixel in the near core costs exactly what it did with
   // one cascade — and that core is where the camera usually looks.
+  // Can anything cast a shadow ONTO this point at all?
+  //
+  // The ground is vastly larger than what stands on it, and the answer for most
+  // of it is no. A point is shadowed only if the ray from it toward the light
+  // meets a caster, so testing that ray against one bounding sphere decides in a
+  // few ALU ops what nine hardware-bilinear depth comparisons would otherwise be
+  // spent discovering. Same pixels: outside the sphere vis stays 1.0, which is
+  // exactly what the taps return.
+  //
+  // Conservative in all three directions that matter. The sphere is a union of
+  // per-model bounds built from POSED bones plus the skin margin, so a jump or a
+  // flying skirt is inside it. A negative radius disables the test outright. And
+  // the halfspace check uses -R rather than 0, so a caster the point is standing
+  // inside still counts.
+  var shadowPossible = material.casterSphere.w > 0.0;
+  if (shadowPossible) {
+    let toLight = normalize(-light.lights[0].direction.xyz);
+    let toCaster = material.casterSphere.xyz - i.worldPos;
+    let along = dot(toCaster, toLight);
+    let perp = length(toCaster - toLight * along);
+    shadowPossible = along > -material.casterSphere.w && perp <= material.casterSphere.w;
+  } else {
+    // Negative radius is the opt-out, not "nothing casts".
+    shadowPossible = material.casterSphere.w < 0.0;
+  }
+
   var vis = 1.0;
-  if (frustum < 1.0 && frustum1 > 0.0) {
+  // The whole cascade lookup, behind the strength dial.
+  //
+  // This is a FULL-COVERAGE draw and each branch below is nine comparison-sampler
+  // taps per pixel — eighteen where the cascades overlap — so on a retina canvas
+  // it is tens of millions of shadow-map fetches a frame. All of it was computed
+  // and then multiplied by material.shadowStrength, which is ZERO whenever the
+  // host turns the ground's shadow catcher off. Turning shadows off in the UI
+  // therefore cost exactly what leaving them on cost, which is what a report of
+  // "no fps gain from disabling shadows" looks like from the outside.
+  //
+  // shadowStrength is a uniform, so this branch is uniform across the draw:
+  // every invocation takes the same side and the taps are genuinely skipped
+  // rather than merely masked. The dark term below is (1.0 - vis) * strength, so
+  // with strength at zero the result is identical either way — a pure
+  // deletion of work, not a change of look.
+  //
+  // The same reasoning the noise tint below already got, applied to the term
+  // that costs a hundred times more.
+  if (material.shadowStrength > 0.0 && shadowPossible) {
+  // The far cascade's taps, skipped entirely when nothing ever drew into it.
+  //
+  // This branch is the expensive one on a wide floor: it runs wherever the NEAR
+  // cascade does not reach, and the near cascade is a 64-unit box around the
+  // camera target, so a floor receding to the horizon takes it almost
+  // everywhere. Nine comparison taps, per pixel, on the largest draw in the
+  // frame — against a map that is cleared unless a stage is in the scene.
+  //
+  // Cleared depth compares as "no occluder", so the skipped path leaves vis at
+  // 1.0, which is exactly what the taps returned. Free, not cheaper.
+  if (material.farCascade > 0.0 && frustum < 1.0 && frustum1 > 0.0) {
     let suv1 = vec2f(ndc1.x * 0.5 + 0.5, 0.5 - ndc1.y * 0.5);
     let suv1_c = clamp(suv1, vec2f(0.02), vec2f(0.98));
     let st1 = ${1 / SHADOW_CASCADES[SHADOW_CASCADES.length - 1].mapSize} * 2.0;
@@ -152,12 +192,27 @@ ${sceneFsOutWgsl()}@fragment fn fs(i: VO) -> FSOut {
     // cascade to cascade rather than snapping to lit mid-floor.
     vis = mix(vis, acc * (1.0 / 9.0), frustum);
   }
+  }
 
   // Frosted/matte micro-texture. Scenes leaving it at zero were still paying
   // sixteen hash rounds a pixel for a tint of exactly 1.
   var noiseTint = 1.0;
   if (material.noiseStrength != 0.0) {
-    let noiseVal = fbmNoise(i.worldPos.xz * 3.0);
+    // One texture sample where four octaves of value noise used to be
+    // EVALUATED — sixteen hash rounds per pixel, on the largest draw in the
+    // frame. Bisection on the device that was slow pinned the ground's whole
+    // cost here: flat colour was smooth, the shader minus its shadow taps was
+    // still slow, and the shader minus only this was smooth. (0.33.2 built
+    // this same bake and measured no win — the cost then was the PCF. The
+    // instrument was right both times; the term changed.)
+    //
+    // The tile is the SAME fbm, baked once at init over a 64-p-unit period
+    // (~21 world units before it repeats — invisible at frost strengths), and
+    // the interior of the tile is bit-identical to the old evaluation because
+    // only lattice cells on the seam are wrapped. Sampled at level 0 with the
+    // repeat sampler: the old evaluation had no filtering either, so distant
+    // sparkle is unchanged rather than quietly "improved".
+    let noiseVal = textureSampleLevel(noiseTex, linearSampler, i.worldPos.xz * ${3 / 64}, 0.0).r;
     noiseTint = 1.0 + (noiseVal - 0.5) * material.noiseStrength;
   }
 
@@ -291,3 +346,54 @@ ${sceneIdWriteWgsl("out", `${GROUND_MATERIAL_ID}u`, `${GROUND_OBJECT_ID}u`)}  re
  */
 export const GROUND_MATERIAL_ID = 0xffff
 export const GROUND_OBJECT_ID = 0xffff
+
+/** Texel edge of the baked frost tile. 1024 over a 64-p-unit period is two
+ *  texels per finest-octave noise cell — the bake resolves everything the
+ *  evaluation produced. r8unorm: the value lives in [0,1] and feeds a 0.05
+ *  tint; eight bits is already 5x below what that tint can show. */
+export const GROUND_NOISE_SIZE = 1024
+
+/**
+ * The frost fbm as a bake: identical math, periodic lattice.
+ *
+ * hash2/valueNoise/fbm are the ground's old helpers verbatim, with one change —
+ * each octave's lattice wraps at its own period (64 p-units at octave 0,
+ * doubling with frequency), so the tile is seamless under the repeat sampler.
+ * Wrapping only renames lattice cells on the seam; every interior cell hashes
+ * exactly as before, which is what makes the bake a relocation of the old
+ * pixels rather than a new look.
+ */
+export const GROUND_NOISE_BAKE_WGSL = /* wgsl */ `
+@vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {
+  let x = f32((vi & 1u) << 2u) - 1.0;
+  let y = f32((vi & 2u) << 1u) - 1.0;
+  return vec4f(x, y, 0.0, 1.0);
+}
+fn hash2(p: vec2f) -> f32 {
+  var p3 = fract(vec3f(p.x, p.y, p.x) * 0.1031);
+  p3 += dot(p3, vec3f(p3.y + 33.33, p3.z + 33.33, p3.x + 33.33));
+  return fract((p3.x + p3.y) * p3.z);
+}
+fn wrapCell(i: vec2f, period: f32) -> vec2f { return i - period * floor(i / period); }
+fn valueNoiseP(p: vec2f, period: f32) -> f32 {
+  let i = floor(p);
+  let f = fract(p);
+  let u = f * f * (3.0 - 2.0 * f);
+  return mix(mix(hash2(wrapCell(i, period)), hash2(wrapCell(i + vec2f(1.0, 0.0), period)), u.x),
+             mix(hash2(wrapCell(i + vec2f(0.0, 1.0), period)), hash2(wrapCell(i + vec2f(1.0, 1.0), period)), u.x), u.y);
+}
+@fragment fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f {
+  let p = pos.xy * (64.0 / ${GROUND_NOISE_SIZE}.0);
+  var v = 0.0;
+  var a = 0.5;
+  var pp = p;
+  var period = 64.0;
+  for (var o = 0; o < 4; o++) {
+    v += a * valueNoiseP(pp, period);
+    pp *= 2.0;
+    period *= 2.0;
+    a *= 0.5;
+  }
+  return vec4f(v, 0.0, 0.0, 1.0);
+}
+`

package/src/shaders/passes/outline.ts

@@ -12,7 +12,14 @@
 //      margins) — sheer fabric gets a proportional rim, never a solid black
 //      hull, without dropping the author's edge flag.
 
-export const OUTLINE_SHADER_WGSL = /* wgsl */ `
+// A FUNCTION rather than a constant, for the reason commonFsOutWgsl is one: the
+// fragment outputs depend on whether the device carries the id attachment, and
+// a string baked at import cannot know what the device said.
+
+import { sceneFsOutWgsl, sceneIdPadWgsl } from "./scene-contract"
+
+export function outlineShaderWgsl(): string {
+  return /* wgsl */ `
 struct CameraUniforms {
   view: mat4x4f,
   projection: mat4x4f,
@@ -91,7 +98,10 @@ struct VertexOutput {
   return output;
 }
 
-struct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };
+// The id output is declared and padded, never written for real: a hull would
+// overwrite the id of the body it traces, so the pipeline takes the id target at
+// writeMask 0. Declared all the same — see sceneFsOutWgsl.
+${sceneFsOutWgsl({ name: "FSOut", aux: "mask" })}
 @fragment fn fs(input: VertexOutput) -> FSOut {
   // Rim alpha FOLLOWS the fabric's texture alpha instead of a hard alpha test:
   // MMD draws blend-material edges solid (only cutout materials alpha-test), so
@@ -106,6 +116,7 @@ struct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };
   var out: FSOut;
   out.color = vec4f(material.edgeColor.rgb, material.edgeColor.a * texA);
   out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
-  return out;
+${sceneIdPadWgsl("out")}  return out;
 }
 `
+}

package/src/shaders/passes/particles.ts

@@ -5,6 +5,7 @@ import { anchorAliasWgsl } from "../anchor-table"
 import { midiApi } from "../midi-api"
 import { CAST_API } from "../cast-api"
 import { clockApi, EFFECT_MATH_API, PARTICLE_STRUCT_WGSL, trailSlotsApi, viewportApi } from "./hosted-api"
+import { sceneIdFieldWgsl, sceneIdPadWgsl } from "./scene-contract"
 // GPU particles for user effects: a compute step and an instanced quad draw.
 //
 // Its own shader MODULE rather than more source spliced into composite.ts, for
@@ -307,7 +308,10 @@ struct FSOut {
   // rejected outright — "reading alpha but it is missing from fragment output".
   // The material shaders declare vec4f here for the same reason.
   @location(1) mask: vec4f,
-}
+  // Declared whenever the pass carries the attachment, and padded rather than
+  // written: a particle is not a thing you would address by id, so its pipeline
+  // takes this target at writeMask 0. Declared anyway — see sceneFsOutWgsl.
+${sceneIdFieldWgsl()}}
 
 @fragment
 fn fs(in: VSOut) -> FSOut {
@@ -333,7 +337,7 @@ fn fs(in: VSOut) -> FSOut {
   // not geometry, was the banding that survived every geometry fix.
   let mg = select(vec2f(select(0.0, 1.0, BLOOM), 1.0), vec2f(select(0.0, c.a, BLOOM), c.a), ADDITIVE);
   out.mask = vec4f(mg.x, mg.y, 0.0, c.a);
-  return out;
+${sceneIdPadWgsl("out")}  return out;
 }
 `
   )

package/src/shaders/passes/scene-contract.ts

@@ -143,12 +143,14 @@ const ADD_PREMULTIPLIED: GPUBlendState = {
 }
 
 /**
- * Which classes actually WRITE an id, and so gain a fragment output for it.
+ * Which classes write a MEANINGFUL id.
  *
- * Everything else keeps its shader exactly as it is and takes the id target at
- * writeMask 0 — legal, specified, and free. The alternative (leaving the target
- * off those pipelines) is not available: every pipeline in a pass must agree
- * with the pass's attachments.
+ * Not the same question as which shaders declare the output — every scene-pass
+ * shader declares all three now (see sceneFsOutWgsl). This set decides only
+ * whose id survives: writeMask 0xf here, writeMask 0 for everyone else, so the
+ * others compute an id nothing stores. Leaving the target off those pipelines
+ * is not available: every pipeline in a pass must agree with the pass's
+ * attachments.
  *
  * The ground is in because a mark placed by id needs the floor to have one.
  * Transparent fabric writes ids too — dissolving a dress needs the dress's own
@@ -184,11 +186,10 @@ const BLENDS: Record<Exclude<SceneRenderClass, "depth-prepass">, [GPUBlendState,
 export function sceneTargets(cls: SceneRenderClass, formats: SceneFormats): GPUColorTargetState[] {
   const targets: GPUColorTargetState[] =
     cls === "depth-prepass"
-      ? // Format only, and writeMask 0. Note the asymmetry this leans on, which
-        // is the same one the id target leans on below: a target the shader has
-        // no output for is legal at writeMask 0 (gpuweb#1918), while an output
-        // with no target is NOT governed (gpuweb#5341). This is the specified
-        // direction, and it is the only one this file ever uses.
+      ? // Format only, and writeMask 0 — the pipeline writes no colour. It still
+        // DECLARES every output, which is the part that used to be missing; see
+        // the note on sceneFsOutWgsl about why writeMask 0 is not a licence to
+        // leave the output off.
         [
           { format: formats.hdr, writeMask: 0 },
           { format: formats.aux, writeMask: 0 },
@@ -226,12 +227,19 @@ export function sceneColorFormats(formats: SceneFormats): GPUTextureFormat[] {
  * author. The struct and the targets above have to agree on count and order,
  * and they now disagree in one file rather than in five.
  *
- * Only the shaders that will GAIN an output take this today — the materials
- * (hand-written and graph-generated alike, through COMMON_FS_OUT_WGSL) and the
- * ground. Outline, particles and ribbons keep their own declarations on
- * purpose: they never write the id, so they would take an `id: false` argument
- * forever, and their structs carry comments about their own blend that belong
- * where they are.
+ * EVERY scene-pass shader takes this — outline, particles, ribbons and the
+ * depth prepass included, none of which write a meaningful id (and the prepass
+ * no meaningful colour either). They did not, once. The reasoning was that a
+ * target at writeMask 0 needs no matching output: true of Dawn, and the reading
+ * of gpuweb#1918 this file used to assert. It is not a reading every browser
+ * shares, and the failure mode when a browser disagrees is the worst kind —
+ * createRenderPipeline does not throw, it returns a pipeline that is already
+ * invalid, and the pass that binds it is dropped whole. Missing geometry, clean
+ * console, and a bug that reproduces on one vendor's browser only.
+ *
+ * So the rule is now the strict one, and it costs nothing to hold: declare
+ * every output the pass has attachments for, and let writeMask decide what is
+ * kept. A shader with no id to write pads it — see sceneIdPadWgsl.
  */
 export function sceneFsOutWgsl(opts?: { name?: string; aux?: string }): string {
   const name = opts?.name ?? "FSOut"
@@ -264,3 +272,34 @@ ${id}};
 export function sceneIdWriteWgsl(out: string, material: string, object: string): string {
   return mrtIds ? `  ${out}.id = vec2u(${material}, ${object});\n` : ""
 }
+
+/**
+ * Just the id FIELD, for a shader that keeps its own struct.
+ *
+ * Particles and ribbons declare their outputs by hand because the comments on
+ * their aux field are about their own blend and belong beside it — taking the
+ * whole struct from sceneFsOutWgsl would move that prose away from what it
+ * explains. They still need the id output when the pass has the attachment, so
+ * they splice this in and pad it with sceneIdPadWgsl.
+ */
+export function sceneIdFieldWgsl(): string {
+  return mrtIds ? `  @location(2) id: vec2u,\n` : ""
+}
+
+/**
+ * The id assignment for a shader that has no id to give.
+ *
+ * The counterpart to the strict rule on sceneFsOutWgsl: outline hulls,
+ * particles, ribbons and the depth prepass all declare the output because the
+ * pass has the attachment, and all of them take writeMask 0, so what they
+ * assign is never stored. Zero, which is the reserved "nothing" id the pass
+ * clears to — so if one of these ever did reach the target, it would read as
+ * absence rather than as a plausible wrong answer pointing at material 0.
+ *
+ * A separate function from sceneIdWriteWgsl rather than a call to it with "0u"
+ * twice, because the two say different things: that one records an identity,
+ * this one satisfies a declaration.
+ */
+export function sceneIdPadWgsl(out: string): string {
+  return mrtIds ? `  ${out}.id = vec2u(0u, 0u);\n` : ""
+}

package/src/shaders/passes/trails.ts

@@ -5,6 +5,7 @@ import { anchorAliasWgsl, ribbonSlotWgsl } from "../anchor-table"
 import { midiApi } from "../midi-api"
 import { CAST_API } from "../cast-api"
 import { clockApi, EFFECT_MATH_API, PARTICLE_STRUCT_WGSL, trailSlotsApi, viewportApi } from "./hosted-api"
+import { sceneIdFieldWgsl, sceneIdPadWgsl } from "./scene-contract"
 // Ribbons along a bone's recorded path, drawn as geometry.
 //
 // This is the effect the whole geometry path was built for. As a fullscreen
@@ -123,7 +124,14 @@ struct CameraU {
 }
 struct TrailU {
   time: f32,
-  _pad0: f32,
+  // How many subjects the cast ACTUALLY holds this frame, not the four the
+  // layout has room for. The instance count is sized by this on the CPU and
+  // decoded by it here, and the two must use the same number or the flattened
+  // [ribbon][subject][segment] index lands on the wrong ribbon. It is a uniform
+  // rather than the RZ_SUBJECTS constant precisely because it changes when a
+  // model is added or removed, and recompiling every trail shader for that
+  // would be absurd.
+  subjects: f32,
   _pad1: f32,
   _pad2: f32,
 }
@@ -244,11 +252,14 @@ fn vs(@builtin(vertex_index) vi: u32, @builtin(instance_index) ii: u32) -> VSOut
   let rest = ii / subs;
   let seg = k / SUB;
   let sub = k % SUB;
-  let subject = i32(rest % u32(RZ_SUBJECTS));
+  // The LIVE subject count, floored at one so a cast that is momentarily empty
+  // divides by something. See TrailU.subjects.
+  let live = max(1u, u32(tu.subjects));
+  let subject = i32(rest % live);
   // Instance index counts RIBBONS; the cast buffer is addressed by anchor slot.
   // One ribbon per trailed anchor, so these are the same number only when every
   // anchor is trailed — _rzRibbonSlot is what bridges them.
-  let ribbon = i32(rest / u32(RZ_SUBJECTS));
+  let ribbon = i32(rest / live);
   let slot = _rzRibbonSlot(ribbon);
 
   let n = rzTrailCount(subject, slot);
@@ -342,9 +353,23 @@ fn vs(@builtin(vertex_index) vi: u32, @builtin(instance_index) ii: u32) -> VSOut
   if (dot(perpA, perpB) < 0.0) { perpB = -perpB; }
   let clipP = select(clipA, clipB, atEnd);
   let perp = select(perpA, perpB, atEnd);
-  // trailWidth speaks PIXELS, like the original's constants; rzViewportHeight()
-  // lets the effect scale them to the frame.
-  let wPx = max(0.0, trailWidth(u, age));
+  // trailWidth speaks WORLD UNITS — the model's units, not the screen's.
+  //
+  // It spoke pixels, like the fullscreen original's constants, and that made
+  // the ribbon a screen ornament: zoom out and it grew relative to the hand
+  // that drew it, zoom in and it thinned to a thread. A ribbon is a thing in
+  // the scene, so its width belongs in the scene's units and should foreshorten
+  // like everything else.
+  //
+  // The EXTRUSION stays in 2D pixel space untouched — every 3D-extrusion
+  // artefact this ribbon ever had (fold-over wedges, bowties, twisted quads) is
+  // recorded above, and none of it comes back. Only the width's SOURCE changes:
+  // a world length L perpendicular to view at depth w projects to
+  // L * proj[1][1] / w in NDC y, so half the frame height converts it to the
+  // pixels the 2D offset wants. Per vertex, so a ribbon receding along its own
+  // length tapers with distance exactly as geometry would.
+  let wWorld = max(0.0, trailWidth(u, age));
+  let wPx = wWorld * cam.proj[1][1] * (H * 0.5) / max(clipP.w, 0.01);
   let ndc = clipP.xy / clipP.w + perp * (c.y * wPx) / toPx;
   out.clip = vec4f(ndc * clipP.w, clipP.z, clipP.w);
   out.slot = u32(slot);
@@ -364,7 +389,10 @@ struct TrailFSOut {
   // The scene's aux target: (bloom mask, coverage). Writing mask 1 is what
   // makes a ribbon BLOOM — it is light, and the gate is what says so.
   @location(1) aux: vec4f,
-}
+  // Declared whenever the pass carries the attachment, and padded rather than
+  // written: a ribbon is not a thing you would address by id, so its pipeline
+  // takes this target at writeMask 0. Declared anyway — see sceneFsOutWgsl.
+${sceneIdFieldWgsl()}}
 
 @fragment
 fn fs(in: VSOut) -> TrailFSOut {
@@ -383,7 +411,7 @@ fn fs(in: VSOut) -> TrailFSOut {
   // mapper is what keeps the sum from clipping.
   o.color = vec4f(c.rgb, c.a);
   o.aux = vec4f(${src.bloom ? "1.0" : "0.0"}, 1.0, 0.0, c.a);
-  return o;
+${sceneIdPadWgsl("o")}  return o;
 }
 `
   )

package/dist/physics-debug.d.ts

@@ -1,30 +0,0 @@
-import type { RezePhysics } from "./physics";
-export declare class PhysicsDebugRenderer {
-    private device;
-    private bindGroup;
-    private wirePipelineSphere;
-    private wirePipelineBox;
-    private wirePipelineCapsule;
-    private wireSphereBuffer;
-    private wireBoxBuffer;
-    private wireCapsuleBuffer;
-    private wireSphereCount;
-    private wireBoxCount;
-    private wireCapsuleCount;
-    private solidPipelineSphere;
-    private solidPipelineBox;
-    private solidPipelineCapsule;
-    private solidSphereBuffer;
-    private solidBoxBuffer;
-    private solidCapsuleBuffer;
-    private solidSphereCount;
-    private solidBoxCount;
-    private solidCapsuleCount;
-    private instanceBuffer;
-    private instanceData;
-    private instanceCapacity;
-    constructor(device: GPUDevice, cameraUniformBuffer: GPUBuffer, presentationFormat: GPUTextureFormat);
-    render(pass: GPURenderPassEncoder, physics: RezePhysics): void;
-    destroy(): void;
-}
-//# sourceMappingURL=physics-debug.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"physics-debug.d.ts","sourceRoot":"","sources":["../src/physics-debug.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAmB5C,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,SAAS,CAAc;IAG/B,OAAO,CAAC,kBAAkB,CAAmB;IAC7C,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,gBAAgB,CAAW;IACnC,OAAO,CAAC,aAAa,CAAW;IAChC,OAAO,CAAC,iBAAiB,CAAW;IACpC,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,gBAAgB,CAAQ;IAIhC,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,oBAAoB,CAAmB;IAC/C,OAAO,CAAC,iBAAiB,CAAW;IACpC,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,kBAAkB,CAAW;IACrC,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,iBAAiB,CAAQ;IAEjC,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,gBAAgB,CAAQ;gBAG9B,MAAM,EAAE,SAAS,EACjB,mBAAmB,EAAE,SAAS,EAC9B,kBAAkB,EAAE,gBAAgB;IA2HtC,MAAM,CAAC,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI;IAmI9D,OAAO,IAAI,IAAI;CAShB"}