@woosh/meep-engine 3.61.2 → 3.62.0

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.62.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/engine/graphics3/PickingSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PickingSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/PickingSystem.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;GAgBG;AACH;IAyBI;;OAEG;IACH,sCAQC;IADG,kCAA8B;IAGlC,2CAIC;IAED,4CAYC;IAED;;;OAGG;IACH,eAHW,QAAQ,UACR,MAAM,QAIhB;IAED;;;OAGG;IACH,iBAHW,QAAQ,UACR,MAAM,QAIhB;IAED;;;;OAIG;IACH,6BAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;;;;;;;;;;OAWG;IACH,cAHW,cAAc,GACZ,QAAQ,aAAa,EAAE,CAAC,CAYpC;IAED;;;;OAIG;IACH,gBAFa;QAAC,OAAO,EAAE,cAAc,CAAC;QAAC,OAAO,SAAW,aAAa,EAAE,KAAG,IAAI,CAAC;QAAC,MAAM,SAAW,KAAK,KAAG,IAAI,CAAA;KAAC,EAAE,CAIhH;IAED;;;;;;OAMG;IACH,iBAHW,MAAM,GACJ,MAAM,CAuBlB;;CACJ;AAED;;;GAGG;AACH;IASI;;OAEG;IACH,oBAFW,aAAa,EAMvB;;CA4IJ;uBA7VsB,kBAAkB;yBAChB,eAAe;8BACV,oBAAoB;gCAPlB,mDAAmD"}
+{"version":3,"file":"PickingSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/PickingSystem.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;GAgBG;AACH;IAyBI;;OAEG;IACH,sCAQC;IADG,kCAA8B;IAGlC,2CAIC;IAED,4CAYC;IAED;;;OAGG;IACH,eAHW,QAAQ,UACR,MAAM,QAIhB;IAED;;;OAGG;IACH,iBAHW,QAAQ,UACR,MAAM,QAIhB;IAED;;;;OAIG;IACH,6BAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;;;;;;;;;;OAWG;IACH,cAHW,cAAc,GACZ,QAAQ,aAAa,EAAE,CAAC,CAYpC;IAED;;;;OAIG;IACH,gBAFa;QAAC,OAAO,EAAE,cAAc,CAAC;QAAC,OAAO,SAAW,aAAa,EAAE,KAAG,IAAI,CAAC;QAAC,MAAM,SAAW,KAAK,KAAG,IAAI,CAAA;KAAC,EAAE,CAIhH;IAED;;;;;;OAMG;IACH,iBAHW,MAAM,GACJ,MAAM,CAuBlB;;CACJ;AAED;;;GAGG;AACH;IASI;;OAEG;IACH,oBAFW,aAAa,EAMvB;;CA8IJ;uBA/VsB,kBAAkB;yBAChB,eAAe;8BACV,oBAAoB;gCAPlB,mDAAmD"}