INSTALL

@@ -1,12 +0,0 @@
-+=============+
-|   INSTALL   |
-+=============+
-
-DEBIAN PACKAGES
-
-	sudo apt-get update 
-	sudo apt-get install libglew-dev
-	sudo apt-get install libglfw3-dev
-	sudo apt-get install libcglm-dev
-	sudo apt-get install libassimp-dev
-

Makefile

@@ -1,35 +1,23 @@
 CC=gcc
-CFLAGS=-DFREEGLUT -g3 -iquote include/
+CFLAGS=-DFREEGLUT_STATIC -g3
 LFLAGS=-lglfw -L/usr/lib64 -lGLEW -lGL -lX11 -lGLU -lassimp -lm
 LD=ld
-SRCDIR=src
+OUT=build
-BINDIR=build
+DEV=dev.c
-TSTDIR=tests
 
-LIB_SRCS = $(wildcard $(SRCDIR)/*.c)
+all:
-LIB_OBJS = $(addprefix $(BINDIR)/, $(notdir $(LIB_SRCS:.c=.o)))
+	mkdir -p $(OUT)
-TST_SRCS = $(wildcard $(TSTDIR)/*.c)
+	$(CC) $(CFLAGS) -c rendlib.c -o $(OUT)/rendlib.o $(LFLAGS)
-TST_OBJS = $(addprefix $(BINDIR)/$(TSTDIR)/, $(notdir $(TST_SRCS:.c=.o)))
+	$(CC) $(CFLAGS) -c math.c -o $(OUT)/math.o $(LFLAGS)
-TST_ASST = $(shell find $(TSTDIR) -maxdepth 1 -mindepth 1 -type d)
+	$(CC) $(CFLAGS) -c object.c -o $(OUT)/object.o $(LFLAGS)
+	$(LD) -relocatable $(OUT)/rendlib.o $(OUT)/math.o $(OUT)/object.o -o $(OUT)/rendlib
 
-init:
+dev: all
-	mkdir -p $(BINDIR) 
+	$(CC) $(CFLAGS) dev.c $(OUT)/rendlib -o $(OUT)/dev $(LFLAGS)
-	mkdir -p $(BINDIR)/tests
 
-all: init $(LIB_OBJS)
+devall: dev 
-	$(LD) -relocatable $(LIB_OBJS) -o $(BINDIR)/rendlib
+	$(OUT)/dev
 
-$(BINDIR)/%.o: $(SRCDIR)/%.c
-	$(CC) $(CFLAGS) -c $< -o $@ $(LFLAGS)
-
-$(BINDIR)/$(TSTDIR)/test-%.o: $(TSTDIR)/test-%.c $(TSTDIR)/assets-% | all
-	$(CC) $(CFLAGS) $< $(BINDIR)/rendlib -o $@ $(LFLAGS)
-	cp -rf $(word 2,$^) $(BINDIR)/$(TSTDIR)/
-
-test: $(TST_OBJS)
-
-runt%: $(BINDIR)/$(TSTDIR)/test-%.o
-	cd $(BINDIR)/$(TSTDIR); ./test-$*.o
 
 clean: 
-	rm -rf $(BINDIR)
+	rm -rf $(OUT)

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/batch.h

@@ -1,14 +0,0 @@
-#ifndef BATCH_H
-#define BATCH_H
-
-#include <GL/glew.h>
-
-struct batch {
-    int id;
-    GLint vertex_array; 
-    GLint vertex_buffer; 
-    GLint indices_buffer;
-    GLint normals_buffer;
-};
-
-#endif 

include/camera.h

@@ -1,32 +0,0 @@
-#ifndef CAMERA_H
-#define CAMERA_H
-
-#include <cglm/vec3.h>
-#include <cglm/mat4.h>
-
-#define CAMERA_PERSPECTIVE 0x1
-#define CAMERA_ORTHOGRAPHIC 0x2
-
-struct camera {
-    int type;
-    float fov; 
-    float near_z; 
-    float far_z; 
-    float yaw; 
-    float pitch; 
-    float sensitivity; 
-    float viewport_modifier;
-
-    vec3 pos; 
-    vec3 front;
-    vec3 center;
-    vec3 up; 
-
-    mat4 view; 
-    mat4 projection;
-};
-
-struct camera *create_camera(int type);
-int bake_camera(struct camera *c);
-
-#endif 

include/math.h

@@ -5,5 +5,6 @@
 #include <cglm/cglm.h>
 
 float frand48(void);
+void calculate_gravity(struct object *src, struct object *target, vec3 force);
 
 #endif 

include/object.h

@@ -19,19 +19,27 @@ 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; 
+    unsigned int vao; // array object for the actual object
-    unsigned int vbo; // vertices
+    unsigned int vbo; // buffer for vertices
-    unsigned int ebo; // indices
+    unsigned int ebo; // buffer for indices
-    unsigned int nbo; // normals
+    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, struct model *model);
+struct object *create_object(struct object **o, float mass, struct model *model);
 
 #endif

include/rendlib.h

@@ -8,13 +8,7 @@ enum errs {
     err_shaders_init = -4,
 };
 
-extern struct camera *ac;
 extern struct object *objects;
-
-extern void (*keyboard_probe)(int key, int scancode, int action, int mods);
-extern void (*mouse_probe)(double x, double y);
-extern void (*update_probe)(void);
-
 int rendlib_start_window(int argc, char *argv[]);
 int rendlib_render(void);
 

include/shaders.h

@@ -1,48 +0,0 @@
-#ifndef SHADERS_H
-#define SHADERS_H 
-
-#define DEFAULT_VSHADER "#version 330 core\n" \
-                        "layout (location = 0) in vec3 pos;\n" \
-                        "layout (location = 1) in vec3 normal;\n" \
-                        "\n" \
-                        "uniform mat4 view;\n" \
-                        "uniform mat4 projection;\n" \
-                        "uniform mat4 translation;\n" \
-                        "uniform mat4 rotation;\n" \
-                        "uniform vec3 color;\n" \
-                        "uniform float scale;\n" \
-                        "\n" \
-                        "out vec4 frag_pos;\n" \
-                        "out vec4 frag_normal;\n" \
-                        "out vec3 object_color;\n" \
-                        "\n" \
-                        "void main() {\n" \
-                        "    gl_Position = projection * view * translation * (vec4(pos.xyz, 1.0) * vec4(scale, scale, scale, 1.0));\n" \
-                        "    frag_pos = gl_Position;\n" \
-                        "    frag_normal = translation * vec4(normal.xyz, 1.0);\n" \
-                        "    object_color = color;\n" \
-                        "}"
-
-#define DEFAULT_FSHADER "#version 330 core\n" \
-                        "in vec4 frag_pos;\n" \
-                        "in vec4 frag_normal;\n" \
-                        "in vec3 object_color;\n" \
-                        "\n" \
-                        "out vec4 outy;\n" \
-                        "\n" \
-                        "void main() {\n" \
-                        "    vec4 norm = normalize(frag_normal);\n" \
-                        "    vec4 ambient = vec4(0.7, 0.7788, 0.46, 1.0);\n" \
-                        "    vec4 light_color = vec4(0.7, 0.7, 0.7, 1.0);\n" \
-                        "    vec4 color = vec4(object_color.xyz, 1.0f);\n" \
-                        "\n" \
-                        "    vec4 light_location = vec4(0.0, 100.0, 0.0, 1.0);\n" \
-                        "    vec4 light_direction = normalize(light_location - frag_pos);\n" \
-                        "    float diff = max(dot(norm.xyz, light_direction.xyz), 0.0);\n" \
-                        "\n" \
-                        "    vec4 diffuse = diff * light_color;\n" \
-                        "\n" \
-                        "    outy = color + diffuse;\n" \
-                        "}"
-
-#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;
+}

src/batch.c

@@ -1,7 +0,0 @@
-#include "batch.h" 
-
-int start_batch(struct batch **ab) {
-    if (*ab != NULL) {
-        return -1;
-    }
-}

src/camera.c

@@ -1,72 +0,0 @@
-#include <string.h>
-#include <cglm/cam.h>
-#include <GL/glew.h>
-#include "camera.h"
-
-struct camera *create_camera(int type) {
-    if (type != CAMERA_PERSPECTIVE && 
-        type != CAMERA_ORTHOGRAPHIC) {
-        return NULL;
-    }
-
-    struct camera *c = malloc(sizeof(struct camera));
-    if (c == NULL) {
-        return NULL;
-    }
-
-    memset(c, 0, sizeof(struct camera));
-
-    c->type = type;
-    c->fov = 80.0f;
-    c->near_z = 0.01f; 
-    c->far_z = 1000.0f;
-    c->yaw = -90.0f;
-    c->pitch = 0.0f;
-    c->sensitivity = 0.02f;
-
-    if (c->type == CAMERA_ORTHOGRAPHIC) {
-        c->viewport_modifier = 0.5f;
-    }
-
-    c->pos[0] = 0.0f;
-    c->pos[1] = 0.0f;
-    c->pos[2] = 10.0f;
-
-    c->front[0] = 0.0f;
-    c->front[1] = 0.0f;
-    c->front[2] = -1.0f;
-    
-    c->up[0] = 0.0f;
-    c->up[1] = 1.0f;
-    c->up[2] = 0.0f;
-
-    return c;
-}
-
-int bake_camera(struct camera *c) {
-    glm_mat4_identity(c->view);
-    glm_vec3_add(c->pos, c->front, c->center);
-    glm_lookat(c->pos, c->center, c->up, c->view);
-
-    glm_mat4_identity(c->projection);
-
-    int screen_viewport[4]; 
-    glGetIntegerv(GL_VIEWPORT, screen_viewport);
-    if (c->type == CAMERA_PERSPECTIVE) {
-        glm_perspective(glm_rad(c->fov), 
-                (float) ((float)screen_viewport[2]/(float)screen_viewport[3]), 
-                c->near_z, c->far_z,
-                c->projection);
-    } else if (c->type == CAMERA_ORTHOGRAPHIC) {
-        float left = -screen_viewport[2]/2    * c->viewport_modifier; 
-        float right = screen_viewport[2]/2    * c->viewport_modifier;
-        float top = screen_viewport[3]/2      * c->viewport_modifier;
-        float bottom = -screen_viewport[3]/2  * c->viewport_modifier;
-        glm_ortho(left, right, bottom, top, c->near_z, c->far_z, c->projection);
-    } else {
-        return -1;
-    }
-
-    return 0;
-}
-

src/math.c

@@ -1,13 +0,0 @@
-#include "math.h"
-#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;
-}

src/object.c

@@ -1,122 +0,0 @@
-#include "object.h"
-
-#include "math.h"
-#include <math.h>
-#include <assimp/cimport.h>
-#include <assimp/scene.h>
-#include <assimp/postprocess.h>
-
-static int load_vertices(struct model *m, struct aiMesh *ms) {
-    m->vertices_num = ms->mNumVertices;
-    int len = m->vertices_num * sizeof(struct aiVector3D);
-    m->vertices = malloc(len);
-    if (m->vertices == NULL) {
-        return -1;
-    }
-
-    memset(m->vertices, 0, len);
-    memcpy(m->vertices, ms->mVertices, len);
-    return 0;
-}
-
-static int load_indices(struct model *m, struct aiMesh *ms) {
-    for (int face_index = 0; face_index < ms->mNumFaces; face_index++) {
-        struct aiFace *face = &(ms->mFaces[face_index]);
-        long start = m->indices_num;
-
-        m->indices_num += face->mNumIndices;
-        m->indices = (unsigned int *) realloc(m->indices, sizeof(unsigned int)*m->indices_num);
-        if (m->indices == NULL) {
-            return -1;
-        }
-
-        memcpy(&m->indices[start], face->mIndices, sizeof(unsigned int)*face->mNumIndices);
-    }
-    return 0;
-}
-
-static int load_normals(struct model *m, struct aiMesh *ms) {
-    m->normals_num = ms->mNumVertices;
-    int len = m->vertices_num * sizeof(struct aiVector3D); 
-    m->normals = malloc(len);
-    if (m->vertices == NULL) {
-        return -1;
-    }
-    memset(m->normals, 0, len);
-    memcpy(m->normals, ms->mNormals, len);
-    return 0;
-}
-
-struct model *load_model(const char *path) {
-    int ret = 0; 
-    struct model *nm = malloc(sizeof(struct model));
-    if (nm == NULL) {
-        return NULL;
-    }
-
-    memset(nm, 0, sizeof(struct model));
-
-    const struct aiScene *scene = aiImportFile(path, aiProcess_Triangulate);
-    if (scene == NULL) {
-        free(nm);
-        return NULL;
-    }
-
-    for (int mesh_index = 0; mesh_index < scene->mNumMeshes; mesh_index++) {
-        struct aiMesh *mesh = scene->mMeshes[mesh_index];
-
-        ret = load_vertices(nm, mesh);
-        if (ret < 0) {
-            free(nm);
-            aiReleaseImport(scene);
-            return NULL;
-        }
-
-        ret = load_indices(nm, mesh);
-        if (ret < 0) {
-            free(nm->vertices);
-            free(nm);
-            aiReleaseImport(scene);
-            return NULL;
-        }
-
-        ret = load_normals(nm, mesh);
-        if (ret < 0) {
-            free(nm->vertices);
-            free(nm->indices);
-            free(nm);
-            aiReleaseImport(scene);
-            return NULL;
-        }
-    }
-
-    return nm;
-}
-
-struct object *create_object(struct object **o, struct model *model) {
-    struct object *no = malloc(sizeof(struct object));
-    if (no == NULL) {
-        return NULL;
-    }
-    memset(no, 0, sizeof(struct object));
-
-    no->scale = 1.0f;
-    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;
-}

src/rendlib.c

@@ -1,319 +0,0 @@
-#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 "rendlib.h"
-#include "camera.h"
-#include "object.h"
-#include "shaders.h"
-
-// global variables 
-int window_width = 960;
-int window_height = 540;
-char *window_title = "rendlib window";
-
-struct camera *ac;
-struct batch *ab;
-
-void (*keyboard_probe)(int key, int scancode, int action, int mods);
-void (*mouse_probe)(double x, double y);
-void (*update_probe)(void);
-
-float top_movement_speed = 0.4f;
-vec3 speed = { 0.0f, 0.0f, 0.0f };
-GLint screen_viewport[4];
-
-struct object *objects;
-
-unsigned int shader_program;
-unsigned int vertex_shader;
-unsigned int fragment_shader;
-
-extern char *default_vshader;
-extern char *default_fshader;
-extern int default_vshader_len;
-extern int default_fshader_len;
-
-void update_screen_viewport(int x, int y, int width, int height) {
-    GLFWwindow *w = glfwGetCurrentContext();
-    glfwSetCursorPos(w, (width/2), (height/2));
-    glViewport(x, y, width, height);
-    glGetIntegerv(GL_VIEWPORT, screen_viewport);
-}
-
-int load_shader(char **s, int *n, unsigned int shader) {
-    glShaderSource(shader, 1, (const char **) s, n);
-    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;
-    }
-
-    return 0;
-}
-
-int fload_shader(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);
-    int ret = load_shader(&fc, &rb, shader); 
-    free(fc);
-    return ret;
-}
-
-int load_default_shaders(void) {
-    int ret = 0;
-    glDeleteProgram(shader_program);
-    shader_program = glCreateProgram();
-
-    vertex_shader = glCreateShader(GL_VERTEX_SHADER);
-    fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
-
-    int vshader_len = strlen(DEFAULT_VSHADER);
-    char *vshader = strndup(DEFAULT_VSHADER, vshader_len);
-    if (vshader == NULL) {
-        return -1;
-    }
-
-    ret = load_shader(&vshader, &vshader_len, vertex_shader);
-    if (ret < 0) {
-        return -1;
-    }
-
-    free(vshader);
-
-    int fshader_len = strlen(DEFAULT_FSHADER);
-    char *fshader = strndup(DEFAULT_FSHADER, fshader_len);
-    if (fshader == NULL) {
-        return -1;
-    }
-
-    ret = load_shader(&fshader, &fshader_len, fragment_shader);
-    if (ret < 0) {
-        return -1;
-    }
-
-    free(fshader);
-
-    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) {
-}
-
-void window_size(GLFWwindow *w, int width, int height) {
-    update_screen_viewport(0, 0, width, height);
-}
-
-void display(void) {
-    handle_input();
-    GLFWwindow *w = glfwGetCurrentContext();
-
-    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);
-    glUseProgram(shader_program);
-
-    int ret = bake_camera(ac);
-    if (ret < 0) {
-        fprintf(stderr, "--error: failed baking camera\n");
-        return;
-    }
-
-    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 *) ac->view);
-    glUniformMatrix4fv(projection_uniform, 1, GL_FALSE, (float *) ac->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;
-        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);
-    }
-
-    glfwSwapBuffers(w);
-    glfwPollEvents();
-}
-
-void rendlib_bake_graphics(void) {
-    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);
-        glGenBuffers(1, &obj->vbo);
-        glGenBuffers(1, &obj->ebo);
-        glGenBuffers(1, &obj->nbo);
-
-        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 (keyboard_probe == NULL) {
-        return; 
-    }
-
-    (keyboard_probe)(key, scancode, action, mods);
-}
-
-void mouse_motion(GLFWwindow *window, double x, double y) {
-    if (mouse_probe == NULL) {
-        return;
-    }
-
-    (mouse_probe)(x, y);
-}
-
-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);
-    glfwSetInputMode(w, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
-
-    ret = glewInit();
-    if (ret != GLEW_OK) {
-        return err_glew_init;
-    }
-
-    ret = load_default_shaders();
-    if (ret < 0) {
-        return err_shaders_init;
-    }
-
-    return 0;
-}
-
-int setup_default_camera(void) {
-    ac = create_camera(CAMERA_PERSPECTIVE);
-    if (ac == NULL) {
-        return -1;
-    }
-    return 0;
-}
-
-int rendlib_render(void) {
-    if (ac == NULL) {
-        if (setup_default_camera() < 0) {
-            return -1;
-        }
-    }
-    rendlib_bake_graphics();
-    for (;;) {
-        if (update_probe != NULL) {
-            (update_probe)();
-        }
-
-        display();
-    }
-    return 0;
-}

tests/test-01.c

@@ -1,188 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <GLFW/glfw3.h>
-#include "rendlib.h"
-#include "camera.h"
-#include "object.h"
-
-#define INPUT_ESCAPE    0b00000001
-#define INPUT_RELOAD    0b00000010
-#define INPUT_LEFT      0b00000100
-#define INPUT_RIGHT     0b00001000
-#define INPUT_DOWN      0b00010000
-#define INPUT_UP        0b00100000
-
-#define MOVEMENT_SPEED  0.2f
-
-char input = 0;
-
-void keyboardp(int key, int scancode, int action, int mods) {
-    if (action == GLFW_PRESS) {
-        switch (key) {
-            case GLFW_KEY_Q: 
-            case GLFW_KEY_ESCAPE: 
-                input |= INPUT_ESCAPE; 
-                break;
-            case GLFW_KEY_R: 
-                input |= INPUT_RELOAD;
-                break;
-            case GLFW_KEY_A:
-            case GLFW_KEY_LEFT:
-                input |= INPUT_LEFT;
-                break;
-            case GLFW_KEY_D:
-            case GLFW_KEY_RIGHT:
-                input |= INPUT_RIGHT;
-                break;
-            case GLFW_KEY_S:
-            case GLFW_KEY_DOWN:
-                input |= INPUT_DOWN;
-                break;
-            case GLFW_KEY_W:
-            case GLFW_KEY_UP:
-                input |= INPUT_UP;
-                break;
-        }
-    } else if (action == GLFW_RELEASE) {
-        switch (key) {
-            case GLFW_KEY_A:
-            case GLFW_KEY_LEFT:
-                input &= ~INPUT_LEFT;
-                break;
-            case GLFW_KEY_D:
-            case GLFW_KEY_RIGHT:
-                input &= ~INPUT_RIGHT;
-                break;
-            case GLFW_KEY_S:
-            case GLFW_KEY_DOWN:
-                input &= ~INPUT_DOWN;
-                break;
-            case GLFW_KEY_W:
-            case GLFW_KEY_UP:
-                input &= ~INPUT_UP;
-                break;
-        }
-    }
-}
-
-int warped_pointer = 0;
-int first_pointer = 1;
-void mousep(double x, double y) {
-    GLint screen_viewport[4];
-    if (warped_pointer == 1) {
-        warped_pointer = 0;
-        return;
-    }
-
-    warped_pointer = 1;
-    glGetIntegerv(GL_VIEWPORT, screen_viewport);
-    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)) * ac->sensitivity;
-    float offset_y = (float) (y - (screen_viewport[3]/2)) * ac->sensitivity;
-
-    ac->yaw += offset_x;
-    ac->pitch -= offset_y;
-
-    if (ac->pitch < -89.9f) {
-        ac->pitch = -89.9f;
-    }
-    if (ac->pitch > 89.9f) {
-        ac->pitch = 89.9f;
-    }
-
-    vec3 view_direction = { cos(glm_rad(ac->yaw)) * cos(glm_rad(ac->pitch)),
-	sin(glm_rad(ac->pitch)),
-	sin(glm_rad(ac->yaw)) * cos(glm_rad(ac->pitch))
-    };
-    glm_normalize_to(view_direction, ac->front);
-}
-
-void periodic_input(void) {
-    int ret = 0;
-    if (input & INPUT_ESCAPE) {
-        exit(EXIT_SUCCESS);
-        input &= ~INPUT_ESCAPE;
-    }
-    
-    if (input & INPUT_LEFT) {
-        vec3 side_scalar = {MOVEMENT_SPEED, MOVEMENT_SPEED,  MOVEMENT_SPEED};
-        vec3 camera_side;
-        glm_cross(ac->front, ac->up, camera_side);
-        glm_normalize(camera_side);
-        glm_vec3_mul(camera_side, side_scalar, camera_side);
-        glm_vec3_sub(ac->pos, camera_side, ac->pos);
-    }
-
-    if (input & INPUT_RIGHT) {
-        vec3 side_scalar = {MOVEMENT_SPEED, MOVEMENT_SPEED,  MOVEMENT_SPEED};
-        vec3 camera_side;
-        glm_cross(ac->front, ac->up, camera_side);
-        glm_normalize(camera_side);
-        glm_vec3_mul(camera_side, side_scalar, camera_side);
-        glm_vec3_add(ac->pos, camera_side, ac->pos);
-    }
-
-    if (input & INPUT_DOWN) {
-        vec3 front_scalar = {MOVEMENT_SPEED, MOVEMENT_SPEED,  MOVEMENT_SPEED};
-        glm_vec3_mul(front_scalar, ac->front, front_scalar);
-        glm_vec3_sub(ac->pos, front_scalar, ac->pos);
-    }
-
-    if (input & INPUT_UP) {
-        vec3 front_scalar = {MOVEMENT_SPEED, MOVEMENT_SPEED,  MOVEMENT_SPEED};
-        glm_vec3_mul(front_scalar, ac->front, front_scalar);
-        glm_vec3_add(ac->pos, front_scalar, ac->pos);
-    }
-
-}
-
-void updatep(void) {
-    periodic_input();
-}
-
-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;
-    }
-
-    keyboard_probe = &keyboardp;
-    mouse_probe = &mousep;
-    update_probe = &updatep;
-
-    struct model *m = load_model("assets-01/sphere.obj");
-    if (m == NULL) {
-        fprintf(stderr, "--error: loading model\n");
-        return EXIT_FAILURE;
-    }
-
-    struct object *o = create_object(&objects, m);
-    if (o == NULL) {
-        fprintf(stderr, "--error: creating object\n");
-        return EXIT_FAILURE;
-    }
-
-    ac = create_camera(CAMERA_PERSPECTIVE);
-    if (ac == NULL) {
-        fprintf(stderr, "--error: creating camera\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;
-}