@woosh/meep-engine 3.61.3 → 3.62.0

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

@@ -1 +1 @@
-{"version":3,"file":"GPUDecalRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/GPUDecalRenderer.js"],"names":[],"mappings":"AA8EA;;;;;;;;;;;;;GAaG;AACH;IA6BI;;;;;;;;;;;OAWG;IACH;QAP8B,KAAK;QACL,OAAO,EAA1B,YAAY;QACC,YAAY,EAAzB,MAAM;QACU,YAAY;QACZ,YAAY;QACZ,SAAS;aA+BnC;IA4SD,gBAoBC;;CACJ"}
+{"version":3,"file":"GPUDecalRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/GPUDecalRenderer.js"],"names":[],"mappings":"AA+EA;;;;;;;;;;;;;GAaG;AACH;IA6BI;;;;;;;;;;;OAWG;IACH;QAP8B,KAAK;QACL,OAAO,EAA1B,YAAY;QACC,YAAY,EAAzB,MAAM;QACU,YAAY;QACZ,YAAY;QACZ,SAAS;aA+BnC;IA4SD,gBAoBC;;CACJ"}

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

@@ -6,6 +6,7 @@ import { TextureDescriptor } from "../../../shade/descriptor/texture/TextureDesc
 import { TextureViewDescriptor } from "../../../shade/descriptor/texture/TextureViewDescriptor.js";
 import { TextureResourceDescriptor } from "../../../shade/device/graph/TextureResourceDescriptor.js";
 import { G_BUFFER_ALBEDO_FORMAT } from "../../../shade/renderer/gbuffer/G_BUFFER_ALBEDO_FORMAT.js";
+import { G_BUFFER_COLOR_TARGETS } from "../../../shade/renderer/gbuffer/G_BUFFER_COLOR_TARGETS.js";
 import { TextureFilterType } from "../../../shade/renderer/texture/TextureFilterType.js";
 import { SAMPLER_ANISOTROPIC_CLAMP } from "../../../shade/renderer/texture/SAMPLER_ANISOTROPIC_CLAMP.js";
 import { graph_build_decal_clusters } from "./graph_build_decal_clusters.js";
@@ -30,7 +31,7 @@ const GROWTH_FACTOR = 1.5;
  *
  * @type {GPUTextureFormat[]}
  */
-const G_BUFFER_FORMATS = ["rg8unorm", "rgba16uint", G_BUFFER_ALBEDO_FORMAT, "r32uint"];
+const G_BUFFER_FORMATS = G_BUFFER_COLOR_TARGETS.map(target => target.format);
 
 /**
  * @type {TextureViewDescriptor}

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":"AAkEA,oDAKG;AAyTH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qCAFU,eAAe,CActB;6BAlX0B,qDAAqD;gCARlD,sBAAsB"}
+{"version":3,"file":"shader_decal_composite.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_decal_composite.js"],"names":[],"mappings":"AAuEA,oDAKG;AA8TH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qCAFU,eAAe,CActB;6BAvX0B,qDAAqD;gCARlD,sBAAsB"}

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

@@ -1,7 +1,7 @@
 import { CAMERA_UNIFORM_STRUCT } from "../../../shade/renderer/camera/CAMERA_UNIFORM_STRUCT.js";
 import { VIEW_UNIFORM_STRUCT } from "../../../shade/renderer/view/VIEW_UNIFORM_STRUCT.js";
 import { chunk_view_mip_bias } from "../../../shade/renderer/view/chunk_view_mip_bias.js";
-import { G_BUFFER_ALBEDO_FORMAT } from "../../../shade/renderer/gbuffer/G_BUFFER_ALBEDO_FORMAT.js";
+import { G_BUFFER_COLOR_TARGETS } from "../../../shade/renderer/gbuffer/G_BUFFER_COLOR_TARGETS.js";
 import {
     chunk_cluster_depth_to_z_slice
 } from "../../../shade/renderer/light/cluster/chunk_cluster_depth_to_z_slice.js";
@@ -20,9 +20,14 @@ import {
 import {
     chunk_decode_g_buffer_normal
 } from "../../../shade/renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../../../shade/renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import {
     chunk_encode_g_buffer_normal
 } from "../../../shade/renderer/shader/chunk/geometry/normal/chunk_encode_g_buffer_normal.js";
+import { chunk_decode_g_buffer_albedo } from "../../../shade/renderer/shader/chunk/material/chunk_decode_g_buffer_albedo.js";
+import { chunk_encode_g_buffer_albedo } from "../../../shade/renderer/shader/chunk/material/chunk_encode_g_buffer_albedo.js";
 import { chunk_mat4_extract_position } from "../../../shade/renderer/shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import { chunk_grid3d_to_index } from "../../../shade/renderer/shader/chunk/grid/chunk_grid3d_to_index.js";
 import { chunk_rgbe9995_decode } from "../../../shade/renderer/shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js";
@@ -83,7 +88,7 @@ resources.createGroup()
 /*
  The two integer targets are declared as such, exactly as `shader_deferred_main` declares the same
  two: a texture bound without a sample type is a `texture_2d<f32>`, and `textureLoad` on one returns
- floats that cannot be written back into an `rgba16uint` or an `r32uint`.
+ floats that cannot be written back into an `r32uint`.
 */
 resources.createGroup()
     .addTexture("gBufferPBR")
@@ -116,8 +121,8 @@ const body = CodeChunk.from(
     //language=WGSL
     `
 struct DecalCompositeOut {
-    @location(0) pbr : vec2<f32>,
-    @location(1) normal : vec4<u32>,
+    @location(0) pbr : vec4<f32>,
+    @location(1) normal : u32,
     @location(2) albedo : vec4<f32>,
     @location(3) emissive : u32,
 }
@@ -130,7 +135,7 @@ fn main(
     let i_coord = vec2<i32>(coord.xy);
 
     let old_pbr = textureLoad(gBufferPBR, i_coord, 0);
-    let old_normal = textureLoad(gBufferNormal, i_coord, 0);
+    let old_normal = textureLoad(gBufferNormal, i_coord, 0).r;
     let old_albedo = textureLoad(gBufferAlbedo, i_coord, 0);
     let old_emissive = textureLoad(gBufferEmissive, i_coord, 0).r;
 
@@ -143,7 +148,7 @@ fn main(
     */
     var out : DecalCompositeOut;
 
-    out.pbr = old_pbr.rg;
+    out.pbr = old_pbr;
     out.normal = old_normal;
     out.albedo = old_albedo;
     out.emissive = old_emissive;
@@ -192,8 +197,8 @@ fn main(
         return out;
     }
 
-    let shading_normal = decode_g_buffer_normal(old_normal.xy);
-    let face_normal = decode_g_buffer_normal(old_normal.zw);
+    let shading_normal = decode_g_buffer_normal(old_normal);
+    let face_normal = decode_g_buffer_face_normal(old_pbr);
 
     /*
      Screen-space world gradients, taken analytically off the surface rather than from 'dpdx'.
@@ -223,7 +228,7 @@ fn main(
     let atlas_normal_size = vec2<f32>(textureDimensions(atlas_normal, 0));
     let atlas_orm_size = vec2<f32>(textureDimensions(atlas_orm, 0));
 
-    var albedo = old_albedo.rgb;
+    var albedo = decode_g_buffer_albedo(old_albedo.rgb);
     var roughness = decode_g_buffer_roughness(old_pbr);
     var metalness = decode_g_buffer_metalness(old_pbr);
     var normal = shading_normal;
@@ -343,15 +348,17 @@ fn main(
         }
     }
 
-    out.albedo = vec4<f32>(albedo, old_albedo.a);
-    out.pbr = vec2<f32>(metalness, roughness);
+    // the albedo's sRGB round trip lands every 8-bit code on itself, so a pixel no decal weighs keeps its bits
+    out.albedo = vec4<f32>(encode_g_buffer_albedo(albedo), old_albedo.a);
+    // the face normal in zw goes back as it came: k/255 written to an 8-bit target is k
+    out.pbr = vec4<f32>(metalness, roughness, old_pbr.zw);
 
     /*
      The two encoded channels are re-encoded only when a decal wrote them: decoding and encoding
      again is not exact, and a channel no decal weights must come back with the bits it had.
     */
     if (wrote_normal) {
-        out.normal = vec4<u32>(encode_g_buffer_normal(normal), old_normal.zw);
+        out.normal = encode_g_buffer_normal(normal);
     }
 
     if (wrote_emissive) {
@@ -369,7 +376,10 @@ fn main(
         chunk_decal_surface_frame,
         chunk_project_position_from_depth,
         chunk_mat4_extract_position,
+        chunk_decode_g_buffer_albedo,
+        chunk_encode_g_buffer_albedo,
         chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_encode_g_buffer_normal,
         chunk_decode_g_buffer_roughness,
         chunk_decode_g_buffer_metalness,
@@ -409,9 +419,9 @@ export const shader_decal_composite = new DecalTileShader({
         body
     }),
     targets: [
-        { label: "pbr", format: "rg8unorm" },
-        { label: "normal", format: "rgba16uint" },
-        { label: "albedo", format: G_BUFFER_ALBEDO_FORMAT },
-        { label: "emissive", format: "r32uint" },
+        { label: "pbr", format: G_BUFFER_COLOR_TARGETS[0].format },
+        { label: "normal", format: G_BUFFER_COLOR_TARGETS[1].format },
+        { label: "albedo", format: G_BUFFER_COLOR_TARGETS[2].format },
+        { label: "emissive", format: G_BUFFER_COLOR_TARGETS[3].format },
     ]
 });

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

@@ -1 +1 @@
-{"version":3,"file":"shader_decal_tile_copy.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_decal_tile_copy.js"],"names":[],"mappings":"AAWA,oDAEG;AA6CH;;;;;;GAMG;AACH,qCAFU,eAAe,CActB;6BArE0B,qDAAqD;gCAClD,sBAAsB"}
+{"version":3,"file":"shader_decal_tile_copy.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_decal_tile_copy.js"],"names":[],"mappings":"AAWA,oDAEG;AA6CH;;;;;;GAMG;AACH,qCAFU,eAAe,CAStB;6BAhE0B,qDAAqD;gCAClD,sBAAsB"}

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

@@ -1,4 +1,4 @@
-import { G_BUFFER_ALBEDO_FORMAT } from "../../../shade/renderer/gbuffer/G_BUFFER_ALBEDO_FORMAT.js";
+import { G_BUFFER_COLOR_TARGETS } from "../../../shade/renderer/gbuffer/G_BUFFER_COLOR_TARGETS.js";
 import { CodeChunk } from "../../../shade/renderer/shader/compiler/CodeChunk.js";
 import {
     ShaderResourceSetDescriptor
@@ -31,8 +31,8 @@ const body = CodeChunk.from(
     //language=WGSL
     `
 struct DecalTileCopyOut {
-    @location(0) pbr : vec2<f32>,
-    @location(1) normal : vec4<u32>,
+    @location(0) pbr : vec4<f32>,
+    @location(1) normal : u32,
     @location(2) albedo : vec4<f32>,
     @location(3) emissive : u32,
 }
@@ -46,8 +46,8 @@ fn main(
     var out : DecalTileCopyOut;
 
     // the two unorm targets round-trip exactly: k/255 written back is k
-    out.pbr = textureLoad(gBufferPBR, i_coord, 0).rg;
-    out.normal = textureLoad(gBufferNormal, i_coord, 0);
+    out.pbr = textureLoad(gBufferPBR, i_coord, 0);
+    out.normal = textureLoad(gBufferNormal, i_coord, 0).r;
     out.albedo = textureLoad(gBufferAlbedo, i_coord, 0);
     out.emissive = textureLoad(gBufferEmissive, i_coord, 0).r;
 
@@ -69,10 +69,5 @@ export const shader_decal_tile_copy = new DecalTileShader({
         resources,
         body
     }),
-    targets: [
-        { format: "rg8unorm" },
-        { format: "rgba16uint" },
-        { format: G_BUFFER_ALBEDO_FORMAT },
-        { format: "r32uint" },
-    ]
+    targets: G_BUFFER_COLOR_TARGETS.map(({ format }) => ({ format }))
 });

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":"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"}
+{"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,CAkClB;IAoED,gBAOC;;CACJ"}

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

@@ -66,7 +66,10 @@ export class GPUHighlightRenderer {
             this.#execute(data, resources, execution, table_size, thickness, resolution);
         });
 
-        data.viz_mesh = pass.read(frame.get(ViewTextures).visibility_mesh);
+        const view_textures = frame.get(ViewTextures);
+
+        data.visibility = pass.read(view_textures.visibility);
+        data.visible_meshlets = pass.read(view_textures.visible_meshlets);
 
         // read and written, because the outline blends over what is already there
         data.color = pass.write(pass.read(scene.color));
@@ -97,7 +100,8 @@ export class GPUHighlightRenderer {
             encoder,
             bindings: {
                 settings,
-                viz_mesh: resources.get(data.viz_mesh).obtainView(),
+                visibility: resources.get(data.visibility).obtainView(),
+                visible_meshlets: resources.get(data.visible_meshlets),
                 highlight_table: this.#table
             },
             colorAttachments: [{

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

@@ -1 +1 @@
-{"version":3,"file":"shader_highlight_outline.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/highlight/shader_highlight_outline.js"],"names":[],"mappings":"AAYA,sDAaG;AAoFH;;;;;;;;;;;;;;;GAeG;AACH,uCAFU,WAAW,CA0BlB;6BA5I0B,qDAAqD;4BAPtD,+CAA+C"}
+{"version":3,"file":"shader_highlight_outline.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/highlight/shader_highlight_outline.js"],"names":[],"mappings":"AAgBA,sDAaG;AAiGH;;;;;;;;;;;;;;;GAeG;AACH,uCAFU,WAAW,CA0BlB;6BA7J0B,qDAAqD;4BAPtD,+CAA+C"}

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

@@ -1,150 +1,167 @@
-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"
-                }
-            })
-        }
-    ]
-});
+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_visibility_decode,
+    VISIBLE_MESHLETS_RESOURCE
+} from "../../../shade/renderer/rasterize/visibility/chunk_visibility_decode.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("visibility", "uint")
+    .add(VISIBLE_MESHLETS_RESOURCE);
+
+resources.createGroup()
+    .addStorageBuffer("highlight_table", WebGPUArray.u32);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+// the mesh row at a pixel, or a row no table holds where no surface is
+fn outline_mesh_at(at: vec2<i32>) -> u32 {
+    let word = textureLoad(visibility, at, 0).r;
+
+    if (word == VISIBILITY_NONE) {
+        return VISIBILITY_NONE;
+    }
+
+    return visibility_decode(word).mesh;
+}
+
+@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, outline_mesh_at(here), 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, outline_mesh_at(at), 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,
+        chunk_visibility_decode,
+    ]
+);
+
+/**
+ * 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/graphics3/shader_picking_gather.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_picking_gather.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/shader_picking_gather.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,0CAFU,MAAM,CAE6B;AAE7C;;;;;;;;GAQG;AACH,qCAFU,MAAM,CAEiC;AAEjD;;GAEG;AACH,4CAFU,MAAM,CAEgC;AAkEhD;;;;;;;;;;;;;;;GAeG;AACH,kDAIG;8BAnH2B,8CAA8C"}
+{"version":3,"file":"shader_picking_gather.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/shader_picking_gather.js"],"names":[],"mappings":"AAeA;;;;;GAKG;AACH,0CAFU,MAAM,CAE6B;AAE7C;;;;;;;;GAQG;AACH,qCAFU,MAAM,CAEiC;AAEjD;;GAEG;AACH,4CAFU,MAAM,CAEgC;AA2EhD;;;;;;;;;;;;;;;GAeG;AACH,kDAIG;8BA5H2B,8CAA8C"}