@woosh/meep-engine 2.110.8 → 2.110.9

package/src/engine/ecs/guid/{GUIDSerializationAdapter.js → UUIDSerializationAdapter.js}

@@ -1,14 +1,14 @@
 import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
-import { GUID } from "./GUID.js";
+import { UUID } from "./UUID.js";
 
-export class GUIDSerializationAdapter extends BinaryClassSerializationAdapter {
-    klass = GUID
+export class UUIDSerializationAdapter extends BinaryClassSerializationAdapter {
+    klass = UUID
     version = 0
 
     /**
      *
      * @param buffer
-     * @param {GUID} value
+     * @param {UUID} value
      */
     serialize(buffer, value) {
         buffer.writeUint8Array(value.data, 0, 16);
@@ -17,7 +17,7 @@ export class GUIDSerializationAdapter extends BinaryClassSerializationAdapter {
     /**
      *
      * @param buffer
-     * @param {GUID} value
+     * @param {UUID} value
      */
     deserialize(buffer, value) {
         buffer.readUint8Array(value.data, 0, 16);

package/src/engine/ecs/ik/InverseKinematics.js

@@ -16,11 +16,11 @@ export class InverseKinematics {
     copy(other) {
         this.constraints.splice(0, this.constraints.length);
 
-        const ikConstraints = other.constraints;
-        const n = ikConstraints.length;
+        const other_constraints = other.constraints;
+        const n = other_constraints.length;
 
         for (let i = 0; i < n; i++) {
-            const constraint = ikConstraints[i];
+            const constraint = other_constraints[i];
 
             const constraintClone = constraint.clone();
 

package/src/engine/ecs/ik/TwoBoneInverseKinematicsSolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TwoBoneInverseKinematicsSolver.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/TwoBoneInverseKinematicsSolver.js"],"names":[],"mappings":"AAyLA;IAGI,0BAuIC;CACJ;yBAzTwB,eAAe"}
+{"version":3,"file":"TwoBoneInverseKinematicsSolver.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/TwoBoneInverseKinematicsSolver.js"],"names":[],"mappings":"AA8CA;IAGI,0BAuIC;CACJ;yBA9KwB,eAAe"}

package/src/engine/ecs/ik/TwoBoneInverseKinematicsSolver.js

@@ -5,10 +5,10 @@ import { v3_displace_in_direction } from "../../../core/geom/vec3/v3_displace_in
 import { v3_dot } from "../../../core/geom/vec3/v3_dot.js";
 import { v3_length } from "../../../core/geom/vec3/v3_length.js";
 import Vector3 from "../../../core/geom/Vector3.js";
-import { clamp } from "../../../core/math/clamp.js";
 import { clamp01 } from "../../../core/math/clamp01.js";
 import { inverseLerp } from "../../../core/math/inverseLerp.js";
 import { findSkeletonBoneByType } from "../../graphics/ecs/mesh/SkeletonUtils.js";
+import { two_joint_ik } from "../../physics/inverse_kinematics/two_joint_ik.js";
 import { IKSolver } from "./IKSolver.js";
 
 const boneWorldPositionC = new Vector3();
@@ -28,147 +28,8 @@ const globalRotationC = new Quaternion();
 const targetLocalRotationA = new Quaternion();
 const targetLocalRotationB = new Quaternion();
 
-
-/**
- * Compute interior angle between tree points
- * @param {Vector3} a
- * @param {Vector3} b
- * @param {Vector3} c
- * @returns {number} angle in radians
- */
-function computeInteriorAngle(a, b, c) {
-
-    //compute AB delta
-    const d_ab_x = a.x - b.x;
-    const d_ab_y = a.y - b.y;
-    const d_ab_z = a.z - b.z;
-
-    //normalize AB delta vector
-    const d_ab_length = v3_length(d_ab_x, d_ab_y, d_ab_z);
-
-    const nd_ab_x = d_ab_x / d_ab_length;
-    const nd_ab_y = d_ab_y / d_ab_length;
-    const nd_ab_z = d_ab_z / d_ab_length;
-
-    //compute CB delta
-    const d_cb_x = c.x - b.x;
-    const d_cb_y = c.y - b.y;
-    const d_cb_z = c.z - b.z;
-
-    //normalize CB delta vector
-    const d_cb_length = v3_length(d_cb_x, d_cb_y, d_cb_z);
-
-    const nd_cb_x = d_cb_x / d_cb_length;
-    const nd_cb_y = d_cb_y / d_cb_length;
-    const nd_cb_z = d_cb_z / d_cb_length;
-
-    //compute dot product
-    const dot = v3_dot(nd_ab_x, nd_ab_y, nd_ab_z, nd_cb_x, nd_cb_y, nd_cb_z);
-
-    //clamp value of dot product for arc cosine function
-    const clamped_dot = clamp(dot, -1, 1);
-
-    return Math.acos(clamped_dot);
-}
-
-
-const d = new Vector3();
-const delta_ca = new Vector3();
-const delta_ta = new Vector3();
-
-const axis0 = new Vector3();
-const axis1 = new Vector3();
-
-const inv_a_gr = new Quaternion();
-const inv_b_gr = new Quaternion();
-
 const r0 = new Quaternion();
 const r1 = new Quaternion();
-const r2 = new Quaternion();
-
-const axis0_la = new Vector3();
-const axis0_lb = new Vector3();
-const axis1_la = new Vector3();
-
-/**
- * Based on http://theorangeduck.com/page/simple-two-joint
- * @param {Vector3} a Root bone position
- * @param {Vector3} b Second bone position
- * @param {Vector3} c Effector position
- * @param {Vector3} t Target position
- * @param {number} eps EPSILON value, small value for rounding error compensation
- * @param {Quaternion} a_gr Global rotation of root bone
- * @param {Quaternion} b_gr Global rotation of second bone
- * @param {Quaternion} a_lr local rotation for root bone, this will be updated as a result
- * @param {Quaternion} b_lr local rotation for second bone, this will be updated as a result
- */
-function two_joint_ik(
-    a, b, c, t, eps,
-    a_gr, b_gr,
-    a_lr, b_lr
-) {
-
-    //Compute lengths of bones
-    const lab = b.distanceTo(a);
-    const lcb = b.distanceTo(c);
-
-    const maximum_extension = lab + lcb - eps;
-
-    //clamp length to the target to maximum extension of the joint
-    const lat = clamp(t.distanceTo(a), eps, maximum_extension);
-
-    //compute current interior angles
-    const ac_ab_0 = computeInteriorAngle(c, a, b);
-    const ba_bc_0 = computeInteriorAngle(a, b, c);
-    const ac_at_0 = computeInteriorAngle(c, a, t);
-
-    // Using the cosine rule to compute desired interior angles
-    const length_at_sqr = lat * lat;
-    const length_cb_sqr = lcb * lcb;
-    const length_ab_sqr = lab * lab;
-
-    const ac_ab_1 = Math.acos(clamp((length_cb_sqr - length_ab_sqr - length_at_sqr) / (-2 * lab * lat), -1, 1));
-    const ba_bc_1 = Math.acos(clamp((length_at_sqr - length_ab_sqr - length_cb_sqr) / (-2 * lab * lcb), -1, 1));
-
-    d.copy(Vector3.back);
-    d.applyQuaternion(b_gr);
-
-    delta_ca.subVectors(c, a);
-    delta_ta.subVectors(t, a);
-
-    axis0.crossVectors(delta_ca, d);
-    axis0.normalize();
-
-    axis1.crossVectors(delta_ca, delta_ta);
-    axis1.normalize();
-
-    inv_a_gr.copyInverse(a_gr);
-    inv_b_gr.copyInverse(b_gr);
-
-    axis0_la.copy(axis0);
-    axis0_la.applyQuaternion(inv_a_gr);
-
-    const angle0 = ac_ab_1 - ac_ab_0;
-
-    r0.fromAxisAngle(axis0_la, angle0);
-
-    const angle1 = ba_bc_1 - ba_bc_0;
-
-    axis0_lb.copy(axis0);
-    axis0_lb.applyQuaternion(inv_b_gr);
-
-    r1.fromAxisAngle(axis0_lb, angle1);
-
-    axis1_la.copy(axis1);
-    axis1_la.applyQuaternion(inv_a_gr);
-
-    r2.fromAxisAngle(axis1_la, ac_at_0);
-
-    r0.multiply(r2);
-
-    a_lr.multiply(r0);
-    b_lr.multiply(r1);
-}
 
 /**
  *

package/src/engine/input/ecs/systems/InputControllerSystem.js

@@ -181,7 +181,7 @@ function removeBindings(mapping, devices, proxies) {
 }
 
 /**
- * @deprecated Use {@link InputSystem} instead
+ * Prefer to use {@link InputSystem} instead
  */
 class InputControllerSystem extends System {
     constructor(devices) {

package/src/engine/intelligence/blackboard/BlackboardDynamicStorageAdapter.d.ts

@@ -38,7 +38,7 @@ export class BlackboardDynamicStorageAdapter {
      */
     private __write_timeout_handle;
     /**
-     *
+     * In milliseconds
      * @type {number}
      * @private
      */

package/src/engine/intelligence/blackboard/BlackboardDynamicStorageAdapter.js

@@ -54,7 +54,7 @@ export class BlackboardDynamicStorageAdapter {
         this.__write_timeout_handle = -1;
 
         /**
-         *
+         * In milliseconds
          * @type {number}
          * @private
          */
@@ -101,14 +101,14 @@ export class BlackboardDynamicStorageAdapter {
     async read() {
         const data = await this.__storage.promiseLoadBinary(this.__storage_key);
 
+        this.__blackboard.reset();
+
         if (data === undefined) {
             // no data
-            this.__blackboard.reset();
             return;
         }
 
-        const buffer = new BinaryBuffer();
-        buffer.fromArrayBuffer(data);
+        const buffer = BinaryBuffer.fromArrayBuffer(data);
 
         const object = this.__serialization_adapter.deserialize(buffer);
 

package/src/engine/physics/gjk/expanding_polytope_algorithm.d.ts

@@ -0,0 +1,13 @@
+/**
+ * TODO: needs to be tested thoroughly, intended to be working with GJK
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number[]} a
+ * @param {number[]} b
+ * @param {number[]} c
+ * @param {number[]} d
+ * @param {AbstractShape3D} coll1
+ * @param {AbstractShape3D} coll2
+ */
+export function expanding_polytope_algorithm(result: number[], result_offset: number, a: number[], b: number[], c: number[], d: number[], coll1: AbstractShape3D, coll2: AbstractShape3D): void;
+//# sourceMappingURL=expanding_polytope_algorithm.d.ts.map

package/src/engine/physics/gjk/expanding_polytope_algorithm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expanding_polytope_algorithm.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/gjk/expanding_polytope_algorithm.js"],"names":[],"mappings":"AAuFA;;;;;;;;;;GAUG;AACH,qDATW,MAAM,EAAE,iBACR,MAAM,KACN,MAAM,EAAE,KACR,MAAM,EAAE,KACR,MAAM,EAAE,KACR,MAAM,EAAE,wDAgQlB"}

package/src/engine/physics/gjk/expanding_polytope_algorithm.js

@@ -0,0 +1,395 @@
+import { assert } from "../../../core/assert.js";
+import { array_copy } from "../../../core/collection/array/array_copy.js";
+import { array_swap } from "../../../core/collection/array/array_swap.js";
+
+import { v3_negate_array } from "../../../core/geom/3d/v3_negate_array.js";
+import { v3_dot } from "../../../core/geom/vec3/v3_dot.js";
+import { v3_dot_array_array } from "../../../core/geom/vec3/v3_dot_array_array.js";
+import { v3_length } from "../../../core/geom/vec3/v3_length.js";
+import { v3_length_sqr } from "../../../core/geom/vec3/v3_length_sqr.js";
+
+const EPA_TOLERANCE = 0.0001;
+const EPA_MAX_NUM_FACES = 64;
+const EPA_MAX_NUM_LOOSE_EDGES = 32;
+const EPA_MAX_NUM_ITERATIONS = 64;
+
+const FACE_ELEMENT_COUNT = 3 * 4;
+
+const EDGE_ELEMENT_COUNT = 2 * 3;
+
+//Array of faces, each with 3 verts and a normal
+const faces = new Float32Array(EPA_MAX_NUM_FACES * FACE_ELEMENT_COUNT);
+
+/**
+ * keep track of edges we need to fix after removing faces
+ * @type {Float32Array}
+ */
+const loose_edges = new Float32Array(EPA_MAX_NUM_LOOSE_EDGES * EDGE_ELEMENT_COUNT);
+
+const scratch_v3 = new Float32Array(3);
+
+
+function write_v3(target, target_index, v) {
+    array_copy(v, 0, faces, target_index * 3, 3);
+}
+
+/**
+ *
+ * @param {number[]|Float32Array} faces
+ * @param {number} index
+ * @param {number[]} a
+ * @param {number[]} b
+ * @param {number[]} c
+ */
+function write_face(faces, index, a, b, c) {
+    const index4 = index * 4;
+
+    write_v3(faces, index4 + 0, a);
+    write_v3(faces, index4 + 1, b);
+    write_v3(faces, index4 + 2, c);
+
+    // normalise(cross(b-a, c-a)); //ABC
+    const ba_x = b[0] - a[0];
+    const ba_y = b[1] - a[1];
+    const ba_z = b[2] - a[2];
+
+    const ca_x = c[0] - a[0];
+    const ca_y = c[1] - a[1];
+    const ca_z = c[2] - a[2];
+
+    // cross product
+
+    const cross_x = ba_y * ca_z - ba_z * ca_y;
+    const cross_y = ba_z * ca_x - ba_x * ca_z;
+    const cross_z = ba_x * ca_y - ba_y * ca_x;
+
+    const normal_offset = (index4 + 3) * 3;
+
+    // normalize
+    const length = v3_length(cross_x, cross_y, cross_z);
+
+    if (length === 0) {
+        // division by 0, there is no normal vector so let's provide something valid
+
+        faces[normal_offset] = 0;
+        faces[normal_offset + 1] = 1;
+        faces[normal_offset + 2] = 0;
+
+        return;
+    }
+
+    const length_inv = 1 / length;
+
+    faces[normal_offset] = cross_x * length_inv;
+    faces[normal_offset + 1] = cross_y * length_inv;
+    faces[normal_offset + 2] = cross_z * length_inv;
+}
+
+/**
+ * TODO: needs to be tested thoroughly, intended to be working with GJK
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number[]} a
+ * @param {number[]} b
+ * @param {number[]} c
+ * @param {number[]} d
+ * @param {AbstractShape3D} coll1
+ * @param {AbstractShape3D} coll2
+ */
+export function expanding_polytope_algorithm(
+    result, result_offset,
+    a, b, c, d,
+    coll1, coll2
+) {
+    /*
+     Adapted from https://github.com/kevinmoran/GJK/blob/master/GJK.h
+
+     "GJK + Expanding Polytope Algorithm - Implementation and Visualization"  https://www.youtube.com/watch?v=6rgiPrzqt9w
+     */
+
+    //Init with final simplex from GJK
+    write_face(faces, 0, a, b, c);
+    write_face(faces, 1, a, c, d);
+    write_face(faces, 2, a, d, b);
+    write_face(faces, 3, b, d, c);
+
+    let num_faces = 4;
+    let closest_face;
+
+    for (let iterations = 0; iterations < EPA_MAX_NUM_ITERATIONS; iterations++) {
+
+        //Find face that's closest to origin
+
+        let min_dist = v3_dot_array_array(faces, 0, faces, 3 * 3);
+        closest_face = 0;
+
+        for (let i = 1; i < num_faces; i++) {
+            const dist = v3_dot_array_array(faces, i * FACE_ELEMENT_COUNT, faces, i * FACE_ELEMENT_COUNT + 3 * 3);
+
+            if (dist < min_dist) {
+                min_dist = dist;
+                closest_face = i;
+            }
+
+        }
+
+        //search normal to face that's closest to origin
+        const closest_face_normal_offset = closest_face * FACE_ELEMENT_COUNT + 3 * 3;
+
+        const search_dir_x = faces[closest_face_normal_offset];
+        const search_dir_y = faces[closest_face_normal_offset + 1];
+        const search_dir_z = faces[closest_face_normal_offset + 2];
+
+        if (search_dir_x === 0 && search_dir_y === 0 && search_dir_z === 0) {
+            debugger;
+        }
+
+        // build new support point to expand polytope
+
+        coll2.support(scratch_v3, 0, search_dir_x, search_dir_y, search_dir_z);
+
+        const support2_x = scratch_v3[0];
+        const support2_y = scratch_v3[1];
+        const support2_z = scratch_v3[2];
+
+        coll1.support(scratch_v3, 0, -search_dir_x, -search_dir_y, -search_dir_z);
+
+        const support1_x = scratch_v3[0];
+        const support1_y = scratch_v3[1];
+        const support1_z = scratch_v3[2];
+
+        const p_x = support2_x - support1_x;
+        const p_y = support2_y - support1_y;
+        const p_z = support2_z - support1_z;
+
+        const dot_p_search_dir = v3_dot(p_x, p_y, p_z, search_dir_x, search_dir_y, search_dir_z);
+
+        if (dot_p_search_dir - min_dist < EPA_TOLERANCE) {
+            //Convergence (new point is not significantly further from origin)
+
+            result[result_offset] = search_dir_x * dot_p_search_dir;
+            result[result_offset + 1] = search_dir_y * dot_p_search_dir;
+            result[result_offset + 2] = search_dir_z * dot_p_search_dir;
+
+            return;
+        }
+
+        let num_loose_edges = 0;
+
+        //Find all triangles that are facing p
+        for (let i = 0; i < num_faces; i++) {
+            const face_offset = i * FACE_ELEMENT_COUNT;
+
+            const face_normal_address = face_offset + 3 * 3;
+            const face_a_address = face_offset;
+
+            const face_normal_x = faces[face_normal_address];
+            const face_normal_y = faces[face_normal_address + 1];
+            const face_normal_z = faces[face_normal_address + 2];
+
+            const face_a_x = faces[face_a_address];
+            const face_a_y = faces[face_a_address + 1];
+            const face_a_z = faces[face_a_address + 2];
+
+            const pa_x = p_x - face_a_x;
+            const pa_y = p_y - face_a_y;
+            const pa_z = p_z - face_a_z;
+
+            if (v3_dot(face_normal_x, face_normal_y, face_normal_z, pa_x, pa_y, pa_z) <= 0) {
+                continue;
+            }
+
+            // triangle i faces p, remove it
+            for (let j = 0; j < 3; j++) //Three edges per face
+            {
+                const a_offset = j * 3;
+
+                const current_edge_ax = faces[face_offset + a_offset];
+                const current_edge_ay = faces[face_offset + a_offset + 1];
+                const current_edge_az = faces[face_offset + a_offset + 2];
+
+                const b_offset = ((j + 1) % 3) * 3;
+
+                const current_edge_bx = faces[face_offset + b_offset];
+                const current_edge_by = faces[face_offset + b_offset + 1];
+                const current_edge_bz = faces[face_offset + b_offset + 2];
+
+                // vec3 current_edge[2] = { faces[i][j], faces[i][(j + 1) % 3] };
+
+                let found_edge = false;
+
+                //Check if current edge is already in list
+                for (let k = 0; k < num_loose_edges; k++) {
+                    const loose_edge_offset = k * EDGE_ELEMENT_COUNT;
+
+                    const loose_edge_ax = loose_edges[loose_edge_offset];
+                    const loose_edge_ay = loose_edges[loose_edge_offset + 1];
+                    const loose_edge_az = loose_edges[loose_edge_offset + 2];
+
+                    const loose_edge_bx = loose_edges[loose_edge_offset + 3];
+                    const loose_edge_by = loose_edges[loose_edge_offset + 4];
+                    const loose_edge_bz = loose_edges[loose_edge_offset + 5];
+
+
+                    // if (loose_edges[k][1] === current_edge[0] && loose_edges[k][0] === current_edge[1]) {
+                    if (
+                        (
+                            loose_edge_ax === current_edge_bx
+                            && loose_edge_ay === current_edge_by
+                            && loose_edge_az === current_edge_bz
+                        )
+                        && (
+                            loose_edge_bx === current_edge_ax
+                            && loose_edge_by === current_edge_ay
+                            && loose_edge_bz === current_edge_az
+                        )
+                    ) {
+                        //Edge is already in the list, remove it
+                        //THIS ASSUMES EDGE CAN ONLY BE SHARED BY 2 TRIANGLES (which should be true)
+                        //THIS ALSO ASSUMES SHARED EDGE WILL BE REVERSED IN THE TRIANGLES (which
+                        //should be true provided every triangle is wound CCW)
+
+                        // Overwrite current edge with last edge in list
+                        loose_edges.copyWithin(loose_edge_offset, (num_loose_edges - 1) * EDGE_ELEMENT_COUNT, (num_loose_edges) * EDGE_ELEMENT_COUNT);
+
+                        num_loose_edges--;
+                        found_edge = true;
+
+                        //exit loop because edge can only be shared once
+                        break;
+                    }
+                }
+
+                if (!found_edge) { //add current edge to list
+                    // assert(num_loose_edges<EPA_MAX_NUM_LOOSE_EDGES);
+
+                    assert.lessThan(num_loose_edges, EPA_MAX_NUM_LOOSE_EDGES);
+
+                    if (num_loose_edges >= EPA_MAX_NUM_LOOSE_EDGES) {
+                        // this should not happen, but if it does it is best to be "kind of right" than to fail completely
+                        break;
+                    }
+
+                    const last_edge_offset = num_loose_edges * EDGE_ELEMENT_COUNT;
+
+                    loose_edges[last_edge_offset] = current_edge_ax;
+                    loose_edges[last_edge_offset + 1] = current_edge_ay;
+                    loose_edges[last_edge_offset + 2] = current_edge_az;
+
+                    loose_edges[last_edge_offset + 3] = current_edge_bx;
+                    loose_edges[last_edge_offset + 4] = current_edge_by;
+                    loose_edges[last_edge_offset + 5] = current_edge_bz;
+
+                    num_loose_edges++;
+                }
+            }
+
+            // move last face to fill the removed element
+            faces.copyWithin(i * FACE_ELEMENT_COUNT, (num_faces - 1) * FACE_ELEMENT_COUNT, num_faces * FACE_ELEMENT_COUNT);
+
+            num_faces--;
+            i--;
+
+        }
+
+        //Reconstruct polytope with p added
+        for (let i = 0; i < num_loose_edges; i++) {
+            // assert(num_faces<EPA_MAX_NUM_FACES);
+
+            assert.lessThan(num_faces, EPA_MAX_NUM_FACES);
+
+            if (num_faces >= EPA_MAX_NUM_FACES) {
+                // should never happen
+                break;
+            }
+
+            const face_offset = num_faces * FACE_ELEMENT_COUNT;
+
+            const loose_edge_offset = i * EDGE_ELEMENT_COUNT;
+
+            array_copy(
+                loose_edges, loose_edge_offset,
+                faces, face_offset,
+                EDGE_ELEMENT_COUNT
+            );
+
+            faces[face_offset + 3 * 2] = p_x;
+            faces[face_offset + 3 * 2 + 1] = p_y;
+            faces[face_offset + 3 * 2 + 2] = p_z;
+
+            // construct normal
+            const face_normal_offset = face_offset + 3 * 3;
+            construct_normal(face_normal_offset, i, p_x, p_y, p_z);
+
+            //Check for wrong normal to maintain CCW winding
+            const bias = 0.000001; //in case dot result is only slightly < 0 (because origin is on face)
+
+            const dot = v3_dot_array_array(faces, face_offset, faces, face_normal_offset)
+
+            if (dot + bias < 0) {
+                array_swap(faces, face_offset, faces, face_offset + 3, 3);
+                // invert normal
+                v3_negate_array(faces, face_normal_offset, faces, face_normal_offset);
+            }
+
+            num_faces++;
+        }
+    }
+
+    console.warn("EPA did not converge");
+
+    //Return most recent closest point
+    const closest_face_offset = closest_face * FACE_ELEMENT_COUNT;
+    const closest_face_normal_offset = closest_face_offset + 3 * 3;
+
+    const dot = v3_dot_array_array(faces, closest_face_offset, faces, closest_face_normal_offset);
+
+    result[result_offset] = faces[closest_face_normal_offset + 0] * dot;
+    result[result_offset + 1] = faces[closest_face_normal_offset + 1] * dot;
+    result[result_offset + 2] = faces[closest_face_normal_offset + 2] * dot;
+
+}
+
+/**
+ *
+ * @param {number} result_offset
+ * @param {number} edge_index
+ * @param {number} p_x
+ * @param {number} p_y
+ * @param {number} p_z
+ */
+function construct_normal(result_offset, edge_index, p_x, p_y, p_z) {
+    const edge_offset = edge_index * EDGE_ELEMENT_COUNT;
+
+    const edge_ax = loose_edges[edge_offset];
+    const edge_ay = loose_edges[edge_offset + 1];
+    const edge_az = loose_edges[edge_offset + 2];
+
+    const edge_bx = loose_edges[edge_offset + 3];
+    const edge_by = loose_edges[edge_offset + 4];
+    const edge_bz = loose_edges[edge_offset + 5];
+
+    const v0x = edge_ax - edge_bx;
+    const v0y = edge_ay - edge_by;
+    const v0z = edge_az - edge_bz;
+
+    const v1x = edge_ax - p_x;
+    const v1y = edge_ay - p_y;
+    const v1z = edge_az - p_z;
+
+    const crossX = v0y * v1z - v0z * v1y;
+    const crossY = v0z * v1x - v0x * v1z;
+    const crossZ = v0x * v1y - v0y * v1x;
+
+    const l_sqr = v3_length_sqr(crossX, crossY, crossZ);
+
+    const l_inv = 1 / Math.sqrt(l_sqr);
+
+    const x = crossX * l_inv;
+    const y = crossY * l_inv;
+    const z = crossZ * l_inv;
+
+    faces[result_offset] = x;
+    faces[result_offset + 1] = y;
+    faces[result_offset + 2] = z;
+}

package/src/engine/physics/gjk/expanding_polytope_algorithm.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=expanding_polytope_algorithm.spec.d.ts.map

package/src/engine/physics/gjk/expanding_polytope_algorithm.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expanding_polytope_algorithm.spec.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/gjk/expanding_polytope_algorithm.spec.js"],"names":[],"mappings":""}