@woosh/meep-engine 3.56.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,22 +1,26 @@
 /**
- * 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`, `OctagonalCutoutHull`),
- * 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`
+ * does for the synthesized material). Each card's `attachments.dryness` rolls it shut, flattens its arch and lets
+ * its tip hang, towards a leaf with no turgor.
  *
  * @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, 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":"AAeA;;;;;;;;;;;;;;;;GAgBG;AACH,kDAPW,OAAO,6BAA6B,EAAE,YAAY,eAClD,OAAO,kCAAkC,EAAE,oBAAoB,WAC/D,iBAAiB,eACjB,aAAa,QACb,QAAQ,GACN,QAAQ,GAAC,IAAI,CAuazB;kCA3biC,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"}