@woosh/meep-engine 3.57.0 → 3.59.0

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/index.d.ts

@@ -3,6 +3,7 @@ export { PhyllotaxisMode } from "./config/PhyllotaxisMode.js";
 export { FoliageCardType } from "./config/FoliageCardType.js";
 export { FoliageBarkType } from "./config/FoliageBarkType.js";
 export { TreePreset } from "./config/TreePreset.js";
+export { TreeGrowth } from "./config/TreeGrowth.js";
 export { BranchGeneratorConfig } from "./config/BranchGeneratorConfig.js";
 export { BranchSpawnRule } from "./config/BranchSpawnRule.js";
 export { FoliageSpawnRule } from "./config/FoliageSpawnRule.js";
@@ -22,6 +23,7 @@ export { make_tree_species_preset } from "./presets/make_tree_species_preset.js"
 export { TreeSkeleton } from "./skeleton/TreeSkeleton.js";
 export { spine_frame_double_reflection } from "./skeleton/spine_frame_double_reflection.js";
 export { tree_skeleton_grow } from "./skeleton/tree_skeleton_grow.js";
+export { tree_skeleton_grow_framework } from "./skeleton/tree_skeleton_grow_framework.js";
 export { tree_skeleton_compute_pipe_radii } from "./skeleton/tree_skeleton_compute_pipe_radii.js";
 export { tree_skeleton_assign_skin_joints } from "./skeleton/tree_skeleton_assign_skin_joints.js";
 export { branch_collar_project } from "./mesh/branch_collar_project.js";
@@ -52,5 +54,6 @@ export { tree_mesh_build_bark, geometry_obtain_joints_attribute } from "./mesh/t
 export { FoliageAtlasCutout, CUTOUT_HULL_VERTEX_COUNT } from "./material/FoliageAtlasCutout.js";
 export { foliage_tile_layout, foliage_tile_raster } from "./material/foliage_tile.js";
 export { leaf_geometry, needle_shoot_geometry } from "./material/leaf_geometry.js";
+export { TreeSpeciesCache, TREE_SPECIES_CACHE } from "./asset/TreeSpeciesCache.js";
 export { place_tree, unplace_tree } from "./asset/place_tree.js";
 //# sourceMappingURL=index.d.ts.map

package/src/generation/foliage/index.js

@@ -3,6 +3,7 @@ export { PhyllotaxisMode } from "./config/PhyllotaxisMode.js";
 export { FoliageCardType } from "./config/FoliageCardType.js";
 export { FoliageBarkType } from "./config/FoliageBarkType.js";
 export { TreePreset } from "./config/TreePreset.js";
+export { TreeGrowth } from "./config/TreeGrowth.js";
 export { BranchGeneratorConfig } from "./config/BranchGeneratorConfig.js";
 export { BranchSpawnRule } from "./config/BranchSpawnRule.js";
 export { FoliageSpawnRule } from "./config/FoliageSpawnRule.js";
@@ -25,6 +26,7 @@ export { TreeSkeleton } from "./skeleton/TreeSkeleton.js";
 export { crown_envelope_evaluate, crown_envelope_sdf } from "./skeleton/crown_envelope_evaluate.js";
 export { spine_frame_double_reflection } from "./skeleton/spine_frame_double_reflection.js";
 export { tree_skeleton_grow } from "./skeleton/tree_skeleton_grow.js";
+export { tree_skeleton_grow_framework } from "./skeleton/tree_skeleton_grow_framework.js";
 export { tree_skeleton_compute_pipe_radii } from "./skeleton/tree_skeleton_compute_pipe_radii.js";
 export { tree_skeleton_assign_skin_joints } from "./skeleton/tree_skeleton_assign_skin_joints.js";
 
@@ -54,6 +56,7 @@ export { FoliageWindSystem } from "../../engine/graphics3/FoliageWindSystem.js";
 
 export { TreeLODAsset } from "./asset/TreeLODAsset.js";
 export { TreeAsset } from "./asset/TreeAsset.js";
+export { TreeSpeciesCache, TREE_SPECIES_CACHE } from "./asset/TreeSpeciesCache.js";
 export { generate_tree } from "./asset/generate_tree.js";
 export { place_tree, unplace_tree } from "./asset/place_tree.js";
 

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 draws the organ at while the tree's atlas holds
+ *           its cover, 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 draws the organ at while the tree's atlas holds
+     * its cover, 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 draws the organ at while the tree's atlas holds
+ *           its cover, 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"}

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

@@ -47,6 +47,8 @@ const PETIOLE_WIDTH = 0.02;
  *           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
  */
 
 /**
@@ -192,13 +194,14 @@ function serrate(xs, ys, period, depth, orders, sign, s_from) {
  * @param {number} L blade length (m)
  * @param {number} W blade width (m)
  * @param {number} depth_scale ontogeny of the lobes' and teeth's depth
- * @returns {{xs: number[], ys: number[], lobes: number[], finest: number}} `lobes`: `(vein origin y, length, half
- *          width)` of each lateral lobe on a side
+ * @returns {{xs: number[], ys: number[], lobes: number[], finest: number, outline: number}} `lobes`: `(vein origin
+ *          y, length, half width)` of each lateral lobe on a side; `outline` is `finest` but for the teeth
  */
 function blade_half(arch, L, W, depth_scale) {
     const envelope = blade_envelope(arch, L, W);
     const xs = [], ys = [];
     let finest = W;
+    let outline = W;
 
     // the base: cordate and lobate bases reach below the top of the petiole
     const lobe_drop = (arch.base_shape === LeafBaseShape.Cordate || arch.base_shape === LeafBaseShape.Lobate)
@@ -246,6 +249,7 @@ function blade_half(arch, L, W, depth_scale) {
             ys.push(y);
         }
         finest = Math.min(finest, lobe_drop);
+        outline = Math.min(outline, lobe_drop);
     } else {
         for (let k = 0; k <= SIDE_SAMPLES; k++) {
             const y = L * k / SIDE_SAMPLES;
@@ -280,7 +284,9 @@ function blade_half(arch, L, W, depth_scale) {
             const length = Math.hypot(x, y - y0);
             lobes.push(y0, length, Math.min(half_width, 0.5 * length));
         }
-        finest = Math.min(finest, 2 * (1 - LOBE_FILL) * spacing * Math.sin(arch.secondary_angle) + half_width);
+        const gap = 2 * (1 - LOBE_FILL) * spacing * Math.sin(arch.secondary_angle) + half_width;
+        finest = Math.min(finest, gap);
+        outline = Math.min(outline, gap);
     }
 
     if (arch.teeth_per_cm > 0 && arch.tooth_depth > 0) {
@@ -289,7 +295,7 @@ function blade_half(arch, L, W, depth_scale) {
         serrate(xs, ys, period, arch.tooth_depth * depth_scale, arch.tooth_orders, 1, 0.08 * L);
         finest = Math.min(finest, period / (arch.tooth_orders > 1 ? 3 : 1));
     }
-    return { xs, ys, lobes, finest };
+    return { xs, ys, lobes, finest, outline };
 }
 
 /**
@@ -337,7 +343,8 @@ function push_segment(list, x0, y0, x1, y1, half_width, angle, ox, oy) {
 }
 
 /**
- * Appends one simple blade, rotated by `angle` and set at `(ox, oy)`, with its veins.
+ * Appends one simple blade, rotated by `angle` and set at `(ox, oy)`, with its veins, and lowers `out.outline` to its
+ * outline's finest feature.
  *
  * @returns {number} its finest feature (m)
  */
@@ -348,6 +355,7 @@ function push_blade(out, arch, L, W, depth_scale, angle, ox, oy) {
     push_segment(out.midveins, 0, 0, 0, L * 0.97, mid_w, angle, ox, oy);
     const sec_w = 0.5 * SECONDARY_WIDTH * L;
     let finest = half.finest;
+    out.outline = Math.min(out.outline, half.outline);
     if (half.lobes.length > 0) {
         // each lobe, both sides, along its secondary vein, which runs most of its length
         const lobe_arch = lobe_architecture(arch);
@@ -356,6 +364,7 @@ function push_blade(out, arch, L, W, depth_scale, angle, ox, oy) {
             const y0 = half.lobes[k], length = half.lobes[k + 1], hw = half.lobes[k + 2];
             const lobe = blade_half(lobe_arch, length, 2 * hw, depth_scale);
             finest = Math.min(finest, lobe.finest);
+            out.outline = Math.min(out.outline, lobe.outline);
             // the vein's origin in the blade's frame, turned and moved as the blade is
             const vx = ox + y0 * sn, vy = oy + y0 * c;
             for (const side of [1, -1]) {
@@ -400,7 +409,7 @@ export function leaf_geometry(arch, maturity, shape_var) {
     const og = leaf_ontogeny(maturity, shape_var);
     const L = arch.blade_length * og.length;
     const W = L / arch.length_width_ratio * og.width;
-    const out = { points: [], contours: [], midveins: [], secondaries: [], stems: [] };
+    const out = { points: [], contours: [], midveins: [], secondaries: [], stems: [], outline: W };
     let finest = W;
     let tip_y = L;
     const petiole = arch.petiole_length * og.length;
@@ -452,6 +461,7 @@ export function leaf_geometry(arch, maturity, shape_var) {
         }
         out.contours.push(first, count);
         finest = Math.min(finest, (1 - floor) * L);
+        out.outline = Math.min(out.outline, (1 - floor) * L);
         tip_y = L;
         out.stems.push(0, -petiole, 0, 0, petiole_w);
     } else {
@@ -474,7 +484,8 @@ export function leaf_geometry(arch, maturity, shape_var) {
         stems: out.stems,
         attach_y: -petiole,
         tip_y,
-        finest
+        finest,
+        outline: out.outline
     };
 }
 
@@ -497,7 +508,7 @@ export function needle_shoot_geometry(arch, needles, shoot_length, needle_angle,
     const og = leaf_ontogeny(maturity, shape_var);
     const L = arch.blade_length * og.length;
     const W = L / arch.length_width_ratio * og.width;
-    const out = { points: [], contours: [], midveins: [], secondaries: [], stems: [] };
+    const out = { points: [], contours: [], midveins: [], secondaries: [], stems: [], outline: W };
     let finest = W;
     const sector = Math.PI / (2 * Math.max(1, planes));
     const sin_a = Math.sin(needle_angle), cos_a = Math.cos(needle_angle);
@@ -523,6 +534,7 @@ export function needle_shoot_geometry(arch, needles, shoot_length, needle_angle,
         stems: out.stems,
         attach_y: 0,
         tip_y: shoot_length + L * Math.cos(needle_angle),
-        finest
+        finest,
+        outline: out.outline
     };
 }

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

@@ -13,8 +13,7 @@
  *
  * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
  * @param {import("./FoliageAtlasCutout.js").FoliageAtlasCutout|null} [out_cutout]
- * @returns {StandardShadeMaterial}
+ * @returns {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial}
  */
-export function make_foliage_material(species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig, out_cutout?: import("./FoliageAtlasCutout.js").FoliageAtlasCutout | null): StandardShadeMaterial;
-import { StandardShadeMaterial } from "../../../shade/renderer/material/StandardShadeMaterial.js";
+export function make_foliage_material(species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig, out_cutout?: import("./FoliageAtlasCutout.js").FoliageAtlasCutout | null): import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial;
 //# sourceMappingURL=make_foliage_material.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"make_foliage_material.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/make_foliage_material.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;GAgBG;AACH,+CAJW,OAAO,gCAAgC,EAAE,iBAAiB,eAC1D,OAAO,yBAAyB,EAAE,kBAAkB,GAAC,IAAI,GACvD,qBAAqB,CA2TjC;sCA5VqC,2DAA2D"}
+{"version":3,"file":"make_foliage_material.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/make_foliage_material.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;GAgBG;AACH,+CAJW,OAAO,gCAAgC,EAAE,iBAAiB,eAC1D,OAAO,yBAAyB,EAAE,kBAAkB,GAAC,IAAI,GACvD,OAAO,2DAA2D,EAAE,qBAAqB,CA6QrG"}