245 lines
8.1 KiB
C
245 lines
8.1 KiB
C
#include "ingame.h"
|
|
#include "title.h"
|
|
#include "scene.h"
|
|
|
|
#include "twn_game_api.h"
|
|
#include "twn_vec.h"
|
|
|
|
#define STB_PERLIN_IMPLEMENTATION
|
|
#include <stb_perlin.h>
|
|
#include <SDL2/SDL.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
|
#define TERRAIN_FREQUENCY 0.1f
|
|
#define TERRAIN_DISTANCE 32
|
|
#define HALF_TERRAIN_DISTANCE ((float)TERRAIN_DISTANCE / 2)
|
|
#define PLAYER_HEIGHT 0.6f
|
|
|
|
static float heightmap[TERRAIN_DISTANCE][TERRAIN_DISTANCE];
|
|
|
|
|
|
static void process_fly_mode(State *state) {
|
|
SceneIngame *scn = (SceneIngame *)state->scene;
|
|
|
|
DrawCameraFromPrincipalAxesResult dir_and_up =
|
|
draw_camera_from_principal_axes(scn->pos, (float)M_PI_2 * 0.8f, scn->roll, scn->pitch, scn->yaw);
|
|
|
|
const Vec3 right = m_vec_norm(m_vec_cross(dir_and_up.direction, dir_and_up.up));
|
|
const float speed = 0.04f; /* TODO: put this in a better place */
|
|
if (input_action_pressed("player_left"))
|
|
scn->pos = vec3_sub(scn->pos, m_vec_scale(right, speed));
|
|
|
|
if (input_action_pressed("player_right"))
|
|
scn->pos = vec3_add(scn->pos, m_vec_scale(right, speed));
|
|
|
|
if (input_action_pressed("player_forward"))
|
|
scn->pos = vec3_add(scn->pos, m_vec_scale(dir_and_up.direction, speed));
|
|
|
|
if (input_action_pressed("player_backward"))
|
|
scn->pos = vec3_sub(scn->pos, m_vec_scale(dir_and_up.direction, speed));
|
|
|
|
if (input_action_pressed("player_jump"))
|
|
scn->pos.y += speed;
|
|
|
|
if (input_action_pressed("player_run"))
|
|
scn->pos.y -= speed;
|
|
}
|
|
|
|
|
|
static float height_at(SceneIngame *scn, Vec2 position) {
|
|
float height0, height1, height2, weight0, weight1, weight2;
|
|
|
|
int const x = (int)(HALF_TERRAIN_DISTANCE + (position.x - scn->pos.x));
|
|
int const y = (int)(HALF_TERRAIN_DISTANCE + (position.y - scn->pos.z));
|
|
|
|
height0 = heightmap[x][y];
|
|
height1 = heightmap[x + 1][y + 1];
|
|
|
|
Vec2 incell = { position.x - floorf(position.x), position.y - floorf(position.y) };
|
|
|
|
/* who needs barycentric coordinates, am i right? */
|
|
weight0 = 1 / sqrtf(powf(incell.x, 2) + powf(incell.y, 2));
|
|
weight1 = 1 / sqrtf(powf(1 - incell.x, 2) + powf(1 - incell.y, 2));
|
|
|
|
/* find which triangle we're directly under */
|
|
/* for this manhattan distance is sufficient */
|
|
if (incell.x + (1 - incell.y) < (1 - incell.x) + incell.y) {
|
|
height2 = heightmap[x][y + 1];
|
|
weight2 = 1 / sqrtf(powf(incell.x, 2) + powf(1 - incell.y, 2));
|
|
} else {
|
|
height2 = heightmap[x + 1][y];
|
|
weight2 = 1 / sqrtf(powf(1 - incell.x, 2) + powf(incell.y, 2));
|
|
}
|
|
|
|
return (height0 * weight0 + height1 * weight1 + height2 * weight2) / (weight0 + weight1 + weight2);
|
|
}
|
|
|
|
|
|
static void process_ground_mode(State *state) {
|
|
SceneIngame *scn = (SceneIngame *)state->scene;
|
|
|
|
DrawCameraFromPrincipalAxesResult dir_and_up =
|
|
draw_camera_from_principal_axes(scn->pos, (float)M_PI_2 * 0.8f, scn->roll, scn->pitch, scn->yaw);
|
|
|
|
dir_and_up.direction.y = 0;
|
|
dir_and_up.direction = vec3_norm(dir_and_up.direction);
|
|
|
|
const Vec3 right = m_vec_norm(m_vec_cross(dir_and_up.direction, dir_and_up.up));
|
|
const float speed = 0.18f; /* TODO: put this in a better place */
|
|
|
|
Vec3 target = scn->pos;
|
|
|
|
/* gravity */
|
|
{
|
|
float const height = height_at(scn, (Vec2){scn->pos.x, scn->pos.z});
|
|
|
|
if (target.y > height + PLAYER_HEIGHT)
|
|
target.y = target.y - 0.4f;
|
|
|
|
if (target.y < height + PLAYER_HEIGHT)
|
|
target.y = height + PLAYER_HEIGHT;
|
|
}
|
|
|
|
/* movement */
|
|
{
|
|
Vec3 direction = {0, 0, 0};
|
|
|
|
if (input_action_pressed("player_left"))
|
|
direction = m_vec_sub(direction, m_vec_scale(right, speed));
|
|
|
|
if (input_action_pressed("player_right"))
|
|
direction = m_vec_add(direction, m_vec_scale(right, speed));
|
|
|
|
if (input_action_pressed("player_forward"))
|
|
direction = m_vec_add(direction, m_vec_scale(dir_and_up.direction, speed));
|
|
|
|
if (input_action_pressed("player_backward"))
|
|
direction = m_vec_sub(direction, m_vec_scale(dir_and_up.direction, speed));
|
|
|
|
target = m_vec_add(target, direction);
|
|
}
|
|
|
|
/* interpolate */
|
|
scn->pos.x = (target.x - scn->pos.x) * (0.13f / 0.9f) + scn->pos.x;
|
|
scn->pos.y = (target.y - scn->pos.y) * (0.13f / 0.9f) + scn->pos.y;
|
|
scn->pos.z = (target.z - scn->pos.z) * (0.13f / 0.9f) + scn->pos.z;
|
|
}
|
|
|
|
|
|
static void generate_terrain(SceneIngame *scn) {
|
|
for (int ly = 0; ly < TERRAIN_DISTANCE; ly++) {
|
|
for (int lx = 0; lx < TERRAIN_DISTANCE; lx++) {
|
|
float x = floorf(scn->pos.x - HALF_TERRAIN_DISTANCE + (float)lx);
|
|
float y = floorf(scn->pos.z - HALF_TERRAIN_DISTANCE + (float)ly);
|
|
|
|
float height = stb_perlin_noise3((float)x * TERRAIN_FREQUENCY, (float)y * TERRAIN_FREQUENCY, 0, 0, 0, 0) * 3 - 1;
|
|
|
|
heightmap[lx][ly] = height;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void draw_terrain(SceneIngame *scn) {
|
|
for (int ly = TERRAIN_DISTANCE - 1; ly > 0; ly--) {
|
|
for (int lx = 0; lx < TERRAIN_DISTANCE - 1; lx++) {
|
|
int32_t x = (int32_t)(floorf(scn->pos.x - HALF_TERRAIN_DISTANCE + (float)lx));
|
|
int32_t y = (int32_t)(floorf(scn->pos.z - HALF_TERRAIN_DISTANCE + (float)ly));
|
|
|
|
float d0 = heightmap[lx][ly];
|
|
float d1 = heightmap[lx + 1][ly];
|
|
float d2 = heightmap[lx + 1][ly - 1];
|
|
float d3 = heightmap[lx][ly - 1];
|
|
|
|
draw_triangle("/assets/grass.png",
|
|
(Vec3){ (float)x, d0, (float)y },
|
|
(Vec3){ (float)x + 1, d1, (float)y },
|
|
(Vec3){ (float)x, d3, (float)y - 1 },
|
|
(Vec2){ 128, 128 },
|
|
(Vec2){ 128, 0 },
|
|
(Vec2){ 0, 128 });
|
|
|
|
draw_triangle("/assets/grass.png",
|
|
(Vec3){ (float)x + 1, d1, (float)y },
|
|
(Vec3){ (float)x + 1, d2, (float)y - 1 },
|
|
(Vec3){ (float)x, d3, (float)y - 1 },
|
|
(Vec2){ 128, 0 },
|
|
(Vec2){ 0, 0 },
|
|
(Vec2){ 0, 128 });
|
|
|
|
draw_billboard("/assets/grasses/10.png",
|
|
(Vec3){ (float)x, d0 + 0.15f, (float)y },
|
|
(Vec2){0.3f, 0.3f},
|
|
(Color){255, 255, 255, 255}, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void ingame_tick(State *state) {
|
|
SceneIngame *scn = (SceneIngame *)state->scene;
|
|
|
|
input_action("player_left", CONTROL_A);
|
|
input_action("player_right", CONTROL_D);
|
|
input_action("player_forward", CONTROL_W);
|
|
input_action("player_backward", CONTROL_S);
|
|
input_action("player_jump", CONTROL_SPACE);
|
|
input_action("player_run", CONTROL_LSHIFT);
|
|
input_action("mouse_capture_toggle", CONTROL_ESCAPE);
|
|
input_action("toggle_camera_mode", CONTROL_C);
|
|
|
|
if (scn->mouse_captured) {
|
|
const float sensitivity = 0.4f * (float)DEG2RAD; /* TODO: put this in a better place */
|
|
scn->yaw += (float)ctx.mouse_movement.x * sensitivity;
|
|
scn->pitch -= (float)ctx.mouse_movement.y * sensitivity;
|
|
scn->pitch = clampf(scn->pitch, (float)-M_PI * 0.49f, (float)M_PI * 0.49f);
|
|
}
|
|
|
|
if (input_action_just_pressed("toggle_camera_mode"))
|
|
scn->flying_camera = !scn->flying_camera;
|
|
|
|
if (scn->flying_camera) {
|
|
process_fly_mode(state);
|
|
} else {
|
|
process_ground_mode(state);
|
|
}
|
|
|
|
/* toggle mouse capture with end key */
|
|
if (input_action_just_pressed("mouse_capture_toggle"))
|
|
scn->mouse_captured = !scn->mouse_captured;
|
|
|
|
input_mouse_captured(scn->mouse_captured);
|
|
|
|
generate_terrain(scn);
|
|
draw_terrain(scn);
|
|
|
|
draw_skybox("/assets/miramar/miramar_*.tga");
|
|
draw_fog(0.9f, 1.0f, 0.05f, (Color){ 140, 147, 160, 255 });
|
|
}
|
|
|
|
|
|
static void ingame_end(State *state) {
|
|
free(state->scene);
|
|
}
|
|
|
|
|
|
Scene *ingame_scene(State *state) {
|
|
(void)state;
|
|
|
|
SceneIngame *new_scene = ccalloc(1, sizeof *new_scene);
|
|
new_scene->base.tick = ingame_tick;
|
|
new_scene->base.end = ingame_end;
|
|
|
|
new_scene->mouse_captured = true;
|
|
|
|
m_audio(m_set(path, "music/mod65.xm"),
|
|
m_opt(channel, "soundtrack"),
|
|
m_opt(repeat, true));
|
|
|
|
new_scene->pos = (Vec3){ 0.1f, 0.0, 0.1f };
|
|
|
|
return (Scene *)new_scene;
|
|
}
|