Init

src/Input.c

@@ -0,0 +1,35 @@
+#include "Input.h"
+
+extern float pos[3];
+
+/* 0: nothing 
+ * 1: W
+ * 2: S
+ * 3: A
+ * 4: D
+ */
+
+static bool pressed[5];
+static int index;
+void key_pressed(GLFWwindow* window, int key, int scancode, int action, int mods){
+	if ( key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)	glfwSetWindowShouldClose(window, true);		
+	if ( key == GLFW_KEY_Q      && action == GLFW_PRESS )   glfwSetWindowShouldClose(window, true);	
+
+    index = 0; 
+    if ( key == GLFW_KEY_W ) index = 1;
+    if ( key == GLFW_KEY_S ) index = 2;
+    if ( key == GLFW_KEY_A ) index = 3;
+    if ( key == GLFW_KEY_D ) index = 4;
+
+    if ( action == GLFW_PRESS )   pressed[index] = true; 
+    if ( action == GLFW_RELEASE ) pressed[index] = false;
+    
+
+}
+
+void processInput(){
+	if (pressed[1] == true) pos[1] += 0.01f;	
+	if (pressed[2] == true)	pos[1] -= 0.01f;
+    if (pressed[3] == true) pos[0] -= 0.01f;
+    if (pressed[4] == true) pos[0] += 0.01f;
+}

src/Input.h

@@ -0,0 +1,13 @@
+#ifndef INPUT
+#define INPUT
+
+#include <GLFW/glfw3.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+void key_pressed();
+
+void processInput();
+
+#endif

src/Renderer.c

@@ -0,0 +1,159 @@
+#include "Renderer.h"
+
+extern int windowHeight;
+extern int windowWidth;
+
+GLFWwindow* initOpenGL() {
+	
+	glfwInit();
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+
+	GLFWwindow* window = glfwCreateWindow(800, 600, "Hello World", NULL, NULL);
+	if(window == NULL) {
+		printf("Failed to create a window\n");
+		glfwTerminate();
+		exit(-1);
+	}
+
+	glfwMakeContextCurrent(window);
+	glfwSetFramebufferSizeCallback(window, WindowGotResized);
+
+	if(!gladLoadGLLoader( (GLADloadproc) glfwGetProcAddress )) {
+		printf("Failed to initialize GLAD");
+		exit(-1);
+	}
+    
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+	// Set Global Texture Parameters
+	float borderColor[] = {1.0f, 1.0f, 0.0f, 1.0f};
+	glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+	return window;
+}
+
+void WindowGotResized(GLFWwindow* window, int width, int height) {
+    windowHeight = height;
+    windowWidth = width;
+	glViewport(0, 0, width, height);
+}
+
+unsigned int compileShaderProgram(const char** vertexSrc, const char** fragmentSrc) {
+	unsigned int vertexShader;
+	vertexShader = glCreateShader(GL_VERTEX_SHADER);
+	glShaderSource(vertexShader, 1, vertexSrc, NULL);
+	glCompileShader(vertexShader);
+
+	int vertexSuccess;
+	char infoLog[512];
+	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &vertexSuccess);
+	if(!vertexSuccess) {
+		glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);		
+		printf("SHADER::VERTEX::COMPILATION_FAILED\n %s \n", infoLog);
+	}
+
+	unsigned int fragmentShader;
+	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
+	glShaderSource(fragmentShader, 1, fragmentSrc, NULL);
+	glCompileShader(fragmentShader);
+
+	int fragmentSuccess;
+	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &fragmentSuccess);
+	if(!fragmentSuccess){
+		glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
+		printf("SHADER::FRAGMENT::COMPILATION_FAILED\n %s \n", infoLog);
+	}
+
+	unsigned int shaderProgram;
+	shaderProgram = glCreateProgram();
+	glAttachShader(shaderProgram, vertexShader);
+	glAttachShader(shaderProgram, fragmentShader);
+	
+	glLinkProgram(shaderProgram);
+
+	int programSuccess;
+	glGetProgramiv(shaderProgram, GL_LINK_STATUS, &programSuccess);
+	if(!programSuccess) {
+		glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
+		printf("SHADER::PROGRAM::LINKING_FAILED\n %s \n", infoLog);
+	}
+	glDeleteShader(vertexShader);
+	glDeleteShader(fragmentShader);
+
+	return shaderProgram;
+
+}
+
+unsigned int createShader(char* vertexPath, char* fragmentPath) {
+	FILE* vertex_file = fopen(vertexPath, "r");
+	FILE* fragment_file = fopen(fragmentPath, "r");
+	if( vertex_file == NULL || fragment_file == NULL ) {
+		printf("Failed to load shaders.\n");
+		exit(1);
+	}
+
+	struct stat vertex_stat;
+	struct stat fragment_stat;
+	stat(vertexPath, &vertex_stat);
+	stat(fragmentPath, &fragment_stat);
+
+	int vertex_length = vertex_stat.st_size;
+	int fragment_length = fragment_stat.st_size;
+	
+	char* vertex_src = (char*)malloc(vertex_length+1);
+	char* fragment_src = (char*)malloc(fragment_length+1);
+	memset(vertex_src, 0, vertex_length+1);
+	memset(fragment_src, 0, fragment_length+1);
+
+	fread(vertex_src, sizeof(char), vertex_length, vertex_file );
+	fread(fragment_src, sizeof(char), fragment_length, fragment_file );
+	
+	vertex_src[vertex_length+1] = '\0';
+	fragment_src[fragment_length+1] = '\0';
+//	printf("%s", vertex_src);
+//	printf("%s", fragment_src);
+
+	const char* vertexSrc = vertex_src;
+	const char* fragmentSrc = fragment_src;
+	
+	unsigned int shaderProgram;
+	shaderProgram = compileShaderProgram(&vertexSrc, &fragmentSrc);
+	free(fragment_src);
+	free(vertex_src);
+
+	return shaderProgram;
+}
+
+unsigned int createTexture(char* path){
+	// Generate Texture
+	unsigned int texture;
+	glGenTextures(1, &texture);
+	glBindTexture(GL_TEXTURE_2D, texture);
+
+	// Set Texure Parameters
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+	// Load texture image
+	int width, height, channels;
+	unsigned char *data = stbi_load(path, &width, &height, &channels, 0);
+
+	if (data) {
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
+		glGenerateMipmap(GL_TEXTURE_2D);
+	} else {
+		printf("Failed to load texture %s", path);
+	}
+	stbi_image_free(data);
+
+	return texture;
+}
+
+

src/Renderer.h

@@ -0,0 +1,23 @@
+#ifndef OPENGLINITIALIZATION
+#define OPENGLINITIALIZATION
+
+#include <glad/glad.h>
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <stb_image.h>
+
+GLFWwindow* initOpenGL();
+
+void WindowGotResized(GLFWwindow* window, int width, int height);
+
+unsigned int compileShaderProgram(const char** vertexSrc, const char** fragmentSrc);
+
+unsigned int createShader(char* vertexPath, char* fragmentPath);
+
+unsigned int createTexture(char* path);
+
+#endif

src/main.c

@@ -0,0 +1,88 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdbool.h>
+
+#include <linmath.h>
+#include "Renderer.h"
+#include "Input.h"
+
+
+float pos[3] = {0.0f, 0.0f, 0.0f};
+int windowWidth;
+int windowHeight;
+
+int main(int argc, char *argv[]) {
+	GLFWwindow* window = initOpenGL();
+	glfwSetKeyCallback(window, &key_pressed);
+
+	const float square[] = {
+		-0.5f, -0.5f, 0.0f, 	 1.0f, -1.0f,	
+	 	 0.5f, -0.5f, 0.0f, 	 1.0f,  1.0f,
+		 0.5f,  0.5f, 0.0f, 	-1.0f,  1.0f,		
+		-0.5f,  0.5f, 0.0f,		-1.0f, -1.0f,	
+	};
+    
+	// CreateShader
+    unsigned int circleShader = createShader("assets/shaders/circleVertex.glsl", "assets/shaders/circleFragment.glsl");
+
+	// Initialise VBO and VAO
+	unsigned int VAO, VBO;
+	glGenVertexArrays(1, &VAO);
+	glGenBuffers(1, &VBO);
+
+	glBindVertexArray(VAO);
+	glBindBuffer(GL_ARRAY_BUFFER, VBO);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(square), square, GL_DYNAMIC_DRAW);
+
+	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0 );
+	glEnableVertexAttribArray(0);
+	glVertexAttribPointer(1, 2,GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3*sizeof(float)));
+	glEnableVertexAttribArray(1);
+
+    float aspect = (float)windowWidth / (float) windowHeight;
+
+    mat4x4 proj, view;
+    mat4x4_identity(proj);
+    mat4x4_identity(view);   
+    proj[1][1] = aspect;
+
+    unsigned int projLoc  = glGetUniformLocation(circleShader, "proj");
+    unsigned int viewLoc  = glGetUniformLocation(circleShader, "view");
+    unsigned int transLoc = glGetUniformLocation(circleShader, "transform");
+
+    mat4x4 transform;
+    mat4x4_identity(transform);
+    
+
+	while(!glfwWindowShouldClose(window)) {
+        aspect = (float) windowWidth / (float) windowHeight;
+         
+        printf("x: %f y: %f \n", pos[0], pos[1]);
+
+		glBindVertexArray(VAO);
+		glBindBuffer(GL_ARRAY_BUFFER, VBO);
+		glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+		glUseProgram(circleShader);
+        proj[1][1] = aspect;
+
+        mat4x4_translate(transform, pos[0], pos[1], pos[2]);
+ 
+        glUniformMatrix4fv(projLoc, 1, GL_FALSE, *proj);
+        glUniformMatrix4fv(viewLoc, 1, GL_FALSE, *view);
+        glUniformMatrix4fv(transLoc, 1, GL_FALSE, *transform);
+
+        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+		glfwSwapBuffers(window);
+		glfwPollEvents();
+		processInput();
+	}
+	
+	glDeleteVertexArrays(1, &VAO);
+	glDeleteBuffers(1, &VBO);
+	glfwTerminate();
+	return 0;
+}

src/stb_image.c

@@ -0,0 +1,2 @@
+#define STB_IMAGE_IMPLEMENTATION
+#include <stb_image.h>