ugly-game 0.7.9 → 0.7.10

package/dist/assets/gpuProps.d.ts

@@ -26,9 +26,37 @@ export interface PropMesh {
     colors: Float32Array;
     indices: Uint32Array;
 }
+/**
+ * Per-instance deformation. Every field is neutral at its default, so an instance that supplies none
+ * renders byte-identically to one drawn before this existed.
+ *
+ * This is the cheap half of "variety": one generated mesh becomes an unlimited stand of visibly
+ * different plants without a second asset, a second draw call, or a provider call. The expensive
+ * half — new silhouettes — still needs a new mesh.
+ */
+export interface PropDeform {
+    /** Vertical scale. 0.6 squat, 1.6 lanky. */
+    height?: number;
+    /** Horizontal scale, applied before taper. */
+    girth?: number;
+    /** >0 narrows toward the top, <0 flares. */
+    taper?: number;
+    /** Lateral tip displacement in units of the plant's own height; grows as u². */
+    bend?: number;
+    bendDir?: number;
+    /** Radians of twist from base to tip. */
+    twist?: number;
+    /** Downward pull on geometry that reaches out — a trunk is unaffected, a frond sags. */
+    droop?: number;
+    yaw?: number;
+    /** Multiplied into vertex colour; gives a within-species value spread. */
+    valueJitter?: number;
+}
 export interface PropInstance {
     model: number;
     mat: Float32Array;
+    /** Optional per-instance deform. Omitted ⇒ the mesh is drawn exactly as authored. */
+    deform?: PropDeform;
 }
 export declare class GpuPropsRenderer {
     private device;
@@ -38,6 +66,8 @@ export declare class GpuPropsRenderer {
     private lightBuf;
     private models;
     private instBufs;
+    /** Allocated capacity in instances, so a per-frame LOD re-bucket reuses the buffer. */
+    private caps;
     private bgs;
     private occBGs;
     private counts;
@@ -59,7 +89,14 @@ export declare class GpuPropsRenderer {
     tick(dt: number): void;
     constructor(device: GPUDevice, format: GPUTextureFormat);
     setModels(meshes: PropMesh[]): void;
-    /** Group instances by model and upload per-model transform buffers. */
+    /**
+     * Group instances by model and upload the per-model instance buffers.
+     *
+     * Safe to call every frame: buffers are REUSED whenever the new count fits the allocated capacity,
+     * and capacity grows with headroom. That matters because distance-bucketed LOD means an instance
+     * changes which model it belongs to as the camera moves, so the grouping is not a one-time setup —
+     * re-allocating a megabyte of storage buffers per frame would cost more than the LOD saves.
+     */
     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;

package/dist/assets/gpuProps.js

@@ -9,7 +9,15 @@ const SHADER = /* wgsl */ `
 // grade = (hueShift, saturation, valueLift, unused)
 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>, wind: vec4<f32>, surf: vec4<f32>, grade: vec4<f32> };
 @group(0) @binding(0) var<uniform> u: U;
-@group(0) @binding(1) var<storage,read> models: array<mat4x4<f32>>;
+// One instance. 'm' is the placement; d0/d1/d2 are the per-instance DEFORM, which is what lets
+// thousands of visibly different plants share a single mesh and a single draw call. Baking each
+// variant on the CPU instead costs one model, one vertex buffer and one draw call per plant —
+// measured, that is the difference between a forest and a slideshow.
+//   d0 = (heightScale, girth, taper, 1/sourceHeight)
+//   d1 = (bend, bendDir, twist, droop)
+//   d2 = (yaw, valueJitter, 1/halfWidth, unused)
+struct Inst { m: mat4x4<f32>, d0: vec4<f32>, d1: vec4<f32>, d2: vec4<f32> };
+@group(0) @binding(1) var<storage,read> models: array<Inst>;
 @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>, @location(3) l: vec3<f32> };
@@ -28,13 +36,63 @@ fn sway(local: vec3<f32>, world: vec3<f32>, up: vec3<f32>, scale: f32) -> vec3<f
   wd = normalize(wd - up * dot(wd, up));                    // project into the local tangent plane
   return world + wd * d;
 }
+// PER-INSTANCE DEFORM, in local space, before placement. Mirrors shared/lifeVariation.ts deform()
+// exactly: the CPU version is the reference and the two must agree, or the same seed gives a
+// different plant depending on which path drew it.
+//
+// Assumes the model's base sits at y = 0, which the cook guarantees (it normalises every plant to
+// base-at-origin). u then runs 0 at the base to 1 at the tip, and everything is anchored: a deformed
+// plant still meets the ground exactly where the original did, so no instance needs its contact
+// re-solved.
+fn deformLocal(p: vec3<f32>, d0: vec4<f32>, d1: vec4<f32>, d2: vec4<f32>) -> vec3<f32> {
+  let H = 1.0 / max(d0.w, 1e-6);
+  let u = clamp(p.y * d0.w, 0.0, 1.0);
+  var x = p.x; var y = p.y; var z = p.z;
+  let rs = d0.y * (1.0 + d0.z * (1.0 - 2.0 * u));        // taper about the vertical axis
+  x = x * rs; z = z * rs;
+  let a = d1.z * u;                                       // twist accumulates with height
+  let ca = cos(a); let sa = sin(a);
+  let tx = x * ca - z * sa; let tz = x * sa + z * ca;
+  x = tx; z = tz;
+  y = y * d0.x;
+  if (d1.w != 0.0) {                                      // droop: weighted by radial reach
+    let r = sqrt(x * x + z * z) * d2.z;
+    y = y - d1.w * H * d0.x * r * r * u;
+  }
+  let dd = d1.x * H * d0.x * u * u;                       // bend as u²: leaves the ground vertical
+  x = x + cos(d1.y) * dd;
+  z = z + sin(d1.y) * dd;
+  let cy = cos(d2.x); let sy = sin(d2.x);
+  return vec3(x * cy - z * sy, y, x * sy + z * cy);
+}
+/**
+ * Normal under the same deform, approximated.
+ *
+ * The exact answer is the inverse-transpose of the deform's Jacobian, which for a bend and a droop
+ * is not cheap. Taper and non-uniform height are the terms that actually matter to shading, so the
+ * normal gets the inverse non-uniform scale plus the rigid rotations (twist + yaw) and nothing else.
+ * The CPU path recomputes normals exactly; the perf lab renders both so the difference can be looked
+ * at rather than assumed.
+ */
+fn deformNormal(n: vec3<f32>, py: f32, d0: vec4<f32>, d1: vec4<f32>, d2: vec4<f32>) -> vec3<f32> {
+  let u = clamp(py * d0.w, 0.0, 1.0);
+  let rs = max(d0.y * (1.0 + d0.z * (1.0 - 2.0 * u)), 1e-4);
+  var v = vec3(n.x / rs, n.y / max(d0.x, 1e-4), n.z / rs);
+  let a = d1.z * u + d2.x;
+  let ca = cos(a); let sa = sin(a);
+  return normalize(vec3(v.x * ca - v.z * sa, v.y, v.x * sa + v.z * ca));
+}
 @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];
-  var world = (m * vec4(p, 1.0)).xyz;
+  let inst = models[ii];
+  let m = inst.m;
+  let lp = deformLocal(p, inst.d0, inst.d1, inst.d2);
+  let ln = deformNormal(nrm, p.y, inst.d0, inst.d1, inst.d2);
+  var world = (m * vec4(lp, 1.0)).xyz;
   let upv = normalize((m * vec4(0.0, 1.0, 0.0, 0.0)).xyz);
   let sc = length(m[0].xyz);
-  world = sway(p, world, upv, sc);
-  var o: VO; o.pos = u.mvp * vec4(world, 1.0); o.world = world; o.n = (m * vec4(nrm, 0.0)).xyz; o.c = col; o.l = p; return o;
+  world = sway(lp, world, upv, sc);
+  var o: VO; o.pos = u.mvp * vec4(world, 1.0); o.world = world; o.n = (m * vec4(ln, 0.0)).xyz;
+  o.c = col * inst.d2.y; o.l = lp; return o;
 }
 // same fixed directional FILL as the terrain cubes (gpuShadow.fixedFill) so plants/rocks read the same 3D shape,
 // day or night, under one shared light. up.w > 0.5 signals a valid local-up was supplied (else fall back to flat).
@@ -124,13 +182,40 @@ fn hsvShift(c: vec3<f32>, hue: f32, sat: f32, val: f32) -> vec3<f32> {
 const OCCLUDER = /* wgsl */ `
 struct OU { lightVP: mat4x4<f32>, wind: vec4<f32> };
 @group(0) @binding(0) var<uniform> o: OU;
-@group(0) @binding(1) var<storage,read> models: array<mat4x4<f32>>;
+struct Inst { m: mat4x4<f32>, d0: vec4<f32>, d1: vec4<f32>, d2: vec4<f32> };
+@group(0) @binding(1) var<storage,read> models: array<Inst>;
+// The occluder must apply the identical DEFORM as well as the identical sway. A deformed plant whose
+// shadow is cast from its undeformed silhouette is the same detachment bug as swaying leaves over a
+// still shadow, and just as visible.
+fn deformLocal(p: vec3<f32>, d0: vec4<f32>, d1: vec4<f32>, d2: vec4<f32>) -> vec3<f32> {
+  let H = 1.0 / max(d0.w, 1e-6);
+  let u = clamp(p.y * d0.w, 0.0, 1.0);
+  var x = p.x; var y = p.y; var z = p.z;
+  let rs = d0.y * (1.0 + d0.z * (1.0 - 2.0 * u));
+  x = x * rs; z = z * rs;
+  let a = d1.z * u;
+  let ca = cos(a); let sa = sin(a);
+  let tx = x * ca - z * sa; let tz = x * sa + z * ca;
+  x = tx; z = tz;
+  y = y * d0.x;
+  if (d1.w != 0.0) {
+    let r = sqrt(x * x + z * z) * d2.z;
+    y = y - d1.w * H * d0.x * r * r * u;
+  }
+  let dd = d1.x * H * d0.x * u * u;
+  x = x + cos(d1.y) * dd;
+  z = z + sin(d1.y) * dd;
+  let cy = cos(d2.x); let sy = sin(d2.x);
+  return vec3(x * cy - z * sy, y, x * sy + z * cy);
+}
 @vertex fn vs(@location(0) p: vec3<f32>, @builtin(instance_index) ii: u32) -> @builtin(position) vec4<f32> {
-  let m = models[ii];
-  var world = (m * vec4(p, 1.0)).xyz;
+  let inst = models[ii];
+  let m = inst.m;
+  let dp = deformLocal(p, inst.d0, inst.d1, inst.d2);
+  var world = (m * vec4(dp, 1.0)).xyz;
   if (o.wind.z > 0.0001) {
     let upv = normalize((m * vec4(0.0, 1.0, 0.0, 0.0)).xyz);
-    let h = max(p.y, 0.0);
+    let h = max(dp.y, 0.0);
     let stiff = pow(min(h * 0.22, 1.0), 1.6);
     let ph = o.wind.w + dot(world.xz, vec2(0.13, 0.17));
     let a = o.wind.z * stiff * length(m[0].xyz);
@@ -140,6 +225,8 @@ struct OU { lightVP: mat4x4<f32>, wind: vec4<f32> };
   }
   return o.lightVP * vec4(world, 1.0);
 }`;
+/** Floats per instance in the storage buffer: mat4 + d0 + d1 + d2. */
+const INST_FLOATS = 28;
 export class GpuPropsRenderer {
     device;
     pipe;
@@ -148,6 +235,8 @@ export class GpuPropsRenderer {
     lightBuf;
     models = [];
     instBufs = [];
+    /** Allocated capacity in instances, so a per-frame LOD re-bucket reuses the buffer. */
+    caps = [];
     bgs = [];
     occBGs = [];
     counts = [];
@@ -270,54 +359,76 @@ export class GpuPropsRenderer {
             colB: mk(m.colors, U.VERTEX | U.COPY_DST),
             idxB: mk(m.indices, U.INDEX | U.COPY_DST),
             idxCount: m.indices.length,
+            extent: measureExtent(m.positions),
         }));
+        this.caps = meshes.map(() => 0);
         this.instBufs = meshes.map(() => null);
         this.bgs = meshes.map(() => null);
         this.occBGs = meshes.map(() => null);
         this.counts = meshes.map(() => 0);
     }
-    /** Group instances by model and upload per-model transform buffers. */
+    /**
+     * Group instances by model and upload the per-model instance buffers.
+     *
+     * Safe to call every frame: buffers are REUSED whenever the new count fits the allocated capacity,
+     * and capacity grows with headroom. That matters because distance-bucketed LOD means an instance
+     * changes which model it belongs to as the camera moves, so the grouping is not a one-time setup —
+     * re-allocating a megabyte of storage buffers per frame would cost more than the LOD saves.
+     */
     setInstances(instances) {
         const dev = this.device;
-        const byModel = this.models.map(() => []);
-        const data = this.models.map(() => []);
+        const n = this.models.length;
+        const counts = new Uint32Array(n);
+        for (const it of instances)
+            if (it.model >= 0 && it.model < n)
+                counts[it.model]++;
+        const cursors = new Uint32Array(n);
+        const arrays = new Array(n);
+        for (let m = 0; m < n; m++)
+            arrays[m] = counts[m] ? new Float32Array(counts[m] * INST_FLOATS) : null;
         for (const it of instances) {
-            if (it.model < 0 || it.model >= this.models.length)
+            if (it.model < 0 || it.model >= n)
                 continue;
-            byModel[it.model].push(0);
-            for (let i = 0; i < 16; i++)
-                data[it.model].push(it.mat[i]);
+            const arr = arrays[it.model];
+            const o = cursors[it.model]++ * INST_FLOATS;
+            arr.set(it.mat.subarray(0, 16), o);
+            writeDeform(arr, o + 16, it.deform, this.models[it.model].extent);
         }
-        for (let m = 0; m < this.models.length; m++) {
-            this.instBufs[m]?.destroy();
-            const arr = new Float32Array(data[m]);
-            this.counts[m] = byModel[m].length;
-            if (arr.length === 0) {
-                this.instBufs[m] = null;
-                this.bgs[m] = null;
-                this.occBGs[m] = null;
+        for (let m = 0; m < n; m++) {
+            const arr = arrays[m];
+            this.counts[m] = counts[m];
+            if (!arr) {
+                // keep the buffer allocated — an empty LOD bucket this frame is usually full the next one
+                if (!this.instBufs[m]) {
+                    this.bgs[m] = null;
+                    this.occBGs[m] = null;
+                }
                 continue;
             }
-            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 } },
-                ],
-            });
+            if (!this.instBufs[m] || counts[m] > this.caps[m]) {
+                this.instBufs[m]?.destroy();
+                const cap = Math.max(16, Math.ceil(counts[m] * 1.5));
+                this.instBufs[m] = dev.createBuffer({
+                    size: cap * INST_FLOATS * 4,
+                    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+                });
+                this.caps[m] = cap;
+                this.bgs[m] = dev.createBindGroup({
+                    layout: this.pipe.getBindGroupLayout(0),
+                    entries: [
+                        { binding: 0, resource: { buffer: this.uBuf } },
+                        { binding: 1, resource: { buffer: this.instBufs[m] } },
+                    ],
+                });
+                this.occBGs[m] = dev.createBindGroup({
+                    layout: this.occPipe.getBindGroupLayout(0),
+                    entries: [
+                        { binding: 0, resource: { buffer: this.lightBuf } },
+                        { binding: 1, resource: { buffer: this.instBufs[m] } },
+                    ],
+                });
+            }
+            dev.queue.writeBuffer(this.instBufs[m], 0, arr);
         }
     }
     /** Occluder pass: draw all instanced props' depth into the shared shadow map from the sun's ortho view. */
@@ -401,6 +512,44 @@ export class GpuPropsRenderer {
         rp.end();
     }
 }
+/** Source height and half-width of a model, reciprocated so the shader multiplies rather than divides. */
+function measureExtent(pos) {
+    let maxY = -Infinity;
+    let minX = Infinity, maxX = -Infinity, minZ = Infinity, maxZ = -Infinity;
+    for (let v = 0; v + 2 < pos.length; v += 3) {
+        if (pos[v + 1] > maxY)
+            maxY = pos[v + 1];
+        if (pos[v] < minX)
+            minX = pos[v];
+        if (pos[v] > maxX)
+            maxX = pos[v];
+        if (pos[v + 2] < minZ)
+            minZ = pos[v + 2];
+        if (pos[v + 2] > maxZ)
+            maxZ = pos[v + 2];
+    }
+    // The cook normalises every prop to base-at-y=0, so maxY IS the height. A model that violates that
+    // still renders — it just gets a `u` ramp that does not reach 1, i.e. a milder deform, never a
+    // broken one.
+    const h = Math.max(1e-6, maxY);
+    const halfW = Math.max(1e-6, Math.max(maxX - minX, maxZ - minZ) * 0.5);
+    return { invH: 1 / h, invHalfW: 1 / halfW };
+}
+/** Pack a PropDeform into d0/d1/d2. An absent deform writes the exact identity. */
+function writeDeform(out, o, d, e) {
+    out[o] = d?.height ?? 1;
+    out[o + 1] = d?.girth ?? 1;
+    out[o + 2] = d?.taper ?? 0;
+    out[o + 3] = e.invH;
+    out[o + 4] = d?.bend ?? 0;
+    out[o + 5] = d?.bendDir ?? 0;
+    out[o + 6] = d?.twist ?? 0;
+    out[o + 7] = d?.droop ?? 0;
+    out[o + 8] = d?.yaw ?? 0;
+    out[o + 9] = d?.valueJitter ?? 1;
+    out[o + 10] = e.invHalfW;
+    out[o + 11] = 0;
+}
 // 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,

package/package.json

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