@woosh/meep-engine 3.61.0 → 3.61.2

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

@@ -72,9 +72,55 @@ const RING = {
     /** @type {import("../config/BranchGeneratorConfig.js").BranchGeneratorConfig|null} */
     lvl_cfg: null,
     collars: [],
-    knots: []
+    knots: [],
+    active_collars: [],
+    active_collar_theta: [],
+    active_knots: [],
+    active_knot_theta: [],
+    is_circle: false
 };
 
+function ring_prepare(ring) {
+    const ac = ring.active_collars;
+    const act = ring.active_collar_theta;
+    ac.length = 0;
+    act.length = 0;
+    const rx = ring.rx, ry = ring.ry, rz = ring.rz;
+    const sx = ring.sx, sy = ring.sy, sz = ring.sz;
+    const t_norm = ring.t_norm;
+    if (ring.collar_amp > 1e-4) {
+        const collars = ring.collars;
+        for (let i = 0; i < collars.length; i++) {
+            const cc = collars[i];
+            if (Math.abs(t_norm - cc.t_c) < 3.2 * cc.sigma_t) {
+                ac.push(cc);
+                act.push(Math.atan2(
+                    cc.tx_c * sx + cc.ty_c * sy + cc.tz_c * sz,
+                    cc.tx_c * rx + cc.ty_c * ry + cc.tz_c * rz
+                ));
+            }
+        }
+    }
+    const ak = ring.active_knots;
+    const akt = ring.active_knot_theta;
+    ak.length = 0;
+    akt.length = 0;
+    if (ring.knot_scale > 0.05) {
+        const knots = ring.knots;
+        for (let i = 0; i < knots.length; i++) {
+            const kn = knots[i];
+            if (Math.abs(t_norm - kn.t_k) < 3.2 * kn.sigma_t) {
+                ak.push(kn);
+                akt.push(Math.atan2(
+                    kn.tx_k * sx + kn.ty_k * sy + kn.tz_k * sz,
+                    kn.tx_k * rx + kn.ty_k * ry + kn.tz_k * rz
+                ));
+            }
+        }
+    }
+    ring.is_circle = !(ring.flare_env > 0.0) && !(ring.flute_env > 1e-5) && !(ring.oval_ecc > 1e-4) && ac.length === 0 && ak.length === 0;
+}
+
 /**
  * The collars of the branches `b` carries, where each joins it: a boss on its bark, and the grain flowing round it.
  *
@@ -160,6 +206,14 @@ function circle_sides(r, tolerance) {
  * @type {number}
  */
 const BARK_REFERENCE_SIDES = 64;
+const REF_THETA = new Float64Array(BARK_REFERENCE_SIDES);
+const REF_COS = new Float64Array(BARK_REFERENCE_SIDES);
+const REF_SIN = new Float64Array(BARK_REFERENCE_SIDES);
+for (let j = 0; j < BARK_REFERENCE_SIDES; j++) {
+    REF_THETA[j] = PI2 * j / BARK_REFERENCE_SIDES;
+    REF_COS[j] = Math.cos(REF_THETA[j]);
+    REF_SIN[j] = Math.sin(REF_THETA[j]);
+}
 
 /**
  * Fills {@link RING} for the candidate ring `c` of a plan's arrays.
@@ -183,19 +237,18 @@ function plan_fill_ring(plan, c, lvl_cfg, collars, knots) {
     RING.lvl_cfg = lvl_cfg;
     RING.collars = collars;
     RING.knots = knots;
+    ring_prepare(RING);
 }
 
 /**
  * Point of candidate ring `c` at angle `theta`, into `out` at `o`: its spine point plus its shaped radius along the
  * ring's radial direction. {@link RING} must hold the ring.
  */
-function plan_ring_point(out, o, plan, c, theta) {
-    bark_ring_shape(SCRATCH_SHAPE, theta, RING);
+function plan_ring_point(out, o, plan, c, theta, cos_t = Math.cos(theta), sin_t = Math.sin(theta)) {
+    bark_ring_shape(SCRATCH_SHAPE, theta, RING, cos_t, sin_t);
     // the weld's symmetric flare on the rings after the first
     const r_mult = SCRATCH_SHAPE[0] + (c > 0 ? plan.weld[c] * 0.18 : 0.0);
     const r = plan.radius[c] * Math.max(0.25, r_mult);
-    const cos_t = Math.cos(theta);
-    const sin_t = Math.sin(theta);
     out[o] = plan.points[c * 3] + r * (cos_t * RING.rx + sin_t * RING.sx);
     out[o + 1] = plan.points[c * 3 + 1] + r * (cos_t * RING.ry + sin_t * RING.sy);
     out[o + 2] = plan.points[c * 3 + 2] + r * (cos_t * RING.rz + sin_t * RING.sz);
@@ -209,7 +262,8 @@ function point_segment_distance(p, po, a, ao, b, bo) {
     const apx = p[po] - a[ao], apy = p[po + 1] - a[ao + 1], apz = p[po + 2] - a[ao + 2];
     const len2 = abx * abx + aby * aby + abz * abz;
     const t = len2 > 0 ? clamp((apx * abx + apy * aby + apz * abz) / len2, 0, 1) : 0;
-    return Math.hypot(apx - t * abx, apy - t * aby, apz - t * abz);
+    const dx = apx - t * abx, dy = apy - t * aby, dz = apz - t * abz;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
 }
 
 /**
@@ -370,8 +424,26 @@ function bark_plan_rings(skeleton, b, lvl_cfg, nodes, edges, collars, knots, wel
     const measured = new Float64Array(C * M * 3);
     for (let c = 0; c < C; c++) {
         plan_fill_ring(plan, c, lvl_cfg, collars, knots);
-        for (let j = 0; j < M; j++) {
-            plan_ring_point(measured, (c * M + j) * 3, plan, c, PI2 * j / M);
+        if (M === BARK_REFERENCE_SIDES && RING.is_circle) {
+            const r = plan.radius[c] * Math.max(0.25, 1.0 + (c > 0 ? plan.weld[c] * 0.18 : 0.0));
+            const px = plan.points[c * 3], py = plan.points[c * 3 + 1], pz = plan.points[c * 3 + 2];
+            const rx = RING.rx, ry = RING.ry, rz = RING.rz, sx = RING.sx, sy = RING.sy, sz = RING.sz;
+            const base = c * M * 3;
+            for (let j = 0; j < M; j++) {
+                const cos_t = REF_COS[j], sin_t = REF_SIN[j];
+                const o = base + j * 3;
+                measured[o] = px + r * (cos_t * rx + sin_t * sx);
+                measured[o + 1] = py + r * (cos_t * ry + sin_t * sy);
+                measured[o + 2] = pz + r * (cos_t * rz + sin_t * sz);
+            }
+        } else if (M === BARK_REFERENCE_SIDES) {
+            for (let j = 0; j < M; j++) {
+                plan_ring_point(measured, (c * M + j) * 3, plan, c, REF_THETA[j], REF_COS[j], REF_SIN[j]);
+            }
+        } else {
+            for (let j = 0; j < M; j++) {
+                plan_ring_point(measured, (c * M + j) * 3, plan, c, PI2 * j / M);
+            }
         }
     }
 
@@ -411,18 +483,27 @@ function bark_plan_rings(skeleton, b, lvl_cfg, nodes, edges, collars, knots, wel
     for (let c = 0; c < C; c++) {
         if (!keep[c]) continue;
         plan_fill_ring(plan, c, lvl_cfg, collars, knots);
+        polygon[0] = measured[c * M * 3];
+        polygon[1] = measured[c * M * 3 + 1];
+        polygon[2] = measured[c * M * 3 + 2];
         let sides = 3;
         for (; sides < M; sides++) {
-            for (let k = 0; k <= sides; k++) {
-                plan_ring_point(polygon, k * 3, plan, c, PI2 * (k % sides) / sides);
+            plan_ring_point(polygon, 3, plan, c, PI2 / sides);
+            plan_ring_point(SCRATCH_PLAN_MID, 0, plan, c, PI2 * 0.5 / sides);
+            if (point_segment_distance(SCRATCH_PLAN_MID, 0, polygon, 0, polygon, 3) > tolerance) continue;
+            for (let k = 2; k < sides; k++) {
+                plan_ring_point(polygon, k * 3, plan, c, PI2 * k / sides);
             }
+            polygon[sides * 3] = polygon[0];
+            polygon[sides * 3 + 1] = polygon[1];
+            polygon[sides * 3 + 2] = polygon[2];
             let within = true;
             for (let j = 0; j < M && within; j++) {
                 const k = Math.floor(j * sides / M);
                 within = point_segment_distance(measured, (c * M + j) * 3, polygon, k * 3, polygon, (k + 1) * 3) <= tolerance;
             }
             // a chord strays furthest from the wood at its middle
-            for (let k = 0; k < sides && within; k++) {
+            for (let k = 1; k < sides && within; k++) {
                 plan_ring_point(SCRATCH_PLAN_MID, 0, plan, c, PI2 * (k + 0.5) / sides);
                 within = point_segment_distance(SCRATCH_PLAN_MID, 0, polygon, k * 3, polygon, (k + 1) * 3) <= tolerance;
             }
@@ -445,14 +526,19 @@ function bark_plan_rings(skeleton, b, lvl_cfg, nodes, edges, collars, knots, wel
  * @param {number} theta
  * @param {RING} ring
  */
-function bark_ring_shape(out, theta, ring) {
+function bark_ring_shape(out, theta, ring, cos_t = Math.cos(theta), sin_t = Math.sin(theta)) {
+    if (ring.is_circle) {
+        out[0] = 1.0;
+        out[1] = 0.0;
+        out[2] = 0.0;
+        out[3] = 1.0;
+        return;
+    }
     const lvl_cfg = ring.lvl_cfg;
-    const rx = ring.rx, ry = ring.ry, rz = ring.rz;
-    const sx = ring.sx, sy = ring.sy, sz = ring.sz;
+    const ry = ring.ry;
+    const sy = ring.sy;
     const t_norm = ring.t_norm;
     const unwelded = ring.unwelded;
-    const cos_t = Math.cos(theta);
-    const sin_t = Math.sin(theta);
     const n_rad_y = cos_t * ry + sin_t * sy;
     const tan_theta_y = -sin_t * ry + cos_t * sy;
 
@@ -490,64 +576,52 @@ function bark_ring_shape(out, theta, ring) {
     }
 
     // 3. Parent-stem branch collar swelling bosses & UV grain streamline deflection around child branches
-    const collars = ring.collars;
+    const collars = ring.active_collars;
+    const collar_thetas = ring.active_collar_theta;
     const parent_collar_amp = ring.collar_amp;
-    if (parent_collar_amp > 1e-4 && collars.length > 0) {
-        for (let c_idx = 0; c_idx < collars.length; c_idx++) {
-            const cc = collars[c_idx];
-            const dt = t_norm - cc.t_c;
-            if (Math.abs(dt) < 3.2 * cc.sigma_t) {
-                const theta_c = Math.atan2(
-                    cc.tx_c * sx + cc.ty_c * sy + cc.tz_c * sz,
-                    cc.tx_c * rx + cc.ty_c * ry + cc.tz_c * rz
-                );
-                const dtheta = Math.atan2(Math.sin(theta - theta_c), Math.cos(theta - theta_c));
-                const sig_t = dt < 0.0 ? cc.sigma_t * 1.25 : cc.sigma_t * 0.90;
-                const u_t = dt / sig_t;
-                const u_th = dtheta / cc.sigma_theta;
-                const dist2 = u_t * u_t + u_th * u_th;
-                if (dist2 < 9.0) {
-                    const gauss = Math.exp(-0.5 * dist2);
-                    const b_amp = parent_collar_amp * (0.55 + 0.75 * cc.r_ratio);
-                    r_mult += b_amp * gauss;
-                    d_rmult_dtheta += -b_amp * gauss * (u_th / cc.sigma_theta);
-                    const r_uv2 = dist2 + 0.85;
-                    u_warp += 0.008 * unwelded * (u_th / r_uv2) * Math.exp(-0.35 * dist2);
-                }
-            }
+    for (let c_idx = 0; c_idx < collars.length; c_idx++) {
+        const cc = collars[c_idx];
+        const dt = t_norm - cc.t_c;
+        const theta_c = collar_thetas[c_idx];
+        const dtheta = Math.atan2(Math.sin(theta - theta_c), Math.cos(theta - theta_c));
+        const sig_t = dt < 0.0 ? cc.sigma_t * 1.25 : cc.sigma_t * 0.90;
+        const u_t = dt / sig_t;
+        const u_th = dtheta / cc.sigma_theta;
+        const dist2 = u_t * u_t + u_th * u_th;
+        if (dist2 < 9.0) {
+            const gauss = Math.exp(-0.5 * dist2);
+            const b_amp = parent_collar_amp * (0.55 + 0.75 * cc.r_ratio);
+            r_mult += b_amp * gauss;
+            d_rmult_dtheta += -b_amp * gauss * (u_th / cc.sigma_theta);
+            const r_uv2 = dist2 + 0.85;
+            u_warp += 0.008 * unwelded * (u_th / r_uv2) * Math.exp(-0.35 * dist2);
         }
     }
 
     // 4. Branch scars: volcanic callus rims + UV grain streamline deflection
-    const knots = ring.knots;
+    const knots = ring.active_knots;
+    const knot_thetas = ring.active_knot_theta;
     const knot_scale = ring.knot_scale;
-    if (knot_scale > 0.05 && knots.length > 0) {
-        for (let k_idx = 0; k_idx < knots.length; k_idx++) {
-            const kn = knots[k_idx];
-            const dt = t_norm - kn.t_k;
-            if (Math.abs(dt) < 3.2 * kn.sigma_t) {
-                const theta_k = Math.atan2(
-                    kn.tx_k * sx + kn.ty_k * sy + kn.tz_k * sz,
-                    kn.tx_k * rx + kn.ty_k * ry + kn.tz_k * rz
-                );
-                const dtheta = Math.atan2(Math.sin(theta - theta_k), Math.cos(theta - theta_k));
-                const u_t = dt / kn.sigma_t;
-                const u_th = dtheta / kn.sigma_theta;
-                const rho2 = u_t * u_t + u_th * u_th;
-                if (rho2 < 9.0) {
-                    const k_amp = kn.amp_k * knot_scale;
-                    const exp_r = Math.exp(-0.85 * rho2);
-                    const w_rim = (0.30 + 1.90 * rho2) * exp_r;
-                    const dw_drho2 = (1.90 - 0.85 * (0.30 + 1.90 * rho2)) * exp_r;
-                    r_mult += k_amp * w_rim;
-                    d_rmult_dtheta += k_amp * dw_drho2 * (2.0 * u_th / kn.sigma_theta);
-                    if (rho2 < 0.65) {
-                        vert_ao *= (0.72 + 0.28 * (rho2 / 0.65));
-                    }
-                    const r_uv2 = rho2 + 0.85;
-                    u_warp += 0.009 * unwelded * (u_th / r_uv2) * Math.exp(-0.35 * rho2);
-                }
+    for (let k_idx = 0; k_idx < knots.length; k_idx++) {
+        const kn = knots[k_idx];
+        const dt = t_norm - kn.t_k;
+        const theta_k = knot_thetas[k_idx];
+        const dtheta = Math.atan2(Math.sin(theta - theta_k), Math.cos(theta - theta_k));
+        const u_t = dt / kn.sigma_t;
+        const u_th = dtheta / kn.sigma_theta;
+        const rho2 = u_t * u_t + u_th * u_th;
+        if (rho2 < 9.0) {
+            const k_amp = kn.amp_k * knot_scale;
+            const exp_r = Math.exp(-0.85 * rho2);
+            const w_rim = (0.30 + 1.90 * rho2) * exp_r;
+            const dw_drho2 = (1.90 - 0.85 * (0.30 + 1.90 * rho2)) * exp_r;
+            r_mult += k_amp * w_rim;
+            d_rmult_dtheta += k_amp * dw_drho2 * (2.0 * u_th / kn.sigma_theta);
+            if (rho2 < 0.65) {
+                vert_ao *= (0.72 + 0.28 * (rho2 / 0.65));
             }
+            const r_uv2 = rho2 + 0.85;
+            u_warp += 0.009 * unwelded * (u_th / r_uv2) * Math.exp(-0.35 * rho2);
         }
     }
 
@@ -704,13 +778,13 @@ export function tree_mesh_build_bark(
     }
 
     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, total_indices);
+    const normals = only_rings ? null : geometry_obtain_attribute(out, StandardAttributes.Normal, 3, total_vertices);
+    const uv0 = only_rings ? null : geometry_obtain_attribute(out, StandardAttributes.TextureCoordinates0, 2, total_vertices);
+    const uv1 = only_rings ? null : geometry_obtain_attribute(out, StandardAttributes.TextureCoordinates1, 2, total_vertices);
+    const colors = only_rings ? null : geometry_obtain_attribute(out, StandardAttributes.Color, 3, total_vertices);
+    const joints = only_rings ? null : geometry_obtain_joints_attribute(out, total_vertices);
+    const weights = only_rings ? null : geometry_obtain_attribute(out, StandardAttributes.SkinningWeights, 4, total_vertices);
+    const indices = only_rings ? null : geometry_obtain_index(out, total_indices);
 
     if (is_empty_fallback) {
         // Populate valid non-degenerate fallback quad so ensureTangents() and MeshoptClusterizer always succeed
@@ -1057,6 +1131,7 @@ export function tree_mesh_build_bark(
             RING.lvl_cfg = lvl_cfg;
             RING.collars = child_collars;
             RING.knots = branch_knots;
+            ring_prepare(RING);
 
             for (let j = 0; j <= m_i; j++) {
                 // Ensure exact periodic closure between j=0 and j=m_i
@@ -1076,7 +1151,7 @@ export function tree_mesh_build_bark(
                 const tan_theta_z = -sin_t * rz + cos_t * sz;
 
                 // The ring's smooth shape at theta (lobes, flutes, ovalization, collar bosses, knots), then its bark relief
-                bark_ring_shape(SCRATCH_SHAPE, theta, RING);
+                bark_ring_shape(SCRATCH_SHAPE, theta, RING, cos_t, sin_t);
                 let r_mult = SCRATCH_SHAPE[0];
                 let d_rmult_dtheta = SCRATCH_SHAPE[1];
                 let u_warp = SCRATCH_SHAPE[2];
@@ -1163,36 +1238,38 @@ export function tree_mesh_build_bark(
                 }
 
                 const v3 = v_cursor * 3;
-                const v2 = v_cursor * 2;
-                const v4 = v_cursor * 4;
-
                 positions[v3] = vx;
                 positions[v3 + 1] = vy;
                 positions[v3 + 2] = vz;
 
-                normals[v3] = vnx;
-                normals[v3 + 1] = vny;
-                normals[v3 + 2] = vnz;
+                if (!only_rings) {
+                    const v2 = v_cursor * 2;
+                    const v4 = v_cursor * 4;
+
+                    normals[v3] = vnx;
+                    normals[v3 + 1] = vny;
+                    normals[v3 + 2] = vnz;
 
-                uv0[v2] = k_wrap * (j / m_i) + twist_uv * arc_s + u_warp;
-                uv0[v2 + 1] = v_base;
+                    uv0[v2] = k_wrap * (j / m_i) + twist_uv * arc_s + u_warp;
+                    uv0[v2 + 1] = v_base;
 
-                uv1[v2] = wind_sway;
-                uv1[v2 + 1] = wind_phase;
+                    uv1[v2] = wind_sway;
+                    uv1[v2 + 1] = wind_phase;
 
-                colors[v3] = vert_ao;
-                colors[v3 + 1] = vert_ao;
-                colors[v3 + 2] = vert_ao;
+                    colors[v3] = vert_ao;
+                    colors[v3 + 1] = vert_ao;
+                    colors[v3 + 2] = vert_ao;
 
-                joints[v4] = ring_j0;
-                joints[v4 + 1] = ring_j1;
-                joints[v4 + 2] = ring_j2;
-                joints[v4 + 3] = ring_j3;
+                    joints[v4] = ring_j0;
+                    joints[v4 + 1] = ring_j1;
+                    joints[v4 + 2] = ring_j2;
+                    joints[v4 + 3] = ring_j3;
 
-                weights[v4] = ring_w0;
-                weights[v4 + 1] = ring_w1;
-                weights[v4 + 2] = ring_w2;
-                weights[v4 + 3] = ring_w3;
+                    weights[v4] = ring_w0;
+                    weights[v4 + 1] = ring_w1;
+                    weights[v4 + 2] = ring_w2;
+                    weights[v4 + 3] = ring_w3;
+                }
 
                 v_cursor++;
             }
@@ -1253,7 +1330,7 @@ export function tree_mesh_build_bark(
                 w3: ring_w3
             });
 
-            if (prev_ring_start >= 0) {
+            if (!only_rings && prev_ring_start >= 0) {
                 i_cursor = branch_ring_triangulate(
                     indices,
                     i_cursor,
@@ -1302,6 +1379,10 @@ export function tree_mesh_build_bark(
         // living branch, a flat break on a dead stub
         const apex_start = v_cursor;
         const m_tip = prev_m;
+        if (only_rings) {
+            v_cursor += m_tip;
+            continue;
+        }
         const apex_height = skeleton.branch_dead[b] ? 0.0 : SHOOT_BUD_HEIGHT;
         const cap_ext = tip_r * apex_height;
         const cap_arc_s = tip_arc_s + cap_ext;

package/src/generation/foliage/skeleton/ShootLightField.d.ts

@@ -78,5 +78,6 @@ export class ShootLightField {
      * @returns {number}
      */
     irradiance_at(x: number, y: number, z: number): number;
+    #private;
 }
 //# sourceMappingURL=ShootLightField.d.ts.map

package/src/generation/foliage/skeleton/ShootLightField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShootLightField.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/ShootLightField.js"],"names":[],"mappings":"AA+DA;;;;;;GAMG;AACH;IACI;;;;OAIG;IACH,iBAJW,UAAU,MAAM,CAAC,OACjB,UAAU,MAAM,CAAC,QACjB,MAAM,EAqBhB;IAjBG,aAAgB;IAChB,kBAAiC;IACjC,WAA0D;IAC1D,WAA0D;IAC1D,WAA0D;IAE1D;;;OAGG;IACH,WAFU,YAAY,CAEc;IACpC;;;OAGG;IACH,YAFU,YAAY,CAEuB;IAC7C,4BAAwC;IAG5C;;OAEG;IACH,cAEC;IAED;;;;;;OAMG;IACH,SALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;OAMG;IACH,WALW,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,QAKhB;IAED;;;;;OAKG;IACH,mBAJW,UAAU,MAAM,CAAC,KACjB,UAAU,MAAM,CAAC,QACjB,MAAM,QAUhB;IAED;;;;OAIG;IACH,gBAFW,MAAM,QAiChB;IAED;;;;;;;OAOG;IACH,iBALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAClC,MAAM,KACN,MAAM,KACN,MAAM,QAiBhB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;CACJ"}
+{"version":3,"file":"ShootLightField.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/ShootLightField.js"],"names":[],"mappings":"AAiEA;;;;;;GAMG;AACH;IAQI;;;;OAIG;IACH,iBAJW,UAAU,MAAM,CAAC,OACjB,UAAU,MAAM,CAAC,QACjB,MAAM,EAqBhB;IAjBG,aAAgB;IAChB,kBAAiC;IACjC,WAA0D;IAC1D,WAA0D;IAC1D,WAA0D;IAE1D;;;OAGG;IACH,WAFU,YAAY,CAEc;IACpC;;;OAGG;IACH,YAFU,YAAY,CAEuB;IAC7C,4BAAwC;IAG5C;;OAEG;IACH,cAeC;IAED;;;;;;OAMG;IACH,SALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;OAMG;IACH,WALW,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,QAgBhB;IAED;;;;;OAKG;IACH,mBAJW,UAAU,MAAM,CAAC,KACjB,UAAU,MAAM,CAAC,QACjB,MAAM,QAUhB;IAED;;;;OAIG;IACH,gBAFW,MAAM,QAuEhB;IAED;;;;;;;OAOG;IACH,iBALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAClC,MAAM,KACN,MAAM,KACN,MAAM,QAiBhB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;;CACJ"}

package/src/generation/foliage/skeleton/ShootLightField.js

@@ -61,6 +61,8 @@ const SKY_WEIGHTS = (() => {
     return w;
 })();
 
+const OPEN_SKY = SKY_WEIGHTS.reduce((s, w) => s + w, 0);
+
 /**
  * Light inside a crown from its own leaves: leaf area deposited in a voxel grid, and the relative irradiance each
  * voxel receives from a standard overcast sky through the leaf area between it and the sky, by Beer-Lambert,
@@ -69,6 +71,13 @@ const SKY_WEIGHTS = (() => {
  * The cost of {@link solve} is the grid's cells times its 17 sky directions, whatever the leaf count.
  */
 export class ShootLightField {
+    #min_i = Infinity;
+    #max_i = -1;
+    #min_j = Infinity;
+    #max_j = -1;
+    #min_k = Infinity;
+    #max_k = -1;
+
     /**
      * @param {ArrayLike<number>} min world corner of the grid
      * @param {ArrayLike<number>} max opposite corner
@@ -99,7 +108,20 @@ export class ShootLightField {
      * Removes all leaf area.
      */
     clear() {
-        this.leaf_area.fill(0);
+        if (this.#max_j < 0) return;
+        const { nx, nz, leaf_area } = this;
+        for (let j = this.#min_j; j <= this.#max_j; j++) {
+            for (let k = this.#min_k; k <= this.#max_k; k++) {
+                const row = (j * nz + k) * nx;
+                leaf_area.fill(0, row + this.#min_i, row + this.#max_i + 1);
+            }
+        }
+        this.#min_i = Infinity;
+        this.#max_i = -1;
+        this.#min_j = Infinity;
+        this.#max_j = -1;
+        this.#min_k = Infinity;
+        this.#max_k = -1;
     }
 
     /**
@@ -125,8 +147,19 @@ export class ShootLightField {
      * @param {number} area
      */
     deposit(x, y, z, area) {
-        const v = this.voxel(x, y, z);
-        if (v >= 0) this.leaf_area[v] += area;
+        const i = Math.floor((x - this.min[0]) / this.cell);
+        const j = Math.floor((y - this.min[1]) / this.cell);
+        const k = Math.floor((z - this.min[2]) / this.cell);
+        if (i < 0 || j < 0 || k < 0 || i >= this.nx || j >= this.ny || k >= this.nz) return;
+        this.leaf_area[(j * this.nz + k) * this.nx + i] += area;
+        if (area > 0) {
+            if (i < this.#min_i) this.#min_i = i;
+            if (i > this.#max_i) this.#max_i = i;
+            if (j < this.#min_j) this.#min_j = j;
+            if (j > this.#max_j) this.#max_j = j;
+            if (k < this.#min_k) this.#min_k = k;
+            if (k > this.#max_k) this.#max_k = k;
+        }
     }
 
     /**
@@ -151,33 +184,71 @@ export class ShootLightField {
      * @param {number} clumping
      */
     solve(clumping) {
-        const { nx, ny, nz, cell } = this;
-        const k_ext = SPHERICAL_LEAF_PROJECTION * clamp(clumping, 0, 1);
-        const volume = cell * cell * cell;
+        const { nx, nz, cell } = this;
         const irradiance = this.irradiance;
         const transmittance = this.transmittance;
         const leaf_area = this.leaf_area;
-        irradiance.fill(0);
+        const max_j = this.#max_j;
+        irradiance.fill(OPEN_SKY);
+        if (max_j < 0) return;
+
+        const min_i = this.#min_i, max_i = this.#max_i;
+        const min_k = this.#min_k, max_k = this.#max_k;
+        for (let j = max_j; j >= 0; j--) {
+            const fall = max_j - j;
+            const k0 = Math.max(0, min_k - 2 * fall), k1 = Math.min(nz - 1, max_k + 2 * fall);
+            const i0 = Math.max(0, min_i - 2 * fall), i1 = Math.min(nx - 1, max_i + 2 * fall);
+            for (let k = k0; k <= k1; k++) {
+                const row = (j * nz + k) * nx;
+                irradiance.fill(0, row + i0, row + i1 + 1);
+            }
+        }
+
+        const k_ext = SPHERICAL_LEAF_PROJECTION * clamp(clumping, 0, 1);
+        const volume = cell * cell * cell;
         for (let d = 0; d < SKY_DIRECTIONS.length; d++) {
             const [dx, dy, dz] = SKY_DIRECTIONS[d];
             const step = Math.hypot(dx, dy, dz) * cell;
             const w = SKY_WEIGHTS[d];
             // a voxel sees the sky through the voxel one step towards it, which was swept the row before
-            for (let j = ny - 1; j >= 0; j--) {
+            for (let j = max_j; j >= 0; j--) {
+                const fall = max_j - j;
+                const k0 = Math.max(0, min_k - 2 * fall), k1 = Math.min(nz - 1, max_k + 2 * fall);
+                const i0 = Math.max(0, min_i - 2 * fall), i1 = Math.min(nx - 1, max_i + 2 * fall);
+                const dk0 = dz < 0 ? min_k : Math.max(0, min_k - dz * fall);
+                const dk1 = dz > 0 ? max_k : Math.min(nz - 1, max_k - dz * fall);
+                const di0 = dx < 0 ? min_i : Math.max(0, min_i - dx * fall);
+                const di1 = dx > 0 ? max_i : Math.min(nx - 1, max_i - dx * fall);
+                const up_fall = fall - 1;
+                const uk0 = up_fall >= 0 ? (dz < 0 ? min_k : Math.max(0, min_k - dz * up_fall)) : nz;
+                const uk1 = up_fall >= 0 ? (dz > 0 ? max_k : Math.min(nz - 1, max_k - dz * up_fall)) : -1;
+                const ui0 = up_fall >= 0 ? (dx < 0 ? min_i : Math.max(0, min_i - dx * up_fall)) : nx;
+                const ui1 = up_fall >= 0 ? (dx > 0 ? max_i : Math.min(nx - 1, max_i - dx * up_fall)) : -1;
                 const j1 = j + dy;
-                for (let k = 0; k < nz; k++) {
-                    const k1 = k + dz;
-                    for (let i = 0; i < nx; i++) {
-                        const i1 = i + dx;
-                        const v = (j * nz + k) * nx + i;
+                for (let k = k0; k <= k1; k++) {
+                    const row = (j * nz + k) * nx;
+                    if (k < dk0 || k > dk1) {
+                        for (let i = i0; i <= i1; i++) irradiance[row + i] += w;
+                        continue;
+                    }
+                    for (let i = i0; i < di0; i++) irradiance[row + i] += w;
+                    const k1_idx = k + dz;
+                    const k_in = k1_idx >= uk0 && k1_idx <= uk1;
+                    const u_row = (j1 * nz + k1_idx) * nx;
+                    for (let i = di0; i <= di1; i++) {
+                        const i1_idx = i + dx;
+                        const v = row + i;
                         let t = 1.0;
-                        if (j1 < ny && k1 >= 0 && k1 < nz && i1 >= 0 && i1 < nx) {
-                            const u = (j1 * nz + k1) * nx + i1;
-                            t = transmittance[u] * Math.exp(-k_ext * (leaf_area[u] / volume) * step);
+                        if (k_in && i1_idx >= ui0 && i1_idx <= ui1) {
+                            const u = u_row + i1_idx;
+                            const lu = leaf_area[u];
+                            t = lu > 0 ? transmittance[u] * Math.exp(-k_ext * (lu / volume) * step) : transmittance[u];
                         }
                         transmittance[v] = t;
-                        irradiance[v] += w * t * Math.exp(-k_ext * (leaf_area[v] / volume) * step * 0.5);
+                        const lv = leaf_area[v];
+                        irradiance[v] += lv > 0 ? w * t * Math.exp(-k_ext * (lv / volume) * step * 0.5) : w * t;
                     }
+                    for (let i = di1 + 1; i <= i1; i++) irradiance[row + i] += w;
                 }
             }
         }

package/src/generation/foliage/skeleton/ShootWoodHash.d.ts

@@ -3,7 +3,7 @@
  * wood, and thinner wood that thicker wood has grown into can be found. A unit is added once, when it has grown, under
  * the cells its axis line crosses; a query reads every unit's place and radius from its axis as they are then, and
  * reaches as far round as the thickest wood ({@link max_radius}), so wood that thickens needs no re-adding. The units
- * of an axis that has died are passed over.
+ * of an axis that has died are passed over, and leave the hash at the next {@link refresh}.
  */
 export class ShootWoodHash {
     /**
@@ -26,8 +26,10 @@ export class ShootWoodHash {
         radii: number[];
         units: number[];
     }>);
-    /** @type {Map<number, number[]>} */
-    cells: Map<number, number[]>;
+    /** @type {Map<number, number[] & {max?: number}>} */
+    cells: Map<number, number[] & {
+        max?: number;
+    }>;
     /**
      * Thickest living unit (m) in each cell as of the last {@link refresh}, a unit added since counting as infinitely
      * thick, so a query that wants only wood at least so thick can pass a cell by.
@@ -69,7 +71,8 @@ export class ShootWoodHash {
     add(m: number, k: number): void;
     /**
      * Records each cell's thickest living unit, after the wood has thickened, and the thickest of all
-     * ({@link max_radius}).
+     * ({@link max_radius}). A dead axis does not live again, so its units leave their cells, in the order the rest
+     * were added, and a cell left empty leaves the hash.
      */
     refresh(): void;
     /**
@@ -85,5 +88,6 @@ export class ShootWoodHash {
      * @returns {number}
      */
     hits(a: ArrayLike<number>, b: ArrayLike<number>, radius: number, min_radius: number, skip: (arg0: number, arg1: number, arg2: number, arg3: number) => boolean): number;
+    #private;
 }
 //# sourceMappingURL=ShootWoodHash.d.ts.map

package/src/generation/foliage/skeleton/ShootWoodHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShootWoodHash.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/ShootWoodHash.js"],"names":[],"mappings":"AAwBA;;;;;;GAMG;AACH;IA8FI;;;;;;OAMG;IACH,uBALW;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAC,KAClC,MAAM,KACN,MAAM,GACJ,MAAM,CAMlB;IApED;;OAEG;IACH,kBAFW,MAAM;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC,EAIrF;IAzCD,oCAAoC;IACpC,OADW,IAAI,MAAM,EAAE,MAAM,EAAE,CAAC,CACd;IAElB;;;;OAIG;IACH,UAFU,IAAI,MAAM,EAAE,MAAM,CAAC,CAER;IAErB;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,WAFU,MAAM,EAAE,CAEH;IAEf;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEF;IAEhB;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IAEV,cAAU;IAMN;eAHqB,OAAO;gBAAU,MAAM,EAAE;eAAS,MAAM,EAAE;eAAS,MAAM,EAAE;QAGhE;IAGpB;;;;OAIG;IACH,OAHW,MAAM,KACN,MAAM,QAsBhB;IAED;;;OAGG;IACH,gBAiBC;IAeD;;;;;;;;;;;OAWG;IACH,QAPW,UAAU,MAAM,CAAC,KACjB,UAAU,MAAM,CAAC,UACjB,MAAM,cACN,MAAM,eACG,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,OAAO,GAC/C,MAAM,CA6ClB;CACJ"}
+{"version":3,"file":"ShootWoodHash.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/ShootWoodHash.js"],"names":[],"mappings":"AAiCA;;;;;;GAMG;AACH;IA0LI;;;;;;OAMG;IACH,uBALW;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAC,KAClC,MAAM,KACN,MAAM,GACJ,MAAM,CAMlB;IAvHD;;OAEG;IACH,kBAFW,MAAM;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC,EAIrF;IAlFD,qDAAqD;IACrD,OADW,IAAI,MAAM,EAAE,MAAM,EAAE,GAAG;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,CAC/B;IAElB;;;;OAIG;IACH,UAFU,IAAI,MAAM,EAAE,MAAM,CAAC,CAER;IAErB;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,WAFU,MAAM,EAAE,CAEH;IAEf;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEF;IAEhB;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IAEV,cAAU;IA+CN;eAHqB,OAAO;gBAAU,MAAM,EAAE;eAAS,MAAM,EAAE;eAAS,MAAM,EAAE;QAGhE;IAGpB;;;;OAIG;IACH,OAHW,MAAM,KACN,MAAM,QA8ChB;IAED;;;;OAIG;IACH,gBA2CC;IAeD;;;;;;;;;;;OAWG;IACH,QAPW,UAAU,MAAM,CAAC,KACjB,UAAU,MAAM,CAAC,UACjB,MAAM,cACN,MAAM,eACG,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,OAAO,GAC/C,MAAM,CAqIlB;;CACJ"}