@carbonenginejs/core-math 0.1.0

package/src/geometry/torus.js

@@ -0,0 +1,88 @@
+import { toJSON } from "./json.js";
+import { vec3 } from "../vec3.js";
+
+
+export function createTorus(options = {})
+{
+    let {
+        radius = 1,
+        tube = 0.4,
+        radialSegments = 12,
+        tubularSegments = 49,
+        arc = Math.PI * 2
+    } = options;
+
+    radialSegments = Math.floor(radialSegments);
+    tubularSegments = Math.floor(tubularSegments);
+
+    const
+        indices = [],
+        positions = [],
+        uvs = [],
+        normals = [];
+
+    const
+        center = vec3.alloc(),
+        vertex = vec3.alloc(),
+        normal = vec3.alloc();
+
+    // generate vertices, normals and uvs
+    for (let j = 0; j <= radialSegments; j++)
+    {
+        for (let i = 0; i <= tubularSegments; i++)
+        {
+            const
+                u = i / tubularSegments * arc,
+                v = j / radialSegments * Math.PI * 2;
+
+            // vertex
+            vertex[0] = (radius + tube * Math.cos(v)) * Math.cos(u);
+            vertex[1] = (radius + tube * Math.cos(v)) * Math.sin(u);
+            vertex[2] = tube * Math.sin(v);
+            positions.push(vertex[0], vertex[1], vertex[2]);
+
+            // normal
+            center[0] = radius * Math.cos(u);
+            center[1] = radius * Math.sin(u);
+            vec3.subtract(normal, vertex, center);
+            vec3.normalize(normal, normal);
+            normals.push(normal[0], normal[1], normal[2]);
+
+            // uv
+            uvs.push(i / tubularSegments);
+            uvs.push(j / radialSegments);
+        }
+    }
+
+    vec3.unalloc(center);
+    vec3.unalloc(vertex);
+    vec3.unalloc(normal);
+
+    // generate indices
+    for (let j = 1; j <= radialSegments; j++)
+    {
+        for (let i = 1; i <= tubularSegments; i++)
+        {
+            // indices
+            const
+                a = (tubularSegments + 1) * j + i - 1,
+                b = (tubularSegments + 1) * (j - 1) + i - 1,
+                c = (tubularSegments + 1) * (j - 1) + i,
+                d = (tubularSegments + 1) * j + i;
+            // faces
+            indices.push(a, b, d);
+            indices.push(b, c, d);
+        }
+    }
+
+    const result = toJSON(indices, positions, uvs, normals);
+    result.factory = createTorus;
+    result.options = {
+        radius,
+        tube,
+        radialSegments,
+        tubularSegments,
+        arc
+    };
+    return result;
+}

package/src/index.js

@@ -0,0 +1,29 @@
+export * as num from "./num.js";
+export * as vec2 from "./vec2.js";
+export * as vec3 from "./vec3.js";
+export * as vec4 from "./vec4.js";
+export * as quat from "./quat.js";
+export * as mat3 from "./mat3.js";
+export * as mat4 from "./mat4.js";
+
+export * as box3 from "./box3.js";
+export * as tri3 from "./tri3.js";
+export * as lne3 from "./lne3.js";
+export * as pln from "./pln.js";
+export * as ray3 from "./ray3.js";
+export * as sph3 from "./sph3.js";
+
+export * as pool from "./pool.js";
+export * as noise from "./noise.js";
+export * as curve from "./curve.js";
+
+export * as geometry from "./geometry/index.js";
+export * as vertex from "./vertex.js";
+export * as mesh from "./mesh.js";
+export * as tangent from "./tangent.js";
+
+
+/**
+ * TypedArray
+ * @typedef {Float64Array|Float32Array|Uint32Array|Uint16Array|Uint8Array|Uint8ClampedArray|Int32Array|Int16Array|Int8Array} TypedArray
+ */

package/src/lne3.js

@@ -0,0 +1,488 @@
+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 = 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 x = a.subarray(0, 3);
+    return lne3.get(out, a, lne3.closestPointToPointParameter(a, point, clampToLine));
+};
+
+/**
+ * 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) || (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];
+
+    out[0] = m[0] * ax + m[4] * ay + m[8] * az + m[12];
+    out[1] = m[1] * ax + m[5] * ay + m[9] * az + m[13];
+    out[2] = m[2] * ax + m[6] * ay + m[10] * az + m[14];
+
+    out[3] = m[0] * bx + m[4] * by + m[8] * bz + m[12];
+    out[4] = m[1] * bx + m[5] * by + m[9] * bz + m[13];
+    out[5] = m[2] * bx + m[6] * by + m[10] * bz + m[14];
+
+    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/mat3.js

@@ -0,0 +1,131 @@
+import { mat3 as glMat3 } from "gl-matrix";
+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;
+