@woosh/meep-engine 3.12.0 → 3.13.1

package/package.json

@@ -6,7 +6,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.12.0",
+  "version": "3.13.1",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/core/geom/3d/shape/ConvexHullShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConvexHullShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/ConvexHullShape3D.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA8CI;;;;;;;OAOG;IACH,sBAJW,YAAY,WACZ,WAAW,GACT,iBAAiB,CAQ7B;IA1DD;;;;OAIG;IACH,UAFU,YAAY,CAES;IAE/B;;;;OAIG;IACH,SAFU,WAAW,CAEQ;IAE7B;;;;;;OAMG;IACH,cAFU,WAAW,CAEa;IAElC,0BAA0B;IAC1B,YADW,WAAW,CACU;IAEhC;;;;;;OAMG;IACH,iBAA+B;IAE/B,oCAAoC;IACpC,eAA6B;IAE7B,8BAA8B;IAC9B,iBAAa;IAEb,8BAA8B;IAC9B,uBAAmB;IAkBnB;;;OAGG;IACH,kBA8EC;IAKD,wCAIC;IAED;;;;;OAKG;IACH,qGAwCC;IAED;;;;;;;;OAQG;IACH,yCAEC;IAED;;;;OAIG;IACH,wCAEC;IAED,qCAkBC;IAED;;;OAGG;IACH,oCAgBC;IAED;;;OAGG;IACH,6CAiBC;IAED,mEAEC;IAED,4DAoBC;IAGD;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAanB;IAcL;;;;OAIG;IACH,8BAFU,OAAO,CAE8B;CAP9C;gCAvX+B,sBAAsB"}
+{"version":3,"file":"ConvexHullShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/ConvexHullShape3D.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA8CI;;;;;;;OAOG;IACH,sBAJW,YAAY,WACZ,WAAW,GACT,iBAAiB,CAQ7B;IA1DD;;;;OAIG;IACH,UAFU,YAAY,CAES;IAE/B;;;;OAIG;IACH,SAFU,WAAW,CAEQ;IAE7B;;;;;;OAMG;IACH,cAFU,WAAW,CAEa;IAElC,0BAA0B;IAC1B,YADW,WAAW,CACU;IAEhC;;;;;;OAMG;IACH,iBAA+B;IAE/B,oCAAoC;IACpC,eAA6B;IAE7B,8BAA8B;IAC9B,iBAAa;IAEb,8BAA8B;IAC9B,uBAAmB;IAkBnB;;;OAGG;IACH,kBAkFC;IAUD,wCAQC;IAED;;;;;OAKG;IACH,qGAwCC;IAED;;;;;;;;OAQG;IACH,yCAEC;IAED;;;;OAIG;IACH,wCAEC;IAED,qCAkBC;IAED;;;OAGG;IACH,oCAgBC;IAED;;;OAGG;IACH,6CAiBC;IAED,mEAEC;IAED,4DAwBC;IAGD;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAanB;IAcL;;;;OAIG;IACH,8BAFU,OAAO,CAE8B;CAP9C;gCAtY+B,sBAAsB"}

package/src/core/geom/3d/shape/ConvexHullShape3D.js

@@ -1,10 +1,10 @@
 import { hash_mix2 } from "../../../math/hash/hash_mix2.js";
 import { computeHashFloat } from "../../../primitives/numbers/computeHashFloat.js";
+import { aabb3_from_v3_array } from "../aabb/aabb3_from_v3_array.js";
+import { convex_polyhedron3_raycast } from "../polyhedron/convex_polyhedron3_raycast.js";
 import { tri3_closest_point } from "../triangle/tri3_closest_point.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
-import { aabb3_from_v3_array } from "../aabb/aabb3_from_v3_array.js";
-import { convex_polyhedron3_raycast } from "../polyhedron/convex_polyhedron3_raycast.js";
 
 /**
  * Convex polyhedron collider.
@@ -161,9 +161,13 @@ export class ConvexHullShape3D extends AbstractShape3D {
             //   Σ a·n === Σ (a − o)·n over a closed surface, since Σ n = 0.
             vol6 += (ax - ox) * nx + (ay - oy) * ny + (az - oz) * nz;
 
-            nx /= len; ny /= len; nz /= len;
+            nx /= len;
+            ny /= len;
+            nz /= len;
             const o = f * 4;
-            planes[o] = nx; planes[o + 1] = ny; planes[o + 2] = nz;
+            planes[o] = nx;
+            planes[o + 1] = ny;
+            planes[o + 2] = nz;
             planes[o + 3] = nx * ax + ny * ay + nz * az;
         }
         this.__planes = planes;
@@ -178,13 +182,22 @@ export class ConvexHullShape3D extends AbstractShape3D {
         this.face_loops = idx;
     }
 
-    get volume() { return this.__volume; }
-    get surface_area() { return this.__surface_area; }
+    get volume() {
+        return this.__volume;
+    }
+
+    get surface_area() {
+        return this.__surface_area;
+    }
 
     compute_bounding_box(result) {
         const b = this.__bbox;
-        result[0] = b[0]; result[1] = b[1]; result[2] = b[2];
-        result[3] = b[3]; result[4] = b[4]; result[5] = b[5];
+        result[0] = b[0];
+        result[1] = b[1];
+        result[2] = b[2];
+        result[3] = b[3];
+        result[4] = b[4];
+        result[5] = b[5];
     }
 
     /**
@@ -201,9 +214,9 @@ export class ConvexHullShape3D extends AbstractShape3D {
     ) {
 
         const v = this.vertices;
-        const vc = v.length / 3;
+        const vertex_array_length = v.length;
 
-        if (vc === 0) {
+        if (vertex_array_length === 0) {
 
             result[result_offset] = 0;
             result[result_offset + 1] = 0;
@@ -212,27 +225,27 @@ export class ConvexHullShape3D extends AbstractShape3D {
             return;
         }
 
-        let best = -Infinity;
-        let bi = 0;
+        let best_distance = -Infinity;
+        let best_offset = 0;
 
-        for (let i = 0; i < vc; i++) {
+        for (let offset = 0; offset < vertex_array_length; offset += 3) {
 
-            const v_x = v[i * 3];
-            const v_y = v[i * 3 + 1];
-            const v_z = v[i * 3 + 2];
+            const v_x = v[offset];
+            const v_y = v[offset + 1];
+            const v_z = v[offset + 2];
 
             const d = direction_x * v_x + direction_y * v_y + direction_z * v_z;
 
-            if (d > best) {
-                best = d;
-                bi = i;
+            if (d > best_distance) {
+                best_distance = d;
+                best_offset = offset;
             }
 
         }
 
-        result[result_offset] = v[bi * 3];
-        result[result_offset + 1] = v[bi * 3 + 1];
-        result[result_offset + 2] = v[bi * 3 + 2];
+        result[result_offset] = v[best_offset];
+        result[result_offset + 1] = v[best_offset + 1];
+        result[result_offset + 2] = v[best_offset + 2];
     }
 
     /**
@@ -342,10 +355,14 @@ export class ConvexHullShape3D extends AbstractShape3D {
             const d2 = tri3_closest_point(scratch_closest, 0, px, py, pz, ax, ay, az, bx, by, bz, cx, cy, cz);
             if (d2 < best_d2) {
                 best_d2 = d2;
-                bx_ = scratch_closest[0]; by_ = scratch_closest[1]; bz_ = scratch_closest[2];
+                bx_ = scratch_closest[0];
+                by_ = scratch_closest[1];
+                bz_ = scratch_closest[2];
             }
         }
-        result[0] = bx_; result[1] = by_; result[2] = bz_;
+        result[0] = bx_;
+        result[1] = by_;
+        result[2] = bz_;
     }
 
 
@@ -387,4 +404,3 @@ ConvexHullShape3D.prototype.isConvexHullShape3D = true;
 
 // closest-point-on-triangle output for the surface-scan query helpers
 const scratch_closest = new Float64Array(3);
-const scratch_point = new Float64Array(3);

package/src/core/geom/3d/shape/PosedShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PosedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/PosedShape3D.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAEI,mCAAmC;IACnC,OADW,eAAe,GAAC,IAAI,CAClB;IAEb,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IAEP;;;;;;;OAOG;IACH,aAJW,eAAe,YACf,UAAQ;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,YACpC,aAAW;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAM1D;IAoED,wCASC;IA4BD;;;;;;;OAOG;IACH,gCAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,MAAM,CAKlB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,OAAO,CAKnB;IAGL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC;gCAlL+B,sBAAsB"}
+{"version":3,"file":"PosedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/PosedShape3D.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAEI,mCAAmC;IACnC,OADW,eAAe,GAAC,IAAI,CAClB;IAEb,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IAEP;;;;;;;OAOG;IACH,aAJW,eAAe,YACf,UAAQ;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,YACpC,aAAW;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAM1D;IAyED,wCASC;IA4BD;;;;;;;OAOG;IACH,gCAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,MAAM,CAKlB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,OAAO,CAKnB;IAGL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC;gCAvL+B,sBAAsB"}

package/src/core/geom/3d/shape/PosedShape3D.js

@@ -86,7 +86,10 @@ export class PosedShape3D extends AbstractShape3D {
         // inline here at the cost of ~7 extra lines per direction.
         // See core/geom/vec3/v3_quat3_apply.js for the canonical form
         // — this is a literal expansion of it.
-        const qx = this.qx, qy = this.qy, qz = this.qz, qw = this.qw;
+        const qx = this.qx;
+        const qy = this.qy;
+        const qz = this.qz;
+        const qw = this.qw;
 
         // Rotate world direction into body frame via the conjugate
         // quaternion: v_local = q* · v_world · q.  Conjugate xyz are
@@ -105,7 +108,9 @@ export class PosedShape3D extends AbstractShape3D {
 
         // Rotate the body-local support point back to world: v_world =
         // q · v_local · q*.
-        const lsx = scratch_local[0], lsy = scratch_local[1], lsz = scratch_local[2];
+        const lsx = scratch_local[0];
+        const lsy = scratch_local[1];
+        const lsz = scratch_local[2];
 
         const tsx =  qw * lsx + qy * lsz - qz * lsy;
         const tsy =  qw * lsy + qz * lsx - qx * lsz;

package/src/engine/graphics3/decal/GPUDecalRenderer.js

@@ -10,7 +10,7 @@ import { TextureFilterType } from "../../../shade/renderer/texture/TextureFilter
 import { SAMPLER_LINEAR_UPSCALE } from "../../../shade/renderer/texture/SAMPLER_LINEAR_UPSCALE.js";
 import { graph_build_decal_clusters } from "./graph_build_decal_clusters.js";
 import { DECAL_RECORD_WORD_COUNT } from "./DECAL_GPU_RECORD.js";
-import { DECAL_COMPOSITE_SETTINGS, shader_decal_composite } from "./shader_decal_composite.js";
+import { shader_decal_composite } from "./shader_decal_composite.js";
 import { build_light_cluster_parameters } from "../../../shade/renderer/light/cluster/build_light_cluster_parameters.js";
 import { DECAL_CLUSTER_RESOLUTION_Z } from "./DECAL_CLUSTER.js";
 
@@ -190,12 +190,12 @@ export class GPUDecalRenderer {
         const encoder = context.encoder;
         const graphics = context.graphics;
 
-        const settings = encoder.allocateTransientValueBuffer(DECAL_COMPOSITE_SETTINGS, {
+        const settings = {
             cluster_params,
             screen_resolution: resolution,
             distance_min: camera.camera.near,
             distance_max: camera.camera.far,
-        });
+        };
 
         const sampler = graphics.samplers.obtain(SAMPLER_LINEAR_UPSCALE);
 

package/src/engine/graphics3/decal/shader_decal_composite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_decal_composite.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_decal_composite.js"],"names":[],"mappings":"AA8DA,oDAKG;AAmSH;;;;;;;;;;;;GAYG;AACH,qCAFU,WAAW,CAclB;6BApV0B,qDAAqD;4BAPtD,+CAA+C"}
+{"version":3,"file":"shader_decal_composite.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_decal_composite.js"],"names":[],"mappings":"AA8DA,oDAKG;AAqSH;;;;;;;;;;;;GAYG;AACH,qCAFU,WAAW,CAclB;6BAtV0B,qDAAqD;4BAPtD,+CAA+C"}

package/src/engine/graphics3/decal/shader_decal_composite.js

@@ -69,9 +69,11 @@ export const DECAL_COMPOSITE_SETTINGS = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
+// per-draw, 32 bytes, read-only: immediate data rather than a uniform buffer. camera stays bound.
+resources.setImmediate("settings", DECAL_COMPOSITE_SETTINGS);
+
 resources.createGroup()
-    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    .addUniform("settings", DECAL_COMPOSITE_SETTINGS);
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT);
 
 /*
  The two integer targets are declared as such, exactly as `shader_deferred_main` declares the same

package/src/engine/graphics3/highlight/GPUHighlightRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUHighlightRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/highlight/GPUHighlightRenderer.js"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH;IAWI;;;;;;;;;OASG;IACH;QAN8B,KAAK;QACN,KAAK,EAAvB,WAAW;QACE,UAAU,EAAvB,MAAM;QACO,SAAS,EAAtB,MAAM;QACJ,MAAM,CA+BlB;IAmED,gBAOC;;CACJ"}
+{"version":3,"file":"GPUHighlightRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/highlight/GPUHighlightRenderer.js"],"names":[],"mappings":"AAiBA;;;;;;GAMG;AACH;IAWI;;;;;;;;;OASG;IACH;QAN8B,KAAK;QACN,KAAK,EAAvB,WAAW;QACE,UAAU,EAAvB,MAAM;QACO,SAAS,EAAtB,MAAM;QACJ,MAAM,CA+BlB;IAmED,gBAOC;;CACJ"}

package/src/engine/graphics3/highlight/GPUHighlightRenderer.js

@@ -3,7 +3,6 @@ import { round_up } from "../../../core/math/round_up.js";
 import { SceneColor } from "../../../shade/renderer/extension/SceneColor.js";
 import { ViewTextures } from "../../../shade/renderer/extension/ViewTextures.js";
 import {
-    HIGHLIGHT_OUTLINE_SETTINGS,
     shader_highlight_outline
 } from "./shader_highlight_outline.js";
 
@@ -88,11 +87,11 @@ export class GPUHighlightRenderer {
 
         const color = resources.get(data.color);
 
-        const settings = encoder.allocateTransientValueBuffer(HIGHLIGHT_OUTLINE_SETTINGS, {
+        const settings = {
             screen_resolution: resolution,
             table_size,
             thickness
-        });
+        };
 
         shader_highlight_outline.draw({
             encoder,

package/src/engine/graphics3/highlight/shader_highlight_outline.js

@@ -1,150 +1,150 @@
-import { BlendState } from "../../../shade/descriptor/blend/BlendState.js";
-import { CodeChunk } from "../../../shade/renderer/shader/compiler/CodeChunk.js";
-import { ImageShader } from "../../../shade/renderer/shader/ImageShader.js";
-import {
-    ShaderResourceSetDescriptor
-} from "../../../shade/renderer/shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../../../shade/renderer/shader/ShaderDescriptor.js";
-import { f32, u32, vec2u } from "../../../shade/renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../../shade/renderer/shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../../shade/renderer/shader/type/WebGPUStruct.js";
-import { chunk_highlight_lookup } from "./chunk_highlight_lookup.js";
-
-export const HIGHLIGHT_OUTLINE_SETTINGS = WebGPUStruct.from({
-    screen_resolution: vec2u,
-
-    /**
-     * How many rows the lookup table has, which is one past the highest mesh row that was
-     * highlighted when it was packed.
-     */
-    table_size: u32,
-
-    /**
-     * Outline width in pixels.
-     */
-    thickness: f32,
-});
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.createGroup()
-    .addUniform("settings", HIGHLIGHT_OUTLINE_SETTINGS);
-
-resources.createGroup()
-    .addTexture("viz_mesh", "uint");
-
-resources.createGroup()
-    .addStorageBuffer("highlight_table", WebGPUArray.u32);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@fragment
-fn main(
-    @builtin(position) coord : vec4<f32>,
-) -> @location(0) vec4<f32> {
-
-    let here = vec2<i32>(coord.xy);
-
-    let resolution = vec2<i32>(settings.screen_resolution);
-
-    let table_size = settings.table_size;
-
-    let own = highlight_of_mesh(&highlight_table, textureLoad(viz_mesh, here, 0).r, table_size);
-
-    /*
-     The outline sits **outside** the silhouette. A pixel that is itself the highlighted mesh is left
-     alone — a highlight marks a unit without painting over it, which is the whole reason the legacy
-     path dilated its mask outwards before compositing.
-    */
-    if (own.a > 0.0) {
-        discard;
-    }
-
-    let thickness = settings.thickness;
-
-    let radius = i32(ceil(thickness));
-
-    /*
-     The strongest highlight within reach, by coverage. Nearest would need a second comparison and
-     would look the same: two highlights close enough to overlap an outline this thin are the same
-     size on screen, and the brighter one is the one the eye follows.
-    */
-    var found = vec4<f32>(0.0);
-
-    for (var dy = -radius; dy <= radius; dy++) {
-        for (var dx = -radius; dx <= radius; dx++) {
-            let offset = vec2<f32>(f32(dx), f32(dy));
-
-            // a disc rather than a square, so the outline is the same width in every direction
-            if (dot(offset, offset) > thickness * thickness) {
-                continue;
-            }
-
-            let at = here + vec2<i32>(dx, dy);
-
-            if (any(at < vec2<i32>(0)) || any(at >= resolution)) {
-                continue;
-            }
-
-            let neighbour = highlight_of_mesh(&highlight_table, textureLoad(viz_mesh, at, 0).r, table_size);
-
-            if (neighbour.a > found.a) {
-                found = neighbour;
-            }
-        }
-    }
-
-    if (found.a <= 0.0) {
-        discard;
-    }
-
-    // premultiplied, which is how the table stores it and how the blend state consumes it
-    return found;
-}
-    `, [
-        chunk_highlight_lookup
-    ]
-);
-
-/**
- * Paints an outline around every highlighted mesh, straight off the visibility buffer.
- *
- * **There is no second geometry pass, no dilation and no blur.** The renderer this replaces drew
- * every highlighted object again into an id target of its own, ping-ponged two render targets to
- * dilate the mask, blurred it, and decoded ids back to colours to composite — five render targets, a
- * duplicated scene graph and its own skinned material variant. Shade already writes a per-pixel mesh
- * id while drawing the frame, so an outline is a neighbourhood test on an integer texture and
- * nothing more.
- *
- * **What that costs is the contract change in D27**: the visibility buffer knows only what was
- * rasterized, so a unit standing behind a building is outlined where it can be seen and nowhere
- * else. The old mask was drawn with the depth buffer cleared and showed through everything.
- *
- * @type {ImageShader}
- */
-export const shader_highlight_outline = ImageShader.from({
-    descriptor: ShaderDescriptor.from({
-        label: "Highlight outline",
-        resources,
-        body
-    }),
-    targets: [
-        {
-            label: "outlined",
-            format: "rgba16float",
-            blend: BlendState.from({
-                color: {
-                    operation: "add",
-                    srcFactor: "one",
-                    dstFactor: "one-minus-src-alpha"
-                },
-                alpha: {
-                    operation: "add",
-                    srcFactor: "one",
-                    dstFactor: "one-minus-src-alpha"
-                }
-            })
-        }
-    ]
-});
+import { BlendState } from "../../../shade/descriptor/blend/BlendState.js";
+import { CodeChunk } from "../../../shade/renderer/shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../../shade/renderer/shader/ImageShader.js";
+import {
+    ShaderResourceSetDescriptor
+} from "../../../shade/renderer/shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../../shade/renderer/shader/ShaderDescriptor.js";
+import { f32, u32, vec2u } from "../../../shade/renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shade/renderer/shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shade/renderer/shader/type/WebGPUStruct.js";
+import { chunk_highlight_lookup } from "./chunk_highlight_lookup.js";
+
+export const HIGHLIGHT_OUTLINE_SETTINGS = WebGPUStruct.from({
+    screen_resolution: vec2u,
+
+    /**
+     * How many rows the lookup table has, which is one past the highest mesh row that was
+     * highlighted when it was packed.
+     */
+    table_size: u32,
+
+    /**
+     * Outline width in pixels.
+     */
+    thickness: f32,
+});
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-draw, 16 bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", HIGHLIGHT_OUTLINE_SETTINGS);
+
+resources.createGroup()
+    .addTexture("viz_mesh", "uint");
+
+resources.createGroup()
+    .addStorageBuffer("highlight_table", WebGPUArray.u32);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+    @builtin(position) coord : vec4<f32>,
+) -> @location(0) vec4<f32> {
+
+    let here = vec2<i32>(coord.xy);
+
+    let resolution = vec2<i32>(settings.screen_resolution);
+
+    let table_size = settings.table_size;
+
+    let own = highlight_of_mesh(&highlight_table, textureLoad(viz_mesh, here, 0).r, table_size);
+
+    /*
+     The outline sits **outside** the silhouette. A pixel that is itself the highlighted mesh is left
+     alone — a highlight marks a unit without painting over it, which is the whole reason the legacy
+     path dilated its mask outwards before compositing.
+    */
+    if (own.a > 0.0) {
+        discard;
+    }
+
+    let thickness = settings.thickness;
+
+    let radius = i32(ceil(thickness));
+
+    /*
+     The strongest highlight within reach, by coverage. Nearest would need a second comparison and
+     would look the same: two highlights close enough to overlap an outline this thin are the same
+     size on screen, and the brighter one is the one the eye follows.
+    */
+    var found = vec4<f32>(0.0);
+
+    for (var dy = -radius; dy <= radius; dy++) {
+        for (var dx = -radius; dx <= radius; dx++) {
+            let offset = vec2<f32>(f32(dx), f32(dy));
+
+            // a disc rather than a square, so the outline is the same width in every direction
+            if (dot(offset, offset) > thickness * thickness) {
+                continue;
+            }
+
+            let at = here + vec2<i32>(dx, dy);
+
+            if (any(at < vec2<i32>(0)) || any(at >= resolution)) {
+                continue;
+            }
+
+            let neighbour = highlight_of_mesh(&highlight_table, textureLoad(viz_mesh, at, 0).r, table_size);
+
+            if (neighbour.a > found.a) {
+                found = neighbour;
+            }
+        }
+    }
+
+    if (found.a <= 0.0) {
+        discard;
+    }
+
+    // premultiplied, which is how the table stores it and how the blend state consumes it
+    return found;
+}
+    `, [
+        chunk_highlight_lookup
+    ]
+);
+
+/**
+ * Paints an outline around every highlighted mesh, straight off the visibility buffer.
+ *
+ * **There is no second geometry pass, no dilation and no blur.** The renderer this replaces drew
+ * every highlighted object again into an id target of its own, ping-ponged two render targets to
+ * dilate the mask, blurred it, and decoded ids back to colours to composite — five render targets, a
+ * duplicated scene graph and its own skinned material variant. Shade already writes a per-pixel mesh
+ * id while drawing the frame, so an outline is a neighbourhood test on an integer texture and
+ * nothing more.
+ *
+ * **What that costs is the contract change in D27**: the visibility buffer knows only what was
+ * rasterized, so a unit standing behind a building is outlined where it can be seen and nowhere
+ * else. The old mask was drawn with the depth buffer cleared and showed through everything.
+ *
+ * @type {ImageShader}
+ */
+export const shader_highlight_outline = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "Highlight outline",
+        resources,
+        body
+    }),
+    targets: [
+        {
+            label: "outlined",
+            format: "rgba16float",
+            blend: BlendState.from({
+                color: {
+                    operation: "add",
+                    srcFactor: "one",
+                    dstFactor: "one-minus-src-alpha"
+                },
+                alpha: {
+                    operation: "add",
+                    srcFactor: "one",
+                    dstFactor: "one-minus-src-alpha"
+                }
+            })
+        }
+    ]
+});

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -64,11 +64,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#356@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#362@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#356@#clear_field"(fluid: FluidComponent): void;
+    static "__#362@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -80,7 +80,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#356@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#362@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -100,7 +100,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#356@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#362@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];

package/src/shade/RENDERER_CONTRACT.md

@@ -541,7 +541,8 @@ frame or is removed and re-added keeps its buffers.
 | `internal_resolution_scale` | render internally below output resolution; `DynamicResolutionScaling` drives it from frame time |
 | `pixel_ratio`, `output_resolution`, `aspect_ratio`, `resize(x, y)` | |
 | `motion_blur`, `dof`, `dof_unreal`, `nss`, `restir_di`, `path_tracer` | sub-objects with their own settings |
-| `frame_count`, `add_debug_frame(n)` | |
+| `frame_count` | |
+| `profile_session` | assign a `GPUProfileSession` to record GPU timings; null when nothing is profiling |
 
 ---
 

package/src/shade/descriptor/pipeline/compute/ComputePipelineDescriptor.d.ts

@@ -19,6 +19,23 @@ export class ComputePipelineDescriptor extends PipelineDescriptorBase {
      */
     static fromJSON(json: GPUComputePipelineDescriptor): ComputePipelineDescriptor;
     compute: ProgrammableStage;
+    /**
+     * `[x, y, z]` of this pipeline's `@workgroup_size`.
+     *
+     * Read once, when the code is set, and kept — the source cannot change under a descriptor
+     * without going back through one of the factories, each of which reads it again. So every
+     * consumer downstream, a profile capture included, gets the number for free.
+     *
+     * Frozen, because it is handed out by reference to per-pass profile records and a descriptor
+     * that outlives a whole capture must not be mutable through one of them.
+     *
+     * Takes no part in {@link equals} or {@link hash}: it is derived from `compute.module`, which
+     * both already cover, and a cache key computed two ways is a cache that can disagree with
+     * itself.
+     *
+     * @returns {readonly number[]}
+     */
+    get workgroup_size(): readonly number[];
     /**
      *
      * @param {GPUComputePipelineDescriptor} json
@@ -35,6 +52,7 @@ export class ComputePipelineDescriptor extends PipelineDescriptorBase {
      * @type {boolean}
      */
     readonly isComputePipelineDescriptor: boolean;
+    #private;
 }
 import { PipelineDescriptorBase } from "../PipelineDescriptorBase.js";
 import { ProgrammableStage } from "../ProgrammableStage.js";

package/src/shade/descriptor/pipeline/compute/ComputePipelineDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComputePipelineDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/descriptor/pipeline/compute/ComputePipelineDescriptor.js"],"names":[],"mappings":"AAQA;IAGI;;;;;OAKG;IACH,mBAJW,MAAM,QACN,MAAM,UACN,wBAAwB,6BAalC;IAED;;;;;OAKG;IACH,wEALW,MAAM,6BAyBhB;IAED;;;OAGG;IACH,+EAMC;IA3DD,2BAAkC;IA6DlC;;;OAGG;IACH,mDAMC;IAED;;;;OAIG;IACH,cAHW,yBAAyB,GACxB,OAAO,CAMlB;IAUL;;;OAGG;IACH,sCAFU,OAAO,CAE8C;CAN9D;uCAhGsC,8BAA8B;kCAEnC,yBAAyB;yCADlB,gCAAgC"}
+{"version":3,"file":"ComputePipelineDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/descriptor/pipeline/compute/ComputePipelineDescriptor.js"],"names":[],"mappings":"AAqBA;IAuDI;;;;;OAKG;IACH,mBAJW,MAAM,QACN,MAAM,UACN,wBAAwB,6BAelC;IAED;;;;;OAKG;IACH,wEALW,MAAM,6BA2BhB;IAED;;;OAGG;IACH,+EAMC;IAnHD,2BAAkC;IAOlC;;;;;;;;;;;;;;;OAeG;IACH,wCAEC;IA4FD;;;OAGG;IACH,mDAUC;IAED;;;;OAIG;IACH,cAHW,yBAAyB,GACxB,OAAO,CAMlB;IAUL;;;OAGG;IACH,sCAFU,OAAO,CAE8C;;CAN9D;uCAtKsC,8BAA8B;kCAEnC,yBAAyB;yCADlB,gCAAgC"}