@carbonenginejs/core-math 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carbonenginejs/core-math",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Browser-friendly gl-matrix based math containers and CarbonEngineJS mesh/tangent helpers.",
   "type": "module",
   "main": "src/index.js",
@@ -71,4 +71,3 @@
     "access": "public"
   }
 }
-

package/src/mat3.js

@@ -1,4 +1,4 @@
-import { mat3 as glMat3 } from "gl-matrix";
+import * as glMat3 from "gl-matrix/esm/mat3.js";
 import { pool } from "./pool.js";
 
 const mat3 = { ...glMat3 };

package/src/mat4.js

@@ -1,9 +1,15 @@
-import { mat4 as glMat4, vec3 as glVec3 } from "gl-matrix";
+import * as glMat4 from "gl-matrix/esm/mat4.js";
+import {
+    copy as copyVec3,
+    cross as crossVec3,
+    dot as dotVec3,
+    normalize as normalizeVec3,
+    squaredLength as squaredLengthVec3,
+    subtract as subtractVec3
+} from "gl-matrix/esm/vec3.js";
 import { pool } from "./pool.js";
 
-const
-    mat4 = { ...glMat4 },
-    vec3 = { ...glVec3 };
+const mat4 = { ...glMat4 };
 
 export { mat4 };
 
@@ -81,9 +87,9 @@ mat4.fromJointMatIndex = function (out, jointMat, index)
  * @param {vec3} v
  * @return {mat4} out
  */
-mat4.arcFromForward = function (out, v)
-{
-    const norm = vec3.normalize(pool.allocF32(3), v);
+mat4.arcFromForward = function (out, v)
+{
+    const norm = normalizeVec3(pool.allocF32(3), v);
 
     mat4.identity(out);
 
@@ -193,32 +199,32 @@ mat4.lookAtD3D = function (out, eye, center, up)
     const z = pool.allocF32(3);
 
     // z = forward = normalize(center - eye)   (LH)
-    vec3.subtract(z, center, eye);
-
-    if (vec3.squaredLength(z) === 0)
+    subtractVec3(z, center, eye);
+
+    if (squaredLengthVec3(z) === 0)
     {
         z[2] = 1;
     }
 
-    vec3.normalize(z, z);
-
-    // x = normalize(cross(up, z))
-    vec3.cross(x, up, z);
-
-    if (vec3.squaredLength(x) === 0)
+    normalizeVec3(z, z);
+
+    // x = normalize(cross(up, z))
+    crossVec3(x, up, z);
+
+    if (squaredLengthVec3(x) === 0)
     {
         // nudge z slightly if up is parallel
         if (Math.abs(up[2]) === 1) z[0] += 0.0001;
         else z[2] += 0.0001;
 
-        vec3.normalize(z, z);
-        vec3.cross(x, up, z);
-    }
-
-    vec3.normalize(x, x);
-
-    // y = cross(z, x)
-    vec3.cross(y, z, x);
+        normalizeVec3(z, z);
+        crossVec3(x, up, z);
+    }
+
+    normalizeVec3(x, x);
+
+    // y = cross(z, x)
+    crossVec3(y, z, x);
 
     // Rotation (axes in columns)
     out[0] = x[0]; out[1] = x[1]; out[2]  = x[2];  out[3]  = 0;
@@ -226,9 +232,9 @@ mat4.lookAtD3D = function (out, eye, center, up)
     out[8] = z[0]; out[9] = z[1]; out[10] = z[2];  out[11] = 0;
 
     // Translation
-    out[12] = -vec3.dot(x, eye);
-    out[13] = -vec3.dot(y, eye);
-    out[14] = -vec3.dot(z, eye);
+    out[12] = -dotVec3(x, eye);
+    out[13] = -dotVec3(y, eye);
+    out[14] = -dotVec3(z, eye);
     out[15] = 1;
 
     pool.freeType(x);
@@ -266,17 +272,17 @@ mat4.setLookRotation = function (out, m, eye, center, up)
         u = pool.allocF32(3); // safeUp
 
     // z axis = eye - center  (camera backward); -z is forward
-    vec3.subtract(z, eye, center);
-
-    if (vec3.squaredLength(z) === 0)
+    subtractVec3(z, eye, center);
+
+    if (squaredLengthVec3(z) === 0)
     {
         // arbitrary (back)
         z[2] = 1;
     }
-    vec3.normalize(z, z);
-
-    // Pick a stable up if the provided up is too aligned with z
-    vec3.copy(u, up);
+    normalizeVec3(z, z);
+
+    // Pick a stable up if the provided up is too aligned with z
+    copyVec3(u, up);
 
     // if |dot(up, z)| is ~1 then up × z is unstable
     const dz = Math.abs(u[0] * z[0] + u[1] * z[1] + u[2] * z[2]);
@@ -293,10 +299,10 @@ mat4.setLookRotation = function (out, m, eye, center, up)
     }
 
     // x = up × z
-    vec3.cross(x, u, z);
-
-    // Still degenerate? (can happen if 'up' was zero-length etc.)
-    if (vec3.squaredLength(x) === 0)
+    crossVec3(x, u, z);
+
+    // Still degenerate? (can happen if 'up' was zero-length etc.)
+    if (squaredLengthVec3(x) === 0)
     {
         // fall back to a guaranteed-not-parallel up using z's dominant axis
         if (Math.abs(z[1]) < 0.999)
@@ -307,13 +313,13 @@ mat4.setLookRotation = function (out, m, eye, center, up)
         {
             u[0] = 1; u[1] = 0; u[2] = 0;
         }
-        vec3.cross(x, u, z);
-    }
-
-    vec3.normalize(x, x);
-
-    // y = z × x
-    vec3.cross(y, z, x);
+        crossVec3(x, u, z);
+    }
+
+    normalizeVec3(x, x);
+
+    // y = z × x
+    crossVec3(y, z, x);
 
     // write rotation (columns)
     out[0]  = x[0]; out[1]  = x[1]; out[2]  = x[2];

package/src/mesh.js

@@ -5,8 +5,11 @@
  * plain arrays or typed arrays and return plain arrays unless otherwise noted.
  */
 
-import { num } from "./num.js";
-import { vec3 } from "./vec3.js";
+import {
+    cross,
+    length as vec3Length,
+    normalize
+} from "gl-matrix/esm/vec3.js";
 
 /**
  * Calculate the unit face normal for a triangle.
@@ -19,12 +22,12 @@ import { vec3 } from "./vec3.js";
 export function triangleNormal(a, b, c)
 {
     const normal = [ 0, 0, 0 ];
-    vec3.cross(
+    cross(
         normal,
         [ b[0] - a[0], b[1] - a[1], b[2] - a[2] ],
         [ c[0] - a[0], c[1] - a[1], c[2] - a[2] ]
     );
-    return vec3.normalize(normal, normal);
+    return normalize(normal, normal);
 }
 
 /**
@@ -38,12 +41,12 @@ export function triangleNormal(a, b, c)
 export function triangleArea2(a, b, c)
 {
     const normal = [ 0, 0, 0 ];
-    vec3.cross(
+    cross(
         normal,
         [ b[0] - a[0], b[1] - a[1], b[2] - a[2] ],
         [ c[0] - a[0], c[1] - a[1], c[2] - a[2] ]
     );
-    return vec3.length(normal);
+    return vec3Length(normal);
 }
 
 /**
@@ -127,24 +130,26 @@ export function computeBoundsFromTriangles(triangles)
  *
  * @param {ArrayLike<number>} positions Flat xyz positions.
  * @param {ArrayLike<number>} indices Flat triangle indices.
- * @returns {number[]} Flat xyz normals.
+ * @returns {Float32Array} Flat xyz normals.
  */
 export function generateNormals(positions, indices)
 {
-    const normals = new Array(positions.length).fill(0);
+    const
+        vertexCount = positions.length / 3,
+        normals = new Float32Array(positions.length);
 
-    for (let i = 0; i < indices.length; i += 3)
+    for (let t = 0; t < indices.length; t += 3)
     {
         const
-            ia = indices[i] * 3,
-            ib = indices[i + 1] * 3,
-            ic = indices[i + 2] * 3,
+            ia = indices[t] * 3,
+            ib = indices[t + 1] * 3,
+            ic = indices[t + 2] * 3,
             ax = positions[ia],
             ay = positions[ia + 1],
             az = positions[ia + 2],
             faceNormal = [ 0, 0, 0 ];
 
-        vec3.cross(
+        cross(
             faceNormal,
             [ positions[ib] - ax, positions[ib + 1] - ay, positions[ib + 2] - az ],
             [ positions[ic] - ax, positions[ic + 1] - ay, positions[ic + 2] - az ]
@@ -158,12 +163,15 @@ export function generateNormals(positions, indices)
         }
     }
 
-    for (let i = 0; i < normals.length; i += 3)
+    for (let i = 0; i < vertexCount; i++)
     {
-        const n = vec3.normalize([ 0, 0, 0 ], [ normals[i], normals[i + 1], normals[i + 2] ]);
-        normals[i] = n[0];
-        normals[i + 1] = n[1];
-        normals[i + 2] = n[2];
+        const
+            offset = i * 3,
+            length = Math.hypot(normals[offset], normals[offset + 1], normals[offset + 2]) || 1;
+
+        normals[offset] /= length;
+        normals[offset + 1] /= length;
+        normals[offset + 2] /= length;
     }
 
     return normals;
@@ -176,20 +184,21 @@ export function generateNormals(positions, indices)
  * @param {ArrayLike<number>} normals Flat xyz normals.
  * @param {ArrayLike<number>} uvs Flat uv coordinates.
  * @param {ArrayLike<number>} indices Flat triangle indices.
- * @returns {number[]} Flat xyz tangents.
+ * @returns {Float32Array} Flat xyz tangents.
  */
 export function generateTangents(positions, normals, uvs, indices)
 {
     const
         vertexCount = positions.length / 3,
-        tangents = new Array(vertexCount * 3).fill(0);
+        tan1 = new Float32Array(vertexCount * 3),
+        tan2 = new Float32Array(vertexCount * 3);
 
-    for (let i = 0; i < indices.length; i += 3)
+    for (let t = 0; t < indices.length; t += 3)
     {
         const
-            i0 = indices[i],
-            i1 = indices[i + 1],
-            i2 = indices[i + 2],
+            i0 = indices[t],
+            i1 = indices[t + 1],
+            i2 = indices[t + 2],
             p0 = i0 * 3,
             p1 = i1 * 3,
             p2 = i2 * 3,
@@ -206,43 +215,52 @@ export function generateTangents(positions, normals, uvs, indices)
             v1 = uvs[t1 + 1] - uvs[t0 + 1],
             s2 = uvs[t2] - uvs[t0],
             v2 = uvs[t2 + 1] - uvs[t0 + 1],
-            divisor = s1 * v2 - s2 * v1;
-
-        if (Math.abs(divisor) <= num.EPSILON) continue;
-
-        const
-            scale = 1 / divisor,
-            tx = (v2 * x1 - v1 * x2) * scale,
-            ty = (v2 * y1 - v1 * y2) * scale,
-            tz = (v2 * z1 - v1 * z2) * scale;
+            divisor = s1 * v2 - s2 * v1,
+            scale = divisor ? 1 / divisor : 0,
+            sx = (v2 * x1 - v1 * x2) * scale,
+            sy = (v2 * y1 - v1 * y2) * scale,
+            sz = (v2 * z1 - v1 * z2) * scale,
+            tx = (s1 * x2 - s2 * x1) * scale,
+            ty = (s1 * y2 - s2 * y1) * scale,
+            tz = (s1 * z2 - s2 * z1) * scale;
 
         for (const offset of [ p0, p1, p2 ])
         {
-            tangents[offset] += tx;
-            tangents[offset + 1] += ty;
-            tangents[offset + 2] += tz;
+            tan1[offset] += sx;
+            tan1[offset + 1] += sy;
+            tan1[offset + 2] += sz;
+            tan2[offset] += tx;
+            tan2[offset + 1] += ty;
+            tan2[offset + 2] += tz;
         }
     }
 
-    for (let i = 0; i < tangents.length; i += 3)
+    const tangents = new Float32Array(vertexCount * 3);
+    for (let i = 0; i < vertexCount; i++)
     {
         const
-            nx = normals[i],
-            ny = normals[i + 1],
-            nz = normals[i + 2],
-            tx = tangents[i],
-            ty = tangents[i + 1],
-            tz = tangents[i + 2],
-            normalDotTangent = nx * tx + ny * ty + nz * tz,
-            tangent = vec3.normalize([ 0, 0, 0 ], [
-                tx - nx * normalDotTangent,
-                ty - ny * normalDotTangent,
-                tz - nz * normalDotTangent
-            ]);
-
-        tangents[i] = tangent[0];
-        tangents[i + 1] = tangent[1];
-        tangents[i + 2] = tangent[2];
+            offset = i * 3,
+            nx = normals[offset],
+            ny = normals[offset + 1],
+            nz = normals[offset + 2],
+            tx = tan1[offset],
+            ty = tan1[offset + 1],
+            tz = tan1[offset + 2],
+            normalDotTangent = nx * tx + ny * ty + nz * tz;
+
+        let ox = tx - nx * normalDotTangent,
+            oy = ty - ny * normalDotTangent,
+            oz = tz - nz * normalDotTangent;
+
+        const length = Math.hypot(ox, oy, oz) || 1;
+
+        ox /= length;
+        oy /= length;
+        oz /= length;
+
+        tangents[offset] = ox;
+        tangents[offset + 1] = oy;
+        tangents[offset + 2] = oz;
     }
 
     return tangents;
@@ -270,7 +288,7 @@ export function generateBiNormals(normals, tangents, { uvHandedness = "right" }
 
     for (let i = 0; i < normals.length; i += 3)
     {
-        const b = vec3.normalize(
+        const b = normalize(
             [ 0, 0, 0 ],
             [
                 normals[i + 1] * tangents[i + 2] - normals[i + 2] * tangents[i + 1],

package/src/quat.js

@@ -1,6 +1,6 @@
-import { quat as glQuat } from "gl-matrix";
-import { vec3 } from "./vec3.js";
-import { num } from "./num.js";
+import * as glQuat from "gl-matrix/esm/quat.js";
+import { dot as vec3Dot } from "gl-matrix/esm/vec3.js";
+import { EPSILON } from "./num.js";
 import { pool } from "./pool.js";
 
 const quat = { ...glQuat };
@@ -35,8 +35,8 @@ quat.unalloc = function(a)
  */
 quat.fromUnitVectors = function(out, from, to)
 {
-    let r = vec3.dot(from, to) + 1;
-    if (r < num.EPSILON)
+    let r = vec3Dot(from, to) + 1;
+    if (r < EPSILON)
     {
         r = 0;
         if (Math.abs(from[0]) > Math.abs(from[2]))

package/src/tangent.js

@@ -11,8 +11,16 @@ import {
     generateNormals,
     generateTangents
 } from "./mesh.js";
-import { num } from "./num.js";
-import { vec3 } from "./vec3.js";
+import {
+    EPSILON,
+    clamp
+} from "./num.js";
+import {
+    cross,
+    dot,
+    length as vec3Length,
+    normalize
+} from "gl-matrix/esm/vec3.js";
 
 /** Full-turn float32 constant used by the CCP tangent-frame shader. */
 export const TANGENT_TAU = 6.28318548;
@@ -100,18 +108,18 @@ export function decodeTangentFrame(u)
 export function encodeTangentFrame(T, B, N)
 {
     let a0 = Math.atan2(T[1], T[0]),
-        a1 = Math.acos(num.clamp(T[2], -1, 1));
+        a1 = Math.acos(clamp(T[2], -1, 1));
 
     const
         a2 = Math.atan2(B[1], B[0]),
-        a3 = Math.acos(num.clamp(B[2], -1, 1));
+        a3 = Math.acos(clamp(B[2], -1, 1));
 
-    if (N && vec3.dot(N, vec3.cross([ 0, 0, 0 ], T, B)) < 0)
+    if (N && dot(N, cross([ 0, 0, 0 ], T, B)) < 0)
     {
         a1 = -a1;
     }
 
-    const enc = angle => num.clamp((angle + PI) / TAU, 0, 1);
+    const enc = angle => clamp((angle + PI) / TAU, 0, 1);
     return [ enc(a0), enc(a1), enc(a2), enc(a3) ];
 }
 
@@ -212,11 +220,11 @@ export function packTangentFrames(normals, tangents, binormals)
     for (let i = 0, o = 0; i < normals.length; i += 3, o += 4)
     {
         const
-            normal = vec3.normalize([ 0, 0, 0 ], [ normals[i], normals[i + 1], normals[i + 2] ]),
-            tangent = vec3.normalize([ 0, 0, 0 ], [ tangents[i], tangents[i + 1], tangents[i + 2] ]),
-            binormal = vec3.normalize([ 0, 0, 0 ], [ binormals[i], binormals[i + 1], binormals[i + 2] ]);
+            normal = normalize([ 0, 0, 0 ], [ normals[i], normals[i + 1], normals[i + 2] ]),
+            tangent = normalize([ 0, 0, 0 ], [ tangents[i], tangents[i + 1], tangents[i + 2] ]),
+            binormal = normalize([ 0, 0, 0 ], [ binormals[i], binormals[i + 1], binormals[i + 2] ]);
 
-        if (vec3.length(normal) <= num.EPSILON || vec3.length(tangent) <= num.EPSILON || vec3.length(binormal) <= num.EPSILON)
+        if (vec3Length(normal) <= EPSILON || vec3Length(tangent) <= EPSILON || vec3Length(binormal) <= EPSILON)
         {
             packed[o] = NULL_TANGENT_UNORM[0];
             packed[o + 1] = NULL_TANGENT_UNORM[1];

package/src/vec2.js

@@ -1,4 +1,4 @@
-import { vec2 as glVec2 } from "gl-matrix";
+import * as glVec2 from "gl-matrix/esm/vec2.js";
 import { pool } from "./pool.js";
 
 const vec2 = { ...glVec2 };

package/src/vec3.js

@@ -1,11 +1,13 @@
-import { vec3 as glVec3, mat4 as glMat4 } from "gl-matrix";
+import * as glVec3 from "gl-matrix/esm/vec3.js";
+import {
+    fromQuat as mat4FromQuat,
+    getRotation as getMat4Rotation
+} from "gl-matrix/esm/mat4.js";
+import { transformMat4 as transformVec4Mat4 } from "gl-matrix/esm/vec4.js";
 import { num } from "./num.js";
 import { pool } from "./pool.js";
-import { vec4 } from "./vec4.js";
 
-const
-    vec3 = { ...glVec3 },
-    mat4 = { ...glMat4 };
+const vec3 = { ...glVec3 };
 
 /**
  * Vector 3
@@ -136,13 +138,13 @@ vec3.directionFromQuat = function (out, axis, q)
  * @param {mat4} m
  * @returns {vec3} out
  */
-vec3.directionFromMat4 = function (out, axis, m)
-{
-    const quat_0 = mat4.getRotation(vec4.alloc(), m);
-    vec3.transformQuat(out, axis, quat_0);
-    vec4.unalloc(quat_0);
-    return out;
-};
+vec3.directionFromMat4 = function (out, axis, m)
+{
+    const quat_0 = getMat4Rotation(pool.allocF32(4), m);
+    vec3.transformQuat(out, axis, quat_0);
+    pool.freeType(quat_0);
+    return out;
+};
 
 /**
  * Divides a vec3 by a scalar
@@ -178,13 +180,13 @@ vec3.euler.DEFAULT_ORDER = "XYZ";
  * @param {string} [order=vec3.euler.DEFAULT_ORDER]
  * @returns {vec3} out
  */
-vec3.euler.fromQuat = function (out, q, order = vec3.euler.DEFAULT_ORDER)
-{
-    // mat4.alloc
-    const mat4_0 = mat4.fromQuat(pool.allocF32(16), q);
-    vec3.euler.fromMat4(out, mat4_0, order);
-    pool.unalloc(mat4_0);
-    return out;
+vec3.euler.fromQuat = function (out, q, order = vec3.euler.DEFAULT_ORDER)
+{
+    // mat4.alloc
+    const mat4_0 = mat4FromQuat(pool.allocF32(16), q);
+    vec3.euler.fromMat4(out, mat4_0, order);
+    pool.unalloc(mat4_0);
+    return out;
 };
 
 /**
@@ -687,9 +689,9 @@ vec3.subtractScalar = function (out, a, s)
  * @returns {vec3} out
  * @throw On perspective divide error
  */
-vec3.unproject = function (out, a, invViewProj, viewport)
-{
-    const vec4_0 = vec4.alloc(4);
+vec3.unproject = function (out, a, invViewProj, viewport)
+{
+    const vec4_0 = pool.allocF32(4);
 
     let x = a[0],
         y = a[1],
@@ -700,14 +702,14 @@ vec3.unproject = function (out, a, invViewProj, viewport)
     vec4_0[2] = 2.0 * z - 1.0;
     vec4_0[3] = 1.0;
 
-    vec4.transformMat4(vec4_0, vec4_0, invViewProj);
-
-    if (vec4_0[3] === 0.0)
-    {
-        vec4.unalloc(vec4_0);
-        out[0] = 0;
-        out[1] = 0;
-        out[2] = 0;
+    transformVec4Mat4(vec4_0, vec4_0, invViewProj);
+
+    if (vec4_0[3] === 0.0)
+    {
+        pool.freeType(vec4_0);
+        out[0] = 0;
+        out[1] = 0;
+        out[2] = 0;
         throw new Error("Perspective divide error");
     }
 
@@ -715,10 +717,10 @@ vec3.unproject = function (out, a, invViewProj, viewport)
     out[1] = vec4_0[1] / vec4_0[3];
     out[2] = vec4_0[2] / vec4_0[3];
 
-    vec4.unalloc(vec4_0);
-
-    return out;
-};
+    pool.freeType(vec4_0);
+
+    return out;
+};
 
 /**
  * Unwraps degrees

package/src/vec4.js

@@ -1,4 +1,4 @@
-import { vec4 as glVec4 } from "gl-matrix";
+import * as glVec4 from "gl-matrix/esm/vec4.js";
 import { num } from "./num.js";
 import { pool } from "./pool.js";