The dragon renders yay

OpenGL/playground/src/main.cpp

@@ -19,15 +19,17 @@
 #include <glm/gtc/type_ptr.hpp>
 
 // Custom includes
+#define LOGGER_DEFINITION
 #include <logger.h>
 #include "timers.h"
 #include "object.h"
+#include "shader.h"
 
 int main(int argc, char** argv) {
 	std::cout << "-----------------------------" << std::endl;
 	std::cout << "----- OpenGL Playground -----" << std::endl;
 	std::cout << "-------- Version 1.0 --------" << std::endl;
-	std::cout << "----- <EFBFBD>Benjamin Kyd 2019 ----" << std::endl;
+	std::cout << "----- ©Benjamin Kyd 2019 ----" << std::endl;
 	std::cout << "-----------------------------" << std::endl;
 	std::cout << 								    std::endl;
 
@@ -60,25 +62,85 @@ int main(int argc, char** argv) {
 	SDL_GL_SetSwapInterval(0);
 
 	gladLoadGLLoader(SDL_GL_GetProcAddress);
-	std::vector<glm::vec4> vertices;
-	std::vector<glm::vec3> normals;
-	std::vector<GLushort> elements;
 	isWindowOpen = true;
 	logger << LOGGER_INFO << "OpenGL and SDL initialized" << LOGGER_ENDL;
 
 
 
-
+	// Load an object into system memory
+	std::vector<glm::vec4> vertices;
+	std::vector<glm::vec3> normals;
+	std::vector<GLushort> elements;
 
 	LoadOBJ(logger, "./resources/dragon.obj", vertices, normals, elements);
 
+	// Generate a vertex array object
+	GLuint vao;
+	glGenVertexArrays(1, &vao);
+	// Bind array to GPU
+	glBindVertexArray(vao);
+
+	// Generate a vertex buffer object
+	GLuint vbo;
+	glGenBuffers(1, &vbo);
+	// Bind buffer to the GPU
+	glBindBuffer(GL_ARRAY_BUFFER, vbo);
+	// Copy vertex data to the vertex buffer already on the GPU
+	glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec4), &vertices[0], GL_STATIC_DRAW);
+
+	// Generate another vertex buffer for the element array buffer
+	GLuint ebo;
+	glGenBuffers(1, &ebo);
+	// Bind buffer to the GPU
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
+	// Copy buffer data to the buffer already on the GPU
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, elements.size() * sizeof(GLushort), &elements[0], GL_STATIC_DRAW);
+
+	// Load, compile, apply and link shader programs
+	Shader simpleShader{ logger };
+	simpleShader.load("./resources/shaders/simple").attatch().link().use();
+
+	GLint posAttrib = glGetAttribLocation(simpleShader.getProgram(), "position");
+	glEnableVertexAttribArray(posAttrib);
+	glVertexAttribPointer(posAttrib, 4, GL_FLOAT, GL_FALSE, 0, 0);
+
+	// Model matrice
+	glm::mat4 model = glm::mat4(1.0f);
+	model = glm::translate(model, {-12.0f, -20.0f, -20.0f});
+	// Gets uniform for model matrice, to be used later
+	GLint uniTrans = glGetUniformLocation(simpleShader.getProgram(), "model");
+
+	// View matrice
+	glm::mat4 view = glm::lookAt(
+		glm::vec3(1.0f, 1.0f, 1.0f),
+		glm::vec3(0.0f, 0.0f, 0.0f),
+		glm::vec3(0.0f, 0.0f, 1.0f)
+	);
+	// Get uniform and send it to the GPU
+	GLint uniView = glGetUniformLocation(simpleShader.getProgram(), "view");
+	glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(view));
+
+	// Projection matrice
+	glm::mat4 proj = glm::perspective(glm::radians(45.0f), 1280.0f / 720.0f, 1.0f, 1000.0f);
+	// Get uniform and send it to the GPU    
+	GLint uniProj = glGetUniformLocation(simpleShader.getProgram(), "proj");
+	glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
+
+
+	glEnable(GL_DEPTH_TEST);
+
 	SDL_Event event;
 	while (isWindowOpen) {
 		FPSCount(logger);
 
 		// Update tick (60ups)
 		if (UPSTimer()) {
+			model = glm::rotate(model, glm::radians(1.0f), glm::vec3(0.0f, 0.0f, 1.0f));
+			model = glm::rotate(model, glm::radians(1.0f), glm::vec3(1.0f, 0.0f, 0.0f));
+			glm::vec4 result = model * glm::vec4(1.0f, 0.0f, 0.0f, 1.0f);
+			glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
 
+			UpdateClock = SDL_GetTicks();
 		}
 
 		// Handle events
@@ -86,12 +148,13 @@ int main(int argc, char** argv) {
 			if (event.type == SDL_QUIT)
 				isWindowOpen = false;
 
-
 		// Clear
 		const float clear[] = {0.1f, 0.45f, 0.9f, 1.0f};
 		glClearBufferfv(GL_COLOR, 0, clear);
 		glClear(GL_DEPTH_BUFFER_BIT);
-		// Swap GL frame buffers
+		// Draw
+		glDrawElements(GL_TRIANGLES, elements.size(), GL_UNSIGNED_SHORT, 0);
+		// Swap
 		SDL_GL_SwapWindow(window);
 	}
 

OpenGL/playground/src/object.cpp

@@ -7,6 +7,7 @@ void LoadOBJ(Logger& logger, std::string file, std::vector<glm::vec4>& vertices,
     std::ifstream in(file, std::ios::in);
     if (!in) {
         logger << LOGGER_ERROR << "Cannot open " << file << LOGGER_ENDL;
+		return;
     }
 
     std::string line;

OpenGL/playground/src/shader.cpp

@@ -3,7 +3,8 @@
 #include <iostream>
 #include <fstream>
 
-Shader::Shader() {
+Shader::Shader(Logger& logger)
+	: logger(logger) {
     m_program = glCreateProgram();
 }
 
@@ -44,10 +45,10 @@ Shader& Shader::load(GLenum type, std::string sourceLoc) {
         if (m_status == GL_FALSE) {
             char buf[512];
             glGetShaderInfoLog(m_vert, 512, NULL, buf);
-            std::cerr << buf << std::endl;
+			logger << LOGGER_ERROR << buf << LOGGER_ENDL;
         }
 
-        std::cout << "Vertex shader at '" << sourceLoc << "' compiled..." << std::endl;
+        logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
     } else if (type == GL_FRAGMENT_SHADER) {
         m_fragLoc = sourceLoc;
         m_fragSource = (std::string)source;
@@ -59,10 +60,10 @@ Shader& Shader::load(GLenum type, std::string sourceLoc) {
         if (m_status == GL_FALSE) {
             char buf[512];
             glGetShaderInfoLog(m_frag, 512, NULL, buf);
-            std::cerr << buf << std::endl;
-        }
+			logger << LOGGER_ERROR << buf << LOGGER_ENDL;
+		}
 
-        std::cout << "Vertex shader at '" << sourceLoc << "' compiled..." << std::endl;
+        logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
     }
 
     return *this;
@@ -90,18 +91,18 @@ Shader& Shader::load(std::string sourceLoc) {
     if (m_status == GL_FALSE) {
         char buf[512];
         glGetShaderInfoLog(m_vert, 512, NULL, buf);
-        std::cerr << buf << std::endl;
+		logger << LOGGER_ERROR << buf << LOGGER_ENDL;
     }
 
     glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
     if (m_status == GL_FALSE) {
         char buf[512];
         glGetShaderInfoLog(m_frag, 512, NULL, buf);
-        std::cerr << buf << std::endl;
-    }
+		logger << LOGGER_ERROR << buf << LOGGER_ENDL;
+	}
 
-    std::cout << "Vertex shader at '" << m_vertLoc << "' compiled..." << std::endl;
-    std::cout << "Fragment shader at '" << m_fragLoc << "' compiled..." << std::endl;
+    logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
+	logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
     return *this;
 }
 

OpenGL/playground/src/shader.h

@@ -3,10 +3,11 @@
 
 #include <glad/glad.h>
 #include <string>
+#include <logger.h>
 
 class Shader {
 public:
-    Shader();
+	Shader(Logger& logger);
 
     Shader& use();
     Shader& link();
@@ -32,6 +33,8 @@ private:
     std::string m_vertLoc;
     std::string m_fragLoc;
 
+	Logger& logger;
+
     GLint m_status;
 };