reze-engine 0.58.2 → 0.58.4

package/dist/engine.js

@@ -42,7 +42,7 @@ import { boneOverlay, boneMarkerPositions, buildOverlayShapes, jointOverlay, lin
 import { BLOOM_BLIT_SHADER_WGSL, BLOOM_DOWNSAMPLE_SHADER_WGSL, BLOOM_UPSAMPLE_SHADER_WGSL, } from "./shaders/passes/bloom";
 import { AGX_LUT_GZ, AGX_LUT_SIZE } from "./shaders/agx-lut";
 import { buildCompositeShader, EFFECT_SCENE_API, buildFieldShader, EFFECT_ANCHORS, EFFECT_SUBJECTS, EFFECT_TRAIL_BASE, EFFECT_TRAIL_SAMPLES, } from "./shaders/passes/composite";
-import { buildParticleComputeShader, buildParticleRenderShader, PARTICLE_LIGHT_BINDING, PARTICLE_POINTS_BINDING, particleEntryPoints, PARTICLE_STRIDE, } from "./shaders/passes/particles";
+import { buildParticleComputeShader, buildParticleRenderShader, PARTICLE_LIGHT_BINDING, PARTICLE_POINTS_BINDING, particleEntryPoints, PARTICLE_INDIRECT_BINDING, PARTICLE_INDIRECT_BYTES, PARTICLE_INDIRECT_DRAW_OFFSET, PARTICLE_STRIDE, } from "./shaders/passes/particles";
 import { MAX_EFFECT_POINTS, POINTS_FLOATS } from "./shaders/points-api";
 import { bonesWithPrefix, pointsData, writeBonePoint } from "./effect-points";
 import { SIM_FORMAT, GRID_MAX, buildSimShader, gridEntryPoint, } from "./shaders/passes/grid";
@@ -1163,7 +1163,9 @@ export class Engine {
         // GPU texture can't be read back cheaply, and PMX diffuse alpha is usually 1.0
         // even for see-through cloth: the translucency lives in the texture).
         this.textureAlphaCache = new Map();
-        this.mipBlitPipeline = null;
+        /** One per format: a render pipeline is bound to its target's format, and
+         *  material textures are sRGB while a group's data maps are not. */
+        this.mipBlitPipelines = new Map();
         this.mipBlitSampler = null;
         this._nextDefaultModelId = 0;
         // IK and physics enabled at engine level (same for all models)
@@ -3056,6 +3058,8 @@ export class Engine {
                 e.particles.computeBinds = b.computeBinds;
                 e.particles.renderBinds = b.renderBinds;
                 e.particles.mirrorRenderBinds = b.mirrorRenderBinds;
+                if (e.particles.live && b.countBinds)
+                    e.particles.live.binds = b.countBinds;
             }
             if (e.grid)
                 e.grid.binds = [this.gridBindGroup(e.grid, 0), this.gridBindGroup(e.grid, 1)];
@@ -3581,6 +3585,7 @@ export class Engine {
             particles?.buffer.destroy();
             particles?.uniform.destroy();
             particles?.points?.buffer.destroy();
+            particles?.live?.indirect.destroy();
             grid?.textures[0].destroy();
             grid?.textures[1].destroy();
             grid?.uniform.destroy();
@@ -3934,6 +3939,7 @@ export class Engine {
             paramsDecl: params.wgsl(EFFECT_PARAMS_BINDING),
             gridSize: grid?.size ?? 0,
             cover: particleEntryPoints(wgsl).cover,
+            live: particleEntryPoints(wgsl).count,
         };
         const prepass = src.blend === "cutout" && src.cover;
         const points = d.points
@@ -3997,13 +4003,23 @@ export class Engine {
         });
         const uniformBytes = new ArrayBuffer(32);
         const uniformView = { floats: new Float32Array(uniformBytes), uints: new Uint32Array(uniformBytes) };
+        // The live count's arguments — written by rzCount, read by the step's
+        // dispatch and the quads' draws. Zero until the first step, so a pool
+        // drawn before it has stepped draws nothing rather than everything.
+        const indirect = src.live
+            ? this.device.createBuffer({
+                label: "particle indirect",
+                size: PARTICLE_INDIRECT_BYTES,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT,
+            })
+            : null;
         // Visibility is per LAYOUT, not shared: a read_write storage buffer may not be
         // visible to the vertex stage at all (WebGPU forbids it — a vertex shader
         // that could write memory has no defined ordering against the rasteriser).
         // Declaring one set of flags for both layouts is what made the pipeline
         // layout invalid, and the error surfaces later and unhelpfully as "invalid
         // due to a previous error".
-        const layoutFor = (storage, visibility, shadow) => this.device.createBindGroupLayout({
+        const layoutFor = (storage, visibility, shadow, withIndirect) => this.device.createBindGroupLayout({
             entries: [
                 { binding: 0, visibility, buffer: { type: storage } },
                 { binding: 1, visibility, buffer: { type: "uniform" } },
@@ -4037,13 +4053,21 @@ export class Engine {
                         { binding: PARTICLE_LIGHT_BINDING + 4, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "comparison" } },
                     ]
                     : []),
+                // The live count's arguments, for the COUNT kernel's layout alone. The
+                // step's layout must not carry them: a bound group's entries count
+                // toward a pass's usage whether the shader reads them or not, and a
+                // buffer may not be writable storage and indirect arguments in one
+                // pass.
+                ...(withIndirect
+                    ? [{ binding: PARTICLE_INDIRECT_BINDING, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } }]
+                    : []),
             ],
         });
         /** One per GRID PARITY, for the reason rebuildFieldBindGroup gives: the grid
          *  alternates which texture is current, and rebuilding a single group every
          *  frame is waste for a change that only ever toggles between two known
          *  states. Both entries are the same view when there is no grid. */
-        const bindFor = (layout, camera, shadow) => [0, 1].map((parity) => this.device.createBindGroup({
+        const bindFor = (layout, camera, shadow, withIndirect) => [0, 1].map((parity) => this.device.createBindGroup({
             layout,
             entries: [
                 { binding: 0, resource: { buffer } },
@@ -4066,10 +4090,12 @@ export class Engine {
                         { binding: PARTICLE_LIGHT_BINDING + 4, resource: this.shadowComparisonSampler },
                     ]
                     : []),
+                ...(withIndirect && indirect ? [{ binding: PARTICLE_INDIRECT_BINDING, resource: { buffer: indirect } }] : []),
             ],
         }));
-        const computeLayout = layoutFor("storage", GPUShaderStage.COMPUTE, false);
-        const renderLayout = layoutFor("read-only-storage", GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, true);
+        const computeLayout = layoutFor("storage", GPUShaderStage.COMPUTE, false, false);
+        const countLayout = indirect ? layoutFor("storage", GPUShaderStage.COMPUTE, false, true) : null;
+        const renderLayout = layoutFor("read-only-storage", GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, true, false);
         // Additive keeps the destination and adds to it, and leaves alpha alone, so
         // a glow does not claim coverage it never occluded. The MASK sums with it —
         // otherwise an additive effect could never reach the bloom gate. Both live
@@ -4082,11 +4108,23 @@ export class Engine {
         const cutout = src.blend === "cutout";
         this.device.pushErrorScope("validation");
         try {
+            const computePipelineLayout = this.device.createPipelineLayout({ bindGroupLayouts: [computeLayout] });
             const compute = await this.device.createComputePipelineAsync({
                 label: "particle compute pipeline",
-                layout: this.device.createPipelineLayout({ bindGroupLayouts: [computeLayout] }),
+                layout: computePipelineLayout,
                 compute: { module: computeModule, entryPoint: "main" },
             });
+            const live = indirect && countLayout
+                ? {
+                    pipeline: await this.device.createComputePipelineAsync({
+                        label: "particle count pipeline",
+                        layout: this.device.createPipelineLayout({ bindGroupLayouts: [countLayout] }),
+                        compute: { module: computeModule, entryPoint: "rzCount" },
+                    }),
+                    indirect,
+                    binds: bindFor(countLayout, this.cameraUniformBuffer, false, true),
+                }
+                : null;
             const renderLayoutObj = this.device.createPipelineLayout({ bindGroupLayouts: [renderLayout] });
             // The prepass, when the effect gave the cutout a cheap shape: coverage to
             // depth, colour targets at writeMask 0 (the depth-prepass class), and
@@ -4129,6 +4167,7 @@ export class Engine {
                 buffer.destroy();
                 uniform.destroy();
                 points?.buffer.destroy();
+                indirect?.destroy();
                 return { ok: false, diagnostics: [scoped.message] };
             }
             return {
@@ -4144,18 +4183,20 @@ export class Engine {
                     counts: uniformView.uints,
                     compute,
                     computeLayout,
-                    computeBinds: bindFor(computeLayout, this.cameraUniformBuffer, false),
+                    computeBinds: bindFor(computeLayout, this.cameraUniformBuffer, false, false),
                     depth,
                     render,
                     renderLayout,
-                    renderBinds: bindFor(renderLayout, this.cameraUniformBuffer, true),
-                    mirrorRenderBinds: bindFor(renderLayout, this.mirrorCameraBuffer, true),
+                    renderBinds: bindFor(renderLayout, this.cameraUniformBuffer, true, false),
+                    mirrorRenderBinds: bindFor(renderLayout, this.mirrorCameraBuffer, true, false),
                     rebind: () => ({
-                        computeBinds: bindFor(computeLayout, this.cameraUniformBuffer, false),
-                        renderBinds: bindFor(renderLayout, this.cameraUniformBuffer, true),
-                        mirrorRenderBinds: bindFor(renderLayout, this.mirrorCameraBuffer, true),
+                        computeBinds: bindFor(computeLayout, this.cameraUniformBuffer, false, false),
+                        renderBinds: bindFor(renderLayout, this.cameraUniformBuffer, true, false),
+                        mirrorRenderBinds: bindFor(renderLayout, this.mirrorCameraBuffer, true, false),
+                        countBinds: countLayout ? bindFor(countLayout, this.cameraUniformBuffer, false, true) : null,
                     }),
                     points,
+                    live,
                 },
             };
         }
@@ -4164,6 +4205,7 @@ export class Engine {
             buffer.destroy();
             uniform.destroy();
             points?.buffer.destroy();
+            indirect?.destroy();
             return { ok: false, diagnostics: [e instanceof Error ? e.message : String(e)] };
         }
     }
@@ -4349,10 +4391,24 @@ export class Engine {
             this.device.queue.writeBuffer(p.uniform, 0, p.data.buffer);
             if (p.points)
                 this.writePoints(p.points);
+            const bind = p.computeBinds[e.grid?.parity ?? 0];
+            if (p.live) {
+                // The frame's live count first, in a pass of its own: a buffer may
+                // not be written as storage and read as indirect arguments inside one
+                // pass, and a pass is the synchronization scope.
+                const count = encoder.beginComputePass({ label: "particle count" });
+                count.setPipeline(p.live.pipeline);
+                count.setBindGroup(0, p.live.binds[e.grid?.parity ?? 0]);
+                count.dispatchWorkgroups(1);
+                count.end();
+            }
             const cp = encoder.beginComputePass({ label: "particles" });
             cp.setPipeline(p.compute);
-            cp.setBindGroup(0, p.computeBinds[e.grid?.parity ?? 0]);
-            cp.dispatchWorkgroups(Math.ceil(p.count / 64));
+            cp.setBindGroup(0, bind);
+            if (p.live)
+                cp.dispatchWorkgroupsIndirect(p.live.indirect, 0);
+            else
+                cp.dispatchWorkgroups(Math.ceil(p.count / 64));
             cp.end();
         }
     }
@@ -4397,14 +4453,21 @@ export class Engine {
                 continue;
             const parity = e.grid?.parity ?? 0;
             const bind = view === "mirror" ? p.mirrorRenderBinds[parity] : p.renderBinds[parity];
+            // The live count's quads when the effect declared one, else the pool's.
+            const draw = () => {
+                if (p.live)
+                    pass.drawIndirect(p.live.indirect, PARTICLE_INDIRECT_DRAW_OFFSET);
+                else
+                    pass.draw(6, p.count);
+            };
             if (p.depth) {
                 pass.setPipeline(p.depth);
                 pass.setBindGroup(0, bind);
-                pass.draw(6, p.count);
+                draw();
             }
             pass.setPipeline(p.render);
             pass.setBindGroup(0, bind);
-            pass.draw(6, p.count);
+            draw();
         }
     }
     /**
@@ -4771,6 +4834,7 @@ export class Engine {
             e.particles?.buffer.destroy();
             e.particles?.uniform.destroy();
             e.particles?.points?.buffer.destroy();
+            e.particles?.live?.indirect.destroy();
             e.particles = null;
         }
     }
@@ -5816,6 +5880,11 @@ export class Engine {
             usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
         });
         this.device.queue.writeTexture({ texture: this.fallbackMaterialTexture }, new Uint8Array([255, 255, 255, 255]), { bytesPerRow: 4 }, [1, 1]);
+        this.noFillBuffer = this.device.createBuffer({
+            label: "model fill (none)",
+            size: 16,
+            usage: GPUBufferUsage.UNIFORM,
+        });
         // Generic shared-toon ramp: lit white down to a soft cool shadow tone with
         // a tight terminator around the midpoint, approximating MMD's toon ramps.
         const TOON_H = 64;
@@ -5922,6 +5991,8 @@ export class Engine {
                     visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
                     buffer: { type: "read-only-storage" },
                 },
+                // The model's own fill — see setModelFill.
+                { binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
             ],
         });
         // group 2: per-material (textures + material uniforms) — bound per draw call.
@@ -8927,6 +8998,54 @@ export class Engine {
         inst.model.setName(newName);
         this.modelInstances.set(newName, inst);
     }
+    /**
+     * Light one model with more than the world gives it: a FILL, linear RGB added
+     * to its ambient everywhere on it. Null takes it away again.
+     *
+     * A game lights its stage and its characters apart. Aether Gazer's rooms are
+     * lit by their lamps and a near-black ambient, while its characters take a
+     * flat base light of their own — so a stage whose World is right for the room
+     * leaves a face turned from the lamps in the dark. This is that second light,
+     * for the models the host counts as cast.
+     */
+    setModelFill(name, fill) {
+        const inst = this.modelInstances.get(name);
+        if (!inst || !this.device)
+            return false;
+        if (!fill) {
+            if (!inst.fillBuffer)
+                return true;
+            const retired = inst.fillBuffer;
+            inst.fillBuffer = null;
+            inst.mainPerInstanceBindGroup = this.perInstanceBindGroup(name, inst.skinMatrixBuffer, null);
+            this.bundlesDirty = true;
+            // Retired once the GPU is done with it: an encoded frame may still name it.
+            void this.device.queue.onSubmittedWorkDone().then(() => retired.destroy());
+            return true;
+        }
+        if (!inst.fillBuffer) {
+            inst.fillBuffer = this.device.createBuffer({
+                label: `${name}: fill`,
+                size: 16,
+                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            });
+            inst.mainPerInstanceBindGroup = this.perInstanceBindGroup(name, inst.skinMatrixBuffer, inst.fillBuffer);
+            this.bundlesDirty = true;
+        }
+        this.device.queue.writeBuffer(inst.fillBuffer, 0, new Float32Array([fill.x, fill.y, fill.z, 0]));
+        return true;
+    }
+    /** The per-model group: its skinning matrices and its fill, or the zero stand-in. */
+    perInstanceBindGroup(name, skinMatrixBuffer, fill) {
+        return this.device.createBindGroup({
+            label: `${name}: main per-instance bind group`,
+            layout: this.mainPerInstanceBindGroupLayout,
+            entries: [
+                { binding: 0, resource: { buffer: skinMatrixBuffer } },
+                { binding: 1, resource: { buffer: fill ?? this.noFillBuffer } },
+            ],
+        });
+    }
     removeModel(name) {
         const inst = this.modelInstances.get(name);
         if (!inst)
@@ -8958,6 +9077,7 @@ export class Engine {
         for (const buf of inst.gpuBuffers) {
             buf.destroy();
         }
+        inst.fillBuffer?.destroy();
         // Per-group StyleUniforms buffers aren't in gpuBuffers (allocated post-load).
         for (const install of inst.styleGroups.values())
             this.destroyInstall(install);
@@ -9940,15 +10060,19 @@ export class Engine {
             const src = wrapped ? entry.source : entry;
             const width = Math.max(1, "naturalWidth" in src ? src.naturalWidth : src.width);
             const height = Math.max(1, "naturalHeight" in src ? src.naturalHeight : src.height);
+            const mipLevelCount = wrapped && entry.mipmaps ? Math.floor(Math.log2(Math.max(width, height))) + 1 : 1;
             const tex = this.device.createTexture({
                 label: `group map: ${group.id}`,
                 size: [width, height],
+                mipLevelCount,
                 // Colour maps decode to linear on sample, the way material textures do;
                 // data maps must not, or every threshold packed in their channels moves.
                 format: wrapped && entry.srgb ? "rgba8unorm-srgb" : "rgba8unorm",
                 usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
             });
             this.device.queue.copyExternalImageToTexture({ source: src }, { texture: tex, premultipliedAlpha: wrapped && entry.premultiplied === true }, [width, height]);
+            if (mipLevelCount > 1)
+                this.generateMipmaps(tex, mipLevelCount);
             return tex;
         });
     }
@@ -11296,11 +11420,7 @@ export class Engine {
                 { binding: 2, resource: this.materialSampler },
             ],
         }));
-        const mainPerInstanceBindGroup = this.device.createBindGroup({
-            label: `${name}: main per-instance bind group`,
-            layout: this.mainPerInstanceBindGroupLayout,
-            entries: [{ binding: 0, resource: { buffer: skinMatrixBuffer } }],
-        });
+        const mainPerInstanceBindGroup = this.perInstanceBindGroup(name, skinMatrixBuffer, null);
         const pickPerInstanceBindGroup = this.device.createBindGroup({
             label: `${name}: pick per-instance bind group`,
             layout: this.pickPerInstanceBindGroupLayout,
@@ -11333,6 +11453,7 @@ export class Engine {
             shadowDrawCalls: [],
             shadowBindGroups,
             mainPerInstanceBindGroup,
+            fillBuffer: null,
             pickPerInstanceBindGroup,
             pickDrawCalls: [],
             isStage,
@@ -12218,31 +12339,35 @@ export class Engine {
     // Bilinear box-filter downsample per level. Reads srgb view (hardware linearizes on sample,
     // re-encodes on write), so intensities are filtered in linear space — matching EEVEE/Blender.
     generateMipmaps(texture, mipLevelCount) {
-        if (!this.mipBlitPipeline || !this.mipBlitSampler) {
+        if (!this.mipBlitSampler) {
             this.mipBlitSampler = this.device.createSampler({
                 magFilter: "linear",
                 minFilter: "linear",
                 addressModeU: "clamp-to-edge",
                 addressModeV: "clamp-to-edge",
             });
+        }
+        let pipeline = this.mipBlitPipelines.get(texture.format);
+        if (!pipeline) {
             const module = this.device.createShaderModule({
                 label: "mipmap blit",
                 code: MIPMAP_BLIT_SHADER_WGSL,
             });
-            this.mipBlitPipeline = this.device.createRenderPipeline({
-                label: "mipmap blit pipeline",
+            pipeline = this.device.createRenderPipeline({
+                label: `mipmap blit pipeline (${texture.format})`,
                 layout: "auto",
                 vertex: { module, entryPoint: "vs" },
-                fragment: { module, entryPoint: "fs", targets: [{ format: "rgba8unorm-srgb" }] },
+                fragment: { module, entryPoint: "fs", targets: [{ format: texture.format }] },
                 primitive: { topology: "triangle-list" },
             });
+            this.mipBlitPipelines.set(texture.format, pipeline);
         }
         const encoder = this.device.createCommandEncoder({ label: "mipgen" });
         for (let level = 1; level < mipLevelCount; level++) {
             const srcView = texture.createView({ baseMipLevel: level - 1, mipLevelCount: 1 });
             const dstView = texture.createView({ baseMipLevel: level, mipLevelCount: 1 });
             const bindGroup = this.device.createBindGroup({
-                layout: this.mipBlitPipeline.getBindGroupLayout(0),
+                layout: pipeline.getBindGroupLayout(0),
                 entries: [
                     { binding: 0, resource: srcView },
                     { binding: 1, resource: this.mipBlitSampler },
@@ -12253,7 +12378,7 @@ export class Engine {
                     { view: dstView, clearValue: { r: 0, g: 0, b: 0, a: 0 }, loadOp: "clear", storeOp: "store" },
                 ],
             });
-            pass.setPipeline(this.mipBlitPipeline);
+            pass.setPipeline(pipeline);
             pass.setBindGroup(0, bindGroup);
             pass.draw(3);
             pass.end();
@@ -15078,12 +15203,13 @@ Engine.JIGGLE_DAMPING_SCALE = 0.5;
  * prefix sum and readback a compacted draw list would need every frame.
  */
 /** Ceiling for `#particles`. Past this an author is asking for a stall. */
-// Raised for the lawn: 65536 blades at real density is a 40-unit patch and
-// an 80-unit one wants four hundred thousand. A cutout pool's cost is
+// Raised for the lawn: an 80-unit field at 36 blades a unit wants seven
+// hundred thousand, and a turf one three million. A cutout pool's cost is
 // bounded by the pixels it covers, not by the count — the step is one
-// compute invocation per slot, the pool buffer is 48 bytes each (24 MB at
-// the cap), and a culled blade is a degenerate quad the rasteriser drops.
-Engine.MAX_PARTICLES = 524288;
+// compute invocation per slot, the pool buffer is 48 bytes each (96 MiB at
+// the cap, under the 128 MiB a storage binding may be without asking for
+// more), and a culled blade is a degenerate quad the rasteriser drops.
+Engine.MAX_PARTICLES = 2097152;
 /**
  * The field layer: user background/foreground mounts, ONE TARGET PAIR PER
  * RESOLUTION. Index 0 is full, index 1 is half — coarsest last, so the

package/dist/graph/slots.js

@@ -121,7 +121,7 @@ ${gate}
   let sun = light.lights[0].color.xyz * light.lights[0].color.w;
   // The world: flat colour, or the HDRI's irradiance at this normal — which
   // is what makes a loaded sky actually light her instead of only backing her.
-  let amb = rzWorldAmbient(n);
+  let amb = rzWorldAmbient(n) + modelFill.rgb;
   let shadow = sampleShadow(input.worldPos, n);
   let tex_color = tex_s.rgb;
 

package/dist/graph/style-group.d.ts

@@ -75,6 +75,13 @@ export type GroupImage = {
     source: GroupImageSource;
     srgb?: boolean;
     premultiplied?: boolean;
+    /**
+     * Give it a mip chain. For a map TILED across a surface — a relief map, a
+     * water's ripples — whose far tiles otherwise shrink to a pixel each and
+     * sample as noise that sparkles with every camera move. Off by default: a
+     * ramp read at a computed coordinate would blur at its own terminator.
+     */
+    mipmaps?: boolean;
 };
 export type GroupDiagnostic = {
     groupId: string;

package/dist/graph/style-group.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"style-group.d.ts","sourceRoot":"","sources":["../../src/graph/style-group.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAE1C,MAAM,MAAM,UAAU,GAAG;IACvB,wFAAwF;IACxF,EAAE,EAAE,MAAM,CAAA;IACV;2CACuC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,2EAA2E;IAC3E,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,sFAAsF;IACtF,KAAK,EAAE,WAAW,CAAA;IAClB,uEAAuE;IACvE,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,wEAAwE;IACxE,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,EAAE,CAAC,UAAU,GAAG,gBAAgB,GAAG,IAAI,CAAC,EAAE,CAAA;IACjD;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,UAAU,GAAG,gBAAgB,GAAG,IAAI,CAAC,EAAE,CAAC,CAAA;CAC5E,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,WAAW,GAAG,gBAAgB,GAAG,iBAAiB,CAAA;AAEjF;;;;;;;;;;;;GAYG;AACH;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,MAAM,EAAE,gBAAgB,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AAE9F,MAAM,MAAM,eAAe,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,UAAU,EAAE,CAAC;IAAC,EAAE,EAAE,OAAO,CAAA;CAAE,CAAA;AAEzF,MAAM,MAAM,sBAAsB,GAAG;IACnC,sCAAsC;IACtC,EAAE,EAAE,OAAO,CAAA;IACX,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,iEAAiE;IACjE,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,kFAAkF;IAClF,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,UAAU,EAAE,CAAC;IAAC,OAAO,EAAE,SAAS,EAAE,CAAA;CAAE,CAAA"}
+{"version":3,"file":"style-group.d.ts","sourceRoot":"","sources":["../../src/graph/style-group.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAE1C,MAAM,MAAM,UAAU,GAAG;IACvB,wFAAwF;IACxF,EAAE,EAAE,MAAM,CAAA;IACV;2CACuC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,2EAA2E;IAC3E,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,sFAAsF;IACtF,KAAK,EAAE,WAAW,CAAA;IAClB,uEAAuE;IACvE,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,wEAAwE;IACxE,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,EAAE,CAAC,UAAU,GAAG,gBAAgB,GAAG,IAAI,CAAC,EAAE,CAAA;IACjD;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,UAAU,GAAG,gBAAgB,GAAG,IAAI,CAAC,EAAE,CAAC,CAAA;CAC5E,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,WAAW,GAAG,gBAAgB,GAAG,iBAAiB,CAAA;AAEjF;;;;;;;;;;;;GAYG;AACH;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,gBAAgB,CAAA;IACxB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,UAAU,EAAE,CAAC;IAAC,EAAE,EAAE,OAAO,CAAA;CAAE,CAAA;AAEzF,MAAM,MAAM,sBAAsB,GAAG;IACnC,sCAAsC;IACtC,EAAE,EAAE,OAAO,CAAA;IACX,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,iEAAiE;IACjE,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,kFAAkF;IAClF,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,UAAU,EAAE,CAAC;IAAC,OAAO,EAAE,SAAS,EAAE,CAAA;CAAE,CAAA"}

package/dist/shaders/materials/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/shaders/materials/common.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,oBAAoB,QAmJhC,CAAC;AA8HF,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAGD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,orMAgHzB,CAAA;AAQD,eAAO,MAAM,4BAA4B,QAC0D,CAAA"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/shaders/materials/common.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,oBAAoB,QAsJhC,CAAC;AA8HF,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAGD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,orMAgHzB,CAAA;AAQD,eAAO,MAAM,4BAA4B,QAC0D,CAAA"}

package/dist/shaders/materials/common.js

@@ -143,6 +143,9 @@ struct LightVP { viewProj: array<mat4x4f, ${SHADOW_CASCADES.length}>, };
 @group(0) @binding(8) var worldEnvTexture: texture_2d<f32>;
 // binding(9) brdfLut is declared inside NODES_WGSL (nodes.ts).
 @group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
+// Light this model receives beyond the world's — see Engine.setModelFill. Zero
+// for a model nobody gave one, which leaves its ambient exactly the world's.
+@group(1) @binding(1) var<uniform> modelFill: vec4f;
 @group(2) @binding(0) var diffuseTexture: texture_2d<f32>;
 @group(2) @binding(1) var<uniform> material: MaterialUniforms;
 // Reserved for future sphere/toon graph nodes; graphs that don't read them get the

package/dist/shaders/passes/particles.d.ts

@@ -36,6 +36,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
@@ -46,15 +55,23 @@ type ParticleSource = {
 export declare const PARTICLE_LIGHT_BINDING = 10;
 /** The effect's named points (`#points`), in both stages — see points-api.ts. */
 export declare 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 declare const PARTICLE_INDIRECT_BINDING = 16;
+export declare const PARTICLE_INDIRECT_BYTES = 32;
+export declare const PARTICLE_INDIRECT_DRAW_OFFSET = 16;
 /** Bytes per particle. Explicitly padded — see the struct below. */
 export declare const PARTICLE_STRIDE = 48;
 /** Does the source define the particle contract? All three are required
- *  together; `cover` is optional and only means anything to a cutout. */
+ *  together; `cover` is optional and only means anything to a cutout, and
+ *  `count` is optional and bounds the frame's work — see particleCount. */
 export declare function particleEntryPoints(wgsl: string): {
     init: boolean;
     step: boolean;
     shade: boolean;
     cover: boolean;
+    count: boolean;
 };
 /**
  * Spawn, age, recycle.

package/dist/shaders/passes/particles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particles.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/particles.ts"],"names":[],"mappings":"AA+BA,sEAAsE;AACtE,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAA;IACb;;mFAE+E;IAC/E,UAAU,EAAE,MAAM,CAAA;IAClB,+EAA+E;IAC/E,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAkCD,qDAAqD;AACrD;0EAC0E;AAC1E,KAAK,aAAa,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,CAAA;AAEpD,KAAK,cAAc,GAAG;IACpB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,aAAa,CAAA;IACpB,qEAAqE;IACrE,KAAK,EAAE,OAAO,CAAA;IACd;;+BAE2B;IAC3B,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;iEAK6D;IAC7D,KAAK,EAAE,OAAO,CAAA;IACd;;;wEAGoE;IACpE,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,0FAA0F;AAC1F,eAAO,MAAM,sBAAsB,KAAK,CAAA;AACxC,iFAAiF;AACjF,eAAO,MAAM,uBAAuB,KAAK,CAAA;AAEzC,oEAAoE;AACpE,eAAO,MAAM,eAAe,KAAK,CAAA;AAwDjC;yEACyE;AACzE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAOlH;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAqDxF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CA2LvF"}
+{"version":3,"file":"particles.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/particles.ts"],"names":[],"mappings":"AA+BA,sEAAsE;AACtE,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAA;IACb;;mFAE+E;IAC/E,UAAU,EAAE,MAAM,CAAA;IAClB,+EAA+E;IAC/E,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAkCD,qDAAqD;AACrD;0EAC0E;AAC1E,KAAK,aAAa,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,CAAA;AAEpD,KAAK,cAAc,GAAG;IACpB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,aAAa,CAAA;IACpB,qEAAqE;IACrE,KAAK,EAAE,OAAO,CAAA;IACd;;+BAE2B;IAC3B,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;iEAK6D;IAC7D,KAAK,EAAE,OAAO,CAAA;IACd;;;;;;;kFAO8E;IAC9E,IAAI,EAAE,OAAO,CAAA;IACb;;;wEAGoE;IACpE,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,0FAA0F;AAC1F,eAAO,MAAM,sBAAsB,KAAK,CAAA;AACxC,iFAAiF;AACjF,eAAO,MAAM,uBAAuB,KAAK,CAAA;AACzC;;sDAEsD;AACtD,eAAO,MAAM,yBAAyB,KAAK,CAAA;AAC3C,eAAO,MAAM,uBAAuB,KAAK,CAAA;AACzC,eAAO,MAAM,6BAA6B,KAAK,CAAA;AAE/C,oEAAoE;AACpE,eAAO,MAAM,eAAe,KAAK,CAAA;AAwDjC;;2EAE2E;AAC3E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAQlI;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CA0ExF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CA2LvF"}

package/dist/shaders/passes/particles.js

@@ -46,6 +46,12 @@ fn _rzCastLive() -> i32 {
 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;
 const CAMERA_STRUCT = /* wgsl */ `
@@ -99,13 +105,15 @@ fn rzProject(p: vec3f) -> vec3f {
 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. */
+ *  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) {
     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),
     };
 }
 /**
@@ -143,8 +151,29 @@ ${src.paramsDecl}
         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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reze-engine",
-  "version": "0.58.2",
+  "version": "0.58.4",
   "description": "A lightweight WebGPU engine for real-time 3D MMD/PMX model rendering",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",