diff options
Diffstat (limited to '')
| -rw-r--r-- | platformer/src/math3d.h | 196 |
1 files changed, 196 insertions, 0 deletions
diff --git a/platformer/src/math3d.h b/platformer/src/math3d.h index 316e418..e0f89a5 100644 --- a/platformer/src/math3d.h +++ b/platformer/src/math3d.h @@ -74,4 +74,200 @@ #ifndef MATH3D_H #define MATH3D_H +#include <math.h> + +#define M3D_PI 3.14159265358979f /* C99 doesn't guarantee M_PI */ + +typedef struct { float x, y; } Vec2; +typedef struct { float x, y, z; } Vec3; +typedef struct { float m[16]; } Mat4; /* column-major: (row r, col c) = m[c*4 + r] */ + +/* ---- Scalar helpers ---------------------------------------------------- */ + +static inline float clampf(float v, float lo, float hi) +{ + if (v < lo) return lo; + if (v > hi) return hi; + return v; +} + +/* Moves current toward target by at most max_step, never overshooting. + * This is how speeds accelerate and brake at a fixed rate per tick. */ +static inline float approachf(float current, float target, float max_step) +{ + if (current < target) { + current += max_step; + return current > target ? target : current; + } + current -= max_step; + return current < target ? target : current; +} + +/* Returns a in (-PI, PI]. */ +static inline float wrap_angle(float a) +{ + a = fmodf(a + M3D_PI, 2.0f * M3D_PI); /* now in (-2PI, 2PI) */ + if (a <= 0.0f) a += 2.0f * M3D_PI; /* now in (0, 2PI] */ + return a - M3D_PI; +} + +/* Like approachf, but for angles: turns the SHORT way around the circle, + * so facing 170 deg and turning to -170 deg is a 20 deg turn, not 340. */ +static inline float approach_angle(float current, float target, float max_step) +{ + float diff = wrap_angle(target - current); + return wrap_angle(current + clampf(diff, -max_step, max_step)); +} + +/* ---- Vec2 -------------------------------------------------------------- */ + +static inline Vec2 vec2_make(float x, float y) +{ + Vec2 v = { x, y }; + return v; +} + +static inline float vec2_length(Vec2 v) +{ + return sqrtf(v.x * v.x + v.y * v.y); +} + +/* ---- Vec3 -------------------------------------------------------------- */ + +static inline Vec3 vec3_make(float x, float y, float z) +{ + Vec3 v = { x, y, z }; + return v; +} + +static inline Vec3 vec3_add(Vec3 a, Vec3 b) +{ + return vec3_make(a.x + b.x, a.y + b.y, a.z + b.z); +} + +static inline Vec3 vec3_sub(Vec3 a, Vec3 b) +{ + return vec3_make(a.x - b.x, a.y - b.y, a.z - b.z); +} + +static inline Vec3 vec3_scale(Vec3 v, float s) +{ + return vec3_make(v.x * s, v.y * s, v.z * s); +} + +static inline float vec3_dot(Vec3 a, Vec3 b) +{ + return a.x * b.x + a.y * b.y + a.z * b.z; +} + +static inline Vec3 vec3_cross(Vec3 a, Vec3 b) +{ + return vec3_make(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 vec3_length(Vec3 v) +{ + return sqrtf(vec3_dot(v, v)); +} + +/* Returns (0,0,0) for a zero-length input instead of dividing by zero. */ +static inline Vec3 vec3_normalize(Vec3 v) +{ + float len = vec3_length(v); + if (len <= 0.0f) return vec3_make(0.0f, 0.0f, 0.0f); + return vec3_scale(v, 1.0f / len); +} + +/* t = 0 gives a, t = 1 gives b. */ +static inline Vec3 vec3_lerp(Vec3 a, Vec3 b, float t) +{ + return vec3_add(a, vec3_scale(vec3_sub(b, a), t)); +} + +/* ---- Mat4 -------------------------------------------------------------- */ + +static inline Mat4 mat4_identity(void) +{ + Mat4 r = {{ 0 }}; + r.m[0] = r.m[5] = r.m[10] = r.m[15] = 1.0f; + return r; +} + +/* result = a * b, so b is applied to a point first, then a. */ +static inline Mat4 mat4_mul(Mat4 a, Mat4 b) +{ + Mat4 r; + for (int col = 0; col < 4; col++) { + for (int row = 0; row < 4; row++) { + float sum = 0.0f; + for (int k = 0; k < 4; k++) + sum += a.m[k * 4 + row] * b.m[col * 4 + k]; + r.m[col * 4 + row] = sum; + } + } + return r; +} + +/* The translation lives in the last column. */ +static inline Mat4 mat4_translate(Vec3 t) +{ + Mat4 r = mat4_identity(); + r.m[12] = t.x; + r.m[13] = t.y; + r.m[14] = t.z; + return r; +} + +static inline Mat4 mat4_scale(Vec3 s) +{ + Mat4 r = mat4_identity(); + r.m[0] = s.x; + r.m[5] = s.y; + r.m[10] = s.z; + return r; +} + +/* Rotates around +Y, turning +Z toward +X: (0,0,1) -> (sin a, 0, cos a). + * This matches the player's facing vector (sin(yaw), 0, cos(yaw)). */ +static inline Mat4 mat4_rotate_y(float angle) +{ + float c = cosf(angle), s = sinf(angle); + Mat4 r = mat4_identity(); + r.m[0] = c; /* row 0, col 0 */ + r.m[8] = s; /* row 0, col 2 */ + r.m[2] = -s; /* row 2, col 0 */ + r.m[10] = c; /* row 2, col 2 */ + return r; +} + +/* Standard OpenGL (gluPerspective) projection. Maps the view frustum to + * clip space, with the camera looking down -Z. */ +static inline Mat4 mat4_perspective(float fovy_rad, float aspect, float near, float far) +{ + float f = 1.0f / tanf(fovy_rad * 0.5f); + Mat4 r = {{ 0 }}; + r.m[0] = f / aspect; + r.m[5] = f; + r.m[10] = (far + near) / (near - far); + r.m[11] = -1.0f; /* row 3, col 2: w = -z */ + r.m[14] = 2.0f * far * near / (near - far); + return r; +} + +/* Standard OpenGL (gluLookAt) view matrix: moves the world so the eye sits + * at the origin looking down -Z, with `up` roughly +Y on screen. */ +static inline Mat4 mat4_look_at(Vec3 eye, Vec3 target, Vec3 up) +{ + Vec3 f = vec3_normalize(vec3_sub(target, eye)); /* forward */ + Vec3 s = vec3_normalize(vec3_cross(f, up)); /* right */ + Vec3 u = vec3_cross(s, f); /* true up */ + Mat4 r = mat4_identity(); + r.m[0] = s.x; r.m[4] = s.y; r.m[8] = s.z; r.m[12] = -vec3_dot(s, eye); + r.m[1] = u.x; r.m[5] = u.y; r.m[9] = u.z; r.m[13] = -vec3_dot(u, eye); + r.m[2] = -f.x; r.m[6] = -f.y; r.m[10] = -f.z; r.m[14] = vec3_dot(f, eye); + return r; +} + #endif /* MATH3D_H */ |
