reze-engine 0.58.1 → 0.58.3

package/src/shaders/passes/particles.ts

@@ -11,6 +11,7 @@ import { clockApi, EFFECT_MATH_API, PARTICLE_STRUCT_WGSL, trailSlotsApi, viewpor
 import { sceneIdFieldWgsl, sceneIdPadWgsl } from "./scene-contract"
 import { idApi } from "../id-api"
 import { sceneLightApi } from "../scene-light-api"
+import { pointsApi } from "../points-api"
 // 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
@@ -100,6 +101,15 @@ type ParticleSource = {
    *  where every stacked fragment is otherwise shaded in full; the prepass is
    *  the shape of that rejection, done by hand and cheaply. */
   cover: boolean
+  /** The effect defines `particleCount() -> u32`: how many of the pool are
+   *  live this frame, as a function of its dials. The step is dispatched and
+   *  the quads drawn for that many slots and no more, through indirect
+   *  arguments a one-thread kernel writes first. A pool sized for its densest
+   *  setting then costs its current setting: a lawn's spare 1.3M slots were
+   *  read, written and issued as degenerate quads every frame, and that
+   *  traffic alone was a third of the frame. The live slots are always the
+   *  first N — an author whose live set is not a prefix has no use for this. */
+  live: boolean
   /** The side of this effect's grid, or 0 when it declared none. Particles READ
    *  the grid; the kernel that steps it lives in the grid pass. A blade of grass
    *  bending where a foot pressed is the whole case: the bend has to persist and
@@ -109,6 +119,14 @@ type ParticleSource = {
 
 /** Where the shading stage's five scene-light bindings start — see scene-light-api.ts. */
 export const PARTICLE_LIGHT_BINDING = 10
+/** The effect's named points (`#points`), in both stages — see points-api.ts. */
+export const PARTICLE_POINTS_BINDING = 15
+/** The indirect arguments a `particleCount` effect writes — compute stage only.
+ *  Eight u32: the step's dispatch (groups, 1, 1, pad) then the quads' draw
+ *  (6, count, 0, 0), so the draw reads at byte 16. */
+export const PARTICLE_INDIRECT_BINDING = 16
+export const PARTICLE_INDIRECT_BYTES = 32
+export const PARTICLE_INDIRECT_DRAW_OFFSET = 16
 
 /** Bytes per particle. Explicitly padded — see the struct below. */
 export const PARTICLE_STRIDE = 48
@@ -168,13 +186,15 @@ fn rzCamPos() -> vec3f { return cam.camPos; }
 `
 
 /** Does the source define the particle contract? All three are required
- *  together; `cover` is optional and only means anything to a cutout. */
-export function particleEntryPoints(wgsl: string): { init: boolean; step: boolean; shade: boolean; cover: boolean } {
+ *  together; `cover` is optional and only means anything to a cutout, and
+ *  `count` is optional and bounds the frame's work — see particleCount. */
+export function particleEntryPoints(wgsl: string): { init: boolean; step: boolean; shade: boolean; cover: boolean; count: boolean } {
   return {
     init: /\bfn\s+particleInit\s*\(/.test(wgsl),
     step: /\bfn\s+particleStep\s*\(/.test(wgsl),
     shade: /\bfn\s+particleShade\s*\(/.test(wgsl),
     cover: /\bfn\s+particleCover\s*\(/.test(wgsl),
+    count: /\bfn\s+particleCount\s*\(/.test(wgsl),
   }
 }
 
@@ -212,8 +232,31 @@ ${src.paramsDecl}
     // Stubbed: this module cannot read an attachment the scene pass writes — see
     // id-api.ts. The author's whole file compiles here, so the names must exist.
     idApi(false, 0, 0) + castDistanceStub() + sceneLightApi(false, 0, 0) +
+    // The named points, for real: particleInit is where a flame is put on a wick.
+    pointsApi(true, 0, PARTICLE_POINTS_BINDING) +
+    (src.live
+      ? `@group(0) @binding(${PARTICLE_INDIRECT_BINDING}) var<storage, read_write> _rzIndirect: array<u32, 8>;\n`
+      : "") +
     "\n// ── user effect ──\n" +
     src.wgsl +
+    (src.live
+      ? /* wgsl */ `
+// The frame's live count, from the author's dials, into the arguments the
+// step dispatch and both draws read. One thread; runs before the step.
+@compute @workgroup_size(1)
+fn rzCount() {
+  let n = min(particleCount(), pu.count);
+  _rzIndirect[0] = (n + 63u) / 64u;
+  _rzIndirect[1] = 1u;
+  _rzIndirect[2] = 1u;
+  _rzIndirect[3] = 0u;
+  _rzIndirect[4] = 6u;
+  _rzIndirect[5] = n;
+  _rzIndirect[6] = 0u;
+  _rzIndirect[7] = 0u;
+}
+`
+      : "") +
     /* wgsl */ `
 @compute @workgroup_size(64)
 fn main(@builtin(global_invocation_id) gid: vec3u) {
@@ -289,6 +332,7 @@ ${src.paramsDecl}
     // The sun's shadow and the world's ambient, for real: the shadow pass has
     // run by the time this draws, inside the scene pass. See scene-light-api.ts.
     sceneLightApi(true, 0, PARTICLE_LIGHT_BINDING) +
+    pointsApi(true, 0, PARTICLE_POINTS_BINDING) +
     "\n// ── user effect ──\n" +
     src.wgsl +
     /* wgsl */ `

package/src/shaders/passes/trails.ts

@@ -11,6 +11,7 @@ import { clockApi, EFFECT_MATH_API, PARTICLE_STRUCT_WGSL, trailSlotsApi, viewpor
 import { sceneIdFieldWgsl, sceneIdPadWgsl } from "./scene-contract"
 import { idApi } from "../id-api"
 import { sceneLightApi } from "../scene-light-api"
+import { pointsApi } from "../points-api"
 // Ribbons along a bone's recorded path, drawn as geometry.
 //
 // This is the effect the whole geometry path was built for. As a fullscreen
@@ -302,7 +303,7 @@ fn rzTurnRadius(a: vec3f, b: vec3f, c: vec3f) -> f32 {
     gridReadApi(0, 8, 9, src.gridSize) +
     // Stubbed: this module cannot read an attachment the scene pass writes — see
     // id-api.ts. The author's whole file compiles here, so the names must exist.
-    idApi(false, 0, 0) + castDistanceStub() + sceneLightApi(false, 0, 0) +
+    idApi(false, 0, 0) + castDistanceStub() + sceneLightApi(false, 0, 0) + pointsApi(false) +
     "\n// ── user effect ──\n" +
     src.wgsl +
     /* wgsl */ `

package/src/shaders/points-api.ts

@@ -0,0 +1,66 @@
+// Named points on the models, for an effect that puts something at each one.
+//
+//     #points flame
+//
+// gives the effect every bone whose name starts with `flame`, on every model in
+// the scene — a stage, its parts, a prop, a character — as RzPoint: where the
+// bone stands and where its tail points, in world space, this frame. A candle
+// stage carries a bone per wick; a flame effect draws one flame on each, sized
+// and stood up by the tail.
+//
+// BONES, because a bone is MMD's own word for a named point in a model. A stage
+// that brings its candles as bones needs no side file, a hand-made stage can
+// add them in any PMX editor, and a candle a character carries moves with the
+// hand that holds it.
+//
+// Not the cast's anchors: those name up to sixteen bones on four characters,
+// one bone per name. A stage is not a character, and fifty wicks share a
+// prefix rather than each having a name worth declaring.
+
+/** How many points one effect can read. A candlelit hall is fifty. */
+export const MAX_EFFECT_POINTS = 256
+
+/** Floats in a points buffer: a vec4 header (count), then two vec4s a point. */
+export const POINTS_FLOATS = 4 + MAX_EFFECT_POINTS * 8
+
+const STRUCT = /* wgsl */ `
+/** One named point: where the bone stands, and where its tail points to. */
+struct RzPoint {
+  pos: vec3f,
+  tip: vec3f,
+}
+`
+
+/**
+ * rzPointCount / rzPoint. `bound` is false in every module that cannot read the
+ * buffer — the author's whole file is spliced into each module it has a mount
+ * in, so the names must resolve there too, and there they read as no points.
+ */
+export function pointsApi(bound: boolean, group = 0, binding = 0): string {
+  if (!bound) {
+    return (
+      STRUCT +
+      /* wgsl */ `
+fn rzPointCount() -> u32 { return 0u; }
+fn rzPoint(i: u32) -> RzPoint { var p: RzPoint; return p; }
+`
+    )
+  }
+  return (
+    STRUCT +
+    /* wgsl */ `
+@group(${group}) @binding(${binding}) var<storage, read> _rzPoints: array<vec4f>;
+
+/** How many named points the scene has for this effect, this frame. */
+fn rzPointCount() -> u32 { return min(u32(_rzPoints[0].x), ${MAX_EFFECT_POINTS}u); }
+
+/** Point i, world space. */
+fn rzPoint(i: u32) -> RzPoint {
+  var p: RzPoint;
+  p.pos = _rzPoints[1u + i * 2u].xyz;
+  p.tip = _rzPoints[2u + i * 2u].xyz;
+  return p;
+}
+`
+  )
+}