@multiplekex/shallot 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@multiplekex/shallot",
-    "version": "0.1.2",
+    "version": "0.1.4",
     "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,8 @@
-import { quat, utils, mat4 } from "wgpu-matrix";
-
-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 DEG_TO_RAD = Math.PI / 180;
+const RAD_TO_DEG = 180 / Math.PI;
 
 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 +20,67 @@ 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;
+    }
+
+    return {
+        x: s0 * fromX + s1 * toX,
+        y: s0 * fromY + s1 * toY,
+        z: s0 * fromZ + s1 * toZ,
+        w: s0 * fromW + s1 * toW,
+    };
 }
 
 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;
+
+    return {
+        x: qw * bx + qx * bw + qy * bz - qz * by,
+        y: qw * by - qx * bz + qy * bw + qz * bx,
+        z: qw * bz + qx * by - qy * bx + qz * bw,
+        w: qw * bw - qx * bx - qy * by - qz * bz,
+    };
 }
 
 export function eulerToQuaternion(
@@ -53,8 +88,22 @@ 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);
+
+    return {
+        x: sx * cy * cz + cx * sy * sz,
+        y: cx * sy * cz - sx * cy * sz,
+        z: cx * cy * sz + sx * sy * cz,
+        w: cx * cy * cz - sx * sy * sz,
+    };
 }
 
 export function quaternionToEuler(
@@ -76,30 +125,22 @@ 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) {
+        return {
+            x: Math.atan2(wx - yz, 1 - (xx + yy)) * RAD_TO_DEG,
+            y: ey * RAD_TO_DEG,
+            z: Math.atan2(wz - xy, 1 - (yy + zz)) * RAD_TO_DEG,
+        };
     } else {
-        ex = Math.atan2(m32, m22);
-        ez = 0;
+        return {
+            x: Math.atan2(yz + wx, 1 - (xx + zz)) * RAD_TO_DEG,
+            y: ey * RAD_TO_DEG,
+            z: 0,
+        };
     }
-
-    return {
-        x: utils.radToDeg(ex),
-        y: utils.radToDeg(ey),
-        z: utils.radToDeg(ez),
-    };
 }
 
 export function lookAt(
@@ -113,16 +154,82 @@ 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 zx = eyeX - targetX;
+    let zy = eyeY - targetY;
+    let zz = eyeZ - targetZ;
+    let zLen = Math.sqrt(zx * zx + zy * zy + zz * zz);
+
+    if (zLen === 0) {
+        zz = 1;
+    } else {
+        zLen = 1 / zLen;
+        zx *= zLen;
+        zy *= zLen;
+        zz *= zLen;
+    }
+
+    let xx = upY * zz - upZ * zy;
+    let xy = upZ * zx - upX * zz;
+    let xz = upX * zy - upY * zx;
+    let xLen = Math.sqrt(xx * xx + xy * xy + xz * xz);
+
+    if (xLen === 0) {
+        if (upZ !== 0) {
+            upX += 1e-4 * upX;
+            upY += 1e-4 * upY;
+            upZ += 1e-4 * upZ;
+        } else if (upY !== 0) {
+            upX += 1e-4 * upX;
+            upY += 1e-4 * upY;
+            upZ += 1e-4 * upZ;
+        } else {
+            upX += 1e-4 * upX;
+            upY += 1e-4 * upY;
+            upZ += 1e-4 * upZ;
+        }
+        xx = upY * zz - upZ * zy;
+        xy = upZ * zx - upX * zz;
+        xz = upX * zy - upY * zx;
+        xLen = Math.sqrt(xx * xx + xy * xy + xz * xz);
+    }
+
+    xLen = 1 / xLen;
+    xx *= xLen;
+    xy *= xLen;
+    xz *= xLen;
+
+    const yx = zy * xz - zz * xy;
+    const yy = zz * xx - zx * xz;
+    const yz = zx * xy - zy * xx;
+
+    const trace = xx + yy + zz;
+    let qw: number, qx: number, qy: number, qz: number;
+
+    if (trace > 0) {
+        const s = 0.5 / Math.sqrt(trace + 1);
+        qw = 0.25 / s;
+        qx = (yz - zy) * s;
+        qy = (zx - xz) * s;
+        qz = (xy - yx) * s;
+    } else if (xx > yy && xx > zz) {
+        const s = 2 * Math.sqrt(1 + xx - yy - zz);
+        qw = (yz - zy) / s;
+        qx = 0.25 * s;
+        qy = (yx + xy) / s;
+        qz = (zx + xz) / s;
+    } else if (yy > zz) {
+        const s = 2 * Math.sqrt(1 + yy - xx - zz);
+        qw = (zx - xz) / s;
+        qx = (yx + xy) / s;
+        qy = 0.25 * s;
+        qz = (yz + zy) / s;
+    } else {
+        const s = 2 * Math.sqrt(1 + zz - xx - yy);
+        qw = (xy - yx) / s;
+        qx = (zx + xz) / s;
+        qy = (yz + zy) / s;
+        qz = 0.25 * s;
+    }
+
+    return { x: qx, y: qy, z: qz, w: qw };
 }