@woosh/meep-engine 3.55.0 → 3.57.0

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

@@ -0,0 +1,48 @@
+/**
+ * Linearly interpolate 4-slot skinning joints and weights between two bark
+ * rings `ra` (weight `1 - xi`) and `rb` (weight `xi`), deduplicating joint IDs,
+ * sorting descending by weight, and keeping 4.
+ *
+ * When more than 4 joints meet, each one dropped hands its weight to the kept joint that carries the point most alike
+ * in the reference wind (the heavier on a tie), and the four kept are those that leave the point least far from where
+ * all of them would carry it: the sum over the dropped of weight times how far apart it and its heir carry the point.
+ * A light joint that moves the point far from the rest may matter more than a heavier one beside it.
+ *
+ * @param {number[]|Uint16Array|Int32Array} out_joints
+ * @param {number} out_j_offset
+ * @param {number[]|Float32Array|Float64Array} out_weights
+ * @param {number} out_w_offset
+ * @param {{j0:number, j1:number, j2:number, j3:number, w0:number, w1:number, w2:number, w3:number}} ra
+ * @param {{j0:number, j1:number, j2:number, j3:number, w0:number, w1:number, w2:number, w3:number}} rb
+ * @param {number} xi interpolation factor in `[0, 1]`
+ * @param {{parents: Int32Array, pivots: Float32Array, rotation: Float32Array}} motion the joints' parents (`-1` for the
+ * root), pivots and turns in the reference wind (`tree_skeleton_read_joint_motion`)
+ * @param {number} x the point's rest position
+ * @param {number} y
+ * @param {number} z
+ * @returns {number} number of active joints (`0..4`) written before zero padding
+ */
+export function interpolate_ring_skin_weights4(out_joints: number[] | Uint16Array | Int32Array, out_j_offset: number, out_weights: number[] | Float32Array | Float64Array, out_w_offset: number, ra: {
+    j0: number;
+    j1: number;
+    j2: number;
+    j3: number;
+    w0: number;
+    w1: number;
+    w2: number;
+    w3: number;
+}, rb: {
+    j0: number;
+    j1: number;
+    j2: number;
+    j3: number;
+    w0: number;
+    w1: number;
+    w2: number;
+    w3: number;
+}, xi: number, motion: {
+    parents: Int32Array;
+    pivots: Float32Array;
+    rotation: Float32Array;
+}, x: number, y: number, z: number): number;
+//# sourceMappingURL=interpolate_ring_skin_weights4.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interpolate_ring_skin_weights4.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/interpolate_ring_skin_weights4.js"],"names":[],"mappings":"AAyDA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,2DAdW,MAAM,EAAE,GAAC,WAAW,GAAC,UAAU,gBAC/B,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,MACN;IAAC,EAAE,EAAC,MAAM,CAAC;IAAC,EAAE,EAAC,MAAM,CAAC;IAAC,EAAE,EAAC,MAAM,CAAC;IAAC,EAAE,EAAC,MAAM,CAAC;IAAC,EAAE,EAAC,MAAM,CAAC;IAAC,EAAE,EAAC,MAAM,CAAC;IAAC,EAAE,EAAC,MAAM,CAAC;IAAC,EAAE,EAAC,MAAM,CAAA;CAAC,MACxF;IAAC,EAAE,EAAC,MAAM,CAAC;IAAC,EAAE,EAAC,MAAM,CAAC;IAAC,EAAE,EAAC,MAAM,CAAC;IAAC,EAAE,EAAC,MAAM,CAAC;IAAC,EAAE,EAAC,MAAM,CAAC;IAAC,EAAE,EAAC,MAAM,CAAC;IAAC,EAAE,EAAC,MAAM,CAAC;IAAC,EAAE,EAAC,MAAM,CAAA;CAAC,MACxF,MAAM,UACN;IAAC,OAAO,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAA;CAAC,KAEnE,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAwJlB"}

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

@@ -0,0 +1,232 @@
+const _merged_j = new Int32Array(8);
+const _merged_w = new Float64Array(8);
+// how far apart merged joints `a` and `b` carry the point, at `a * 8 + b`
+const _apart = new Float64Array(64);
+
+/**
+ * @param {number} x
+ * @returns {number} set bits of `x`
+ */
+function bit_count(x) {
+    let n = 0;
+    for (; x !== 0; x &= x - 1) n++;
+    return n;
+}
+
+/**
+ * How far (m) joint `j` turning in the reference wind moves point `(x, y, z)`: its turn times the lever from its pivot.
+ */
+function joint_moves(motion, j, x, y, z) {
+    const o = j * 3;
+    return motion.rotation[j] * Math.hypot(x - motion.pivots[o], y - motion.pivots[o + 1], z - motion.pivots[o + 2]);
+}
+
+/**
+ * How far apart (m) joints `a` and `b` carry point `(x, y, z)` in the reference wind: every joint between them in
+ * the joint tree turns it, each by its turn times its lever, and none of the joints above both does.
+ *
+ * @param {{parents: Int32Array, pivots: Float32Array, rotation: Float32Array}} motion
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+function joints_apart(motion, a, b, x, y, z) {
+    const parents = motion.parents;
+    let depth_a = 0;
+    for (let j = a; parents[j] >= 0; j = parents[j]) depth_a++;
+    let depth_b = 0;
+    for (let j = b; parents[j] >= 0; j = parents[j]) depth_b++;
+    let apart = 0.0;
+    while (depth_a > depth_b) {
+        apart += joint_moves(motion, a, x, y, z);
+        a = parents[a];
+        depth_a--;
+    }
+    while (depth_b > depth_a) {
+        apart += joint_moves(motion, b, x, y, z);
+        b = parents[b];
+        depth_b--;
+    }
+    while (a !== b) {
+        apart += joint_moves(motion, a, x, y, z) + joint_moves(motion, b, x, y, z);
+        a = parents[a];
+        b = parents[b];
+    }
+    return apart;
+}
+
+/**
+ * Linearly interpolate 4-slot skinning joints and weights between two bark
+ * rings `ra` (weight `1 - xi`) and `rb` (weight `xi`), deduplicating joint IDs,
+ * sorting descending by weight, and keeping 4.
+ *
+ * When more than 4 joints meet, each one dropped hands its weight to the kept joint that carries the point most alike
+ * in the reference wind (the heavier on a tie), and the four kept are those that leave the point least far from where
+ * all of them would carry it: the sum over the dropped of weight times how far apart it and its heir carry the point.
+ * A light joint that moves the point far from the rest may matter more than a heavier one beside it.
+ *
+ * @param {number[]|Uint16Array|Int32Array} out_joints
+ * @param {number} out_j_offset
+ * @param {number[]|Float32Array|Float64Array} out_weights
+ * @param {number} out_w_offset
+ * @param {{j0:number, j1:number, j2:number, j3:number, w0:number, w1:number, w2:number, w3:number}} ra
+ * @param {{j0:number, j1:number, j2:number, j3:number, w0:number, w1:number, w2:number, w3:number}} rb
+ * @param {number} xi interpolation factor in `[0, 1]`
+ * @param {{parents: Int32Array, pivots: Float32Array, rotation: Float32Array}} motion the joints' parents (`-1` for the
+ * root), pivots and turns in the reference wind (`tree_skeleton_read_joint_motion`)
+ * @param {number} x the point's rest position
+ * @param {number} y
+ * @param {number} z
+ * @returns {number} number of active joints (`0..4`) written before zero padding
+ */
+export function interpolate_ring_skin_weights4(
+    out_joints,
+    out_j_offset,
+    out_weights,
+    out_w_offset,
+    ra,
+    rb,
+    xi,
+    motion,
+    x,
+    y,
+    z
+) {
+    let m_count = 0;
+
+    function accumulate(j_id, w_val) {
+        if (w_val <= 1e-7) return;
+        for (let m = 0; m < m_count; m++) {
+            if (_merged_j[m] === j_id) {
+                _merged_w[m] += w_val;
+                return;
+            }
+        }
+        _merged_j[m_count] = j_id;
+        _merged_w[m_count] = w_val;
+        m_count++;
+    }
+
+    const w_a = 1.0 - xi;
+    const w_b = xi;
+    accumulate(ra.j0, ra.w0 * w_a);
+    accumulate(ra.j1, ra.w1 * w_a);
+    accumulate(ra.j2, ra.w2 * w_a);
+    accumulate(ra.j3, ra.w3 * w_a);
+    accumulate(rb.j0, rb.w0 * w_b);
+    accumulate(rb.j1, rb.w1 * w_b);
+    accumulate(rb.j2, rb.w2 * w_b);
+    accumulate(rb.j3, rb.w3 * w_b);
+
+    // Sort descending by weight
+    for (let a = 0; a < m_count - 1; a++) {
+        for (let b = a + 1; b < m_count; b++) {
+            if (_merged_w[b] > _merged_w[a]) {
+                const tw = _merged_w[a];
+                _merged_w[a] = _merged_w[b];
+                _merged_w[b] = tw;
+                const tj = _merged_j[a];
+                _merged_j[a] = _merged_j[b];
+                _merged_j[b] = tj;
+            }
+        }
+    }
+
+    const top_k = Math.min(4, m_count);
+    if (m_count > 4) {
+        for (let a = 0; a < m_count; a++) {
+            for (let b = a + 1; b < m_count; b++) {
+                const apart = joints_apart(motion, _merged_j[a], _merged_j[b], x, y, z);
+                _apart[a * 8 + b] = apart;
+                _apart[b * 8 + a] = apart;
+            }
+        }
+        // the four kept are those that leave the point least far off: the sum over the dropped of weight times how far
+        // apart it and the nearest kept carry the point, the heavier kept on a tie
+        let best_kept = 0, best_cost = Infinity, best_weight = -Infinity;
+        for (let kept = 0; kept < (1 << m_count); kept++) {
+            if (bit_count(kept) !== 4) continue;
+            let cost = 0.0, weight = 0.0;
+            for (let d = 0; d < m_count; d++) {
+                if ((kept >> d) & 1) {
+                    weight += _merged_w[d];
+                    continue;
+                }
+                let nearest = Infinity;
+                for (let k = 0; k < m_count; k++) {
+                    if ((kept >> k) & 1) nearest = Math.min(nearest, _apart[d * 8 + k]);
+                }
+                cost += _merged_w[d] * nearest;
+            }
+            if (cost < best_cost - 1e-12 || (cost < best_cost + 1e-12 && weight > best_weight)) {
+                best_kept = kept;
+                best_cost = cost;
+                best_weight = weight;
+            }
+        }
+        // each dropped joint hands its weight to the kept joint that carries the point most alike, the heavier on a tie
+        for (let d = 0; d < m_count; d++) {
+            if ((best_kept >> d) & 1) continue;
+            let nearest = -1;
+            for (let k = 0; k < m_count; k++) {
+                if (!((best_kept >> k) & 1)) continue;
+                if (nearest < 0 || _apart[d * 8 + k] < _apart[d * 8 + nearest]
+                    || (_apart[d * 8 + k] === _apart[d * 8 + nearest] && _merged_w[k] > _merged_w[nearest])) {
+                    nearest = k;
+                }
+            }
+            _merged_w[nearest] += _merged_w[d];
+            _merged_w[d] = 0.0;
+        }
+        // move the kept four to the front, in order
+        let s = 0;
+        for (let k = 0; k < m_count; k++) {
+            if (!((best_kept >> k) & 1)) continue;
+            _merged_j[s] = _merged_j[k];
+            _merged_w[s] = _merged_w[k];
+            s++;
+        }
+        // keep the kept four sorted
+        for (let a = 0; a < 3; a++) {
+            for (let b = a + 1; b < 4; b++) {
+                if (_merged_w[b] > _merged_w[a]) {
+                    const tw = _merged_w[a];
+                    _merged_w[a] = _merged_w[b];
+                    _merged_w[b] = tw;
+                    const tj = _merged_j[a];
+                    _merged_j[a] = _merged_j[b];
+                    _merged_j[b] = tj;
+                }
+            }
+        }
+    }
+
+    let w4_sum = 0.0;
+    for (let s = 0; s < top_k; s++) {
+        w4_sum += _merged_w[s];
+    }
+
+    if (w4_sum > 1e-7) {
+        const inv_w4 = 1.0 / w4_sum;
+        for (let s = 0; s < 4; s++) {
+            if (s < top_k) {
+                out_joints[out_j_offset + s] = _merged_j[s];
+                out_weights[out_w_offset + s] = _merged_w[s] * inv_w4;
+            } else {
+                out_joints[out_j_offset + s] = 0;
+                out_weights[out_w_offset + s] = 0.0;
+            }
+        }
+    } else {
+        out_joints[out_j_offset] = 0;
+        out_joints[out_j_offset + 1] = 0;
+        out_joints[out_j_offset + 2] = 0;
+        out_joints[out_j_offset + 3] = 0;
+        out_weights[out_w_offset] = 1.0;
+        out_weights[out_w_offset + 1] = 0.0;
+        out_weights[out_w_offset + 2] = 0.0;
+        out_weights[out_w_offset + 3] = 0.0;
+    }
+
+    return top_k;
+}

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

@@ -1 +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,CAg7BpB;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;yBAphCwB,8CAA8C;kCAQrC,gCAAgC;8BADpC,4BAA4B"}
+{"version":3,"file":"tree_mesh_build_bark.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_mesh_build_bark.js"],"names":[],"mappings":"AA4CA;;;;;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,CA65BpB;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;yBA1/BwB,8CAA8C;kCAOrC,gCAAgC;8BADpC,4BAA4B"}