@woosh/meep-engine 3.57.0 → 3.58.0

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

@@ -0,0 +1,25 @@
+/**
+ * Every card of every cluster (`tree_cluster_cards`), drawn with its representative's tile
+ * (`tree_cluster_representatives`, `tree_cluster_bake`): that tile's hull, a fan of
+ * {@link CUTOUT_HULL_VERTEX_COUNT} triangles about the hull's centre, placed on the card's plane by its placement. Every vertex is skinned as
+ * the point its cluster hangs from; its flutter grows from that point to the cluster's furthest corner, as a leaf
+ * card's does from its stem to its tip. The canopy's
+ * occlusion and its outward normals are the leaves' own, baked into the tile: the card's normal is its plane's, the
+ * frame its tile's normals are written in.
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {import("./tree_clusters.js").TreeCluster[]} clusters
+ * @param {import("./tree_cluster_cards.js").TreeClusterCard[]} cards
+ * @param {{rep: Int32Array, frames: Float64Array}} placement per card, its representative and the frame its tile is
+ *        placed by (`tree_cluster_representatives`)
+ * @param {import("../material/tree_cluster_bake.js").TreeClusterBake} bake the representatives' tiles
+ * @param {Geometry} [out]
+ * @returns {Geometry|null} `null` when there are no cards
+ */
+export function tree_mesh_build_clusters(skeleton: import("../skeleton/TreeSkeleton.js").TreeSkeleton, species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig, clusters: import("./tree_clusters.js").TreeCluster[], cards: import("./tree_cluster_cards.js").TreeClusterCard[], placement: {
+    rep: Int32Array;
+    frames: Float64Array;
+}, bake: import("../material/tree_cluster_bake.js").TreeClusterBake, out?: Geometry): Geometry | null;
+import { Geometry } from "../../../shade/renderer/geometry/Geometry.js";
+//# sourceMappingURL=tree_mesh_build_clusters.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tree_mesh_build_clusters.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_mesh_build_clusters.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;GAkBG;AACH,mDAVW,OAAO,6BAA6B,EAAE,YAAY,WAClD,OAAO,gCAAgC,EAAE,iBAAiB,YAC1D,OAAO,oBAAoB,EAAE,WAAW,EAAE,SAC1C,OAAO,yBAAyB,EAAE,eAAe,EAAE,aACnD;IAAC,GAAG,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAC,QAEvC,OAAO,kCAAkC,EAAE,eAAe,QAC1D,QAAQ,GACN,QAAQ,GAAC,IAAI,CA8GzB;yBA9IwB,8CAA8C"}

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

@@ -0,0 +1,144 @@
+import { clamp } from "../../../core/math/clamp.js";
+import { Geometry } from "../../../shade/renderer/geometry/Geometry.js";
+import {
+    geometry_obtain_attribute,
+    geometry_obtain_index
+} from "../../../shade/renderer/geometry/geometry_obtain_attribute.js";
+import { StandardAttributes } from "../../../shade/renderer/geometry/StandardAttributes.js";
+import { CUTOUT_HULL_VERTEX_COUNT } from "../material/FoliageAtlasCutout.js";
+import { geometry_obtain_joints_attribute } from "./tree_mesh_build_bark.js";
+
+/**
+ * Golden ratio conjugate: the phase step between consecutive clusters, so neighbours sway apart.
+ * @type {number}
+ */
+const PHASE_STEP = 0.6180339887498949;
+
+/**
+ * Every card of every cluster (`tree_cluster_cards`), drawn with its representative's tile
+ * (`tree_cluster_representatives`, `tree_cluster_bake`): that tile's hull, a fan of
+ * {@link CUTOUT_HULL_VERTEX_COUNT} triangles about the hull's centre, placed on the card's plane by its placement. Every vertex is skinned as
+ * the point its cluster hangs from; its flutter grows from that point to the cluster's furthest corner, as a leaf
+ * card's does from its stem to its tip. The canopy's
+ * occlusion and its outward normals are the leaves' own, baked into the tile: the card's normal is its plane's, the
+ * frame its tile's normals are written in.
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {import("./tree_clusters.js").TreeCluster[]} clusters
+ * @param {import("./tree_cluster_cards.js").TreeClusterCard[]} cards
+ * @param {{rep: Int32Array, frames: Float64Array}} placement per card, its representative and the frame its tile is
+ *        placed by (`tree_cluster_representatives`)
+ * @param {import("../material/tree_cluster_bake.js").TreeClusterBake} bake the representatives' tiles
+ * @param {Geometry} [out]
+ * @returns {Geometry|null} `null` when there are no cards
+ */
+export function tree_mesh_build_clusters(skeleton, species, clusters, cards, placement, bake, out = new Geometry()) {
+    const count = cards.length;
+    if (count === 0) {
+        return null;
+    }
+    const K = CUTOUT_HULL_VERTEX_COUNT;
+    const verts_per_card = K + 1;
+    const total_vertices = count * verts_per_card;
+
+    const positions = geometry_obtain_attribute(out, StandardAttributes.Position, 3, total_vertices);
+    const normals = geometry_obtain_attribute(out, StandardAttributes.Normal, 3, total_vertices);
+    const uv0 = geometry_obtain_attribute(out, StandardAttributes.TextureCoordinates0, 2, total_vertices);
+    const uv1 = geometry_obtain_attribute(out, StandardAttributes.TextureCoordinates1, 2, total_vertices);
+    const colors = geometry_obtain_attribute(out, StandardAttributes.Color, 3, total_vertices);
+    const joints = geometry_obtain_joints_attribute(out, total_vertices);
+    const weights = geometry_obtain_attribute(out, StandardAttributes.SkinningWeights, 4, total_vertices);
+    const indices = geometry_obtain_index(out, count * K * 3);
+
+    const hulls = bake.cutout.hulls;
+    const local = new Float64Array((K + 1) * 2);
+    const corner = new Float64Array(3);
+
+    // how far each cluster reaches from where it hangs, over all its cards
+    const reach = new Float64Array(clusters.length).fill(1e-6);
+    const frames = placement.frames;
+    const corner_of = (i, k, out_corner) => {
+        const f = i * 12, r = placement.rep[i];
+        const a = bake.extents[r * 4] + local[k * 2] * (bake.extents[r * 4 + 2] - bake.extents[r * 4]);
+        const b = bake.extents[r * 4 + 1] + local[k * 2 + 1] * (bake.extents[r * 4 + 3] - bake.extents[r * 4 + 1]);
+        for (let d = 0; d < 3; d++) out_corner[d] = frames[f + d] + frames[f + 3 + d] * a + frames[f + 6 + d] * b;
+    };
+    // the hull of representative `i`'s tile
+    const load_hull = (i) => {
+        let cu = 0, cv = 0;
+        for (let k = 0; k < K; k++) {
+            local[(k + 1) * 2] = hulls[(i * K + k) * 2];
+            local[(k + 1) * 2 + 1] = hulls[(i * K + k) * 2 + 1];
+            cu += local[(k + 1) * 2];
+            cv += local[(k + 1) * 2 + 1];
+        }
+        local[0] = cu / K;
+        local[1] = cv / K;
+    };
+    for (let i = 0; i < count; i++) {
+        const cluster = clusters[cards[i].cluster];
+        load_hull(placement.rep[i]);
+        for (let k = 0; k <= K; k++) {
+            corner_of(i, k, corner);
+            const d = Math.hypot(corner[0] - cluster.position[0], corner[1] - cluster.position[1], corner[2] - cluster.position[2]);
+            reach[cards[i].cluster] = Math.max(reach[cards[i].cluster], d);
+        }
+    }
+
+    for (let i = 0; i < count; i++) {
+        const cluster = clusters[cards[i].cluster];
+        const f = i * 12, r = placement.rep[i];
+        const ox = frames[f], oy = frames[f + 1], oz = frames[f + 2];
+        const e1x = frames[f + 3], e1y = frames[f + 4], e1z = frames[f + 5];
+        const e2x = frames[f + 6], e2y = frames[f + 7], e2z = frames[f + 8];
+        const nx = frames[f + 9], ny = frames[f + 10], nz = frames[f + 11];
+        const x0 = bake.extents[r * 4], y0 = bake.extents[r * 4 + 1];
+        const x1 = bake.extents[r * 4 + 2], y1 = bake.extents[r * 4 + 3];
+        const u0 = bake.uv_rects[r * 4], v0 = bake.uv_rects[r * 4 + 1];
+        const u1 = bake.uv_rects[r * 4 + 2], v1 = bake.uv_rects[r * 4 + 3];
+
+        // the fan's centre, then the hull's corners, in the tile's [0, 1]^2
+        load_hull(r);
+        const cluster_reach = reach[cards[i].cluster];
+        const phase = (cards[i].cluster * PHASE_STEP) % 1;
+
+        const base = i * verts_per_card;
+        for (let k = 0; k <= K; k++) {
+            const tu = local[k * 2], tv = local[k * 2 + 1];
+            const a = x0 + tu * (x1 - x0), b = y0 + tv * (y1 - y0);
+            const v = base + k;
+            positions[v * 3] = ox + e1x * a + e2x * b;
+            positions[v * 3 + 1] = oy + e1y * a + e2y * b;
+            positions[v * 3 + 2] = oz + e1z * a + e2z * b;
+            normals[v * 3] = nx;
+            normals[v * 3 + 1] = ny;
+            normals[v * 3 + 2] = nz;
+            uv0[v * 2] = u0 + tu * (u1 - u0);
+            uv0[v * 2 + 1] = v0 + tv * (v1 - v0);
+            const from_x = positions[v * 3] - cluster.position[0];
+            const from_y = positions[v * 3 + 1] - cluster.position[1];
+            const from_z = positions[v * 3 + 2] - cluster.position[2];
+            uv1[v * 2] = clamp(0.25 + 0.75 * Math.hypot(from_x, from_y, from_z) / cluster_reach, 0, 1);
+            uv1[v * 2 + 1] = phase;
+            colors[v * 3] = 1;
+            colors[v * 3 + 1] = 1;
+            colors[v * 3 + 2] = 1;
+            for (let s = 0; s < 4; s++) {
+                joints[v * 4 + s] = cluster.joints[s];
+                weights[v * 4 + s] = cluster.weights[s];
+            }
+        }
+        for (let k = 0; k < K; k++) {
+            const t = (i * K + k) * 3;
+            indices[t] = base;
+            indices[t + 1] = base + 1 + k;
+            indices[t + 2] = base + 1 + ((k + 1) % K);
+        }
+    }
+
+    out.name = `${species.name || "tree"}_clusters`;
+    out.ensureBounds();
+    out.ensureTangents();
+    return out;
+}

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

@@ -1,12 +1,11 @@
 /**
- * Synthesizes the foliage `Geometry` for a given LOD from a `FoliageAttachmentSet`,
- * applying golden-ratio low-discrepancy LOD decimation ($h_i < k_{\text{keep}}$),
- * optical area-compensation scaling ($s_{\text{comp}} = k_{\text{keep}}^{-\eta}$),
- * botanical 3D card geometry (`FoldedVCard`, `CrossCard`, `TriStarCluster`, `RibbedFrond`, `CutoutHull`),
- * MaxRect-packed ontogenetic variant UV remapping, hemisphere-safe normal puffing,
- * volumetric canopy AO, and 4-joint skeletal wind skinning.
+ * Synthesizes one card for every leaf of a `FoliageAttachmentSet`, in its order: the leaves as the tree grew them, which
+ * each LOD's cluster cards are drawn from (`tree_cluster_bake`). Card `c` holds vertices
+ * `[c * verts_per_card, (c + 1) * verts_per_card)`. Botanical 3D card geometry (`FoldedVCard`, `CrossCard`,
+ * `TriStarCluster`, `RibbedFrond`, `CutoutHull`), MaxRect-packed ontogenetic variant UV remapping,
+ * hemisphere-safe normal puffing, volumetric canopy AO, and 4-joint skeletal wind skinning.
  *
- * Returns `null` if foliage is disabled or `lod_config.foliage_keep_ratio <= 0` or `attachments.count === 0`.
+ * Returns `null` if there are no attachments.
  *
  * Vertex colours carry each card's tint divided by `attachments.tint_scale`, so a tint brighter than 1 survives the
  * `unorm8` encoding: the material drawing these cards sets its `diffuse_color` to `tint_scale` (as `generate_tree`
@@ -16,14 +15,12 @@
  * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
  * @param {import("./foliage_collect_attachments.js").FoliageAttachmentSet} attachments
  * @param {TreeSpeciesConfig} [config]
- * @param {TreeLODConfig} [lod_config]
  * @param {import("../material/FoliageAtlasCutout.js").FoliageAtlasCutout|null} [cutout] shape of the atlas the
  *        cards show, from `make_foliage_material`; `CutoutHull` cards cover whole tiles without it
  * @param {Geometry} [out]
  * @returns {Geometry|null}
  */
-export function tree_mesh_build_foliage(skeleton: import("../skeleton/TreeSkeleton.js").TreeSkeleton, attachments: import("./foliage_collect_attachments.js").FoliageAttachmentSet, config?: TreeSpeciesConfig, lod_config?: TreeLODConfig, cutout?: import("../material/FoliageAtlasCutout.js").FoliageAtlasCutout | null, out?: Geometry): Geometry | null;
+export function tree_mesh_build_foliage(skeleton: import("../skeleton/TreeSkeleton.js").TreeSkeleton, attachments: import("./foliage_collect_attachments.js").FoliageAttachmentSet, config?: TreeSpeciesConfig, cutout?: import("../material/FoliageAtlasCutout.js").FoliageAtlasCutout | null, out?: Geometry): Geometry | null;
 import { TreeSpeciesConfig } from "../config/TreeSpeciesConfig.js";
-import { TreeLODConfig } from "../config/TreeLODConfig.js";
 import { Geometry } from "../../../shade/renderer/geometry/Geometry.js";
 //# sourceMappingURL=tree_mesh_build_foliage.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tree_mesh_build_foliage.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_mesh_build_foliage.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kDATW,OAAO,6BAA6B,EAAE,YAAY,eAClD,OAAO,kCAAkC,EAAE,oBAAoB,WAC/D,iBAAiB,eACjB,aAAa,WACb,OAAO,mCAAmC,EAAE,kBAAkB,GAAC,IAAI,QAEnE,QAAQ,GACN,QAAQ,GAAC,IAAI,CAqazB;kCAxciC,gCAAgC;8BADpC,4BAA4B;yBAPjC,8CAA8C"}
+{"version":3,"file":"tree_mesh_build_foliage.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_mesh_build_foliage.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,kDARW,OAAO,6BAA6B,EAAE,YAAY,eAClD,OAAO,kCAAkC,EAAE,oBAAoB,WAC/D,iBAAiB,WACjB,OAAO,mCAAmC,EAAE,kBAAkB,GAAC,IAAI,QAEnE,QAAQ,GACN,QAAQ,GAAC,IAAI,CA8YzB;kCA/aiC,gCAAgC;yBAPzC,8CAA8C"}

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

@@ -7,7 +7,6 @@ import {
 } from "../../../shade/renderer/geometry/geometry_obtain_attribute.js";
 import { StandardAttributes } from "../../../shade/renderer/geometry/StandardAttributes.js";
 import { FoliageCardType } from "../config/FoliageCardType.js";
-import { TreeLODConfig } from "../config/TreeLODConfig.js";
 import { TreeSpeciesConfig } from "../config/TreeSpeciesConfig.js";
 import { compute_foliage_variant_atlas_layout } from "../material/compute_foliage_variant_atlas_layout.js";
 import { foliage_tile_layout } from "../material/foliage_tile.js";
@@ -22,14 +21,13 @@ import { geometry_obtain_joints_attribute } from "./tree_mesh_build_bark.js";
 const WHOLE_TILE_HULL = new Float32Array([0, 0, 1, 0, 1, 0.5, 1, 1, 0, 1, 0, 0.5]);
 
 /**
- * Synthesizes the foliage `Geometry` for a given LOD from a `FoliageAttachmentSet`,
- * applying golden-ratio low-discrepancy LOD decimation ($h_i < k_{\text{keep}}$),
- * optical area-compensation scaling ($s_{\text{comp}} = k_{\text{keep}}^{-\eta}$),
- * botanical 3D card geometry (`FoldedVCard`, `CrossCard`, `TriStarCluster`, `RibbedFrond`, `CutoutHull`),
- * MaxRect-packed ontogenetic variant UV remapping, hemisphere-safe normal puffing,
- * volumetric canopy AO, and 4-joint skeletal wind skinning.
+ * Synthesizes one card for every leaf of a `FoliageAttachmentSet`, in its order: the leaves as the tree grew them, which
+ * each LOD's cluster cards are drawn from (`tree_cluster_bake`). Card `c` holds vertices
+ * `[c * verts_per_card, (c + 1) * verts_per_card)`. Botanical 3D card geometry (`FoldedVCard`, `CrossCard`,
+ * `TriStarCluster`, `RibbedFrond`, `CutoutHull`), MaxRect-packed ontogenetic variant UV remapping,
+ * hemisphere-safe normal puffing, volumetric canopy AO, and 4-joint skeletal wind skinning.
  *
- * Returns `null` if foliage is disabled or `lod_config.foliage_keep_ratio <= 0` or `attachments.count === 0`.
+ * Returns `null` if there are no attachments.
  *
  * Vertex colours carry each card's tint divided by `attachments.tint_scale`, so a tint brighter than 1 survives the
  * `unorm8` encoding: the material drawing these cards sets its `diffuse_color` to `tint_scale` (as `generate_tree`
@@ -39,7 +37,6 @@ const WHOLE_TILE_HULL = new Float32Array([0, 0, 1, 0, 1, 0.5, 1, 1, 0, 1, 0, 0.5
  * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
  * @param {import("./foliage_collect_attachments.js").FoliageAttachmentSet} attachments
  * @param {TreeSpeciesConfig} [config]
- * @param {TreeLODConfig} [lod_config]
  * @param {import("../material/FoliageAtlasCutout.js").FoliageAtlasCutout|null} [cutout] shape of the atlas the
  *        cards show, from `make_foliage_material`; `CutoutHull` cards cover whole tiles without it
  * @param {Geometry} [out]
@@ -49,39 +46,16 @@ export function tree_mesh_build_foliage(
 	skeleton,
 	attachments,
 	config = new TreeSpeciesConfig(),
-	lod_config = new TreeLODConfig(),
 	cutout = null,
 	out = new Geometry()
 ) {
 	const species = config && config.isTreeSpeciesConfig ? config : TreeSpeciesConfig.from(config);
-	const lod_cfg = lod_config && lod_config.isTreeLODConfig ? lod_config : TreeLODConfig.from(lod_config);
 	const fol = species.foliage;
-	const keep_ratio = clamp(lod_cfg.foliage_keep_ratio ?? 1.0, 0.0, 1.0);
-	if (!attachments || attachments.count === 0 || keep_ratio <= 0.0) {
+	if (!attachments || attachments.count === 0) {
 		return null;
 	}
-
-	// Filter active attachment indices by golden-ratio rank
-	const active_indices = [];
-	for (let i = 0; i < attachments.count; i++) {
-		if (attachments.ranks[i] < keep_ratio) {
-			active_indices.push(i);
-		}
-	}
-	if (active_indices.length === 0 && attachments.count > 0) {
-		active_indices.push(0);
-	}
-	const card_count = active_indices.length;
-
-	// Area compensation scale: k_keep^(-eta)
-	const eta = clamp(lod_cfg.foliage_area_compensation_exponent ?? 0.42, 0.0, 0.6);
-	const area_comp = Math.pow(Math.max(0.08, keep_ratio), -eta);
-
-	// Determine effective card type for this LOD
-	let card_type = fol.card_type;
-	if (lod_cfg.simplify_cards) {
-		card_type = FoliageCardType.FoldedVCard;
-	}
+	const card_count = attachments.count;
+	const card_type = fol.card_type;
 
 	const frond_segs = Math.max(2, fol.frond_segments | 0);
 	let verts_per_card = 6;
@@ -143,8 +117,8 @@ export function tree_mesh_build_foliage(
 	}
 
 	// the card's width is the tile's; its length runs from the anchor to the tile's far edge
-	const base_w = tiles.card_size * area_comp;
-	const base_l = tiles.card_size * (1.0 - tiles.anchor_v) * area_comp;
+	const base_w = tiles.card_size;
+	const base_l = tiles.card_size * (1.0 - tiles.anchor_v);
 	const turgid_fold = clamp(fol.fold_angle, 0.0, 0.65);
 	const turgid_arch = fol.arch_height;
 	const turgid_droop = fol.camber_droop;
@@ -229,7 +203,7 @@ export function tree_mesh_build_foliage(
 	const inv_tint_scale = has_tints ? 1.0 / Math.max(1.0, attachments.tint_scale ?? 1.0) : 1.0;
 
 	for (let c = 0; c < card_count; c++) {
-		const att_idx = active_indices[c];
+		const att_idx = c;
 		const a3 = att_idx * 3;
 		const a2 = att_idx * 2;
 		const a4 = att_idx * 4;
@@ -459,7 +433,7 @@ export function tree_mesh_build_foliage(
 		preserve_existing_color: true
 	});
 
-	out.name = `${species.name || "tree"}_foliage_lod${lod_cfg.level}`;
+	out.name = `${species.name || "tree"}_leaves`;
 	out.ensureBounds();
 	out.ensureTangents();
 

package/src/generation/foliage/presets/make_tree_species_preset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"make_tree_species_preset.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/presets/make_tree_species_preset.js"],"names":[],"mappings":"AAyKA;;;;;;;;GAQG;AACH,kDAJW,UAAU,GAAC,MAAM,oBAEf,iBAAiB,CA+7C7B;2BA1mD0B,yBAAyB;kCAClB,gCAAgC"}
+{"version":3,"file":"make_tree_species_preset.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/presets/make_tree_species_preset.js"],"names":[],"mappings":"AAkKA;;;;;;;;GAQG;AACH,kDAJW,UAAU,GAAC,MAAM,oBAEf,iBAAiB,CAs0C7B;2BA1+C0B,yBAAyB;kCAClB,gCAAgC"}