feat: draw line, draw aabb, draw quad_line

refactor buffers into own struct so we can draw different kind of shapes

src/main.c

@@ -42,6 +42,11 @@ int main() {
 	glfwSetErrorCallback(error_callback);
 	glfwSetKeyCallback(renderer.window, key_callback);
 
+	AABB test_aabb = {
+		.position = {renderer.width * 0.5, renderer.height * 0.5},
+		.half_size = {50, 50},
+	};
+
 
 	while (!glfwWindowShouldClose(renderer.window)) {
 		glfwPollEvents();
@@ -50,18 +55,26 @@ int main() {
 		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_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 });
-			
-		
 
-		glfwSwapBuffers(renderer.window);
+		render_aabb(&renderer, (float*)&test_aabb, (vec4){1, 1, 1, 0.5});
 
+
+		glfwSwapBuffers(renderer.window);
 	}
 
 	renderer_destroy(&renderer);
 
 	return 0;
-}
+}
+

src/renderer.c

@@ -66,11 +66,18 @@ RENDERER_ERROR renderer_init(Renderer *renderer, int width, int height) {
     renderer->height = height;
 
     RENDERER_ERROR err = renderer_init_glfw(renderer, width, height);
-    if (err != RENDERER_ERROR_OK) return err;
+    if (err != RENDERER_ERROR_OK) {
+        ERROR_AND_QUIT(err, "could not intialize OpenGL");
+    }
+    
+    
+    
     
-    renderer_init_shaders(renderer);
     renderer_init_quad(renderer);
+    renderer_init_line(renderer);
     renderer_init_textures(renderer);
+    renderer_init_shaders(renderer);
+    
 	
     return RENDERER_ERROR_OK;
 
@@ -146,33 +153,14 @@ void renderer_init_shaders(Renderer *renderer) {
 
 }
 
-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);
-
-    glUniformMatrix4fv(glGetUniformLocation(default_shader, "model"), 1, GL_FALSE, &model[0][0]);
-    glUniform4fv(glGetUniformLocation(default_shader, "color"), 1, color);
-
-    glBindVertexArray(renderer->vao);
-    glBindTexture(GL_TEXTURE_2D, renderer->texture_color);
-    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, NULL);
-
-    glBindVertexArray(0);
 
-}
 
 void renderer_destroy(Renderer* renderer) {
 
     glDeleteTextures(1, &renderer->texture_color);
-    glDeleteBuffers(1, &renderer->vbo);
-    glDeleteBuffers(1, &renderer->ebo);
+    glDeleteBuffers(1, &renderer->quad.vbo);
+    glDeleteBuffers(1, &renderer->quad.ebo);
+    glDeleteBuffers(1, &renderer->line.vbo);
     glDeleteProgram(renderer->programs[0]);
 
     glfwTerminate();
@@ -265,16 +253,16 @@ void renderer_init_quad(Renderer *renderer) {
         1, 2, 3
     };
 
-    glGenVertexArrays(1, &renderer->vao);
-    glGenBuffers(1, &renderer->vbo);
-    glGenBuffers(1, &renderer->ebo);
+    glGenVertexArrays(1, &renderer->quad.vao);
+    glGenBuffers(1, &renderer->quad.vbo);
+    glGenBuffers(1, &renderer->quad.ebo);
 
-    glBindVertexArray(renderer->vao);
+    glBindVertexArray(renderer->quad.vao);
 
-    glBindBuffer(GL_ARRAY_BUFFER, renderer->vbo);
+    glBindBuffer(GL_ARRAY_BUFFER, renderer->quad.vbo);
     glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
 
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, renderer->ebo);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, renderer->quad.ebo);
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
 
     // x, y, z
@@ -287,4 +275,97 @@ void renderer_init_quad(Renderer *renderer) {
     glEnableVertexAttribArray(1);
 
     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);
+
+    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);
+
+    glBindVertexArray(0);
+
+}
+
+
+void renderer_init_line(Renderer *renderer)
+{
+
+	glGenVertexArrays(1, &renderer->line.vao);
+	glBindVertexArray(renderer->line.vao);
+
+	glGenBuffers(1, &renderer->line.vbo);
+	glBindBuffer(GL_ARRAY_BUFFER, renderer->line.vbo);
+	glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(float), NULL, GL_DYNAMIC_DRAW);
+
+	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);
+  
+
+    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);
+    
+}
+
+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);
+}
+
+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);
 }

src/renderer.h

@@ -21,10 +21,10 @@ typedef int RENDERER_ERROR;
 #define RENDERER_ERROR_GLFW -1
 #define RENDERER_ERROR_GLAD -2
 
-#define ERROR_AND_QUIT(R, ...) \
-( R==RENDERER_ERROR_GLFW ? fprintf(stderr, "GLFW: %s\n", __VA_ARGS__) \
- : R==RENDERER_ERROR_GLAD ? fprintf(stderr, "GLAD: %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
@@ -35,17 +35,31 @@ struct nk_glfw_vertex {
 };
 #endif
 
+typedef struct aabb {
+	vec2 position;
+	vec2 half_size;
+} AABB;
+
+typedef struct {
+	GLuint vao;
+	GLuint vbo;
+	GLuint ebo;
+} Quad;
+
 typedef struct {
+	GLuint vao;
+	GLuint vbo;
+} Line;
 
+typedef struct {
 	GLFWwindow *window;
 	int width;
 	int height;
 
+	Quad quad;
+	Line line;
 
-	GLuint vao;
-	GLuint vbo;
-	GLuint ebo;
-
+	
 	mat4x4 projection;
 
 	GLuint texture_color;
@@ -65,7 +79,6 @@ typedef struct {
 	struct nk_buffer cmds;
 #endif
 
-
 } Renderer;
 
 
@@ -74,10 +87,20 @@ 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_init_quad(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 renderer_init_line(Renderer *renderer);
+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);