@woosh/meep-engine 3.57.0 → 3.58.0

package/src/generation/foliage/config/TreeLODConfig.js

@@ -3,7 +3,14 @@ import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
 import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
 
 /**
- * Level-of-Detail (LOD) decimation and area-compensation configuration.
+ * Geometric error (m) of the finest LOD by default, and where `tree_lod_plan` starts looking for each tree's own:
+ * `generate_tree` draws each LOD at the finest error its `TREE_RENDER_COST_CEILING` allows. Chosen.
+ * @type {number}
+ */
+export const TREE_LOD_ERROR_FINEST = 0.01;
+
+/**
+ * A level of detail: the tree drawn to a geometric error.
  */
 export class TreeLODConfig {
     /**
@@ -13,48 +20,11 @@ export class TreeLODConfig {
     level = 0;
 
     /**
-     * Multiplier in (0, 1] applied to radial ring segment counts (clamped >= 3).
-     * @type {number}
-     */
-    radial_scale = 1.0;
-
-    /**
-     * Multiplier in (0, 1] applied to longitudinal Hermite spine subdivisions (clamped >= 1).
+     * Geometric error (m) the LOD is drawn to: wood thinner than this is not drawn as a tube, and the bark's rings and
+     * their sides are as few as keep the surface within it (`tree_mesh_build_bark`).
      * @type {number}
      */
-    longitudinal_scale = 1.0;
-
-    /**
-     * Maximum branch recursion level retained in this LOD.
-     * @type {number}
-     */
-    max_branch_level = 3;
-
-    /**
-     * Minimum branch base radius (meters) retained in this LOD.
-     * @type {number}
-     */
-    min_branch_radius = 0.0;
-
-    /**
-     * Fraction in [0, 1] of foliage attachments retained via golden-ratio low-discrepancy rank.
-     * @type {number}
-     */
-    foliage_keep_ratio = 1.0;
-
-    /**
-     * Area-compensation exponent eta in [0, 0.5]: remaining cards scale by `keep_ratio^(-eta)`
-     * so optical canopy density stays invariant across LOD transitions.
-     * @type {number}
-     */
-    foliage_area_compensation_exponent = 0.42;
-
-    /**
-     * If true, complex cards (`TriStarCluster`, `RibbedFrond`, `CutoutHull`) collapse
-     * to simpler low-triangle `FoldedVCard` or single quad representations.
-     * @type {boolean}
-     */
-    simplify_cards = false;
+    error = TREE_LOD_ERROR_FINEST;
 
     /**
      * @param {Partial<TreeLODConfig>} [options]
@@ -67,60 +37,19 @@ export class TreeLODConfig {
     }
 
     /**
-     * Creates a default sequence of progressive LOD configurations.
+     * A chain of LODs, each drawn to twice the error of the one before, from `error` at level 0: each switches at twice
+     * the distance of the one before, at the same error on screen.
      * @param {number} [lod_count=3]
+     * @param {number} [error] m, of level 0
      * @returns {TreeLODConfig[]}
      */
-    static createDefaultChain(lod_count = 3) {
+    static createDefaultChain(lod_count = 3, error = TREE_LOD_ERROR_FINEST) {
         const count = Math.max(1, lod_count | 0);
-        const presets = [
-            {
-                level: 0,
-                radial_scale: 1.0,
-                longitudinal_scale: 1.0,
-                max_branch_level: 3,
-                min_branch_radius: 0.0,
-                foliage_keep_ratio: 1.0,
-                foliage_area_compensation_exponent: 0.42,
-                simplify_cards: false
-            },
-            {
-                level: 1,
-                radial_scale: 0.65,
-                longitudinal_scale: 0.7,
-                max_branch_level: 2,
-                min_branch_radius: 0.015,
-                foliage_keep_ratio: 0.55,
-                foliage_area_compensation_exponent: 0.42,
-                simplify_cards: false
-            },
-            {
-                level: 2,
-                radial_scale: 0.45,
-                longitudinal_scale: 0.5,
-                max_branch_level: 1,
-                min_branch_radius: 0.035,
-                foliage_keep_ratio: 0.28,
-                foliage_area_compensation_exponent: 0.44,
-                simplify_cards: true
-            },
-            {
-                level: 3,
-                radial_scale: 0.35,
-                longitudinal_scale: 0.35,
-                max_branch_level: 1,
-                min_branch_radius: 0.06,
-                foliage_keep_ratio: 0.15,
-                foliage_area_compensation_exponent: 0.46,
-                simplify_cards: true
-            }
-        ];
-
         const result = [];
         for (let i = 0; i < count; i++) {
-            const template = presets[Math.min(i, presets.length - 1)];
-            const cfg = TreeLODConfig.from(template);
+            const cfg = new TreeLODConfig();
             cfg.level = i;
+            cfg.error = error * Math.pow(2, i);
             result.push(cfg);
         }
         return result;
@@ -135,15 +64,10 @@ export class TreeLODConfig {
             return this;
         }
         if (overrides.level !== undefined) this.level = overrides.level | 0;
-        if (overrides.radial_scale !== undefined) this.radial_scale = overrides.radial_scale;
-        if (overrides.longitudinal_scale !== undefined) this.longitudinal_scale = overrides.longitudinal_scale;
-        if (overrides.max_branch_level !== undefined) this.max_branch_level = overrides.max_branch_level | 0;
-        if (overrides.min_branch_radius !== undefined) this.min_branch_radius = overrides.min_branch_radius;
-        if (overrides.foliage_keep_ratio !== undefined) this.foliage_keep_ratio = overrides.foliage_keep_ratio;
-        if (overrides.foliage_area_compensation_exponent !== undefined) {
-            this.foliage_area_compensation_exponent = overrides.foliage_area_compensation_exponent;
+        if (overrides.error !== undefined) {
+            assert.greaterThan(overrides.error, 0, 'error');
+            this.error = overrides.error;
         }
-        if (overrides.simplify_cards !== undefined) this.simplify_cards = Boolean(overrides.simplify_cards);
         return this;
     }
 
@@ -154,13 +78,7 @@ export class TreeLODConfig {
     copy(other) {
         assert.defined(other, 'other');
         this.level = other.level;
-        this.radial_scale = other.radial_scale;
-        this.longitudinal_scale = other.longitudinal_scale;
-        this.max_branch_level = other.max_branch_level;
-        this.min_branch_radius = other.min_branch_radius;
-        this.foliage_keep_ratio = other.foliage_keep_ratio;
-        this.foliage_area_compensation_exponent = other.foliage_area_compensation_exponent;
-        this.simplify_cards = other.simplify_cards;
+        this.error = other.error;
         return this;
     }
 
@@ -181,25 +99,14 @@ export class TreeLODConfig {
         if (this === other) return true;
         if (!other || !other.isTreeLODConfig) return false;
         return this.level === other.level
-            && this.radial_scale === other.radial_scale
-            && this.longitudinal_scale === other.longitudinal_scale
-            && this.max_branch_level === other.max_branch_level
-            && this.min_branch_radius === other.min_branch_radius
-            && this.foliage_keep_ratio === other.foliage_keep_ratio
-            && this.foliage_area_compensation_exponent === other.foliage_area_compensation_exponent
-            && this.simplify_cards === other.simplify_cards;
+            && this.error === other.error;
     }
 
     /**
      * @returns {number}
      */
     hash() {
-        let h = hash_mix2(this.level, this.max_branch_level);
-        h = hash_mix2(h, computeHashFloat(this.radial_scale));
-        h = hash_mix2(h, computeHashFloat(this.longitudinal_scale));
-        h = hash_mix2(h, computeHashFloat(this.min_branch_radius));
-        h = hash_mix2(h, computeHashFloat(this.foliage_keep_ratio));
-        h = hash_mix2(h, this.simplify_cards ? 1 : 0);
+        let h = hash_mix2(this.level, computeHashFloat(this.error));
         return h;
     }
 }

package/src/generation/foliage/config/TreeSpeciesConfig.d.ts

@@ -66,7 +66,8 @@ export class TreeSpeciesConfig {
      */
     shoot_rules: ShootSystemRule[];
     /**
-     * How the twig systems of `shoot_rules` grow together: seasons, and vigour in the light they make for each other.
+     * How the shoot systems of `shoot_rules` grow together: the tree's age, its leader, and their vigour in the light they
+     * make for each other.
      * @type {ShootGrowthConfig}
      */
     shoot_growth: ShootGrowthConfig;

package/src/generation/foliage/config/TreeSpeciesConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TreeSpeciesConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/TreeSpeciesConfig.js"],"names":[],"mappings":"AAiBA;;GAEG;AACH;IAsGI;;;OAGG;IACH,mCAFa,eAAe,EAAE,CAwB7B;IAED;;;OAGG;IACH,gCAFa,qBAAqB,EAAE,CAmGnC;IAED;;;OAGG;IACH,sBAHW,QAAQ,iBAAiB,CAAC,GACxB,iBAAiB,CAS7B;IAnPD;;;OAGG;IACH,MAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,QAFU,UAAU,GAAC,MAAM,CAEH;IAExB;;;OAGG;IACH,MAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,OAFU,WAAW,CAEK;IAE1B;;;;OAIG;IACH,UAFU,qBAAqB,EAAE,CAEnB;IAEd;;;;OAIG;IACH,cAFU,eAAe,EAAE,CAET;IAElB;;;OAGG;IACH,SAFU,aAAa,CAEO;IAE9B;;;OAGG;IACH,eAFU,gBAAgB,EAAE,CAET;IAEnB;;;;OAIG;IACH,aAFU,eAAe,EAAE,CAEV;IAEjB;;;OAGG;IACH,cAFU,iBAAiB,CAEY;IAEvC;;;OAGG;IACH,eAFU,kBAAkB,CAEa;IAEzC;;;OAGG;IACH,kBAFU,qBAAqB,CAEgB;IAE/C;;;OAGG;IACH,MAFU,cAAc,CAEI;IAE5B;;;OAGG;IACH,MAFU,aAAa,EAAE,CAEf;IAEV;;;;OAIG;IACH,aAFU,MAAM,UAAU,MAAM,CAAC,CAAC,cAAU,IAAI,CAE7B;IAyJnB;;;;OAIG;IACH,iCAFa,IAAI,CA6ChB;IAED;;;OAGG;IACH,YAHW,iBAAiB,GACf,IAAI,CAsBhB;IAED;;OAEG;IACH,SAFa,iBAAiB,CAM7B;IAED;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAyDnB;IAED;;OAEG;IACH,QAFa,MAAM,CAmClB;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;CAN9C;2BAnb0B,iBAAiB;4BAPhB,kBAAkB;sCAFR,4BAA4B;gCAClC,sBAAsB;8BAExB,oBAAoB;iCAEjB,uBAAuB;gCAExB,sBAAsB;kCADpB,wBAAwB;mCAPvB,yBAAyB;sCAKtB,4BAA4B;+BAMnC,qBAAqB;8BAFtB,oBAAoB"}
+{"version":3,"file":"TreeSpeciesConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/TreeSpeciesConfig.js"],"names":[],"mappings":"AAiBA;;GAEG;AACH;IAuGI;;;OAGG;IACH,mCAFa,eAAe,EAAE,CAwB7B;IAED;;;OAGG;IACH,gCAFa,qBAAqB,EAAE,CA6FnC;IAED;;;OAGG;IACH,sBAHW,QAAQ,iBAAiB,CAAC,GACxB,iBAAiB,CAS7B;IA9OD;;;OAGG;IACH,MAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,QAFU,UAAU,GAAC,MAAM,CAEH;IAExB;;;OAGG;IACH,MAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,OAFU,WAAW,CAEK;IAE1B;;;;OAIG;IACH,UAFU,qBAAqB,EAAE,CAEnB;IAEd;;;;OAIG;IACH,cAFU,eAAe,EAAE,CAET;IAElB;;;OAGG;IACH,SAFU,aAAa,CAEO;IAE9B;;;OAGG;IACH,eAFU,gBAAgB,EAAE,CAET;IAEnB;;;;OAIG;IACH,aAFU,eAAe,EAAE,CAEV;IAEjB;;;;OAIG;IACH,cAFU,iBAAiB,CAEY;IAEvC;;;OAGG;IACH,eAFU,kBAAkB,CAEa;IAEzC;;;OAGG;IACH,kBAFU,qBAAqB,CAEgB;IAE/C;;;OAGG;IACH,MAFU,cAAc,CAEI;IAE5B;;;OAGG;IACH,MAFU,aAAa,EAAE,CAEf;IAEV;;;;OAIG;IACH,aAFU,MAAM,UAAU,MAAM,CAAC,CAAC,cAAU,IAAI,CAE7B;IAmJnB;;;;OAIG;IACH,iCAFa,IAAI,CA6ChB;IAED;;;OAGG;IACH,YAHW,iBAAiB,GACf,IAAI,CAsBhB;IAED;;OAEG;IACH,SAFa,iBAAiB,CAM7B;IAED;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAyDnB;IAED;;OAEG;IACH,QAFa,MAAM,CAmClB;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;CAN9C;2BA9a0B,iBAAiB;4BAPhB,kBAAkB;sCAFR,4BAA4B;gCAClC,sBAAsB;8BAExB,oBAAoB;iCAEjB,uBAAuB;gCAExB,sBAAsB;kCADpB,wBAAwB;mCAPvB,yBAAyB;sCAKtB,4BAA4B;+BAMnC,qBAAqB;8BAFtB,oBAAoB"}

package/src/generation/foliage/config/TreeSpeciesConfig.js

@@ -77,7 +77,8 @@ export class TreeSpeciesConfig {
     shoot_rules = [];
 
     /**
-     * How the twig systems of `shoot_rules` grow together: seasons, and vigour in the light they make for each other.
+     * How the shoot systems of `shoot_rules` grow together: the tree's age, its leader, and their vigour in the light they
+     * make for each other.
      * @type {ShootGrowthConfig}
      */
     shoot_growth = new ShootGrowthConfig();
@@ -156,8 +157,6 @@ export class TreeSpeciesConfig {
         return [
             BranchGeneratorConfig.from({
                 segments: 12,
-                radial_segments_max: 14,
-                radial_segments_min: 8,
                 length: 9.0,
                 length_variance: 0.06,
                 radius_ratio: 0.058,
@@ -190,8 +189,6 @@ export class TreeSpeciesConfig {
             }),
             BranchGeneratorConfig.from({
                 segments: 8,
-                radial_segments_max: 9,
-                radial_segments_min: 5,
                 length: 5.2,
                 length_variance: 0.14,
                 radius_ratio: 0.046,
@@ -224,8 +221,6 @@ export class TreeSpeciesConfig {
             }),
             BranchGeneratorConfig.from({
                 segments: 6,
-                radial_segments_max: 6,
-                radial_segments_min: 4,
                 length: 2.1,
                 length_variance: 0.18,
                 radius_ratio: 0.036,

package/src/generation/foliage/material/foliage_atlas_cutout.d.ts

@@ -8,18 +8,20 @@
  * @param {Int32Array} row_min first covered texel of each row, `-1` for an empty row
  * @param {Int32Array} row_max last covered texel of each row
  * @param {number} coverage_sum sum of alpha over the tile
- * @param {number} res tile resolution in texels
+ * @param {number} width tile width in texels
+ * @param {number} [height] tile height in texels
  */
-export function foliage_atlas_cutout_fit_tile(out: FoliageAtlasCutout, variant: number, row_min: Int32Array, row_max: Int32Array, coverage_sum: number, res: number): void;
+export function foliage_atlas_cutout_fit_tile(out: FoliageAtlasCutout, variant: number, row_min: Int32Array, row_max: Int32Array, coverage_sum: number, width: number, height?: number): void;
 /**
  * Fits tile `variant`'s hull from its alpha as the atlas stores it: an alpha that rounds to 0 is not drawn.
  *
  * @param {FoliageAtlasCutout} out already sized
  * @param {number} variant
  * @param {Float32Array} alpha the tile's coverage, row-major from `v` 0
- * @param {number} res
+ * @param {number} width
+ * @param {number} [height]
  */
-export function foliage_atlas_cutout_fit_alpha(out: FoliageAtlasCutout, variant: number, alpha: Float32Array, res: number): void;
+export function foliage_atlas_cutout_fit_alpha(out: FoliageAtlasCutout, variant: number, alpha: Float32Array, width: number, height?: number): void;
 /**
  * Synthesizes only the alpha of the foliage atlas `make_foliage_material` would build for `species`, and fits its
  * cutout. For callers that need the atlas's shape without its textures; `make_foliage_material` produces the same

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;;;;;;;;;;;GAWG;AACH,mDAPW,kBAAkB,WAClB,MAAM,WACN,UAAU,WACV,UAAU,gBACV,MAAM,OACN,MAAM,QA8GhB;AAED;;;;;;;GAOG;AACH,oDALW,kBAAkB,WAClB,MAAM,SACN,YAAY,OACZ,MAAM,QAkBhB;AAED;;;;;;;;GAQG;AACH,8CAJW,OAAO,gCAAgC,EAAE,iBAAiB,QAC1D,kBAAkB,GAChB,kBAAkB,CAU9B;mCAxK4D,yBAAyB"}
+{"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"}

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

@@ -16,25 +16,29 @@ import { foliage_tile_layout, foliage_tile_raster } from "./foliage_tile.js";
  * @param {Int32Array} row_min first covered texel of each row, `-1` for an empty row
  * @param {Int32Array} row_max last covered texel of each row
  * @param {number} coverage_sum sum of alpha over the tile
- * @param {number} res tile resolution in texels
+ * @param {number} width tile width in texels
+ * @param {number} [height] tile height in texels
  */
-export function foliage_atlas_cutout_fit_tile(out, variant, row_min, row_max, coverage_sum, res) {
-	const inv_res = 1.0 / res;
+export function foliage_atlas_cutout_fit_tile(out, variant, row_min, row_max, coverage_sum, width, height = width) {
+	const inv_w = 1.0 / width;
+	const inv_h = 1.0 / height;
 
 	// The hull keeps half a texel inside the tile, where bilinear filtering starts to read the atlas neighbour.
 	// Only a texel on the tile's own border loses its outer half to that.
-	const lo = 0.5 * inv_res;
-	const hi = 1.0 - lo;
-	const bounds = [lo, lo, hi, hi];
+	const lo_x = 0.5 * inv_w;
+	const hi_x = 1.0 - lo_x;
+	const lo_y = 0.5 * inv_h;
+	const hi_y = 1.0 - lo_y;
+	const bounds = [lo_x, lo_y, hi_x, hi_y];
 
-	const points = new Float64Array(res * 8);
+	const points = new Float64Array(height * 8);
 	let n = 0;
-	for (let y = 0; y < res; y++) {
+	for (let y = 0; y < height; y++) {
 		if (row_min[y] < 0) continue;
-		const x0 = clamp(row_min[y] * inv_res, lo, hi);
-		const x1 = clamp((row_max[y] + 1) * inv_res, lo, hi);
-		const y0 = clamp(y * inv_res, lo, hi);
-		const y1 = clamp((y + 1) * inv_res, lo, hi);
+		const x0 = clamp(row_min[y] * inv_w, lo_x, hi_x);
+		const x1 = clamp((row_max[y] + 1) * inv_w, lo_x, hi_x);
+		const y0 = clamp(y * inv_h, lo_y, hi_y);
+		const y1 = clamp((y + 1) * inv_h, lo_y, hi_y);
 		points[n * 2] = x0;
 		points[n * 2 + 1] = y0;
 		points[n * 2 + 2] = x0;
@@ -67,10 +71,10 @@ export function foliage_atlas_cutout_fit_tile(out, variant, row_min, row_max, co
 			let clip_a = new Float64Array((K + 4) * 2);
 			let clip_b = new Float64Array((K + 4) * 2);
 			clip_a.set(free);
-			let kc = polygon2_clip_axis_halfplane(clip_a, k_free, clip_b, 0, lo, false);
-			kc = polygon2_clip_axis_halfplane(clip_b, kc, clip_a, 0, hi, true);
-			kc = polygon2_clip_axis_halfplane(clip_a, kc, clip_b, 1, lo, false);
-			kc = polygon2_clip_axis_halfplane(clip_b, kc, clip_a, 1, hi, true);
+			let kc = polygon2_clip_axis_halfplane(clip_a, k_free, clip_b, 0, lo_x, false);
+			kc = polygon2_clip_axis_halfplane(clip_b, kc, clip_a, 0, hi_x, true);
+			kc = polygon2_clip_axis_halfplane(clip_a, kc, clip_b, 1, lo_y, false);
+			kc = polygon2_clip_axis_halfplane(clip_b, kc, clip_a, 1, hi_y, true);
 			k = convex_hull_fixed_count_2d_relaxation(hull, 0, K, clip_a, kc, bounds);
 			if (k > K) {
 				// Still stuck. Pulling the unbounded fit's corners into the tile would cut the leaf, so take the
@@ -121,11 +125,11 @@ export function foliage_atlas_cutout_fit_tile(out, variant, row_min, row_max, co
 	const base = variant * K * 2;
 	for (let i = 0; i < K; i++) {
 		const src = ccw ? i : K - 1 - i;
-		out.hulls[base + i * 2] = clamp(hull[src * 2], lo, hi);
-		out.hulls[base + i * 2 + 1] = clamp(hull[src * 2 + 1], lo, hi);
+		out.hulls[base + i * 2] = clamp(hull[src * 2], lo_x, hi_x);
+		out.hulls[base + i * 2 + 1] = clamp(hull[src * 2 + 1], lo_y, hi_y);
 	}
 
-	out.coverage[variant] = coverage_sum * inv_res * inv_res;
+	out.coverage[variant] = coverage_sum * inv_w * inv_h;
 }
 
 /**
@@ -134,16 +138,17 @@ export function foliage_atlas_cutout_fit_tile(out, variant, row_min, row_max, co
  * @param {FoliageAtlasCutout} out already sized
  * @param {number} variant
  * @param {Float32Array} alpha the tile's coverage, row-major from `v` 0
- * @param {number} res
+ * @param {number} width
+ * @param {number} [height]
  */
-export function foliage_atlas_cutout_fit_alpha(out, variant, alpha, res) {
-	const row_min = new Int32Array(res);
-	const row_max = new Int32Array(res);
+export function foliage_atlas_cutout_fit_alpha(out, variant, alpha, width, height = width) {
+	const row_min = new Int32Array(height);
+	const row_max = new Int32Array(height);
 	let coverage_sum = 0.0;
-	for (let y = 0; y < res; y++) {
+	for (let y = 0; y < height; y++) {
 		row_min[y] = -1;
-		for (let x = 0; x < res; x++) {
-			const a = alpha[y * res + x];
+		for (let x = 0; x < width; x++) {
+			const a = alpha[y * width + x];
 			if (Math.round(a * 255) > 0) {
 				if (row_min[y] < 0) row_min[y] = x;
 				row_max[y] = x;
@@ -151,7 +156,7 @@ export function foliage_atlas_cutout_fit_alpha(out, variant, alpha, res) {
 			coverage_sum += a;
 		}
 	}
-	foliage_atlas_cutout_fit_tile(out, variant, row_min, row_max, coverage_sum, res);
+	foliage_atlas_cutout_fit_tile(out, variant, row_min, row_max, coverage_sum, width, height);
 }
 
 /**

package/src/generation/foliage/material/foliage_material_from_samplers.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A foliage card material over an atlas: cutout (`TransparencyMode.AlphaTested`), drawn from both sides, its albedo
+ * straight-alpha sRGB, its 2-channel tangent-space normal and its ORM linear.
+ *
+ * @param {import("../../../engine/graphics/texture/sampler/Sampler2D.js").Sampler2D} albedo_sampler uint8 RGBA, straight alpha
+ * @param {import("../../../engine/graphics/texture/sampler/Sampler2D.js").Sampler2D} normal_sampler uint8, 2 channels
+ * @param {import("../../../engine/graphics/texture/sampler/Sampler2D.js").Sampler2D} orm_sampler uint8 RGBA
+ * @param {string} name
+ * @returns {StandardShadeMaterial}
+ */
+export function foliage_material_from_samplers(albedo_sampler: import("../../../engine/graphics/texture/sampler/Sampler2D.js").Sampler2D, normal_sampler: import("../../../engine/graphics/texture/sampler/Sampler2D.js").Sampler2D, orm_sampler: import("../../../engine/graphics/texture/sampler/Sampler2D.js").Sampler2D, name: string): StandardShadeMaterial;
+import { StandardShadeMaterial } from "../../../shade/renderer/material/StandardShadeMaterial.js";
+//# sourceMappingURL=foliage_material_from_samplers.d.ts.map

package/src/generation/foliage/material/foliage_material_from_samplers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foliage_material_from_samplers.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/foliage_material_from_samplers.js"],"names":[],"mappings":"AAUA;;;;;;;;;GASG;AACH,+DANW,OAAO,uDAAuD,EAAE,SAAS,kBACzE,OAAO,uDAAuD,EAAE,SAAS,eACzE,OAAO,uDAAuD,EAAE,SAAS,QACzE,MAAM,GACJ,qBAAqB,CAkDjC;sCAnEqC,2DAA2D"}

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

@@ -0,0 +1,69 @@
+import { ShadeDrawSide } from "../../../shade/renderer/material/ShadeDrawSide.js";
+import { StandardShadeMaterial } from "../../../shade/renderer/material/StandardShadeMaterial.js";
+import { TransparencyMode } from "../../../shade/renderer/material/TransparencyMode.js";
+import { ColorSpace } from "../../../shade/renderer/texture/ColorSpace.js";
+import { ShadeTexture } from "../../../shade/renderer/texture/ShadeTexture.js";
+import { TextureFilterType } from "../../../shade/renderer/texture/TextureFilterType.js";
+import { TextureWrapType } from "../../../shade/renderer/texture/TextureWrapType.js";
+import { AlphaMode } from "../../../shade/renderer/texture/source/AlphaMode.js";
+import { ShadeImage } from "../../../shade/renderer/texture/source/ShadeImage.js";
+
+/**
+ * A foliage card material over an atlas: cutout (`TransparencyMode.AlphaTested`), drawn from both sides, its albedo
+ * straight-alpha sRGB, its 2-channel tangent-space normal and its ORM linear.
+ *
+ * @param {import("../../../engine/graphics/texture/sampler/Sampler2D.js").Sampler2D} albedo_sampler uint8 RGBA, straight alpha
+ * @param {import("../../../engine/graphics/texture/sampler/Sampler2D.js").Sampler2D} normal_sampler uint8, 2 channels
+ * @param {import("../../../engine/graphics/texture/sampler/Sampler2D.js").Sampler2D} orm_sampler uint8 RGBA
+ * @param {string} name
+ * @returns {StandardShadeMaterial}
+ */
+export function foliage_material_from_samplers(albedo_sampler, normal_sampler, orm_sampler, name) {
+    const albedo_image = ShadeImage.fromSampler2D(albedo_sampler);
+    albedo_image.color_space = ColorSpace.SRGB;
+    // CRITICAL: Keep AlphaMode.Straight so texture_write_to_gpu premultiplies once on upload
+    // and G-buffer albedo_unpremultiply recovers clean dilated leaf color at cutout boundaries.
+    albedo_image.alpha_mode = AlphaMode.Straight;
+    const texture_albedo = ShadeTexture.from(albedo_image);
+    texture_albedo.label = `${name}_albedo`;
+    texture_albedo.color_space = ColorSpace.SRGB;
+    texture_albedo.mipmapGenerationFilter = TextureFilterType.MagicKernelSharp;
+    texture_albedo.wrapS = TextureWrapType.ClampToEdge;
+    texture_albedo.wrapT = TextureWrapType.ClampToEdge;
+
+    const normal_image = ShadeImage.fromSampler2D(normal_sampler);
+    normal_image.color_space = ColorSpace.None;
+    normal_image.alpha_mode = AlphaMode.Opaque;
+    const texture_normal = ShadeTexture.from(normal_image);
+    texture_normal.label = `${name}_normal`;
+    texture_normal.color_space = ColorSpace.LinearSRGB;
+    texture_normal.mipmapGenerationFilter = TextureFilterType.LinearNormal;
+    texture_normal.wrapS = TextureWrapType.ClampToEdge;
+    texture_normal.wrapT = TextureWrapType.ClampToEdge;
+
+    const orm_image = ShadeImage.fromSampler2D(orm_sampler);
+    orm_image.color_space = ColorSpace.None;
+    orm_image.alpha_mode = AlphaMode.Opaque;
+    const texture_orm = ShadeTexture.from(orm_image);
+    texture_orm.label = `${name}_orm`;
+    texture_orm.color_space = ColorSpace.LinearSRGB;
+    texture_orm.wrapS = TextureWrapType.ClampToEdge;
+    texture_orm.wrapT = TextureWrapType.ClampToEdge;
+
+    const material = new StandardShadeMaterial();
+    material.name = `${name}_material`;
+    material.texture_albedo = texture_albedo;
+    material.texture_normal = texture_normal;
+    material.texture_orm = texture_orm;
+    material.roughness_factor = 1.0;
+    material.metallic_factor = 0.0;
+    // CRITICAL: Keep transmission_factor = 0 on AlphaTested cards so transparent card corners
+    // do not act as refractive glass in the path tracer!
+    material.transmission_factor = 0.0;
+    material.ambient_factors.a = 1.0;
+    material.ambient_factors.b = 0.0;
+    material.transparency_mode = TransparencyMode.AlphaTested;
+    material.transparency = TransparencyMode.AlphaTested;
+    material.draw_side = ShadeDrawSide.Double;
+    return material;
+}

package/src/generation/foliage/material/foliage_tile.d.ts

@@ -9,6 +9,11 @@
  * @property {number} leaves_per_card leaves one card draws: one leaf, or a needle shoot's needles
  * @property {number} needles needles a needle-shoot tile draws, its plane's share of the card's; 0 for a leaf
  * @property {number} shoot_length length of shoot a needle-shoot tile draws (m), 0 for a leaf
+ * @property {number} outline the mature organ's finest feature of shape (m), its margin's teeth aside (`LeafGeometry`)
+ * @property {number} texel the tile's texel (m): `card_size / resolution`
+ * @property {number} legible_texel the coarsest texel (m) a cluster card may draw the organ at, as coarse as still tells
+ *           the leaf from another seen whole: its outline's finest feature `FEATURE_TEXELS` across; a needle, a line,
+ *           as a stem is, `STEM_TEXELS` across its width
  */
 /**
  * Maturity variants of a species' foliage atlas.
@@ -76,6 +81,20 @@ export type FoliageTileLayout = {
      * length of shoot a needle-shoot tile draws (m), 0 for a leaf
      */
     shoot_length: number;
+    /**
+     * the mature organ's finest feature of shape (m), its margin's teeth aside (`LeafGeometry`)
+     */
+    outline: number;
+    /**
+     * the tile's texel (m): `card_size / resolution`
+     */
+    texel: number;
+    /**
+     * the coarsest texel (m) a cluster card may draw the organ at, as coarse as still tells
+     * the leaf from another seen whole: its outline's finest feature `FEATURE_TEXELS` across; a needle, a line,
+     * as a stem is, `STEM_TEXELS` across its width
+     */
+    legible_texel: number;
 };
 export type FoliageTileRaster = {
     /**

package/src/generation/foliage/material/foliage_tile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"foliage_tile.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/foliage_tile.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;;GAWG;AAEH;;;;GAIG;AACH,sDAHW,OAAO,oCAAoC,EAAE,qBAAqB,GAChE,MAAM,CAIlB;AAmBD;;;;;;;;;;;;;GAaG;AACH,6CAHW,OAAO,gCAAgC,EAAE,iBAAiB,GACxD,iBAAiB,CAkC7B;AAuBD;;;;;;;;;GASG;AACH,6CANW,OAAO,gCAAgC,EAAE,iBAAiB,UAC1D,iBAAiB,WACjB,MAAM,kBACN,OAAO,GACL,iBAAiB,CAwH7B;;;;;mBA1Oa,MAAM;;;;gBACN,MAAM;;;;WACN,MAAM;;;;eACN,MAAM;;;;cACN,MAAM;cACN,MAAM;;;;qBACN,MAAM;;;;aACN,MAAM;;;;kBACN,MAAM;;;;;;cA+EN,MAAM;;;;WACN,YAAY;;;;UACZ,YAAY;;;;eACZ,YAAY;;;;SACZ,YAAY;;;;YACZ,YAAY;;;;UACZ,YAAY"}
+{"version":3,"file":"foliage_tile.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/foliage_tile.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH,sDAHW,OAAO,oCAAoC,EAAE,qBAAqB,GAChE,MAAM,CAIlB;AAmBD;;;;;;;;;;;;;GAaG;AACH,6CAHW,OAAO,gCAAgC,EAAE,iBAAiB,GACxD,iBAAiB,CAqC7B;AAuBD;;;;;;;;;GASG;AACH,6CANW,OAAO,gCAAgC,EAAE,iBAAiB,UAC1D,iBAAiB,WACjB,MAAM,kBACN,OAAO,GACL,iBAAiB,CAwH7B;;;;;mBAlPa,MAAM;;;;gBACN,MAAM;;;;WACN,MAAM;;;;eACN,MAAM;;;;cACN,MAAM;cACN,MAAM;;;;qBACN,MAAM;;;;aACN,MAAM;;;;kBACN,MAAM;;;;aACN,MAAM;;;;WACN,MAAM;;;;;;mBACN,MAAM;;;;;;cAoFN,MAAM;;;;WACN,YAAY;;;;UACZ,YAAY;;;;eACZ,YAAY;;;;SACZ,YAAY;;;;YACZ,YAAY;;;;UACZ,YAAY"}

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

@@ -58,6 +58,11 @@ const COVERAGE_ROWS = 4;
  * @property {number} leaves_per_card leaves one card draws: one leaf, or a needle shoot's needles
  * @property {number} needles needles a needle-shoot tile draws, its plane's share of the card's; 0 for a leaf
  * @property {number} shoot_length length of shoot a needle-shoot tile draws (m), 0 for a leaf
+ * @property {number} outline the mature organ's finest feature of shape (m), its margin's teeth aside (`LeafGeometry`)
+ * @property {number} texel the tile's texel (m): `card_size / resolution`
+ * @property {number} legible_texel the coarsest texel (m) a cluster card may draw the organ at, as coarse as still tells
+ *           the leaf from another seen whole: its outline's finest feature `FEATURE_TEXELS` across; a needle, a line,
+ *           as a stem is, `STEM_TEXELS` across its width
  */
 
 /**
@@ -130,7 +135,10 @@ export function foliage_tile_layout(species) {
         anchor_v: TILE_MARGIN + (g.attach_y - min_y) * scale,
         leaves_per_card: needle_shoot ? card_needles : 1,
         needles,
-        shoot_length
+        shoot_length,
+        outline: g.outline,
+        texel: card_size / resolution,
+        legible_texel: g.outline / (needle_shoot ? STEM_TEXELS : FEATURE_TEXELS)
     };
 }
 

package/src/generation/foliage/material/leaf_geometry.d.ts

@@ -14,6 +14,8 @@
  *           start of a needle shoot's stretch
  * @property {number} tip_y where the organ ends along `y` (m), for the shading that runs base to tip
  * @property {number} finest smallest feature of the outline (m): a tooth, a sinus, the blade's width
+ * @property {number} outline smallest feature of the outline's shape (m), its margin's teeth aside: a sinus, a lobe,
+ *           the blade's width; what tells the leaf from another seen whole
  */
 /**
  * Size, width and lobe depth of a leaf at ontogenetic maturity `maturity` (0 juvenile, 1 mature) against the mature
@@ -99,5 +101,10 @@ export type LeafGeometry = {
      * smallest feature of the outline (m): a tooth, a sinus, the blade's width
      */
     finest: number;
+    /**
+     * smallest feature of the outline's shape (m), its margin's teeth aside: a sinus, a lobe,
+     * the blade's width; what tells the leaf from another seen whole
+     */
+    outline: number;
 };
 //# sourceMappingURL=leaf_geometry.d.ts.map

package/src/generation/foliage/material/leaf_geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"leaf_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/leaf_geometry.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;GAOG;AACH,wCAJW,MAAM,aACN,MAAM,GACJ;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAQ1D;AA8TD;;;;;;;;;;;;;;GAcG;AACH,oCALW,OAAO,+BAA+B,EAAE,gBAAgB,YACxD,MAAM,aACN,MAAM,GACJ,YAAY,CAkFxB;AAED;;;;;;;;;;;;;;GAcG;AACH,4CATW,OAAO,+BAA+B,EAAE,gBAAgB,WACxD,MAAM,gBACN,MAAM,gBACN,MAAM,UACN,MAAM,YACN,MAAM,aACN,MAAM,GACJ,YAAY,CAkCxB;;;;;;YA5ea,MAAM,EAAE;;;;;cAER,MAAM,EAAE;;;;;WAER,MAAM,EAAE;;;;;mBAER,MAAM;;;;;WAEN,MAAM,EAAE;;;;;cAER,MAAM;;;;WAEN,MAAM;;;;YACN,MAAM"}
+{"version":3,"file":"leaf_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/leaf_geometry.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;;GAOG;AACH,wCAJW,MAAM,aACN,MAAM,GACJ;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAQ1D;AAqUD;;;;;;;;;;;;;;GAcG;AACH,oCALW,OAAO,+BAA+B,EAAE,gBAAgB,YACxD,MAAM,aACN,MAAM,GACJ,YAAY,CAoFxB;AAED;;;;;;;;;;;;;;GAcG;AACH,4CATW,OAAO,+BAA+B,EAAE,gBAAgB,WACxD,MAAM,gBACN,MAAM,gBACN,MAAM,UACN,MAAM,YACN,MAAM,aACN,MAAM,GACJ,YAAY,CAmCxB;;;;;;YAxfa,MAAM,EAAE;;;;;cAER,MAAM,EAAE;;;;;WAER,MAAM,EAAE;;;;;mBAER,MAAM;;;;;WAEN,MAAM,EAAE;;;;;cAER,MAAM;;;;WAEN,MAAM;;;;YACN,MAAM;;;;;aACN,MAAM"}