Add camera handling and movement

Camera related movements have been moved to camera.c - it tracks the
matrices as well so we don't have to call it in block_update

The player class is empty right now, but the camera will be a child of
the player, and the player a child of the engine

11 files changed, 112 insertions, 21 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 2b88db2..9b9cf03 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -9,4 +9,5 @@ add_executable(junkcraft
     chunk.c
     world.c
     input.c
+    camera.c
 )
diff --git a/src/block.c b/src/block.c
index a21203f..544be0a 100644
--- a/src/block.c
+++ b/src/block.c
@@ -74,30 +74,18 @@ void block_update(struct block* blk) {
     // RTS matrix - rotate, translate, scale
     glm_mat4_identity(blk->model);
     float angle = glm_rad(blk->angle);
-    vec3 axis_y = { 0.0f, 1.0f, 0.0f };
     vec3 scale = { 0.90f, 0.90f, 0.90f };
     glm_translate(blk->model, blk->coords);
     glm_scale(blk->model, scale);
     // glm_rotate_at(blk->model, pivot, angle, rot_axis);
     // View matrix (camera)
-    vec3 camera = { 8.0f, 10.0f, 15.0f };
-    vec3 cam_pivot = { 8.0f, 0.0f, -8.0f };
-    vec3 camera_direction = { 0.0f, -1.0f, -5.0f };
-    //glm_look(camera, camera_direction, axis_y, blk->view);
-    glm_lookat(camera, cam_pivot, axis_y, blk->view);
-    glm_rotate_at(blk->view, cam_pivot, angle, axis_y);
-    // Projection (perspective) matrix
-    glm_perspective(glm_rad(45.0f), 800.0f / 600.0f, 0.1f, -10.0f, blk->perspective);
-
-    blk->angle = fmodf(blk->angle + 0.005f, 360.0f);
+    //blk->angle = fmodf(blk->angle + 0.005f, 360.0f);
 }
 
 // Register block vbos and ebos to context
 int block_draw(struct block* blk, struct shader* shader) {
     glBindVertexArray(blk->_vao);
     set_uniform_mat4("model", shader, blk->model);
-    set_uniform_mat4("view", shader, blk->view);
-    set_uniform_mat4("perspective", shader, blk->perspective);
     GLuint loc = glGetUniformLocation(shader->program, "face_colors");
     if (loc == -1) {
         fprintf(stderr, "Invalid var %s for get_uniform_mat4: Does not exist\n", "face_colors");
@@ -124,9 +112,5 @@ void block_debug(struct block *blk) {
     glm_vec3_print(blk->coords, stderr);
     fprintf(stderr, "==== Block Model ====\n");
     glm_mat4_print(blk->model, stderr);
-    fprintf(stderr, "==== Block View ====\n");
-    glm_mat4_print(blk->view, stderr);
-    fprintf(stderr, "==== Block Perspective ====\n");
-    glm_mat4_print(blk->perspective, stderr);
 
 }
diff --git a/src/block.h b/src/block.h
index 4c308d4..1da88ac 100644
--- a/src/block.h
+++ b/src/block.h
@@ -10,8 +10,6 @@ struct block {
     GLuint _ebo;
     int _vertex_count;
     mat4 model;
-    mat4 view;
-    mat4 perspective;
     float angle;
 };
 int block_init(vec3 pos, struct block* blk);
diff --git a/src/camera.c b/src/camera.c
new file mode 100644
index 0000000..e409b06
--- /dev/null
+++ b/src/camera.c
@@ -0,0 +1,44 @@
+#include "camera.h"
+#include "cglm/cam.h"
+#include "cglm/io.h"
+#include "cglm/mat4.h"
+#include "cglm/vec3.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void camera_init(struct camera** camera) {
+    struct camera* cam = malloc(sizeof(struct camera));
+    memset(cam, 0, sizeof(struct camera));
+    vec3 camera_direction = { 0.0f, -1.0f, -5.0f };
+    vec3 camera_up = { 0.0f, 1.0f, 0.0f };
+    memcpy(cam->direction, camera_direction, sizeof(vec3));
+    memcpy(cam->up, camera_up, sizeof(vec3));
+    glm_mat4_identity(cam->view);
+    glm_mat4_identity(cam->perspective);
+    cam->fov = glm_rad(45.0f);
+    *camera = cam;
+}
+void camera_set_position(struct camera* camera, vec3 pos) {
+    memcpy(camera->position, pos, sizeof(vec3));
+}
+
+void camera_update(struct camera* camera, struct shader* shader) {
+    // vec3 camera = { 8.0f, 10.0f, 15.0f };
+    // vec3 cam_pivot = { 8.0f, 0.0f, -8.0f };
+    glm_look(camera->position, camera->direction, camera->up, camera->view);
+    // glm_lookat(camera, cam_pivot, axis_y, blk->view);
+    // glm_rotate_at(blk->view, cam_pivot, angle, axis_y);
+    // Projection (perspective) matrix
+    glm_perspective(camera->fov, 800.0f / 600.0f, 0.1f, -10.0f, camera->perspective);
+    set_uniform_mat4("view", shader, camera->view);
+    set_uniform_mat4("perspective", shader, camera->perspective);
+    // fprintf(stderr, "==== Block View ====\n");
+    // glm_mat4_print(camera->view, stderr);
+    // fprintf(stderr, "==== Block Perspective ====\n");
+    // glm_mat4_print(camera->perspective, stderr);
+}
+
+void camera_move(struct camera *camera, float *move) {
+    glm_vec3_add(camera->position, move, camera->position);
+}
diff --git a/src/camera.h b/src/camera.h
new file mode 100644
index 0000000..199f0b4
--- /dev/null
+++ b/src/camera.h
@@ -0,0 +1,17 @@
+#pragma once
+#include "cglm/types.h"
+#include "shader.h"
+
+struct camera {
+    vec3 position;
+    vec3 direction;
+    vec3 up;
+    mat4 view;
+    mat4 perspective;
+    float fov;
+};
+
+void camera_init(struct camera** camera);
+void camera_update(struct camera* camera, struct shader* shader);
+void camera_set_position(struct camera* camera, vec3 pos);
+void camera_move(struct camera* camera, vec3 move);
diff --git a/src/engine.c b/src/engine.c
index 84db967..7bfa115 100644
--- a/src/engine.c
+++ b/src/engine.c
@@ -1,5 +1,6 @@
 #include "engine.h"
 #include "block.h"
+#include "camera.h"
 #include "chunk.h"
 #include "input.h"
 #include "window.h"
@@ -44,6 +45,14 @@ int engine_init(struct engine *engine) {
             _engine_insert_chunk_ptrs(engine, chunk);
         }
     }
+
+
+    // Setup camera
+    camera_init(&engine->camera);
+    vec3 camera_pos = { 10.0f, 10.0f, 15.0f };
+    camera_set_position(engine->camera, camera_pos);
+
+    // Final step - Start the game
     engine->game_loop = 1;
     return 0;
 }
@@ -73,6 +82,7 @@ void engine_draw(struct engine* engine) {
         glUseProgram(engine->shader->program);
         for (int i = 0; i < vector_length(engine->objects); i++) {
             struct block* block = vector_get(engine->objects, i);
+            camera_update(engine->camera, engine->shader);
             block_draw(block, engine->shader);
         }
         SDL_RenderPresent(engine->window->renderer);
diff --git a/src/engine.h b/src/engine.h
index 7fde16f..2eb7518 100644
--- a/src/engine.h
+++ b/src/engine.h
@@ -6,6 +6,7 @@ struct engine {
     struct window* window;
     struct shader* shader;
     struct vector* objects;
+    struct camera* camera;
     int game_loop;
 };
 
diff --git a/src/input.c b/src/input.c
index 68722e7..54ae199 100644
--- a/src/input.c
+++ b/src/input.c
@@ -1,5 +1,8 @@
 #include "input.h"
+#include "camera.h"
+#include "cglm/types.h"
 #include "pthread.h"
+#include <SDL2/SDL_events.h>
 
 pthread_t input_init(struct engine* engine) {
     pthread_t thread;
@@ -18,5 +21,29 @@ void input_handle(struct engine *engine) {
         if (event.type == SDL_QUIT) {
             engine->game_loop = 0;
         }
+        if (event.type == SDL_KEYDOWN) {
+            SDL_KeyboardEvent key = event.key;
+            vec3 ahead = { 0.0f, 0.0f, -1.0f };
+            vec3 behind = { 0.0f, 0.0f, 1.0f };
+            vec3 left = { -1.0f, 0.0f, 0.0f };
+            vec3 right = { 1.0f, 0.0f, 0.0f };
+            switch (key.keysym.sym) {
+                case SDLK_w:
+                    camera_move(engine->camera, ahead);
+                    break;
+                case SDLK_a:
+                    camera_move(engine->camera, left);
+                    break;
+                case SDLK_s:
+                    camera_move(engine->camera, behind);
+                    break;
+                case SDLK_d:
+                    camera_move(engine->camera, right);
+                    break;
+                case SDLK_ESCAPE:
+                    engine->game_loop = 0;
+                    break;
+            }
+        }
     }
 }
diff --git a/src/player.c b/src/player.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/player.c
diff --git a/src/player.h b/src/player.h
new file mode 100644
index 0000000..2f47d73
--- /dev/null
+++ b/src/player.h
@@ -0,0 +1,8 @@
+#pragma once
+#include "camera.h"
+#include "cglm/cglm.h"
+
+struct player {
+    vec3 position;
+    struct camera* camera;
+};
diff --git a/src/world.c b/src/world.c
index e81f100..72a0c21 100644
--- a/src/world.c
+++ b/src/world.c
@@ -7,8 +7,9 @@ int world_init(int32_t seed, struct world** world) {
     struct world* wld = malloc(sizeof(struct world));
     memset(wld, 0, sizeof(struct world));
     wld->seed = seed;
-    for (int i = 0; i < WORLD_WIDTH; i++) {
-        for (int j = 0; j < WORLD_LENGTH; j++) {
+    //TODO: Improve loading here
+    for (int i = 0; i < 2; i++) {
+        for (int j = 0; j < 2; j++) {
             struct chunk* chunk;
             vec2 coords = { i, j };
             chunk_gen(wld, coords, &chunk);