@multiplekex/shallot 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@multiplekex/shallot",
-    "version": "0.1.2",
+    "version": "0.1.3",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",
@@ -19,8 +19,7 @@
     "dependencies": {
         "@mapbox/tiny-sdf": "^2.0.7",
         "bitecs": "^0.4.0",
-        "fast-xml-parser": "^5.3.3",
-        "wgpu-matrix": "^3.4.0"
+        "fast-xml-parser": "^5.3.3"
     },
     "devDependencies": {
         "@napi-rs/canvas": "^0.1.88",
@@ -28,7 +27,8 @@
         "@types/three": "^0.182.0",
         "three": "^0.182.0",
         "troika-three-text": "^0.52.4",
-        "webgpu": "^0.3.8"
+        "webgpu": "^0.3.8",
+        "wgpu-matrix": "^3.4.0"
     },
     "peerDependencies": {
         "typescript": "^5"

package/src/core/math.ts

@@ -1,15 +1,11 @@
-import { quat, utils, mat4 } from "wgpu-matrix";
+const DEG_TO_RAD = Math.PI / 180;
+const RAD_TO_DEG = 180 / Math.PI;
 
-const tempQuatA = quat.create();
-const tempQuatB = quat.create();
-const tempQuatOut = quat.create();
-const tempMat4 = mat4.create();
-const tempVec3A = new Float32Array(3);
-const tempVec3B = new Float32Array(3);
-const tempVec3C = new Float32Array(3);
+const _quat = { x: 0, y: 0, z: 0, w: 1 };
+const _euler = { x: 0, y: 0, z: 0 };
 
 export function clamp(value: number, min: number, max: number): number {
-    return Math.max(min, Math.min(max, value));
+    return value < min ? min : value > max ? max : value;
 }
 
 export function lerp(a: number, b: number, t: number): number {
@@ -27,25 +23,65 @@ export function slerp(
     toW: number,
     t: number
 ): { x: number; y: number; z: number; w: number } {
-    quat.set(fromX, fromY, fromZ, fromW, tempQuatA);
-    quat.set(toX, toY, toZ, toW, tempQuatB);
-    quat.slerp(tempQuatA, tempQuatB, t, tempQuatOut);
-    return { x: tempQuatOut[0], y: tempQuatOut[1], z: tempQuatOut[2], w: tempQuatOut[3] };
+    let dot = fromX * toX + fromY * toY + fromZ * toZ + fromW * toW;
+
+    if (dot < 0) {
+        dot = -dot;
+        toX = -toX;
+        toY = -toY;
+        toZ = -toZ;
+        toW = -toW;
+    }
+
+    let s0: number, s1: number;
+    if (dot > 0.9995) {
+        s0 = 1 - t;
+        s1 = t;
+    } else {
+        const theta0 = Math.acos(dot);
+        const sinTheta0 = Math.sqrt(1 - dot * dot);
+        const theta = theta0 * t;
+        const sinTheta = Math.sin(theta);
+        s0 = Math.cos(theta) - (dot * sinTheta) / sinTheta0;
+        s1 = sinTheta / sinTheta0;
+    }
+
+    _quat.x = s0 * fromX + s1 * toX;
+    _quat.y = s0 * fromY + s1 * toY;
+    _quat.z = s0 * fromZ + s1 * toZ;
+    _quat.w = s0 * fromW + s1 * toW;
+    return _quat;
 }
 
 export function rotateQuaternion(
-    quatX: number,
-    quatY: number,
-    quatZ: number,
-    quatW: number,
+    qx: number,
+    qy: number,
+    qz: number,
+    qw: number,
     dx: number,
     dy: number,
     dz: number
 ): { x: number; y: number; z: number; w: number } {
-    quat.fromEuler(utils.degToRad(dx), utils.degToRad(dy), utils.degToRad(dz), "xyz", tempQuatA);
-    quat.set(quatX, quatY, quatZ, quatW, tempQuatB);
-    quat.multiply(tempQuatB, tempQuatA, tempQuatOut);
-    return { x: tempQuatOut[0], y: tempQuatOut[1], z: tempQuatOut[2], w: tempQuatOut[3] };
+    const hx = dx * DEG_TO_RAD * 0.5;
+    const hy = dy * DEG_TO_RAD * 0.5;
+    const hz = dz * DEG_TO_RAD * 0.5;
+    const cx = Math.cos(hx),
+        sx = Math.sin(hx);
+    const cy = Math.cos(hy),
+        sy = Math.sin(hy);
+    const cz = Math.cos(hz),
+        sz = Math.sin(hz);
+
+    const bx = sx * cy * cz + cx * sy * sz;
+    const by = cx * sy * cz - sx * cy * sz;
+    const bz = cx * cy * sz + sx * sy * cz;
+    const bw = cx * cy * cz - sx * sy * sz;
+
+    _quat.x = qw * bx + qx * bw + qy * bz - qz * by;
+    _quat.y = qw * by - qx * bz + qy * bw + qz * bx;
+    _quat.z = qw * bz + qx * by - qy * bx + qz * bw;
+    _quat.w = qw * bw - qx * bx - qy * by - qz * bz;
+    return _quat;
 }
 
 export function eulerToQuaternion(
@@ -53,8 +89,21 @@ export function eulerToQuaternion(
     y: number,
     z: number
 ): { x: number; y: number; z: number; w: number } {
-    quat.fromEuler(utils.degToRad(x), utils.degToRad(y), utils.degToRad(z), "xyz", tempQuatOut);
-    return { x: tempQuatOut[0], y: tempQuatOut[1], z: tempQuatOut[2], w: tempQuatOut[3] };
+    const hx = x * DEG_TO_RAD * 0.5;
+    const hy = y * DEG_TO_RAD * 0.5;
+    const hz = z * DEG_TO_RAD * 0.5;
+    const cx = Math.cos(hx),
+        sx = Math.sin(hx);
+    const cy = Math.cos(hy),
+        sy = Math.sin(hy);
+    const cz = Math.cos(hz),
+        sz = Math.sin(hz);
+
+    _quat.x = sx * cy * cz + cx * sy * sz;
+    _quat.y = cx * sy * cz - sx * cy * sz;
+    _quat.z = cx * cy * sz + sx * sy * cz;
+    _quat.w = cx * cy * cz - sx * sy * sz;
+    return _quat;
 }
 
 export function quaternionToEuler(
@@ -76,30 +125,18 @@ export function quaternionToEuler(
         wy = w * y2,
         wz = w * z2;
 
-    const m11 = 1 - (yy + zz);
-    const m12 = xy - wz;
     const m13 = xz + wy;
-    const m22 = 1 - (xx + zz);
-    const m23 = yz - wx;
-    const m32 = yz + wx;
-    const m33 = 1 - (xx + yy);
-
-    const ey = Math.asin(Math.max(-1, Math.min(1, m13)));
-    let ex: number, ez: number;
+    const ey = Math.asin(m13 < -1 ? -1 : m13 > 1 ? 1 : m13);
 
-    if (Math.abs(m13) < 0.9999999) {
-        ex = Math.atan2(-m23, m33);
-        ez = Math.atan2(-m12, m11);
+    if (m13 > -0.9999999 && m13 < 0.9999999) {
+        _euler.x = Math.atan2(wx - yz, 1 - (xx + yy)) * RAD_TO_DEG;
+        _euler.z = Math.atan2(wz - xy, 1 - (yy + zz)) * RAD_TO_DEG;
     } else {
-        ex = Math.atan2(m32, m22);
-        ez = 0;
+        _euler.x = Math.atan2(yz + wx, 1 - (xx + zz)) * RAD_TO_DEG;
+        _euler.z = 0;
     }
-
-    return {
-        x: utils.radToDeg(ex),
-        y: utils.radToDeg(ey),
-        z: utils.radToDeg(ez),
-    };
+    _euler.y = ey * RAD_TO_DEG;
+    return _euler;
 }
 
 export function lookAt(
@@ -113,16 +150,59 @@ export function lookAt(
     upY = 1,
     upZ = 0
 ): { x: number; y: number; z: number; w: number } {
-    tempVec3A[0] = eyeX;
-    tempVec3A[1] = eyeY;
-    tempVec3A[2] = eyeZ;
-    tempVec3B[0] = targetX;
-    tempVec3B[1] = targetY;
-    tempVec3B[2] = targetZ;
-    tempVec3C[0] = upX;
-    tempVec3C[1] = upY;
-    tempVec3C[2] = upZ;
-    mat4.cameraAim(tempVec3A, tempVec3B, tempVec3C, tempMat4);
-    quat.fromMat(tempMat4, tempQuatOut);
-    return { x: tempQuatOut[0], y: tempQuatOut[1], z: tempQuatOut[2], w: tempQuatOut[3] };
+    let fwdX = targetX - eyeX;
+    let fwdY = targetY - eyeY;
+    let fwdZ = targetZ - eyeZ;
+    const fwdLenSq = fwdX * fwdX + fwdY * fwdY + fwdZ * fwdZ;
+    if (fwdLenSq > 0) {
+        const invLen = 1 / Math.sqrt(fwdLenSq);
+        fwdX *= invLen;
+        fwdY *= invLen;
+        fwdZ *= invLen;
+    }
+
+    let rightX = upY * fwdZ - upZ * fwdY;
+    let rightY = upZ * fwdX - upX * fwdZ;
+    let rightZ = upX * fwdY - upY * fwdX;
+    const rightLenSq = rightX * rightX + rightY * rightY + rightZ * rightZ;
+    if (rightLenSq > 0) {
+        const invLen = 1 / Math.sqrt(rightLenSq);
+        rightX *= invLen;
+        rightY *= invLen;
+        rightZ *= invLen;
+    }
+
+    const newUpX = fwdY * rightZ - fwdZ * rightY;
+    const newUpY = fwdZ * rightX - fwdX * rightZ;
+    const newUpZ = fwdX * rightY - fwdY * rightX;
+
+    const trace = rightX + newUpY + fwdZ;
+
+    if (trace > 0) {
+        const s = 0.5 / Math.sqrt(trace + 1);
+        _quat.w = 0.25 / s;
+        _quat.x = (newUpZ - fwdY) * s;
+        _quat.y = (fwdX - rightZ) * s;
+        _quat.z = (rightY - newUpX) * s;
+    } else if (rightX > newUpY && rightX > fwdZ) {
+        const s = 2 * Math.sqrt(1 + rightX - newUpY - fwdZ);
+        _quat.w = (newUpZ - fwdY) / s;
+        _quat.x = 0.25 * s;
+        _quat.y = (newUpX + rightY) / s;
+        _quat.z = (fwdX + rightZ) / s;
+    } else if (newUpY > fwdZ) {
+        const s = 2 * Math.sqrt(1 + newUpY - rightX - fwdZ);
+        _quat.w = (fwdX - rightZ) / s;
+        _quat.x = (newUpX + rightY) / s;
+        _quat.y = 0.25 * s;
+        _quat.z = (fwdY + newUpZ) / s;
+    } else {
+        const s = 2 * Math.sqrt(1 + fwdZ - rightX - newUpY);
+        _quat.w = (rightY - newUpX) / s;
+        _quat.x = (fwdX + rightZ) / s;
+        _quat.y = (fwdY + newUpZ) / s;
+        _quat.z = 0.25 * s;
+    }
+
+    return _quat;
 }