init: kick-off repository from gravity's SC

source code was taken from my project gravity and
modified so I can reuse the renderer in other projects.
I will also upgrade it, free it from old bugs, put more
effort into learning the math behind rendering, etc.

.gitignore

@@ -0,0 +1,6 @@
+.idea/
+cmake-build-debug/
+build/
+.ccls-cache/
+*.mtl
+compile_commands.json

Makefile

@@ -0,0 +1,23 @@
+CC=gcc
+CFLAGS=-DFREEGLUT_STATIC -g3
+LFLAGS=-lglfw -L/usr/lib64 -lGLEW -lGL -lX11 -lGLU -lassimp -lm
+LD=ld
+OUT=build
+DEV=dev.c
+
+all:
+	mkdir -p $(OUT)
+	$(CC) $(CFLAGS) -c rendlib.c -o $(OUT)/rendlib.o $(LFLAGS)
+	$(CC) $(CFLAGS) -c math.c -o $(OUT)/math.o $(LFLAGS)
+	$(CC) $(CFLAGS) -c object.c -o $(OUT)/object.o $(LFLAGS)
+	$(LD) -relocatable $(OUT)/rendlib.o $(OUT)/math.o $(OUT)/object.o -o $(OUT)/rendlib
+
+dev: all
+	$(CC) $(CFLAGS) dev.c $(OUT)/rendlib -o $(OUT)/dev $(LFLAGS)
+
+devall: dev 
+	$(OUT)/dev
+
+
+clean: 
+	rm -rf $(OUT)

README

@@ -0,0 +1,8 @@
+               _ _ _ _   
+ ___ ___ ___ _| | |_| |_ 
+|  _| -_|   | . | | | . |
+|_| |___|_|_|___|_|_|___|
+
+    A work in progress rendering library written 
+    in C.
+

assets/shaders/shader.frag

@@ -0,0 +1,21 @@
+#version 330 core
+in vec4 frag_pos;
+in vec4 frag_normal;
+in vec3 object_color;
+
+out vec4 outy;
+
+void main() {
+    vec4 norm = normalize(frag_normal);
+    vec4 ambient = vec4(0.7, 0.7788, 0.46, 1.0);
+    vec4 light_color = vec4(0.7, 0.7, 0.7, 1.0);
+    vec4 color = vec4(object_color.xyz, 1.0f);
+
+    vec4 light_location = vec4(0.0, 100.0, 0.0, 1.0);
+    vec4 light_direction = normalize(light_location - frag_pos);
+    float diff = max(dot(norm.xyz, light_direction.xyz), 0.0);
+
+    vec4 diffuse = diff * light_color;
+
+    outy = color + diffuse;
+}

assets/shaders/shader.vert

@@ -0,0 +1,21 @@
+#version 330 core
+layout (location = 0) in vec3 pos;
+layout (location = 1) in vec3 normal;
+
+uniform mat4 view;
+uniform mat4 projection;
+uniform mat4 translation;
+uniform mat4 rotation;
+uniform vec3 color;
+uniform float scale;
+
+out vec4 frag_pos;
+out vec4 frag_normal;
+out vec3 object_color;
+
+void main() {
+    gl_Position = projection * view * translation * (vec4(pos.xyz, 1.0) * vec4(scale, scale, scale, 1.0));
+    frag_pos = gl_Position;
+    frag_normal = translation * vec4(normal.xyz, 1.0);
+    object_color = color;
+}

dev.c

@@ -0,0 +1,34 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "include/rendlib.h"
+#include "include/object.h"
+
+int main(int argc, char *argv[]) {
+    int ret = rendlib_start_window(argc, argv);
+    if (ret < 0) {
+        fprintf(stderr, "--error: %d\n", ret);
+        return EXIT_FAILURE;
+    }
+
+    struct model *m = load_model("assets/models/sphere.obj");
+    if (m == NULL) {
+        fprintf(stderr, "--error: loading model\n");
+        return EXIT_FAILURE;
+    }
+
+    struct object *o = create_object(&objects, 100.0f, m);
+    if (o == NULL) {
+        fprintf(stderr, "--error: creating object\n");
+        return EXIT_FAILURE;
+    }
+
+    ret = rendlib_render();
+    if (ret < 0) {
+        fprintf(stderr, "--error: %d\n", ret);
+        return EXIT_FAILURE;
+    }
+
+    fprintf(stdout, "--rendering\n");
+
+    return EXIT_SUCCESS;
+}

include/math.h

@@ -0,0 +1,10 @@
+#ifndef MATH_H
+#define MATH_H
+
+#include "object.h"
+#include <cglm/cglm.h>
+
+float frand48(void);
+void calculate_gravity(struct object *src, struct object *target, vec3 force);
+
+#endif 

include/object.h

@@ -0,0 +1,45 @@
+#ifndef OBJECT_H
+#define OBJECT_H 
+
+#include <cglm/cglm.h>
+
+#define MAX_PATHS 2000
+
+struct model {
+    float *vertices;
+    unsigned int *indices;
+    float *normals;
+
+    long vertices_num;
+    long indices_num;
+    long normals_num;
+};
+
+struct object {
+    vec4 translation_force;
+    vec4 position;
+    vec3 color;
+    float mass;
+    void *next;
+
+    float *paths;
+    int paths_num;
+    int paths_max;
+
+    struct model *model;
+    float scale;
+
+    unsigned int vao; // array object for the actual object
+    unsigned int vbo; // buffer for vertices
+    unsigned int ebo; // buffer for indices
+    unsigned int nbo; // buffer for normals
+
+    unsigned int pvao; // array object for paths
+    unsigned int pbo; // buffer for paths
+};
+
+struct model *load_model(const char *path);
+int record_path(struct object *obj);
+struct object *create_object(struct object **o, float mass, struct model *model);
+
+#endif

include/rendlib.h

@@ -0,0 +1,15 @@
+#ifndef RENDLIB_H
+#define RENDLIB_H
+
+enum errs {
+    err_glfw_init = -1,
+    err_glfw_win = -2,
+    err_glew_init = -3,
+    err_shaders_init = -4,
+};
+
+extern struct object *objects;
+int rendlib_start_window(int argc, char *argv[]);
+int rendlib_render(void);
+
+#endif

math.c

@@ -0,0 +1,42 @@
+#include "math.h"
+#include "include/object.h"
+#include <cglm/cglm.h>
+
+float frand48(void) {
+    float number = (float) rand() / (float) (RAND_MAX + 1.0);
+    float side = rand() % 2;
+    if (side == 0) {
+        number = -number;
+    }
+
+    return number;
+}
+
+void calculate_gravity(struct object *src, struct object *target, vec3 force) {
+    vec4 v4distance;
+    glm_vec4_sub(target->position, src->position, v4distance);
+
+    vec3 v3distance;
+    glm_vec3(v4distance, v3distance);
+
+    float distance_xy = sqrt((v3distance[0] * v3distance[0]) + (v3distance[1] * v3distance[1]));
+    float distance_xyz = sqrt((distance_xy * distance_xy) + (v3distance[2] * v3distance[2]));
+    float force_scale = 4.0f;
+
+    float g = 6.67f * 1e-11f;
+    float top = g * src->mass * target->mass;
+
+    for (int i = 0; i < 3; i++) {
+        v3distance[i] = (v3distance[i] * v3distance[i] * v3distance[i]);
+    }
+
+    for (int i = 0; i < 3; i++) {
+        if (v3distance[i] == 0) {
+            force[i] = 0.0f;
+            continue;
+        }
+
+        force[i] = (top / (distance_xyz / (target->position[i] - src->position[i]))) * force_scale;
+    }
+}
+

object.c

@@ -0,0 +1,129 @@
+#include "include/object.h"
+
+#include "include/math.h"
+#include <math.h>
+#include <assimp/cimport.h>
+#include <assimp/scene.h>
+#include <assimp/postprocess.h>
+
+struct model *load_model(const char *path) {
+    struct model *new_model = (struct model *) calloc(1, sizeof(struct model));
+    const struct aiScene *scene = aiImportFile(path, aiProcess_Triangulate);
+
+    if (scene == NULL) {
+        fprintf(stderr, "Error: failed importing file from path '%s'", path);
+    }
+
+    for (int mesh_index = 0; mesh_index < scene->mNumMeshes; mesh_index++) {
+        struct aiMesh *mesh = scene->mMeshes[mesh_index];
+
+        // fetch vertices
+        for (int vertex_index = 0; vertex_index < mesh->mNumVertices; vertex_index++) {
+            struct aiVector3D *vertex = &(mesh->mVertices[vertex_index]);
+            long start = new_model->vertices_num*3;
+
+            new_model->vertices_num++;
+            new_model->vertices = (float *) realloc(new_model->vertices, new_model->vertices_num*3*sizeof(float));
+            if (new_model->vertices == NULL) {
+                fprintf(stderr, "Error: failed allocating memory for vertices\n");
+                goto error;
+            }
+
+            memcpy(&new_model->vertices[start], vertex, sizeof(float)*3);
+        }
+
+        // fetch indices
+        for (int face_index = 0; face_index < mesh->mNumFaces; face_index++) {
+            struct aiFace *face = &(mesh->mFaces[face_index]);
+            long start = new_model->indices_num;
+
+            new_model->indices_num += face->mNumIndices;
+            new_model->indices = (unsigned int *) realloc(new_model->indices, sizeof(unsigned int)*new_model->indices_num);
+            if (new_model->indices == NULL) {
+                fprintf(stderr, "Error: failed allocating memory for indices\n");
+                goto error;
+            }
+
+            memcpy(&new_model->indices[start], face->mIndices, sizeof(unsigned int)*face->mNumIndices);
+        }
+
+        // fetch normals
+        for (int normal_index = 0; normal_index < mesh->mNumVertices; normal_index++) {
+            struct aiVector3D *normal = &(mesh->mNormals[normal_index]);
+            long start = new_model->normals_num*3;
+
+            new_model->normals_num++;
+            new_model->normals = (float *) realloc(new_model->normals, new_model->normals_num*3*sizeof(float));
+            if (new_model->normals == NULL) {
+                fprintf(stderr, "Error: failed allocating memory for normals\n");
+                goto error;
+            }
+
+            memcpy(&new_model->normals[start], normal, sizeof(float)*3);
+        }
+    }
+
+    return new_model;
+
+error:
+    aiReleaseImport(scene);
+    free(new_model->vertices);
+    free(new_model->indices);
+    free(new_model->normals);
+    free(new_model);
+    return NULL;
+}
+
+int record_path(struct object *obj) {
+    if (obj->paths_num <= obj->paths_max) {
+        obj->paths = (float *) reallocarray(obj->paths, (obj->paths_num+1)*3, sizeof(float));
+    }
+
+    if (obj->paths == NULL) {
+        fprintf(stderr, "Error: failed allocating memory for paths of object\n");
+        return -1;
+    }
+
+    memcpy(obj->paths+(obj->paths_num*3), obj->position, 3*sizeof(float));
+
+    if (obj->paths_num < obj->paths_max) {
+        obj->paths_num++;
+        goto end;
+    }
+
+    // pop first element 
+    memmove(obj->paths, &obj->paths[3], (obj->paths_num)*3*sizeof(float));
+
+end:
+    return 0;
+}
+
+struct object *create_object(struct object **o, float mass, struct model *model) {
+    struct object *no = malloc(sizeof(struct object));
+    if (no == NULL) {
+        return NULL;
+    }
+    memset(no, 0, sizeof(struct object));
+
+    no->mass = mass;
+    no->scale = 1.0f;
+    no->paths_max = MAX_PATHS;
+    no->model = model;
+    glm_vec4_one(no->position);
+    glm_vec3_one(no->color);
+
+    for (int i = 0; i < 3; i++) {
+        no->color[i] = 0.5f + (fabs(frand48()) / 2);
+    }
+
+    if (*o == NULL) {
+        *o = no;
+        return no;
+    }
+
+    struct object *previous_object = *o;
+    no->next = previous_object;
+    *o = no;
+
+    return no;
+}

rendlib.c

@@ -0,0 +1,473 @@
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+#include <cglm/cglm.h>
+#include "include/rendlib.h"
+#include "include/math.h"
+#include "include/object.h"
+
+// global variables 
+int window_width = 960;
+int window_height = 540;
+char *window_title = "rendlib window";
+
+// global settings
+float fov = 80.0f; // default fov
+float fov_change = 1.0f;
+vec3 camera_pos = { 0.0f, 0.0f, 20.0f };
+vec3 camera_front = { 0.0f, 0.0f, -1.0f };
+vec3 camera_up = { 0.0f, 1.0f, 0.0f }; 
+struct object *camera_lock = NULL; // is camera locked to any object?
+float camera_yaw = -90.0f; // x rotation
+float camera_pitch = 0.0f; // y rotation
+float camera_sensitivity = 0.01f;
+float top_movement_speed = 0.2f;
+vec3 speed = { 0.0f, 0.0f, 0.0f };
+
+GLint screen_viewport[4]; // viewport: x,y,width,height
+int toggle_tracing = 0; // true or false
+long added_particles = 0;
+
+// tmp input 
+int inputs[8] = {0,0,0,0,0,0,};
+
+// tmp 
+struct model *sphere_model;
+struct object *objects;
+
+// opengl
+unsigned int shader_program;
+unsigned int vertex_shader;
+unsigned int fragment_shader;
+
+// shaders
+const char *object_vertex_shader_location = "assets/shaders/shader.vert";
+const char *object_fragment_shader_location = "assets/shaders/shader.frag";
+
+int load_shader(const char *path, unsigned int shader) {
+    FILE *fp = fopen(path, "r");
+    if (fp == NULL) {
+        fprintf(stderr, "error: cannot open file '%s'\n", path);
+        return -1;
+    }
+
+    fseek(fp, 0L, SEEK_END);
+    int len = ftell(fp);
+    if (len == -1) {
+        fprintf(stderr, "error: cannot fetch length of file '%s'\n", path);
+        return -1;
+    }
+
+    fseek(fp, 0L, SEEK_SET);
+    char *fc = (char *) malloc(len);
+    if (fc == NULL) {
+        fprintf(stderr, "error: not enough dynamic memory\n");
+        return -1;
+    }
+    memset(fc, 0, len);
+    int rb = 0;
+    do {
+        rb += fread(fc+rb, sizeof(char), len-rb, fp);
+        if (rb == 0) {
+            break;
+        }
+    } while (rb < len);
+
+    fclose(fp);
+    glShaderSource(shader, 1, (const char **) &fc, &rb);
+    glCompileShader(shader);
+
+    int success;
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+    if (success != GL_TRUE) {
+        int log_length;
+        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
+
+        char log[log_length];
+        glGetShaderInfoLog(shader, log_length, NULL, log);
+
+        fprintf(stderr, "Shader Compilation Error: %s\n", log);
+        return -1;
+    }
+
+    free(fc);
+    return 0;
+}
+
+int load_shaders(void) {
+    glDeleteProgram(shader_program);
+    shader_program = glCreateProgram();
+
+    // create and load new shaders
+    vertex_shader = glCreateShader(GL_VERTEX_SHADER);
+    fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
+
+    if (load_shader(object_vertex_shader_location, vertex_shader) == -1) {
+        return -1;
+    }
+
+    if (load_shader(object_fragment_shader_location, fragment_shader) == -1) {
+        return -1;
+    }
+
+    // compile object shader program
+    glAttachShader(shader_program, vertex_shader);
+    glAttachShader(shader_program, fragment_shader);
+    glLinkProgram(shader_program);
+
+    int success;
+    glGetProgramiv(shader_program, GL_LINK_STATUS, &success);
+
+    if (success != GL_TRUE) {
+        int log_length;
+        glGetProgramiv(shader_program, GL_INFO_LOG_LENGTH, &log_length);
+
+        char log[log_length];
+        glGetProgramInfoLog(shader_program, log_length, NULL, log);
+
+        fprintf(stderr, "[object program] Shader Compilation Error: %s\n", log);
+        return -1;
+    }
+
+    glDeleteShader(vertex_shader);
+    glDeleteShader(fragment_shader);
+
+    return 0;
+}
+
+void handle_input(void) {
+    int ret = 0; 
+    if (inputs[0]) {
+        exit(EXIT_SUCCESS);
+        inputs[0] = 0; 
+    }
+
+    if (inputs[1]) {
+        ret = load_shaders();
+        if (ret < 0) {
+            fprintf(stderr, "--error: reloading shaders\n");
+            exit(EXIT_FAILURE);
+        }
+        inputs[1] = 0; 
+    }
+
+    if (inputs[2]) {
+        vec3 side_scalar = {top_movement_speed, top_movement_speed, top_movement_speed };
+        vec3 camera_side;
+        glm_cross(camera_front, camera_up, camera_side);
+        glm_normalize(camera_side);
+        glm_vec3_mul(camera_side, side_scalar, camera_side);
+        glm_vec3_sub(camera_pos, camera_side, camera_pos);
+    }
+
+    if (inputs[3]) {
+        vec3 side_scalar = {top_movement_speed, top_movement_speed, top_movement_speed };
+        vec3 camera_side;
+        glm_cross(camera_front, camera_up, camera_side);
+        glm_normalize(camera_side);
+        glm_vec3_mul(camera_side, side_scalar, camera_side);
+        glm_vec3_add(camera_pos, camera_side, camera_pos);
+    }
+
+    if (inputs[4]) {
+        vec3 front_scalar = {top_movement_speed, top_movement_speed, top_movement_speed };
+        glm_vec3_mul(front_scalar, camera_front, front_scalar);
+        glm_vec3_sub(camera_pos, front_scalar, camera_pos);
+    }
+
+    if (inputs[5]) {
+        vec3 front_scalar = {top_movement_speed, top_movement_speed, top_movement_speed };
+        glm_vec3_mul(front_scalar, camera_front, front_scalar);
+        glm_vec3_add(camera_pos, front_scalar, camera_pos);
+    }
+}
+
+void window_size(GLFWwindow *w, int width, int height) {
+    glViewport(0, 0, width, height);
+}
+
+void display(void) {
+    handle_input();
+    GLFWwindow *w = glfwGetCurrentContext();
+
+    mat4 view;
+    mat4 projection;
+
+    GLint translation_uniform;
+    GLint view_uniform;
+    GLint projection_uniform;
+    GLint color_uniform;
+    GLint scale_uniform;
+
+    glClearColor(0.13f, 0.13f, 0.13f, 0.0f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glGetIntegerv(GL_VIEWPORT, screen_viewport);
+    glUseProgram(shader_program);
+
+    glm_mat4_identity(view);
+    vec3 camera_center;
+    glm_vec3_add(camera_pos, camera_front, camera_center);
+    glm_lookat(camera_pos, camera_center, camera_up, view);
+
+    glm_mat4_identity(projection);
+    glm_perspective(glm_rad(fov), (float) screen_viewport[2]/(float) screen_viewport[3], 0.01f, 100000.0f, projection);
+
+    view_uniform = glGetUniformLocation(shader_program, "view");
+    projection_uniform = glGetUniformLocation(shader_program, "projection");
+    translation_uniform = glGetUniformLocation(shader_program, "translation");
+    color_uniform = glGetUniformLocation(shader_program, "color");
+    scale_uniform = glGetUniformLocation(shader_program, "scale");
+
+    glUniformMatrix4fv(view_uniform, 1, GL_FALSE, (float *) view);
+    glUniformMatrix4fv(projection_uniform, 1, GL_FALSE, (float *) projection);
+
+    for (struct object *obj = objects; obj != NULL; obj = obj->next) {
+        mat4 translation_matrix;
+        glm_mat4_identity(translation_matrix);
+        struct model *obj_model = obj->model;
+
+        // calculate gravity
+        for (struct object *target = objects; target != NULL; target = target->next) {
+            if (target == obj) {
+                continue;
+            }
+
+            vec3 force;
+            glm_vec3_zero(force);
+            calculate_gravity(obj, target, force);
+
+            vec4 force_new;
+            for (int i = 0; i < 3; i++) {
+                force_new[i] = force[i];
+            }
+            force_new[3] = 0.0f;
+
+            float n = obj->mass;
+            vec4 scaler = {n,n,n,1.0f};
+            glm_vec4_div(force_new, scaler, force_new);
+
+            glm_vec4_add(force_new, obj->translation_force, obj->translation_force);
+        }
+
+        glm_vec4_add(obj->position, obj->translation_force, obj->position);
+
+        // follow object if camera locked 
+        if (camera_lock == obj) {
+            glm_vec3_add(camera_pos, obj->translation_force, camera_pos);
+        }
+
+        // record path
+        if (toggle_tracing == 1) {
+            if (record_path(obj) == -1) {
+                exit(EXIT_FAILURE);
+            }
+        }
+
+        glm_translate(translation_matrix, obj->position);
+
+        glUniformMatrix4fv(translation_uniform, 1, GL_FALSE, (float *) translation_matrix);
+
+        glUniform3fv(color_uniform, 1, (float *) obj->color);
+        glUniform1f(scale_uniform, obj->scale);
+
+        glBindVertexArray(obj->vao);
+        glDrawElements(GL_TRIANGLES, obj_model->indices_num, GL_UNSIGNED_INT, (void *) 0);
+
+        glBindVertexArray(obj->pvao);
+
+        glBindBuffer(GL_ARRAY_BUFFER, obj->pbo);
+        glBufferData(GL_ARRAY_BUFFER, obj->paths_num*3*sizeof(float),obj->paths, GL_STATIC_DRAW);
+
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(float), (void *) 0);
+        glEnableVertexAttribArray(0);
+
+        glm_mat4_identity(translation_matrix);
+        glUniformMatrix4fv(translation_uniform, 1, GL_FALSE, (float *) translation_matrix);
+        glUniform1f(scale_uniform, 1.0f);
+
+        glDrawArrays(GL_LINE_STRIP, 0, obj->paths_num);
+    }
+
+    /*glutPostRedisplay();
+    glutSwapBuffers();*/
+    glfwSwapBuffers(w);
+    glfwPollEvents();
+}
+
+void rendlib_bake_graphics(void) {
+    // setup default mouse position
+    glGetIntegerv(GL_VIEWPORT, screen_viewport);
+
+
+    for (struct object *obj = objects; obj != NULL; obj = obj->next) {
+        struct model *obj_model = obj->model;
+        glGenVertexArrays(1, &obj->vao);
+        glGenVertexArrays(1, &obj->pvao);
+        glGenBuffers(1, &obj->vbo);
+        glGenBuffers(1, &obj->ebo);
+        glGenBuffers(1, &obj->nbo);
+        glGenBuffers(1, &obj->pbo);
+
+        glBindVertexArray(obj->vao);
+
+        glBindBuffer(GL_ARRAY_BUFFER,obj->vbo);
+        glBufferData(GL_ARRAY_BUFFER,obj_model->vertices_num*3*sizeof(float),obj_model->vertices, GL_STATIC_DRAW);
+
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(float), (void *) 0);
+        glEnableVertexAttribArray(0);
+
+        glBindBuffer(GL_ARRAY_BUFFER, obj->nbo);
+        glBufferData(GL_ARRAY_BUFFER, obj_model->normals_num*3*sizeof(float), obj_model->normals, GL_STATIC_DRAW);
+
+        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3*sizeof(float), (void *) 0);
+        glEnableVertexAttribArray(1);
+
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,obj->ebo);
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, obj_model->indices_num*sizeof(unsigned int), obj_model->indices, GL_STATIC_DRAW);
+
+        glBindVertexArray(0);
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    }
+
+    glEnable(GL_DEPTH_TEST);
+}
+void keyboard(GLFWwindow *w, int key, int scancode, int action, int mods) {
+    if (action == GLFW_PRESS) {
+        switch (key) {
+            case GLFW_KEY_ESCAPE: 
+                inputs[0] = 1;
+                break;
+            case GLFW_KEY_R: 
+                inputs[1] = 1;
+                break;
+            case GLFW_KEY_A:
+                inputs[2] = 1;
+                break;
+            case GLFW_KEY_D:
+                inputs[3] = 1;
+                break;
+            case GLFW_KEY_S:
+                inputs[4] = 1;
+                break;
+            case GLFW_KEY_W:
+                inputs[5] = 1; 
+                break;
+        }
+
+    } else if (action == GLFW_RELEASE) {
+        switch (key) {
+            case GLFW_KEY_A:
+                inputs[2] = 0;
+                break;
+            case GLFW_KEY_D:
+                inputs[3] = 0;
+                break;
+            case GLFW_KEY_S:
+                inputs[4] = 0;
+                break;
+            case GLFW_KEY_W:
+                inputs[5] = 0; 
+                break;
+        }
+    }
+}
+
+void mouse(int button, int state, int x, int y) {
+    switch (button) {
+        case 3:
+            if (fov-fov_change < 0.0f) {
+                break;
+            }
+
+            fov -= fov_change;
+            break;
+        case 4:
+            if (fov+fov_change > 180.0f) {
+                break;
+            }
+
+            fov += fov_change;
+            break;
+        default:
+            break;
+    }
+}
+
+int warped_pointer = 0;
+int first_pointer = 1;
+void mouse_motion(GLFWwindow *window, double x, double y) {
+    if (warped_pointer == 1) {
+        warped_pointer = 0;
+        return;
+    }
+
+    warped_pointer = 1;
+    GLFWwindow *w = glfwGetCurrentContext();
+    glfwSetCursorPos(w, (screen_viewport[2]/2), (screen_viewport[3]/2));
+
+    if (first_pointer == 1) {
+        first_pointer = 0;
+        return;
+    }
+
+    float offset_x = (float) (x - (screen_viewport[2]/2)) * camera_sensitivity;
+    float offset_y = (float) (y - (screen_viewport[3]/2)) * camera_sensitivity;
+
+    camera_yaw += offset_x;
+    camera_pitch -= offset_y;
+
+    // limit view rotation
+    if (camera_pitch < -89.9f) {
+        camera_pitch = -89.9f;
+    }
+    if (camera_pitch > 89.9f) {
+        camera_pitch = 89.9f;
+    }
+
+    vec3 view_direction;
+    view_direction[0] = cos(glm_rad(camera_yaw)) * cos(glm_rad(camera_pitch));
+    view_direction[1] = sin(glm_rad(camera_pitch));
+    view_direction[2] = sin(glm_rad(camera_yaw)) * cos(glm_rad(camera_pitch));
+    glm_normalize_to(view_direction, camera_front);
+}
+
+int rendlib_start_window(int argc, char *argv[]) {
+    int ret = glfwInit();
+    if (!ret) {
+        return err_glfw_init;
+    }
+
+    GLFWwindow *w = glfwCreateWindow(window_width, window_height, window_title, NULL, NULL);
+    if (w == NULL) {
+        return err_glfw_win;
+    }
+
+    glfwMakeContextCurrent(w);
+    glfwSetWindowSizeCallback(w, window_size);
+    glfwSetCursorPosCallback(w, mouse_motion);
+    glfwSetKeyCallback(w, keyboard);
+
+    ret = glewInit();
+    if (ret != GLEW_OK) {
+        return err_glew_init;
+    }
+
+    ret = load_shaders();
+    if (ret < 0) {
+        return err_shaders_init;
+    }
+
+    return 0;
+}
+
+int rendlib_render(void) {
+    rendlib_bake_graphics();
+    for (;;) {
+        display();
+    }
+    return 0;
+}