// Pyre GPU — math core
// Bare-metal compatible: no libc, no floats required by caller.
// N8toriousAi, 2026.

#ifndef PYRE_MATH_H
#define PYRE_MATH_H

typedef struct { float x, y, z; } vec3;
typedef struct { float x, y, z, w; } vec4;
typedef struct { float m[16]; } mat4;  // column-major

// ---- vec3 ----
static inline vec3 v3(float x, float y, float z) {
    vec3 v = {x, y, z}; return v;
}
static inline vec3 v3_add(vec3 a, vec3 b) {
    return v3(a.x+b.x, a.y+b.y, a.z+b.z);
}
static inline vec3 v3_sub(vec3 a, vec3 b) {
    return v3(a.x-b.x, a.y-b.y, a.z-b.z);
}
static inline vec3 v3_scale(vec3 a, float s) {
    return v3(a.x*s, a.y*s, a.z*s);
}
static inline float v3_dot(vec3 a, vec3 b) {
    return a.x*b.x + a.y*b.y + a.z*b.z;
}
static inline vec3 v3_cross(vec3 a, vec3 b) {
    return v3(a.y*b.z - a.z*b.y,
              a.z*b.x - a.x*b.z,
              a.x*b.y - a.y*b.x);
}
static inline float v3_len(vec3 a) {
    // Newton-Raphson sqrt, no libm
    float x = v3_dot(a, a);
    if (x <= 0.0f) return 0.0f;
    float r = x;
    for (int i = 0; i < 8; i++) r = 0.5f * (r + x / r);
    return r;
}
static inline vec3 v3_norm(vec3 a) {
    float l = v3_len(a);
    return l > 0.0f ? v3_scale(a, 1.0f/l) : a;
}

// ---- mat4 (column-major) ----
static inline mat4 m4_identity(void) {
    mat4 m = {{0}};
    m.m[0] = m.m[5] = m.m[10] = m.m[15] = 1.0f;
    return m;
}
static inline mat4 m4_mul(mat4 a, mat4 b) {
    mat4 r = {{0}};
    for (int c = 0; c < 4; c++)
        for (int r_ = 0; r_ < 4; r_++) {
            float s = 0.0f;
            for (int k = 0; k < 4; k++)
                s += a.m[k*4 + r_] * b.m[c*4 + k];
            r.m[c*4 + r_] = s;
        }
    return r;
}
static inline vec4 m4_mul_v4(mat4 m, vec4 v) {
    vec4 r;
    r.x = m.m[0]*v.x + m.m[4]*v.y + m.m[8]*v.z  + m.m[12]*v.w;
    r.y = m.m[1]*v.x + m.m[5]*v.y + m.m[9]*v.z  + m.m[13]*v.w;
    r.z = m.m[2]*v.x + m.m[6]*v.y + m.m[10]*v.z + m.m[14]*v.w;
    r.w = m.m[3]*v.x + m.m[7]*v.y + m.m[11]*v.z + m.m[15]*v.w;
    return r;
}
// perspective projection
static inline mat4 m4_perspective(float fov_deg, float aspect, float near, float far) {
    float fov_rad = fov_deg * 0.0174533f;
    // tan via Taylor — good enough for projection
    float x = fov_rad * 0.5f;
    float tan_h = x + x*x*x/3.0f + 2.0f*x*x*x*x*x/15.0f;
    float f = 1.0f / tan_h;
    mat4 m = {{0}};
    m.m[0] = f / aspect;
    m.m[5] = f;
    m.m[10] = (far + near) / (near - far);
    m.m[11] = -1.0f;
    m.m[14] = (2.0f * far * near) / (near - far);
    return m;
}
// look-at view matrix
static inline mat4 m4_lookat(vec3 eye, vec3 center, vec3 up) {
    vec3 f = v3_norm(v3_sub(center, eye));
    vec3 s = v3_norm(v3_cross(f, up));
    vec3 u = v3_cross(s, f);
    mat4 m = m4_identity();
    m.m[0] = s.x;  m.m[4] = s.y;  m.m[8]  = s.z;
    m.m[1] = u.x;  m.m[5] = u.y;  m.m[9]  = u.z;
    m.m[2] = -f.x; m.m[6] = -f.y; m.m[10] = -f.z;
    m.m[12] = -v3_dot(s, eye);
    m.m[13] = -v3_dot(u, eye);
    m.m[14] =  v3_dot(f, eye);
    return m;
}
// rotation about Y (for turntable)
static inline mat4 m4_rot_y(float rad) {
    // sin/cos via Taylor
    float x = rad;
    float x2 = x*x;
    float s = x - x*x2/6.0f + x*x2*x2/120.0f;
    float c = 1.0f - x2/2.0f + x2*x2/24.0f;
    mat4 m = m4_identity();
    m.m[0] = c;   m.m[8] = s;
    m.m[2] = -s;  m.m[10] = c;
    return m;
}

#endif
