@woosh/meep-engine 3.56.0 → 3.57.0

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

@@ -0,0 +1,59 @@
+/**
+ * Perimeter vertices of a fitted cutout hull. With the midrib vertex in its middle a `FoliageCardType.CutoutHull`
+ * card is `CUTOUT_HULL_VERTEX_COUNT + 1` vertices fanned into `CUTOUT_HULL_VERTEX_COUNT` triangles.
+ * @type {number}
+ */
+export const CUTOUT_HULL_VERTEX_COUNT: number;
+/**
+ * What the synthesized foliage atlas looks like to the geometry built on it: per variant tile, a convex hull that
+ * holds every texel with any coverage, and how much of the tile is leaf.
+ *
+ * Produced by `make_foliage_material` (or `foliage_atlas_cutout`, which synthesizes only the alpha), consumed by
+ * `tree_mesh_build_foliage` (hull cards) and `foliage_collect_attachments` (card density).
+ */
+export class FoliageAtlasCutout {
+    /**
+     * @type {number}
+     */
+    variant_count: number;
+    /**
+     * Counter-clockwise hull of each tile in tile-local `[0, 1]^2` UVs (`v` from the stem anchor end towards the tip),
+     * `CUTOUT_HULL_VERTEX_COUNT` (u, v) pairs per variant. Never leaves the tile: each vertex stays half a texel inside.
+     * @type {Float32Array}
+     */
+    hulls: Float32Array;
+    /**
+     * Alpha-weighted leaf area of each tile, as a fraction of the tile.
+     * @type {Float32Array}
+     */
+    coverage: Float32Array;
+    /**
+     * @param {number} variant_count
+     * @returns {this}
+     */
+    resize(variant_count: number): this;
+    /**
+     * Mean leaf fraction over all tiles.
+     * @returns {number}
+     */
+    mean_coverage(): number;
+    /**
+     * Mean leaf fraction over `count` tiles from `first`: one tile kind of the atlas.
+     * @param {number} first
+     * @param {number} count
+     * @returns {number}
+     */
+    mean_coverage_of(first: number, count: number): number;
+    /**
+     * Area of a tile's hull, as a fraction of the tile.
+     * @param {number} variant
+     * @returns {number}
+     */
+    hull_area(variant: number): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isFoliageAtlasCutout: boolean;
+}
+//# sourceMappingURL=FoliageAtlasCutout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FoliageAtlasCutout.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/FoliageAtlasCutout.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;;;;GAMG;AACH;IACC;;OAEG;IACH,eAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,OAFU,YAAY,CAEM;IAE5B;;;OAGG;IACH,UAFU,YAAY,CAES;IAE/B;;;OAGG;IACH,sBAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,iBAFa,MAAM,CAQlB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CASlB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,MAAM,CAOlB;IAGF;;;OAGG;IACH,+BAFU,OAAO,CAEgC;CANhD"}

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

@@ -0,0 +1,93 @@
+import { polygon2_signed_area } from "../../../core/geom/2d/polygon/polygon2_signed_area.js";
+
+/**
+ * Perimeter vertices of a fitted cutout hull. With the midrib vertex in its middle a `FoliageCardType.CutoutHull`
+ * card is `CUTOUT_HULL_VERTEX_COUNT + 1` vertices fanned into `CUTOUT_HULL_VERTEX_COUNT` triangles.
+ * @type {number}
+ */
+export const CUTOUT_HULL_VERTEX_COUNT = 6;
+
+/**
+ * What the synthesized foliage atlas looks like to the geometry built on it: per variant tile, a convex hull that
+ * holds every texel with any coverage, and how much of the tile is leaf.
+ *
+ * Produced by `make_foliage_material` (or `foliage_atlas_cutout`, which synthesizes only the alpha), consumed by
+ * `tree_mesh_build_foliage` (hull cards) and `foliage_collect_attachments` (card density).
+ */
+export class FoliageAtlasCutout {
+	/**
+	 * @type {number}
+	 */
+	variant_count = 0;
+
+	/**
+	 * Counter-clockwise hull of each tile in tile-local `[0, 1]^2` UVs (`v` from the stem anchor end towards the tip),
+	 * `CUTOUT_HULL_VERTEX_COUNT` (u, v) pairs per variant. Never leaves the tile: each vertex stays half a texel inside.
+	 * @type {Float32Array}
+	 */
+	hulls = new Float32Array(0);
+
+	/**
+	 * Alpha-weighted leaf area of each tile, as a fraction of the tile.
+	 * @type {Float32Array}
+	 */
+	coverage = new Float32Array(0);
+
+	/**
+	 * @param {number} variant_count
+	 * @returns {this}
+	 */
+	resize(variant_count) {
+		if (this.variant_count !== variant_count) {
+			this.variant_count = variant_count;
+			this.hulls = new Float32Array(variant_count * CUTOUT_HULL_VERTEX_COUNT * 2);
+			this.coverage = new Float32Array(variant_count);
+		}
+		return this;
+	}
+
+	/**
+	 * Mean leaf fraction over all tiles.
+	 * @returns {number}
+	 */
+	mean_coverage() {
+		let sum = 0.0;
+		for (let i = 0; i < this.variant_count; i++) {
+			sum += this.coverage[i];
+		}
+		return this.variant_count > 0 ? sum / this.variant_count : 0.0;
+	}
+
+	/**
+	 * Mean leaf fraction over `count` tiles from `first`: one tile kind of the atlas.
+	 * @param {number} first
+	 * @param {number} count
+	 * @returns {number}
+	 */
+	mean_coverage_of(first, count) {
+		const end = Math.min(this.variant_count, first + count);
+		let sum = 0.0;
+		for (let i = first; i < end; i++) {
+			sum += this.coverage[i];
+		}
+		return end > first ? sum / (end - first) : 0.0;
+	}
+
+	/**
+	 * Area of a tile's hull, as a fraction of the tile.
+	 * @param {number} variant
+	 * @returns {number}
+	 */
+	hull_area(variant) {
+		return polygon2_signed_area(
+			this.hulls.subarray(variant * CUTOUT_HULL_VERTEX_COUNT * 2, (variant + 1) * CUTOUT_HULL_VERTEX_COUNT * 2),
+			CUTOUT_HULL_VERTEX_COUNT
+		);
+	}
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+FoliageAtlasCutout.prototype.isFoliageAtlasCutout = true;

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

@@ -0,0 +1,26 @@
+/**
+ * Packs `variant_count` square foliage card tiles of size `resolution x resolution` into a 2D atlas
+ * using the engine's `MaxRectanglesPacker` (`pack_max_rectangles`), returning the atlas dimensions,
+ * pixel-space `AABB2` boxes, and normalized `[u0, v0, u1, v1]` UV rectangles.
+ *
+ * @param {number} [resolution=128]
+ * @param {number} [variant_count=4]
+ * @returns {{
+ *   resolution: number,
+ *   variant_count: number,
+ *   atlas_w: number,
+ *   atlas_h: number,
+ *   boxes: AABB2[],
+ *   uv_rects: Float32Array
+ * }}
+ */
+export function compute_foliage_variant_atlas_layout(resolution?: number, variant_count?: number): {
+    resolution: number;
+    variant_count: number;
+    atlas_w: number;
+    atlas_h: number;
+    boxes: AABB2[];
+    uv_rects: Float32Array;
+};
+import AABB2 from "../../../core/geom/2d/aabb/AABB2.js";
+//# sourceMappingURL=compute_foliage_variant_atlas_layout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compute_foliage_variant_atlas_layout.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/compute_foliage_variant_atlas_layout.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,kEAXW,MAAM,kBACN,MAAM,GACJ;IACZ,UAAc,EAAE,MAAM,CAAC;IACvB,aAAiB,EAAE,MAAM,CAAC;IAC1B,OAAW,EAAE,MAAM,CAAC;IACpB,OAAW,EAAE,MAAM,CAAC;IACpB,KAAS,EAAE,KAAK,EAAE,CAAC;IACnB,QAAY,EAAE,YAAY,CAAA;CACvB,CA4CH;kBA9DiB,qCAAqC"}

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

@@ -0,0 +1,63 @@
+import AABB2 from "../../../core/geom/2d/aabb/AABB2.js";
+import { pack_max_rectangles } from "../../../core/geom/packing/max-rect/pack_max_rectangles.js";
+import { clamp } from "../../../core/math/clamp.js";
+
+/**
+ * Packs `variant_count` square foliage card tiles of size `resolution x resolution` into a 2D atlas
+ * using the engine's `MaxRectanglesPacker` (`pack_max_rectangles`), returning the atlas dimensions,
+ * pixel-space `AABB2` boxes, and normalized `[u0, v0, u1, v1]` UV rectangles.
+ *
+ * @param {number} [resolution=128]
+ * @param {number} [variant_count=4]
+ * @returns {{
+ *   resolution: number,
+ *   variant_count: number,
+ *   atlas_w: number,
+ *   atlas_h: number,
+ *   boxes: AABB2[],
+ *   uv_rects: Float32Array
+ * }}
+ */
+export function compute_foliage_variant_atlas_layout(resolution = 128, variant_count = 4) {
+	const res = Math.max(16, resolution | 0);
+	const count = clamp(variant_count | 0, 1, 16);
+	const cols = Math.max(1, Math.ceil(Math.sqrt(count)));
+	const rows = Math.max(1, Math.ceil(count / cols));
+	const atlas_w = cols * res;
+	const atlas_h = rows * res;
+
+	/** @type {AABB2[]} */
+	const boxes = new Array(count);
+	for (let k = 0; k < count; k++) {
+		boxes[k] = new AABB2(0, 0, res, res);
+	}
+
+	const packed = pack_max_rectangles(atlas_w, atlas_h, boxes);
+	if (!packed) {
+		// Deterministic grid fallback if custom non-uniform boxes are ever used
+		for (let k = 0; k < count; k++) {
+			const c = k % cols;
+			const r = Math.floor(k / cols);
+			boxes[k].set(c * res, r * res, (c + 1) * res, (r + 1) * res);
+		}
+	}
+
+	const uv_rects = new Float32Array(count * 4);
+	for (let k = 0; k < count; k++) {
+		const b = boxes[k];
+		const k4 = k * 4;
+		uv_rects[k4] = b.x0 / atlas_w;
+		uv_rects[k4 + 1] = b.y0 / atlas_h;
+		uv_rects[k4 + 2] = b.x1 / atlas_w;
+		uv_rects[k4 + 3] = b.y1 / atlas_h;
+	}
+
+	return {
+		resolution: res,
+		variant_count: count,
+		atlas_w,
+		atlas_h,
+		boxes,
+		uv_rects
+	};
+}

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

@@ -0,0 +1,34 @@
+/**
+ * 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
+ * nothing a coarser mip spreads into an edge texel is cut off.
+ *
+ * @param {FoliageAtlasCutout} out already sized
+ * @param {number} variant
+ * @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
+ */
+export function foliage_atlas_cutout_fit_tile(out: FoliageAtlasCutout, variant: number, row_min: Int32Array, row_max: Int32Array, coverage_sum: number, res: 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
+ */
+export function foliage_atlas_cutout_fit_alpha(out: FoliageAtlasCutout, variant: number, alpha: Float32Array, res: 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
+ * cutout as a by-product.
+ *
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {FoliageAtlasCutout} [out]
+ * @returns {FoliageAtlasCutout}
+ */
+export function foliage_atlas_cutout(species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig, out?: FoliageAtlasCutout): FoliageAtlasCutout;
+import { FoliageAtlasCutout } from "./FoliageAtlasCutout.js";
+//# sourceMappingURL=foliage_atlas_cutout.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,174 @@
+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 { CUTOUT_HULL_VERTEX_COUNT, FoliageAtlasCutout } from "./FoliageAtlasCutout.js";
+import { foliage_tile_layout, foliage_tile_raster } from "./foliage_tile.js";
+
+/**
+ * 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
+ * nothing a coarser mip spreads into an edge texel is cut off.
+ *
+ * @param {FoliageAtlasCutout} out already sized
+ * @param {number} variant
+ * @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
+ */
+export function foliage_atlas_cutout_fit_tile(out, variant, row_min, row_max, coverage_sum, res) {
+	const inv_res = 1.0 / res;
+
+	// 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 points = new Float64Array(res * 8);
+	let n = 0;
+	for (let y = 0; y < res; 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);
+		points[n * 2] = x0;
+		points[n * 2 + 1] = y0;
+		points[n * 2 + 2] = x0;
+		points[n * 2 + 3] = y1;
+		points[n * 2 + 4] = x1;
+		points[n * 2 + 5] = y0;
+		points[n * 2 + 6] = x1;
+		points[n * 2 + 7] = y1;
+		n += 4;
+	}
+
+	const K = CUTOUT_HULL_VERTEX_COUNT;
+	const hull = new Float64Array(Math.max(K, n) * 2);
+	let k = 0;
+
+	if (n >= 3) {
+		const indices = convex_hull_monotone_2d(points, n);
+		const loop = new Float64Array(indices.length * 2);
+		for (let i = 0; i < indices.length; i++) {
+			loop[i * 2] = points[indices[i] * 2];
+			loop[i * 2 + 1] = points[indices[i] * 2 + 1];
+		}
+		// relaxation extends neighbouring edges over each one it removes; bounded, it never extends one out of the tile
+		k = convex_hull_fixed_count_2d_relaxation(hull, 0, K, loop, indices.length, bounds);
+		if (k > K) {
+			// No edge of the silhouette's hull can go without pushing a corner out of the tile: the tile's own sides
+			// have to become edges. Fit unbounded, clip that to the tile, and relax the clipped polygon inside it.
+			const free = new Float64Array(K * 2);
+			const k_free = convex_hull_fixed_count_2d_relaxation(free, 0, K, loop, indices.length);
+			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);
+			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
+				// silhouette's bounding box instead: looser, but it holds every drawn texel and stays in the tile.
+				let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+				for (let i = 0; i < n; i++) {
+					x0 = Math.min(x0, points[i * 2]);
+					x1 = Math.max(x1, points[i * 2]);
+					y0 = Math.min(y0, points[i * 2 + 1]);
+					y1 = Math.max(y1, points[i * 2 + 1]);
+				}
+				const ym = 0.5 * (y0 + y1);
+				hull.set([x0, y0, x1, y0, x1, ym, x1, y1, x0, y1, x0, ym]);
+				k = K;
+			}
+		}
+	}
+
+	if (k < 3) {
+		// nothing drawn on this tile: the whole tile
+		hull.set([0, 0, 1, 0, 1, 0.5, 1, 1, 0, 1, 0, 0.5]);
+		k = K;
+	}
+
+	// fewer hull corners than the card has: split the longest edge until it has them all
+	while (k < K) {
+		let longest = 0;
+		let longest_len = -1;
+		for (let i = 0; i < k; i++) {
+			const j = (i + 1) % k;
+			const len = Math.hypot(hull[j * 2] - hull[i * 2], hull[j * 2 + 1] - hull[i * 2 + 1]);
+			if (len > longest_len) {
+				longest_len = len;
+				longest = i;
+			}
+		}
+		const j = (longest + 1) % k;
+		const mx = 0.5 * (hull[longest * 2] + hull[j * 2]);
+		const my = 0.5 * (hull[longest * 2 + 1] + hull[j * 2 + 1]);
+		hull.copyWithin((longest + 2) * 2, (longest + 1) * 2, k * 2);
+		hull[(longest + 1) * 2] = mx;
+		hull[(longest + 1) * 2 + 1] = my;
+		k++;
+	}
+
+	const ccw = polygon2_is_counter_clockwise(hull, 0, K);
+
+	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.coverage[variant] = coverage_sum * inv_res * inv_res;
+}
+
+/**
+ * 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
+ */
+export function foliage_atlas_cutout_fit_alpha(out, variant, alpha, res) {
+	const row_min = new Int32Array(res);
+	const row_max = new Int32Array(res);
+	let coverage_sum = 0.0;
+	for (let y = 0; y < res; y++) {
+		row_min[y] = -1;
+		for (let x = 0; x < res; x++) {
+			const a = alpha[y * res + x];
+			if (Math.round(a * 255) > 0) {
+				if (row_min[y] < 0) row_min[y] = x;
+				row_max[y] = x;
+			}
+			coverage_sum += a;
+		}
+	}
+	foliage_atlas_cutout_fit_tile(out, variant, row_min, row_max, coverage_sum, res);
+}
+
+/**
+ * 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
+ * cutout as a by-product.
+ *
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {FoliageAtlasCutout} [out]
+ * @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);
+	}
+	return out;
+}

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

@@ -0,0 +1,110 @@
+/**
+ * @typedef {Object} FoliageTileLayout
+ * @property {number} variant_count maturity variants, one tile each
+ * @property {number} resolution texels across a tile
+ * @property {number} scale tile units per metre: every tile draws its organ at its true size at this scale
+ * @property {number} card_size the side of the square card a tile covers (m)
+ * @property {number} anchor_u where the organ attaches to its shoot, in tile units
+ * @property {number} anchor_v
+ * @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
+ */
+/**
+ * Maturity variants of a species' foliage atlas.
+ * @param {import("../config/FoliageMaterialConfig.js").FoliageMaterialConfig} material
+ * @returns {number}
+ */
+export function foliage_atlas_variant_count(material: import("../config/FoliageMaterialConfig.js").FoliageMaterialConfig): number;
+/**
+ * How a species' foliage atlas lays out its tiles: every tile draws its organ (a leaf, or a stretch of needle shoot)
+ * at the same scale, its true size, so a card's size in metres is the tile's at that scale. The mature organ fills the
+ * tile within its margin, attached at the bottom middle; younger, smaller ones fit inside.
+ *
+ * A needle-shoot card draws a stretch of shoot as long as a needle, with as many needles as the shoot bears there
+ * (`FoliageConfig.leaves_per_metre`), shared among the planes it stands up: each plane's tile draws the needles in
+ * its sector round the shoot.
+ *
+ * The resolution draws the organ's finest feature `FEATURE_TEXELS` texels across, and its narrowest stem `STEM_TEXELS`.
+ *
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @returns {FoliageTileLayout}
+ */
+export function foliage_tile_layout(species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig): FoliageTileLayout;
+/**
+ * Rasterizes tile `variant` of a species' atlas: the organ's exact coverage of each texel, and the fields the
+ * material shades it with.
+ *
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {FoliageTileLayout} layout
+ * @param {number} variant
+ * @param {boolean} [coverage_only] skip everything but `alpha`
+ * @returns {FoliageTileRaster}
+ */
+export function foliage_tile_raster(species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig, layout: FoliageTileLayout, variant: number, coverage_only?: boolean): FoliageTileRaster;
+export type FoliageTileLayout = {
+    /**
+     * maturity variants, one tile each
+     */
+    variant_count: number;
+    /**
+     * texels across a tile
+     */
+    resolution: number;
+    /**
+     * tile units per metre: every tile draws its organ at its true size at this scale
+     */
+    scale: number;
+    /**
+     * the side of the square card a tile covers (m)
+     */
+    card_size: number;
+    /**
+     * where the organ attaches to its shoot, in tile units
+     */
+    anchor_u: number;
+    anchor_v: number;
+    /**
+     * leaves one card draws: one leaf, or a needle shoot's needles
+     */
+    leaves_per_card: number;
+    /**
+     * needles a needle-shoot tile draws, its plane's share of the card's; 0 for a leaf
+     */
+    needles: number;
+    /**
+     * length of shoot a needle-shoot tile draws (m), 0 for a leaf
+     */
+    shoot_length: number;
+};
+export type FoliageTileRaster = {
+    /**
+     * of the tile's organ
+     */
+    maturity: number;
+    /**
+     * leaf coverage of each texel, row-major from the tile's bottom (`v` 0) up
+     */
+    alpha: Float32Array;
+    /**
+     * how strongly a vein shows, `[0, 1]`
+     */
+    vein: Float32Array;
+    /**
+     * `0` at the margin, `1` on the midvein (or a primary vein, a rachis)
+     */
+    edge_norm: Float32Array;
+    /**
+     * where along the organ, `0` at its foot, `1` at its tip
+     */
+    tip: Float32Array;
+    /**
+     * lamina relief: camber, bullation, raised veins
+     */
+    height: Float32Array;
+    /**
+     * coverage of the woody stem: petiole, rachis, shoot
+     */
+    stem: Float32Array;
+};
+//# sourceMappingURL=foliage_tile.d.ts.map

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

@@ -0,0 +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"}