1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
|
/*
* ============================================================
* FILE: math3d.h
*
* PURPOSE: The small amount of vector/matrix math the game needs, written
* by hand so we don't pull in a math library.
*
* FITS IN: Header-only (every function is `static inline`). Included by
* any file that does math. Depends only on <math.h>.
*
* INTERFACE: Use these exact names:
*
* Constants
* M3D_PI 3.14159265358979f (C99 doesn't guarantee M_PI)
*
* Types (plain structs, passed and returned BY VALUE since they're small)
* typedef struct { float x, y; } Vec2;
* typedef struct { float x, y, z; } Vec3;
* typedef struct { float m[16]; } Mat4; COLUMN-MAJOR, element (row r,
* col c) is m[c*4 + r], so it can
* go straight to glUniformMatrix4fv
* with transpose = GL_FALSE.
*
* Scalar helpers
* float clampf(float v, float lo, float hi);
* float approachf(float current, float target, float max_step);
* moves current toward target by at most max_step, never overshoots.
* (Used for acceleration/friction.)
* float wrap_angle(float a);
* returns a in (-PI, PI].
* float approach_angle(float current, float target, float max_step);
* like approachf but takes the SHORT way around the circle.
* (Used for turning the player.)
*
* Vec2
* Vec2 vec2_make(float x, float y);
* float vec2_length(Vec2 v);
*
* Vec3
* Vec3 vec3_make(float x, float y, float z);
* Vec3 vec3_add(Vec3 a, Vec3 b);
* Vec3 vec3_sub(Vec3 a, Vec3 b);
* Vec3 vec3_scale(Vec3 v, float s);
* float vec3_dot(Vec3 a, Vec3 b);
* Vec3 vec3_cross(Vec3 a, Vec3 b);
* float vec3_length(Vec3 v);
* Vec3 vec3_normalize(Vec3 v); returns (0,0,0) for zero-length input
* Vec3 vec3_lerp(Vec3 a, Vec3 b, float t);
*
* Mat4
* Mat4 mat4_identity(void);
* Mat4 mat4_mul(Mat4 a, Mat4 b); result = a * b (b is applied first)
* Mat4 mat4_translate(Vec3 t);
* Mat4 mat4_scale(Vec3 s);
* Mat4 mat4_rotate_y(float angle); rotates +Z toward +X, i.e.
* (0,0,1) -> (sin a, 0, cos a)
* Mat4 mat4_perspective(float fovy_rad, float aspect, float near, float far);
* standard OpenGL (gluPerspective) form
* Mat4 mat4_look_at(Vec3 eye, Vec3 target, Vec3 up);
* standard OpenGL (gluLookAt) form
*
* CONVENTIONS: Right-handed, Y up. Radians everywhere. Keep each function a
* few lines with a short comment; this is a learning resource.
* Include guard: MATH3D_H.
*
* NOT IN SCOPE: Quaternions, matrix inverse, SIMD, Vec4, generic N-dim math.
* Add a function only when a caller needs it.
*
* DONE WHEN: All functions above compile cleanly under -std=c99 -Wall
* -Wextra, and mat4_perspective * mat4_look_at produces a
* correct view of the ground grid in render.c.
* ============================================================
*/
#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 */
|