@carbonenginejs/runtime-utils 0.1.0

package/src/lne3.js

@@ -0,0 +1,497 @@
+import { vec3 } from "./vec3.js";
+import { box3 } from "./box3.js";
+import { pool } from "./pool.js";
+
+/**
+ * 3D Line
+ * @typedef {Float32Array} lne3
+ */
+export const lne3 = {};
+
+/**
+ * Allocates a pooled lne3
+ * @returns {Float32Array|lne3}
+ */
+lne3.alloc = function()
+{
+    return pool.allocF32(6);
+};
+
+/**
+ * Unallocates a pooled lne3
+ * @param {Float32Array|lne3} a
+ */
+lne3.unalloc = function(a)
+{
+    pool.freeType(a);
+};
+
+/**
+ * Line3 End methods
+ *
+ * @param {lne3} a
+ * @returns {TypedArray}
+ */
+lne3.$end = function (a)
+{
+    return a.subarray(3, 6);
+};
+
+/**
+ * Line3 start helper methods
+ *
+ * @param {lne3} a
+ * @returns {TypedArray}
+ */
+lne3.$start = function (a)
+{
+    return a.subarray(0, 3);
+};
+
+/**
+ * Clones a lne3
+ *
+ * @param {lne3} a
+ * @returns {lne3}
+ */
+lne3.clone = function (a)
+{
+    let out = new Float32Array(6);
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    out[3] = a[3];
+    out[4] = a[4];
+    out[5] = a[5];
+    return out;
+};
+
+/**
+ * Returns a point parameter based on the closest point as projected on the line segment.
+ * If clamp to line is true, then the returned value will be between 0 and 1
+ *
+ * @author three.js authors (converted)
+ * @param {vec3} a              - source lne3
+ * @param {vec3} point          - point to compare
+ * @param {boolean} clampToLine - optional setting to clamp the result to the lne3
+ * @returns {number}            - closest point parameter
+ */
+lne3.closestPointToPointParameter = function(a, point, clampToLine)
+{
+    const
+        startP = vec3.alloc(),
+        startEnd = vec3.alloc();
+
+    startP[0] = point[0] - a[0];
+    startP[1] = point[1] - a[1];
+    startP[2] = point[2] - a[2];
+
+    startEnd[0] = a[3] - a[0];
+    startEnd[1] = a[4] - a[1];
+    startEnd[2] = a[5] - a[2];
+
+    let startEnd2 = startEnd[0] * startEnd[0] + startEnd[1] * startEnd[1] + startEnd[2] * startEnd[2],
+        startEnd_startP = startEnd[0] * startP[0] + startEnd[1] * startP[1] + startEnd[2] * startP[2],
+        t = startEnd2 === 0 ? 0 : startEnd_startP / startEnd2;
+
+    vec3.unalloc(startP);
+    vec3.unalloc(startEnd);
+
+    if (clampToLine) t = Math.max(0, Math.min(1, t));
+    return t;
+
+};
+
+/**
+ * Copies the values from one lne3 into another
+ *
+ * @param {lne3} out
+ * @param {lne3} a
+ * @returns {lne3} out
+ */
+lne3.copy = function (out, a)
+{
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    out[3] = a[3];
+    out[4] = a[4];
+    out[5] = a[5];
+    return out;
+};
+
+/**
+ * Copies the start component from one lne3 into another
+ *
+ * @param {lne3} out
+ * @param {lne3} a
+ * @returns {lne3} out
+ */
+lne3.copyStart = function (out, a)
+{
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    return out;
+};
+
+/**
+ * Copies the end component from one lne3 into another
+ *
+ * @param {lne3} out
+ * @param {lne3} a
+ * @returns {lne3} out
+ */
+lne3.copyEnd =function (out, a)
+{
+    out[3] = a[3];
+    out[4] = a[4];
+    out[5] = a[5];
+    return out;
+};
+
+/**
+ * Creates a lne3
+ *
+ * @returns {lne3}
+ */
+lne3.create = function ()
+{
+    return new Float32Array(6);
+};
+
+/**
+ * Checks two lne3's for equality
+ *
+ * @param {lne3} a
+ * @param {lne3} b
+ * @returns {boolean}
+ */
+lne3.equals = box3.equals;
+
+/**
+ * Checks a lne3 against it's components for equality
+ *
+ * @param {lne3} a
+ * @param {vec3} min
+ * @param {vec3} max
+ * @returns {boolean}
+ */
+lne3.equalsStartEnd = box3.equalsBounds;
+
+/**
+ * Checks for box3 exact equality
+ *
+ * @param {lne3} a
+ * @param {lne3} b
+ * @returns {boolean}
+ */
+lne3.exactEquals = box3.exactEquals;
+
+/**
+ * Checks for exact equality between a lne3 and components
+ *
+ * @param {lne3} a
+ * @param {vec3} min
+ * @param {vec3} max
+ * @returns {boolean}
+ */
+lne3.exactEqualsStartEnd = box3.exactEqualsBounds;
+
+/**
+ * Sets a lne3 from an array at an optional offset
+ *
+ * @param {lne3} out
+ * @param {Array} arr
+ * @param {number} [index=0]
+ * @returns {lne3}
+ */
+lne3.fromArray = box3.fromArray;
+
+/**
+ * Sets a line from start and end components
+ *
+ * @param {lne3} out
+ * @param {vec3} start
+ * @param {vec3} end
+ * @returns {lne3} out
+ */
+lne3.fromStartEnd = box3.fromBounds;
+
+/**
+ * Returns a vector at a certain position along a lne3
+ *
+ * @author three.js authors (converted)
+ * @param {vec3} out     - receiving vec3
+ * @param {lne3} a       - source lne3
+ * @param {number} t     - Float representing the start (0) and end (1) of the line
+ * @returns {vec3} [out] - receiving vec3
+ */
+lne3.get = function(out, a, t)
+{
+    if (t < 0 || t > 1)
+    {
+        out[0] = 0;
+        out[1] = 0;
+        out[2] = 0;
+        throw new Error("Normalization error");
+    }
+    else
+    {
+        out[0] = (a[3] - a[0]) * t + a[0];
+        out[1] = (a[4] - a[1]) * t + a[1];
+        out[2] = (a[5] - a[2]) * t + a[2];
+    }
+    return out;
+};
+
+/**
+ * Sets a vec3 from the lne3's center
+ *
+ * @param {vec3} out   - receiving vec3
+ * @param {lne3} a     - source lne3
+ * @returns {vec3} out - receiving vec3
+ */
+lne3.getCenter = function(out, a)
+{
+    out[0] = (a[0] + a[3]) * 0.5;
+    out[1] = (a[1] + a[4]) * 0.5;
+    out[2] = (a[2] + a[5]) * 0.5;
+    return out;
+};
+
+/**
+ * Returns the closets point on a lne3 to a given point.
+ * - If clamp to line is true, then the returned value will be clamped to the line segment.
+ *
+ * @author three.js authors (converted)
+ * @param {vec3} out            - receiving vec3
+ * @param {lne3} a              - source lne3
+ * @param {vec3} point          - point to compare
+ * @param {boolean} clampToLine - optional setting to clamp the result to a line segment
+ * @returns {vec3} out          - receiving vec3
+ */
+lne3.getClosestPointToPoint = function(out, a, point, clampToLine)
+{
+    const t = lne3.closestPointToPointParameter(a, point, clampToLine);
+    out[0] = (a[3] - a[0]) * t + a[0];
+    out[1] = (a[4] - a[1]) * t + a[1];
+    out[2] = (a[5] - a[2]) * t + a[2];
+    return out;
+};
+
+/**
+ * Gets the end component of a lne3
+ *
+ * @param {vec3} out
+ * @param {lne3} a
+ * @returns {vec3} out
+ */
+lne3.getEnd = box3.getMax;
+
+/**
+ * Gets a lne3's delta
+ *
+ * @param {vec3} out   - receiving vec3
+ * @param {lne3} a       - source lne3
+ * @returns {vec3} out - receiving vec3
+ */
+lne3.getDelta = function(out, a)
+{
+    out[0] = a[3] - a[0];
+    out[1] = a[4] - a[1];
+    out[2] = a[5] - a[2];
+    return out;
+};
+
+/**
+ * Gets the start component of a lne3
+ *
+ * @param {vec3} out
+ * @param {lne3} a
+ * @returns {vec3} out
+ */
+lne3.getStart = box3.getMin;
+
+/**
+ * Checks for intersection with a plane's components
+ *
+ * @param {lne3} a    - receiving lne3
+ * @param {vec3} n    - plane normal
+ * @param {number} c  - plane constant
+ * @returns {boolean}
+ */
+lne3.intersectsNormalConstant = function(a, n, c)
+{
+    const
+        startSign = (n[0] * a[0] + n[1] * a[1] + n[2] * a[2]) + c,
+        endSign = (n[0] * a[3] + n[1] * a[4] + n[2] * a[5]) + c;
+
+    return startSign === 0 || endSign === 0 ||
+        (startSign < 0 && endSign > 0) || (endSign < 0 && startSign > 0);
+};
+
+/**
+ * Gets the length of the line
+ *
+ * @param {lne3} a  - source lne3
+ * @returns {number} - distance
+ */
+lne3.length = function(a)
+{
+    let x = a[0] - a[3],
+        y = a[1] - a[4],
+        z = a[2] - a[5];
+
+    return Math.sqrt(x * x + y * y + z * z);
+};
+
+/**
+ * Sets a lne3 from values
+ *
+ * @param out - Receiving lne3
+ * @param sX
+ * @param sY
+ * @param sZ
+ * @param eX
+ * @param eY
+ * @param eZ
+ * @returns {lne3}
+ */
+lne3.set = box3.set;
+
+/**
+ * Gets the squared length of the lne3
+ *
+ * @param {lne3} a  - source line
+ * @returns {number} - squared distance
+ */
+lne3.squaredLength = function(a)
+{
+    let x = a[0] - a[3],
+        y = a[1] - a[4],
+        z = a[2] - a[5];
+
+    return x * x + y * y + z * z;
+};
+
+/**
+ * Sets an array from the lne3
+ *
+ * @param {lne3} a
+ * @param {Array} arr
+ * @param {number} [index]
+ * @returns {lne3} a
+ */
+lne3.toArray = box3.toArray;
+
+/**
+ * Sets a start and end vector from a lne3
+ *
+ * @param {lne3} a
+ * @param {vec3} start
+ * @param {vec3} end
+ * @returns {lne3} a
+ */
+lne3.toStartEnd = box3.toBounds;
+
+/**
+ * Sets the line start from a vector
+ * @param {lne3} out
+ * @param {vec3} v
+ */
+lne3.setStart = box3.setMinBounds;
+
+/**
+ * Sets the line end from a vector
+ * @param {lne3} out
+ * @param {vec3} v
+ */
+lne3.setEnd = box3.setMaxBounds;
+
+/**
+ * Transforms a lne3 by a mat4
+ *
+ * @param {lne3} out
+ * @param {lne3} a
+ * @param {mat4} m
+ * @returns {lne3} out
+ */
+lne3.transformMat4 = function(out, a, m)
+{
+    let ax = a[0],
+        ay = a[1],
+        az = a[2],
+        bx = a[3],
+        by = a[4],
+        bz = a[5],
+        aw = m[3] * ax + m[7] * ay + m[11] * az + m[15],
+        bw = m[3] * bx + m[7] * by + m[11] * bz + m[15];
+
+    aw = aw || 1;
+    bw = bw || 1;
+
+    out[0] = (m[0] * ax + m[4] * ay + m[8] * az + m[12]) / aw;
+    out[1] = (m[1] * ax + m[5] * ay + m[9] * az + m[13]) / aw;
+    out[2] = (m[2] * ax + m[6] * ay + m[10] * az + m[14]) / aw;
+
+    out[3] = (m[0] * bx + m[4] * by + m[8] * bz + m[12]) / bw;
+    out[4] = (m[1] * bx + m[5] * by + m[9] * bz + m[13]) / bw;
+    out[5] = (m[2] * bx + m[6] * by + m[10] * bz + m[14]) / bw;
+
+    return out;
+};
+
+/**
+ * Translates a lne3
+ *
+ * @param {lne3} out
+ * @param {lne3} a
+ * @param {vec3} v
+ * @returns {lne3} out
+ */
+lne3.translate = function(out, a, v)
+{
+    out[0] = a[0] + v[0];
+    out[1] = a[1] + v[1];
+    out[2] = a[2] + v[2];
+    out[3] = a[3] + v[0];
+    out[4] = a[4] + v[1];
+    out[5] = a[5] + v[2];
+    return out;
+};
+
+export const {
+    alloc,
+    unalloc,
+    $end,
+    $start,
+    clone,
+    closestPointToPointParameter,
+    copy,
+    copyStart,
+    copyEnd,
+    create,
+    equals,
+    equalsStartEnd,
+    exactEquals,
+    exactEqualsStartEnd,
+    fromArray,
+    fromStartEnd,
+    get,
+    getCenter,
+    getClosestPointToPoint,
+    getEnd,
+    getDelta,
+    getStart,
+    intersectsNormalConstant,
+    length,
+    set,
+    squaredLength,
+    toArray,
+    toStartEnd,
+    setStart,
+    setEnd,
+    transformMat4,
+    translate
+} = lne3;

package/src/lookup.js

@@ -0,0 +1,48 @@
+/** Compares string representations by stable Unicode code-unit order. */
+export function compareCodeUnits(left, right)
+{
+    const a = String(left);
+    const b = String(right);
+
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/** Returns a new string array in stable Unicode code-unit order. */
+export function sortStrings(values)
+{
+    return Array.from(values, String).sort(compareCodeUnits);
+}
+
+/** Builds a Map and rejects duplicate keys instead of silently overwriting. */
+export function indexBy(values, keySelector, options = {})
+{
+    if (typeof keySelector !== "function")
+    {
+        throw new TypeError("indexBy keySelector must be a function.");
+    }
+
+    const result = new Map();
+    const label = options.label ?? "value";
+    let index = 0;
+
+    for (const value of values)
+    {
+        const key = keySelector(value, index++);
+
+        if (result.has(key))
+        {
+            throw new Error(`Duplicate ${label} key ${formatKey(key)}.`);
+        }
+
+        result.set(key, value);
+    }
+
+    return result;
+}
+
+function formatKey(value)
+{
+    const json = JSON.stringify(value);
+
+    return json === undefined ? String(value) : json;
+}

package/src/mat3.js

@@ -0,0 +1,131 @@
+import * as glMat3 from "gl-matrix/esm/mat3.js";
+import { pool } from "./pool.js";
+
+const mat3 = { ...glMat3 };
+
+export { mat3 };
+
+/**
+ * Allocates a pooled mat3
+ * @returns {Float32Array|mat3}
+ */
+mat3.alloc = function()
+{
+    return pool.allocF32(9);
+};
+
+/**
+ * Unallocates a pooled mat3
+ * @param {mat3|Float32Array} a
+ */
+mat3.unalloc = function(a)
+{
+    pool.freeType(a);
+};
+
+/**
+ * Sets a mat3 from an array at an option offset
+ *
+ * @param {mat3} out
+ * @param {Array} arr
+ * @param {number} [offset=0]
+ * @returns {mat3} out
+ */
+mat3.fromArray = function(out, arr, offset = 0)
+{
+    out[0] = arr[offset];
+    out[1] = arr[offset + 1];
+    out[2] = arr[offset + 2];
+    out[3] = arr[offset + 3];
+    out[4] = arr[offset + 4];
+    out[5] = arr[offset + 5];
+    out[6] = arr[offset + 6];
+    out[7] = arr[offset + 7];
+    out[8] = arr[offset + 8];
+    return out;
+};
+
+/**
+ * Sets a mat3 from an array at an option offset
+ *
+ * @param {mat3} out
+ * @param {Array} arr
+ * @param {number} [index=0]
+ * @returns {mat3} out
+ */
+mat3.setArray = function(out, arr, index = 0)
+{
+    out[0] = arr[index];
+    out[1] = arr[index + 1];
+    out[2] = arr[index + 2];
+    out[3] = arr[index + 3];
+    out[4] = arr[index + 4];
+    out[5] = arr[index + 5];
+    out[6] = arr[index + 6];
+    out[7] = arr[index + 7];
+    out[8] = arr[index + 8];
+    return out;
+};
+
+/**
+ * Sets an array at an optional offset
+ *
+ * @param {mat3} a
+ * @param {Array} arr
+ * @param {number} [index=0]
+ * @returns {mat3} a
+ */
+mat3.toArray = function(a, arr, index = 0)
+{
+    arr[index] = a[0];
+    arr[index + 1] = a[1];
+    arr[index + 2] = a[2];
+    arr[index + 3] = a[3];
+    arr[index + 4] = a[4];
+    arr[index + 5] = a[5];
+    arr[index + 6] = a[6];
+    arr[index + 7] = a[7];
+    arr[index + 8] = a[8];
+    return a;
+};
+
+export const {
+    add,
+    adjoint,
+    clone,
+    copy,
+    create,
+    determinant,
+    equals,
+    exactEquals,
+    frob,
+    fromMat2d,
+    fromMat4,
+    fromQuat,
+    fromRotation,
+    fromScaling,
+    fromTranslation,
+    fromValues,
+    identity,
+    invert,
+    mul,
+    multiply,
+    multiplyScalar,
+    multiplyScalarAndAdd,
+    normalFromMat4,
+    projection,
+    rotate,
+    scale,
+    set,
+    str,
+    sub,
+    subtract,
+    translate,
+    transpose,
+    alloc,
+    unalloc,
+    fromArray,
+    setArray,
+    toArray
+} = mat3;
+