ugly-game 0.7.6 → 0.7.8

package/dist/gpuShadow.d.ts

@@ -47,10 +47,13 @@ export declare class GpuShadowRenderer {
     private tileRectBuf;
     private useAtlas;
     private alphaPipe;
+    private alphaBGL;
     private overlayBuf;
     private overlayBG;
+    private overlayCap;
     private overlayScratch;
     private overlayCount;
+    private overlayDeferred;
     private cullPipe;
     private cullBGL;
     private cap;
@@ -96,8 +99,19 @@ export declare class GpuShadowRenderer {
     /** Dynamic scene: pre-allocate for `cap` instances; call updateInstances() each frame. */
     setCapacity(cap: number): void;
     updateInstances(instances: CubeInstance[]): void;
-    /** Translucent overlay cubes drawn over the opaque scene each frame; `emissive` carries per-cube alpha. */
-    updateOverlay(instances: CubeInstance[]): void;
+    /** Translucent overlay cubes drawn over the opaque scene; `emissive` carries per-cube alpha (0..1). The buffer
+     *  GROWS to fit (no hard cap). Pass `eye` to SORT the cubes back-to-front (farthest first) so overlapping
+     *  translucent cubes blend in the correct order — required for anything denser than the place ghost. By default
+     *  the cubes draw at the end of frame(); call deferOverlay(true) + overlayPass() to draw them after your own
+     *  transparent passes (e.g. water) so those don't paint over them. */
+    updateOverlay(instances: CubeInstance[], eye?: [number, number, number]): void;
+    /** Defer the translucent overlay out of frame() so the caller draws it via overlayPass() AFTER its own
+     *  transparent geometry (e.g. water). Otherwise those later passes paint over the overlay. */
+    deferOverlay(on: boolean): void;
+    /** Draw the translucent overlay in its own pass over `colorView`, depth-tested (read-only) against `depthView`
+     *  — same pipeline as the in-frame draw, just callable after other transparent passes. Pairs with
+     *  deferOverlay(true). No-op if the overlay is empty. */
+    overlayPass(enc: GPUCommandEncoder, colorView: GPUTextureView, depthView: GPUTextureView): void;
     /** Write a frustum's cull uniform: 6 planes + count + this frustum's VP + occlusion params (occ on the camera pass). */
     private writeCull;
     /** The sun shadow-map depth view + its comparison sampler + texel size. Feed these into GpuPropsRenderer/

package/dist/gpuShadow.js

@@ -145,9 +145,18 @@ fn cull(@builtin(global_invocation_id) gid: vec3<u32>) {
       let t1 = vec2<i32>(floor(clamp(mx, vec2<f32>(0.0), vec2<f32>(1.0)) * dim));
       // only query a bounded footprint; a huge on-screen box just isn't occlusion-tested (kept)
       if (t1.x - t0.x <= 8 && t1.y - t0.y <= 8) {
+        // DILATE the query by 2 Hi-Z texels. hiz is LAST frame's depth; under camera motion a cube reprojects by
+        // a few source pixels between frames, so a cube sitting at an occluder's silhouette gets tested against
+        // stale NEAR depth from where the occluder used to be and is wrongly culled — it blinks out for a frame
+        // (worst on thin/sparse geometry, but a one-frame hole in dense terrain too). Taking MAX over a dilated
+        // footprint is strictly MORE conservative (it can only raise farOccluder ⇒ only ever KEEP more cubes), so it
+        // never hides real geometry; it just leaves a couple of deeply-hidden cubes unculled. 2×8px of slack.
+        let lim = vec2<i32>(i32(cc.occ.y) - 1, i32(cc.occ.z) - 1);
+        let q0 = max(t0 - vec2<i32>(2, 2), vec2<i32>(0, 0));
+        let q1 = min(t1 + vec2<i32>(2, 2), lim);
         var farOccluder = 0.0;                          // MAX over the footprint of the coarse max-depth
-        for (var y = t0.y; y <= t1.y; y++) {
-          for (var x = t0.x; x <= t1.x; x++) {
+        for (var y = q0.y; y <= q1.y; y++) {
+          for (var x = q0.x; x <= q1.x; x++) {
             farOccluder = max(farOccluder, textureLoad(hiz, vec2<i32>(x, y), 0).r);
           }
         }
@@ -341,10 +350,13 @@ export class GpuShadowRenderer {
     tileRectBuf;
     useAtlas = 0;
     alphaPipe;
+    alphaBGL; // kept so the overlay buffer can grow and rebind on demand
     overlayBuf;
     overlayBG;
+    overlayCap = OVERLAY_CAP; // grows to fit — the overlay is no longer hard-capped
     overlayScratch = new Float32Array(OVERLAY_CAP * INST_F);
     overlayCount = 0;
+    overlayDeferred = false; // when true, frame() does NOT draw the overlay — the caller draws it via overlayPass()
     // GPU-driven culling: one compute pipeline; per-frustum (camera + light) indirect args + compacted visible lists.
     cullPipe;
     cullBGL;
@@ -473,7 +485,7 @@ export class GpuShadowRenderer {
         });
         // translucent overlay: alpha-blended, depth-tested but not depth-writing (drawn after opaque)
         const alphaMod = device.createShaderModule({ code: ALPHA_WGSL });
-        const alphaBGL = device.createBindGroupLayout({
+        const alphaBGL = (this.alphaBGL = device.createBindGroupLayout({
             entries: [
                 {
                     binding: 0,
@@ -486,7 +498,7 @@ export class GpuShadowRenderer {
                     buffer: { type: 'read-only-storage' },
                 },
             ],
-        });
+        }));
         this.alphaPipe = device.createRenderPipeline({
             layout: device.createPipelineLayout({ bindGroupLayouts: [alphaBGL] }),
             vertex: { module: alphaMod, entryPoint: 'vs' },
@@ -791,14 +803,67 @@ export class GpuShadowRenderer {
         this.device.queue.writeBuffer(this.instBuf, 0, this.scratch, 0, n * INST_F);
         this.count = n;
     }
-    /** Translucent overlay cubes drawn over the opaque scene each frame; `emissive` carries per-cube alpha. */
-    updateOverlay(instances) {
-        const n = Math.min(instances.length, OVERLAY_CAP);
-        this.fill(this.overlayScratch, instances, n);
+    /** Translucent overlay cubes drawn over the opaque scene; `emissive` carries per-cube alpha (0..1). The buffer
+     *  GROWS to fit (no hard cap). Pass `eye` to SORT the cubes back-to-front (farthest first) so overlapping
+     *  translucent cubes blend in the correct order — required for anything denser than the place ghost. By default
+     *  the cubes draw at the end of frame(); call deferOverlay(true) + overlayPass() to draw them after your own
+     *  transparent passes (e.g. water) so those don't paint over them. */
+    updateOverlay(instances, eye) {
+        let list = instances;
+        if (eye && instances.length > 1) {
+            // back-to-front: a nearer translucent cube must blend OVER a farther one, so draw the farthest first
+            list = instances
+                .map((c) => ({
+                c,
+                d: (c.x - eye[0]) * (c.x - eye[0]) +
+                    (c.y - eye[1]) * (c.y - eye[1]) +
+                    (c.z - eye[2]) * (c.z - eye[2]),
+            }))
+                .sort((a, b) => b.d - a.d)
+                .map((o) => o.c);
+        }
+        const n = list.length;
+        if (n > this.overlayCap) {
+            this.overlayCap = Math.ceil(n * 1.5);
+            this.overlayScratch = new Float32Array(this.overlayCap * INST_F);
+            this.overlayBuf.destroy();
+            this.overlayBuf = this.device.createBuffer({
+                size: this.overlayScratch.byteLength,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+            });
+            this.overlayBG = this.device.createBindGroup({
+                layout: this.alphaBGL,
+                entries: [
+                    { binding: 0, resource: { buffer: this.camBuf } },
+                    { binding: 1, resource: { buffer: this.overlayBuf } },
+                ],
+            });
+        }
+        this.fill(this.overlayScratch, list, n);
         if (n > 0)
             this.device.queue.writeBuffer(this.overlayBuf, 0, this.overlayScratch, 0, n * INST_F);
         this.overlayCount = n;
     }
+    /** Defer the translucent overlay out of frame() so the caller draws it via overlayPass() AFTER its own
+     *  transparent geometry (e.g. water). Otherwise those later passes paint over the overlay. */
+    deferOverlay(on) {
+        this.overlayDeferred = on;
+    }
+    /** Draw the translucent overlay in its own pass over `colorView`, depth-tested (read-only) against `depthView`
+     *  — same pipeline as the in-frame draw, just callable after other transparent passes. Pairs with
+     *  deferOverlay(true). No-op if the overlay is empty. */
+    overlayPass(enc, colorView, depthView) {
+        if (this.overlayCount === 0)
+            return;
+        const mp = enc.beginRenderPass({
+            colorAttachments: [{ view: colorView, loadOp: 'load', storeOp: 'store' }],
+            depthStencilAttachment: { view: depthView, depthReadOnly: true },
+        });
+        mp.setPipeline(this.alphaPipe);
+        mp.setBindGroup(0, this.overlayBG);
+        mp.draw(36, this.overlayCount);
+        mp.end();
+    }
     /** Write a frustum's cull uniform: 6 planes + count + this frustum's VP + occlusion params (occ on the camera pass). */
     writeCull(buf, vp, occlude) {
         const planes = frustumPlanes(vp);
@@ -914,11 +979,11 @@ export class GpuShadowRenderer {
         mp.setPipeline(this.mainPipe);
         mp.setBindGroup(0, this.mainBG);
         mp.drawIndirect(this.camArgs, 0);
-        if (this.overlayCount > 0) {
+        if (!this.overlayDeferred && this.overlayCount > 0) {
             mp.setPipeline(this.alphaPipe);
             mp.setBindGroup(0, this.overlayBG);
             mp.draw(36, this.overlayCount);
-        } // translucent overlay last (uncapped, no cull)
+        } // translucent overlay last (no cull) — unless deferred to overlayPass() (drawn after the caller's water etc.)
         mp.end();
         // Rebuild the coarse Hi-Z from the depth just written → next frame's cull uses it.
         if (occlusion) {

package/dist/loop/simCore.js

@@ -59,9 +59,10 @@ export function coopStepBatch(opts) {
         stepped++;
     };
     // STEP_BUDGET burst first (forced, deterministic — independent of the target AND of play/pause, so a harness can
-    // advance a paused world).
+    // advance a paused world). The FULL budget runs (not maxCatch-bounded): it's a caller-chosen finite count, so a
+    // replay/harness step(N) advances exactly N — dropping the remainder would make deterministic advance lossy.
     let budget = opts.ctl.takeStepBudget();
-    while (budget-- > 0 && stepped < maxCatch)
+    while (budget-- > 0)
         stepOnce();
     // Then chase the target — but only while PLAYING. Pausing freezes the sim without touching the queue or budget.
     if (opts.ctl.playing) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ugly-game",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "type": "module",
   "exports": {
     ".": {