Added shader loading, added glad

src/display/render.c

@@ -0,0 +1,81 @@
+#include "render.h"
+
+render_t *RENDER_CURRENT = NULL;
+
+render_t * renderInit(char *name) {
+  // Can't contextualize twice
+  if(RENDER_CURRENT != NULL) return NULL;
+
+  // Attempt to init GLFW
+  if(!glfwInit()) return NULL;
+ 
+  // Initialize the renderer
+  render_t *render = malloc(sizeof(render_t));
+  if(!render) return NULL; 
+  render->width = WINDOW_WIDTH_DEFAULT;
+  render->height = WINDOW_HEIGHT_DEFAULT;
+
+  // Create the window.
+  render->window = glfwCreateWindow(render->width, render->height,
+    name, NULL, NULL
+  );
+  if(!render->window) {
+    free(render);
+    glfwTerminate();
+    return NULL;
+  }
+
+  // Make the window the context current
+  glfwMakeContextCurrent(render->window);
+  
+  // Load GLAD
+  gladLoadGL((GLADloadproc)glfwGetProcAddress);
+
+  RENDER_CURRENT = render;
+
+  // Listeners
+  glfwSetWindowSizeCallback(render->window, &renderOnResize);
+
+  //GLEnable Things
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+  glEnable(GL_DEPTH_TEST);
+  glDepthMask(GL_TRUE);
+  glDepthFunc(GL_LEQUAL);
+
+  return render;
+}
+
+void renderFrame(render_t *render) {
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+  glBegin(GL_TRIANGLES);
+    glColor3f(1, 0, 0);
+    glVertex3f(-1, -1, 0);
+
+    glColor3f(0, 1, 0);
+    glVertex3f(0, 1, 0);
+
+    glColor3f(0, 0, 1);
+    glVertex3f(1, -1, 0);
+  glEnd();
+}
+
+bool renderDispose(render_t *render) {
+  // Cleanup the callback
+  glfwSetWindowSizeCallback(render->window, NULL);
+
+  // Free up the renderer
+  free(render);
+  RENDER_CURRENT = NULL;
+
+  // Terminate the GLFW context.
+  glfwTerminate();
+  return true;
+}
+
+void renderOnResize(GLFWwindow *window, int32_t width, int32_t height) {
+  RENDER_CURRENT->width = width;
+  RENDER_CURRENT->height = height;
+  glViewport(0, 0, width, height);
+}

src/display/render.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <malloc.h>
+
+// I load GLAD and GLFW Here because they need to be included in specific orders
+#include <glad/glad.h>
+#include <GLFW/glfw3.h>
+
+#include <cglm/call.h>
+
+#define WINDOW_WIDTH_DEFAULT 480
+#define WINDOW_HEIGHT_DEFAULT 270
+
+/**
+ * Contains information about the current render state, can be used for querying
+ * how the renderer is currently set up.
+ */
+typedef struct {
+  /** The GLFW Window Context Pointer */
+  GLFWwindow *window;
+
+  /** Resolution (in pixels) */
+  int32_t width, height;
+} render_t;
+
+/**  Current active renderer. */
+extern render_t *RENDER_CURRENT;
+
+/**
+ * Initialize the renderer.
+ * 
+ * @param width Width (in pixels) of the window.
+ * @param height Height (in pixels) of the window.
+ * @param name String of the windows' name.
+ * @return Rendering Context information.
+ */
+render_t * renderInit(char *name);
+
+/**
+ * Render a single frame of the render loop. The renderer is not (currently)
+ * responsible for render looping.
+ * 
+ * @param render The renderer to loop for.
+ */
+void renderFrame(render_t *render);
+
+/**
+ * Cleanup a render context.
+ * 
+ * @param render Renderer to cleanup.
+ * @return True or False if Successful/Not.
+ */
+bool renderDispose(render_t *render);
+
+/**
+ * Resize callbacks.
+ * 
+ * @param window Window that was resized.
+ * @param width New window width.
+ * @param height New window height.
+ */
+void renderOnResize(GLFWwindow *window, int32_t width, int32_t height);

src/display/shader.c

@@ -0,0 +1,88 @@
+#include "shader.h"
+
+shader_t * shaderCompile(char *vertexShaderSource, char* fragmentShaderSource) {
+  int isSuccess, maxLength;
+  char *error;
+  GLuint shaderVertex, shaderFragment, shaderProgram;
+  
+  
+  // Load the vertex shader first
+  shaderVertex = glCreateShader(GL_VERTEX_SHADER);
+  glShaderSource(shaderVertex, 1, &vertexShaderSource, 0);
+  glCompileShader(shaderVertex);
+
+  // Validate
+  glGetShaderiv(shaderVertex, GL_COMPILE_STATUS, &isSuccess);
+  if(!isSuccess) {
+    glGetShaderiv(shaderVertex, GL_INFO_LOG_LENGTH, &maxLength);
+    error = malloc(maxLength);
+    glGetShaderInfoLog(shaderVertex, maxLength, &maxLength, error);
+    printf("Failed to compile vertex shader %s\n", error);
+    free(error);
+    return NULL;
+  }
+
+  // Now load the Frag shader
+  shaderFragment = glCreateShader(GL_FRAGMENT_SHADER);
+  glShaderSource(shaderFragment, 1, &fragmentShaderSource, 0);
+  glCompileShader(shaderFragment);
+  glGetShaderiv(shaderFragment, GL_COMPILE_STATUS, &isSuccess);
+  if(!isSuccess) {
+    glGetShaderiv(shaderFragment, GL_INFO_LOG_LENGTH, &maxLength);
+    error = malloc(maxLength);
+    glGetShaderInfoLog(shaderFragment, maxLength, &maxLength, error);
+    printf("Failed to compile fragment shader %s\n", error);
+    free(error);
+    glDeleteShader(shaderVertex);
+    return NULL;
+  }
+
+  // Now create the shader program.
+  shaderProgram = glCreateProgram();
+  glAttachShader(shaderProgram, shaderVertex);
+  glAttachShader(shaderProgram, shaderFragment);
+
+  //Bind, Verify & Use the shader program
+  glLinkProgram(shaderProgram);
+  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &isSuccess);
+  if(!isSuccess) {
+    glGetProgramiv(shaderProgram, GL_INFO_LOG_LENGTH, &maxLength);
+    error = malloc(maxLength);
+    glGetProgramInfoLog(shaderProgram, maxLength, &maxLength, error);
+    printf("Failed to load shader program %s\n", error);
+    free(error);
+    glDeleteShader(shaderVertex);
+    glDeleteShader(shaderFragment);
+    return NULL;
+  }
+
+  // Everything is okay, let's create the encapsulated shader.
+  shader_t *shader = malloc(sizeof(shader_t));
+  if(shader == NULL) {
+    glDeleteProgram(shaderProgram);
+    glDeleteShader(shaderVertex);
+    glDeleteShader(shaderFragment);
+    return NULL;
+  }
+  shader->shaderVertex = shaderVertex;
+  shader->shaderFrag = shaderFragment;
+  shader->shaderProgram = shaderProgram;
+
+  // Bind the shader
+  shaderUse(shader);
+
+  // Fetch the uniforms.
+  return shader;
+}
+
+bool shaderDipose(shader_t *shader) {
+  glDeleteProgram(shader->shaderProgram);
+  glDeleteShader(shader->shaderVertex);
+  glDeleteShader(shader->shaderFrag);
+  free(shader);
+  return true;
+}
+
+void shaderUse(shader_t *shader) {
+  glUseProgram(shader->shaderProgram);
+}

src/display/shader.h

@@ -0,0 +1,43 @@
+#pragma once
+#include <glad/glad.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <malloc.h>
+
+/**
+ * Structure containing information about an OpenGL Shader. For simplicity sake
+ * we demand certain uninforms to be present on the shader target.
+ */
+typedef struct {
+  /** Pointer to an uploaded vertex shader program */
+  GLuint shaderVertex;
+
+  /** Pointer to an uploaded fragment shader program */
+  GLuint shaderFrag;
+
+  /** Pointer to an uploaded shader program linked */
+  GLuint shaderProgram;
+} shader_t;
+
+/**
+ * Create a shader from vertex and fragment shader code.
+ * 
+ * @param vertexShaderSource The raw vertex shader code.
+ * @param fragmentShaderSource The raw fragment shader code.
+ * @return Pointer to the loaded shader.
+ */
+shader_t * shaderCompile(char *vertexShaderSource, char* fragmentShaderSource);
+
+/**
+ * Cleanup and unload a previously loaded shader.
+ * 
+ * @param shader The shader to unload
+ * @return True if successfully disposed.
+ */
+bool shaderDipose(shader_t *shader);
+
+/**
+ * Attaches the supplied shader as the current shader.
+ * @param shader The shader to attach
+ */
+void shaderUse(shader_t *shader);