Clean up ghost file and move shader functions into a new file

Makefile

@@ -1,20 +1,27 @@
-ghostland: glad.o ghostland.o stb_image.o collisions.o player.o
+CC := g++
-	g++ -o ghostland glad.o ghostland.o stb_image.o collisions.o player.o -ldl -lglfw -std=c++17 -O3
+CFLAGS := -std=c++17 -O3
+LDFLAGS := -ldl -lglfw
+
+ghostland: glad.o ghostland.o stb_image.o collisions.o player.o shader.o
+	$(CC) -o ghostland glad.o ghostland.o stb_image.o collisions.o player.o shader.o $(LDFLAGS) $(CFLAGS)
 
 glad.o: glad.c
-	g++ -c -o glad.o glad.c -O3
+	$(CC) -c -o glad.o glad.c $(CFLAGS)
 
 ghostland.o: ghostland.cpp
-	g++ -c -o ghostland.o ghostland.cpp -std=c++17 -O3
+	$(CC) -c -o ghostland.o ghostland.cpp $(CFLAGS)
 
 stb_image.o: stb_image.c
-	g++ -c -o stb_image.o stb_image.c -std=c++17 -O3
+	$(CC) -c -o stb_image.o stb_image.c $(CFLAGS)
 
-collisions.o: collisions.cpp
+collisions.o: collisions.cpp collisions.h
-	g++ -c -o collisions.o collisions.cpp -std=c++17 -O3
+	$(CC) -c -o collisions.o collisions.cpp $(CFLAGS)
 
-player.o: player.cpp
+player.o: player.cpp player.h
-	g++ -c -o player.o player.cpp -std=c++17 -O3
+	$(CC) -c -o player.o player.cpp $(CFLAGS)
+
+shader.o: shader.cpp shader.h
+	$(CC) -c -o shader.o shader.cpp $(CFLAGS)
 
 clean:
 	rm -f *.o ghostland

ghostland.cpp

@@ -15,11 +15,11 @@
 
 #include "collisions.h"
 #include "player.h"
+#include "shader.h"
 
 void framebuffer_size_callback(GLFWwindow* window, int width, int height);
 void mouse_callback(GLFWwindow* window, double xpos, double ypos);
 void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
-int createShader(const char *filename, int shadertype);
 void set_light_front(int xoffset, int yoffset);
 
 // player
@@ -159,44 +159,19 @@ int main(int argc, char *argv[])
 
     glEnable(GL_DEPTH_TEST);
 
-    int vertex_shader = createShader("vertexshader.glsl", GL_VERTEX_SHADER);
+    int wall_program = create_shader_program("vertexshader.glsl", "fragmentshader.glsl");
-    if (vertex_shader < 0) {
+    if (wall_program < 0) {
-        return -1;
-    }
-    int fragment_shader = createShader("fragmentshader.glsl", GL_FRAGMENT_SHADER);
-    if (fragment_shader < 0) {
-        return -1;
-    }
-
-    int wall_program = glCreateProgram();
-    glAttachShader(wall_program, vertex_shader);
-    glAttachShader(wall_program, fragment_shader);
-    glLinkProgram(wall_program);
-    glGetProgramiv(wall_program, GL_LINK_STATUS, &success);
-    if (!success) {
-        char infoLog[1024];
-        glGetProgramInfoLog(wall_program, 1024, NULL, infoLog);
-        printf("Shader wall_program link error: %s\n", infoLog);
         glfwTerminate();
         return -1;
     }
 
-    int floor_program = glCreateProgram();
+    // Perhaps there's a better way of doing this, rather than re-compiling the same files?
-    glAttachShader(floor_program, vertex_shader);
+    int floor_program = create_shader_program("vertexshader.glsl", "fragmentshader.glsl");
-    glAttachShader(floor_program, fragment_shader);
+    if (wall_program < 0) {
-    glLinkProgram(floor_program);
-    glGetProgramiv(floor_program, GL_LINK_STATUS, &success);
-    if (!success) {
-        char infoLog[1024];
-        glGetProgramInfoLog(floor_program, 1024, NULL, infoLog);
-        printf("Shader floor_program link error: %s\n", infoLog);
         glfwTerminate();
         return -1;
     }
 
-    glDeleteShader(vertex_shader);
-    glDeleteShader(fragment_shader);
-
     // do stuff for walls
     unsigned int wallsVBO, wallsVAO;
     glGenVertexArrays(1, &wallsVAO);
@@ -260,24 +235,8 @@ int main(int argc, char *argv[])
     glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
     glEnableVertexAttribArray(0);
 
-    int trail_shader = createShader("trailshader.glsl", GL_VERTEX_SHADER);
+    int trail_program = create_shader_program("trailshader.glsl", "trailfragshader.glsl");
-    if (trail_shader < 0) {
+    if (trail_program < 0) {
-        return -1;
-    }
-    int trailfrag_shader = createShader("trailfragshader.glsl", GL_FRAGMENT_SHADER);
-    if (trailfrag_shader < 0) {
-        return -1;
-    }
-
-    int trail_program = glCreateProgram();
-    glAttachShader(trail_program, trail_shader);
-    glAttachShader(trail_program, trailfrag_shader);
-    glLinkProgram(trail_program);
-    glGetProgramiv(trail_program, GL_LINK_STATUS, &success);
-    if (!success) {
-        char infoLog[1024];
-        glGetProgramInfoLog(wall_program, 1024, NULL, infoLog);
-        printf("Shader trail_program link error: %s\n", infoLog);
         glfwTerminate();
         return -1;
     }
@@ -287,6 +246,7 @@ int main(int argc, char *argv[])
     int trail_ix = 0;
     int trail_sz = 0;
 
+    // TODO move these into config file??
     int time_secI = 0, num_frames = 1;
     float time_sec;
     glm::vec3 wall_color = glm::vec3(0.61f, 0.6f, 0.59f);
@@ -340,7 +300,7 @@ int main(int argc, char *argv[])
 
         float fov = player->get_fov();
         glm::mat4 projection = glm::perspective(glm::radians(fov), (float)WINDOWWIDTH / (float)WINDOWHEIGHT, 0.1f, 256.0f);
-        glUniformMatrix4fv(glGetUniformLocation(wall_program, projectionC), 1, GL_FALSE, &projection[0][0]);
+        set_uniform(wall_program, projectionC, projection);
 
         glm::vec3 camera_pos, camera_front, camera_up;
         camera_pos = player->get_camera_pos();
@@ -348,10 +308,10 @@ int main(int argc, char *argv[])
         camera_up = player->get_camera_up();
 
         glm::mat4 view = glm::lookAt(camera_pos, camera_pos + camera_front, camera_up);
-        glUniformMatrix4fv(glGetUniformLocation(wall_program, viewC), 1, GL_FALSE, &view[0][0]);
+        set_uniform(wall_program, viewC, view);
 
         glm::mat4 model = glm::mat4(1.0f);
-        glUniformMatrix4fv(glGetUniformLocation(wall_program, modelC), 1, GL_FALSE, &model[0][0]);
+        set_uniform(wall_program, modelC, model);
 
         // light position
         glm::vec3 light_pos = player->get_light_pos();
@@ -360,54 +320,53 @@ int main(int argc, char *argv[])
         //printf("light_pos: (%f, %f, %f)\n", light_front.x, light_front.y, light_front.z);
 
         // fragment requirements
-        glUniform3fv(glGetUniformLocation(wall_program, viewposC), 1, &camera_pos[0]);
+        set_uniform(wall_program, viewposC, camera_pos);
-        glUniform1f(glGetUniformLocation(wall_program, shininessC), wall_shininess);
+        set_uniform(wall_program, shininessC, wall_shininess);
-        glUniform3fv(glGetUniformLocation(wall_program, colorC), 1, &wall_color[0]);
+        set_uniform(wall_program, colorC, wall_color);
-        glUniform3fv(glGetUniformLocation(wall_program, lightposC), 1, &light_pos[0]);
+        set_uniform(wall_program, lightposC, light_pos);
-        glUniform3fv(glGetUniformLocation(wall_program, directionC), 1, &light_front[0]);
+        set_uniform(wall_program, directionC, light_front);
-        glUniform1f(glGetUniformLocation(wall_program, largecutoffC), largecutoff);
+        set_uniform(wall_program, largecutoffC, largecutoff);
-        glUniform1f(glGetUniformLocation(wall_program, smallcutoffC), smallcutoff);
+        set_uniform(wall_program, smallcutoffC, smallcutoff);
-        glUniform3fv(glGetUniformLocation(wall_program, ambientC), 1, &ambient[0]);
+        set_uniform(wall_program, ambientC, ambient);
-        glUniform3fv(glGetUniformLocation(wall_program, diffuseC), 1, &diffuse[0]);
+        set_uniform(wall_program, diffuseC, diffuse);
-        glUniform3fv(glGetUniformLocation(wall_program, specularC), 1, &specular[0]);
+        set_uniform(wall_program, specularC, specular);
 
         glBindVertexArray(wallsVAO);
         glDrawArrays(GL_TRIANGLES, 0, num_wall_vertices);
 
         glUseProgram(floor_program);
 
-        glUniformMatrix4fv(glGetUniformLocation(floor_program, projectionC), 1, GL_FALSE, &projection[0][0]);
+        set_uniform(floor_program, projectionC, projection);
-        glUniformMatrix4fv(glGetUniformLocation(floor_program, viewC), 1, GL_FALSE, &view[0][0]);
+        set_uniform(floor_program, viewC, view);
-        glUniformMatrix4fv(glGetUniformLocation(floor_program, modelC), 1, GL_FALSE, &model[0][0]);
+        set_uniform(floor_program, modelC, model);
-        glUniform3fv(glGetUniformLocation(floor_program, viewposC), 1, &camera_pos[0]);
+        set_uniform(floor_program, viewposC, camera_pos);
 
         // fragment requirements
-        glUniform3fv(glGetUniformLocation(floor_program, viewposC), 1, &camera_pos[0]);
+        set_uniform(floor_program, shininessC, floor_shininess);
-        glUniform1f(glGetUniformLocation(floor_program, shininessC), floor_shininess);
+        set_uniform(floor_program, colorC, floor_color);
-        glUniform3fv(glGetUniformLocation(floor_program, colorC), 1, &floor_color[0]);
+        set_uniform(floor_program, lightposC, light_pos);
-        glUniform3fv(glGetUniformLocation(floor_program, lightposC), 1, &light_pos[0]);
+        set_uniform(floor_program, directionC, light_front);
-        glUniform3fv(glGetUniformLocation(floor_program, directionC), 1, &light_front[0]);
+        set_uniform(floor_program, largecutoffC, largecutoff);
-        glUniform1f(glGetUniformLocation(floor_program, largecutoffC), largecutoff);
+        set_uniform(floor_program, smallcutoffC, smallcutoff);
-        glUniform1f(glGetUniformLocation(floor_program, smallcutoffC), smallcutoff);
+        set_uniform(floor_program, ambientC, ambient);
-        glUniform3fv(glGetUniformLocation(floor_program, ambientC), 1, &ambient[0]);
+        set_uniform(floor_program, diffuseC, diffuse);
-        glUniform3fv(glGetUniformLocation(floor_program, diffuseC), 1, &diffuse[0]);
+        set_uniform(floor_program, specularC, specular);
-        glUniform3fv(glGetUniformLocation(floor_program, specularC), 1, &specular[0]);
 
         glBindVertexArray(floorVAO);
         glDrawArrays(GL_TRIANGLES, 0, 6 * 6 * 1);
 
         glUseProgram(trail_program);
 
-        glUniformMatrix4fv(glGetUniformLocation(trail_program, projectionC), 1, GL_FALSE, &projection[0][0]);
+        set_uniform(trail_program, projectionC, projection);
-        glUniformMatrix4fv(glGetUniformLocation(trail_program, viewC), 1, GL_FALSE, &view[0][0]);
+        set_uniform(trail_program, viewC, view);
         glm::vec3 trail_color = glm::vec3(1.0f, 0.0f, 0.0f);
-        glUniform3fv(glGetUniformLocation(trail_program, objectcolorC), 1, &trail_color[0]);
+        set_uniform(trail_program, objectcolorC, trail_color);
 
         for (int i = 0; i < trail_sz; i++) {
             glm::mat4 model = glm::mat4(1.0f);
             model = glm::translate(model, trail_positions[i]);
             model = glm::rotate(model, glm::radians(trail_angles[i]), glm::vec3(0.0f, -1.0f, 0.0f));
-            glUniformMatrix4fv(glGetUniformLocation(trail_program, modelC), 1, GL_FALSE, &model[0][0]);
+            set_uniform(trail_program, modelC, model);
             glBindVertexArray(trailVAO);
 
             glDrawArrays(GL_TRIANGLES, 0, 3 * 3 * 3);
@@ -435,39 +394,6 @@ void framebuffer_size_callback(GLFWwindow* window, int width, int height)
     glViewport(0, 0, width, height);
 }
 
-int createShader(const char *filename, int shadertype) {
-    FILE* fp = fopen(filename, "r");
-    if (!fp) {
-        printf("failed to open vertex shader!\n");
-        return -1;
-    }
-    fseek(fp, 0L, SEEK_END);
-    unsigned int buffer_sz = ftell(fp);
-    rewind(fp);
-
-    char *buffer = (char *)calloc(sizeof(char), buffer_sz + 1);
-    if (fread(buffer, buffer_sz, 1, fp) != 1) {
-        printf("failed to read vertex shader!\n");
-        return -1;
-    }
-    fclose(fp);
-
-    int shader = glCreateShader(shadertype);
-    glShaderSource(shader, 1, &buffer, NULL);
-    free(buffer);
-    glCompileShader(shader);
-    int success;
-    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
-    if (!success) {
-        char info_log[1024];
-        glGetShaderInfoLog(shader, 1024, NULL, info_log);
-        printf("Shader compile error for %s: %s\n", filename, info_log);
-        glfwTerminate();
-        return -1;
-    }
-    return shader;
-}
-
 void mouse_callback(GLFWwindow* window, double xpos, double ypos) {
     player->mouse_callback(window, xpos, ypos);
 }

player.h

@@ -17,7 +17,6 @@ const float hvelocity = 10.0;
 
 class Player {
 
-
     public:
 
         Player(glm::vec3 startpos, float startyaw);

shader.cpp

@@ -0,0 +1,82 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <glad/glad.h>
+#include <GLFW/glfw3.h>
+
+#include "shader.h"
+
+int create_shader(const char *filename, int shadertype) {
+    FILE* fp = fopen(filename, "r");
+    if (!fp) {
+        printf("failed to open vertex shader!\n");
+        return -1;
+    }
+    fseek(fp, 0L, SEEK_END);
+    unsigned int buffer_sz = ftell(fp);
+    rewind(fp);
+
+    char *buffer = (char *)calloc(sizeof(char), buffer_sz + 1);
+    if (fread(buffer, buffer_sz, 1, fp) != 1) {
+        printf("failed to read vertex shader!\n");
+        return -1;
+    }
+    fclose(fp);
+
+    int shader = glCreateShader(shadertype);
+    glShaderSource(shader, 1, &buffer, NULL);
+    free(buffer);
+    glCompileShader(shader);
+    int success;
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+    if (!success) {
+        char info_log[1024];
+        glGetShaderInfoLog(shader, 1024, NULL, info_log);
+        printf("Shader compile error for %s: %s\n", filename, info_log);
+        glfwTerminate();
+        return -1;
+    }
+    return shader;
+}
+
+int create_shader_program(const char *vertex_filename, const char *fragment_filename) {
+
+    int vertex_shader = create_shader(vertex_filename, GL_VERTEX_SHADER);
+    if (vertex_shader < 0) {
+        return -1;
+    }
+
+    int fragment_shader = create_shader(fragment_filename, GL_FRAGMENT_SHADER);
+    if (fragment_shader < 0) {
+        return -1;
+    }
+
+    int program = glCreateProgram();
+    glAttachShader(program, vertex_shader);
+    glAttachShader(program, fragment_shader);
+    glLinkProgram(program);
+    int success;
+    glGetProgramiv(program, GL_LINK_STATUS, &success);
+    if (!success) {
+        char infoLog[1024];
+        glGetProgramInfoLog(program, 1024, NULL, infoLog);
+        printf("Shader wall_program link error: %s\n", infoLog);
+        return -1;
+    }
+
+    glDeleteShader(vertex_shader);
+    glDeleteShader(fragment_shader);
+
+    return program;
+
+}
+
+void set_uniform(int program, const char *key, float value) {
+    glUniform1f(glGetUniformLocation(program, key), value);
+}
+
+void set_uniform(int program, const char *key, const glm::vec3 &value) {
+    glUniform3fv(glGetUniformLocation(program, key), 1, &value[0]);
+}
+void set_uniform(int program, const char *key, const glm::mat4 &value) {
+    glUniformMatrix4fv(glGetUniformLocation(program, key), 1, GL_FALSE, &value[0][0]);
+}

shader.h

@@ -0,0 +1,13 @@
+#ifndef SHADER_H
+#define SHADER_H
+
+#include <glm/glm.hpp>
+
+int create_shader(const char *filename, int shadertype);
+int create_shader_program(const char *vertex_filename, const char *fragment_filename);
+
+void set_uniform(int program, const char *key, float value);
+void set_uniform(int program, const char *key, const glm::vec3 &value);
+void set_uniform(int program, const char *key, const glm::mat4 &value);
+
+#endif