@woosh/meep-engine 3.61.1 → 3.61.2

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.61.1",
+  "version": "3.61.2",
   "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/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 });

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

@@ -1 +1 @@
-{"version":3,"file":"tree_mesh_build_bark.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_mesh_build_bark.js"],"names":[],"mappings":"AA+iBA;;;;;GAKG;AACH,2DAJW,QAAQ,SACR,MAAM,GACJ,WAAW,CAevB;AAED;;;;;;;;;;GAUG;AACH,+CANW,OAAO,6BAA6B,EAAE,YAAY,WAClD,iBAAiB,eACjB,aAAa,QACb,OAAO,8CAA8C,EAAE,QAAQ,yBAC7D,QAAQ,CAyxBpB;AAED;;;;;;;;;;;;;;GAcG;AACH,yDAVW,OAAO,6BAA6B,EAAE,YAAY,WAClD,iBAAiB,eACjB,aAAa,GACX,IAAI,MAAM,EAAE,MAAM;IAC9B,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IACvC,CAAK,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAC5D,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IACnD,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAC/C,CAAC,CAAC,CAQL;yBAv3CwB,8CAA8C;kCAOrC,gCAAgC;8BADpC,4BAA4B"}
+{"version":3,"file":"tree_mesh_build_bark.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_mesh_build_bark.js"],"names":[],"mappings":"AAynBA;;;;;GAKG;AACH,2DAJW,QAAQ,SACR,MAAM,GACJ,WAAW,CAevB;AAED;;;;;;;;;;GAUG;AACH,+CANW,OAAO,6BAA6B,EAAE,YAAY,WAClD,iBAAiB,eACjB,aAAa,QACb,OAAO,8CAA8C,EAAE,QAAQ,yBAC7D,QAAQ,CAgyBpB;AAED;;;;;;;;;;;;;;GAcG;AACH,yDAVW,OAAO,6BAA6B,EAAE,YAAY,WAClD,iBAAiB,eACjB,aAAa,GACX,IAAI,MAAM,EAAE,MAAM;IAC9B,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IACvC,CAAK,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAC5D,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IACnD,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAC/C,CAAC,CAAC,CAQL;yBAx8CwB,8CAA8C;kCAOrC,gCAAgC;8BADpC,4BAA4B"}