wasmcart 0.2.0

package/include/wc_mat4.h

@@ -0,0 +1,210 @@
+/*
+ * wc_mat4.h - 4x4 matrix operations for wasmcart GL carts
+ *
+ * Single-header library providing column-major 4x4 matrix operations
+ * for OpenGL-style rendering. Uses wc_math.h for trig functions.
+ *
+ * USAGE:
+ *   #include "wc_math.h"
+ *   #include "wc_mat4.h"
+ *
+ * All functions are static inline. No separate .c file needed.
+ *
+ * CONVENTIONS:
+ *   - Column-major layout (OpenGL convention)
+ *   - mat4[col*4 + row], e.g. mat4[12] = translation X
+ *   - Right-handed coordinate system
+ *   - Angles in radians unless noted (wc_mat4_perspective takes radians)
+ *   - wc_mat4_rotate takes degrees (matches glRotatef convention)
+ */
+
+#ifndef WC_MAT4_H
+#define WC_MAT4_H
+
+#ifndef WC_MATH_H
+#error "Include wc_math.h before wc_mat4.h"
+#endif
+
+/* ── Type ─────────────────────────────────────────────────────────── */
+
+typedef float wc_mat4[16];
+
+/* ── Identity ─────────────────────────────────────────────────────── */
+
+static inline void wc_mat4_identity(wc_mat4 m) {
+    for (int i = 0; i < 16; i++) m[i] = 0.0f;
+    m[0] = m[5] = m[10] = m[15] = 1.0f;
+}
+
+static inline int wc_mat4_is_identity(const wc_mat4 m) {
+    const float e = 0.0001f;
+    for (int i = 0; i < 16; i++) {
+        float expected = (i == 0 || i == 5 || i == 10 || i == 15) ? 1.0f : 0.0f;
+        float d = m[i] - expected;
+        if (d > e || d < -e) return 0;
+    }
+    return 1;
+}
+
+/* ── Copy ─────────────────────────────────────────────────────────── */
+
+static inline void wc_mat4_copy(wc_mat4 dst, const wc_mat4 src) {
+    for (int i = 0; i < 16; i++) dst[i] = src[i];
+}
+
+/* ── Multiply: out = a * b ────────────────────────────────────────── */
+/* out may alias a or b safely (uses temp buffer) */
+
+static inline void wc_mat4_multiply(wc_mat4 out, const wc_mat4 a, const wc_mat4 b) {
+    wc_mat4 tmp;
+    for (int c = 0; c < 4; c++)
+        for (int r = 0; r < 4; r++) {
+            tmp[c*4+r] = 0.0f;
+            for (int k = 0; k < 4; k++)
+                tmp[c*4+r] += a[k*4+r] * b[c*4+k];
+        }
+    for (int i = 0; i < 16; i++) out[i] = tmp[i];
+}
+
+/* ── Transform operations (modify m in-place, post-multiply) ───── */
+
+/* Translate: m = m * T(x,y,z) */
+static inline void wc_mat4_translate(wc_mat4 m, float x, float y, float z) {
+    m[12] += m[0]*x + m[4]*y + m[8]*z;
+    m[13] += m[1]*x + m[5]*y + m[9]*z;
+    m[14] += m[2]*x + m[6]*y + m[10]*z;
+}
+
+/* Scale: m = m * S(x,y,z) */
+static inline void wc_mat4_scale(wc_mat4 m, float x, float y, float z) {
+    m[0] *= x; m[1] *= x; m[2]  *= x; m[3]  *= x;
+    m[4] *= y; m[5] *= y; m[6]  *= y; m[7]  *= y;
+    m[8] *= z; m[9] *= z; m[10] *= z; m[11] *= z;
+}
+
+/* Rotate: m = m * R(angle_deg, ax, ay, az) - matches glRotatef */
+static inline void wc_mat4_rotate(wc_mat4 m, float angle_deg, float ax, float ay, float az) {
+    float rad = angle_deg * WC_DEG2RAD;
+    float c = wc_cosf(rad), s = wc_sinf(rad), t = 1.0f - c;
+    /* Normalize axis */
+    float len = ax*ax + ay*ay + az*az;
+    if (len > 0.0001f) {
+        float il = 1.0f / wc_sqrtf(len);
+        ax *= il; ay *= il; az *= il;
+    }
+    wc_mat4 rot;
+    rot[0] = t*ax*ax+c;     rot[4] = t*ax*ay-s*az;  rot[8]  = t*ax*az+s*ay;  rot[12] = 0;
+    rot[1] = t*ax*ay+s*az;  rot[5] = t*ay*ay+c;     rot[9]  = t*ay*az-s*ax;  rot[13] = 0;
+    rot[2] = t*ax*az-s*ay;  rot[6] = t*ay*az+s*ax;  rot[10] = t*az*az+c;     rot[14] = 0;
+    rot[3] = 0;             rot[7] = 0;              rot[11] = 0;             rot[15] = 1;
+    wc_mat4 tmp;
+    wc_mat4_copy(tmp, m);
+    wc_mat4_multiply(m, tmp, rot);
+}
+
+/* ── Projection matrices (write from scratch, not in-place) ──────── */
+
+/* Perspective projection: fovy in radians, outputs to m */
+static inline void wc_mat4_perspective(wc_mat4 m, float fovy_rad, float aspect,
+                                       float znear, float zfar) {
+    float f = wc_cosf(fovy_rad * 0.5f) / wc_sinf(fovy_rad * 0.5f);
+    for (int i = 0; i < 16; i++) m[i] = 0.0f;
+    m[0] = f / aspect;
+    m[5] = f;
+    m[10] = (zfar + znear) / (znear - zfar);
+    m[11] = -1.0f;
+    m[14] = (2.0f * zfar * znear) / (znear - zfar);
+}
+
+/* Perspective projection: fovy in degrees (matches gluPerspective) */
+static inline void wc_mat4_perspective_deg(wc_mat4 m, float fovy_deg, float aspect,
+                                           float znear, float zfar) {
+    wc_mat4_perspective(m, fovy_deg * WC_DEG2RAD, aspect, znear, zfar);
+}
+
+/* Orthographic projection */
+static inline void wc_mat4_ortho(wc_mat4 m, float left, float right,
+                                 float bottom, float top,
+                                 float znear, float zfar) {
+    for (int i = 0; i < 16; i++) m[i] = 0.0f;
+    m[0]  =  2.0f / (right - left);
+    m[5]  =  2.0f / (top - bottom);
+    m[10] = -2.0f / (zfar - znear);
+    m[12] = -(right + left) / (right - left);
+    m[13] = -(top + bottom) / (top - bottom);
+    m[14] = -(zfar + znear) / (zfar - znear);
+    m[15] = 1.0f;
+}
+
+/* ── View matrix ──────────────────────────────────────────────────── */
+
+/* LookAt: build a view matrix (matches gluLookAt) */
+static inline void wc_mat4_look_at(wc_mat4 m,
+                                   float eye_x, float eye_y, float eye_z,
+                                   float center_x, float center_y, float center_z,
+                                   float up_x, float up_y, float up_z) {
+    /* Forward = normalize(center - eye) */
+    float fx = center_x - eye_x, fy = center_y - eye_y, fz = center_z - eye_z;
+    float fl = wc_sqrtf(fx*fx + fy*fy + fz*fz);
+    if (fl > 0.0001f) { fx /= fl; fy /= fl; fz /= fl; }
+
+    /* Side = normalize(forward x up) */
+    float sx = fy*up_z - fz*up_y;
+    float sy = fz*up_x - fx*up_z;
+    float sz = fx*up_y - fy*up_x;
+    float sl = wc_sqrtf(sx*sx + sy*sy + sz*sz);
+    if (sl > 0.0001f) { sx /= sl; sy /= sl; sz /= sl; }
+
+    /* Recomputed up = side x forward */
+    float ux = sy*fz - sz*fy;
+    float uy = sz*fx - sx*fz;
+    float uz = sx*fy - sy*fx;
+
+    for (int i = 0; i < 16; i++) m[i] = 0.0f;
+    m[0] = sx;  m[4] = sy;  m[8]  = sz;
+    m[1] = ux;  m[5] = uy;  m[9]  = uz;
+    m[2] = -fx; m[6] = -fy; m[10] = -fz;
+    m[12] = -(sx*eye_x + sy*eye_y + sz*eye_z);
+    m[13] = -(ux*eye_x + uy*eye_y + uz*eye_z);
+    m[14] =  (fx*eye_x + fy*eye_y + fz*eye_z);
+    m[15] = 1.0f;
+}
+
+/* ── Single-axis rotation helpers (write from scratch) ────────────── */
+
+static inline void wc_mat4_rotate_x(wc_mat4 m, float angle_rad) {
+    wc_mat4_identity(m);
+    float c = wc_cosf(angle_rad), s = wc_sinf(angle_rad);
+    m[5] = c;  m[6] = s;
+    m[9] = -s; m[10] = c;
+}
+
+static inline void wc_mat4_rotate_y(wc_mat4 m, float angle_rad) {
+    wc_mat4_identity(m);
+    float c = wc_cosf(angle_rad), s = wc_sinf(angle_rad);
+    m[0] = c;  m[2] = -s;
+    m[8] = s;  m[10] = c;
+}
+
+static inline void wc_mat4_rotate_z(wc_mat4 m, float angle_rad) {
+    wc_mat4_identity(m);
+    float c = wc_cosf(angle_rad), s = wc_sinf(angle_rad);
+    m[0] = c;  m[1] = s;
+    m[4] = -s; m[5] = c;
+}
+
+/* ── Translation helper (write from scratch) ──────────────────────── */
+
+static inline void wc_mat4_from_translation(wc_mat4 m, float x, float y, float z) {
+    wc_mat4_identity(m);
+    m[12] = x; m[13] = y; m[14] = z;
+}
+
+/* ── Scale helper (write from scratch) ────────────────────────────── */
+
+static inline void wc_mat4_from_scale(wc_mat4 m, float x, float y, float z) {
+    wc_mat4_identity(m);
+    m[0] = x; m[5] = y; m[10] = z;
+}
+
+#endif /* WC_MAT4_H */

package/include/wc_math.h

@@ -0,0 +1,116 @@
+/*
+ * wc_math.h - Math functions without libm for wasmcart carts
+ *
+ * Single-header library providing trig, sqrt, atan2, and utility math
+ * functions that don't require linking against libm. Useful for WASM
+ * carts compiled with -nostdlib or minimal libc.
+ *
+ * USAGE:
+ *   #include "wc_math.h"
+ *
+ * All functions are static inline, so just include this header wherever
+ * you need math. No separate .c file needed. No link dependencies.
+ *
+ * ACCURACY:
+ *   - wc_sinf/wc_cosf: ~0.001 max error (Bhaskara I approximation)
+ *   - wc_sqrtf: ~1e-6 relative error (10 Newton-Raphson iterations)
+ *   - wc_atan2f: ~0.01 max error (polynomial approximation)
+ *   - wc_tanf: limited near pi/2 (clamped denominator)
+ *
+ * If you need full libm precision, link against libm instead.
+ */
+
+#ifndef WC_MATH_H
+#define WC_MATH_H
+
+/* ── Constants ────────────────────────────────────────────────────── */
+
+#define WC_PI       3.14159265358979f
+#define WC_TWO_PI   6.28318530717959f
+#define WC_HALF_PI  1.57079632679490f
+#define WC_DEG2RAD  (WC_PI / 180.0f)
+#define WC_RAD2DEG  (180.0f / WC_PI)
+
+/* ── Basic utilities ──────────────────────────────────────────────── */
+
+static inline float wc_fabsf(float x) {
+    return x < 0.0f ? -x : x;
+}
+
+static inline float wc_fmodf(float a, float b) {
+    return a - (int)(a / b) * b;
+}
+
+static inline float wc_floorf(float x) {
+    int i = (int)x;
+    return (float)(x < (float)i ? i - 1 : i);
+}
+
+static inline float wc_clampf(float v, float lo, float hi) {
+    if (v < lo) return lo;
+    if (v > hi) return hi;
+    return v;
+}
+
+static inline float wc_lerpf(float a, float b, float t) {
+    return a + (b - a) * t;
+}
+
+static inline float wc_signf(float x) {
+    return x > 0.0f ? 1.0f : (x < 0.0f ? -1.0f : 0.0f);
+}
+
+static inline float wc_minf(float a, float b) { return a < b ? a : b; }
+static inline float wc_maxf(float a, float b) { return a > b ? a : b; }
+
+/* ── Trigonometry (Bhaskara I approximation) ──────────────────────── */
+
+static inline float wc_sinf(float x) {
+    x = wc_fmodf(x, WC_TWO_PI);
+    if (x > WC_PI) x -= WC_TWO_PI;
+    if (x < -WC_PI) x += WC_TWO_PI;
+    float a = wc_fabsf(x);
+    return 16.0f * x * (WC_PI - a) /
+           (5.0f * WC_PI * WC_PI - 4.0f * x * (WC_PI - a));
+}
+
+static inline float wc_cosf(float x) {
+    return wc_sinf(x + WC_HALF_PI);
+}
+
+static inline float wc_tanf(float x) {
+    float c = wc_cosf(x);
+    if (wc_fabsf(c) < 0.0001f) c = 0.0001f;
+    return wc_sinf(x) / c;
+}
+
+/* ── Square root (Newton-Raphson, 10 iterations) ──────────────────── */
+
+static inline float wc_sqrtf(float x) {
+    if (x <= 0.0f) return 0.0f;
+    float g = x * 0.5f;
+    for (int i = 0; i < 10; i++)
+        g = 0.5f * (g + x / g);
+    return g;
+}
+
+/* ── Atan2 (polynomial approximation) ─────────────────────────────── */
+
+static inline float wc_atan2f(float y, float x) {
+    if (x == 0.0f) {
+        if (y > 0.0f) return WC_HALF_PI;
+        if (y < 0.0f) return -WC_HALF_PI;
+        return 0.0f;
+    }
+    float abs_x = wc_fabsf(x);
+    float abs_y = wc_fabsf(y);
+    float a = (abs_x < abs_y) ? abs_x / abs_y : abs_y / abs_x;
+    float s = a * a;
+    float r = ((-0.0464964749f * s + 0.15931422f) * s - 0.327622764f) * s * a + a;
+    if (abs_y > abs_x) r = WC_HALF_PI - r;
+    if (x < 0.0f) r = WC_PI - r;
+    if (y < 0.0f) r = -r;
+    return r;
+}
+
+#endif /* WC_MATH_H */