@woosh/meep-engine 3.55.0 → 3.57.0

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

@@ -0,0 +1,35 @@
+/**
+ * Spatial hash of the framework's segments at their radii when built, so a shoot can be kept from growing through, or
+ * being engulfed by, framework wood. Rebuild it after the framework thickens.
+ */
+export class ShootFrameworkHash {
+    /**
+     * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+     * @param {number} [segment_count] framework segments, `[0, segment_count)`; all by default
+     */
+    constructor(skeleton: import("./TreeSkeleton.js").TreeSkeleton, segment_count?: number);
+    /** @type {Map<number, number[]>} */
+    cells: Map<number, number[]>;
+    skeleton: import("./TreeSkeleton.js").TreeSkeleton;
+    segment_count: number;
+    /**
+     * Query stamp of the last query that met each segment, so each is tested once a query.
+     * @type {Int32Array}
+     */
+    seen: Int32Array;
+    query: number;
+    /**
+     * Whether the capsule from `a` to `b` of radius `radius` runs into a framework segment, other than those of
+     * `exempt_branch` within one segment of `exempt_edge` (the junction it grows from). Radii are the skeleton's now.
+     *
+     * @param {ArrayLike<number>} a
+     * @param {ArrayLike<number>} b
+     * @param {number} radius
+     * @param {number} exempt_branch
+     * @param {number} exempt_edge
+     * @returns {boolean}
+     */
+    hits(a: ArrayLike<number>, b: ArrayLike<number>, radius: number, exempt_branch: number, exempt_edge: number): boolean;
+    #private;
+}
+//# sourceMappingURL=ShootFrameworkHash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShootFrameworkHash.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/ShootFrameworkHash.js"],"names":[],"mappings":"AAwBA;;;GAGG;AACH;IAII;;;OAGG;IACH,sBAHW,OAAO,mBAAmB,EAAE,YAAY,kBACxC,MAAM,EAmBhB;IAxBD,oCAAoC;IACpC,OADW,IAAI,MAAM,EAAE,MAAM,EAAE,CAAC,CACd;IAOd,mDAAwB;IACxB,sBAAkC;IAClC;;;OAGG;IACH,MAFU,UAAU,CAEqB;IACzC,cAAc;IAkElB;;;;;;;;;;OAUG;IACH,QAPW,UAAU,MAAM,CAAC,KACjB,UAAU,MAAM,CAAC,UACjB,MAAM,iBACN,MAAM,eACN,MAAM,GACJ,OAAO,CAQnB;;CACJ"}

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

@@ -0,0 +1,129 @@
+import { line3_compute_segment_segment_closest_points } from "../../../core/geom/3d/line/line3_compute_segment_segment_closest_points.js";
+
+/**
+ * Edge (m) of a cell of the framework's segment hash.
+ * @type {number}
+ */
+const FRAMEWORK_CELL = 0.25;
+
+/**
+ * Gap (m) a shoot keeps from framework wood.
+ * @type {number}
+ */
+const CLEARANCE = 0.001;
+
+/**
+ * Cells per axis the integer key spans, centred on the origin: 2048 cells of 0.25 m is 512 m.
+ * @type {number}
+ */
+const KEY_SPAN = 2048;
+
+const SCRATCH_ST = new Float64Array(2);
+const SCRATCH_Q0 = new Float32Array(3);
+const SCRATCH_Q1 = new Float32Array(3);
+
+/**
+ * Spatial hash of the framework's segments at their radii when built, so a shoot can be kept from growing through, or
+ * being engulfed by, framework wood. Rebuild it after the framework thickens.
+ */
+export class ShootFrameworkHash {
+    /** @type {Map<number, number[]>} */
+    cells = new Map();
+
+    /**
+     * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+     * @param {number} [segment_count] framework segments, `[0, segment_count)`; all by default
+     */
+    constructor(skeleton, segment_count = skeleton.segment_count) {
+        this.skeleton = skeleton;
+        this.segment_count = segment_count;
+        /**
+         * Query stamp of the last query that met each segment, so each is tested once a query.
+         * @type {Int32Array}
+         */
+        this.seen = new Int32Array(segment_count);
+        this.query = 0;
+        const p0 = new Float32Array(3);
+        const p1 = new Float32Array(3);
+        for (let e = 0; e < segment_count; e++) {
+            skeleton.node_read_position(p0, 0, skeleton.segment_v0(e));
+            skeleton.node_read_position(p1, 0, skeleton.segment_v1(e));
+            const r = Math.max(skeleton.node_read_radius(skeleton.segment_v0(e)), skeleton.node_read_radius(skeleton.segment_v1(e))) + CLEARANCE;
+            this.#each_cell(p0, p1, r, -1, -1, -1, -1, -1, e);
+        }
+    }
+
+    /**
+     * Visits every cell the box around segment `a`-`b` padded by `pad` covers: registers segment `register` in each,
+     * or with `register < 0` tests each cell's segments against the capsule (see {@link hits}).
+     */
+    #each_cell(a, b, pad, radius, exempt_branch, exempt_edge, ev0, ev1, register) {
+        const x0 = Math.floor((Math.min(a[0], b[0]) - pad) / FRAMEWORK_CELL), x1 = Math.floor((Math.max(a[0], b[0]) + pad) / FRAMEWORK_CELL);
+        const y0 = Math.floor((Math.min(a[1], b[1]) - pad) / FRAMEWORK_CELL), y1 = Math.floor((Math.max(a[1], b[1]) + pad) / FRAMEWORK_CELL);
+        const z0 = Math.floor((Math.min(a[2], b[2]) - pad) / FRAMEWORK_CELL), z1 = Math.floor((Math.max(a[2], b[2]) + pad) / FRAMEWORK_CELL);
+        for (let x = x0; x <= x1; x++) for (let y = y0; y <= y1; y++) for (let z = z0; z <= z1; z++) {
+            const key = ((x + KEY_SPAN / 2) * KEY_SPAN + (y + KEY_SPAN / 2)) * KEY_SPAN + (z + KEY_SPAN / 2);
+            if (register >= 0) {
+                let list = this.cells.get(key);
+                if (list === undefined) {
+                    list = [];
+                    this.cells.set(key, list);
+                }
+                list.push(register);
+                continue;
+            }
+            const list = this.cells.get(key);
+            if (list !== undefined && this.#test(list, a, b, radius, exempt_branch, exempt_edge, ev0, ev1)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Whether a cell's segments meet the capsule.
+     */
+    #test(list, a, b, radius, exempt_branch, exempt_edge, ev0, ev1) {
+        const skeleton = this.skeleton;
+        const q0 = SCRATCH_Q0;
+        const q1 = SCRATCH_Q1;
+        for (let i = 0; i < list.length; i++) {
+            const e = list[i];
+            if (this.seen[e] === this.query) continue;
+            this.seen[e] = this.query;
+            const v0 = skeleton.segment_v0(e), v1 = skeleton.segment_v1(e);
+            if (e === exempt_edge || (skeleton.node_branch_id(v1) === exempt_branch
+                && (v0 === ev0 || v0 === ev1 || v1 === ev0 || v1 === ev1))) continue;
+            skeleton.node_read_position(q0, 0, v0);
+            skeleton.node_read_position(q1, 0, v1);
+            line3_compute_segment_segment_closest_points(SCRATCH_ST, a[0], a[1], a[2], b[0], b[1], b[2], q0[0], q0[1], q0[2], q1[0], q1[1], q1[2]);
+            const t = SCRATCH_ST[1];
+            const r = skeleton.node_read_radius(v0) + (skeleton.node_read_radius(v1) - skeleton.node_read_radius(v0)) * t;
+            const sa = SCRATCH_ST[0];
+            const dx = a[0] + (b[0] - a[0]) * sa - (q0[0] + (q1[0] - q0[0]) * t);
+            const dy = a[1] + (b[1] - a[1]) * sa - (q0[1] + (q1[1] - q0[1]) * t);
+            const dz = a[2] + (b[2] - a[2]) * sa - (q0[2] + (q1[2] - q0[2]) * t);
+            if (Math.hypot(dx, dy, dz) < r + radius + CLEARANCE) return true;
+        }
+        return false;
+    }
+
+    /**
+     * Whether the capsule from `a` to `b` of radius `radius` runs into a framework segment, other than those of
+     * `exempt_branch` within one segment of `exempt_edge` (the junction it grows from). Radii are the skeleton's now.
+     *
+     * @param {ArrayLike<number>} a
+     * @param {ArrayLike<number>} b
+     * @param {number} radius
+     * @param {number} exempt_branch
+     * @param {number} exempt_edge
+     * @returns {boolean}
+     */
+    hits(a, b, radius, exempt_branch, exempt_edge) {
+        const skeleton = this.skeleton;
+        const ev0 = exempt_edge >= 0 ? skeleton.segment_v0(exempt_edge) : -1;
+        const ev1 = exempt_edge >= 0 ? skeleton.segment_v1(exempt_edge) : -1;
+        this.query++;
+        return this.#each_cell(a, b, radius, radius, exempt_branch, exempt_edge, ev0, ev1, -1);
+    }
+}

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

@@ -0,0 +1,51 @@
+/**
+ * Makes segment `e` at least `need` thick at `u` along it, where a lateral joins, raising only the node nearer the
+ * junction and only by as much as it takes.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {number} e
+ * @param {number} u
+ * @param {number} need
+ * @returns {boolean} whether a node was raised
+ */
+export function shoot_hold_junction(skeleton: import("./TreeSkeleton.js").TreeSkeleton, e: number, u: number, need: number): boolean;
+/**
+ * Girth of the wood a tree's twig systems grow on, season by season: every axis, every carrier, and the framework that
+ * carries them. Wood only thickens; each season it is at least:
+ * - the pipe model over the current shoots it carries, `r^alpha` the sum of theirs, as `tree_skeleton_compute_pipe_radii`
+ *   treats the framework;
+ * - the diameter [BB2000 Table 7] gives an annual unit of its length and age, `0.27 + 0.13 age + 0.02 l` (cm);
+ * - where a lateral joins, `1 / SHOOT_LATERAL_RADIUS_RATIO` of the lateral's root, as the pipe-model pass holds it.
+ *
+ * Twigs keep their radii on their axes (`radii`); carriers and framework parents are thickened in the skeleton.
+ *
+ * [BB2000]: Buck-Sorlin & Bell (2000), Forestry 73(1): 1-19.
+ */
+export class ShootGirth {
+    /**
+     * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+     * @param {import("./shoot_systems_simulate.js").ShootCarrier[]} carriers
+     * @param {number} framework_count framework branches, `[0, framework_count)`
+     * @param {number} alpha pipe-model exponent
+     */
+    constructor(skeleton: import("./TreeSkeleton.js").TreeSkeleton, carriers: import("./shoot_systems_simulate.js").ShootCarrier[], framework_count: number, alpha: number);
+    skeleton: import("./TreeSkeleton.js").TreeSkeleton;
+    carriers: import("./shoot_systems_simulate.js").ShootCarrier[];
+    alpha: number;
+    framework_order: number[];
+    nodes: any[];
+    edges: any[];
+    /**
+     * Thickens the wood for the load it carries after `season`: the living axes, their carriers, and the framework that
+     * carries those.
+     *
+     * @param {Array<import("./shoot_systems_simulate.js").ShootAxis & {alive: boolean, radii: number[]}>} axes
+     * @param {number} season
+     */
+    update(axes: Array<import("./shoot_systems_simulate.js").ShootAxis & {
+        alive: boolean;
+        radii: number[];
+    }>, season: number): void;
+    #private;
+}
+//# sourceMappingURL=ShootGirth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShootGirth.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/ShootGirth.js"],"names":[],"mappings":"AA2LA;;;;;;;;;GASG;AACH,8CANW,OAAO,mBAAmB,EAAE,YAAY,KACxC,MAAM,KACN,MAAM,QACN,MAAM,GACJ,OAAO,CAgBnB;AA1MD;;;;;;;;;;;GAWG;AACH;IACI;;;;;OAKG;IACH,sBALW,OAAO,mBAAmB,EAAE,YAAY,YACxC,OAAO,6BAA6B,EAAE,YAAY,EAAE,mBACpD,MAAM,SACN,MAAM,EAiBhB;IAdG,mDAAwB;IACxB,+DAAwB;IACxB,cAAkB;IAKlB,0BAA4B;IAC5B,aAAe;IACf,aAAe;IAOnB;;;;;;OAMG;IACH,aAHW,MAAM,OAAO,6BAA6B,EAAE,SAAS,GAAG;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC,UAC1F,MAAM,QAQhB;;CA+HJ"}

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

@@ -0,0 +1,212 @@
+import { clamp } from "../../../core/math/clamp.js";
+import {
+    SHOOT_LATERAL_RADIUS_RATIO,
+    SHOOT_MIN_RADIUS,
+    shoot_locate_on_chain,
+    shoot_radius,
+    shoot_wood_radius
+} from "./shoot_geometry.js";
+
+/**
+ * Girth of the wood a tree's twig systems grow on, season by season: every axis, every carrier, and the framework that
+ * carries them. Wood only thickens; each season it is at least:
+ * - the pipe model over the current shoots it carries, `r^alpha` the sum of theirs, as `tree_skeleton_compute_pipe_radii`
+ *   treats the framework;
+ * - the diameter [BB2000 Table 7] gives an annual unit of its length and age, `0.27 + 0.13 age + 0.02 l` (cm);
+ * - where a lateral joins, `1 / SHOOT_LATERAL_RADIUS_RATIO` of the lateral's root, as the pipe-model pass holds it.
+ *
+ * Twigs keep their radii on their axes (`radii`); carriers and framework parents are thickened in the skeleton.
+ *
+ * [BB2000]: Buck-Sorlin & Bell (2000), Forestry 73(1): 1-19.
+ */
+export class ShootGirth {
+    /**
+     * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+     * @param {import("./shoot_systems_simulate.js").ShootCarrier[]} carriers
+     * @param {number} framework_count framework branches, `[0, framework_count)`
+     * @param {number} alpha pipe-model exponent
+     */
+    constructor(skeleton, carriers, framework_count, alpha) {
+        this.skeleton = skeleton;
+        this.carriers = carriers;
+        this.alpha = alpha;
+        // from the deepest branches up: a split's forks keep their parent's level, and every branch comes after its parent
+        const order = [];
+        for (let b = 0; b < framework_count; b++) order.push(b);
+        order.sort((a, b) => (skeleton.branch_level[b] - skeleton.branch_level[a]) || (b - a));
+        this.framework_order = order;
+        this.nodes = [];
+        this.edges = [];
+        for (const c of carriers) {
+            c.carrier_area = new Float64Array(c.units.length);
+            c.carrier_demand = new Float64Array(c.units.length);
+        }
+    }
+
+    /**
+     * Thickens the wood for the load it carries after `season`: the living axes, their carriers, and the framework that
+     * carries those.
+     *
+     * @param {Array<import("./shoot_systems_simulate.js").ShootAxis & {alive: boolean, radii: number[]}>} axes
+     * @param {number} season
+     */
+    update(axes, season) {
+        this.#axes(axes, season);
+        for (let s = 0; s < this.carriers.length; s++) {
+            this.#carrier(s, axes, season);
+        }
+        this.#framework();
+    }
+
+    /**
+     * Every living axis's node radii, from the tips down; laterals come after their mother, so walking back has a
+     * mother's laterals done first.
+     */
+    #axes(axes, season) {
+        const alpha = this.alpha;
+        for (const c of this.carriers) {
+            c.carrier_area.fill(0);
+            c.carrier_demand.fill(0);
+        }
+        const pipe = new Array(axes.length);
+        const demand_of = new Array(axes.length);
+        for (let m = 0; m < axes.length; m++) {
+            if (!axes[m].alive) continue;
+            const n = axes[m].units.length;
+            pipe[m] = new Float64Array(n + 1);
+            demand_of[m] = new Float64Array(n);
+        }
+        for (let m = axes.length - 1; m >= 0; m--) {
+            const axis = axes[m];
+            if (!axis.alive) continue;
+            const units = axis.units;
+            const n = units.length;
+            const area = pipe[m];
+            area[n] += Math.pow(shoot_wood_radius(units[n - 1], 0), alpha);
+            for (let k = n - 1; k >= 0; k--) area[k] += area[k + 1];
+            const r = axis.radii;
+            while (r.length < n + 1) r.push(0);
+            let demand = 0;
+            for (let k = n; k >= 0; k--) {
+                const unit = Math.min(k, n - 1);
+                // a lateral on the unit below this node, or above it, needs the node thick enough
+                if (k < n) demand = Math.max(demand, demand_of[m][k]);
+                if (k > 0) demand = Math.max(demand, demand_of[m][k - 1]);
+                const aged = shoot_radius(units[unit], Math.max(0, season - axis.unit_seasons[unit]));
+                let rk = Math.max(r[k], SHOOT_MIN_RADIUS, aged, Math.pow(area[k], 1 / alpha), demand);
+                if (k < n) rk = Math.max(rk, r[k + 1]);
+                r[k] = rk;
+            }
+            if (axis.parent >= 0) {
+                if (!axes[axis.parent].alive) continue;
+                pipe[axis.parent][axis.parent_unit] += area[0];
+                demand_of[axis.parent][axis.parent_unit] = Math.max(demand_of[axis.parent][axis.parent_unit], r[0] / SHOOT_LATERAL_RADIUS_RATIO);
+            } else {
+                const c = this.carriers[axis.system];
+                c.carrier_area[axis.parent_unit] += area[0];
+                c.carrier_demand[axis.parent_unit] = Math.max(c.carrier_demand[axis.parent_unit], r[0] / SHOOT_LATERAL_RADIUS_RATIO);
+            }
+        }
+    }
+
+    /**
+     * A carrier's annual units grown by `season` carry what grows on them; the stretch of it not grown yet keeps the
+     * framework's girth.
+     */
+    #carrier(s, axes, season) {
+        const c = this.carriers[s];
+        if (c.rule.zones.length === 0) return;
+        const skeleton = this.skeleton;
+        const alpha = this.alpha;
+        const units = c.units;
+        const grown = Math.min(units.length, season - c.first_season + 1);
+        if (grown <= 0) return;
+        const last = grown - 1;
+        const unit_area = new Float64Array(grown);
+        let area = Math.pow(shoot_wood_radius(units[last], 0), alpha);
+        for (let k = last; k >= 0; k--) {
+            area += c.carrier_area[k];
+            unit_area[k] = area;
+        }
+        const end = c.starts[last] + units[last];
+        const chain = c.nodes;
+        // down to the first node below the oldest unit, which holds up the segment the oldest laterals join
+        for (let i = chain.length - 1; i >= 0; i--) {
+            const v = chain[i];
+            const arc = skeleton.node_t_norm(v) * c.length;
+            if (i < chain.length - 1 && skeleton.node_t_norm(chain[i + 1]) * c.length < c.starts[0]) break;
+            if (arc > end + 1e-6) continue;
+            let k = last;
+            while (k > 0 && arc < c.starts[k]) k--;
+            let demand = 0;
+            for (let j = Math.max(0, k - 1); j <= last; j++) demand = Math.max(demand, c.carrier_demand[j]);
+            const aged = shoot_radius(units[k], Math.max(0, season - (c.first_season + k)));
+            skeleton.node_write_radius(v, Math.max(skeleton.node_read_radius(v), aged, Math.pow(unit_area[k], 1 / alpha), demand));
+        }
+        // the radius a lateral sees where it joins is between two nodes: hold it there too
+        for (let m = 0; m < axes.length; m++) {
+            const axis = axes[m];
+            if (!axis.alive || axis.system !== s || axis.parent >= 0) continue;
+            const located = shoot_locate_on_chain(skeleton, c.nodes, c.edges, (c.starts[axis.parent_unit] + axis.u * units[axis.parent_unit]) / c.length);
+            shoot_hold_junction(skeleton, located.edge, located.u, axis.radii[0] / SHOOT_LATERAL_RADIUS_RATIO);
+        }
+        // and the carrier still tapers towards its tip
+        for (let i = chain.length - 2; i >= 0; i--) {
+            const v = chain[i];
+            skeleton.node_write_radius(v, Math.max(skeleton.node_read_radius(v), skeleton.node_read_radius(chain[i + 1])));
+        }
+        skeleton.branch_base_radius[c.carrier] = skeleton.node_read_radius(chain[0]);
+    }
+
+    /**
+     * Every framework branch is held at least `1 / SHOOT_LATERAL_RADIUS_RATIO` of a child's root where the child joins,
+     * deepest branches first so a thickened child passes its girth on down, and still tapers towards its tip.
+     */
+    #framework() {
+        const skeleton = this.skeleton;
+        const nodes = this.nodes, edges = this.edges;
+        const order = this.framework_order;
+        for (let i = 0; i < order.length; i++) {
+            const b = order[i];
+            const p = skeleton.branch_parent[b];
+            const e = skeleton.branch_parent_edge[b];
+            if (p < 0 || e < 0) continue;
+            const need = skeleton.node_read_radius(skeleton.branch_root_vertex[b]) / SHOOT_LATERAL_RADIUS_RATIO;
+            const t0 = skeleton.node_t_norm(skeleton.segment_v0(e));
+            const t1 = skeleton.node_t_norm(skeleton.segment_v1(e));
+            const u = clamp((skeleton.branch_parent_attach_t[b] - t0) / Math.max(1e-6, t1 - t0), 0, 1);
+            if (!shoot_hold_junction(skeleton, e, u, need)) continue;
+            skeleton.collect_branch_chain(p, nodes, edges);
+            for (let k = nodes.length - 2; k >= 0; k--) {
+                skeleton.node_write_radius(nodes[k], Math.max(skeleton.node_read_radius(nodes[k]), skeleton.node_read_radius(nodes[k + 1])));
+            }
+            skeleton.branch_base_radius[p] = skeleton.node_read_radius(nodes[0]);
+        }
+    }
+}
+
+/**
+ * Makes segment `e` at least `need` thick at `u` along it, where a lateral joins, raising only the node nearer the
+ * junction and only by as much as it takes.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {number} e
+ * @param {number} u
+ * @param {number} need
+ * @returns {boolean} whether a node was raised
+ */
+export function shoot_hold_junction(skeleton, e, u, need) {
+    const v0 = skeleton.segment_v0(e);
+    const v1 = skeleton.segment_v1(e);
+    const r0 = skeleton.node_read_radius(v0);
+    const r1 = skeleton.node_read_radius(v1);
+    if (r0 + (r1 - r0) * u >= need) {
+        return false;
+    }
+    if (u < 0.5) {
+        skeleton.node_write_radius(v0, (need - r1 * u) / (1 - u));
+    } else {
+        skeleton.node_write_radius(v1, (need - r0 * (1 - u)) / u);
+    }
+    return true;
+}

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

@@ -0,0 +1,73 @@
+/**
+ * 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,
+ * `exp(-G Omega LAD path)` per direction. 1 under open sky.
+ *
+ * The cost of {@link solve} is the grid's cells times its 17 sky directions, whatever the leaf count.
+ */
+export class ShootLightField {
+    /**
+     * @param {ArrayLike<number>} min world corner of the grid
+     * @param {ArrayLike<number>} max opposite corner
+     * @param {number} cell edge of a voxel (m)
+     */
+    constructor(min: ArrayLike<number>, max: ArrayLike<number>, cell: number);
+    cell: number;
+    min: Float64Array;
+    nx: number;
+    ny: number;
+    nz: number;
+    /**
+     * One-sided leaf area in each voxel (m^2).
+     * @type {Float64Array}
+     */
+    leaf_area: Float64Array;
+    /**
+     * Relative irradiance at each voxel's centre, after {@link solve}.
+     * @type {Float64Array}
+     */
+    irradiance: Float64Array;
+    transmittance: Float64Array;
+    /**
+     * Removes all leaf area.
+     */
+    clear(): void;
+    /**
+     * Index of the voxel holding a point, or -1 outside the grid.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number}
+     */
+    voxel(x: number, y: number, z: number): number;
+    /**
+     * Adds `area` of leaf (m^2) at a point. Leaf outside the grid shades nothing.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} area
+     */
+    deposit(x: number, y: number, z: number, area: number): void;
+    /**
+     * Adds `area` of leaf spread evenly along the segment from `a` to `b`.
+     * @param {ArrayLike<number>} a
+     * @param {ArrayLike<number>} b
+     * @param {number} area
+     */
+    deposit_segment(a: ArrayLike<number>, b: ArrayLike<number>, area: number): void;
+    /**
+     * Relative irradiance at every voxel from the leaf area deposited, with leaf clumping `clumping` (`Omega`, 1 for
+     * leaves spread at random within a voxel). A voxel's own leaf shades its centre over half a step.
+     * @param {number} clumping
+     */
+    solve(clumping: number): void;
+    /**
+     * Relative irradiance at a point, 1 outside the grid.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number}
+     */
+    irradiance_at(x: number, y: number, z: number): number;
+}
+//# sourceMappingURL=ShootLightField.d.ts.map

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

@@ -0,0 +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;;;;;;OAMG;IACH,iBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;CACJ"}