ugly-game 0.5.18 → 0.5.19

package/dist/assets/anim.js

@@ -1,6 +1,18 @@
-const u16 = (v) => { const a = new Uint8Array(2); new DataView(a.buffer).setUint16(0, v, true); return a; };
-const u32 = (v) => { const a = new Uint8Array(4); new DataView(a.buffer).setUint32(0, v, true); return a; };
-const i16 = (v) => { const a = new Uint8Array(2); new DataView(a.buffer).setInt16(0, v, true); return a; };
+const u16 = (v) => {
+    const a = new Uint8Array(2);
+    new DataView(a.buffer).setUint16(0, v, true);
+    return a;
+};
+const u32 = (v) => {
+    const a = new Uint8Array(4);
+    new DataView(a.buffer).setUint32(0, v, true);
+    return a;
+};
+const i16 = (v) => {
+    const a = new Uint8Array(2);
+    new DataView(a.buffer).setInt16(0, v, true);
+    return a;
+};
 const f32s = (arr) => new Uint8Array(arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength));
 const f32 = (v) => f32s(Float32Array.of(v));
 export function packAnim(clip) {

package/dist/assets/animMoat.js

@@ -26,7 +26,12 @@ export function continuityScan(trace, factor = 8, floor = 0.02) {
                 violations.push({ tick: t, index: i, jump: a, ratio: a / base });
         }
     }
-    return { ticks: T, components: C, violations, clean: violations.length === 0 };
+    return {
+        ticks: T,
+        components: C,
+        violations,
+        clean: violations.length === 0,
+    };
 }
 /** The animation IR: the deterministic per-tick bone-matrix palette for a clip sampled over `ticks`. */
 export function animationPaletteTrace(skel, clip, ticks) {
@@ -44,12 +49,23 @@ export function scanAnimationContinuity(skel, clip, ticks = 120, factor = 8, flo
     const r = continuityScan(animationPaletteTrace(skel, clip, ticks), factor, floor);
     const seen = new Set();
     const violations = [];
-    for (const v of r.violations) { // dedupe to one entry per (tick,joint)
+    for (const v of r.violations) {
+        // dedupe to one entry per (tick,joint)
         const joint = Math.floor(v.index / 16), key = `${v.tick}:${joint}`;
         if (seen.has(key))
             continue;
         seen.add(key);
-        violations.push({ clipTime: ticks > 1 ? (v.tick / (ticks - 1)) * clip.duration : 0, joint, element: v.index % 16, ratio: v.ratio });
+        violations.push({
+            clipTime: ticks > 1 ? (v.tick / (ticks - 1)) * clip.duration : 0,
+            joint,
+            element: v.index % 16,
+            ratio: v.ratio,
+        });
     }
-    return { clean: violations.length === 0, ticks, duration: clip.duration, violations };
+    return {
+        clean: violations.length === 0,
+        ticks,
+        duration: clip.duration,
+        violations,
+    };
 }

package/dist/assets/assemble.js

@@ -12,7 +12,11 @@ import { dsin, dcos } from '../dmath';
 import { resolveKit } from './partkit';
 import { resolveRole } from './style';
 function applyPoint(M, x, y, z) {
-    return [M[0] * x + M[4] * y + M[8] * z + M[12], M[1] * x + M[5] * y + M[9] * z + M[13], M[2] * x + M[6] * y + M[10] * z + M[14]];
+    return [
+        M[0] * x + M[4] * y + M[8] * z + M[12],
+        M[1] * x + M[5] * y + M[9] * z + M[13],
+        M[2] * x + M[6] * y + M[10] * z + M[14],
+    ];
 }
 /** Assemble a rigged creature mesh from a genome. Deterministic + style-conformant. */
 export function assemble(arch, kit, genome, guide) {
@@ -20,28 +24,41 @@ export function assemble(arch, kit, genome, guide) {
     const prop = genome.proportion;
     // 1) Deform the shared rig's rest translations (bone lengths). Default per-joint scale = [girth,height,
     //    girth]; limb sockets add limbLength, head sockets add headScale. inverseBind stays ORIGINAL.
-    const sv = arch.restLocals.map(() => [prop.girth, prop.height, prop.girth]);
+    const sv = arch.restLocals.map(() => [
+        prop.girth,
+        prop.height,
+        prop.girth,
+    ]);
     for (const s of arch.sockets) {
         const j = s.jointIndex;
         if (j < 0 || j >= sv.length)
             continue;
-        const f = s.region === 'limb' ? prop.limbLength : s.region === 'head' ? prop.headScale : 1;
+        const f = s.region === 'limb'
+            ? prop.limbLength
+            : s.region === 'head'
+                ? prop.headScale
+                : 1;
         sv[j] = [sv[j][0] * f, sv[j][1] * f, sv[j][2] * f];
     }
     const restLocals = arch.restLocals.map((r, j) => ({
         t: [r.t[0] * sv[j][0], r.t[1] * sv[j][1], r.t[2] * sv[j][2]],
-        q: [r.q[0], r.q[1], r.q[2], r.q[3]], s: [r.s[0], r.s[1], r.s[2]],
+        q: [r.q[0], r.q[1], r.q[2], r.q[3]],
+        s: [r.s[0], r.s[1], r.s[2]],
     }));
     // 2) Weld each selected part (deterministic socket order) with its per-part deform, concatenating
     //    positions/indices/joints/weights into one mesh sharing the archetype's parents + inverseBind.
     const positions = [], indices = [], joints = [], weights = [], roles = [];
     let minx = Infinity, miny = Infinity, minz = Infinity, maxx = -Infinity, maxy = -Infinity, maxz = -Infinity;
-    const sockets = [...arch.sockets].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    const sockets = [...arch.sockets].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
     for (const s of sockets) {
         const part = selected[s.id];
         if (!part)
             continue;
-        const d = genome.partDeform[s.id] ?? { scale: [1, 1, 1], stretch: [1, 1, 1], twist: 0 };
+        const d = genome.partDeform[s.id] ?? {
+            scale: [1, 1, 1],
+            stretch: [1, 1, 1],
+            twist: 0,
+        };
         // socket joint bind position (= translation of the inverse of its inverseBind) → deform pivots here
         const j = s.jointIndex, ib = new Float64Array(16);
         for (let i = 0; i < 16; i++)
@@ -51,7 +68,11 @@ export function assemble(arch, kit, genome, guide) {
         const half = d.twist / 2, qy = [0, dsin(half), 0, dcos(half)];
         const Tp = composeTRS([bx, by, bz], [0, 0, 0, 1], [1, 1, 1]);
         const R = composeTRS([0, 0, 0], qy, [1, 1, 1]);
-        const S = composeTRS([0, 0, 0], [0, 0, 0, 1], [d.scale[0] * d.stretch[0], d.scale[1] * d.stretch[1], d.scale[2] * d.stretch[2]]);
+        const S = composeTRS([0, 0, 0], [0, 0, 0, 1], [
+            d.scale[0] * d.stretch[0],
+            d.scale[1] * d.stretch[1],
+            d.scale[2] * d.stretch[2],
+        ]);
         const Tn = composeTRS([-bx, -by, -bz], [0, 0, 0, 1], [1, 1, 1]);
         const W = mul(Tp, mul(R, mul(S, Tn)));
         const base = positions.length / 3, pv = part.mesh.positions.length / 3;
@@ -75,18 +96,33 @@ export function assemble(arch, kit, genome, guide) {
                 ws += part.weights[v * 4 + k];
             for (let k = 0; k < 4; k++) {
                 joints.push(part.joints[v * 4 + k]);
-                weights.push(ws > 0 ? part.weights[v * 4 + k] / ws : (k === 0 ? 1 : 0));
+                weights.push(ws > 0 ? part.weights[v * 4 + k] / ws : k === 0 ? 1 : 0);
             }
         }
         for (const idx of part.mesh.indices)
             indices.push(idx + base);
-        roles.push({ first: base, count: pv, region: part.tag.region, role: resolveRole(guide, part.tag.region) });
+        roles.push({
+            first: base,
+            count: pv,
+            region: part.tag.region,
+            role: resolveRole(guide, part.tag.region),
+        });
     }
     return {
-        mesh: { positions: new Float32Array(positions), indices: new Uint32Array(indices) },
-        jointCount: arch.jointCount, parents: arch.parents, inverseBind: arch.inverseBind,
-        jointsPerVertex: new Uint16Array(joints), weightsPerVertex: new Float32Array(weights),
-        restLocals, rootWorld: arch.rootWorld, roles,
-        bounds: positions.length ? [minx, miny, minz, maxx, maxy, maxz] : [0, 0, 0, 0, 0, 0],
+        mesh: {
+            positions: new Float32Array(positions),
+            indices: new Uint32Array(indices),
+        },
+        jointCount: arch.jointCount,
+        parents: arch.parents,
+        inverseBind: arch.inverseBind,
+        jointsPerVertex: new Uint16Array(joints),
+        weightsPerVertex: new Float32Array(weights),
+        restLocals,
+        rootWorld: arch.rootWorld,
+        roles,
+        bounds: positions.length
+            ? [minx, miny, minz, maxx, maxy, maxz]
+            : [0, 0, 0, 0, 0, 0],
     };
 }

package/dist/assets/genome.js

@@ -11,13 +11,22 @@ import { partsForSocket } from './partkit';
 /** Deterministic mulberry32 (local copy so the platform module has no game-code dependency). */
 function rng(seed) {
     let a = seed >>> 0;
-    return () => { a = (a + 0x6d2b79f5) | 0; let t = Math.imul(a ^ (a >>> 15), 1 | a); t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; return ((t ^ (t >>> 14)) >>> 0) / 4294967296; };
+    return () => {
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
 }
 const lerp = (r, lo, hi) => lo + (hi - lo) * r;
-function hashStr(s) { let h = 2166136261 >>> 0; for (let i = 0; i < s.length; i++) {
-    h ^= s.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-} return h >>> 0; }
+function hashStr(s) {
+    let h = 2166136261 >>> 0;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+}
 /** Sample a full genome from a seed: pick a part per socket, deform it, set global proportion + palette.
  *  Per-field seed splits keep draws independent (adding a field can't perturb earlier ones). */
 export function sampleGenome(arch, kit, seed) {
@@ -29,27 +38,62 @@ export function sampleGenome(arch, kit, seed) {
         if (opts.length)
             parts[s.id] = opts[Math.floor(rp() * opts.length) % opts.length].tag.id;
         partDeform[s.id] = {
-            scale: [lerp(rd(), 0.85, 1.15), lerp(rd(), 0.85, 1.15), lerp(rd(), 0.85, 1.15)],
-            stretch: [lerp(rd(), 0.9, 1.1), lerp(rd(), 0.9, 1.1), lerp(rd(), 0.9, 1.1)],
+            scale: [
+                lerp(rd(), 0.85, 1.15),
+                lerp(rd(), 0.85, 1.15),
+                lerp(rd(), 0.85, 1.15),
+            ],
+            stretch: [
+                lerp(rd(), 0.9, 1.1),
+                lerp(rd(), 0.9, 1.1),
+                lerp(rd(), 0.9, 1.1),
+            ],
             twist: lerp(rd(), -0.3, 0.3),
         };
     }
     const rprop = rng(seed ^ 0x3003);
-    const proportion = { height: lerp(rprop(), 0.8, 1.3), girth: lerp(rprop(), 0.85, 1.2), limbLength: lerp(rprop(), 0.85, 1.2), headScale: lerp(rprop(), 0.85, 1.25) };
+    const proportion = {
+        height: lerp(rprop(), 0.8, 1.3),
+        girth: lerp(rprop(), 0.85, 1.2),
+        limbLength: lerp(rprop(), 0.85, 1.2),
+        headScale: lerp(rprop(), 0.85, 1.25),
+    };
     const rpal = rng(seed ^ 0x4004);
     const roleRamp = {};
     for (const s of arch.sockets)
         roleRamp[s.region] ??= Math.floor(rpal() * 6);
-    return { archetypeId: arch.id, partKitVersion: kit.version, seed, parts, partDeform, proportion, palette: { guideId: '', roleRamp } };
+    return {
+        archetypeId: arch.id,
+        partKitVersion: kit.version,
+        seed,
+        parts,
+        partDeform,
+        proportion,
+        palette: { guideId: '', roleRamp },
+    };
 }
 /** Stable canonical string (sorted keys, fixed float precision) → the cache/replay identity. */
 export function canonicalizeGenome(g) {
     const fx = (n) => n.toFixed(6);
-    const parts = Object.keys(g.parts).sort().map((k) => `${k}:${g.parts[k]}`).join(',');
-    const def = Object.keys(g.partDeform).sort().map((k) => { const d = g.partDeform[k]; return `${k}:${d.scale.map(fx)}|${d.stretch.map(fx)}|${fx(d.twist)}`; }).join(',');
+    const parts = Object.keys(g.parts)
+        .sort()
+        .map((k) => `${k}:${g.parts[k]}`)
+        .join(',');
+    const def = Object.keys(g.partDeform)
+        .sort()
+        .map((k) => {
+        const d = g.partDeform[k];
+        return `${k}:${d.scale.map(fx)}|${d.stretch.map(fx)}|${fx(d.twist)}`;
+    })
+        .join(',');
     const p = g.proportion, prop = [p.height, p.girth, p.limbLength, p.headScale].map(fx).join(',');
-    const ramp = Object.keys(g.palette.roleRamp).sort().map((k) => `${k}:${g.palette.roleRamp[k]}`).join(',');
+    const ramp = Object.keys(g.palette.roleRamp)
+        .sort()
+        .map((k) => `${k}:${g.palette.roleRamp[k]}`)
+        .join(',');
     return `${g.archetypeId}#${g.partKitVersion}#${parts}#${def}#${prop}#${g.palette.guideId}:${ramp}`;
 }
 /** Content hash including the kit version (a kit change invalidates caches deterministically). */
-export function genomeHash(g) { return fnv1a(canonicalizeGenome(g) + '|' + String(g.partKitVersion)); }
+export function genomeHash(g) {
+    return fnv1a(canonicalizeGenome(g) + '|' + String(g.partKitVersion));
+}

package/dist/assets/genomeExplore.js

@@ -10,21 +10,32 @@
 import { sampleGenome } from './genome';
 import { assemble } from './assemble';
 import { composeTRS, forwardKinematics, buildPalette } from './pose';
-function toMat(arr) { const m = new Float64Array(16); for (let i = 0; i < 16; i++)
-    m[i] = arr[i] ?? 0; return m; }
+function toMat(arr) {
+    const m = new Float64Array(16);
+    for (let i = 0; i < 16; i++)
+        m[i] = arr[i] ?? 0;
+    return m;
+}
 /** The largest VERTICAL gap between an assembled creature's parts (by role vertex-range Y-extents). A
  *  big gap means a body region has NO geometry — e.g. dropped mesh primitives (a multi-material sub-mesh
  *  silently skipped) or a missing socket. Structural validity + bind correctness both MISS this; it is
  *  the mesh-COMPLETENESS check the pipeline lacked (it hid the "floating head / no chest" render bug). */
 export function verticalCoverageGap(a) {
     const pos = a.mesh.positions;
-    const ranges = a.roles.map((r) => { let lo = Infinity, hi = -Infinity; for (let v = r.first; v < r.first + r.count; v++) {
-        const y = pos[v * 3 + 1];
-        if (y < lo)
-            lo = y;
-        if (y > hi)
-            hi = y;
-    } return [lo, hi]; }).filter((r) => r[0] <= r[1]).sort((p, q) => p[0] - q[0]);
+    const ranges = a.roles
+        .map((r) => {
+        let lo = Infinity, hi = -Infinity;
+        for (let v = r.first; v < r.first + r.count; v++) {
+            const y = pos[v * 3 + 1];
+            if (y < lo)
+                lo = y;
+            if (y > hi)
+                hi = y;
+        }
+        return [lo, hi];
+    })
+        .filter((r) => r[0] <= r[1])
+        .sort((p, q) => p[0] - q[0]);
     if (ranges.length < 2)
         return 0;
     let cover = ranges[0][1], maxGap = 0;
@@ -57,7 +68,7 @@ export function auditGenome(arch, kit, guide, g) {
     const failures = [];
     try {
         for (const s of arch.sockets)
-            if (g.parts[s.id] === undefined)
+            if (!(s.id in g.parts))
                 failures.push(`socket ${s.id} unfilled`);
         const a = assemble(arch, kit, g, guide);
         const vc = a.mesh.positions.length / 3;
@@ -79,13 +90,14 @@ export function auditGenome(arch, kit, guide, g) {
             failures.push('skin weights do not sum to 1');
         if (a.roles.reduce((t, r) => t + r.count, 0) !== vc)
             failures.push('roles do not cover all vertices');
-        if (a.roles.some((r) => guide.roles[r.role] === undefined))
+        if (a.roles.some((r) => !(r.role in guide.roles)))
             failures.push('assigned role not in StyleGuide');
         const gap = verticalCoverageGap(a), height = a.bounds[4] - a.bounds[1];
         if (height > 0 && gap > 0.12 * height)
             failures.push(`vertical geometry gap ${gap.toFixed(2)} of ${height.toFixed(2)} tall — a body region has no mesh (dropped primitive / missing part?)`);
         const b = assemble(arch, kit, g, guide);
-        if (JSON.stringify([...a.mesh.positions]) !== JSON.stringify([...b.mesh.positions]))
+        if (JSON.stringify([...a.mesh.positions]) !==
+            JSON.stringify([...b.mesh.positions]))
             failures.push('non-deterministic assemble');
     }
     catch (e) {

package/dist/assets/geometry.js

@@ -9,7 +9,9 @@ import { MeshoptEncoder, MeshoptDecoder } from 'meshoptimizer';
 const POS_STRIDE = 8; // 4 × uint16 (x,y,z + pad) — meshopt requires stride % 4 == 0; the constant
 // pad channel costs ~nothing after encoding.
 const AABB_BYTES = 24; // 6 × float32: min.xyz, max.xyz, prepended to the vtx payload.
-const quant = (v, lo, hi) => hi > lo ? Math.max(0, Math.min(65535, Math.round((v - lo) / (hi - lo) * 65535))) : 0;
+const quant = (v, lo, hi) => hi > lo
+    ? Math.max(0, Math.min(65535, Math.round(((v - lo) / (hi - lo)) * 65535)))
+    : 0;
 function bounds3(p) {
     let a = Infinity, b = Infinity, c = Infinity, d = -Infinity, e = -Infinity, f = -Infinity;
     for (let i = 0; i < p.length; i += 3) {
@@ -51,7 +53,13 @@ export function compactMesh(positions, indices, uvs) {
         }
         outIdx[i] = n;
     }
-    return uvs ? { positions: Float32Array.from(posOut), indices: outIdx, uvs: Float32Array.from(uvOut) } : { positions: Float32Array.from(posOut), indices: outIdx };
+    return uvs
+        ? {
+            positions: Float32Array.from(posOut),
+            indices: outIdx,
+            uvs: Float32Array.from(uvOut),
+        }
+        : { positions: Float32Array.from(posOut), indices: outIdx };
 }
 export async function encodeGeometry(m) {
     await MeshoptEncoder.ready;
@@ -86,7 +94,10 @@ export async function decodeGeometry(enc) {
     }
     const idxBytes = new Uint8Array(enc.indexCount * 4);
     MeshoptDecoder.decodeIndexBuffer(idxBytes, enc.indexCount, 4, enc.idx);
-    return { positions, indices: new Uint32Array(idxBytes.buffer, idxBytes.byteOffset, enc.indexCount) };
+    return {
+        positions,
+        indices: new Uint32Array(idxBytes.buffer, idxBytes.byteOffset, enc.indexCount),
+    };
 }
 // ── UV (TEXCOORD_0): 16-bit quantized within its 2D bounds, meshopt-encoded, shared across LODs ──
 const UV_STRIDE = 4; // 2 × uint16

package/dist/assets/gpuProps.d.ts

@@ -19,11 +19,16 @@ export declare class GpuPropsRenderer {
     private bgs;
     private occBGs;
     private counts;
+    private dummyShadowView;
+    private dummyShadowSamp;
+    private shadowBG;
+    private lastSV;
+    private lastSS;
     constructor(device: GPUDevice, format: GPUTextureFormat);
     setModels(meshes: PropMesh[]): void;
     /** Group instances by model and upload per-model transform buffers. */
     setInstances(instances: PropInstance[]): void;
     /** Occluder pass: draw all instanced props' depth into the shared shadow map from the sun's ortho view. */
     shadowPass(pass: GPURenderPassEncoder, lightVP: Float32Array): void;
-    frame(enc: GPUCommandEncoder, colorView: GPUTextureView, depthView: GPUTextureView, camVP: Float32Array, sunDir: [number, number, number], sunCol: [number, number, number], amb: [number, number, number], camPos: [number, number, number], fog: [number, number, number], fogDensity: number, up?: [number, number, number]): void;
+    frame(enc: GPUCommandEncoder, colorView: GPUTextureView, depthView: GPUTextureView, camVP: Float32Array, sunDir: [number, number, number], sunCol: [number, number, number], amb: [number, number, number], camPos: [number, number, number], fog: [number, number, number], fogDensity: number, up?: [number, number, number], lightVP?: Float32Array, shadowView?: GPUTextureView, shadowSamp?: GPUSampler): void;
 }

package/dist/assets/gpuProps.js

@@ -4,9 +4,11 @@
 // terrain. Runs in a load pass after the terrain so props depth-test against the surface.
 // ─────────────────────────────────────────────────────────────────────────────
 const SHADER = /* wgsl */ `
-struct U { mvp: mat4x4<f32>, sun: vec4<f32>, sunCol: vec4<f32>, amb: vec4<f32>, cam: vec4<f32>, fog: vec4<f32>, up: vec4<f32> };
+struct U { mvp: mat4x4<f32>, lightVP: mat4x4<f32>, sun: vec4<f32>, sunCol: vec4<f32>, amb: vec4<f32>, cam: vec4<f32>, fog: vec4<f32>, up: vec4<f32> };
 @group(0) @binding(0) var<uniform> u: U;
 @group(0) @binding(1) var<storage,read> models: array<mat4x4<f32>>;
+@group(1) @binding(0) var shadowMap: texture_depth_2d;      // the SAME sun shadow map the terrain cubes sample
+@group(1) @binding(1) 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>, @builtin(instance_index) ii: u32) -> VO {
   let m = models[ii];
@@ -22,11 +24,28 @@ fn fixedFill(N: vec3<f32>, up: vec3<f32>) -> f32 {
   let L = normalize(up * 0.82 + t * 0.57);
   return max(dot(N, L), 0.0);
 }
+// PCF 3×3 sun shadow — mirrors gpuShadow.shadowFactor so props sit in the SAME shadow as the terrain. 1 = lit, 0 = shadowed.
+fn shadowFactor(world: vec3<f32>, ndl: f32) -> f32 {
+  let lp = u.lightVP * vec4(world, 1.0);
+  let proj = lp.xyz / lp.w;
+  let uv = proj.xy * vec2(0.5, -0.5) + vec2(0.5, 0.5);
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0 || proj.z > 1.0 || proj.z < 0.0) { return 1.0; }
+  let bias = max(0.0006 * (1.0 - ndl), 0.0004);
+  let texel = 1.0 / 2048.0;
+  var s = 0.0;
+  for (var dy = -1; dy <= 1; dy = dy + 1) {
+    for (var dx = -1; dx <= 1; dx = dx + 1) {
+      s = s + textureSampleCompareLevel(shadowMap, shadowSamp, uv + vec2(f32(dx), f32(dy)) * texel, proj.z - bias);
+    }
+  }
+  return s / 9.0;
+}
 @fragment fn fs(i: VO) -> @location(0) vec4<f32> {
   let N = normalize(i.n);
   let ff = select(1.0, 0.5 + 0.85 * fixedFill(N, u.up.xyz), u.up.w > 0.5);   // fixed fill (fall back to flat amb if no up)
   let d = clamp(dot(N, -normalize(u.sun.xyz)), 0.0, 1.0);
-  let lit = i.c * (u.amb.xyz * ff + d * u.sunCol.xyz);
+  let sh = mix(1.0, shadowFactor(i.world, d), u.sun.w);   // u.sun.w = shadow-receive enable (0 ⇒ off, byte-identical for demo)
+  let lit = i.c * (u.amb.xyz * ff + d * u.sunCol.xyz * sh);
   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);
@@ -49,29 +68,79 @@ export class GpuPropsRenderer {
     bgs = [];
     occBGs = [];
     counts = [];
+    // shadow-receive (group 1): a dummy 1×1 depth map when no sun shadow is supplied (demo path), else the terrain's
+    // shared shadow map. The bind group is cached and only rebuilt when the supplied view/sampler identity changes.
+    dummyShadowView;
+    dummyShadowSamp;
+    shadowBG = null;
+    lastSV = null;
+    lastSS = null;
     constructor(device, format) {
         this.device = device;
         const sm = device.createShaderModule({ code: SHADER });
         this.pipe = device.createRenderPipeline({
             layout: 'auto',
-            vertex: { module: sm, entryPoint: 'vs', buffers: [
-                    { 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' }] }
-                ] },
+            vertex: {
+                module: sm,
+                entryPoint: 'vs',
+                buffers: [
+                    {
+                        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' }],
+                    },
+                ],
+            },
             fragment: { module: sm, entryPoint: 'fs', targets: [{ format }] },
             primitive: { topology: 'triangle-list', cullMode: 'none' },
-            depthStencil: { format: 'depth24plus', depthWriteEnabled: true, depthCompare: 'less' },
+            depthStencil: {
+                format: 'depth24plus',
+                depthWriteEnabled: true,
+                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' }] }] },
+            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' },
+            depthStencil: {
+                format: 'depth32float',
+                depthWriteEnabled: true,
+                depthCompare: 'less',
+            },
+        });
+        this.uBuf = device.createBuffer({
+            size: 128 + 16 * 6, // 2× mat4 (mvp + lightVP) + 6× vec4
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        this.lightBuf = device.createBuffer({
+            size: 64,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
         });
-        this.uBuf = device.createBuffer({ size: 96 + 16 * 6, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
-        this.lightBuf = device.createBuffer({ size: 64, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+        const dummy = device.createTexture({
+            size: [1, 1],
+            format: 'depth32float',
+            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT,
+        });
+        this.dummyShadowView = dummy.createView();
+        this.dummyShadowSamp = device.createSampler({ compare: 'less' });
     }
     setModels(meshes) {
         const dev = this.device, U = GPUBufferUsage;
@@ -81,8 +150,18 @@ export class GpuPropsRenderer {
             p.colB.destroy();
             p.idxB.destroy();
         }
-        const mk = (d, u) => { const b = dev.createBuffer({ size: d.byteLength, usage: u }); dev.queue.writeBuffer(b, 0, d); return b; };
-        this.models = meshes.map((m) => ({ posB: mk(m.positions, U.VERTEX | U.COPY_DST), nrmB: mk(m.normals, U.VERTEX | U.COPY_DST), colB: mk(m.colors, U.VERTEX | U.COPY_DST), idxB: mk(m.indices, U.INDEX | U.COPY_DST), idxCount: m.indices.length }));
+        const mk = (d, u) => {
+            const b = dev.createBuffer({ size: d.byteLength, usage: u });
+            dev.queue.writeBuffer(b, 0, d);
+            return b;
+        };
+        this.models = meshes.map((m) => ({
+            posB: mk(m.positions, U.VERTEX | U.COPY_DST),
+            nrmB: mk(m.normals, U.VERTEX | U.COPY_DST),
+            colB: mk(m.colors, U.VERTEX | U.COPY_DST),
+            idxB: mk(m.indices, U.INDEX | U.COPY_DST),
+            idxCount: m.indices.length,
+        }));
         this.instBufs = meshes.map(() => null);
         this.bgs = meshes.map(() => null);
         this.occBGs = meshes.map(() => null);
@@ -110,11 +189,26 @@ export class GpuPropsRenderer {
                 this.occBGs[m] = null;
                 continue;
             }
-            const b = dev.createBuffer({ size: arr.byteLength, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+            const b = dev.createBuffer({
+                size: arr.byteLength,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+            });
             dev.queue.writeBuffer(b, 0, arr);
             this.instBufs[m] = b;
-            this.bgs[m] = dev.createBindGroup({ layout: this.pipe.getBindGroupLayout(0), entries: [{ binding: 0, resource: { buffer: this.uBuf } }, { binding: 1, resource: { buffer: b } }] });
-            this.occBGs[m] = dev.createBindGroup({ layout: this.occPipe.getBindGroupLayout(0), entries: [{ binding: 0, resource: { buffer: this.lightBuf } }, { binding: 1, resource: { buffer: b } }] });
+            this.bgs[m] = dev.createBindGroup({
+                layout: this.pipe.getBindGroupLayout(0),
+                entries: [
+                    { binding: 0, resource: { buffer: this.uBuf } },
+                    { binding: 1, resource: { buffer: b } },
+                ],
+            });
+            this.occBGs[m] = dev.createBindGroup({
+                layout: this.occPipe.getBindGroupLayout(0),
+                entries: [
+                    { binding: 0, resource: { buffer: this.lightBuf } },
+                    { binding: 1, resource: { buffer: b } },
+                ],
+            });
         }
     }
     /** Occluder pass: draw all instanced props' depth into the shared shadow map from the sun's ortho view. */
@@ -131,19 +225,45 @@ export class GpuPropsRenderer {
             pass.drawIndexed(mdl.idxCount, this.counts[m]);
         }
     }
-    frame(enc, colorView, depthView, camVP, sunDir, sunCol, amb, camPos, fog, fogDensity, up) {
-        const u = new Float32Array(24 + 24);
+    frame(enc, colorView, depthView, camVP, sunDir, sunCol, amb, camPos, fog, fogDensity, up, 
+    // Optional sun shadow-receive: pass the terrain's lightVP + shadow-map view + comparison sampler and props sit
+    // in the same shadow. Omit all three (the demo path) → no shadowing, byte-identical to before.
+    lightVP, shadowView, shadowSamp) {
+        const receive = !!(lightVP && shadowView && shadowSamp);
+        const u = new Float32Array(56);
         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], 0], 28);
-        u.set([fog[0], fog[1], fog[2], fogDensity], 32);
+        u.set(lightVP ?? IDENTITY4, 16); // lightVP (identity when not receiving — result is gated off by sun.w)
+        u.set([sunDir[0], sunDir[1], sunDir[2], receive ? 1 : 0], 32); // sun.w = shadow-receive enable
+        u.set([sunCol[0], sunCol[1], sunCol[2], 0], 36);
+        u.set([amb[0], amb[1], amb[2], 0], 40);
+        u.set([camPos[0], camPos[1], camPos[2], 0], 44);
+        u.set([fog[0], fog[1], fog[2], fogDensity], 48);
         if (up)
-            u.set([up[0], up[1], up[2], 1], 36); // up.w=1 → enable the fixed directional fill (matches the terrain)
+            u.set([up[0], up[1], up[2], 1], 52); // up.w=1 → enable the fixed directional fill (matches the terrain)
         this.device.queue.writeBuffer(this.uBuf, 0, u);
-        const rp = enc.beginRenderPass({ colorAttachments: [{ view: colorView, loadOp: 'load', storeOp: 'store' }], depthStencilAttachment: { view: depthView, depthLoadOp: 'load', depthStoreOp: 'store' } });
+        // group 1: the shadow map + comparison sampler (dummy when not receiving). Rebuild only when the view changes.
+        const sv = shadowView ?? this.dummyShadowView, ss = shadowSamp ?? this.dummyShadowSamp;
+        if (!this.shadowBG || sv !== this.lastSV || ss !== this.lastSS) {
+            this.shadowBG = this.device.createBindGroup({
+                layout: this.pipe.getBindGroupLayout(1),
+                entries: [
+                    { binding: 0, resource: sv },
+                    { binding: 1, resource: ss },
+                ],
+            });
+            this.lastSV = sv;
+            this.lastSS = ss;
+        }
+        const rp = enc.beginRenderPass({
+            colorAttachments: [{ view: colorView, loadOp: 'load', storeOp: 'store' }],
+            depthStencilAttachment: {
+                view: depthView,
+                depthLoadOp: 'load',
+                depthStoreOp: 'store',
+            },
+        });
         rp.setPipeline(this.pipe);
+        rp.setBindGroup(1, this.shadowBG);
         for (let m = 0; m < this.models.length; m++) {
             const bg = this.bgs[m], mdl = this.models[m];
             if (!bg || this.counts[m] === 0)
@@ -158,3 +278,7 @@ export class GpuPropsRenderer {
         rp.end();
     }
 }
+// column-major identity mat4, used for lightVP when shadow-receive is off
+const IDENTITY4 = new Float32Array([
+    1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
+]);