@woosh/meep-engine 3.61.2 → 3.61.3

package/CHANGELOG.md

@@ -2,6 +2,117 @@
 
 ## Unreleased
 
+### Probe clipmap GI: a probe ray's hit reads one texel of the brick material, drawn by its weight
+
+- **Changed:** the shade takes a hit's diffuse albedo and emissive from one of the 8 brick material texels about its
+  surface point, drawn in proportion to its weight in their blend (`probe_clipmap_hit_material_pick`,
+  `brick_material_surface_pick`, `surface_material_pick` over `sample_discrete_wrs_mat2x4`), where it blended
+  the 8: the blend on average, which the probe's blend of its rays takes. The draw comes from the ray's slot and
+  direction, apart from the light pass's draws. On Sponza the shade costs 0.62 ms at the median where it cost 0.84
+  on an AMD RDNA2 iGPU (40 µs where 50 on an RTX 4090), and the converged indirect diffuse differs from the blend's
+  by less than two runs of the blend differ. The brick material debug view and the gather into world texels keep
+  the blend.
+- **Added:** `chunk_surface_material_pick` (`surface_material_pick`, `surface_material_surface_at`,
+  `SURFACE_MATERIAL_NO_CORNER`), `chunk_brick_material_surface_pick`, `chunk_probe_clipmap_hit_material_pick`.
+
+### Model SDF: bricks of the same bytes share a slot, and fields and surface caches go in bundles
+
+- **Changed:** a field brick takes the slot already holding its bytes. After evaluate, a pass a texel a thread
+  sums each brick's u32 content key (`MESH_SDF_BRICK_KEY.js`). Resolve's find takes the first slot listed under
+  the key in a content table (`chunk_mesh_sdf_contents`), or claims the key in the frame's claims, the first
+  brick of the key its representative; compare, a texel a thread, holds the brick's bytes against the slot's or
+  the representative's; fresh gives a representative a fresh slot listed under its key, and a brick whose bytes
+  differ a slot of its own listed nowhere (`GPUGeometrySDFManager.bricks_collided`). A key only finds candidates:
+  two bricks share a slot once their 512 bytes compare equal, never on their keys alone. A slot counts the
+  entries holding it, and free gives it back with the last; a grown atlas's content table takes the old one's
+  records (`shader_mesh_sdf_content_rehash`). On Sponza 57% of the field's 115,978 stored bricks are copies of
+  another: they take 49,823 slots where they took 115,978, the atlas 32 MiB where it took 64, the field 38.51 MiB
+  where it took 69.26, and every entry reads the same bytes as before; no two of the 49,823 distinct bricks share
+  a key. The fill's frames cost 29 µs more at the median, beside evaluate's 1.4 ms.
+- **Added:** `ModelCacheBundle` (`geometry/sdf/bundle/`): Model SDFs and Model Surface Caches in one package,
+  each brick once, the fields naming bricks and the caches naming fields, kept as bytes by
+  `model_cache_bundle_write` and `model_cache_bundle_read` (`MODEL_CACHE_BUNDLE.js`).
+  `GPUGeometrySDFManager.export_bundle` reads resident ones out; `upload_bundle` takes one back as the fields of
+  geometries that have none, placed by the next bake (`shader_mesh_sdf_upload`), sharing its bricks with those
+  resident, by key and compare as the bake does, or not, and offers its caches to the surface caches, which take
+  one where the material keeps the same planes (`GPUMeshSurfaceCaches.adopt_layout`). On Sponza a bundle of the
+  scene is 54.7 MB; taken back on a fresh page, with sharing or without, its fields hold what the bake's did and
+  export again as they were, and only the fields admitted before the upload were baked.
+- **Added:** `chunk_hash_table_atomic`, inserts, finds and removes on the device over `cpu_build_hash_table`'s
+  table, which holds at least `HASH_TABLE_PROBE_LIMIT` records, on the probe sequence
+  `chunk_generate_next_linear_congruential_index` it now shares with `chunk_hash_table_get`;
+  `HASH_TABLE_PROBE_LIMIT` is exported. `chunk_subgroup_atomic_load` loads an atomic every lane of a subgroup
+  reads once a subgroup, where `atomicLoad` is a read-modify-write (D3D12): on Sponza the key pass's 24 µs a
+  frame fell to 6. `GPUMeshSurfaceCaches.material_of` names a cache's material.
+- **Changed:** `chunk_subgroup_atomic_add` takes calls behind returns its caller knows to be subgroup-uniform:
+  its uniformity diagnostic is off.
+- **Breaking:** the bake's arena keeps a record of `MESH_SDF_TAKEN_WORDS` for each brick taken, then the frame's
+  claims; evaluate binds no slot stack and takes no `slot_capacity`; store takes `tally_offset`; the log has
+  `MESH_SDF_LOG_SHARED` and `MESH_SDF_LOG_COLLIDED`, and take writes `MESH_SDF_TAKE_COUNT`. Free binds
+  `mesh_sdf_contents` and `mesh_sdf_content_table`.
+
+### Probe clipmap GI: a Model Surface Cache keeps 4³ blocks, block-coded, where its field can hold surface
+
+- **Changed:** a field's bricks are surveyed once, when one of its caches first keeps a plane: each brick keeps
+  those of its eight 4³ blocks some texel of which can hold surface, numbered in the geometry's block table, a word a
+  brick, and the count is read back. Every cache of the geometry keeps its blocks by those numbers, and only those.
+- **Changed:** each plane a cache keeps is block-coded. The diffuse albedo is two subsets of the block's texels, each
+  a line through their square roots with 888 endpoints, and a subset bit and a 3-bit index a texel (48 B a block): the
+  subsets start split about the mean of r + g + b, then each texel moves to the nearer line until none moves. The
+  metalness and roughness is a line of 4-bit endpoints and a 2-bit index a texel (20 B), the emissive a code a texel
+  (256 B), the presence a bit a texel (8 B). A bake lists, traces into a staging, and codes a workgroup a block. On
+  Sponza the caches take 34.55 MiB where they took 299.8 MiB, and the albedo the probes' hits read is as far off the
+  G-buffer's as before (0.0359 and 0.0879 on two views).
+- **Changed:** the caches' tables and blocks are one storage buffer, `mesh_surface_data`, in place of the planes'
+  atlases and the presence words: readers bind it and the records.
+- **Breaking:** `MESH_SURFACE_STRUCT` is 52 bytes: `tiles`, `blocks`, `texels`, `table`, each run's word
+  (`presence_blocks`, `albedo_blocks`, `metal_rough_blocks`, `emissive_blocks`) and each plane's code.
+  `GPUMeshSurfaceCaches.atlas_at` and `presence` are gone for `data`; `set_blocks` hands a survey's count over,
+  and `blocks_of` reads it. `MESH_SURFACE_PRESENCE_RESOURCE` and the planes' texture resources are gone for
+  `MESH_SURFACE_DATA_RESOURCE`; `MESH_SURFACE_TEXEL_STRUCT` names its staging slot in place of its tiles.
+
+### Probe clipmap GI: a Model Surface Cache keeps a plane only where it varies
+
+- **Changed:** each plane of a Model Surface Cache — diffuse albedo, metalness and roughness, emissive — is its own
+  atlas, and a cache keeps texels of a plane only where its material makes it vary over the surface, as the bake's
+  material sample does: an albedo texture, vertex colors or a metalness that varies vary the diffuse albedo, an ORM
+  texture the metalness and roughness, an emissive texture under a factor that is not 0 the emissive. Every other
+  plane is one code in the cache's record, the material's own value, and a cache that varies in no plane is never
+  baked. On Sponza, where no material is emissive and one lacks an ORM texture, the caches take 299.8 MiB where they
+  took 515.75 MiB.
+- **Changed:** which texels hold a material is a presence bit a texel, beside the planes (`mesh_surface_presence`,
+  16 words a brick), set by the bake where it found surface; readers blend those alone. The brick clipmap's own
+  material still says it in its albedo plane.
+- **Added:** `albedo_compress` and `metal_rough_compress` on the host, giving the shader codecs' codes, and
+  `meshlet_batch_colored`, whether a batch's vertices carry a color other than white.
+- **Breaking:** `MESH_SURFACE_STRUCT` is 44 bytes: `tiles`, `texels` (bit `1 << plane` for each plane kept),
+  the presence's tile and each plane's, and each plane's code, where it held `tile_base` and `tiles`.
+  `GPUMeshSurfaceCaches.atlas` is `atlas_at(plane)`, with `presence` beside it, and `set_layout` takes whether
+  the geometry is colored. Readers of the caches bind `mesh_surface_presence`. `surface_material_corners` takes
+  the surface point (`surface_material_point`) and a presence mask, which `surface_material_present` makes from an
+  albedo plane, and `surface_material_surface` and `surface_material_metal_rough` take the tile's origin.
+  `NEUTRAL_SURFACE` is a module of its own.
+
+### Probe clipmap GI: the mesh cards are gone; every hit reads the brick material
+
+- **Changed:** the probes' hits always read the brick material, gathered as each clipmap brick is built from the
+  Model Surface Cache of the `meshes` row nearest each texel (`geometry/sdf/surface/`, added the change before). The
+  brick material is made with the clipmaps, and the scene holds keep a surface cache for each (geometry, material) pair
+  the SDF world draws. On Sponza the hits' albedo is 0.0288 and 0.0301 off the G-buffer's on two views, against the
+  cards' 0.0294 and 0.0306; the caches take 512 MiB where the cards took 111.5 MiB.
+- **Changed:** the brick clipmap keeps no object cells, which named a hit's row for the cards: no 64 rows a slot, no
+  object merge in the mesh provider's batches and resolve, no row looked up by the probe trace. The probe ray record's
+  `row` is `albedo`, which shade writes.
+- **Changed:** a field's header loses its `cards` word, the bake log's records are three words, and the take four.
+- **Breaking:** gone are `geometry/sdf/cards/` (`GPUMeshCardSets`, `MeshCardCaptureMode`, the placement and capture
+  passes, `chunk_mesh_card_surface`), `GPUGeometrySDFManager.cards` and `graph_bake`'s `capture_budget` and
+  `material_contexts`, `ProbeClipmapHitMaterial`, `PROBE_CLIPMAP_HIT_MATERIAL`, `chunk_probe_clipmap_hit_surface`,
+  the settings `hit_material`, `card_capture_budget` and `card_capture_mode`, `ProbeClipmapSceneHolds`'s `surfaces`
+  option, `card_set_of` and `card_rows_buffer`, `GPUProbeClipmap.graph_update`'s `card_rows` and `hit_material`,
+  `GPUBrickClipmap.objects`, `BRICK_OBJECT_CELLS`, `BRICK_OBJECTS_RESOURCE` and `chunk_brick_clipmap_object`.
+  `probe_clipmap_hit_material` and `probe_clipmap_hit_metal_rough` take no row. `ProbeClipmapDebugView.MeshCards` is
+  `MeshSurfaces`, at the same value, and shows each row's surface cache.
+
 ### Network: a client ahead of the host repays its lead in seconds
 
 - **Fixed:** a client that found itself far ahead of the host — the host lost time: a hidden or hitched

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.61.2",
+  "version": "3.61.3",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

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

@@ -66,11 +66,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#486@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#488@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#486@#clear_field"(fluid: FluidComponent): void;
+    static "__#488@#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
@@ -82,7 +82,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#486@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#488@#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
@@ -102,7 +102,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#486@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#488@#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 Transform64> | ResourceAccessSpecification<typeof FluidObstacle> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof FluidComponent>)[];

package/src/shade/playground/probe_clipmap/README.md

@@ -21,7 +21,7 @@ has the two lines that put it there. Another scene loads with `?scene=/some/othe
 | control | what it does |
 |---|---|
 | Indirect light | the probe clipmap, or IBL to compare against |
-| Debug view | the brick clipmap as the probes' rays see it; the geometry caches' mesh SDF; the hits' albedo from the cards |
+| Debug view | the brick clipmap as the probes' rays see it; the geometry caches' mesh SDF; the hits' albedo from the meshes' surface caches; the brick material the probes' hits read; the light the probes' indirect diffuse (irradiance / π) or indirect specular (radiance) is made of, before the surface's albedo, metalness, reflectance and occlusion, through the frame's TAA and exposure |
 | Path tracer (P) | the accumulating path tracer's image in place of the rasterized one, as ground truth; TAA is off while it is on and comes back after |
 | History re-sampling (R) | each probe update pools its rays with what four of its neighbours have already seen, where their depth confirms it (`ProbeClipmapSettings.history_resampling`); off by default, and measured quieter but no faster to converge on Sponza (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.8) |
 | Ray re-sampling (T) | each probe update also takes every ray one neighbour traced the same frame, the neighbour drawn by its radiance and the probe's sight of it, each ray where the probe's depth confirms its hit or sky (`ProbeClipmapSettings.ray_resampling`); off by default (PROBE_RAY_REPROJECTION_SCOPE_2026_11_01.md) |
@@ -39,6 +39,5 @@ the camera, the sun or the point lights restarts it. It stops at three bounces.
 
 ## What to expect
 
-Specular light still comes from the environment, unoccluded, until the probes' specular lands (the
-proposal's S6). Indoors, where the probes' diffuse is rightly darker than IBL's, that sky reflection shows
-as a bluish sheen over cloth and stone.
+Both lobes come from the probes (the proposal's §9). A pixel no probe weighs anything for takes the
+environment's light for both, as IBL gives it.

package/src/shade/playground/probe_clipmap/index.html

@@ -99,7 +99,11 @@
             <option value="None" selected>None</option>
             <option value="BrickClipmap">Brick clipmap — what the rays see</option>
             <option value="MeshSDF">Mesh SDF — the geometry caches</option>
-            <option value="MeshCards">Mesh cards — the hits' albedo</option>
+            <option value="MeshSurfaces">Mesh surfaces — each mesh's surface cache</option>
+            <option value="IndirectDiffuse">Indirect diffuse — the probes' irradiance / π, before the material</option>
+            <option value="IndirectSpecular">Indirect specular — the probes' radiance, before the material</option>
+            <option value="BrickMaterial">Brick material — the probes' hits' albedo</option>
+            <option value="BrickMetalRough">Brick material — the probes' hits' metal (R) and rough (G)</option>
         </select>
     </label>
 
@@ -153,18 +157,6 @@
         frame-time knob; this page starts higher so Sponza is whole in seconds, not minutes.
     </p>
 
-    <label>
-        <span>Card capture</span>
-        <select id="card_capture_mode">
-            <option value="Raster" selected>Raster — the material's own pass</option>
-            <option value="Trace">Trace — a ray a texel</option>
-        </select>
-    </label>
-    <p class="note">
-        How the cards take their albedo. A change captures every card set again; the Mesh cards view
-        shows what they hold.
-    </p>
-
     <hr>
 
     <div id="status"></div>

package/src/shade/playground/probe_clipmap/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AA0FA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CA0SzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AAyFA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAsSzB"}

package/src/shade/playground/probe_clipmap/main.js

@@ -11,7 +11,6 @@ import { camera_frame_sphere } from "../../renderer/camera/camera_frame_sphere.j
 import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCameraController.js";
 import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
 import { create_frame_loop } from "../../renderer/create_frame_loop.js";
-import { MeshCardCaptureMode } from "../../renderer/geometry/sdf/cards/MeshCardCaptureMode.js";
 import { ProbeClipmapDebugView } from "../../renderer/global_illumination/probe_clipmap/debug/ProbeClipmapDebugView.js";
 import { make_sunlight } from "../../renderer/light/make_sunlight.js";
 import { PointLight } from "../../renderer/light/model/PointLight.js";
@@ -242,10 +241,6 @@ export async function start() {
         renderer.probe_clipmap.debug_view = ProbeClipmapDebugView[event.target.value];
     });
 
-    element('card_capture_mode').addEventListener('change', event => {
-        renderer.probe_clipmap.card_capture_mode = MeshCardCaptureMode[event.target.value];
-    });
-
     const taa_toggle = element('taa');
     const path_tracing_toggle = element('path_tracing');
 

package/src/shade/playground/probe_clipmap_box/README.md

@@ -34,7 +34,7 @@ then open <http://localhost:5173/src/shade/playground/probe_clipmap_box/index.ht
 | Sun (1, 2, 3) | through the hole onto the red wall or the green wall, from 45°, or straight down onto the floor |
 | Hole open (H) | closed, a lid of the hole's size sits flush in the ceiling; it is placed into the scene and taken out again, so the bricks the rays march are rebuilt as a level's would be |
 | Indirect light | the probe clipmap, or IBL to compare against |
-| Debug view | the brick clipmap as the rays see it; the geometry caches' mesh SDF; the hits' albedo from the cards |
+| Debug view | the brick clipmap as the rays see it; the geometry caches' mesh SDF; the hits' albedo from the meshes' surface caches |
 | Restart GI (K) | gives the clipmaps back and builds them again from nothing, the geometry caches kept: a cold start without a reload |
 | Path tracer (P) | the accumulating path tracer, three bounces, for context; TAA is off while it is on |
 | TAA | the resolve the probe pick's noise is meant for |

package/src/shade/playground/probe_clipmap_box/index.html

@@ -127,7 +127,7 @@
             <option value="None" selected>None</option>
             <option value="BrickClipmap">Brick clipmap — what the rays see</option>
             <option value="MeshSDF">Mesh SDF — the geometry caches</option>
-            <option value="MeshCards">Mesh cards — the hits' albedo</option>
+            <option value="MeshSurfaces">Mesh surfaces — each mesh's surface cache</option>
         </select>
     </label>
 

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/Renderer.js

@@ -1215,6 +1215,37 @@ export class Renderer {
         cmd.finish();
     }
 
+    /**
+     * The inputs of the probe clipmap's fused indirect pass (`shader_probe_clipmap_indirect_lighting`), less the
+     * probes' own bindings, which `GPUProbeClipmapGI.write_sampling_bindings` adds: for the frame's pass and for
+     * the mode's indirect debug views alike. A fresh object each call, as the probes' bindings are written into it.
+     *
+     * @param {object} params
+     * @param {GPUViewContext} params.view_ctx
+     * @param {number} params.depth graph handle
+     * @param {number} params.normal graph handle
+     * @param {number} params.bent_normal graph handle
+     * @param {number} params.albedo_ao graph handle
+     * @param {number} params.pbr graph handle
+     * @param {number} params.environment graph handle
+     * @param {number} params.camera graph handle
+     * @returns {Object}
+     */
+    #probe_clipmap_indirect_inputs({ view_ctx, depth, normal, bent_normal, albedo_ao, pbr, environment, camera }) {
+        return {
+            tDepth: depth,
+            tNormals: normal,
+            tBentNormals: bent_normal,
+            tGBufferAlbedo: albedo_ao,
+            tGBufferPBR: pbr,
+            tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+            view: view_ctx.uniform_buffer.buffer,
+            camera,
+            tEnvironment: environment,
+            tSplitSum: STATIC_GRAPHICS_ENGINE_ASSETS.split_sum,
+        };
+    }
+
     /**
      * Build and composite deferred indirect lighting, including fused and SSR paths.
      *
@@ -1307,18 +1338,16 @@ export class Renderer {
                             output: [current_color_out],
                             input_depth: gr_texture_depth_current,
                             load_op: "load",
-                            inputs: this.#probe_clipmap_gi.write_sampling_bindings({
-                                tDepth: gr_texture_depth_current,
-                                tNormals: gr_texture_normal,
-                                tBentNormals: bent_normals,
-                                tGBufferAlbedo: gr_texture_material_albedo_ao,
-                                tGBufferPBR: gr_texture_pbr,
-                                tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
-                                view: view_ctx.uniform_buffer.buffer,
+                            inputs: this.#probe_clipmap_gi.write_sampling_bindings(this.#probe_clipmap_indirect_inputs({
+                                view_ctx,
+                                depth: gr_texture_depth_current,
+                                normal: gr_texture_normal,
+                                bent_normal: bent_normals,
+                                albedo_ao: gr_texture_material_albedo_ao,
+                                pbr: gr_texture_pbr,
+                                environment: gr_texture_environment,
                                 camera: gr_buffer_camera_current,
-                                tEnvironment: gr_texture_environment,
-                                tSplitSum: STATIC_GRAPHICS_ENGINE_ASSETS.split_sum,
-                            }),
+                            })),
                         });
                         return current_color_out;
                     }
@@ -3339,6 +3368,16 @@ export class Renderer {
                 view: view_ctx,
                 settings: this.probe_clipmap,
                 resolution: resolution_internal.asArray(),
+                indirect: this.#probe_clipmap_indirect_inputs({
+                    view_ctx,
+                    depth: gr_texture_depth_current,
+                    normal: gr_texture_normal,
+                    bent_normal: bent_normals,
+                    albedo_ao: gr_texture_material_albedo_ao,
+                    pbr: gr_texture_pbr,
+                    environment: gr_texture_environment,
+                    camera: gr_buffer_camera_current,
+                }),
             });
         }
 

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts

@@ -143,7 +143,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#283@#execute_restrict"(record: object, _resources: any, context: {
+    static "__#285@#execute_restrict"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -151,7 +151,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#283@#execute_fill"(record: object, _resources: any, context: {
+    static "__#285@#execute_fill"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -159,7 +159,7 @@ export class GPUFluidCascade {
      * @param {import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#283@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#285@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/GPUFluidCascadeStack.d.ts

@@ -63,7 +63,7 @@ export class GPUFluidCascadeStack {
      * @param {*} _resources
      * @param {{encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#285@#execute_publish"(pass: object, _resources: any, context: {
+    static "__#287@#execute_publish"(pass: object, _resources: any, context: {
         encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts

@@ -90,19 +90,19 @@ export class GPUFluidForcing {
      * @param {number} clear_size bytes cleared from 0 when the pool reuses the buffer
      * @returns {BufferResourceDescriptor}
      */
-    static "__#286@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
+    static "__#288@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
     /**
      * @param {object} record
      * @param {FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#286@#execute_extract"(record: object, resources: FramePassResources, context: {
+    static "__#288@#execute_extract"(record: object, resources: FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
-    static "__#286@#execute_clear"(record: any, _resources: any, context: any): void;
-    static "__#286@#execute_query"(record: any, resources: any, context: any): void;
-    static "__#286@#execute_command"(record: any, resources: any, context: any): void;
-    static "__#286@#execute_apply"(record: any, resources: any, context: any): void;
+    static "__#288@#execute_clear"(record: any, _resources: any, context: any): void;
+    static "__#288@#execute_query"(record: any, resources: any, context: any): void;
+    static "__#288@#execute_command"(record: any, resources: any, context: any): void;
+    static "__#288@#execute_apply"(record: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.d.ts

@@ -41,7 +41,7 @@ export class GPUFluidPressureSolve {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#282@#execute"(data: {
+    static "__#284@#execute"(data: {
         solve: GPUFluidPressureSolve;
         arm: number;
         count: number;

package/src/shade/renderer/fluid/query/GPUFluidQueries.d.ts

@@ -49,7 +49,7 @@ export class GPUFluidQueries {
      * @param {import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#287@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#289@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/geometry/meshlet/meshlet_batch_colored.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Whether any vertex of the batch carries a color other than white. A meshlet keeps a color for each of
+ * its vertices, or one for all of them when they share it; a geometry without colors keeps white, once a
+ * meshlet.
+ *
+ * @param {import("./MeshletBatch.js").MeshletBatch} batch
+ * @returns {boolean}
+ */
+export function meshlet_batch_colored(batch: import("./MeshletBatch.js").MeshletBatch): boolean;
+//# sourceMappingURL=meshlet_batch_colored.d.ts.map

package/src/shade/renderer/geometry/meshlet/meshlet_batch_colored.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meshlet_batch_colored.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/meshlet_batch_colored.js"],"names":[],"mappings":"AAeA;;;;;;;GAOG;AACH,6CAHW,OAAO,mBAAmB,EAAE,YAAY,GACtC,OAAO,CAgCnB"}

package/src/shade/renderer/geometry/meshlet/meshlet_batch_colored.js

@@ -0,0 +1,54 @@
+import { StandardAttributes } from "../StandardAttributes.js";
+import { MESHLET_METADATA_FLAGS } from "./encoding/MESHLET_METADATA_FLAGS.js";
+import { MESHLET_METADATA_STRUCT } from "./encoding/MESHLET_METADATA_STRUCT.js";
+import { meshlet_data_index_section_size } from "./meshlet_data_index_section_size.js";
+import { meshlet_get_attribute_offset } from "./meshlet_get_attribute_offset.js";
+
+const STRIDE = MESHLET_METADATA_STRUCT.size >>> 2;
+const ADDRESS = MESHLET_METADATA_STRUCT.get("address").offset >>> 2;
+const PRIMITIVE_COUNT = MESHLET_METADATA_STRUCT.get("primitive_count").offset >>> 2;
+const VERTEX_COUNT = MESHLET_METADATA_STRUCT.get("vertex_count").offset >>> 2;
+const FLAGS = MESHLET_METADATA_STRUCT.get("flags").offset >>> 2;
+
+/** the color bytes of an encoded vertex color, r | g << 8 | b << 16 */
+const RGB = 0xFFFFFF;
+
+/**
+ * Whether any vertex of the batch carries a color other than white. A meshlet keeps a color for each of
+ * its vertices, or one for all of them when they share it; a geometry without colors keeps white, once a
+ * meshlet.
+ *
+ * @param {import("./MeshletBatch.js").MeshletBatch} batch
+ * @returns {boolean}
+ */
+export function meshlet_batch_colored(batch) {
+    const count = batch.count;
+
+    if (count === 0) {
+        return false;
+    }
+
+    // as written: in the platform's byte order, which a typed view reads
+    const metadata = new Uint32Array(batch.metadata_buffer);
+    const data = new Uint32Array(batch.data_buffer);
+
+    for (let meshlet = 0; meshlet < count; meshlet++) {
+        const header = meshlet * STRIDE;
+        const flags = metadata[header + FLAGS];
+        const vertex_count = metadata[header + VERTEX_COUNT];
+
+        const first = metadata[header + ADDRESS]
+            + meshlet_data_index_section_size(metadata[header + PRIMITIVE_COUNT])
+            + meshlet_get_attribute_offset(StandardAttributes.Color, flags, vertex_count);
+
+        const colors = (flags & MESHLET_METADATA_FLAGS.ATTRIBUTE_COMPRESSED_COLOR) !== 0 ? 1 : vertex_count;
+
+        for (let i = 0; i < colors; i++) {
+            if ((data[first + i] & RGB) !== RGB) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}