@woosh/meep-engine 3.52.0 → 3.53.0

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

@@ -0,0 +1,150 @@
+import { clamp } from "../../../core/math/clamp.js";
+import { lerp } from "../../../core/math/lerp.js";
+import { smoothStep } from "../../../core/math/smoothStep.js";
+import { geometry_obtain_attribute } from "../../../shade/renderer/geometry/geometry_obtain_attribute.js";
+import { StandardAttributes } from "../../../shade/renderer/geometry/StandardAttributes.js";
+
+/**
+ * Computes analytic volumetric crown ambient occlusion (combining normalized crown-shell depth
+ * and vertical sky exposure) into `StandardAttributes.Color` (`vec3<f32>`), and optionally
+ * applies hemisphere-safe normal puffing (`dot(n_puffed, n_orig) >= 0.55`) onto `StandardAttributes.Normal`.
+ *
+ * @param {import("../../../shade/renderer/geometry/Geometry.js").Geometry} geometry
+ * @param {ArrayLike<number>} crown_center `[cx, cy, cz]`
+ * @param {ArrayLike<number>} crown_radii `[rx, ry, rz]`
+ * @param {Object} [options]
+ * @param {number} [options.ao_core_darkening=0.35]
+ * @param {number} [options.normal_puffiness=0.0]
+ * @param {boolean} [options.preserve_existing_color=true]
+ */
+export function tree_mesh_apply_canopy_ao(
+    geometry,
+    crown_center,
+    crown_radii,
+    options = {}
+) {
+    const pos_attr = geometry.getAttribute(StandardAttributes.Position);
+    if (!pos_attr || pos_attr.count === 0) {
+        return;
+    }
+
+    const vertex_count = pos_attr.count;
+    const positions = pos_attr.data;
+
+    const existing_color = geometry.getAttribute(StandardAttributes.Color);
+    const has_existing = Boolean(existing_color && existing_color.count === vertex_count && options.preserve_existing_color !== false);
+    const colors = geometry_obtain_attribute(geometry, StandardAttributes.Color, 3, vertex_count);
+    if (!has_existing) {
+        colors.fill(1.0);
+    }
+
+    const ao_core_darkening = clamp(options.ao_core_darkening ?? 0.35, 0.0, 0.85);
+    const normal_puffiness = clamp(options.normal_puffiness ?? 0.0, 0.0, 0.85);
+
+    const cx = crown_center[0] ?? 0.0;
+    const cy = crown_center[1] ?? 5.0;
+    const cz = crown_center[2] ?? 0.0;
+
+    const rx = Math.max(0.25, crown_radii[0] ?? 4.0);
+    const ry = Math.max(0.25, crown_radii[1] ?? 4.0);
+    const rz = Math.max(0.25, crown_radii[2] ?? 4.0);
+
+    const inv_rx = 1.0 / rx;
+    const inv_ry = 1.0 / ry;
+    const inv_rz = 1.0 / rz;
+
+    const norm_attr = geometry.getAttribute(StandardAttributes.Normal);
+    const normals = norm_attr && norm_attr.count === vertex_count ? norm_attr.data : null;
+
+    for (let v = 0; v < vertex_count; v++) {
+        const idx = v * 3;
+        const px = positions[idx];
+        const py = positions[idx + 1];
+        const pz = positions[idx + 2];
+
+        const dx = (px - cx) * inv_rx;
+        const dy = (py - cy) * inv_ry;
+        const dz = (pz - cz) * inv_rz;
+
+        const rho = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        const shell_t = smoothStep(0.0, 1.05, rho);
+        const ao_shell = lerp(1.0 - ao_core_darkening, 1.0, shell_t);
+
+        const h_norm = clamp((py - (cy - ry)) / (2.0 * ry), 0.0, 1.0);
+        const ao_sky = 0.82 + 0.18 * h_norm;
+
+        const ao = clamp(ao_shell * ao_sky, 0.18, 1.0);
+
+        colors[idx] = clamp(colors[idx] * ao, 0.0, 1.0);
+        colors[idx + 1] = clamp(colors[idx + 1] * ao, 0.0, 1.0);
+        colors[idx + 2] = clamp(colors[idx + 2] * ao, 0.0, 1.0);
+
+        if (normals !== null && normal_puffiness > 0.0) {
+            const nx0 = normals[idx];
+            const ny0 = normals[idx + 1];
+            const nz0 = normals[idx + 2];
+
+            // Outward ellipsoid gradient
+            let gx = dx * inv_rx;
+            let gy = dy * inv_ry + 0.25 * inv_ry; // Slight upward bias toward sky
+            let gz = dz * inv_rz;
+            const g_len = Math.sqrt(gx * gx + gy * gy + gz * gz);
+            if (g_len > 1e-6) {
+                gx /= g_len;
+                gy /= g_len;
+                gz /= g_len;
+
+                // Ensure outward gradient stays in the same hemisphere as the original vertex normal
+                const dot_orig_g = nx0 * gx + ny0 * gy + nz0 * gz;
+                if (dot_orig_g < 0.0) {
+                    // Project gradient onto tangent plane of original normal so we never invert the card hemisphere
+                    gx -= dot_orig_g * nx0;
+                    gy -= dot_orig_g * ny0;
+                    gz -= dot_orig_g * nz0;
+                    const p_len = Math.sqrt(gx * gx + gy * gy + gz * gz);
+                    if (p_len > 1e-6) {
+                        gx /= p_len;
+                        gy /= p_len;
+                        gz /= p_len;
+                    } else {
+                        gx = nx0;
+                        gy = ny0;
+                        gz = nz0;
+                    }
+                }
+
+                let pnx = lerp(nx0, gx, normal_puffiness);
+                let pny = lerp(ny0, gy, normal_puffiness);
+                let pnz = lerp(nz0, gz, normal_puffiness);
+                const pn_len = Math.sqrt(pnx * pnx + pny * pny + pnz * pnz);
+                if (pn_len > 1e-8) {
+                    pnx /= pn_len;
+                    pny /= pn_len;
+                    pnz /= pn_len;
+                }
+
+                // Enforce hemisphere guard dot(n_puffed, n_orig) >= 0.55
+                const dot_final = pnx * nx0 + pny * ny0 + pnz * nz0;
+                if (dot_final < 0.55) {
+                    pnx = lerp(nx0, pnx, 0.45);
+                    pny = lerp(ny0, pny, 0.45);
+                    pnz = lerp(nz0, pnz, 0.45);
+                    const f_len = Math.sqrt(pnx * pnx + pny * pny + pnz * pnz);
+                    if (f_len > 1e-8) {
+                        pnx /= f_len;
+                        pny /= f_len;
+                        pnz /= f_len;
+                    }
+                }
+
+                normals[idx] = pnx;
+                normals[idx + 1] = pny;
+                normals[idx + 2] = pnz;
+            }
+        }
+    }
+
+    if (norm_attr) {
+        norm_attr.needsUpdate = true;
+    }
+}

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

@@ -0,0 +1,55 @@
+/**
+ * Helper to obtain a `Uint16Array` attribute on `Geometry` for `StandardAttributes.SkinningJoints`.
+ * @param {Geometry} geometry
+ * @param {number} count vertex count
+ * @returns {Uint16Array}
+ */
+export function geometry_obtain_joints_attribute(geometry: Geometry, count: number): Uint16Array;
+/**
+ * Sweeps the Cubic Hermite branch spines of a `TreeSkeleton` into a single manifold, seamless-UV
+ * bark `Geometry` with root buttress lobes, longitudinal bark flutes, welded lateral branch collars,
+ * canopy ambient occlusion, and 4-joint skeletal wind skinning attributes.
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {TreeSpeciesConfig} [config]
+ * @param {TreeLODConfig} [lod_config]
+ * @param {import("../../../shade/renderer/geometry/Geometry.js").Geometry} [out]
+ * @returns {Geometry}
+ */
+export function tree_mesh_build_bark(skeleton: import("../skeleton/TreeSkeleton.js").TreeSkeleton, config?: TreeSpeciesConfig, lod_config?: TreeLODConfig, out?: import("../../../shade/renderer/geometry/Geometry.js").Geometry, only_rings?: boolean): Geometry;
+/**
+ * Computes the meshed cross-sectional ring centroids, radii, polygon vertex counts, and 4-slot
+ * skinning weights for every retained branch in `skeleton` using the exact same ring synthesis as
+ * `tree_mesh_build_bark`.
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {TreeSpeciesConfig} [config]
+ * @param {TreeLODConfig} [lod_config]
+ * @returns {Map<number, Array<{
+ *   cx: number, cy: number, cz: number,
+ *   r: number, m: number, t_norm: number, flute_amp: number,
+ *   j0: number, j1: number, j2: number, j3: number,
+ *   w0: number, w1: number, w2: number, w3: number
+ * }>>}
+ */
+export function tree_mesh_compute_branch_rings(skeleton: import("../skeleton/TreeSkeleton.js").TreeSkeleton, config?: TreeSpeciesConfig, lod_config?: TreeLODConfig): Map<number, Array<{
+    cx: number;
+    cy: number;
+    cz: number;
+    r: number;
+    m: number;
+    t_norm: number;
+    flute_amp: number;
+    j0: number;
+    j1: number;
+    j2: number;
+    j3: number;
+    w0: number;
+    w1: number;
+    w2: number;
+    w3: number;
+}>>;
+import { Geometry } from "../../../shade/renderer/geometry/Geometry.js";
+import { TreeSpeciesConfig } from "../config/TreeSpeciesConfig.js";
+import { TreeLODConfig } from "../config/TreeLODConfig.js";
+//# sourceMappingURL=tree_mesh_build_bark.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tree_mesh_build_bark.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_mesh_build_bark.js"],"names":[],"mappings":"AAmDA;;;;;GAKG;AACH,2DAJW,QAAQ,SACR,MAAM,GACJ,WAAW,CAevB;AAED;;;;;;;;;;GAUG;AACH,+CANW,OAAO,6BAA6B,EAAE,YAAY,WAClD,iBAAiB,eACjB,aAAa,QACb,OAAO,8CAA8C,EAAE,QAAQ,yBAC7D,QAAQ,CA86BpB;AAED;;;;;;;;;;;;;;GAcG;AACH,yDAVW,OAAO,6BAA6B,EAAE,YAAY,WAClD,iBAAiB,eACjB,aAAa,GACX,IAAI,MAAM,EAAE,MAAM;IAC9B,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IACvC,CAAK,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAC5D,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IACnD,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAC/C,CAAC,CAAC,CAQL;yBAlhCwB,8CAA8C;kCAQrC,gCAAgC;8BADpC,4BAA4B"}