ugly-game 0.2.0 → 0.3.0

package/dist/gpuTerrain.js

@@ -0,0 +1,154 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// GPU TERRAIN — a smooth lit triangle-mesh renderer for the world surface (PLATFORM), replacing the
+// boxy instanced-cube look. Draws an indexed mesh (per-vertex position / normal / colour) with a sun
+// lambert term + ambient + distance fog + a translucent animated water plane. It BOTH casts (shadowPass:
+// its depth into the shared sun shadow map) and RECEIVES sun shadows (PCF sample in the fragment), so
+// hills and props darken the ground they occlude — which also makes the sun's direction legible.
+// ─────────────────────────────────────────────────────────────────────────────
+import { SHADOW_WGSL } from './gpuShadowMap';
+const TERRAIN = /* wgsl */ `
+struct U { mvp: mat4x4<f32>, sun: vec4<f32>, sunCol: vec4<f32>, amb: vec4<f32>, cam: vec4<f32>, fog: vec4<f32>, lightVP: mat4x4<f32>, shadowP: vec4<f32> };
+@group(0) @binding(0) var<uniform> u: U;
+@group(0) @binding(1) var shadowMap: texture_depth_2d;
+@group(0) @binding(2) var shadowSamp: sampler_comparison;
+struct VO { @builtin(position) pos: vec4<f32>, @location(0) world: vec3<f32>, @location(1) n: vec3<f32>, @location(2) c: vec3<f32> };
+@vertex fn vs(@location(0) p: vec3<f32>, @location(1) nrm: vec3<f32>, @location(2) col: vec3<f32>) -> VO {
+  var o: VO; o.pos = u.mvp * vec4(p, 1.0); o.world = p; o.n = nrm; o.c = col; return o;
+}
+` + SHADOW_WGSL + /* wgsl */ `
+@fragment fn fs(i: VO) -> @location(0) vec4<f32> {
+  let d = clamp(dot(normalize(i.n), -normalize(u.sun.xyz)), 0.0, 1.0);
+  let sh = shadowFactor(u.lightVP, i.world, d, u.shadowP.x, shadowMap, shadowSamp);
+  let lit = i.c * (u.amb.xyz + d * sh * u.sunCol.xyz);
+  let dist = length(i.world - u.cam.xyz);
+  let f = clamp(1.0 - exp(-dist * u.fog.w), 0.0, 1.0);
+  return vec4(mix(lit, u.fog.xyz, f), 1.0);
+}`;
+// Depth-only occluder pass: terrain depth from the sun's ortho view.
+const OCCLUDER = /* wgsl */ `
+@group(0) @binding(0) var<uniform> lightVP: mat4x4<f32>;
+@vertex fn vs(@location(0) p: vec3<f32>) -> @builtin(position) vec4<f32> { return lightVP * vec4(p, 1.0); }
+`;
+// cam.w carries a render clock (seconds) so the surface animates; ripples perturb the up-normal, driving
+// fresnel sky reflection (more reflective at grazing angles) + a sharp sun glint — a real water look.
+const WATER = /* wgsl */ `
+struct U { mvp: mat4x4<f32>, sun: vec4<f32>, sunCol: vec4<f32>, amb: vec4<f32>, cam: vec4<f32>, fog: vec4<f32> };
+@group(0) @binding(0) var<uniform> u: U;
+struct VO { @builtin(position) pos: vec4<f32>, @location(0) world: vec3<f32> };
+@vertex fn vs(@location(0) p: vec3<f32>) -> VO { var o: VO; o.pos = u.mvp * vec4(p, 1.0); o.world = p; return o; }
+@fragment fn fs(i: VO) -> @location(0) vec4<f32> {
+  let t = u.cam.w;
+  let view = normalize(u.cam.xyz - i.world);
+  let w1 = sin(i.world.x * 0.33 + t * 1.1) + sin(i.world.z * 0.27 - t * 0.9);
+  let w2 = sin(i.world.x * 0.12 - t * 0.55) + sin(i.world.z * 0.17 + t * 0.7);
+  let n = normalize(vec3(w1 * 0.05, 1.0, w2 * 0.05));
+  let fres = pow(clamp(1.0 - max(dot(view, n), 0.0), 0.0, 1.0), 4.0);
+  let deep = vec3(0.03, 0.13, 0.24);
+  let shallow = vec3(0.08, 0.30, 0.40);
+  var col = mix(shallow, deep, 0.55);
+  col = mix(col, u.fog.xyz, fres * 0.6);
+  let refl = reflect(normalize(u.sun.xyz), n);
+  let spec = pow(max(dot(view, refl), 0.0), 64.0);
+  col += u.sunCol.xyz * spec * 0.9;
+  let dist = length(i.world - u.cam.xyz);
+  let f = clamp(1.0 - exp(-dist * u.fog.w), 0.0, 1.0);
+  col = mix(col, u.fog.xyz, f);
+  return vec4(col, 0.80);
+}`;
+const U_FLOATS = 56; // mvp(16)+sun+sunCol+amb+cam+fog(20)+lightVP(16)+shadowP(4)
+export class GpuTerrainRenderer {
+    device;
+    terrainPipe;
+    waterPipe;
+    occPipe;
+    uBuf;
+    uBG;
+    uBGw;
+    lightBuf;
+    occBG;
+    posB = null;
+    nrmB = null;
+    colB = null;
+    idxB = null;
+    idxCount = 0;
+    waterB;
+    texel;
+    constructor(device, format, shadow) {
+        this.device = device;
+        this.texel = shadow.texel;
+        const tm = device.createShaderModule({ code: TERRAIN });
+        const vbuf = [
+            { arrayStride: 12, attributes: [{ shaderLocation: 0, offset: 0, format: 'float32x3' }] },
+            { arrayStride: 12, attributes: [{ shaderLocation: 1, offset: 0, format: 'float32x3' }] },
+            { arrayStride: 12, attributes: [{ shaderLocation: 2, offset: 0, format: 'float32x3' }] },
+        ];
+        this.terrainPipe = device.createRenderPipeline({ layout: 'auto', vertex: { module: tm, entryPoint: 'vs', buffers: vbuf }, fragment: { module: tm, entryPoint: 'fs', targets: [{ format }] }, primitive: { topology: 'triangle-list', cullMode: 'none' }, depthStencil: { format: 'depth24plus', depthWriteEnabled: true, depthCompare: 'less' } });
+        const wm = device.createShaderModule({ code: WATER });
+        this.waterPipe = device.createRenderPipeline({ layout: 'auto', vertex: { module: wm, entryPoint: 'vs', buffers: [{ arrayStride: 12, attributes: [{ shaderLocation: 0, offset: 0, format: 'float32x3' }] }] }, fragment: { module: wm, entryPoint: 'fs', targets: [{ format, blend: { color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha' }, alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha' } } }] }, primitive: { topology: 'triangle-list', cullMode: 'none' }, depthStencil: { format: 'depth24plus', depthWriteEnabled: false, depthCompare: 'less' } });
+        const om = device.createShaderModule({ code: OCCLUDER });
+        this.occPipe = device.createRenderPipeline({ layout: 'auto', vertex: { module: om, entryPoint: 'vs', buffers: [{ arrayStride: 12, attributes: [{ shaderLocation: 0, offset: 0, format: 'float32x3' }] }] }, primitive: { topology: 'triangle-list', cullMode: 'none' }, depthStencil: { format: 'depth32float', depthWriteEnabled: true, depthCompare: 'less' } });
+        this.uBuf = device.createBuffer({ size: U_FLOATS * 4, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+        this.uBG = device.createBindGroup({ layout: this.terrainPipe.getBindGroupLayout(0), entries: [{ binding: 0, resource: { buffer: this.uBuf } }, { binding: 1, resource: shadow.view }, { binding: 2, resource: shadow.sampler }] });
+        this.uBGw = device.createBindGroup({ layout: this.waterPipe.getBindGroupLayout(0), entries: [{ binding: 0, resource: { buffer: this.uBuf } }] });
+        this.lightBuf = device.createBuffer({ size: 64, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+        this.occBG = device.createBindGroup({ layout: this.occPipe.getBindGroupLayout(0), entries: [{ binding: 0, resource: { buffer: this.lightBuf } }] });
+        this.waterB = device.createBuffer({ size: 6 * 3 * 4, usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST });
+    }
+    /** Replace the terrain mesh (positions/normals/colors are Nx3, indices triangle list). */
+    setTerrain(positions, normals, colors, indices) {
+        const dev = this.device, U = GPUBufferUsage;
+        this.posB?.destroy();
+        this.nrmB?.destroy();
+        this.colB?.destroy();
+        this.idxB?.destroy();
+        const mk = (d, u) => { const b = dev.createBuffer({ size: d.byteLength, usage: u }); dev.queue.writeBuffer(b, 0, d); return b; };
+        this.posB = mk(positions, U.VERTEX | U.COPY_DST);
+        this.nrmB = mk(normals, U.VERTEX | U.COPY_DST);
+        this.colB = mk(colors, U.VERTEX | U.COPY_DST);
+        this.idxB = mk(indices, U.INDEX | U.COPY_DST);
+        this.idxCount = indices.length;
+    }
+    /** Occluder pass: draw the terrain depth into the shared shadow map from the sun's ortho view. */
+    shadowPass(pass, lightVP) {
+        if (!this.idxB || !this.posB)
+            return;
+        this.device.queue.writeBuffer(this.lightBuf, 0, lightVP);
+        pass.setPipeline(this.occPipe);
+        pass.setBindGroup(0, this.occBG);
+        pass.setVertexBuffer(0, this.posB);
+        pass.setIndexBuffer(this.idxB, 'uint32');
+        pass.drawIndexed(this.idxCount);
+    }
+    frame(enc, colorView, depthView, camVP, sunDir, sunCol, amb, camPos, fog, fogDensity, sea, extent, center, lightVP, time = 0, load = false) {
+        const u = new Float32Array(U_FLOATS);
+        u.set(camVP, 0);
+        u.set([sunDir[0], sunDir[1], sunDir[2], 0], 16);
+        u.set([sunCol[0], sunCol[1], sunCol[2], 0], 20);
+        u.set([amb[0], amb[1], amb[2], 0], 24);
+        u.set([camPos[0], camPos[1], camPos[2], time], 28);
+        u.set([fog[0], fog[1], fog[2], fogDensity], 32);
+        u.set(lightVP, 36);
+        u.set([this.texel, 0, 0, 0], 52);
+        this.device.queue.writeBuffer(this.uBuf, 0, u);
+        const [cx, cz] = center, e = extent;
+        this.device.queue.writeBuffer(this.waterB, 0, new Float32Array([cx - e, sea, cz - e, cx + e, sea, cz - e, cx + e, sea, cz + e, cx - e, sea, cz - e, cx + e, sea, cz + e, cx - e, sea, cz + e]));
+        const rp = enc.beginRenderPass({
+            colorAttachments: [{ view: colorView, ...(load ? { loadOp: 'load' } : { clearValue: { r: fog[0], g: fog[1], b: fog[2], a: 1 }, loadOp: 'clear' }), storeOp: 'store' }],
+            depthStencilAttachment: { view: depthView, ...(load ? { depthLoadOp: 'load' } : { depthClearValue: 1, depthLoadOp: 'clear' }), depthStoreOp: 'store' },
+        });
+        if (this.idxB && this.posB && this.nrmB && this.colB) {
+            rp.setPipeline(this.terrainPipe);
+            rp.setBindGroup(0, this.uBG);
+            rp.setVertexBuffer(0, this.posB);
+            rp.setVertexBuffer(1, this.nrmB);
+            rp.setVertexBuffer(2, this.colB);
+            rp.setIndexBuffer(this.idxB, 'uint32');
+            rp.drawIndexed(this.idxCount);
+        }
+        rp.setPipeline(this.waterPipe);
+        rp.setBindGroup(0, this.uBGw);
+        rp.setVertexBuffer(0, this.waterB);
+        rp.draw(6);
+        rp.end();
+    }
+}

package/dist/gpuTiled.d.ts

@@ -0,0 +1,55 @@
+export interface Instance {
+    x: number;
+    y: number;
+    z: number;
+    scale: number;
+    material: number;
+    bounds: number;
+}
+export interface Light {
+    x: number;
+    y: number;
+    z: number;
+    radius: number;
+    r: number;
+    g: number;
+    b: number;
+}
+export type Plane = readonly [number, number, number, number];
+export declare const TILE = 24, MAX_PER_TILE = 256;
+export declare class GpuTiledRenderer {
+    private device;
+    private format;
+    private instBuf;
+    private argsBuf;
+    private visBuf;
+    private camBuf;
+    private lightBuf;
+    private tileCountBuf;
+    private tileListBuf;
+    private readBuf;
+    private cullPipe;
+    private lightPipe;
+    private drawPipe;
+    private cullBG;
+    private lightBG;
+    private drawBG;
+    private count;
+    private capPerPipe;
+    private lightCount;
+    ntx: number;
+    nty: number;
+    numTiles: number;
+    constructor(device: GPUDevice, format: GPUTextureFormat);
+    setScene(instances: Instance[], capPerPipe: number, maxLights: number, w: number, h: number): void;
+    setLights(lights: Light[]): void;
+    frame(encoder: GPUCommandEncoder, view: GPUTextureView, depth: GPUTextureView, viewProj: Float32Array, right: number[], up: number[], fwd: number[], planes: Plane[], sun: number[], sunCol: number[], ambient: number, w: number, h: number): void;
+    /** Queue a copy of the tile-count buffer for readback (call on measure frames only). */
+    copyTileCounts(encoder: GPUCommandEncoder): void;
+    /** Read tile light counts → { avg, max } over non-empty tiles (proves O(lights-per-tile)). */
+    readTileStats(): Promise<{
+        avg: number;
+        max: number;
+        nonEmpty: number;
+    }>;
+}

package/dist/gpuTiled.js

@@ -0,0 +1,247 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// Tiled (forward+) light culling — scales the many-dynamic-lights renderer from
+// hundreds to THOUSANDS of lights. A COMPUTE pass bins each light into the screen
+// tiles its projected sphere overlaps; the fragment shader then shades only its
+// tile's lights → O(lights-per-tile) instead of O(all-lights). Same story as the
+// instance brute→grid cull, applied to lights. Builds on the GPU-driven lit backend
+// (shared/gpuLit). See design/moonshot-open-world.md §5 (phase 4), GAME.md §3.6.
+// ─────────────────────────────────────────────────────────────────────────────
+const INSTANCE_F32 = 8, ARG_U32 = 4, LIGHT_F32 = 8, CAM_F32 = 72;
+export const TILE = 24, MAX_PER_TILE = 256;
+const WGSL = /* wgsl */ `
+struct Inst { pos: vec4<f32>, attr: vec4<f32> };
+struct Args { vc: u32, ic: atomic<u32>, fv: u32, fi: u32 };
+struct Light { posr: vec4<f32>, color: vec4<f32> };
+struct Cam {
+  viewProj: mat4x4<f32>,
+  right: vec4<f32>, up: vec4<f32>, fwd: vec4<f32>,
+  planes: array<vec4<f32>, 6>,
+  counts: vec4<f32>,   // count, capPerPipe, pipelines, lightCount
+  sun: vec4<f32>, sunCol: vec4<f32>,
+  tile: vec4<f32>,     // tileSize, numTilesX, numTilesY, maxPerTile
+  screen: vec4<f32>,   // w, h
+};
+
+// ── instance frustum cull → per-pipeline indirect args ──
+@group(0) @binding(0) var<storage, read> instances: array<Inst>;
+@group(0) @binding(1) var<storage, read_write> args: array<Args>;
+@group(0) @binding(2) var<storage, read_write> visible: array<u32>;
+@group(0) @binding(3) var<uniform> cam: Cam;
+@compute @workgroup_size(64)
+fn cull(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let i = gid.x; if (i >= u32(cam.counts.x)) { return; }
+  let inst = instances[i]; let c = inst.pos.xyz; let r = inst.attr.y;
+  for (var p = 0u; p < 6u; p++) { let pl = cam.planes[p]; if (dot(pl.xyz, c) + pl.w < -r) { return; } }
+  let pipe = u32(inst.attr.x); let slot = atomicAdd(&args[pipe].ic, 1u); let cap = u32(cam.counts.y);
+  if (slot < cap) { visible[pipe * cap + slot] = i; }
+}
+
+// ── tiled light culling: bin each light into the screen tiles it overlaps ──
+@group(0) @binding(0) var<storage, read> lc_lights: array<Light>;
+@group(0) @binding(1) var<storage, read_write> tileCount: array<atomic<u32>>;
+@group(0) @binding(2) var<storage, read_write> tileList: array<u32>;
+@group(0) @binding(3) var<uniform> lc_cam: Cam;
+@compute @workgroup_size(64)
+fn cullLights(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let li = gid.x; if (li >= u32(lc_cam.counts.w)) { return; }
+  let L = lc_lights[li];
+  let clip = lc_cam.viewProj * vec4(L.posr.xyz, 1.0);
+  if (clip.w <= 0.0) { return; }                                 // behind camera (approx)
+  let inv = 1.0 / clip.w;
+  let sx = (clip.x * inv * 0.5 + 0.5) * lc_cam.screen.x;
+  let sy = (0.5 - clip.y * inv * 0.5) * lc_cam.screen.y;
+  let clipR = lc_cam.viewProj * vec4(L.posr.xyz + lc_cam.right.xyz * L.posr.w, 1.0);
+  let srx = (clipR.x / clipR.w * 0.5 + 0.5) * lc_cam.screen.x;
+  let sr = max(abs(srx - sx), 2.0);                              // screen-space radius (px)
+  let ts = lc_cam.tile.x; let ntx = i32(lc_cam.tile.y); let nty = i32(lc_cam.tile.z); let mpt = u32(lc_cam.tile.w);
+  let minx = clamp(i32((sx - sr) / ts), 0, ntx - 1); let maxx = clamp(i32((sx + sr) / ts), 0, ntx - 1);
+  let miny = clamp(i32((sy - sr) / ts), 0, nty - 1); let maxy = clamp(i32((sy + sr) / ts), 0, nty - 1);
+  for (var ty = miny; ty <= maxy; ty++) { for (var tx = minx; tx <= maxx; tx++) {
+    let tile = u32(ty * ntx + tx); let slot = atomicAdd(&tileCount[tile], 1u);
+    if (slot < mpt) { tileList[tile * mpt + slot] = li; }
+  } }
+}
+
+// ── lit render: impostor spheres shaded by sun + the pixel's TILE lights ──
+@group(0) @binding(0) var<storage, read> rinstances: array<Inst>;
+@group(0) @binding(1) var<storage, read> rvisible: array<u32>;
+@group(0) @binding(2) var<uniform> rcam: Cam;
+@group(0) @binding(3) var<storage, read> rlights: array<Light>;
+@group(0) @binding(4) var<storage, read> rTileCount: array<u32>;
+@group(0) @binding(5) var<storage, read> rTileList: array<u32>;
+
+struct VOut { @builtin(position) pos: vec4<f32>, @location(0) uv: vec2<f32>, @location(1) center: vec3<f32>, @location(2) scale: f32 };
+const QUAD = array<vec2<f32>, 6>(vec2(-1.,-1.), vec2(1.,-1.), vec2(1.,1.), vec2(-1.,-1.), vec2(1.,1.), vec2(-1.,1.));
+@vertex
+fn vs(@builtin(vertex_index) vi: u32, @builtin(instance_index) ii: u32) -> VOut {
+  let inst = rinstances[rvisible[ii]]; let q = QUAD[vi];
+  let world = inst.pos.xyz + (rcam.right.xyz * q.x + rcam.up.xyz * q.y) * inst.pos.w;
+  var o: VOut; o.pos = rcam.viewProj * vec4(world, 1.0); o.uv = q; o.center = inst.pos.xyz; o.scale = inst.pos.w; return o;
+}
+@fragment
+fn fs(v: VOut) -> @location(0) vec4<f32> {
+  let r2 = dot(v.uv, v.uv); if (r2 > 1.0) { discard; }
+  let nz = sqrt(1.0 - r2);
+  let N = normalize(rcam.right.xyz * v.uv.x + rcam.up.xyz * v.uv.y - rcam.fwd.xyz * nz);
+  let wp = v.center + N * v.scale;
+  let base = vec3<f32>(0.5, 0.52, 0.58);
+  var lit = base * rcam.sunCol.a + base * rcam.sunCol.rgb * max(dot(N, -rcam.sun.xyz), 0.0);
+  let ntx = u32(rcam.tile.y); let mpt = u32(rcam.tile.w);
+  let tx = min(u32(v.pos.x / rcam.tile.x), ntx - 1u); let ty = min(u32(v.pos.y / rcam.tile.x), u32(rcam.tile.z) - 1u);
+  let tile = ty * ntx + tx; let cnt = min(rTileCount[tile], mpt);
+  for (var j = 0u; j < cnt; j++) {
+    let L = rlights[rTileList[tile * mpt + j]];
+    let d3 = L.posr.xyz - wp; let d = length(d3); let rad = L.posr.w;
+    if (d < rad) { let a = 1.0 - d / rad; lit += base * L.color.rgb * max(dot(N, d3 / d), 0.0) * a * a; }
+  }
+  return vec4(lit, 1.0);
+}
+`;
+export class GpuTiledRenderer {
+    device;
+    format;
+    instBuf;
+    argsBuf;
+    visBuf;
+    camBuf;
+    lightBuf;
+    tileCountBuf;
+    tileListBuf;
+    readBuf;
+    cullPipe;
+    lightPipe;
+    drawPipe;
+    cullBG;
+    lightBG;
+    drawBG;
+    count = 0;
+    capPerPipe = 0;
+    lightCount = 0;
+    ntx = 0;
+    nty = 0;
+    numTiles = 0;
+    constructor(device, format) {
+        this.device = device;
+        this.format = format;
+    }
+    setScene(instances, capPerPipe, maxLights, w, h) {
+        const d = this.device;
+        this.count = instances.length;
+        this.capPerPipe = capPerPipe;
+        this.ntx = Math.ceil(w / TILE);
+        this.nty = Math.ceil(h / TILE);
+        this.numTiles = this.ntx * this.nty;
+        const idata = new Float32Array(this.count * INSTANCE_F32);
+        for (let i = 0; i < this.count; i++) {
+            const o = i * INSTANCE_F32, it = instances[i];
+            idata[o] = it.x;
+            idata[o + 1] = it.y;
+            idata[o + 2] = it.z;
+            idata[o + 3] = it.scale;
+            idata[o + 4] = it.material;
+            idata[o + 5] = it.bounds;
+        }
+        this.instBuf = d.createBuffer({ size: idata.byteLength, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+        d.queue.writeBuffer(this.instBuf, 0, idata);
+        this.argsBuf = d.createBuffer({ size: ARG_U32 * 4, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT | GPUBufferUsage.COPY_DST });
+        this.visBuf = d.createBuffer({ size: capPerPipe * 4, usage: GPUBufferUsage.STORAGE });
+        this.camBuf = d.createBuffer({ size: CAM_F32 * 4, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+        this.lightBuf = d.createBuffer({ size: maxLights * LIGHT_F32 * 4, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+        this.tileCountBuf = d.createBuffer({ size: this.numTiles * 4, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC });
+        this.tileListBuf = d.createBuffer({ size: this.numTiles * MAX_PER_TILE * 4, usage: GPUBufferUsage.STORAGE });
+        this.readBuf = d.createBuffer({ size: this.numTiles * 4, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ });
+        const mod = d.createShaderModule({ code: WGSL });
+        this.cullPipe = d.createComputePipeline({ layout: 'auto', compute: { module: mod, entryPoint: 'cull' } });
+        this.lightPipe = d.createComputePipeline({ layout: 'auto', compute: { module: mod, entryPoint: 'cullLights' } });
+        this.drawPipe = d.createRenderPipeline({ layout: 'auto', vertex: { module: mod, entryPoint: 'vs' }, fragment: { module: mod, entryPoint: 'fs', targets: [{ format: this.format }] }, primitive: { topology: 'triangle-list' }, depthStencil: { format: 'depth24plus', depthWriteEnabled: true, depthCompare: 'less' } });
+        this.cullBG = d.createBindGroup({ layout: this.cullPipe.getBindGroupLayout(0), entries: [{ binding: 0, resource: { buffer: this.instBuf } }, { binding: 1, resource: { buffer: this.argsBuf } }, { binding: 2, resource: { buffer: this.visBuf } }, { binding: 3, resource: { buffer: this.camBuf } }] });
+        this.lightBG = d.createBindGroup({ layout: this.lightPipe.getBindGroupLayout(0), entries: [{ binding: 0, resource: { buffer: this.lightBuf } }, { binding: 1, resource: { buffer: this.tileCountBuf } }, { binding: 2, resource: { buffer: this.tileListBuf } }, { binding: 3, resource: { buffer: this.camBuf } }] });
+        this.drawBG = d.createBindGroup({ layout: this.drawPipe.getBindGroupLayout(0), entries: [{ binding: 0, resource: { buffer: this.instBuf } }, { binding: 1, resource: { buffer: this.visBuf } }, { binding: 2, resource: { buffer: this.camBuf } }, { binding: 3, resource: { buffer: this.lightBuf } }, { binding: 4, resource: { buffer: this.tileCountBuf } }, { binding: 5, resource: { buffer: this.tileListBuf } }] });
+    }
+    setLights(lights) {
+        this.lightCount = lights.length;
+        const data = new Float32Array(lights.length * LIGHT_F32);
+        for (let i = 0; i < lights.length; i++) {
+            const o = i * LIGHT_F32, L = lights[i];
+            data[o] = L.x;
+            data[o + 1] = L.y;
+            data[o + 2] = L.z;
+            data[o + 3] = L.radius;
+            data[o + 4] = L.r;
+            data[o + 5] = L.g;
+            data[o + 6] = L.b;
+        }
+        this.device.queue.writeBuffer(this.lightBuf, 0, data);
+    }
+    frame(encoder, view, depth, viewProj, right, up, fwd, planes, sun, sunCol, ambient, w, h) {
+        const cam = new Float32Array(CAM_F32);
+        cam.set(viewProj, 0);
+        cam[16] = right[0];
+        cam[17] = right[1];
+        cam[18] = right[2];
+        cam[20] = up[0];
+        cam[21] = up[1];
+        cam[22] = up[2];
+        cam[24] = fwd[0];
+        cam[25] = fwd[1];
+        cam[26] = fwd[2];
+        for (let p = 0; p < 6; p++) {
+            cam[28 + p * 4] = planes[p][0];
+            cam[29 + p * 4] = planes[p][1];
+            cam[30 + p * 4] = planes[p][2];
+            cam[31 + p * 4] = planes[p][3];
+        }
+        cam[52] = this.count;
+        cam[53] = this.capPerPipe;
+        cam[54] = 1;
+        cam[55] = this.lightCount;
+        cam[56] = sun[0];
+        cam[57] = sun[1];
+        cam[58] = sun[2];
+        cam[60] = sunCol[0];
+        cam[61] = sunCol[1];
+        cam[62] = sunCol[2];
+        cam[63] = ambient;
+        cam[64] = TILE;
+        cam[65] = this.ntx;
+        cam[66] = this.nty;
+        cam[67] = MAX_PER_TILE;
+        cam[68] = w;
+        cam[69] = h;
+        this.device.queue.writeBuffer(this.camBuf, 0, cam);
+        this.device.queue.writeBuffer(this.argsBuf, 0, new Uint32Array([6, 0, 0, 0]));
+        this.device.queue.writeBuffer(this.tileCountBuf, 0, new Uint32Array(this.numTiles)); // reset tile counts to 0
+        const cp = encoder.beginComputePass();
+        cp.setPipeline(this.cullPipe);
+        cp.setBindGroup(0, this.cullBG);
+        cp.dispatchWorkgroups(Math.ceil(this.count / 64));
+        cp.setPipeline(this.lightPipe);
+        cp.setBindGroup(0, this.lightBG);
+        cp.dispatchWorkgroups(Math.ceil(this.lightCount / 64));
+        cp.end();
+        const rp = encoder.beginRenderPass({ colorAttachments: [{ view, clearValue: { r: 0.02, g: 0.03, b: 0.05, a: 1 }, loadOp: 'clear', storeOp: 'store' }], depthStencilAttachment: { view: depth, depthClearValue: 1, depthLoadOp: 'clear', depthStoreOp: 'store' } });
+        rp.setPipeline(this.drawPipe);
+        rp.setBindGroup(0, this.drawBG);
+        rp.drawIndirect(this.argsBuf, 0);
+        rp.end();
+    }
+    /** Queue a copy of the tile-count buffer for readback (call on measure frames only). */
+    copyTileCounts(encoder) { encoder.copyBufferToBuffer(this.tileCountBuf, 0, this.readBuf, 0, this.numTiles * 4); }
+    /** Read tile light counts → { avg, max } over non-empty tiles (proves O(lights-per-tile)). */
+    async readTileStats() {
+        await this.readBuf.mapAsync(GPUMapMode.READ);
+        const a = new Uint32Array(this.readBuf.getMappedRange().slice(0));
+        this.readBuf.unmap();
+        let sum = 0, max = 0, ne = 0;
+        for (let i = 0; i < this.numTiles; i++) {
+            const c = Math.min(a[i], MAX_PER_TILE);
+            if (c > 0) {
+                sum += c;
+                ne++;
+                if (c > max)
+                    max = c;
+            }
+        }
+        return { avg: ne ? sum / ne : 0, max, nonEmpty: ne };
+    }
+}

package/dist/gpuWorld.d.ts

@@ -0,0 +1,49 @@
+import type { CubeInstance } from './gpuShadow';
+/** A dynamic instance that also knows where it was last frame (for its motion vector). */
+export interface WorldInstance extends CubeInstance {
+    px: number;
+    py: number;
+    pz: number;
+}
+export declare class GpuWorldRenderer {
+    private device;
+    private w;
+    private h;
+    private instBuf;
+    private scratch;
+    private count;
+    private uBuf;
+    private rBuf;
+    private u;
+    private r;
+    private lightScratch;
+    private lightBuf;
+    private shadowTex;
+    private shadowView;
+    private shadowSamp;
+    private histSamp;
+    private shadowPipe;
+    private scenePipe;
+    private resolvePipe;
+    private shadowBGL;
+    private sceneBGL;
+    private resolveBGL;
+    private shadowBG;
+    private sceneBG;
+    private colorTex?;
+    private colorView;
+    private motionTex?;
+    private motionView;
+    private depthTex?;
+    private depthView;
+    private hist;
+    private histView;
+    private resolveBG;
+    private ping;
+    constructor(device: GPUDevice, format: GPUTextureFormat);
+    resize(w: number, h: number): void;
+    setCapacity(cap: number): void;
+    updateInstances(list: WorldInstance[]): void;
+    /** currVP/prevVP/lightVP: Float32Array(16). jitter: clip sub-pixel. */
+    frame(enc: GPUCommandEncoder, swapView: GPUTextureView, currVP: Float32Array, prevVP: Float32Array, lightVP: Float32Array, jitter: [number, number], sunDir: [number, number, number], ambient: number, taaOn: boolean, blend: number): void;
+}