@woosh/meep-engine 2.47.3 → 2.47.10

package/src/core/{bvh2/aabb3 → geom/3d/aabb}/aabb3_intersects_frustum_degree.js

@@ -1,6 +1,6 @@
 //
 
-import { computeAABB3PlaneSide } from "../../geom/3d/aabb/computeAABB3PlaneSide.js";
+import { aabb3_compute_plane_side } from "./aabb3_compute_plane_side.js";
 
 /**
  *
@@ -20,16 +20,15 @@ export function aabb3_intersects_frustum_degree(
 ) {
 
     let result = 2;
-    let i = 0;
 
-    for (; i < 24; i += 4) {
+    for (let i = 0; i < 24; i += 4) {
 
         const p_x = frustum[i];
         const p_y = frustum[i + 1];
         const p_z = frustum[i + 2];
         const p_w = frustum[i + 3];
 
-        const plane_side = computeAABB3PlaneSide(
+        const plane_side = aabb3_compute_plane_side(
             p_x, p_y, p_z, p_w,
             x0, y0, z0, x1, y1, z1
         );
@@ -38,6 +37,7 @@ export function aabb3_intersects_frustum_degree(
             // completely outside
             return 0;
         } else if (plane_side === 0) {
+            // partially inside - plane intersects AABB
             result = 1;
         }
     }

package/src/core/{bvh2/aabb3 → geom/3d/aabb}/aabb3_intersects_line_segment.js

@@ -1,4 +1,4 @@
-import { fabsf } from "../../math/fabsf.js";
+import { fabsf } from "../../../math/fabsf.js";
 
 /**
  *  http://stackoverflow.com/questions/3106666/intersection-of-line-segment-with-axis-aligned-box-in-c-sharp

package/src/core/geom/3d/aabb/aabb3_intersects_ray.js

@@ -0,0 +1,87 @@
+const fabsf = Math.abs;
+
+/**
+ * NOTES:
+ *      https://web.archive.org/web/20090803054252/http://tog.acm.org/resources/GraphicsGems/gems/RayBox.c
+ *      https://tavianator.com/fast-branchless-raybounding-box-intersections/
+ *      https://gamedev.stackexchange.com/questions/18436/most-efficient-aabb-vs-ray-collision-algorithms
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {boolean}
+ */
+export function aabb3_intersects_ray(
+    x0, y0, z0,
+    x1, y1, z1,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
+
+    // Z Projection
+    const extents_x = (x1 - x0) * 0.5;
+
+    const center_x = x0 + extents_x;
+
+    const diff_x = origin_x - center_x;
+
+
+    if (diff_x * direction_x >= 0.0 && fabsf(diff_x) > extents_x) {
+        return false;
+    }
+
+    // Y projection
+    const extents_y = (y1 - y0) * 0.5;
+
+    const center_y = y0 + extents_y;
+
+    const diff_y = origin_y - center_y;
+
+
+    if (diff_y * direction_y >= 0.0 && fabsf(diff_y) > extents_y) {
+        return false;
+    }
+
+    // Z projection
+    const extents_z = (z1 - z0) * 0.5;
+
+    const center_z = z0 + extents_z;
+
+    const diff_z = origin_z - center_z;
+
+
+    if (diff_z * direction_z >= 0.0 && fabsf(diff_z) > extents_z) {
+        return false;
+    }
+
+    const abs_direction_y = fabsf(direction_y);
+    const abs_direction_z = fabsf(direction_z);
+
+    const f0 = fabsf(direction_y * diff_z - direction_z * diff_y);
+
+    if (f0 > extents_y * abs_direction_z + extents_z * abs_direction_y) {
+        return false;
+    }
+
+    const abs_direction_x = fabsf(direction_x);
+
+    const f1 = fabsf(direction_z * diff_x - direction_x * diff_z);
+
+    if (f1 > extents_x * abs_direction_z + extents_z * abs_direction_x) {
+        return false;
+    }
+
+    const f2 = fabsf(direction_x * diff_y - direction_y * diff_x);
+
+    return f2 <= extents_x * abs_direction_y + extents_y * abs_direction_x;
+}
+

package/src/core/{bvh2/aabb3 → geom/3d/aabb}/aabb3_intersects_ray.spec.js

@@ -1,4 +1,4 @@
-import { seededRandom } from "../../math/random/seededRandom.js";
+import { seededRandom } from "../../../math/random/seededRandom.js";
 import { aabb3_intersects_ray } from "./aabb3_intersects_ray.js";
 
 test.skip("performance raycast", () => {

package/src/core/{bvh2/aabb3 → geom/3d/aabb}/aabb3_intersects_ray_branchless.js

@@ -1,5 +1,5 @@
-import { min2 } from "../../math/min2.js";
-import { max2 } from "../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
+import { max2 } from "../../../math/max2.js";
 
 /**
  * SLOW, don't use in production

package/src/core/{bvh2/aabb3/aabb3_intersect_ray_slab.js → geom/3d/aabb/aabb3_intersects_ray_slab.js}

@@ -1,10 +1,9 @@
-import { min2 } from "../../math/min2.js";
-import { max2 } from "../../math/max2.js";
+import { max3 } from "../../../math/max3.js";
+import { min3 } from "../../../math/min3.js";
 
 /**
- * see: https://tavianator.com/fast-branchless-raybounding-box-intersections-part-2-nans/
+ * @see https://tavianator.com/fast-branchless-raybounding-box-intersections-part-2-nans/
  * NOTE: this solution forgoes consistent handling of NaNs in favor of execution speed
- * FIXME some manual tests have shown deviation in results between this implementation and others. Possible bugs?
  * @param {number} x0
  * @param {number} y0
  * @param {number} z0
@@ -19,7 +18,7 @@ import { max2 } from "../../math/max2.js";
  * @param {number} dirZ
  * @returns {boolean}
  */
-export function aabb3_intersect_ray_slab(
+export function aabb3_intersects_ray_slab(
     x0, y0, z0,
     x1, y1, z1,
     oX, oY, oZ,
@@ -46,28 +45,47 @@ export function aabb3_intersect_ray_slab(
         }
 
      */
-    const dir_inv_x = -dirX;
-    const dir_inv_y = -dirY;
-    const dir_inv_z = -dirZ;
+
+    let tmin_x, tmax_x, tmin_y, tmax_y, tmin_z, tmax_z;
+    const dir_inv_x = 1 / dirX;
+    const dir_inv_y = 1 / dirY;
+    const dir_inv_z = 1 / dirZ;
 
     const t1_x = (x0 - oX) * dir_inv_x;
     const t2_x = (x1 - oX) * dir_inv_x;
 
-    const tMin_x = min2(t1_x, t2_x);
-    const tMax_x = max2(t1_x, t2_x);
-
     const t1_y = (y0 - oY) * dir_inv_y;
     const t2_y = (y1 - oY) * dir_inv_y;
 
-    const tMin_y = max2(tMin_x, min2(t1_y, t2_y));
-    const tMax_y = min2(tMax_x, max2(t1_y, t2_y));
-
     const t1_z = (z0 - oZ) * dir_inv_z;
     const t2_z = (z1 - oZ) * dir_inv_z;
 
-    const tMin_z = max2(tMin_y, min2(t1_z, t2_z));
-    const tMax_z = min2(tMax_y, max2(t1_z, t2_z));
+
+    if (t1_x > t2_x) {
+        tmin_x = t2_x;
+        tmax_x = t1_x;
+    } else {
+        tmin_x = t1_x;
+        tmax_x = t2_x;
+    }
+    if (t1_y > t2_y) {
+        tmin_y = t2_y;
+        tmax_y = t1_y;
+    } else {
+        tmin_y = t1_y;
+        tmax_y = t2_y;
+    }
+    if (t1_z > t2_z) {
+        tmin_z = t2_z;
+        tmax_z = t1_z;
+    } else {
+        tmin_z = t1_z;
+        tmax_z = t2_z;
+    }
+
+    const tmin = max3(tmin_x, tmin_y, tmin_z);
+    const tmax = min3(tmax_x, tmax_y, tmax_z);
 
 
-    return tMax_z > max2(tMin_z, 0.0);
+    return tmax >= tmin;
 }

package/src/core/geom/3d/aabb/aabb3_matrix4_project_by_corners.js

@@ -6,7 +6,11 @@ import { assert } from "../../../assert.js";
  * @param {number[]|Float32Array|Float64Array} aabb_corners
  * @param {number[]|Float32Array|mat4} projection_matrix
  */
-export function aabb3_matrix4_project_by_corners(result, aabb_corners, projection_matrix) {
+export function aabb3_matrix4_project_by_corners(
+    result,
+    aabb_corners,
+    projection_matrix
+) {
     assert.greaterThanOrEqual(result.length, 6, 'result.length must >= 6');
     assert.greaterThanOrEqual(aabb_corners.length, 24, 'aabb_corners.length must >= 24');
     assert.greaterThanOrEqual(projection_matrix.length, 16, 'projection_matrix.length must >= 16');

package/src/core/{bvh2/aabb3 → geom/3d/aabb}/aabb3_nearest_point_on_surface.js

@@ -1,5 +1,5 @@
-import { clamp } from "../../math/clamp.js";
-import { min2 } from "../../math/min2.js";
+import { clamp } from "../../../math/clamp.js";
+import { min2 } from "../../../math/min2.js";
 
 //
 

package/src/core/geom/3d/aabb/aabb3_raycast.js

@@ -0,0 +1,103 @@
+//
+
+
+import { min2 } from "../../../math/min2.js";
+import { max2 } from "../../../math/max2.js";
+
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} result hit 6-tuple is written here as follows: [hit_position_x, hit_position_y, hit_position_z, hit_normal_x, hit_normal_y, hit_normal_z]
+ * @param {number} result_offset offset into result array where to write the hit data
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} origin_x ray origin
+ * @param {number} origin_y ray origin
+ * @param {number} origin_z ray origin
+ * @param {number} direction_x ray direction
+ * @param {number} direction_y ray direction
+ * @param {number} direction_z ray direction
+ * @returns {boolean} true if ray hit the box, false otherwise
+ *
+ *
+ * @see https://tavianator.com/fast-branchless-raybounding-box-intersections-part-2-nans/
+ * @see https://gdbooks.gitbooks.io/3dcollisions/content/Chapter3/raycast_aabb.html
+ * @see https://blog.johnnovak.net/2016/10/22/the-nim-ray-tracer-project-part-4-calculating-box-normals/
+ */
+export function aabb3_raycast(result, result_offset, x0, y0, z0, x1, y1, z1, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z) {
+
+    // first find intersection
+    const dir_inv_x = 1 / direction_x;
+    const dir_inv_y = 1 / direction_y;
+    const dir_inv_z = 1 / direction_z;
+
+    const t1_x = (x0 - origin_x) * dir_inv_x;
+    const t2_x = (x1 - origin_x) * dir_inv_x;
+
+    const t1_y = (y0 - origin_y) * dir_inv_y;
+    const t2_y = (y1 - origin_y) * dir_inv_y;
+
+    const t1_z = (z0 - origin_z) * dir_inv_z;
+    const t2_z = (z1 - origin_z) * dir_inv_z;
+
+    let tMax = max2(t1_x, t2_x);
+    tMax = min2(tMax, max2(t1_y, t2_y));
+    tMax = min2(tMax, max2(t1_z, t2_z));
+
+    if (tMax < 0) {
+        // if tMax < 0, AABB is behind the ray origin in the opposite direction to the ray's
+        return false;
+    }
+
+    let tMin = min2(t1_x, t2_x);
+    tMin = max2(tMin, min2(t1_y, t2_y));
+    tMin = max2(tMin, min2(t1_z, t2_z));
+
+    if (tMin > tMax) {
+        // if tMin > tMax, ray does not intersect the AABB
+        return false;
+    }
+
+    // ray hit detected, figure out offset along the ray from origin to hit
+    const ray_offset = tMin < 0 ? tMax : tMin;
+
+    const hit_x = origin_x + direction_x * ray_offset;
+    const hit_y = origin_y + direction_y * ray_offset;
+    const hit_z = origin_z + direction_z * ray_offset;
+
+    // figure out normal
+    const center_x = (x0 + x1) * 0.5;
+    const center_y = (y0 + y1) * 0.5;
+    const center_z = (z0 + z1) * 0.5;
+
+    const p_x = hit_x - center_x;
+    const p_y = hit_y - center_y;
+    const p_z = hit_z - center_z;
+
+    const d_x = (x0 - x1) * 0.5;
+    const d_y = (y0 - y1) * 0.5;
+    const d_z = (z0 - z1) * 0.5;
+
+    // bias is necessary to deal with rounding errors
+    const bias = 1.000001;
+
+    const normal_x = (p_x / Math.abs(d_x) * bias) | 0;
+    const normal_y = (p_y / Math.abs(d_y) * bias) | 0;
+    const normal_z = (p_z / Math.abs(d_z) * bias) | 0;
+
+    // normalize surface normal vector
+    const normal_inv_length = 1 / Math.hypot(normal_x, normal_y, normal_z);
+
+    result[result_offset] = hit_x;
+    result[result_offset + 1] = hit_y;
+    result[result_offset + 2] = hit_z;
+
+    result[result_offset + 3] = normal_x * normal_inv_length;
+    result[result_offset + 4] = normal_y * normal_inv_length;
+    result[result_offset + 5] = normal_z * normal_inv_length;
+
+    return true;
+}

package/src/core/{bvh2/aabb3 → geom/3d/aabb}/aabb3_signed_distance_sqr_to_point.js

@@ -1,4 +1,4 @@
-import { max2 } from "../../math/max2.js";
+import { max2 } from "../../../math/max2.js";
 
 /**
  * Compute squared distance to point, value is negative if the point is inside the box

package/src/core/geom/3d/aabb/computeBoundingBoxFromVertexData.js

@@ -1,20 +1,12 @@
+import { aabb3_from_v3_array } from "./aabb3_from_v3_array.js";
+
 /**
- *
+ * @deprecated use {@link aabb3_from_v3_array} instead
  * @param {Float32Array} data must be x,y,z sequence
  * @param {AABB3} aabb
  */
 export function computeBoundingBoxFromVertexData(data, aabb) {
-    aabb.setNegativelyInfiniteBounds();
-
-    let i = 0;
-    const data_size = data.length;
-
-    while (i < data_size) {
-        const x = data[i++];
-        const y = data[i++];
-        const z = data[i++];
 
-        aabb._expandToFitPoint(x, y, z);
-    }
+    aabb3_from_v3_array(aabb, data, data.length);
 
 }

package/src/core/geom/3d/aabb/compute_aabb_from_points.js

@@ -9,7 +9,14 @@ import { max2 } from "../../../math/max2.js";
  * @param {number} input_count
  * @param {number} d number of dimensions
  */
-export function compute_aabb_from_points(result, input, input_offset, input_count, d) {
+export function compute_aabb_from_points(
+    result,
+    input,
+    input_offset,
+    input_count,
+    d
+) {
+
     let i = 0;
     let j = 0;
 

package/src/core/geom/3d/shape/UnitCubeShape3D.js

@@ -5,7 +5,7 @@ import { max2 } from "../../../math/max2.js";
 import { max3 } from "../../../math/max3.js";
 import { min2 } from "../../../math/min2.js";
 import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
-import { aabb3_nearest_point_on_surface } from "../../../bvh2/aabb3/aabb3_nearest_point_on_surface.js";
+import { aabb3_nearest_point_on_surface } from "../aabb/aabb3_nearest_point_on_surface.js";
 
 export class UnitCubeShape3D extends AbstractShape3D {
 

package/src/core/geom/3d/triangle/computeTriangleRayIntersection.js

@@ -204,7 +204,7 @@ export function computeTriangleRayIntersectionBarycentricEdge(result, origin_x,
     const tvec_z = origin_z - az;
 
     // calculate u
-    let u = v3_dot(tvec_x, tvec_y, tvec_z, pvec_x, pvec_y, pvec_z);
+    const u = v3_dot(tvec_x, tvec_y, tvec_z, pvec_x, pvec_y, pvec_z);
 
     if (u < 0 || u > det) {
         // outside of bounds of the triangle
@@ -218,7 +218,7 @@ export function computeTriangleRayIntersectionBarycentricEdge(result, origin_x,
     const qvec_z = tvec_x * edge1_y - tvec_y * edge1_x;
 
     // calculate V parameter
-    let v = v3_dot(direction_x, direction_y, direction_z, qvec_x, qvec_y, qvec_z);
+    const v = v3_dot(direction_x, direction_y, direction_z, qvec_x, qvec_y, qvec_z);
 
     if (v < 0 || u + v > det) {
         // out of bounds
@@ -231,12 +231,9 @@ export function computeTriangleRayIntersectionBarycentricEdge(result, origin_x,
     // calculate t, scale parameter, ray intersects triangle
     const t = v3_dot(edge2_x, edge2_y, edge2_z, qvec_x, qvec_y, qvec_z) * inv_det;
 
-    u *= inv_det;
-    v *= inv_det;
-
     result[0] = t;
-    result[1] = u;
-    result[2] = v;
+    result[1] = u*inv_det;
+    result[2] = v*inv_det;
 
     return true;
 }

package/src/core/model/node-graph/DataType.d.ts

@@ -0,0 +1,4 @@
+export class DataType{
+    id:number
+    name:string
+}

package/src/core/model/node-graph/node/NodeDescription.d.ts

@@ -1,3 +1,13 @@
-export class NodeDescription{
+import {Port} from "./Port";
+import {DataType} from "../DataType";
+import {PortDirection} from "./PortDirection";
 
+export class NodeDescription {
+
+    readonly inPorts:Port[]
+    readonly outPorts:Port[]
+
+    getPorts(): Port[]
+
+    createPort(type: DataType, name:string,direction:PortDirection): number
 }

package/src/core/model/node-graph/node/NodeRegistry.spec.js

@@ -19,7 +19,7 @@ test("serialize/deserialize 1 node with 1 port", () => {
     p0.dataType = t0;
     p0.direction = PortDirection.In;
 
-    n0.ports.push(p0);
+    n0.getPorts().push(p0);
 
     const lA = new NodeRegistry();
 
@@ -75,3 +75,49 @@ test("hasType", () => {
 
     expect(registry.hasType(type)).toBe(true);
 });
+
+test("inPorts works as intended", () => {
+    const node = new NodeDescription();
+
+    const type = DataType.from(0, 'a');
+
+    expect(node.inPorts.length).toBe(0);
+
+    node.createPort(type, 'a', PortDirection.Out);
+
+    expect(node.inPorts.length).toBe(0);
+
+    node.createPort(type, 'a', PortDirection.In);
+
+    expect(node.inPorts.length).toBe(1);
+
+});
+
+test("outPorts works as intended", () => {
+    const node = new NodeDescription();
+
+    const type = DataType.from(0, 'a');
+
+    expect(node.outPorts.length).toBe(0);
+
+    node.createPort(type, 'a', PortDirection.In);
+
+    expect(node.outPorts.length).toBe(0);
+
+    node.createPort(type, 'a', PortDirection.Out);
+
+    expect(node.outPorts.length).toBe(1);
+
+});
+
+test("createPort assigns unique IDs for ports", () => {
+
+    const node = new NodeDescription();
+
+    const type = DataType.from(0, 'a');
+
+    const a = node.createPort(type, 'a', PortDirection.In);
+    const b = node.createPort(type, 'a', PortDirection.In);
+
+    expect(a).not.toEqual(b);
+});

package/src/core/model/node-graph/node/Port.d.ts

@@ -0,0 +1,3 @@
+export class Port{
+
+}

package/src/core/model/node-graph/node/Port.js

@@ -35,11 +35,15 @@ export class Port {
     }
 
     hash() {
+        const dataType = this.dataType;
+
+        const type_hash = dataType !== null ? dataType.id : 0;
+
         return computeHashIntegerArray(
             computeStringHash(this.name),
             this.id,
             this.direction,
-            this.dataType.id
+            type_hash
         );
     }
 
@@ -50,8 +54,8 @@ export class Port {
      */
     equals(other) {
 
-        return this.name === other.name
-            && this.id === other.id
+        return this.id === other.id
+            && this.name === other.name
             && this.direction === other.direction
             && this.dataType === other.dataType
             ;

package/src/core/model/node-graph/node/Port.spec.js

@@ -0,0 +1,44 @@
+import { Port } from "./Port.js";
+
+test("constructor does not throw", () => {
+    expect(() => new Port()).not.toThrow();
+});
+
+test("hash is consistent", () => {
+    const port = new Port();
+
+    expect(port.hash()).toEqual(port.hash());
+});
+
+test("hash is an unsigned integer", () => {
+    const port = new Port();
+
+    const hash = port.hash();
+
+    expect(typeof hash).toEqual("number");
+    expect(Number.isInteger(hash)).toEqual(true);
+    expect(hash).toBeGreaterThanOrEqual(0);
+});
+
+test("hash is different for different ports", () => {
+
+    const a = new Port();
+    const b = new Port();
+
+    expect(a.hash()).not.toEqual(b.hash());
+});
+
+test("equality works as intended", () => {
+    const a = new Port();
+
+    expect(a.equals(a)).toEqual(true);
+
+    const b = new Port();
+
+    expect(b.equals(a)).toEqual(false);
+
+    b.id = a.id;
+
+    expect(b.equals(a)).toEqual(true);
+    
+});

package/src/core/model/node-graph/node/PortDirection.d.ts

@@ -0,0 +1,5 @@
+export enum PortDirection{
+    In= 0,
+    Out= 1,
+    Unspecified= 2
+}

package/src/engine/asset/Asset.js

@@ -28,7 +28,7 @@ export class Asset {
 
         /**
          *
-         * @type {Array.<AssetDescription>}
+         * @type {Array<AssetDescription>}
          */
         this.dependencies = [];
 

package/src/engine/asset/AssetLoadState.js

@@ -0,0 +1,10 @@
+/**
+ * @enum {number}
+ */
+export const AssetLoadState = {
+    Initial: 0,
+    Queued: 1,
+    Loading: 2,
+    Succeeded: 3,
+    Failed: 4
+};