@woosh/meep-engine 2.126.42 → 2.126.44

package/package.json

@@ -5,7 +5,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.126.42",
+  "version": "2.126.44",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.d.ts

@@ -2,9 +2,9 @@
  *
  * @param {number[]} result
  * @param {number} result_offset
- * @param {number} constrained_planes_mask if bit is set to 1, that plane is not allowed to move
+ * @param {number} plane_mask if bit is set to 0, that plane is not allowed to move
  * @param {BVH} bvh
  * @param {number[]|ArrayLike<number>|Float32Array} frustum
  */
-export function compute_tight_near_far_clipping_planes(result: number[], result_offset: number, constrained_planes_mask: number, bvh: BVH, frustum: number[] | ArrayLike<number> | Float32Array): boolean;
+export function compute_tight_near_far_clipping_planes(result: number[], result_offset: number, plane_mask: number, bvh: BVH, frustum: number[] | ArrayLike<number> | Float32Array): boolean;
 //# sourceMappingURL=compute_tight_near_far_clipping_planes.d.ts.map

package/src/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_tight_near_far_clipping_planes.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.js"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH,+DANW,MAAM,EAAE,iBACR,MAAM,2BACN,MAAM,OACN,GAAG,WACH,MAAM,EAAE,GAAC,SAAS,CAAC,MAAM,CAAC,GAAC,YAAY,WAuIjD"}
+{"version":3,"file":"compute_tight_near_far_clipping_planes.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.js"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH,+DANW,MAAM,EAAE,iBACR,MAAM,cACN,MAAM,OACN,GAAG,WACH,MAAM,EAAE,GAAC,SAAS,CAAC,MAAM,CAAC,GAAC,YAAY,WA+LjD"}

package/src/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.js

@@ -1,28 +1,39 @@
-//
-
-
 import { array_copy } from "../../../collection/array/array_copy.js";
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { aabb3_array_intersects_frustum_degree } from "../../../geom/3d/aabb/aabb3_array_intersects_frustum_degree.js";
 import { v3_distance_above_plane } from "../../../geom/vec3/v3_distance_above_plane.js";
 import { NULL_NODE } from "../BVH.js";
-import { bvh_collect_user_data } from "./bvh_collect_user_data.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 const scratch_aabb = [];
 
+const scratch_frustum = new Float32Array(24);
+
 /**
  *
  * @param {number[]} result
  * @param {number} result_offset
- * @param {number} constrained_planes_mask if bit is set to 1, that plane is not allowed to move
+ * @param {number} plane_mask if bit is set to 0, that plane is not allowed to move
  * @param {BVH} bvh
  * @param {number[]|ArrayLike<number>|Float32Array} frustum
  */
-export function compute_tight_near_far_clipping_planes(result, result_offset, constrained_planes_mask, bvh, frustum) {
+export function compute_tight_near_far_clipping_planes(
+    result,
+    result_offset,
+    plane_mask,
+    bvh,
+    frustum
+) {
+
     // initialize result
-    array_copy(frustum, 0, result, result_offset, 24);
+    array_copy(frustum, 0, scratch_frustum, 0, 24);
+
+    // set output planes to infinity so we can slowly bring them in
+    for (let i = 0; i < 6; i++) {
+        if (((plane_mask >> i) & 1) === 1) {
+            scratch_frustum[i * 4 + 3] = Infinity;
+        }
+    }
 
     const root = bvh.root;
 
@@ -68,13 +79,19 @@ export function compute_tight_near_far_clipping_planes(result, result_offset, co
         const _z1 = scratch_aabb[5];
 
         for (let plane_index = 0; plane_index < 6; plane_index++) {
+
+            if (((plane_mask >> plane_index) & 1) === 1) {
+                // plane is not fixed, we're done here
+                continue;
+            }
+
             const plane_address = plane_index * 4;
 
             //read out plane
-            const plane_normal_x = frustum[plane_address];
-            const plane_normal_y = frustum[plane_address + 1];
-            const plane_normal_z = frustum[plane_address + 2];
-            const plane_offset = frustum[plane_address + 3];
+            const plane_normal_x = scratch_frustum[plane_address];
+            const plane_normal_y = scratch_frustum[plane_address + 1];
+            const plane_normal_z = scratch_frustum[plane_address + 2];
+            const plane_offset = scratch_frustum[plane_address + 3];
 
 
             // construct nearest and farthest corners along the plane normal
@@ -112,45 +129,81 @@ export function compute_tight_near_far_clipping_planes(result, result_offset, co
                 continue node_loop;
             }
 
-            if ((constrained_planes_mask & (1 << plane_index)) !== 0) {
-                // plane is constrained, we're done here
-                continue;
-            }
-
-            //
-
         }
 
-        const intersection = aabb3_array_intersects_frustum_degree(scratch_aabb, 0, frustum);
-
-        if (intersection === 0) {
-            // fully outside
-            continue;
-        }
 
         const node_is_leaf = bvh.node_is_leaf(node);
 
         if (!node_is_leaf) {
 
-            if (intersection === 2) {
-                // fully inside, fast collection path
-                result_cursor += bvh_collect_user_data(result, result_cursor, bvh, node);
-            } else {
-                // partially inside
-                // read in-order
-                const child1 = bvh.node_get_child1(node);
-                const child2 = bvh.node_get_child2(node);
-
-                // write to stack in reverse order, so that fist child ends up being visited first
-                stack[stack.pointer++] = child1;
-                stack[stack.pointer++] = child2;
-            }
+            // inside
+            // read in-order
+            const child1 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
+
+            // write to stack in reverse order, so that fist child ends up being visited first
+            stack[stack.pointer++] = child1;
+            stack[stack.pointer++] = child2;
 
         } else {
+
             // leaf node
 
+            // update planes
+            for (let i = 0; i < 6; i++) {
+                if (((plane_mask >> i) & 1) === 1) {
+
+                    const plane_address = i * 4;
+
+                    //read out plane
+                    const plane_normal_x = scratch_frustum[plane_address];
+                    const plane_normal_y = scratch_frustum[plane_address + 1];
+                    const plane_normal_z = scratch_frustum[plane_address + 2];
+                    const plane_offset = scratch_frustum[plane_address + 3];
+
+
+                    // construct nearest and farthest corners along the plane normal
+                    if (plane_normal_x > 0) {
+                        x0 = _x0;
+                        x1 = _x1;
+                    } else {
+                        x0 = _x1;
+                        x1 = _x0;
+                    }
+
+                    if (plane_normal_y > 0) {
+                        y0 = _y0;
+                        y1 = _y1;
+                    } else {
+                        y0 = _y1;
+                        y1 = _y0;
+                    }
+
+                    if (plane_normal_z > 0) {
+                        z0 = _z0;
+                        z1 = _z1;
+                    } else {
+                        z0 = _z1;
+                        z1 = _z0;
+                    }
+
+                    const distance_above_plane = v3_distance_above_plane(
+                        x1, y1, z1,
+                        plane_normal_x, plane_normal_y, plane_normal_z, 0
+                    );
+
+                    if (distance_above_plane < plane_offset) {
+                        // move plane
+                        scratch_frustum[plane_address + 3] = distance_above_plane;
+                    }
+                }
+            }
+
         }
     }
 
-    return true;
+    // TODO check if results are still at infinity
+
+    array_copy(scratch_frustum, 0, result, result_offset, 24);
+
 }

package/src/core/math/spline/spline3_hermite_derivative.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns the first-order partial derivative of a hermite curve with control points p0, m0, p1, m1 at the parameter t in [0,1].
+ *
+ * @param {number} t
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} m0
+ * @param {number} m1
+ * @returns {number}
+ */
+export function spline3_hermite_derivative(t: number, p0: number, p1: number, m0: number, m1: number): number;
+//# sourceMappingURL=spline3_hermite_derivative.d.ts.map

package/src/core/math/spline/spline3_hermite_derivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spline3_hermite_derivative.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_derivative.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,8CAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAclB"}

package/src/core/math/spline/spline3_hermite_derivative.js

@@ -0,0 +1,23 @@
+/**
+ * Returns the first-order partial derivative of a hermite curve with control points p0, m0, p1, m1 at the parameter t in [0,1].
+ *
+ * @param {number} t
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} m0
+ * @param {number} m1
+ * @returns {number}
+ */
+export function spline3_hermite_derivative(t, p0, p1, m0, m1) {
+
+    // see https://github.com/krishauser/Klampt/blob/0ed16608a3eceee59d04383a17c207ebc33a399f/Python/klampt/math/spline.py#L22
+
+    const t2 = t * t
+    const dcx1 = (6.0 * t2 - 6.0 * t)
+    const dcx2 = (-6.0 * t2 + 6.0 * t)
+    const dcv1 = 3.0 * t2 - 4.0 * t + 1.0
+    const dcv2 = 3.0 * t2 - 2.0 * t
+
+    return dcx1 * p0 + dcx2 * p1 + dcv1 * m0 + dcv2 * m1
+
+}

package/src/core/math/spline/spline3_hermite_subdivide.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Subdivides a hermite curve into two hermite curves.
+ * The result is written in form [a_p0, a_p1, a_m0, a_m1, b_p0, b_p1, b_m0, b_m1], note the stride and offset.
+ * @param {number[]} output where to write the result
+ * @param {number} output_offset where to start writing
+ * @param {number} output_stride what should be the step between result values, useful when working in higher dimensions. Typically, this will be 1.
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} m0 tangent at p0
+ * @param {number} m1 tangent at p1
+ * @param {number} [t=0.5] where to split, normalized position, must be value between 0 and 1
+ */
+export function spline3_hermite_subdivide(output: number[], output_offset: number, output_stride: number, p0: number, p1: number, m0: number, m1: number, t?: number): void;
+//# sourceMappingURL=spline3_hermite_subdivide.d.ts.map

package/src/core/math/spline/spline3_hermite_subdivide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spline3_hermite_subdivide.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_subdivide.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,kDATW,MAAM,EAAE,iBACR,MAAM,iBACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA+BhB"}

package/src/core/math/spline/spline3_hermite_subdivide.js

@@ -0,0 +1,46 @@
+import { assert } from "../../assert.js";
+import { spline3_hermite } from "./spline3_hermite.js";
+import { spline3_hermite_derivative } from "./spline3_hermite_derivative.js";
+
+/**
+ * Subdivides a hermite curve into two hermite curves.
+ * The result is written in form [a_p0, a_p1, a_m0, a_m1, b_p0, b_p1, b_m0, b_m1], note the stride and offset.
+ * @param {number[]} output where to write the result
+ * @param {number} output_offset where to start writing
+ * @param {number} output_stride what should be the step between result values, useful when working in higher dimensions. Typically, this will be 1.
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} m0 tangent at p0
+ * @param {number} m1 tangent at p1
+ * @param {number} [t=0.5] where to split, normalized position, must be value between 0 and 1
+ */
+export function spline3_hermite_subdivide(
+    output,
+    output_offset,
+    output_stride,
+    p0, p1, m0, m1,
+    t = 0.5
+) {
+    assert.isNonNegativeInteger(output_offset, 'output_offset');
+    assert.isNonNegativeInteger(output_stride, 'output_stride');
+    assert.greaterThanOrEqual(output_stride, 1, 'output_stride must be at least 1');
+
+    // see https://github.com/krishauser/Klampt/blob/0ed16608a3eceee59d04383a17c207ebc33a399f/Python/klampt/math/spline.py#L63
+
+    const xm = spline3_hermite(t, p0, p1, m0, m1);
+    const vm = spline3_hermite_derivative(t, p0, p1, m0, m1);
+
+
+    // first segment
+    output[output_offset] = p0;
+    output[output_offset + output_stride] = xm;
+    output[output_offset + output_stride * 2] = m0 * t;
+    output[output_offset + output_stride * 3] = vm * t;
+
+    // second segment
+    output[output_offset + output_stride * 4] = xm;
+    output[output_offset + output_stride * 5] = p1;
+    output[output_offset + output_stride * 6] = vm * (1 - t);
+    output[output_offset + output_stride * 7] = m1 * (1 - t);
+
+}

package/src/engine/ecs/transform/Transform.js

@@ -2,8 +2,8 @@ import { assert } from "../../../core/assert.js";
 import { allocate_m4 } from "../../../core/geom/3d/mat4/allocate_m4.js";
 import { compose_matrix4_array } from "../../../core/geom/3d/mat4/compose_matrix4_array.js";
 import { decompose_matrix_4_array } from "../../../core/geom/3d/mat4/decompose_matrix_4_array.js";
-import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
 import { M4_IDENTITY } from "../../../core/geom/3d/mat4/M4_IDENTITY.js";
+import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { TransformFlags } from "./TransformFlags.js";

package/src/engine/graphics/geometry/optimization/merge/merge_geometry_hierarchy.js

@@ -2,8 +2,8 @@ import { Group, Matrix4, Mesh } from "three";
 import { mergeBufferGeometries } from "three/examples/jsm/utils/BufferGeometryUtils.js";
 import { array_copy } from "../../../../../core/collection/array/array_copy.js";
 import { HashMap } from "../../../../../core/collection/map/HashMap.js";
-import { m4_multiply } from "../../../../../core/geom/3d/mat4/m4_multiply.js";
 import { M4_IDENTITY } from "../../../../../core/geom/3d/mat4/M4_IDENTITY.js";
+import { m4_multiply } from "../../../../../core/geom/3d/mat4/m4_multiply.js";
 import { StaticMaterialCache } from "../../../../asset/loaders/material/StaticMaterialCache.js";
 import { computeGeometryEquality } from "../../buffered/computeGeometryEquality.js";
 import { computeGeometryHash } from "../../buffered/computeGeometryHash.js";