46 float rl = right - left;
47 float tb = top - bottom;
48 float fn = far - near;
67 out.
d0 = -(right + left) / rl;
68 out.
d1 = -(top + bottom) / tb;
69 out.
d2 = -(far + near) / fn;
86 float fov_rad = fov_deg * (M_PI / 180.0f);
87 float f = 1.0f / tanf(fov_rad / 2.0f);
101 out.
c2 = (far + near) / (near - far);
106 out.
d2 = (2 * far * near) / (near - far);
118 " % .6f % .6f % .6f % .6f\n"
119 " % .6f % .6f % .6f % .6f\n"
120 " % .6f % .6f % .6f % .6f\n"
121 " % .6f % .6f % .6f % .6f\n",
191 vec3 negated_sun_dir = {
199 float distance = 100.0f;
200 pos.
x += light_dir.
x * distance;
201 pos.
y += light_dir.
y * distance;
202 pos.
z += light_dir.
z * distance;
211 lcam->
pitch = -M_PI / 2;
274 float wlen = sqrtf(wish.
x * wish.
x + wish.
y * wish.
y);
275 float falignment = 0.0f;
278 falignment = (fwd.
x * wish.
x + fwd.
y * wish.
y) / (wlen);
279 falignment =
clamp(falignment, -1.0f, 1.0f);
281 if (falignment > 1) falignment -= 1;
283 wish = (
vec2){wish.
x + fwd.
x, wish.
y + fwd.
y};
284 wlen = sqrtf(wish.
x * wish.
x + wish.
y * wish.
y);
292 float curr = vx * wish.
x + vy * wish.
y;
293 float add = wish_speed - curr;
294 if (add <= 0.0f)
return;
296 float acc = 0.005 * wish_speed *
dt;
297 if (acc > add) acc = add;
304 float vlen = sqrtf(vx * vx + vy * vy);
306 float alignment = 0.0f;
307 if (vlen > 1e-5f && wlen > 1e-5f)
309 alignment = (vx * wish.
x + vy * wish.
y) / (vlen * wlen);
310 alignment =
clamp(alignment, -1.0f, 1.0f);
312 float steer = 1.0f - alignment;
315 float steer_nudge = 0.005 * steer *
dt;
323 float scale = vlen / nlen;
342 static const float MAX_SPEED = 0.5f;
343 static const float ACCEL = 0.001f;
344 static const float GRAVITY = 0.002f;
345 float accel_step = ACCEL *
dt;
346 float s_len = sqrtf(move_dir.
x * move_dir.
x + move_dir.
y * move_dir.
y);
366 float wish_x = move_dir.
x * fwd.
x + move_dir.
y * rgt.
x;
367 float wish_y = move_dir.
x * fwd.
y + move_dir.
y * rgt.
y;
369 float proj_wish = wish_x * rgt.
x + wish_y * rgt.
y;
370 float target_roll = proj_wish * -0.05f;
371 if (wish_x == 0.0f && wish_y == 0.0f) target_roll = 0.0f;
382 float add = MAX_SPEED - cur;
385 float push = fminf(add, accel_step);
398 if (nlen > MAX_SPEED)
400 float scale = MAX_SPEED / nlen;
441 const int STEP_AMT = 100;
442 const float THRESHOLD = 0.2f;
455 bool started_inside = (prev_d < THRESHOLD);
466 for (
int i = 0; i < STEP_AMT; i++)
472 if ((d - THRESHOLD) * (prev_d - THRESHOLD) < 0.0f)
476 float t = prev_d / (prev_d - d);
498 float z1 = p.
z - 1.0f;
503 if (d0 * d1 > 0.0f) {
507 for (
int i = 0; i < 100; i++)
509 float zm = 0.5f * (z0 + z1);
518 return 0.5f * (z0 + z1);
531 const int FAIL = 5000;
532 const float STEP_SIZE = 0.0065f;
533 const float THRESHOLD = 0.35f;
538 if (fail_bottom > THRESHOLD)
545 bool top_outside =
false;
546 if (density > THRESHOLD)
549 bool valid_hit =
false;
550 while (density > THRESHOLD && failsafe < FAIL)
553 if (density <= THRESHOLD)
562 if (valid_hit && failsafe < FAIL)
584 float dist_to_floor = z - (current_floor);
585 if (dist_to_floor <= 0.1f)
651 float voxel_size = chunk_world_size / 64.0;
659 vec3 prop2 = proposed;
663 float d = voxel_size;
668 vec3 collision_normal = (
vec3){99, 99, 99};
673 (
vec3){cam_pos.
x, cam_pos.
y, cam_pos.
z},
674 (
vec3){proposed.
x, proposed.
y, proposed.
z},
689 if (collision_normal.
x != 99 && collision_normal.
y != 99 && collision_normal.
z != 99)
693 float vel_dot_n =
vec3_dot(wish, collision_normal);
695 if (vel_dot_n < 0.0f)
698 proposed.
x = cam_pos.
x + wish.
x;
699 proposed.
y = cam_pos.
y + wish.
y;
700 proposed.
z = cam_pos.
z + wish.
z;
702 proposed.
x += collision_normal.
x * 0.01f;
703 proposed.
y += collision_normal.
y * 0.01f;
704 proposed.
z += collision_normal.
z * 0.01f;
740 static const float MAX_SPEED = 100.0f;
741 static const float ACCEL = 1.0f;
742 float accel_step = ACCEL *
dt;
743 float s_len = sqrtf(move_dir.
x * move_dir.
x + move_dir.
y * move_dir.
y);
753 float wish_x = move_dir.
x * fwd.
x + move_dir.
y * rgt.
x;
754 float wish_y = move_dir.
x * fwd.
y + move_dir.
y * rgt.
y;
755 float wish_z = move_dir.
x * fwd.
z + move_dir.
y * rgt.
z;
757 float proj_wish = wish_x * rgt.
x + wish_y * rgt.
y + wish_z * rgt.
z;
758 float target_roll = proj_wish * -0.05f;
759 if (wish_x == 0.0f && wish_y == 0.0f) target_roll = 0.0f;
769 float add = MAX_SPEED - cur;
772 float push = fminf(add, accel_step);
791 float cross = a.
x*b.
y - a.
y*b.
x;
792 float dot = a.
x*b.
x + a.
y*b.
y;
793 return atan2f(cross, dot);
809 float angle = atan2f(dot,
vec3_dot(a, b));
810 if (dot < 0) angle = -angle;
824 float pa = atan2f(a.
z, sqrtf(a.
x * a.
x + a.
y * a.
y));
825 float pb = atan2f(b.
z, sqrtf(b.
x * b.
x + b.
y * b.
y));
838 glClientWaitSync(
fence, GL_SYNC_FLUSH_COMMANDS_BIT, 60);
840 vec4 * ptr = glMapBufferRange(
841 GL_SHADER_STORAGE_BUFFER,
847 memcpy(&pos, ptr,
sizeof(
vec4));
848 glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
850 vec3 ppos = {pos.
x, pos.
y, pos.
z};
void update_light_camera(Camera *lcam)
float pitch_difference(vec3 a, vec3 b)
float signed_angle(vec2 a, vec2 b)
void resolve_collisions(Camera *cam, float planet_radius)
mat4 make_ortho(float left, float right, float bottom, float top, float near, float far)
vec3 find_density_normal(vec3 sample, float d)
void print_mat4(const mat4 *m)
float find_surface(vec3 cam_pos, vec3 p, float planet_radius)
float find_surface_z(vec3 p)
float signed_angle_3d(vec3 a, vec3 b, vec3 n)
void apply_velocity(Camera *cam, vec3 move_dir, float dt)
bool find_surface_entry(vec3 start, vec3 p, vec3 *entry, vec3 *normal, float voxel_size, float radius, float planet_radius)
void look_at_selected_body()
void update_camera(Camera *cam)
mat4 make_look_at(Camera *cam, vec3 eye)
bool check_collision(vec3 start, vec3 final, vec3 *normal, vec3 *entrance, float d, float current_floor, float planet_radius)
void apply_air_acceleration(vec2 wish, float wish_speed, float accel, float dt)
bool hit_ground(float z, float current_floor)
mat4 make_projection(float fov_deg, float aspect, float near, float far)
void compute_camera_basis(Camera *cam, vec3 world_up)
void apply_planet_velocity(Camera *cam, vec3 move_dir, float dt)
float calc_density(vec3 p)
Copies the exact density function from the GPU to the CPU.
vec3 vec3_cross(vec3 a, vec3 b)
float vec3_dot(vec3 a, vec3 b)
vec3 vec3_normalize(vec3 v)
vec3 vec3_scale(vec3 a, float b)
vec3 vec3_sub(vec3 a, vec3 b)
vec3 vec3_add(vec3 a, vec3 b)
float lerp(float a, float b, float t)
vec4 vec4_scale(vec4 a, float b)
float clamp(float a, float b, float c)
mat4 mat4_inverse(mat4 in)
float vec3_length(vec3 v)
void start_timer(Timer *t)