@carbonenginejs/runtime-utils 0.1.0

package/src/pool.js

@@ -0,0 +1,160 @@
+import {
+    GL_BYTE,
+    GL_UNSIGNED_BYTE,
+    GL_SHORT,
+    GL_UNSIGNED_SHORT,
+    GL_INT,
+    GL_UNSIGNED_INT,
+    GL_FLOAT
+} from "./constants.js";
+
+
+function loop(n, f)
+{
+    const result = Array(n);
+    for (let i = 0; i < n; ++i) result[i] = f(i);
+    return result;
+}
+
+function nextPow16(v)
+{
+    for (let i = 16; i <= (1 << 28); i *= 16)
+    {
+        if (v <= i) return i;
+    }
+    return 0;
+}
+
+function log2(v)
+{
+    let r, shift;
+    r = (v > 0xFFFF) << 4;
+    v >>>= r;
+    shift = (v > 0xFF) << 3;
+    v >>>= shift;
+    r |= shift;
+    shift = (v > 0xF) << 2;
+    v >>>= shift;
+    r |= shift;
+    shift = (v > 0x3) << 1;
+    v >>>= shift;
+    r |= shift;
+    return r | (v >> 1);
+}
+
+export function createPool()
+{
+
+    const bufferPool = loop(8, function ()
+    {
+        return [];
+    });
+
+    function free(buf)
+    {
+        bufferPool[log2(buf.byteLength) >> 2].push(buf);
+    }
+
+    function alloc(n)
+    {
+        let sz = nextPow16(n),
+            bin = bufferPool[log2(sz) >> 2];
+
+        if (bin.length > 0) return bin.pop();
+
+        return new ArrayBuffer(sz);
+    }
+
+    /**
+     * Shortcut to allocating a float 32 array
+     * @param {Number} length
+     * @returns {Float32Array}
+     */
+    function allocF32(length)
+    {
+        const result = new Float32Array(alloc(4 * length), 0, length);
+        return result.length !== length ? result.subarray(0, length) : result;
+    }
+
+    /**
+     * Allocated a typed array of a given size
+     * @param {Number|Function}type
+     * @param {Number} n
+     * @returns {Int8Array|Uint8Array|Int16Array|Uint16Array|Int32Array|Uint32Array|Float32Array|null}
+     */
+    function allocType(type, n)
+    {
+        let result = null;
+        switch (type)
+        {
+            case GL_BYTE:
+            case Int8Array:
+                result = new Int8Array(alloc(n), 0, n);
+                break;
+
+            case GL_UNSIGNED_BYTE:
+            case Uint8Array:
+                result = new Uint8Array(alloc(n), 0, n);
+                break;
+
+            case GL_SHORT:
+            case Int16Array:
+                result = new Int16Array(alloc(2 * n), 0, n);
+                break;
+
+            case GL_UNSIGNED_SHORT:
+            case Uint16Array:
+                result = new Uint16Array(alloc(2 * n), 0, n);
+                break;
+
+            case GL_INT:
+            case Int32Array:
+                result = new Int32Array(alloc(4 * n), 0, n);
+                break;
+
+            case GL_UNSIGNED_INT:
+            case Uint32Array:
+                result = new Uint32Array(alloc(4 * n), 0, n);
+                break;
+
+            case GL_FLOAT:
+            case Float32Array:
+                result = new Float32Array(alloc(4 * n), 0, n);
+                break;
+
+            default:
+                return null;
+        }
+
+        if (result.length !== n)
+        {
+            return result.subarray(0, n);
+        }
+
+        return result;
+    }
+
+    function freeType(array)
+    {
+        free(array.buffer);
+    }
+
+    return {
+        allocF32,
+        allocType,
+        unalloc: freeType,
+        freeType,
+        free
+    };
+
+}
+
+export const pool = createPool();
+
+export const {
+    allocF32,
+    allocType,
+    unalloc,
+    freeType,
+    free
+} = pool;

package/src/quat.js

@@ -0,0 +1,144 @@
+import * as glQuat from "gl-matrix/esm/quat.js";
+import { EPSILON } from "./num.js";
+import { pool } from "./pool.js";
+
+const quat = { ...glQuat };
+
+export { quat };
+
+/**
+ * Allocates a pooled vec4
+ * @returns {Float32Array|quat}
+ */
+quat.alloc = function()
+{
+    return pool.allocF32(4);
+};
+
+/**
+ * Unallocates a pooled vec4
+ * @param {Float32Array|quat} a
+ */
+quat.unalloc = function(a)
+{
+    pool.freeType(a);
+};
+
+/**
+ * Creates a quat from unit vectors
+ *
+ * @param {quat} out
+ * @param {vec3} from
+ * @param {vec3} to
+ * @returns {quat}
+ */
+quat.fromUnitVectors = function(out, from, to)
+{
+    const
+        fromX = from[0],
+        fromY = from[1],
+        fromZ = from[2],
+        toX = to[0],
+        toY = to[1],
+        toZ = to[2];
+
+    let r = fromX * toX + fromY * toY + fromZ * toZ + 1;
+    if (r < EPSILON)
+    {
+        r = 0;
+        if (Math.abs(fromX) > Math.abs(fromZ))
+        {
+            out[0] = -fromY;
+            out[1] = fromX;
+            out[2] = 0;
+            out[3] = r;
+        }
+        else
+        {
+            out[0] = 0;
+            out[1] = -fromZ;
+            out[2] = fromY;
+            out[3] = r;
+        }
+    }
+    else
+    {
+        out[0] = fromY * toZ - fromZ * toY;
+        out[1] = fromZ * toX - fromX * toZ;
+        out[2] = fromX * toY - fromY * toX;
+        out[3] = r;
+    }
+    return quat.normalize(out, out);
+};
+
+/**
+ * Creates a Carbon yaw/pitch/roll quaternion.
+ *
+ * @param {quat} out
+ * @param {number} yaw
+ * @param {number} pitch
+ * @param {number} roll
+ * @returns {quat}
+ */
+quat.fromYawPitchRoll = function(out, yaw, pitch, roll)
+{
+    const
+        sinYaw = Math.sin(yaw / 2),
+        cosYaw = Math.cos(yaw / 2),
+        sinPitch = Math.sin(pitch / 2),
+        cosPitch = Math.cos(pitch / 2),
+        sinRoll = Math.sin(roll / 2),
+        cosRoll = Math.cos(roll / 2);
+
+    out[0] = sinYaw * cosPitch * sinRoll + cosYaw * sinPitch * cosRoll;
+    out[1] = sinYaw * cosPitch * cosRoll - cosYaw * sinPitch * sinRoll;
+    out[2] = cosYaw * cosPitch * sinRoll - sinYaw * sinPitch * cosRoll;
+    out[3] = cosYaw * cosPitch * cosRoll + sinYaw * sinPitch * sinRoll;
+    return out;
+};
+
+export const {
+    add,
+    calculateW,
+    clone,
+    conjugate,
+    copy,
+    create,
+    dot,
+    equals,
+    exactEquals,
+    exp,
+    fromEuler,
+    fromMat3,
+    fromValues,
+    getAngle,
+    getAxisAngle,
+    identity,
+    invert,
+    len,
+    length,
+    lerp,
+    ln,
+    mul,
+    multiply,
+    normalize,
+    pow,
+    random,
+    rotateX,
+    rotateY,
+    rotateZ,
+    rotationTo,
+    scale,
+    set,
+    setAxes,
+    setAxisAngle,
+    slerp,
+    sqlerp,
+    sqrLen,
+    squaredLength,
+    str,
+    alloc,
+    unalloc,
+    fromUnitVectors,
+    fromYawPitchRoll
+} = quat;