feat: minor refactorings

.gitignore

@@ -1,3 +1,6 @@
 build/
 .vscode/
-.vs/
+.vs/
+.cache/
+.fleet/
+compile_commands.json

src/CMakeLists.txt

@@ -2,12 +2,14 @@ cmake_minimum_required(VERSION 3.5)
 
 
 set(PROJECT_NAME gl-windows)
-
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED TRUE)
+set(CMAKE_C_FLAGS "-Wall -Wextra -Werror")
 project(${PROJECT_NAME})
 include_directories(${INCLUDE_DIRS})
 
 add_executable(${PROJECT_NAME} main.c fio.c glad.c renderer.c )
 
-find_library(GLFW_LIBRARY NAMES glfw3 HINTS "c:/temp/usr/lib")
+find_library(GLFW_LIBRARY NAMES glfw3 HINTS "c:/usr/lib")
 
 target_link_libraries(${PROJECT_NAME} ${GLFW_LIBRARY})

src/fio.c

@@ -1,41 +1,38 @@
 #include "fio.h"
 
-#include <inttypes.h>
-#include <sys/stat.h>
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include <assert.h>
+#include <inttypes.h>
 #include <io.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+void read_shader_source(GLchar *source, const char *file_path) {
+
+  GLchar buf[1024] = {0};
+  errno_t err = 0;
+  struct _stat st;
+  int result = 0;
+
+  if (_access(file_path, 4) == -1) {
+    fprintf(stderr, "file not found %s\n", file_path);
+    return;
+  }
+  FILE *f = NULL;
+
+  err = fopen_s(&f, file_path, "r");
+  if (err != 0) {
+    fprintf(stderr, "could not open file %s\n", file_path);
+    return;
+  }
+
+  result = _stat(file_path, &st);
+  assert(result == 0 && "could not stat file");
+  assert(st.st_size <= 1024 && "shader source too long");
+
+  fread(buf, st.st_size, 1, f);
+  assert(buf[0] != 0);
 
-void read_shader_source(GLchar* source, const char* file_path) {
-    
-    GLchar buf[1024] = { 0 };
-    errno_t err = 0;
-    struct _stat st;
-    int result = 0;
-    
-
-    if (_access(file_path, 4) == -1) {
-        fprintf(stderr, "file not found %s\n", file_path);
-        return;
-    }
-    FILE* f = NULL;
-
-
-    err = fopen_s(&f, file_path, "r");
-    if (err != 0) {
-        fprintf(stderr, "could not open file %s\n", file_path);
-        return;
-    }
-    
-   
-    result = _stat(file_path, &st);
-    assert(result == 0 && "could not stat file");
-    assert(st.st_size <= 1024 && "shader source too long");
-    
-    fread(buf, st.st_size, 1, f);
-    assert(buf[0] != 0);
-
-    strcpy_s(source, 1024, buf);
+  strcpy_s(source, 1024, buf);
 }

src/main.c

@@ -1,12 +1,10 @@
 #include "renderer.h"
 
-#include <stdio.h>
 #include <assert.h>
+#include <stdio.h>
 
-#include <glad/glad.h>
 #include <GLFW/glfw3.h>
-
-
+#include <glad/glad.h>
 
 #define WINDOW_WIDTH 1200
 #define WINDOW_HEIGHT 800
@@ -14,67 +12,60 @@
 #define MAX_VERTEX_BUFFER 512 * 1024
 #define MAX_ELEMENT_BUFFER 128 * 1024
 
-
-static void error_callback(int e, const char* d) { 
-	fprintf(stderr, "ERROR: %d: %s\n", e, d); 
+static void error_callback(int e, const char *d) {
+  fprintf(stderr, "ERROR: %d: %s\n", e, d);
 }
 
-void resize_window_callback(GLFWwindow* window, int width, int height) {
-	glViewport(0, 0, width, height);
+void resize_window_callback(GLFWwindow *window, int width, int height) {
+  (void)window;
+  glViewport(0, 0, width, height);
 }
 
-
-void key_callback(GLFWwindow *window, int key, int scancode, int action, int mods)
-{
-	if(key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE) {
-		glfwSetWindowShouldClose(window, GLFW_TRUE);
-	}
+void key_callback(GLFWwindow *window, int key, int scancode, int action,
+                  int mods) {
+  (void)scancode;
+  (void)mods;
+  if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE) {
+    glfwSetWindowShouldClose(window, GLFW_TRUE);
+  }
 }
 
 int main() {
 
-	Renderer renderer = {0};
-	RENDERER_ERROR err = renderer_init(&renderer, WINDOW_WIDTH, WINDOW_HEIGHT);
-	if (err != RENDERER_ERROR_OK) {
-		ERROR_AND_QUIT(err, "could not initialize glfw");
-	}
-	
-	glfwSetErrorCallback(error_callback);
-	glfwSetKeyCallback(renderer.window, key_callback);
-
-	AABB test_aabb = {
-		.position = {renderer.width * 0.5, renderer.height * 0.5},
-		.half_size = {50, 50},
-	};
+  Renderer renderer = {0};
+  RENDERER_ERROR err = renderer_init(&renderer, WINDOW_WIDTH, WINDOW_HEIGHT);
+  if (err != RENDERER_ERROR_OK) {
+    ERROR_AND_QUIT(err, "could not initialize glfw");
+  }
 
+  glfwSetErrorCallback(error_callback);
+  glfwSetKeyCallback(renderer.window, key_callback);
 
-	while (!glfwWindowShouldClose(renderer.window)) {
-		glfwPollEvents();
-		glfwGetWindowSize(renderer.window, &renderer.width, &renderer.height);
-		glViewport(0, 0, renderer.width, renderer.height);
-		glClear(GL_COLOR_BUFFER_BIT);
-		glClearColor(0.8f, 0.8f, 0.8f, 1.0f);
+  AABB test_aabb = {
+      .position = {renderer.width * 0.5, renderer.height * 0.5},
+      .half_size = {50, 50},
+  };
 
+  while (!glfwWindowShouldClose(renderer.window)) {
+    glfwPollEvents();
+    glfwGetWindowSize(renderer.window, &renderer.width, &renderer.height);
+    glViewport(0, 0, renderer.width, renderer.height);
+    glClear(GL_COLOR_BUFFER_BIT);
+    glClearColor(0.8f, 0.8f, 0.8f, 1.0f);
 
-		render_line(&renderer,
-			(vec2) {600.0f, 600.0f},
-			(vec2) {300.0f, 300.0f},
-			(vec4) {1.0f, 0.0f, 0.0f, 1.0f}
-		);
+    render_line(&renderer, (vec2){600.0f, 600.0f}, (vec2){300.0f, 300.0f},
+                (vec4){1.0f, 0.0f, 0.0f, 1.0f});
 
-		render_quad(&renderer,
-			(vec2){	renderer.width * 0.5f, renderer.height * 0.5f	},
-			(vec2){	50.0f, 50.0f },
-			(vec4) { 0.4f, 1.0f, 0.8f, 1.0f });
+    render_quad(&renderer,
+                (vec2){renderer.width * 0.5f, renderer.height * 0.5f},
+                (vec2){50.0f, 50.0f}, (vec4){0.4f, 1.0f, 0.8f, 1.0f});
 
-		render_aabb(&renderer, (float*)&test_aabb, (vec4){1, 1, 1, 0.5});
+    render_aabb(&renderer, (float *)&test_aabb, (vec4){1, 1, 1, 0.5});
 
+    glfwSwapBuffers(renderer.window);
+  }
 
-		glfwSwapBuffers(renderer.window);
-	}
+  renderer_destroy(&renderer);
 
-	renderer_destroy(&renderer);
-
-	return 0;
+  return 0;
 }
-

src/renderer.c

@@ -2,370 +2,277 @@
 #include "renderer.h"
 #include "fio.h"
 
-#include <stdio.h>
 #include <stdbool.h>
+#include <stdio.h>
 #include <stdlib.h>
 
-#include <linmath.h>
-#include <glad/glad.h>
 #include <GLFW/glfw3.h>
+#include <glad/glad.h>
+#include <linmath.h>
 
+static const char *shader_type_as_cstr(GLuint shader) {
+  switch (shader) {
+  case GL_VERTEX_SHADER:
+    return "GL_VERTEX_SHADER";
+  case GL_FRAGMENT_SHADER:
+    return "GL_FRAGMENT_SHADER";
+  default:
+    return "(Unknown)";
+  }
+}
 
+static bool compile_shader_source(const GLchar *source, GLenum shader_type,
+                                  GLuint *shader) {
+  *shader = glCreateShader(shader_type);
+  glShaderSource(*shader, 1, &source, NULL);
+  glCompileShader(*shader);
+
+  GLint compiled = 0;
+  glGetShaderiv(*shader, GL_COMPILE_STATUS, &compiled);
+
+  if (!compiled) {
+    GLchar message[1024];
+    GLsizei message_size = 0;
+    glGetShaderInfoLog(*shader, sizeof(message), &message_size, message);
+    fprintf(stderr, "ERROR: could not compile %s\n",
+            shader_type_as_cstr(shader_type));
+    fprintf(stderr, "%.*s\n", message_size, message);
+    return false;
+  }
+
+  return true;
+}
 
-void renderer_init_nk(Renderer* renderer) {
-#if 0
-    renderer->ctx = nk_glfw3_init(renderer->window, NK_GLFW3_INSTALL_CALLBACKS);
-
-    {
-        struct nk_font_atlas* atlas;
-        nk_glfw3_font_stash_begin(&atlas);
-        struct nk_font* roboto = nk_font_atlas_add_from_file(atlas, "fonts/Roboto.ttf", 14, 0);
-        nk_glfw3_font_stash_end();
-        nk_style_set_font(renderer->ctx, &roboto->handle);
-    }
-
-    GLsizei vs = sizeof(struct nk_glfw_vertex);
-    size_t vp = NK_OFFSETOF(struct nk_glfw_vertex, position);
-    size_t vt = NK_OFFSETOF(struct nk_glfw_vertex, uv);
-    size_t vc = NK_OFFSETOF(struct nk_glfw_vertex, col);
-
-    renderer->programs[NUKLEAR_PROGRAM] = glCreateProgram();
-
-    GLchar frag_source[1024] = { 0 };
-    GLchar vert_source[1024] = { 0 };
-    read_shader_source(frag_source, "shaders/nk.frag");
-    read_shader_source(vert_source, "shaders/nk.vert");
-
-    GLuint shaders[2];
-
-    compile_shader_source(frag_source, GL_FRAGMENT_SHADER, &shaders[0]);
-    compile_shader_source(vert_source, GL_VERTEX_SHADER, &shaders[1]);
+static void attach_shaders_to_program(GLuint *shaders, size_t shaders_count,
+                                      GLuint program) {
+  for (size_t i = 0; i < shaders_count; ++i) {
+    glAttachShader(program, shaders[i]);
+  }
+}
 
-    attach_shaders_to_program(shaders, 2, renderer->programs[NUKLEAR_PROGRAM]);
-    link_program(renderer->programs[NUKLEAR_PROGRAM], __FILE__, __LINE__);
+static bool link_program(GLuint program, const char *file_path, size_t line) {
+  glLinkProgram(program);
 
-    glEnableVertexAttribArray((GLuint)renderer->attrib_pos);
-    glEnableVertexAttribArray((GLuint)renderer->attrib_uv);
-    glEnableVertexAttribArray((GLuint)renderer->attrib_col);
+  GLint linked = 0;
+  glGetProgramiv(program, GL_LINK_STATUS, &linked);
+  if (!linked) {
+    GLsizei message_size = 0;
+    GLchar message[1024];
 
-    glVertexAttribPointer((GLuint)renderer->attrib_pos, 2, GL_FLOAT, GL_FALSE, vs, (void*)vp);
-    glVertexAttribPointer((GLuint)renderer->attrib_uv, 2, GL_FLOAT, GL_FALSE, vs, (void*)vt);
-    glVertexAttribPointer((GLuint)renderer->attrib_col, 4, GL_UNSIGNED_BYTE, GL_TRUE, vs, (void*)vc);
+    glGetProgramInfoLog(program, sizeof(message), &message_size, message);
+    fprintf(stderr, "%s:%zu: Program Linking: %.*s\n", file_path, line,
+            message_size, message);
+  }
 
-    nk_buffer_init_default(&renderer->cmds);
-#endif
+  return linked;
 }
 
-
-
-
 RENDERER_ERROR renderer_init(Renderer *renderer, int width, int height) {
 
-    
-    renderer->width = width;
-    renderer->height = height;
-
-    RENDERER_ERROR err = renderer_init_glfw(renderer, width, height);
-    if (err != RENDERER_ERROR_OK) {
-        ERROR_AND_QUIT(err, "could not intialize OpenGL");
-    }
-    
-    
-    
-    
-    renderer_init_quad(renderer);
-    renderer_init_line(renderer);
-    renderer_init_textures(renderer);
-    renderer_init_shaders(renderer);
-    
-	
-    return RENDERER_ERROR_OK;
+  renderer->width = width;
+  renderer->height = height;
 
-}
+  RENDERER_ERROR err = renderer_init_glfw(renderer, width, height);
+  if (err != RENDERER_ERROR_OK) {
+    ERROR_AND_QUIT(err, "could not intialize OpenGL");
+  }
 
-RENDERER_ERROR renderer_init_glfw(Renderer* renderer, int width, int height)
-{
-    if (!glfwInit()) {
-        fprintf(stderr, "[GFLW] failed to init!\n");
-        return RENDERER_ERROR_GLFW;
-    }
+  renderer_init_quad(renderer);
+  renderer_init_line(renderer);
+  renderer_init_textures(renderer);
+  renderer_init_shaders(renderer);
 
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
-    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+  return RENDERER_ERROR_OK;
+}
 
-    renderer->window = glfwCreateWindow(width, height, "Demo", NULL, NULL);
-    glfwMakeContextCurrent(renderer->window);
+RENDERER_ERROR renderer_init_glfw(Renderer *renderer, int width, int height) {
+  if (!glfwInit()) {
+    fprintf(stderr, "[GFLW] failed to init!\n");
+    return RENDERER_ERROR_GLFW;
+  }
 
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
 
-    /* OpenGL */
+  renderer->window = glfwCreateWindow(width, height, "Demo", NULL, NULL);
+  glfwMakeContextCurrent(renderer->window);
 
-    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
-    {
-        fprintf(stderr, "Failed to initialize GLAD (OpenGL)\n");
-        return RENDERER_ERROR_GLAD;
-    }
-    glViewport(0, 0, renderer->width, renderer->width);
-    glfwGetWindowSize(renderer->window, &width, &height);
+  /* OpenGL */
 
-    return RENDERER_ERROR_OK;
+  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
+    fprintf(stderr, "Failed to initialize GLAD (OpenGL)\n");
+    return RENDERER_ERROR_GLAD;
+  }
+  glViewport(0, 0, renderer->width, renderer->width);
+  glfwGetWindowSize(renderer->window, &width, &height);
 
+  return RENDERER_ERROR_OK;
 }
 
 void renderer_init_textures(Renderer *renderer) {
-    glGenTextures(1, &renderer->texture_color);
-    glBindTexture(GL_TEXTURE_2D, renderer->texture_color);
-    short solid_white[4] = { 255, 255, 255, 255 };
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, solid_white);
-    glBindTexture(GL_TEXTURE_2D, 0);
-
+  glGenTextures(1, &renderer->texture_color);
+  glBindTexture(GL_TEXTURE_2D, renderer->texture_color);
+  short solid_white[4] = {255, 255, 255, 255};
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+               solid_white);
+  glBindTexture(GL_TEXTURE_2D, 0);
 }
 
 void renderer_init_shaders(Renderer *renderer) {
-    
-    GLuint shader[2] = { 0 };
-    char frag_shader[1024];
-    char vert_shader[1024];
 
-    renderer->programs[DEFAULT_PROGRAM] = glCreateProgram();
+  GLuint shader[2] = {0};
+  char frag_shader[1024];
+  char vert_shader[1024];
 
-    read_shader_source(frag_shader, "simple.frag");
-    read_shader_source(vert_shader, "simple.vert");
+  renderer->programs[DEFAULT_PROGRAM] = glCreateProgram();
 
-    compile_shader_source(frag_shader, GL_FRAGMENT_SHADER, &shader[0]);
-    compile_shader_source(vert_shader, GL_VERTEX_SHADER, &shader[1]);
-    attach_shaders_to_program(shader, 2, renderer->programs[DEFAULT_PROGRAM]);
+  read_shader_source(frag_shader, "simple.frag");
+  read_shader_source(vert_shader, "simple.vert");
 
-    link_program(renderer->programs[DEFAULT_PROGRAM], __FILE__, __LINE__);
+  compile_shader_source(frag_shader, GL_FRAGMENT_SHADER, &shader[0]);
+  compile_shader_source(vert_shader, GL_VERTEX_SHADER, &shader[1]);
+  attach_shaders_to_program(shader, 2, renderer->programs[DEFAULT_PROGRAM]);
 
-    mat4x4_ortho(renderer->projection, 0, (float)renderer->width, 0, (float)renderer->height, -2.0f, 2.0f);
-    glUseProgram(renderer->programs[DEFAULT_PROGRAM]);
+  link_program(renderer->programs[DEFAULT_PROGRAM], __FILE__, __LINE__);
 
-    glUniformMatrix4fv(
-        glGetUniformLocation(renderer->programs[DEFAULT_PROGRAM], "projection"),
-        1,
-        GL_FALSE,
-        &renderer->projection[0][0]
-    );
+  mat4x4_ortho(renderer->projection, 0, (float)renderer->width, 0,
+               (float)renderer->height, -2.0f, 2.0f);
+  glUseProgram(renderer->programs[DEFAULT_PROGRAM]);
 
-    glDeleteShader(shader[0]);
-    glDeleteShader(shader[1]);
+  glUniformMatrix4fv(
+      glGetUniformLocation(renderer->programs[DEFAULT_PROGRAM], "projection"),
+      1, GL_FALSE, &renderer->projection[0][0]);
 
+  glDeleteShader(shader[0]);
+  glDeleteShader(shader[1]);
 }
 
+void renderer_destroy(Renderer *renderer) {
 
+  glDeleteTextures(1, &renderer->texture_color);
+  glDeleteBuffers(1, &renderer->quad.vbo);
+  glDeleteBuffers(1, &renderer->quad.ebo);
+  glDeleteBuffers(1, &renderer->line.vbo);
+  glDeleteProgram(renderer->programs[0]);
 
-void renderer_destroy(Renderer* renderer) {
-
-    glDeleteTextures(1, &renderer->texture_color);
-    glDeleteBuffers(1, &renderer->quad.vbo);
-    glDeleteBuffers(1, &renderer->quad.ebo);
-    glDeleteBuffers(1, &renderer->line.vbo);
-    glDeleteProgram(renderer->programs[0]);
-
-    glfwTerminate();
-    //nk_buffer_free(&renderer->cmds);
-}
-
-
-static const char* shader_type_as_cstr(GLuint shader)
-{
-    switch (shader) {
-    case GL_VERTEX_SHADER:
-        return "GL_VERTEX_SHADER";
-    case GL_FRAGMENT_SHADER:
-        return "GL_FRAGMENT_SHADER";
-    default:
-        return "(Unknown)";
-    }
+  glfwTerminate();
+  // nk_buffer_free(&renderer->cmds);
 }
 
-static bool compile_shader_source(const GLchar* source, GLenum shader_type, GLuint* shader)
-{
-    *shader = glCreateShader(shader_type);
-    glShaderSource(*shader, 1, &source, NULL);
-    glCompileShader(*shader);
-
-    GLint compiled = 0;
-    glGetShaderiv(*shader, GL_COMPILE_STATUS, &compiled);
-
-    if (!compiled) {
-        GLchar message[1024];
-        GLsizei message_size = 0;
-        glGetShaderInfoLog(*shader, sizeof(message), &message_size, message);
-        fprintf(stderr, "ERROR: could not compile %s\n", shader_type_as_cstr(shader_type));
-        fprintf(stderr, "%.*s\n", message_size, message);
-        return false;
-    }
-
-    return true;
-}
+void renderer_init_quad(Renderer *renderer) {
 
-static void attach_shaders_to_program(GLuint* shaders, size_t shaders_count, GLuint program)
-{
-    for (size_t i = 0; i < shaders_count; ++i) {
-        glAttachShader(program, shaders[i]);
-    }
-}
+  // x y z u v
+  float vertices[] = {0.5,  0.5,  0, 0, 0, 0.5,  -0.5, 0, 0, 1,
+                      -0.5, -0.5, 0, 1, 1, -0.5, 0.5,  0, 1, 0};
+  GLuint indices[] = {0, 1, 3, 1, 2, 3};
 
-static bool link_program(GLuint program, const char* file_path, size_t line)
-{
-    glLinkProgram(program);
+  glGenVertexArrays(1, &renderer->quad.vao);
+  glGenBuffers(1, &renderer->quad.vbo);
+  glGenBuffers(1, &renderer->quad.ebo);
 
-    GLint linked = 0;
-    glGetProgramiv(program, GL_LINK_STATUS, &linked);
-    if (!linked) {
-        GLsizei message_size = 0;
-        GLchar message[1024];
+  glBindVertexArray(renderer->quad.vao);
 
-        glGetProgramInfoLog(program, sizeof(message), &message_size, message);
-        fprintf(stderr, "%s:%zu: Program Linking: %.*s\n", file_path, line, message_size, message);
-    }
+  glBindBuffer(GL_ARRAY_BUFFER, renderer->quad.vbo);
+  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
 
-    return linked;
-}
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, renderer->quad.ebo);
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices,
+               GL_STATIC_DRAW);
 
+  // x, y, z
+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), NULL);
+  glEnableVertexAttribArray(0);
 
-static void renderer_upload_atlas(Renderer* renderer, const void* image, int width, int height) {
-#if 0
-    glGenTextures(1, &renderer->font_tex);
-    glBindTexture(GL_TEXTURE_2D, &renderer->font_tex);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)width, (GLsizei)height, 0,
-        GL_RGBA, GL_UNSIGNED_BYTE, image);
+  // u, v
+  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float),
+                        (void *)(3 * sizeof(float)));
+  glEnableVertexAttribArray(1);
 
-#endif
+  glBindVertexArray(0);
 }
 
+void render_quad(Renderer *renderer, vec2 pos, vec2 size, vec4 color) {
 
-void renderer_init_quad(Renderer *renderer) {
-
-    // x y z u v
-    float vertices[] = {
-         0.5,  0.5, 0, 0, 0,
-         0.5, -0.5, 0, 0, 1,
-        -0.5, -0.5, 0, 1, 1,
-        -0.5,  0.5, 0, 1, 0
-    };
-    GLuint indices[] = {
-        0, 1, 3,
-        1, 2, 3
-    };
-
-    glGenVertexArrays(1, &renderer->quad.vao);
-    glGenBuffers(1, &renderer->quad.vbo);
-    glGenBuffers(1, &renderer->quad.ebo);
-
-    glBindVertexArray(renderer->quad.vao);
-
-    glBindBuffer(GL_ARRAY_BUFFER, renderer->quad.vbo);
-    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+  GLuint default_shader = renderer->programs[DEFAULT_PROGRAM];
+  glUseProgram(default_shader);
+  mat4x4 model;
+  mat4x4_identity(model);
 
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, renderer->quad.ebo);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
+  mat4x4_translate(model, pos[0], pos[1], 0);
+  mat4x4_scale_aniso(model, model, size[0], size[1], 1);
 
-    // x, y, z
-    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), NULL);
-    glEnableVertexAttribArray(0);
+  glUniformMatrix4fv(glGetUniformLocation(default_shader, "model"), 1, GL_FALSE,
+                     &model[0][0]);
+  glUniform4fv(glGetUniformLocation(default_shader, "color"), 1, color);
 
+  glBindVertexArray(renderer->quad.vao);
+  glBindTexture(GL_TEXTURE_2D, renderer->texture_color);
+  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, NULL);
 
-    // u, v
-    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
-    glEnableVertexAttribArray(1);
-
-    glBindVertexArray(0);
+  glBindVertexArray(0);
 }
 
-void render_quad(Renderer* renderer, vec2 pos, vec2 size, vec4 color)
-{
-
-    GLuint default_shader = renderer->programs[DEFAULT_PROGRAM];
-    glUseProgram(default_shader);
-    mat4x4 model;
-    mat4x4_identity(model);
-
-    mat4x4_translate(model, pos[0], pos[1], 0);
-    mat4x4_scale_aniso(model, model, size[0], size[1], 1);
+void renderer_init_line(Renderer *renderer) {
 
-    glUniformMatrix4fv(glGetUniformLocation(default_shader, "model"), 1, GL_FALSE, &model[0][0]);
-    glUniform4fv(glGetUniformLocation(default_shader, "color"), 1, color);
+  glGenVertexArrays(1, &renderer->line.vao);
+  glBindVertexArray(renderer->line.vao);
 
-    glBindVertexArray(renderer->quad.vao);
-    glBindTexture(GL_TEXTURE_2D, renderer->texture_color);
-    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, NULL);
+  glGenBuffers(1, &renderer->line.vbo);
+  glBindBuffer(GL_ARRAY_BUFFER, renderer->line.vbo);
+  glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(float), NULL, GL_DYNAMIC_DRAW);
 
-    glBindVertexArray(0);
+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), NULL);
+  glEnableVertexAttribArray(0);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
 
+  glBindVertexArray(0);
 }
 
+void render_line(Renderer *renderer, vec2 start, vec2 end, vec4 color) {
+  glEnable(GL_LINE_SMOOTH);
+  glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
+  GLuint default_shader = renderer->programs[DEFAULT_PROGRAM];
+  glUseProgram(default_shader);
+  glLineWidth(3);
 
-void renderer_init_line(Renderer *renderer)
-{
+  float x = end[0] - start[0];
+  float y = end[1] - start[1];
+  float line[6] = {0, 0, 0, x, y, 0};
 
-	glGenVertexArrays(1, &renderer->line.vao);
-	glBindVertexArray(renderer->line.vao);
+  mat4x4 model;
+  mat4x4_translate(model, start[0], start[1], 0);
 
-	glGenBuffers(1, &renderer->line.vbo);
-	glBindBuffer(GL_ARRAY_BUFFER, renderer->line.vbo);
-	glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(float), NULL, GL_DYNAMIC_DRAW);
+  glUniformMatrix4fv(glGetUniformLocation(default_shader, "model"), 1, GL_FALSE,
+                     &model[0][0]);
+  glUniform4fv(glGetUniformLocation(default_shader, "color"), 1, color);
 
-	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), NULL);
-	glEnableVertexAttribArray(0);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glBindTexture(GL_TEXTURE_2D, renderer->texture_color);
+  glBindVertexArray(renderer->line.vao);
 
-	glBindVertexArray(0);
+  glBindBuffer(GL_ARRAY_BUFFER, renderer->line.vbo);
+  glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(line), line);
+  glDrawArrays(GL_LINES, 0, 2);
 
-
-}
-void render_line(Renderer* renderer, vec2 start, vec2 end, vec4 color)
-{
-    glEnable(GL_LINE_SMOOTH);
-    glHint(GL_LINE_SMOOTH_HINT,  GL_NICEST);
-    GLuint default_shader = renderer->programs[DEFAULT_PROGRAM];
-    glUseProgram(default_shader);
-    glLineWidth(3);
-  
-
-    float x = end[0] - start[0];
-    float y = end[1] - start[1];
-    float line[6] = {0, 0, 0, x, y, 0};
-    
-    mat4x4 model;
-    mat4x4_translate(model, start[0], start[1], 0);
-
-
-    glUniformMatrix4fv(glGetUniformLocation(default_shader, "model"), 1, GL_FALSE, &model[0][0]);
-    glUniform4fv(glGetUniformLocation(default_shader, "color"), 1, color);
-
-    glBindTexture(GL_TEXTURE_2D, renderer->texture_color);
-    glBindVertexArray(renderer->line.vao);
-
-    glBindBuffer(GL_ARRAY_BUFFER, renderer->line.vbo);
-    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof (line), line);
-    glDrawArrays(GL_LINES, 0, 2);
-
-    
-    glBindVertexArray(0);
-    
+  glBindVertexArray(0);
 }
 
 void render_quad_line(Renderer *renderer, vec2 pos, vec2 size, vec4 color) {
-	vec2 points[4] = {
-		{pos[0] - size[0] * 0.5f, pos[1] - size[1] * 0.5f},
-		{pos[0] + size[0] * 0.5f, pos[1] - size[1] * 0.5f},
-		{pos[0] + size[0] * 0.5f, pos[1] + size[1] * 0.5f},
-		{pos[0] - size[0] * 0.5f, pos[1] + size[1] * 0.5f},
-	};
-
-	render_line(renderer, points[0], points[1], color);
-	render_line(renderer,points[1], points[2], color);
-	render_line(renderer,points[2], points[3], color);
-	render_line(renderer, points[3], points[0], color);
+  vec2 points[4] = {
+      {pos[0] - size[0] * 0.5f, pos[1] - size[1] * 0.5f},
+      {pos[0] + size[0] * 0.5f, pos[1] - size[1] * 0.5f},
+      {pos[0] + size[0] * 0.5f, pos[1] + size[1] * 0.5f},
+      {pos[0] - size[0] * 0.5f, pos[1] + size[1] * 0.5f},
+  };
+
+  render_line(renderer, points[0], points[1], color);
+  render_line(renderer, points[1], points[2], color);
+  render_line(renderer, points[2], points[3], color);
+  render_line(renderer, points[3], points[0], color);
 }
 
 void render_aabb(Renderer *renderer, float *aabb, vec4 color) {
-	vec2 size;
-	vec2_scale(size, &aabb[2], 2);
-	render_quad_line(renderer, &aabb[0], size, color);
+  vec2 size;
+  vec2_scale(size, &aabb[2], 2);
+  render_quad_line(renderer, &aabb[0], size, color);
 }

src/renderer.h

@@ -6,9 +6,8 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
-#include <glad/glad.h>
 #include <GLFW/glfw3.h>
-
+#include <glad/glad.h>
 
 #define UNIFORMS_COUNT 1
 #define PROGRAMS_COUNT 2
@@ -21,11 +20,11 @@ typedef int RENDERER_ERROR;
 #define RENDERER_ERROR_GLFW -1
 #define RENDERER_ERROR_GLAD -2
 
-#define ERROR_AND_QUIT(ERR, ...) \
-( ERR==RENDERER_ERROR_GLFW ? fprintf(stderr, "GLFW: %s\n", __VA_ARGS__) \
-: ERR==RENDERER_ERROR_GLAD ? fprintf(stderr, "OpenGL: %s\n", __VA_ARGS__) \
-: fprintf(stderr, "%s\n", __VA_ARGS__)); exit(1)
-
+#define ERROR_AND_QUIT(ERR, ...)                                               \
+  (ERR == RENDERER_ERROR_GLFW   ? fprintf(stderr, "GLFW: %s\n", __VA_ARGS__)   \
+   : ERR == RENDERER_ERROR_GLAD ? fprintf(stderr, "OpenGL: %s\n", __VA_ARGS__) \
+                                : fprintf(stderr, "%s\n", __VA_ARGS__));       \
+  exit(1)
 
 #if 0
 struct nk_glfw_vertex {
@@ -36,40 +35,39 @@ struct nk_glfw_vertex {
 #endif
 
 typedef struct aabb {
-	vec2 position;
-	vec2 half_size;
+  vec2 position;
+  vec2 half_size;
 } AABB;
 
 typedef struct {
-	GLuint vao;
-	GLuint vbo;
-	GLuint ebo;
+  GLuint vao;
+  GLuint vbo;
+  GLuint ebo;
 } Quad;
 
 typedef struct {
-	GLuint vao;
-	GLuint vbo;
+  GLuint vao;
+  GLuint vbo;
 } Line;
 
 typedef struct {
-	GLFWwindow *window;
-	int width;
-	int height;
+  GLFWwindow *window;
+  int width;
+  int height;
+
+  Quad quad;
+  Line line;
 
-	Quad quad;
-	Line line;
+  mat4x4 projection;
 
-	
-	mat4x4 projection;
+  GLuint texture_color;
 
-	GLuint texture_color;
-	
-	GLuint uniforms[UNIFORMS_COUNT];
-	GLuint programs[PROGRAMS_COUNT];
+  GLuint uniforms[UNIFORMS_COUNT];
+  GLuint programs[PROGRAMS_COUNT];
 
-	GLint attrib_pos;
-	GLint attrib_uv;
-	GLint attrib_col;
+  GLint attrib_pos;
+  GLint attrib_uv;
+  GLint attrib_col;
 
 #if 0
 	/* nuklear */
@@ -81,34 +79,22 @@ typedef struct {
 
 } Renderer;
 
-
 RENDERER_ERROR renderer_init(Renderer *renderer, int width, int height);
-RENDERER_ERROR renderer_init_glfw(Renderer* renderer, int width, int height);
+RENDERER_ERROR renderer_init_glfw(Renderer *renderer, int width, int height);
 
 void renderer_init_shaders(Renderer *renderer);
 void renderer_init_textures(Renderer *renderer);
 
-void renderer_destroy(Renderer* renderer);
-
+void renderer_destroy(Renderer *renderer);
 
 void renderer_init_quad(Renderer *renderer);
-void render_quad(Renderer* renderer, vec2 pos, vec2 size, vec4 color);
+void render_quad(Renderer *renderer, vec2 pos, vec2 size, vec4 color);
 
 void renderer_init_line(Renderer *renderer);
-void render_line(Renderer*, vec2 start, vec2 end, vec4 color);
+void render_line(Renderer *, vec2 start, vec2 end, vec4 color);
 void render_quad_line(Renderer *renderer, vec2 pos, vec2 size, vec4 color);
 void render_aabb(Renderer *renderer, float *aabb, vec4 color);
 
-
-
-void renderer_init_nk(Renderer* renderer);
-
-
-void read_shader_source(GLchar* source, const char* file_path);
-static const char* shader_type_as_cstr(GLuint shader);
-static bool compile_shader_source(const GLchar* source, GLenum shader_type, GLuint* shader);
-static void attach_shaders_to_program(GLuint* shaders, size_t shaders_count, GLuint program);
-static bool link_program(GLuint program, const char* file_path, size_t line);
-static void renderer_upload_atlas(Renderer* renderer, const void* image, int width, int height);
+void read_shader_source(GLchar *source, const char *file_path);
 
 #endif // _RENDERER_H_