basic rendering for both opengl and vulkan

rendering/gl/context.h

@@ -0,0 +1,21 @@
+/* SPDX-License-Identifier:BSD-3-Clause */
+#ifndef GL_CONTEXT_H
+#define GL_CONTEXT_H
+
+#include "gl.h"
+#include "../../core/types.h"
+#define RGFW_OPENGL
+#ifndef RGFW_IMPLEMENTATION
+#define RGFW_IMPORT
+#endif
+#include "../../rgfw.h"
+
+struct renderer_context {
+	RGFW_window *window;
+	GLuint shader_program;
+	GLuint vao;
+	GLuint vbo;
+	GLuint ebo;
+};
+
+#endif

rendering/gl/platform.c

@@ -1,51 +1,53 @@
 /* SPDX-License-Identifier:BSD-3-Clause */
 
 #include "gl.h"
+#define RGFW_EXPORT
 #define RGFW_IMPLEMENTATION
 #define RGFW_OPENGL
-#include "../rgfw.h"
+#include "../../rgfw.h"
+
+#include "../renderer.h"
+#include "../../core/log.h"
 
 /*
  * This function is the entrypoint for the whole game. Its role is to
  * initialize OpenGL, create the renderer and start the game loop.
  */
-int platform_run(i32 argc, u8 * *argv)
+int platform_run(i32 argc, u8 **argv)
 {
 	(void)argc;
 	(void)argv;
 
+	log_info("Using OpenGL as rendering backend.\n");
+
 	RGFW_glHints *hints = RGFW_getGlobalHints_OpenGL();
 	hints->major = 3;
 	hints->minor = 3;
 	RGFW_setGlobalHints_OpenGL(hints);
 
-	RGFW_window *win = RGFW_createWindow("Topaz", 0, 0, 800, 600, RGFW_windowCenter | RGFW_windowNoResize | RGFW_windowHide);
+	RGFW_window *win = RGFW_createWindow("topaz", 0, 0, 800, 600, RGFW_windowCenter | RGFW_windowNoResize | RGFW_windowHide);
 	RGFW_window_createContext_OpenGL(win, hints);
 
 	int glad_version = gladLoadGL(RGFW_getProcAddress_OpenGL);
 	if (glad_version == 0) {
-		printf("Failed to initialize OpenGL context.\n");
+		log_error("Failed to initialize OpenGL context.\n");
 		return -1;
 	}
 
 	RGFW_window_show(win);
-
 	RGFW_window_setExitKey(win, RGFW_escape);
 
-	const u8 *version = glGetString(GL_VERSION);
-	printf("OpenGL Version: %s\n", version);
-	printf("GLAD Version: %d.%d\n", GLAD_VERSION_MAJOR(glad_version), GLAD_VERSION_MINOR(glad_version));
+	log_info("OpenGL initialized.\n");
 
+	struct renderer_context *context = renderer_context_init(win);
 
 	while (RGFW_window_shouldClose(win) == RGFW_FALSE) {
 		RGFW_event event;
 		while (RGFW_window_checkEvent(win, &event));
-
-		glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
-		glClear(GL_COLOR_BUFFER_BIT);
-		RGFW_window_swapBuffers_OpenGL(win);
+		renderer_present(context);
 	}
 
+	renderer_context_deinit(context);
 	RGFW_window_close(win);
 	return 0;
 }

rendering/gl/renderer.c

@@ -0,0 +1,154 @@
+/* SPDX-License-Identifier:BSD-3-Clause */
+#include "context.h"
+#include "../renderer.h"
+#include "../../core/log.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+static const char *vertex_shader_src =
+	"#version 330 core\n"
+	"layout (location = 0) in vec2 in_position;\n"
+	"layout (location = 1) in vec3 in_color;\n"
+	"out vec3 frag_color;\n"
+	"void main() {\n"
+	"    gl_Position = vec4(in_position, 0.0, 1.0);\n"
+	"    frag_color = in_color;\n"
+	"}\n";
+
+static const char *fragment_shader_src =
+	"#version 330 core\n"
+	"in vec3 frag_color;\n"
+	"out vec4 out_color;\n"
+	"void main() {\n"
+	"    out_color = vec4(frag_color, 1.0);\n"
+	"}\n";
+
+static GLuint compile_shader(GLenum type, const char *source)
+{
+	GLuint shader = glCreateShader(type);
+	glShaderSource(shader, 1, &source, NULL);
+	glCompileShader(shader);
+
+	GLint success;
+	glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+	if (!success) {
+		char info[512];
+		glGetShaderInfoLog(shader, 512, NULL, info);
+		log_error("Shader compilation failed: ");
+		printf("%s\n", info);
+	}
+
+	return shader;
+}
+
+static GLuint create_shader_program(void)
+{
+	GLuint vert = compile_shader(GL_VERTEX_SHADER, vertex_shader_src);
+	GLuint frag = compile_shader(GL_FRAGMENT_SHADER, fragment_shader_src);
+
+	GLuint program = glCreateProgram();
+	glAttachShader(program, vert);
+	glAttachShader(program, frag);
+	glLinkProgram(program);
+
+	GLint success;
+	glGetProgramiv(program, GL_LINK_STATUS, &success);
+	if (!success) {
+		char info[512];
+		glGetProgramInfoLog(program, 512, NULL, info);
+		log_error("Shader linking failed: ");
+		printf("%s\n", info);
+	}
+
+	glDeleteShader(vert);
+	glDeleteShader(frag);
+
+	return program;
+}
+
+static void create_quad_buffers(struct renderer_context *context)
+{
+	f32 vertices[] = {
+		-0.5f, -0.5f,  1.0f, 0.0f, 0.0f,
+		 0.5f, -0.5f,  0.0f, 1.0f, 0.0f,
+		 0.5f,  0.5f,  0.0f, 0.0f, 1.0f,
+		-0.5f,  0.5f,  1.0f, 1.0f, 1.0f
+	};
+
+	u16 indices[] = { 0, 1, 2, 2, 3, 0 };
+
+	glGenVertexArrays(1, &context->vao);
+	glGenBuffers(1, &context->vbo);
+	glGenBuffers(1, &context->ebo);
+
+	glBindVertexArray(context->vao);
+
+	glBindBuffer(GL_ARRAY_BUFFER, context->vbo);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, context->ebo);
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
+
+	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(f32), (void *)0);
+	glEnableVertexAttribArray(0);
+
+	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(f32), (void *)(2 * sizeof(f32)));
+	glEnableVertexAttribArray(1);
+
+	glBindVertexArray(0);
+
+	log_info("Quad buffers created.\n");
+}
+
+struct renderer_context *renderer_context_init(RGFW_window *window)
+{
+	struct renderer_context *context = malloc(sizeof(struct renderer_context));
+	context->window = window;
+
+	context->shader_program = create_shader_program();
+	log_info("Shader program created.\n");
+
+	create_quad_buffers(context);
+
+	glEnable(GL_FRAMEBUFFER_SRGB);
+
+	return context;
+}
+
+void renderer_context_deinit(struct renderer_context *context)
+{
+	glDeleteVertexArrays(1, &context->vao);
+	glDeleteBuffers(1, &context->vbo);
+	glDeleteBuffers(1, &context->ebo);
+	glDeleteProgram(context->shader_program);
+	free(context);
+}
+
+struct mesh *renderer_build_chunk_mesh(void)
+{
+	return NULL;
+}
+
+void renderer_draw_mesh(struct renderer_context *context, struct mesh mesh)
+{
+	(void)context;
+	(void)mesh;
+}
+
+void renderer_draw_chunk(struct renderer_context *context, struct mesh mesh)
+{
+	(void)context;
+	(void)mesh;
+}
+
+void renderer_present(struct renderer_context *context)
+{
+	glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
+	glClear(GL_COLOR_BUFFER_BIT);
+
+	glUseProgram(context->shader_program);
+	glBindVertexArray(context->vao);
+	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
+
+	RGFW_window_swapBuffers_OpenGL(context->window);
+}