lots of changes

include/debugging.h

@@ -0,0 +1,6 @@
+#ifndef __DEBUGGING_H__
+#define __DEBUGGING_H__
+
+void enable_debugging();
+
+#endif

include/events.h

@@ -0,0 +1,9 @@
+#ifndef __EVENTS_H__
+#define __EVENTS_H__
+
+#include <types.h>
+
+void framebuffer_size_callback(Window window, int width, int height);
+void process_input(Window window); 
+
+#endif

include/init.h

@@ -0,0 +1,9 @@
+#ifndef __INIT_H__
+#define __INIT_H__
+
+#include <types.h>
+
+void init_gl(int major, int minor);
+Window create_window(int width, int height, const char* title); 
+
+#endif

include/opengl.h

@@ -0,0 +1,7 @@
+#ifndef __OPENGL_H__
+#define __OPENGL_H__
+
+#include <glad/gl.h>
+#include <GLFW/glfw3.h>
+
+#endif

include/shaders.h

@@ -0,0 +1,9 @@
+#ifndef __SHADERS_H__
+#define __SHADERS_H__
+
+#include <stdint.h>
+
+uint32_t compile_shader(const char* path, int32_t type);
+uint32_t load_shader_program(uint32_t shader, ...);
+
+#endif

include/types.h

@@ -0,0 +1,8 @@
+#ifndef __TYPES_H__
+#define __TYPES_H__
+
+#include <opengl.h>
+
+typedef GLFWwindow* Window;
+
+#endif

shader.frag

@@ -0,0 +1,8 @@
+#version 460 core
+
+in vec4 fragColor;
+out vec4 finalColor;
+
+void main() {
+    finalColor = fragColor;
+}

shader.vert

@@ -0,0 +1,10 @@
+#version 460 core
+
+layout(location = 0) in vec3 aPos;
+
+out vec4 fragColor;
+
+void main() {
+    gl_Position = vec4(aPos, 1.0);
+    fragColor = vec4(1.0, 0.0, 0.0, 1.0);
+}

src/debugging.c

@@ -0,0 +1,79 @@
+#include <debugging.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <opengl.h>
+
+void message_callback(int32_t source, int32_t type, uint32_t id, int32_t severity, size_t length, char const* message, void const* user_param)
+{
+	char* src_str;
+	switch (source) {
+	case GL_DEBUG_SOURCE_API: 
+            src_str = "API";
+            break;
+	case GL_DEBUG_SOURCE_WINDOW_SYSTEM: 
+            src_str = "WINDOW SYSTEM";
+            break;
+	case GL_DEBUG_SOURCE_SHADER_COMPILER: 
+            src_str = "SHADER COMPILER";
+            break;
+	case GL_DEBUG_SOURCE_THIRD_PARTY: 
+            src_str = "THIRD PARTY";
+            break;
+	case GL_DEBUG_SOURCE_APPLICATION: 
+            src_str = "APPLICATION";
+            break;
+	case GL_DEBUG_SOURCE_OTHER: 
+            src_str = "OTHER";
+            break;
+	}
+
+	char* type_str;
+	switch (type) {
+	case GL_DEBUG_TYPE_ERROR: 
+            type_str = "ERROR";
+            break;
+	case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: 
+            type_str = "DEPRECATED_BEHAVIOR";
+            break;
+	case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: 
+            type_str = "UNDEFINED_BEHAVIOR";
+            break;
+	case GL_DEBUG_TYPE_PORTABILITY: 
+            type_str = "PORTABILITY";
+            break;
+	case GL_DEBUG_TYPE_PERFORMANCE: 
+            type_str = "PERFORMANCE";
+            break;
+	case GL_DEBUG_TYPE_MARKER: 
+            type_str = "MARKER";
+            break;
+	case GL_DEBUG_TYPE_OTHER: 
+            type_str = "OTHER";
+            break;
+	}
+
+	char* severity_str;
+        switch (severity) {
+	case GL_DEBUG_SEVERITY_NOTIFICATION:
+            severity_str = "NOTIFICATION";
+            break;
+	case GL_DEBUG_SEVERITY_LOW:
+            severity_str = "LOW";
+            break;
+	case GL_DEBUG_SEVERITY_MEDIUM: 
+            severity_str = "MEDIUM";
+            break;
+	case GL_DEBUG_SEVERITY_HIGH: 
+            severity_str = "HIGH";
+            break;
+	}
+	
+        printf("[%s] %s (%s): %d, %s\n", src_str, type_str, severity_str, id, message);
+}
+
+void enable_debugging() {
+    glEnable(GL_DEBUG_OUTPUT);
+    glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, NULL, GL_FALSE);
+    glDebugMessageCallback((GLDEBUGPROC)message_callback, NULL);
+}

src/events.c

@@ -0,0 +1,11 @@
+#include <events.h>
+
+void framebuffer_size_callback(Window window, int width, int height) {
+    glViewport(0, 0, width, height);
+}
+
+void process_input(Window window) {
+    if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+        glfwSetWindowShouldClose(window, GLFW_TRUE);
+}
+

src/init.c

@@ -0,0 +1,43 @@
+#include <init.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <events.h>
+
+#include <opengl.h>
+
+void init_gl(int major, int minor) {
+    if(!glfwInit()) {
+        printf("[GLFW] Failed to initialize\n");
+        exit(-1);
+    } else {
+        printf("[GLFW] Initialized successfully\n");
+    }
+
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, major);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, minor);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+}
+
+Window create_window(int width, int height, const char* title) {
+    Window window = glfwCreateWindow(width, height, title, NULL, NULL);
+    if(!window) {
+        printf("[GLFW] Failed to create window\n");
+        glfwTerminate();
+        exit(-1);
+    } else {
+        printf("[GLFW] Window created successfully\n");
+    }
+    glfwMakeContextCurrent(window);
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); 
+
+    if (!gladLoadGL((GLADloadfunc)glfwGetProcAddress)) {
+        printf("[GLAD] Failed to initialize\n");
+        exit(-1);
+    } else {
+        printf("[GLAD] Initialized successfully\n");
+    }
+
+    glViewport(0, 0, width, height);
+
+    return window;
+}

src/main.c

@@ -1,51 +1,33 @@
-#include <stdio.h>
-#include <glad/gl.h>
-#include <GLFW/glfw3.h>
-#include <stdlib.h>
-
-void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
-    glViewport(0, 0, width, height);
-}
-
-void process_input(GLFWwindow *window) {
-    if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
-        glfwSetWindowShouldClose(window, GLFW_TRUE);
-}
-
-void init_glfw(int major, int minor) {
-    if(!glfwInit()) {
-        fprintf(stderr, "Failed to initialize GLFW\n");
-        exit(-1);
-    }
-
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, major);
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, minor);
-    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-}
-
-GLFWwindow* create_window(int width, int height, const char* title) {
-    GLFWwindow* window = glfwCreateWindow(width, height, title, NULL, NULL);
-    if(!window) {
-        fprintf(stderr, "Failed to create GLFW window\n");
-        glfwTerminate();
-        exit(-1);
-    }
-    glfwMakeContextCurrent(window);
-    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); 
-
-    if (!gladLoadGL((GLADloadfunc)glfwGetProcAddress)) {
-        fprintf(stderr, "Failed to initialize GLAD\n");
-        exit(-1);
-    }
-
-    glViewport(0, 0, width, height);
-
-    return window;
-}
+#include <init.h>
+#include <debugging.h>
+#include <shaders.h>
+#include <events.h>
 
 int main() {
-    init_glfw(4, 6);
+    init_gl(4, 6);
     GLFWwindow* window = create_window(800, 600, "gearlib");
+    enable_debugging();
+
+    float vertices[] = {
+        -0.5f, -0.5f, 0.0f,  // bottom left
+         0.5f, -0.5f, 0.0f,  // bottom right
+         0.0f,  0.5f, 0.0f   // top
+    };
+
+    uint32_t vbo;
+    glCreateBuffers(1, &vbo);
+    glNamedBufferStorage(vbo, sizeof(vertices), vertices, GL_DYNAMIC_STORAGE_BIT);
+
+    uint32_t vao;
+    glCreateVertexArrays(1, &vao);
+    glVertexArrayVertexBuffer(vao, 0, vbo, 0, 3 * sizeof(float));
+    glEnableVertexArrayAttrib(vao, 0);
+    glVertexArrayAttribFormat(vao, 0, 3, GL_FLOAT, GL_FALSE, 0);
+    glVertexArrayAttribBinding(vao, 0, 0);
+
+    uint32_t program = load_shader_program(
+            compile_shader("shader.vert", GL_VERTEX_SHADER),
+            compile_shader("shader.frag", GL_FRAGMENT_SHADER), 0);
 
     while (!glfwWindowShouldClose(window)) {
         process_input(window);
@@ -53,6 +35,11 @@ int main() {
         glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
         glClear(GL_COLOR_BUFFER_BIT);
 
+        glUseProgram(program);
+
+        glBindVertexArray(vao);
+        glDrawArrays(GL_TRIANGLES, 0, 3);
+        
         glfwSwapBuffers(window);
         glfwPollEvents();
     }

src/shaders.c

@@ -0,0 +1,67 @@
+#include <shaders.h>
+#include <stdarg.h>
+#define SL_IMPLEMENTATION
+#include <slibs/slibs.h>
+#include <opengl.h>
+
+uint32_t compile_shader(const char* path, int32_t type) {
+    sl_string source = { 0 };
+    sl_read_file(path, &source);
+    const char* source_cstr = sl_c_str(source);
+
+    uint32_t shader = glCreateShader(type);
+    glShaderSource(shader, 1, &source_cstr, NULL);
+    glCompileShader(shader);
+
+    sl_str_free(source);
+
+    int success;
+    char info_log[512];
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+    if(!success) {
+        glGetShaderInfoLog(shader, 512, NULL, info_log);
+        printf("[Shader %d, %s] Failed to compile: %s\n", shader, path, info_log);
+        exit(-1);
+    } else {
+        printf("[Shader %d, %s] Compiled successfully\n", shader, path);
+    }
+
+    return shader;
+}
+
+uint32_t load_shader_program(uint32_t shader, ...) {
+    sl_vec(uint32_t) shaders = { 0 };
+
+    va_list args;
+    va_start(args, shader);
+    while(shader != 0) {
+        sl_vec_push(shaders, shader);
+        shader = va_arg(args, uint32_t);
+    }
+    va_end(args);
+
+    uint32_t program = glCreateProgram();
+    for(sl_vec_it(shader, shaders)) {
+        glAttachShader(program, *shader);
+        printf("[Shader %d] Attached to program %d\n", *shader, program);
+    }
+    glLinkProgram(program);
+
+    int success;
+    char info_log[512];
+    glGetProgramiv(program, GL_LINK_STATUS, &success);
+    if(!success) {
+        glGetProgramInfoLog(program, 512, NULL, info_log);
+        printf("[Program %d] Failed to link: %s\n", program, info_log);
+        exit(-1);
+    } else {
+        printf("[Program %d] Linked successfully\n", program);
+    }
+
+    for(sl_vec_it(shader, shaders)) {
+        glDeleteShader(*shader);
+        printf("[Shader %d] Deleted successfully\n", *shader);
+    } 
+
+    return program;
+}