Logger class and boilerplate out of the way

OpenGL/playground/.gitignore

@@ -0,0 +1 @@
+build/

OpenGL/playground/CMakeLists.txt

@@ -24,7 +24,7 @@ if (WIN32)
 	include_directories(${executable}
 		"C:/dev/glm"
 		"C:/dev/SDL2/include/"
-		"C:/dev/SDL2_image/include/"
+		#"C:/dev/SDL2_image/include/"
 	)
 endif (WIN32)
 

OpenGL/playground/CMakeSettings.json

@@ -0,0 +1,25 @@
+{
+  "environments": [
+    {
+      "DevDir": "E:\\Languages\\Examples\\OpenGL\\playground\\build",
+      "BuildDir": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}"
+    }
+  ],
+  "configurations": [
+    {
+      "name": "x64-Debug",
+      "generator": "Ninja",
+      "configurationType": "Debug",
+      "inheritEnvironments": [
+        "msvc_x64_x64"
+      ],
+      "buildRoot": "E:\\Languages\\Examples\\OpenGL\\playground\\build",
+      // "buildRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}",
+      "installRoot": "E:\\Languages\\Examples\\OpenGL\\playground\\build",
+      // "installRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}",
+      "cmakeCommandArgs": "",
+      "buildCommandArgs": "-v",
+      "ctestCommandArgs": ""
+    }
+  ]
+}

OpenGL/playground/include/logger.h

@@ -0,0 +1,162 @@
+#ifndef INCLUDE_LOGGER_H_
+#define INCLUDE_LOGGER_H_
+
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <map>
+
+#ifdef _WIN32
+#include <Windows.h>
+typedef enum {
+	CONSOLE_COLOUR_FG_BLACK = 0,
+	CONSOLE_COLOUR_FG_BLUE = FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_GREEN = FOREGROUND_GREEN,
+	CONSOLE_COLOUR_FG_CYAN = FOREGROUND_GREEN | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_RED = FOREGROUND_RED,
+	CONSOLE_COLOUR_FG_MAGENTA = FOREGROUND_RED | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_YELLOW = FOREGROUND_RED | FOREGROUND_GREEN,
+	CONSOLE_COLOUR_FG_GRAY = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_LIGHT_GRAY = FOREGROUND_INTENSITY,
+	CONSOLE_COLOUR_FG_LIGHT_BLUE = FOREGROUND_INTENSITY | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_LIGHT_GREEN = FOREGROUND_INTENSITY | FOREGROUND_GREEN,
+	CONSOLE_COLOUR_FG_LIGHT_CYAN = FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_LIGHT_RED = FOREGROUND_INTENSITY | FOREGROUND_RED,
+	CONSOLE_COLOUR_FG_LIGHT_MAGENTA = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_LIGHT_YELLOW = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN,
+	CONSOLE_COLOUR_FG_WHITE = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_FG_DEFAULT = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
+	CONSOLE_COLOUR_BG_DEFAULT = 0
+} ConsoleColour;
+
+#ifdef _WIN32
+	HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
+	WORD wOldColorAttrs;
+	CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+#endif
+
+#else 
+typedef enum {
+	CONSOLE_COLOUR_FG_DEFAULT = 39,
+	CONSOLE_COLOUR_FG_BLACK = 30,
+	CONSOLE_COLOUR_FG_RED = 31,
+	CONSOLE_COLOUR_FG_GREEN = 32,
+	CONSOLE_COLOUR_FG_YELLOW = 33,
+	CONSOLE_COLOUR_FG_BLUE = 34,
+	CONSOLE_COLOUR_FG_MAGENTA = 35,
+	CONSOLE_COLOUR_FG_CYAN = 36,
+	CONSOLE_COLOUR_FG_LIGHT_GRAY = 37,
+	CONSOLE_COLOUR_FG_DARK_GRAY = 90,
+	CONSOLE_COLOUR_FG_LIGHT_RED = 91,
+	CONSOLE_COLOUR_FG_LIGHT_GREEN = 92,
+	CONSOLE_COLOUR_FG_LIGHT_YELLOW = 93,
+	CONSOLE_COLOUR_FG_LIGHT_BLUE = 94,
+	CONSOLE_COLOUR_FG_LIGHT_MAGENTA = 95,
+	CONSOLE_COLOUR_FG_LIGHT_CYAN = 96,
+	CONSOLE_COLOUR_FG_WHITE = 97,
+	CONSOLE_COLOUR_BG_RED = 41,
+	CONSOLE_COLOUR_BG_GREEN = 42,
+	CONSOLE_COLOUR_BG_BLUE = 44,
+	CONSOLE_COLOUR_BG_DEFAULT = 49
+} ConsoleColour;
+#endif
+
+
+class Colour {
+public:
+	//template<class T, class D>
+	//static std::string getColouredText(T colour, D text) {
+	//	std::stringstream output;
+		
+//#ifdef _WIN32
+	//	SetConsoleTextAttribute(h, T);
+//#else
+	//	output << "\033[" << colour << "m" << text;
+	//	output << "\033[" << CONSOLE_COLOUR_BG_DEFAULT << "m";
+	//	output << "\033[" << CONSOLE_COLOUR_FG_DEFAULT << "m";
+//#endif
+
+	//	return output.str();
+	//}
+
+	static void resetColour() {
+#ifdef _WIN32
+		SetConsoleTextAttribute(h, CONSOLE_COLOUR_BG_DEFAULT);
+		SetConsoleTextAttribute(h, CONSOLE_COLOUR_FG_DEFAULT);
+#else
+		std::cout
+			<< "\033[" << CONSOLE_COLOUR_BG_DEFAULT << "m"
+			<< "\033[" << CONSOLE_COLOUR_FG_DEFAULT << "m";
+#endif
+	}
+
+	template<class T>
+	static void consoleColour(T colour) {
+#ifdef _WIN32
+		SetConsoleTextAttribute(h, colour);
+#else
+		std::cout << "\033[" << colour << "m";
+#endif
+	}
+};
+
+typedef enum {
+	LOGGER_INFO = CONSOLE_COLOUR_FG_GREEN,
+	LOGGER_WARN = CONSOLE_COLOUR_FG_YELLOW,
+	LOGGER_ERROR = CONSOLE_COLOUR_FG_RED,
+	LOGGER_PANIC = CONSOLE_COLOUR_FG_RED,
+	LOGGER_DEBUG = CONSOLE_COLOUR_FG_BLUE
+} LogType;
+
+typedef enum {
+	LOGGER_EXIT,
+	LOGGER_ENDL
+} LogAction;
+
+class Logger {
+public:
+
+	std::stringstream outStream;
+	std::map<LogType, std::string> lookupTable;
+	Logger() {
+
+#ifdef _WIN32
+		GetConsoleScreenBufferInfo(h, &csbiInfo);
+		wOldColorAttrs = csbiInfo.wAttributes;
+#endif
+
+		lookupTable[LOGGER_INFO] = "INFO";
+		lookupTable[LOGGER_WARN] = "WARN";
+		lookupTable[LOGGER_ERROR] = "ERROR";
+		lookupTable[LOGGER_PANIC] = "PANIC";
+		lookupTable[LOGGER_DEBUG] = "DEBUG";
+	}
+
+	Logger& operator<< (const LogType type) {
+		std::cout << "[";
+		Colour::consoleColour(type);
+		std::cout << lookupTable[type];
+		Colour::consoleColour(CONSOLE_COLOUR_FG_DEFAULT);
+		std::cout << "] ";
+		return *this;
+	}
+
+	Logger& operator<< (const LogAction action) {
+		if (action == LOGGER_ENDL) {
+			std::cout << outStream.str() << std::endl;
+			outStream.str(std::string());;
+			outStream.flush();
+		}
+		if (action == LOGGER_EXIT)
+			exit(0);
+		return *this;
+	}
+
+	template<typename T>
+	Logger& operator<< (const T& data) {
+		outStream << data;
+		return *this;
+	}
+};
+
+#endif

OpenGL/playground/src/main.cpp

@@ -1,5 +1,7 @@
-#include <iostream>
+// General includes
+#include <chrono>
 
+// GL includes
 #include <glad/glad.h>
 
 // SDL includes different on windows
@@ -15,15 +17,27 @@
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
 
+// Custom includes
+#include <logger.h>
+
 int main(int argc, char** argv) {
 	std::cout << "----- OpenGL Playground -----" << std::endl;
 	std::cout << "-------- Version 1.0 --------" << std::endl;
-	std::cout << "----- ©Benjamin Kyd 2019 ----" << std::endl;
+	std::cout << "----- ©Benjamin Kyd 2019 ----" << std::endl << std::endl;
 
+	// Get global variables ready
+	Logger logger;
 	SDL_Window* window = nullptr;
 	SDL_GLContext glContext;
 	bool isWindowClosed = true;
 
+	logger << LOGGER_DEBUG << "debug" << LOGGER_ENDL;
+	logger << LOGGER_INFO << "info" << LOGGER_ENDL;
+	logger << LOGGER_WARN << "warn" << LOGGER_ENDL;
+	logger << LOGGER_ERROR << "error" << LOGGER_ENDL;
+	logger << LOGGER_PANIC << "panic" << LOGGER_ENDL << LOGGER_ENDL;
+
+	// Initialize SDL and OpenGL
 	SDL_Init(SDL_INIT_EVERYTHING);
 
 	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
@@ -36,14 +50,51 @@ int main(int argc, char** argv) {
 	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
 	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
 
-	window = SDL_CreateWindow("GL CUBE",
+	window = SDL_CreateWindow("OpenGL Playground V1.0",
 		SDL_WINDOWPOS_CENTERED,
 		SDL_WINDOWPOS_CENTERED,
-		500, 500,
+		1000, 1000,
 		SDL_WINDOW_OPENGL);
 	glContext = SDL_GL_CreateContext(window);
 	SDL_GL_SetSwapInterval(0);
 
 	gladLoadGLLoader(SDL_GL_GetProcAddress);
+	isWindowClosed = false;
 
+	logger << LOGGER_INFO << "OpenGL and SDL initialized" << LOGGER_ENDL;
+
+
+
+	// Various timers needed for FPS counting
+	std::chrono::high_resolution_clock timer;
+	auto FPSCalculateLast = timer.now();
+	auto FPSClock = SDL_GetTicks();
+
+	auto UpdateClock = SDL_GetTicks();
+
+	SDL_Event event;
+	while (!isWindowClosed) {
+		// Calculate and display framerate
+		if (SDL_GetTicks() - FPSClock >= 1000) {
+			auto deltaTime = std::chrono::duration_cast<std::chrono::nanoseconds>(timer.now() - FPSCalculateLast).count();
+			logger << LOGGER_INFO << "FPS: " << (int)(1 / ((float)deltaTime * 1e-9)) << LOGGER_ENDL;
+			FPSClock = SDL_GetTicks();
+		}
+		FPSCalculateLast = timer.now();
+
+		// Update tick
+		if (SDL_GetTicks() - UpdateClock >= 10) {
+
+		}
+
+		// Handle events
+		while (SDL_PollEvent(&event) != 0)
+			if (event.type == SDL_QUIT)
+				isWindowClosed = true;
+
+		// Swap GL frame buffers
+		SDL_GL_SwapWindow(window);
+	}
+
+	return 0;
 }