@woosh/meep-engine 3.61.1 → 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.1",
+  "version": "3.61.3",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/engine/network/sim/SimActionExecutor.d.ts

@@ -224,6 +224,10 @@ export class SimActionExecutor {
     /**
      * Execute an action: capture prior state of affected components, apply, log.
      *
+     * Not re-entrant: calling `execute` or {@link record} from inside `affected_components`,
+     * {@link authorize}, `apply`, `announce` or {@link on_component_written} is illegal (the
+     * executor is passed to actions for `slot_table` / `current_sender_id` reads only).
+     *
      * @param {SimAction} action
      * @param {number} [sender_id] peer that originated this action.
      *   Defaults to {@link SENDER_LOCAL} for locally-originated actions.

package/src/engine/network/sim/SimActionExecutor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SimActionExecutor.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/SimActionExecutor.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,2BAFU,MAAM,CAEiB;AAEjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,6BAFU,MAAM,CAEmB;AAEnC;;;;;;;;;;GAUG;AACH,8BAFU,MAAM,CAEoB;AAEpC;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAEqB;AAErC;;;;;;GAMG;AACH,0BAFU,MAAM,CAEgB;AAEhC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IA2EI;;;;;;;;;OASG;IACH,sGATW;QACV,KAAS,yBAAyB;QAClC,UAAc,YAAY;QAC1B,eAAmB,oBAAoB;QACvC,kBAAsB,8BAA8B;QACpD,UAAc,uBAAuB;QACrC,gBAAoB,CAAC,mBAAmB;KACrC,EAyFH;IAjKD;;;;;;;;;OASG;IACH,gBAFU,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAEP;IAEtB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,WAFU,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,KAAK,OAAO,CAAC,GAAG,IAAI,CAEtE;IAEjB;;;;;;;;;;;;;;;OAeG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;;;OAOG;IACH,sBAFU,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,eAAe,UAAU,KAAK,IAAI,CAAC,GAAG,IAAI,CAE7C;IAaxB;;OAEG;IACH,8BAAkB;IAElB;;OAEG;IACH,sBAA4B;IAE5B;;OAEG;IACH,mCAAsC;IAEtC;;OAEG;IACH,gDAA4C;IAE5C;;;;OAIG;IACH,iCAA4B;IAE5B;;;;;;;;;;;OAWG;IACH,kBAFU,mBAAiB,IAAI,CAES;IA4BxC;;;;;;;OAOG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;OAOG;IACH,kBAFU,MAAM,CAEoB;IAGxC;;;;;;;;;;OAUG;IACH,uCAPW,MAAM,GAGJ,OAAO,CA0KnB;IAkCD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gCAwCC;IAED;;;;;;;;;;;;;OAaG;IACH,4BAFW,MAAM,QAqChB;IAED;;;;;;;;OAQG;IACH,sBAJW,UAAU,UACV,MAAM,UACN,MAAM,QAchB;;CACJ;mBA7mBkB,uCAAuC"}
+{"version":3,"file":"SimActionExecutor.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/SimActionExecutor.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,2BAFU,MAAM,CAEiB;AAEjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,6BAFU,MAAM,CAEmB;AAEnC;;;;;;;;;;GAUG;AACH,8BAFU,MAAM,CAEoB;AAEpC;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAEqB;AAErC;;;;;;GAMG;AACH,0BAFU,MAAM,CAEgB;AAEhC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IA2EI;;;;;;;;;OASG;IACH,sGATW;QACV,KAAS,yBAAyB;QAClC,UAAc,YAAY;QAC1B,eAAmB,oBAAoB;QACvC,kBAAsB,8BAA8B;QACpD,UAAc,uBAAuB;QACrC,gBAAoB,CAAC,mBAAmB;KACrC,EAyFH;IAjKD;;;;;;;;;OASG;IACH,gBAFU,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAEP;IAEtB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,WAFU,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,KAAK,OAAO,CAAC,GAAG,IAAI,CAEtE;IAEjB;;;;;;;;;;;;;;;OAeG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;;;OAOG;IACH,sBAFU,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,eAAe,UAAU,KAAK,IAAI,CAAC,GAAG,IAAI,CAE7C;IAaxB;;OAEG;IACH,8BAAkB;IAElB;;OAEG;IACH,sBAA4B;IAE5B;;OAEG;IACH,mCAAsC;IAEtC;;OAEG;IACH,gDAA4C;IAE5C;;;;OAIG;IACH,iCAA4B;IAE5B;;;;;;;;;;;OAWG;IACH,kBAFU,mBAAiB,IAAI,CAES;IA4BxC;;;;;;;OAOG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;OAOG;IACH,kBAFU,MAAM,CAEoB;IAGxC;;;;;;;;;;;;;;OAcG;IACH,uCAPW,MAAM,GAGJ,OAAO,CA0KnB;IAkCD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gCAwCC;IAED;;;;;;;;;;;;;OAaG;IACH,4BAFW,MAAM,QAqChB;IAED;;;;;;;;OAQG;IACH,sBAJW,UAAU,UACV,MAAM,UACN,MAAM,QAchB;;CACJ;mBAjnBkB,uCAAuC"}

package/src/engine/network/sim/SimActionExecutor.js

@@ -274,6 +274,10 @@ export class SimActionExecutor {
     /**
      * Execute an action: capture prior state of affected components, apply, log.
      *
+     * Not re-entrant: calling `execute` or {@link record} from inside `affected_components`,
+     * {@link authorize}, `apply`, `announce` or {@link on_component_written} is illegal (the
+     * executor is passed to actions for `slot_table` / `current_sender_id` reads only).
+     *
      * @param {SimAction} action
      * @param {number} [sender_id] peer that originated this action.
      *   Defaults to {@link SENDER_LOCAL} for locally-originated actions.

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/generation/foliage/material/foliage_atlas_cutout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"foliage_atlas_cutout.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/foliage_atlas_cutout.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AACH,mDARW,kBAAkB,WAClB,MAAM,WACN,UAAU,WACV,UAAU,gBACV,MAAM,SACN,MAAM,WACN,MAAM,QAiHhB;AAED;;;;;;;;GAQG;AACH,oDANW,kBAAkB,WAClB,MAAM,SACN,YAAY,SACZ,MAAM,WACN,MAAM,QAkBhB;AAED;;;;;;;;GAQG;AACH,8CAJW,OAAO,gCAAgC,EAAE,iBAAiB,QAC1D,kBAAkB,GAChB,kBAAkB,CAU9B;mCA7K4D,yBAAyB"}
+{"version":3,"file":"foliage_atlas_cutout.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/foliage_atlas_cutout.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;GAYG;AACH,mDARW,kBAAkB,WAClB,MAAM,WACN,UAAU,WACV,UAAU,gBACV,MAAM,SACN,MAAM,WACN,MAAM,QAiHhB;AAED;;;;;;;;GAQG;AACH,oDANW,kBAAkB,WAClB,MAAM,SACN,YAAY,SACZ,MAAM,WACN,MAAM,QAkBhB;AAED;;;;;;;;GAQG;AACH,8CAJW,OAAO,gCAAgC,EAAE,iBAAiB,QAC1D,kBAAkB,GAChB,kBAAkB,CAqB9B;mCA3L4D,yBAAyB"}

package/src/generation/foliage/material/foliage_atlas_cutout.js

@@ -1,11 +1,16 @@
+import { HashMap } from "../../../core/collection/map/HashMap.js";
 import { convex_hull_fixed_count_2d_relaxation } from "../../../core/geom/2d/convex-hull/convex_hull_fixed_count_2d_relaxation.js";
 import { convex_hull_monotone_2d } from "../../../core/geom/2d/convex-hull/convex_hull_monotone_2d.js";
 import { polygon2_clip_axis_halfplane } from "../../../core/geom/2d/polygon/polygon2_clip_axis_halfplane.js";
 import { polygon2_is_counter_clockwise } from "../../../core/geom/2d/polygon/polygon2_is_counter_clockwise.js";
 import { clamp } from "../../../core/math/clamp.js";
+import { TreeSpeciesConfig } from "../config/TreeSpeciesConfig.js";
 import { CUTOUT_HULL_VERTEX_COUNT, FoliageAtlasCutout } from "./FoliageAtlasCutout.js";
 import { foliage_tile_layout, foliage_tile_raster } from "./foliage_tile.js";
 
+/** @type {HashMap<TreeSpeciesConfig, FoliageAtlasCutout>} */
+const CUTOUT_CACHE = new HashMap();
+
 /**
  * Fits one tile's hull from the texel rows its silhouette covers. Each covered row contributes the outer corners of
  * its first and last covered texel, so the hull holds every texel with any coverage at all: no alpha threshold, and
@@ -169,11 +174,22 @@ export function foliage_atlas_cutout_fit_alpha(out, variant, alpha, width, heigh
  * @returns {FoliageAtlasCutout}
  */
 export function foliage_atlas_cutout(species, out = new FoliageAtlasCutout()) {
-	const layout = foliage_tile_layout(species);
-	out.resize(layout.variant_count);
-	for (let v = 0; v < layout.variant_count; v++) {
-		const raster = foliage_tile_raster(species, layout, v, true);
-		foliage_atlas_cutout_fit_alpha(out, v, raster.alpha, layout.resolution);
+	const key = new TreeSpeciesConfig();
+	key.seed = 0;
+	key.foliage.copy(species.foliage);
+	key.foliage_material.copy(species.foliage_material);
+	let cached = CUTOUT_CACHE.get(key);
+	if (cached === undefined) {
+		const layout = foliage_tile_layout(key);
+		cached = new FoliageAtlasCutout().resize(layout.variant_count);
+		for (let v = 0; v < layout.variant_count; v++) {
+			const raster = foliage_tile_raster(key, layout, v, true);
+			foliage_atlas_cutout_fit_alpha(cached, v, raster.alpha, layout.resolution);
+		}
+		CUTOUT_CACHE.set(key, cached);
 	}
+	out.resize(cached.variant_count);
+	out.hulls.set(cached.hulls);
+	out.coverage.set(cached.coverage);
 	return out;
 }

package/src/generation/foliage/mesh/tree_cluster_representatives.d.ts

@@ -81,6 +81,14 @@ export type CutShape = {
      * its tile's, at its LOD's texel
      */
     bytes: number;
+    /**
+     * its tile's width in texels
+     */
+    tw: number;
+    /**
+     * its tile's height in texels
+     */
+    th: number;
 };
 /**
  * One LOD's cluster cards, and the error it is drawn to.

package/src/generation/foliage/mesh/tree_cluster_representatives.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree_cluster_representatives.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_cluster_representatives.js"],"names":[],"mappings":"AA4CA;;;;;;;GAOG;AAEH;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uDATW,OAAO,6BAA6B,EAAE,YAAY,eAClD,OAAO,kCAAkC,EAAE,oBAAoB,UAC/D,OAAO,8CAA8C,EAAE,QAAQ,QAC/D,cAAc,EAAE,cAChB,MAAM,iBACN,MAAM,UACN,MAAM,GACJ,0BAA0B,CActC;;;;;SAxFa,MAAM;;;;UACN,MAAM;;;;;UACN,MAAM;cAEN,MAAM;;;;cACN,MAAM;;;;iBACN,MAAM;;;;YACN,MAAM;YACN,MAAM;;;;WACN,MAAM;;;;;;cAmBN,OAAO,oBAAoB,EAAE,WAAW,EAAE;WAC1C,OAAO,yBAAyB,EAAE,eAAe,EAAE;;;;WACnD,MAAM;;;;;;;;;WAON,OAAO,yBAAyB,EAAE,eAAe,EAAE;;;;YACnD,YAAY;;;;aACZ,MAAM,EAAE,EAAE;;;;;;gBACV,MAAM;QAAC,GAAG,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAC,CAAC"}
+{"version":3,"file":"tree_cluster_representatives.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_cluster_representatives.js"],"names":[],"mappings":"AA6CA;;;;;;;GAOG;AAEH;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uDATW,OAAO,6BAA6B,EAAE,YAAY,eAClD,OAAO,kCAAkC,EAAE,oBAAoB,UAC/D,OAAO,8CAA8C,EAAE,QAAQ,QAC/D,cAAc,EAAE,cAChB,MAAM,iBACN,MAAM,UACN,MAAM,GACJ,0BAA0B,CAoHtC;;;;;SAhMa,MAAM;;;;UACN,MAAM;;;;;UACN,MAAM;cAEN,MAAM;;;;cACN,MAAM;;;;iBACN,MAAM;;;;YACN,MAAM;YACN,MAAM;;;;WACN,MAAM;;;;QACN,MAAM;;;;QACN,MAAM;;;;;;cAmBN,OAAO,oBAAoB,EAAE,WAAW,EAAE;WAC1C,OAAO,yBAAyB,EAAE,eAAe,EAAE;;;;WACnD,MAAM;;;;;;;;;WAON,OAAO,yBAAyB,EAAE,eAAe,EAAE;;;;YACnD,YAAY;;;;aACZ,MAAM,EAAE,EAAE;;;;;;gBACV,MAAM;QAAC,GAAG,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAC,CAAC"}

package/src/generation/foliage/mesh/tree_cluster_representatives.js

@@ -1,7 +1,6 @@
 import { assert } from "../../../core/assert.js";
 import { tree_cluster_atlas_pack } from "../material/tree_cluster_atlas_pack.js";
 import { tree_cluster_press } from "../material/tree_cluster_press.js";
-import { tree_cluster_tiles } from "../material/tree_cluster_tiles.js";
 import { foliage_scale_spread } from "./foliage_scale_spread.js";
 
 /**
@@ -28,6 +27,8 @@ const SCRATCH_B = new Float32Array(3);
  * @property {number} hang_u where it hangs, on its plane along its tile's u, m from its origin
  * @property {number} hang_v
  * @property {number} bytes its tile's, at its LOD's texel
+ * @property {number} tw its tile's width in texels
+ * @property {number} th its tile's height in texels
  */
 
 /**
@@ -99,52 +100,78 @@ export function tree_cluster_representatives(skeleton, attachments, leaves, lods
     assert.greaterThan(fine_texel, 0, 'fine_texel');
     assert.greaterThan(legible_texel, 0, 'legible_texel');
 
-    // every cut's leaves pressed onto it, whatever the texel
+    // every cut's leaves pressed onto it, whatever the texel, and its frame, unpadded extent, shown area and hang
     const pressed_lods = lods.map(lod => tree_cluster_press(leaves, attachments, lod.cards));
-    // Ends: a cut's size is never under a texel, so once a texel is as large as every cut, one tile draws them all
-    for (let texel = Math.min(fine_texel, legible_texel); ; texel = texel < legible_texel ? Math.min(2 * texel, legible_texel) : 2 * texel) {
-        const representatives = choose(skeleton, attachments, leaves, lods, pressed_lods, texel, budget);
-        if (representatives !== null) return representatives;
-    }
-}
-
-/**
- * The representatives at LOD0's texel `leaf_texel` (`tree_cluster_representatives`), or `null` when the atlas cannot
- * hold tiles that draw every cut at a size the tree grows.
- *
- * @returns {TreeClusterRepresentatives|null}
- */
-function choose(skeleton, attachments, leaves, lods, pressed_lods, leaf_texel, budget) {
-
-    // ---- every cut's shape and tile, at its LOD's texel
-    const lod_texels = lods.map((lod, k) => k === 0 ? leaf_texel : Math.max(leaf_texel, lods[k - 1].error));
-    /** @type {CutShape[]} */
-    const shapes = [];
-    const lod_first = [];
-    const lod_tiles = [];
-    for (let k = 0; k < lods.length; k++) {
-        const { clusters, cards } = lods[k];
-        lod_first.push(shapes.length);
+    const index = leaves.index.data;
+    const tris_per_leaf = index.length / 3 / attachments.count;
+    const nodes = [], edges = [];
+    const lod_geom = lods.map(({ clusters, cards }, k) => {
         const pressed = pressed_lods[k];
-        const texel = lod_texels[k];
-        const tiles = tree_cluster_tiles(skeleton, cards, pressed, cards.map(() => texel));
-        lod_tiles.push(tiles);
         const P = pressed.positions;
-        const nodes = [], edges = [];
-        const index = leaves.index.data;
-        const tris_per_leaf = index.length / 3 / attachments.count;
-        for (let i = 0; i < cards.length; i++) {
+        const verts_per_leaf = pressed.verts_per_leaf;
+        const count = cards.length;
+        const frames = new Float64Array(count * 12);
+        const bounds = new Float64Array(count * 4);
+        const areas = new Float64Array(count);
+        const hang_u = new Float64Array(count);
+        const hang_v = new Float64Array(count);
+        for (let i = 0; i < count; i++) {
             const card = cards[i];
+            const ox = card.origin[0], oy = card.origin[1], oz = card.origin[2];
+            const nx = card.normal[0], ny = card.normal[1], nz = card.normal[2];
+            const e1x = card.axis[0], e1y = card.axis[1], e1z = card.axis[2];
+            const e2x = ny * e1z - nz * e1y, e2y = nz * e1x - nx * e1z, e2z = nx * e1y - ny * e1x;
             const f = i * 12;
-            const w = tiles.extents[i * 4 + 2] - tiles.extents[i * 4] - 2 * texel;
-            const h = tiles.extents[i * 4 + 3] - tiles.extents[i * 4 + 1] - 2 * texel;
-            const span = Math.max(texel * texel, w * h);
+            frames[f] = ox;
+            frames[f + 1] = oy;
+            frames[f + 2] = oz;
+            frames[f + 3] = e1x;
+            frames[f + 4] = e1y;
+            frames[f + 5] = e1z;
+            frames[f + 6] = e2x;
+            frames[f + 7] = e2y;
+            frames[f + 8] = e2z;
+            frames[f + 9] = nx;
+            frames[f + 10] = ny;
+            frames[f + 11] = nz;
+
+            let min1 = Infinity, max1 = -Infinity, min2 = Infinity, max2 = -Infinity;
+            for (let v = pressed.first[i] * verts_per_leaf; v < pressed.first[i + 1] * verts_per_leaf; v++) {
+                const x = P[v * 3], y = P[v * 3 + 1], z = P[v * 3 + 2];
+                const a = (x - ox) * e1x + (y - oy) * e1y + (z - oz) * e1z;
+                const b = (x - ox) * e2x + (y - oy) * e2y + (z - oz) * e2z;
+                if (a < min1) min1 = a;
+                if (a > max1) max1 = a;
+                if (b < min2) min2 = b;
+                if (b > max2) max2 = b;
+            }
+            for (let s2 = 0; s2 < card.segments.length; s2 += 2) {
+                skeleton.collect_branch_chain(card.segments[s2], nodes, edges);
+                for (const v of [nodes[card.segments[s2 + 1]], nodes[card.segments[s2 + 1] + 1]]) {
+                    skeleton.node_read_position(SCRATCH_A, 0, v);
+                    const pad = skeleton.node_read_radius(v);
+                    const a = (SCRATCH_A[0] - ox) * e1x + (SCRATCH_A[1] - oy) * e1y + (SCRATCH_A[2] - oz) * e1z;
+                    const b = (SCRATCH_A[0] - ox) * e2x + (SCRATCH_A[1] - oy) * e2y + (SCRATCH_A[2] - oz) * e2z;
+                    if (a - pad < min1) min1 = a - pad;
+                    if (a + pad > max1) max1 = a + pad;
+                    if (b - pad < min2) min2 = b - pad;
+                    if (b + pad > max2) max2 = b + pad;
+                }
+            }
+            if (!(max1 >= min1)) {
+                min1 = max1 = min2 = max2 = 0;
+            }
+            bounds[i * 4] = min1;
+            bounds[i * 4 + 1] = min2;
+            bounds[i * 4 + 2] = max1;
+            bounds[i * 4 + 3] = max2;
+
             // pressed flat, a leaf's triangles show their whole area
             let area = 0;
             for (let j = 0; j < card.leaves.length; j++) {
                 const c = card.leaves[j];
                 // from the leaf's vertices to the card's pressed copy's
-                const shift = (pressed.first[i] + j - c) * pressed.verts_per_leaf;
+                const shift = (pressed.first[i] + j - c) * verts_per_leaf;
                 for (let t = c * tris_per_leaf; t < (c + 1) * tris_per_leaf; t++) {
                     const i0 = (index[t * 3] + shift) * 3, i1 = (index[t * 3 + 1] + shift) * 3, i2 = (index[t * 3 + 2] + shift) * 3;
                     const ax = P[i1] - P[i0], ay = P[i1 + 1] - P[i0 + 1], az = P[i1 + 2] - P[i0 + 2];
@@ -153,40 +180,82 @@ function choose(skeleton, attachments, leaves, lods, pressed_lods, leaf_texel, b
                 }
             }
             // a twig shows its length on the plane by its diameter
-            const n = card.normal;
             for (let s2 = 0; s2 < card.segments.length; s2 += 2) {
                 skeleton.collect_branch_chain(card.segments[s2], nodes, edges);
                 const va = nodes[card.segments[s2 + 1]], vb = nodes[card.segments[s2 + 1] + 1];
                 skeleton.node_read_position(SCRATCH_A, 0, va);
                 skeleton.node_read_position(SCRATCH_B, 0, vb);
                 const ex = SCRATCH_B[0] - SCRATCH_A[0], ey = SCRATCH_B[1] - SCRATCH_A[1], ez = SCRATCH_B[2] - SCRATCH_A[2];
-                const along = ex * n[0] + ey * n[1] + ez * n[2];
-                const shown = Math.hypot(ex - along * n[0], ey - along * n[1], ez - along * n[2]);
+                const along = ex * nx + ey * ny + ez * nz;
+                const shown = Math.hypot(ex - along * nx, ey - along * ny, ez - along * nz);
                 area += shown * (skeleton.node_read_radius(va) + skeleton.node_read_radius(vb));
             }
-            const size = Math.sqrt(Math.max(texel * texel, area));
+            areas[i] = area;
+
             const H = clusters[card.cluster].position;
-            const dx = H[0] - tiles.frames[f], dy = H[1] - tiles.frames[f + 1], dz = H[2] - tiles.frames[f + 2];
-            const hang_u = dx * tiles.frames[f + 3] + dy * tiles.frames[f + 4] + dz * tiles.frames[f + 5];
-            const hang_v = dx * tiles.frames[f + 6] + dy * tiles.frames[f + 7] + dz * tiles.frames[f + 8];
+            const dx = H[0] - ox, dy = H[1] - oy, dz = H[2] - oz;
+            hang_u[i] = dx * e1x + dy * e1y + dz * e1z;
+            hang_v[i] = dx * e2x + dy * e2y + dz * e2z;
+        }
+        return { frames, bounds, areas, hang_u, hang_v };
+    });
+
+    const spread = foliage_scale_spread(attachments.scales, attachments.scales.length);
+    const shrink = Math.log(spread.low);
+    const grow = Math.log(spread.high);
+
+    // Ends: a cut's size is never under a texel, so once a texel is as large as every cut, one tile draws them all
+    for (let texel = Math.min(fine_texel, legible_texel); ; texel = texel < legible_texel ? Math.min(2 * texel, legible_texel) : 2 * texel) {
+        const representatives = choose(lods, lod_geom, shrink, grow, texel, budget);
+        if (representatives !== null) return representatives;
+    }
+}
+
+/**
+ * The representatives at LOD0's texel `leaf_texel` (`tree_cluster_representatives`), or `null` when the atlas cannot
+ * hold tiles that draw every cut at a size the tree grows.
+ *
+ * @returns {TreeClusterRepresentatives|null}
+ */
+function choose(lods, lod_geom, shrink, grow, leaf_texel, budget) {
+
+    // ---- every cut's shape and tile, at its LOD's texel
+    const lod_texels = lods.map((lod, k) => k === 0 ? leaf_texel : Math.max(leaf_texel, lods[k - 1].error));
+    /** @type {CutShape[]} */
+    const shapes = [];
+    const lod_first = [];
+    for (let k = 0; k < lods.length; k++) {
+        const { cards } = lods[k];
+        lod_first.push(shapes.length);
+        const texel = lod_texels[k];
+        const { bounds, areas, hang_u, hang_v } = lod_geom[k];
+        for (let i = 0; i < cards.length; i++) {
+            const min1 = bounds[i * 4], min2 = bounds[i * 4 + 1], max1 = bounds[i * 4 + 2], max2 = bounds[i * 4 + 3];
+            const tw = Math.ceil((max1 - min1) / texel) + 2;
+            const th = Math.ceil((max2 - min2) / texel) + 2;
+            const w = (min1 - texel + tw * texel) - (min1 - texel) - 2 * texel;
+            const h = (min2 - texel + th * texel) - (min2 - texel) - 2 * texel;
+            const span = Math.max(texel * texel, w * h);
+            const area = areas[i];
+            const size = Math.sqrt(Math.max(texel * texel, area));
+            const hu = hang_u[i], hv = hang_v[i];
             shapes.push({
                 lod: k,
                 card: i,
                 size,
                 log_size: Math.log(size),
                 coverage: area / span,
-                hang_offset: Math.hypot(hang_u, hang_v) / Math.sqrt(span),
-                hang_u,
-                hang_v,
-                bytes: tiles.sizes[i * 2] * tiles.sizes[i * 2 + 1] * CLUSTER_TEXEL_BYTES
+                hang_offset: Math.hypot(hu, hv) / Math.sqrt(span),
+                hang_u: hu,
+                hang_v: hv,
+                bytes: tw * th * CLUSTER_TEXEL_BYTES,
+                tw,
+                th
             });
         }
     }
 
     // ---- the fewest representatives that draw every cut at a size the tree's own leaves grow to, while the atlas fits
-    const spread = foliage_scale_spread(attachments.scales, attachments.scales.length);
-    const shrink = Math.log(spread.low);
-    const grow = Math.log(spread.high);
     // whether representative `r` draws cut `c` as the tree would grow it: no finer LOD's cut, its leaves magnified
     // within their own spread
     const draws = (c, r) => {
@@ -233,40 +302,60 @@ function choose(skeleton, attachments, leaves, lods, pressed_lods, leaf_texel, b
         }
         return lo;
     };
+    const from_ranks = new Int32Array(n);
+    const to_ranks = new Int32Array(n);
+    for (let r = 0; r < n; r++) {
+        from_ranks[r] = first_rank(shapes[r].log_size, shrink, false);
+        to_ranks[r] = first_rank(shapes[r].log_size, grow, true);
+    }
     const counts = new Int32Array(n);
     const window = new Int32Array(n);
+    const unlikes = new Float64Array(n).fill(NaN);
+    let counts_dirty = true;
     while (undrawn > 0) {
         // the one that draws the most cuts not yet drawn, the least unlike them where several do
         let pick_count = 0;
-        for (let r = 0; r < n; r++) {
-            counts[r] = 0;
-            if (taken[r]) continue;
-            if (chosen.length === 0 ? affordable && shapes[r].bytes > budget : spent + shapes[r].bytes > budget) continue;
-            const s = shapes[r];
-            const from = first_rank(s.log_size, shrink, false);
-            const to = first_rank(s.log_size, grow, true);
-            let count = 0;
-            for (let k = s.lod; k < lods.length; k++) {
-                count += fenwick_sum(undrawn_of_lod[k], to) - fenwick_sum(undrawn_of_lod[k], from);
+        if (counts_dirty) {
+            unlikes.fill(NaN);
+            for (let r = 0; r < n; r++) {
+                counts[r] = 0;
+                if (taken[r]) continue;
+                if (chosen.length === 0 ? affordable && shapes[r].bytes > budget : spent + shapes[r].bytes > budget) continue;
+                const s = shapes[r];
+                const from = from_ranks[r];
+                const to = to_ranks[r];
+                let count = 0;
+                for (let k = s.lod; k < lods.length; k++) {
+                    count += fenwick_sum(undrawn_of_lod[k], to) - fenwick_sum(undrawn_of_lod[k], from);
+                }
+                counts[r] = count;
+                if (count > pick_count) pick_count = count;
+            }
+            counts_dirty = false;
+        } else {
+            for (let r = 0; r < n; r++) {
+                if (counts[r] > pick_count) pick_count = counts[r];
             }
-            counts[r] = count;
-            if (count > pick_count) pick_count = count;
         }
         let pick = -1, pick_unlike = Infinity;
         if (pick_count > 0) {
             for (let r = 0; r < n; r++) {
                 if (counts[r] !== pick_count) continue;
-                // the cuts it draws, from its window, summed in the order of the cuts
-                const s = shapes[r];
-                const to = first_rank(s.log_size, grow, true);
-                let w = 0;
-                for (let i = first_rank(s.log_size, shrink, false); i < to; i++) {
-                    const c = by_size[i];
-                    if (!drawn[c] && shapes[c].lod >= s.lod) window[w++] = c;
+                let unlike = unlikes[r];
+                if (Number.isNaN(unlike)) {
+                    // the cuts it draws, from its window, summed in the order of the cuts
+                    const s = shapes[r];
+                    const to = to_ranks[r];
+                    let w = 0;
+                    for (let i = from_ranks[r]; i < to; i++) {
+                        const c = by_size[i];
+                        if (!drawn[c] && shapes[c].lod >= s.lod) window[w++] = c;
+                    }
+                    window.subarray(0, w).sort();
+                    unlike = 0;
+                    for (let i = 0; i < w; i++) unlike += cut_distance(shapes[window[i]], s);
+                    unlikes[r] = unlike;
                 }
-                window.subarray(0, w).sort();
-                let unlike = 0;
-                for (let i = 0; i < w; i++) unlike += cut_distance(shapes[window[i]], s);
                 if (unlike < pick_unlike) {
                     pick = r;
                     pick_unlike = unlike;
@@ -275,18 +364,29 @@ function choose(skeleton, attachments, leaves, lods, pressed_lods, leaf_texel, b
         }
         if (pick < 0) break;
         const s = shapes[pick];
-        chosen_sizes.push(lod_tiles[s.lod].sizes[s.card * 2], lod_tiles[s.lod].sizes[s.card * 2 + 1]);
+        const tw = s.tw, th = s.th;
         taken[pick] = 1;
+        counts[pick] = 0;
         if (chosen.length > 0) {
+            chosen_sizes.push(tw, th);
             const packed = tree_cluster_atlas_pack(chosen_sizes, chosen.length + 1);
             if (packed.atlas_w * packed.atlas_h * CLUSTER_TEXEL_BYTES > budget) {
                 // its tile fits the sum but not the packing
                 chosen_sizes.length -= 2;
+                for (let r = 0; r < n; r++) {
+                    if (shapes[r].tw === tw && shapes[r].th === th) {
+                        taken[r] = 1;
+                        counts[r] = 0;
+                    }
+                }
                 continue;
             }
+        } else {
+            chosen_sizes.push(tw, th);
         }
         chosen.push(pick);
         spent += s.bytes;
+        counts_dirty = true;
         for (let c = lod_first[s.lod]; c < n; c++) {
             if (!drawn[c] && draws(c, pick)) {
                 drawn[c] = 1;
@@ -303,7 +403,7 @@ function choose(skeleton, attachments, leaves, lods, pressed_lods, leaf_texel, b
         const count = lods[k].cards.length;
         const rep = new Int32Array(count);
         const frames = new Float64Array(count * 12);
-        const tiles = lod_tiles[k];
+        const tile_frames = lod_geom[k].frames;
         for (let i = 0; i < count; i++) {
             const own = lod_first[k] + i;
             const c = shapes[own];
@@ -331,11 +431,11 @@ function choose(skeleton, attachments, leaves, lods, pressed_lods, leaf_texel, b
             const tv = c.hang_v - (sin * s.hang_u + cos * s.hang_v);
             const f = i * 12;
             for (let d = 0; d < 3; d++) {
-                const e1 = tiles.frames[f + 3 + d], e2 = tiles.frames[f + 6 + d];
-                frames[f + d] = tiles.frames[f + d] + e1 * tu + e2 * tv;
+                const e1 = tile_frames[f + 3 + d], e2 = tile_frames[f + 6 + d];
+                frames[f + d] = tile_frames[f + d] + e1 * tu + e2 * tv;
                 frames[f + 3 + d] = e1 * cos + e2 * sin;
                 frames[f + 6 + d] = -e1 * sin + e2 * cos;
-                frames[f + 9 + d] = tiles.frames[f + 9 + d];
+                frames[f + 9 + d] = tile_frames[f + 9 + d];
             }
         }
         placements.push({ rep, frames });