Plannnninnnngggg

CMakeLists.txt

@@ -40,9 +40,9 @@ if (UNIX)
 endif (UNIX)
 
 include_directories(${executable}
-    #${PNG_INCLUDE_DIR}
-    #${JPEG_INCLUDE_DIR}
-    ${IncludeDIR}
+	#${PNG_INCLUDE_DIR}
+	#${JPEG_INCLUDE_DIR}
+	${IncludeDIR}
 )
 
 file(GLOB SourceFiles 
@@ -53,8 +53,8 @@ file(GLOB SourceFiles
 add_executable(${executable} ${SourceFiles})
 
 set_target_properties(${executable} PROPERTIES
-    CXX_STANDARD 17
-    CXX_EXTENSIONS OFF
+	CXX_STANDARD 17
+	CXX_EXTENSIONS OFF
 )
 
 if (UNIX)
@@ -63,7 +63,7 @@ if (UNIX)
 		#SDL2_image
 		#PNG::PNG
 		#JPEG::JPEG
-	    OpenGL::OpenGL
+		OpenGL::OpenGL
 		OpenGL::GL
 		Threads::Threads
 	)
@@ -80,5 +80,5 @@ if (WIN32)
 endif (WIN32)
 
 target_link_libraries(${executable}
-    ${CMAKE_DL_LIBS}
+	${CMAKE_DL_LIBS}
 )

include/OBJLoaderExample.cpp

@@ -1,80 +1,80 @@
-#define TINYOBJLOADER_IMPLEMENTATION // define this in only *one* .cc
-#include "tiny_obj_loader.h"
-
-std::string inputfile = "cornell_box.obj";
-tinyobj::attrib_t attrib;
-std::vector<tinyobj::shape_t> shapes;
-std::vector<tinyobj::material_t> materials;
-
-std::string warn;
-std::string err;
-bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, inputfile.c_str());
-  
-if (!err.empty()) { // `err` may contain warning message.
-  std::cerr << err << std::endl;
-}
-
-if (!ret) {
-  exit(1);
-}
-
-// Loop over shapes
-for (size_t s = 0; s < shapes.size(); s++) {
-  // Loop over faces(polygon)
-  size_t index_offset = 0;
-  for (size_t f = 0; f < shapes[s].mesh.num_face_vertices.size(); f++) {
-    int fv = shapes[s].mesh.num_face_vertices[f];
-
-    // Loop over vertices in the face.
-    for (size_t v = 0; v < fv; v++) {
-      // access to vertex
-      tinyobj::index_t idx = shapes[s].mesh.indices[index_offset + v];
-      tinyobj::real_t vx = attrib.vertices[3*idx.vertex_index+0];
-      tinyobj::real_t vy = attrib.vertices[3*idx.vertex_index+1];
-      tinyobj::real_t vz = attrib.vertices[3*idx.vertex_index+2];
-      tinyobj::real_t nx = attrib.normals[3*idx.normal_index+0];
-      tinyobj::real_t ny = attrib.normals[3*idx.normal_index+1];
-      tinyobj::real_t nz = attrib.normals[3*idx.normal_index+2];
-      tinyobj::real_t tx = attrib.texcoords[2*idx.texcoord_index+0];
-      tinyobj::real_t ty = attrib.texcoords[2*idx.texcoord_index+1];
-      // Optional: vertex colors
-      // tinyobj::real_t red = attrib.colors[3*idx.vertex_index+0];
-      // tinyobj::real_t green = attrib.colors[3*idx.vertex_index+1];
-      // tinyobj::real_t blue = attrib.colors[3*idx.vertex_index+2];
-    }
-    index_offset += fv;
-
-    // per-face material
-    shapes[s].mesh.material_ids[f];
-  }
-}
-
-/**
- * attrib_t::vertices => 3 floats per vertex
-
-       v[0]        v[1]        v[2]        v[3]               v[n-1]
-  +-----------+-----------+-----------+-----------+      +-----------+
-  | x | y | z | x | y | z | x | y | z | x | y | z | .... | x | y | z |
-  +-----------+-----------+-----------+-----------+      +-----------+
-
-attrib_t::normals => 3 floats per vertex
-
-       n[0]        n[1]        n[2]        n[3]               n[n-1]
-  +-----------+-----------+-----------+-----------+      +-----------+
-  | x | y | z | x | y | z | x | y | z | x | y | z | .... | x | y | z |
-  +-----------+-----------+-----------+-----------+      +-----------+
-
-attrib_t::texcoords => 2 floats per vertex
-
-       t[0]        t[1]        t[2]        t[3]               t[n-1]
-  +-----------+-----------+-----------+-----------+      +-----------+
-  |  u  |  v  |  u  |  v  |  u  |  v  |  u  |  v  | .... |  u  |  v  |
-  +-----------+-----------+-----------+-----------+      +-----------+
-
-attrib_t::colors => 3 floats per vertex(vertex color. optional)
-
-       c[0]        c[1]        c[2]        c[3]               c[n-1]
-  +-----------+-----------+-----------+-----------+      +-----------+
-  | x | y | z | x | y | z | x | y | z | x | y | z | .... | x | y | z |
-  +-----------+-----------+-----------+-----------+      +-----------+
-/*
+#define TINYOBJLOADER_IMPLEMENTATION // define this in only *one* .cc
+#include "tiny_obj_loader.h"
+
+std::string inputfile = "cornell_box.obj";
+tinyobj::attrib_t attrib;
+std::vector<tinyobj::shape_t> shapes;
+std::vector<tinyobj::material_t> materials;
+
+std::string warn;
+std::string err;
+bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, inputfile.c_str());
+  
+if (!err.empty()) { // `err` may contain warning message.
+  std::cerr << err << std::endl;
+}
+
+if (!ret) {
+  exit(1);
+}
+
+// Loop over shapes
+for (size_t s = 0; s < shapes.size(); s++) {
+  // Loop over faces(polygon)
+  size_t index_offset = 0;
+  for (size_t f = 0; f < shapes[s].mesh.num_face_vertices.size(); f++) {
+    int fv = shapes[s].mesh.num_face_vertices[f];
+
+    // Loop over vertices in the face.
+    for (size_t v = 0; v < fv; v++) {
+      // access to vertex
+      tinyobj::index_t idx = shapes[s].mesh.indices[index_offset + v];
+      tinyobj::real_t vx = attrib.vertices[3*idx.vertex_index+0];
+      tinyobj::real_t vy = attrib.vertices[3*idx.vertex_index+1];
+      tinyobj::real_t vz = attrib.vertices[3*idx.vertex_index+2];
+      tinyobj::real_t nx = attrib.normals[3*idx.normal_index+0];
+      tinyobj::real_t ny = attrib.normals[3*idx.normal_index+1];
+      tinyobj::real_t nz = attrib.normals[3*idx.normal_index+2];
+      tinyobj::real_t tx = attrib.texcoords[2*idx.texcoord_index+0];
+      tinyobj::real_t ty = attrib.texcoords[2*idx.texcoord_index+1];
+      // Optional: vertex colors
+      // tinyobj::real_t red = attrib.colors[3*idx.vertex_index+0];
+      // tinyobj::real_t green = attrib.colors[3*idx.vertex_index+1];
+      // tinyobj::real_t blue = attrib.colors[3*idx.vertex_index+2];
+    }
+    index_offset += fv;
+
+    // per-face material
+    shapes[s].mesh.material_ids[f];
+  }
+}
+
+/**
+ * attrib_t::vertices => 3 floats per vertex
+
+       v[0]        v[1]        v[2]        v[3]               v[n-1]
+  +-----------+-----------+-----------+-----------+      +-----------+
+  | x | y | z | x | y | z | x | y | z | x | y | z | .... | x | y | z |
+  +-----------+-----------+-----------+-----------+      +-----------+
+
+attrib_t::normals => 3 floats per vertex
+
+       n[0]        n[1]        n[2]        n[3]               n[n-1]
+  +-----------+-----------+-----------+-----------+      +-----------+
+  | x | y | z | x | y | z | x | y | z | x | y | z | .... | x | y | z |
+  +-----------+-----------+-----------+-----------+      +-----------+
+
+attrib_t::texcoords => 2 floats per vertex
+
+       t[0]        t[1]        t[2]        t[3]               t[n-1]
+  +-----------+-----------+-----------+-----------+      +-----------+
+  |  u  |  v  |  u  |  v  |  u  |  v  |  u  |  v  | .... |  u  |  v  |
+  +-----------+-----------+-----------+-----------+      +-----------+
+
+attrib_t::colors => 3 floats per vertex(vertex color. optional)
+
+       c[0]        c[1]        c[2]        c[3]               c[n-1]
+  +-----------+-----------+-----------+-----------+      +-----------+
+  | x | y | z | x | y | z | x | y | z | x | y | z | .... | x | y | z |
+  +-----------+-----------+-----------+-----------+      +-----------+
+/*

legacy/include/KHR/khrplatform.h

@@ -0,0 +1,282 @@
+#ifndef __khrplatform_h_
+#define __khrplatform_h_
+
+/*
+** Copyright (c) 2008-2018 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be included
+** in all copies or substantial portions of the Materials.
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Khronos platform-specific types and definitions.
+ *
+ * The master copy of khrplatform.h is maintained in the Khronos EGL
+ * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+ * The last semantic modification to khrplatform.h was at commit ID:
+ *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
+ *
+ * Adopters may modify this file to suit their platform. Adopters are
+ * encouraged to submit platform specific modifications to the Khronos
+ * group so that they can be included in future versions of this file.
+ * Please submit changes by filing pull requests or issues on
+ * the EGL Registry repository linked above.
+ *
+ *
+ * See the Implementer's Guidelines for information about where this file
+ * should be located on your system and for more details of its use:
+ *    http://www.khronos.org/registry/implementers_guide.pdf
+ *
+ * This file should be included as
+ *        #include <KHR/khrplatform.h>
+ * by Khronos client API header files that use its types and defines.
+ *
+ * The types in khrplatform.h should only be used to define API-specific types.
+ *
+ * Types defined in khrplatform.h:
+ *    khronos_int8_t              signed   8  bit
+ *    khronos_uint8_t             unsigned 8  bit
+ *    khronos_int16_t             signed   16 bit
+ *    khronos_uint16_t            unsigned 16 bit
+ *    khronos_int32_t             signed   32 bit
+ *    khronos_uint32_t            unsigned 32 bit
+ *    khronos_int64_t             signed   64 bit
+ *    khronos_uint64_t            unsigned 64 bit
+ *    khronos_intptr_t            signed   same number of bits as a pointer
+ *    khronos_uintptr_t           unsigned same number of bits as a pointer
+ *    khronos_ssize_t             signed   size
+ *    khronos_usize_t             unsigned size
+ *    khronos_float_t             signed   32 bit floating point
+ *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
+ *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
+ *                                         nanoseconds
+ *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
+ *    khronos_boolean_enum_t      enumerated boolean type. This should
+ *      only be used as a base type when a client API's boolean type is
+ *      an enum. Client APIs which use an integer or other type for
+ *      booleans cannot use this as the base type for their boolean.
+ *
+ * Tokens defined in khrplatform.h:
+ *
+ *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
+ *
+ *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
+ *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
+ *
+ * Calling convention macros defined in this file:
+ *    KHRONOS_APICALL
+ *    KHRONOS_APIENTRY
+ *    KHRONOS_APIATTRIBUTES
+ *
+ * These may be used in function prototypes as:
+ *
+ *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
+ *                                  int arg1,
+ *                                  int arg2) KHRONOS_APIATTRIBUTES;
+ */
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APICALL
+ *-------------------------------------------------------------------------
+ * This precedes the return type of the function in the function prototype.
+ */
+#if defined(_WIN32) && !defined(__SCITECH_SNAP__)
+#   define KHRONOS_APICALL __declspec(dllimport)
+#elif defined (__SYMBIAN32__)
+#   define KHRONOS_APICALL IMPORT_C
+#elif defined(__ANDROID__)
+#   define KHRONOS_APICALL __attribute__((visibility("default")))
+#else
+#   define KHRONOS_APICALL
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIENTRY
+ *-------------------------------------------------------------------------
+ * This follows the return type of the function  and precedes the function
+ * name in the function prototype.
+ */
+#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
+    /* Win32 but not WinCE */
+#   define KHRONOS_APIENTRY __stdcall
+#else
+#   define KHRONOS_APIENTRY
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIATTRIBUTES
+ *-------------------------------------------------------------------------
+ * This follows the closing parenthesis of the function prototype arguments.
+ */
+#if defined (__ARMCC_2__)
+#define KHRONOS_APIATTRIBUTES __softfp
+#else
+#define KHRONOS_APIATTRIBUTES
+#endif
+
+/*-------------------------------------------------------------------------
+ * basic type definitions
+ *-----------------------------------------------------------------------*/
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
+
+
+/*
+ * Using <stdint.h>
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__VMS ) || defined(__sgi)
+
+/*
+ * Using <inttypes.h>
+ */
+#include <inttypes.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
+
+/*
+ * Win32
+ */
+typedef __int32                 khronos_int32_t;
+typedef unsigned __int32        khronos_uint32_t;
+typedef __int64                 khronos_int64_t;
+typedef unsigned __int64        khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__sun__) || defined(__digital__)
+
+/*
+ * Sun or Digital
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#if defined(__arch64__) || defined(_LP64)
+typedef long int                khronos_int64_t;
+typedef unsigned long int       khronos_uint64_t;
+#else
+typedef long long int           khronos_int64_t;
+typedef unsigned long long int  khronos_uint64_t;
+#endif /* __arch64__ */
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif 0
+
+/*
+ * Hypothetical platform with no float or int64 support
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#define KHRONOS_SUPPORT_INT64   0
+#define KHRONOS_SUPPORT_FLOAT   0
+
+#else
+
+/*
+ * Generic fallback
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#endif
+
+
+/*
+ * Types that are (so far) the same on all platforms
+ */
+typedef signed   char          khronos_int8_t;
+typedef unsigned char          khronos_uint8_t;
+typedef signed   short int     khronos_int16_t;
+typedef unsigned short int     khronos_uint16_t;
+
+/*
+ * Types that differ between LLP64 and LP64 architectures - in LLP64,
+ * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
+ * to be the only LLP64 architecture in current use.
+ */
+#ifdef _WIN64
+typedef signed   long long int khronos_intptr_t;
+typedef unsigned long long int khronos_uintptr_t;
+typedef signed   long long int khronos_ssize_t;
+typedef unsigned long long int khronos_usize_t;
+#else
+typedef signed   long  int     khronos_intptr_t;
+typedef unsigned long  int     khronos_uintptr_t;
+typedef signed   long  int     khronos_ssize_t;
+typedef unsigned long  int     khronos_usize_t;
+#endif
+
+#if KHRONOS_SUPPORT_FLOAT
+/*
+ * Float type
+ */
+typedef          float         khronos_float_t;
+#endif
+
+#if KHRONOS_SUPPORT_INT64
+/* Time types
+ *
+ * These types can be used to represent a time interval in nanoseconds or
+ * an absolute Unadjusted System Time.  Unadjusted System Time is the number
+ * of nanoseconds since some arbitrary system event (e.g. since the last
+ * time the system booted).  The Unadjusted System Time is an unsigned
+ * 64 bit value that wraps back to 0 every 584 years.  Time intervals
+ * may be either signed or unsigned.
+ */
+typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
+typedef khronos_int64_t        khronos_stime_nanoseconds_t;
+#endif
+
+/*
+ * Dummy value used to pad enum types to 32 bits.
+ */
+#ifndef KHRONOS_MAX_ENUM
+#define KHRONOS_MAX_ENUM 0x7FFFFFFF
+#endif
+
+/*
+ * Enumerated boolean type
+ *
+ * Values other than zero should be considered to be true.  Therefore
+ * comparisons should not be made against KHRONOS_TRUE.
+ */
+typedef enum {
+    KHRONOS_FALSE = 0,
+    KHRONOS_TRUE  = 1,
+    KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
+} khronos_boolean_enum_t;
+
+#endif /* __khrplatform_h_ */

legacy/include/logger.h

@@ -0,0 +1,154 @@
+#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
+	static HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
+	static WORD wOldColorAttrs;
+	static 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:
+	static void resetColour();
+
+	template<typename 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_LIGHT_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();
+
+	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
+
+#ifdef LOGGER_DEFINITION
+#undef LOGGER_DEFINITION
+
+void Colour::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
+}
+
+Logger::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";
+}
+
+#endif

legacy/really-legacy/main.cpp

@@ -1,237 +1,237 @@
-// General includes
-#include <chrono>
-#include <vector>
-
-// GL includes
-#include <glad/glad.hpp>
-
-// SDL includes different on windows
-// the way i have it set up so i gotta
-// do it like this unfortunately 
-#if _WIN32
-#include <SDL.h>
-#else
-#include <SDL2/SDL.h>
-#endif
-
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#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 << "----- ©Benjamin Kyd 2019 ----" << std::endl;
-	std::cout << "-----------------------------" << std::endl;
-	std::cout << std::endl;
-
-	// Get global variables ready
-	Logger logger;
-	SDL_Window* window = nullptr;
-	SDL_GLContext glContext;
-	bool isWindowOpen = false;
-
-	// Initialize SDL and OpenGL
-	// isWindowOpen = init(logger, window, glContext);
-	SDL_Init(SDL_INIT_EVERYTHING);
-
-	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
-	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
-	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
-	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
-	SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
-	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-
-	// MXAA
-	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
-	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
-	SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "4");
-
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
-
-	window = SDL_CreateWindow("OpenGL Playground V1.0",
-		SDL_WINDOWPOS_CENTERED,
-		SDL_WINDOWPOS_CENTERED,
-		// 640, 480,
-		1280, 720,
-		SDL_WINDOW_OPENGL);
-	glContext = SDL_GL_CreateContext(window);
-	SDL_GL_SetSwapInterval(1);
-
-	gladLoadGLLoader(SDL_GL_GetProcAddress);
-	// SDL_SetRelativeMouseMode(SDL_TRUE);
-	// SDL_WarpMouseInWindow(window, 0, 0);
-
-	isWindowOpen = true;
-
-	logger << LOGGER_INFO << "OpenGL and SDL initialized" << LOGGER_ENDL;
-
-	// Load an object into system memory
-	std::vector<glm::vec3> vertices;
-	std::vector<glm::vec3> normals;
-	std::vector<GLushort> elements;
-
-	// LoadOBJ(logger, "./resources/dragon.obj", vertices, normals, elements);
-	LoadOBJ(logger, "./resources/lucy.obj", vertices, normals, elements);
-	// LoadOBJ(logger, "./resources/donut.obj", vertices, normals, elements);
-
-	std::vector<glm::vec3> toGPU;
-	toGPU.insert(toGPU.end(), vertices.begin(), vertices.end());
-	toGPU.insert(toGPU.end(), normals.begin(), normals.end());
-
-	// 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, toGPU.size() * sizeof(glm::vec3), &toGPU[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/phong").attatch().link().use();
-
-	GLint posAttrib = glGetAttribLocation(simpleShader.getProgram(), "position");
-	glEnableVertexAttribArray(posAttrib);
-	glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, 0, 0);
-
-	GLint normalAttrib = glGetAttribLocation(simpleShader.getProgram(), "normal");
-	glEnableVertexAttribArray(normalAttrib);
-	glVertexAttribPointer(normalAttrib, 3, GL_FLOAT, GL_FALSE, 0, (const void*)(vertices.size() * sizeof(glm::vec3)));
-
-	// Set up camera
-	// Camera camera(glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, -90.0f, 0.0f), 45.0f, 640.0f / 480.0f, 0.1f, 1000.0f);
-
-
-	// Model matrice
-	glm::mat4 model = glm::mat4(1.0f);
-	model = glm::translate(model, { -170.0f, -170.0f, -170.0f });
-	model = glm::rotate(model, glm::radians(-160.0f), glm::vec3(0.0f, 1.0f, 0.0f));
-	// Gets uniform for model matrice, to be used later
-	GLint uniTrans = glGetUniformLocation(simpleShader.getProgram(), "model");
-	glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
-
-
-	// View matrice
-	glm::mat4 view = glm::lookAt(
-		glm::vec3(1.0f, 1.0f, 1.0f),
-		glm::vec3(0.0f, 0.4f, 0.0f),
-		glm::vec3(0.0f, 1.0f, 0.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);//camera.perspective;
-	// Get uniform and send it to the GPU
-	GLint uniProj = glGetUniformLocation(simpleShader.getProgram(), "proj");
-	glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
-
-
-	glm::vec3 lightPos = { -2.0f, 4.0f, -1.0f };
-
-	GLint uniLight = glGetUniformLocation(simpleShader.getProgram(), "lightpos");
-	glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(lightPos));
-
-	simpleShader.use();
-	glEnable(GL_DEPTH_TEST);
-	glEnable(GL_MULTISAMPLE);
-
-	SDL_Event event;
-	logger << LOGGER_ENDL;
-	while (isWindowOpen) {
-		FPSCount(logger);
-
-		// Update tick (60ups)
-		if (UPSTimer()) {
-			const Uint8 *state = SDL_GetKeyboardState(NULL);
-			
-			if (state[SDL_SCANCODE_Q]) {
-				model = glm::rotate(model, glm::radians(-1.5f), glm::vec3(0.0f, 1.0f, 0.0f));
-				glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
-			}
-
-			if (state[SDL_SCANCODE_E]) {
-				model = glm::rotate(model, glm::radians(1.5f), glm::vec3(0.0f, 1.0f, 0.0f));
-				glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
-			}
-
-			UpdateClock = SDL_GetTicks();
-		}
-
-		// Handle events
-		while (SDL_PollEvent(&event) != 0) {
-			if (event.type == SDL_QUIT || event.key.keysym.sym == SDLK_ESCAPE)
-				isWindowOpen = false;
-			if (event.key.keysym.sym == SDLK_r) {
-				simpleShader.reload();
-
-				posAttrib = glGetAttribLocation(simpleShader.getProgram(), "position");
-				glEnableVertexAttribArray(posAttrib);
-				glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, 0, 0);
-
-				normalAttrib = glGetAttribLocation(simpleShader.getProgram(), "normal");
-				glEnableVertexAttribArray(normalAttrib);
-				glVertexAttribPointer(normalAttrib, 3, GL_FLOAT, GL_FALSE, 0, (const void*)(vertices.size() * sizeof(glm::vec3)));
-
-				uniTrans = glGetUniformLocation(simpleShader.getProgram(), "model");
-				glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
-				
-				uniView = glGetUniformLocation(simpleShader.getProgram(), "view");
-				glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(view));
-
-				uniProj = glGetUniformLocation(simpleShader.getProgram(), "proj");
-				glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
-
-				uniLight = glGetUniformLocation(simpleShader.getProgram(), "lightpos");
-				glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(lightPos));
-			}
-			if (event.type == SDL_MOUSEMOTION) {
-				int mouseX = event.motion.xrel;
-				int mouseY = event.motion.yrel;
-				// camera.rot.y += mouseX * 0.5f;
-				// camera.rot.x += mouseY * -0.5f;
-			}
-		}
-
-
-		glViewport(0, 0, 1280, 720);
-		glBindFramebuffer(GL_FRAMEBUFFER, 0);
-		glClear(GL_DEPTH_BUFFER_BIT);
-		const float clear[] = {0.1f, 0.45f, 0.9f, 1.0f};
-		glClearBufferfv(GL_COLOR, 0, clear);
-		simpleShader.use();
-
-		glDrawElements(GL_TRIANGLES, elements.size(), GL_UNSIGNED_SHORT, 0);
-
-		// Swap
-		SDL_GL_SwapWindow(window);
-	}
-
-	return 0;
-}
+// General includes
+#include <chrono>
+#include <vector>
+
+// GL includes
+#include <glad/glad.hpp>
+
+// SDL includes different on windows
+// the way i have it set up so i gotta
+// do it like this unfortunately 
+#if _WIN32
+#include <SDL.h>
+#else
+#include <SDL2/SDL.h>
+#endif
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#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 << "----- ©Benjamin Kyd 2019 ----" << std::endl;
+	std::cout << "-----------------------------" << std::endl;
+	std::cout << std::endl;
+
+	// Get global variables ready
+	Logger logger;
+	SDL_Window* window = nullptr;
+	SDL_GLContext glContext;
+	bool isWindowOpen = false;
+
+	// Initialize SDL and OpenGL
+	// isWindowOpen = init(logger, window, glContext);
+	SDL_Init(SDL_INIT_EVERYTHING);
+
+	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
+	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+	// MXAA
+	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
+	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
+	SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "4");
+
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
+
+	window = SDL_CreateWindow("OpenGL Playground V1.0",
+		SDL_WINDOWPOS_CENTERED,
+		SDL_WINDOWPOS_CENTERED,
+		// 640, 480,
+		1280, 720,
+		SDL_WINDOW_OPENGL);
+	glContext = SDL_GL_CreateContext(window);
+	SDL_GL_SetSwapInterval(1);
+
+	gladLoadGLLoader(SDL_GL_GetProcAddress);
+	// SDL_SetRelativeMouseMode(SDL_TRUE);
+	// SDL_WarpMouseInWindow(window, 0, 0);
+
+	isWindowOpen = true;
+
+	logger << LOGGER_INFO << "OpenGL and SDL initialized" << LOGGER_ENDL;
+
+	// Load an object into system memory
+	std::vector<glm::vec3> vertices;
+	std::vector<glm::vec3> normals;
+	std::vector<GLushort> elements;
+
+	// LoadOBJ(logger, "./resources/dragon.obj", vertices, normals, elements);
+	LoadOBJ(logger, "./resources/lucy.obj", vertices, normals, elements);
+	// LoadOBJ(logger, "./resources/donut.obj", vertices, normals, elements);
+
+	std::vector<glm::vec3> toGPU;
+	toGPU.insert(toGPU.end(), vertices.begin(), vertices.end());
+	toGPU.insert(toGPU.end(), normals.begin(), normals.end());
+
+	// 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, toGPU.size() * sizeof(glm::vec3), &toGPU[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/phong").attatch().link().use();
+
+	GLint posAttrib = glGetAttribLocation(simpleShader.getProgram(), "position");
+	glEnableVertexAttribArray(posAttrib);
+	glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, 0, 0);
+
+	GLint normalAttrib = glGetAttribLocation(simpleShader.getProgram(), "normal");
+	glEnableVertexAttribArray(normalAttrib);
+	glVertexAttribPointer(normalAttrib, 3, GL_FLOAT, GL_FALSE, 0, (const void*)(vertices.size() * sizeof(glm::vec3)));
+
+	// Set up camera
+	// Camera camera(glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, -90.0f, 0.0f), 45.0f, 640.0f / 480.0f, 0.1f, 1000.0f);
+
+
+	// Model matrice
+	glm::mat4 model = glm::mat4(1.0f);
+	model = glm::translate(model, { -170.0f, -170.0f, -170.0f });
+	model = glm::rotate(model, glm::radians(-160.0f), glm::vec3(0.0f, 1.0f, 0.0f));
+	// Gets uniform for model matrice, to be used later
+	GLint uniTrans = glGetUniformLocation(simpleShader.getProgram(), "model");
+	glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
+
+
+	// View matrice
+	glm::mat4 view = glm::lookAt(
+		glm::vec3(1.0f, 1.0f, 1.0f),
+		glm::vec3(0.0f, 0.4f, 0.0f),
+		glm::vec3(0.0f, 1.0f, 0.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);//camera.perspective;
+	// Get uniform and send it to the GPU
+	GLint uniProj = glGetUniformLocation(simpleShader.getProgram(), "proj");
+	glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
+
+
+	glm::vec3 lightPos = { -2.0f, 4.0f, -1.0f };
+
+	GLint uniLight = glGetUniformLocation(simpleShader.getProgram(), "lightpos");
+	glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(lightPos));
+
+	simpleShader.use();
+	glEnable(GL_DEPTH_TEST);
+	glEnable(GL_MULTISAMPLE);
+
+	SDL_Event event;
+	logger << LOGGER_ENDL;
+	while (isWindowOpen) {
+		FPSCount(logger);
+
+		// Update tick (60ups)
+		if (UPSTimer()) {
+			const Uint8 *state = SDL_GetKeyboardState(NULL);
+			
+			if (state[SDL_SCANCODE_Q]) {
+				model = glm::rotate(model, glm::radians(-1.5f), glm::vec3(0.0f, 1.0f, 0.0f));
+				glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
+			}
+
+			if (state[SDL_SCANCODE_E]) {
+				model = glm::rotate(model, glm::radians(1.5f), glm::vec3(0.0f, 1.0f, 0.0f));
+				glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
+			}
+
+			UpdateClock = SDL_GetTicks();
+		}
+
+		// Handle events
+		while (SDL_PollEvent(&event) != 0) {
+			if (event.type == SDL_QUIT || event.key.keysym.sym == SDLK_ESCAPE)
+				isWindowOpen = false;
+			if (event.key.keysym.sym == SDLK_r) {
+				simpleShader.reload();
+
+				posAttrib = glGetAttribLocation(simpleShader.getProgram(), "position");
+				glEnableVertexAttribArray(posAttrib);
+				glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, 0, 0);
+
+				normalAttrib = glGetAttribLocation(simpleShader.getProgram(), "normal");
+				glEnableVertexAttribArray(normalAttrib);
+				glVertexAttribPointer(normalAttrib, 3, GL_FLOAT, GL_FALSE, 0, (const void*)(vertices.size() * sizeof(glm::vec3)));
+
+				uniTrans = glGetUniformLocation(simpleShader.getProgram(), "model");
+				glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
+				
+				uniView = glGetUniformLocation(simpleShader.getProgram(), "view");
+				glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(view));
+
+				uniProj = glGetUniformLocation(simpleShader.getProgram(), "proj");
+				glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
+
+				uniLight = glGetUniformLocation(simpleShader.getProgram(), "lightpos");
+				glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(lightPos));
+			}
+			if (event.type == SDL_MOUSEMOTION) {
+				int mouseX = event.motion.xrel;
+				int mouseY = event.motion.yrel;
+				// camera.rot.y += mouseX * 0.5f;
+				// camera.rot.x += mouseY * -0.5f;
+			}
+		}
+
+
+		glViewport(0, 0, 1280, 720);
+		glBindFramebuffer(GL_FRAMEBUFFER, 0);
+		glClear(GL_DEPTH_BUFFER_BIT);
+		const float clear[] = {0.1f, 0.45f, 0.9f, 1.0f};
+		glClearBufferfv(GL_COLOR, 0, clear);
+		simpleShader.use();
+
+		glDrawElements(GL_TRIANGLES, elements.size(), GL_UNSIGNED_SHORT, 0);
+
+		// Swap
+		SDL_GL_SwapWindow(window);
+	}
+
+	return 0;
+}

legacy/really-legacy/object.cpp

@@ -1,58 +1,58 @@
-#include "object.h"
-
-#include <fstream>
-
-// https://en.wikibooks.org/wiki/OpenGL_Programming/Modern_OpenGL_Tutorial_Load_OBJ
-void LoadOBJ(Logger& logger, std::string file, std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& normals, std::vector<GLushort>& elements) {
-    std::ifstream in(file, std::ios::in);
-    if (!in) {
-        logger << LOGGER_ERROR << "Cannot open " << file << LOGGER_ENDL;
-		return;
-    }
-
-    std::string line;
-    while (getline(in, line)) {
-        if (line.substr(0,2) == "v ") {
-            std::istringstream s(line.substr(2));
-            glm::vec3 v; s >> v.x; s >> v.y; s >> v.z;
-            vertices.push_back(v);
-        } else if (line.substr(0,2) == "f ") {
-            std::istringstream s(line.substr(2));
-            GLushort a,b,c;
-            s >> a; s >> b; s >> c;
-            a--; b--; c--;
-            elements.push_back(a); elements.push_back(b); elements.push_back(c);
-        } else if (line[0] == '#') { }
-        else {} 
-    }
-
-   normals.resize(vertices.size(), glm::vec3(0.0, 0.0, 0.0));
-   for (int i = 0; i < elements.size(); i += 3) {
-       GLushort ia = elements[i];
-       GLushort ib = elements[i+1];
-       GLushort ic = elements[i+2];
-       glm::vec3 normal = glm::normalize(glm::cross(
-       glm::vec3(vertices[ib]) - glm::vec3(vertices[ia]),
-       glm::vec3(vertices[ic]) - glm::vec3(vertices[ia])));
-       normals[ia] = normals[ib] = normals[ic] = normal;
-   }
-
-    logger << LOGGER_INFO << "Loaded OBJ: " << file << LOGGER_ENDL;
-}
-
-void FlatShade(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& normals, std::vector<GLushort>& elements) {
-    std::vector<glm::vec3> shared_vertices;
-    for (int i = 0; i < elements.size(); i++) {
-        vertices.push_back(shared_vertices[elements[i]]);
-        if ((i % 3) == 2) {
-            GLushort ia = elements[i-2];
-            GLushort ib = elements[i-1];
-            GLushort ic = elements[i];
-            glm::vec3 normal = glm::normalize(glm::cross(
-                shared_vertices[ic] - shared_vertices[ia],
-            shared_vertices[ib] - shared_vertices[ia]));
-            for (int n = 0; n < 3; n++)
-            normals.push_back(normal);
-        }
-    }
-}
+#include "object.h"
+
+#include <fstream>
+
+// https://en.wikibooks.org/wiki/OpenGL_Programming/Modern_OpenGL_Tutorial_Load_OBJ
+void LoadOBJ(Logger& logger, std::string file, std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& normals, std::vector<GLushort>& elements) {
+    std::ifstream in(file, std::ios::in);
+    if (!in) {
+        logger << LOGGER_ERROR << "Cannot open " << file << LOGGER_ENDL;
+		return;
+    }
+
+    std::string line;
+    while (getline(in, line)) {
+        if (line.substr(0,2) == "v ") {
+            std::istringstream s(line.substr(2));
+            glm::vec3 v; s >> v.x; s >> v.y; s >> v.z;
+            vertices.push_back(v);
+        } else if (line.substr(0,2) == "f ") {
+            std::istringstream s(line.substr(2));
+            GLushort a,b,c;
+            s >> a; s >> b; s >> c;
+            a--; b--; c--;
+            elements.push_back(a); elements.push_back(b); elements.push_back(c);
+        } else if (line[0] == '#') { }
+        else {} 
+    }
+
+   normals.resize(vertices.size(), glm::vec3(0.0, 0.0, 0.0));
+   for (int i = 0; i < elements.size(); i += 3) {
+       GLushort ia = elements[i];
+       GLushort ib = elements[i+1];
+       GLushort ic = elements[i+2];
+       glm::vec3 normal = glm::normalize(glm::cross(
+       glm::vec3(vertices[ib]) - glm::vec3(vertices[ia]),
+       glm::vec3(vertices[ic]) - glm::vec3(vertices[ia])));
+       normals[ia] = normals[ib] = normals[ic] = normal;
+   }
+
+    logger << LOGGER_INFO << "Loaded OBJ: " << file << LOGGER_ENDL;
+}
+
+void FlatShade(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& normals, std::vector<GLushort>& elements) {
+    std::vector<glm::vec3> shared_vertices;
+    for (int i = 0; i < elements.size(); i++) {
+        vertices.push_back(shared_vertices[elements[i]]);
+        if ((i % 3) == 2) {
+            GLushort ia = elements[i-2];
+            GLushort ib = elements[i-1];
+            GLushort ic = elements[i];
+            glm::vec3 normal = glm::normalize(glm::cross(
+                shared_vertices[ic] - shared_vertices[ia],
+            shared_vertices[ib] - shared_vertices[ia]));
+            for (int n = 0; n < 3; n++)
+            normals.push_back(normal);
+        }
+    }
+}

legacy/really-legacy/object.h

@@ -1,33 +1,33 @@
-#ifndef SRC_OBJECT_H_
-#define SRC_OBJECT_H_
-
-// General includes
-#include <vector>
-
-// GL includes
-#include <glad/glad.hpp>
-
-#if _WIN32
-#include <SDL.h>
-#else
-#include <SDL2/SDL.h>
-#endif
-
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtc/type_ptr.hpp>
-
-// Custom includes
-#include <logger.h>
-
-void LoadOBJ(Logger& logger, 
-             std::string file,
-             std::vector<glm::vec3>& vertices,
-             std::vector<glm::vec3>& normals,
-             std::vector<GLushort>& elements);
-
-void FlatShade(std::vector<glm::vec3>& vertices,
-               std::vector<glm::vec3>& normals,
-               std::vector<GLushort>& elements);
-
-#endif
+#ifndef SRC_OBJECT_H_
+#define SRC_OBJECT_H_
+
+// General includes
+#include <vector>
+
+// GL includes
+#include <glad/glad.hpp>
+
+#if _WIN32
+#include <SDL.h>
+#else
+#include <SDL2/SDL.h>
+#endif
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+// Custom includes
+#include <logger.h>
+
+void LoadOBJ(Logger& logger, 
+             std::string file,
+             std::vector<glm::vec3>& vertices,
+             std::vector<glm::vec3>& normals,
+             std::vector<GLushort>& elements);
+
+void FlatShade(std::vector<glm::vec3>& vertices,
+               std::vector<glm::vec3>& normals,
+               std::vector<GLushort>& elements);
+
+#endif

legacy/really-legacy/resources/shaders/phong.frag

@@ -1,39 +1,39 @@
-#version 330
-
-in vec3 Normal;
-in vec3 FragPos;
-// in vec4 FragPosLightSpace;
-
-uniform vec3 lightPos;
-
-out vec4 outColour;
-
-vec3 viewPos = vec3(0.0, 0.0, 0.0);
-vec3 objectColour = vec3(1.0, 1.0, 1.0);
-vec3 lightColour = vec3(0.7, 0.0, 0.65);
-// vec3 lightColour = vec3(0.3, 0.85, 1.0);
-
-void main() {
-    vec3 normal = normalize(Normal);
-    vec3 lightDir = normalize(lightPos - FragPos);
-
-    float diff = max(dot(normal, lightDir), 0.0);
-    vec3 diffuse = diff * lightColour;
-
-
-    float specularStrength = 0;
-
-    vec3 viewDir = normalize(viewPos - FragPos);
-    vec3 reflectDir = reflect(-lightDir, normal);
-
-    float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32);
-    vec3 specular = specularStrength * spec * lightColour;
-
-
-    float ambientStrength = 0.4;
-    vec3 ambient = ambientStrength * lightColour;
-
-    vec3 result = (ambient + diffuse + specular) * objectColour;   
-
-    outColour = vec4(result, 1.0);
-}
+#version 330
+
+in vec3 Normal;
+in vec3 FragPos;
+// in vec4 FragPosLightSpace;
+
+uniform vec3 lightPos;
+
+out vec4 outColour;
+
+vec3 viewPos = vec3(0.0, 0.0, 0.0);
+vec3 objectColour = vec3(1.0, 1.0, 1.0);
+vec3 lightColour = vec3(0.7, 0.0, 0.65);
+// vec3 lightColour = vec3(0.3, 0.85, 1.0);
+
+void main() {
+    vec3 normal = normalize(Normal);
+    vec3 lightDir = normalize(lightPos - FragPos);
+
+    float diff = max(dot(normal, lightDir), 0.0);
+    vec3 diffuse = diff * lightColour;
+
+
+    float specularStrength = 0;
+
+    vec3 viewDir = normalize(viewPos - FragPos);
+    vec3 reflectDir = reflect(-lightDir, normal);
+
+    float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32);
+    vec3 specular = specularStrength * spec * lightColour;
+
+
+    float ambientStrength = 0.4;
+    vec3 ambient = ambientStrength * lightColour;
+
+    vec3 result = (ambient + diffuse + specular) * objectColour;   
+
+    outColour = vec4(result, 1.0);
+}

legacy/really-legacy/resources/shaders/phong.vert

@@ -1,18 +1,18 @@
-#version 330 
-
-layout(location = 0) in vec3 position;
-layout(location = 1) in vec3 normal;
-layout(location = 2) in vec3 texCoord;
-
-out vec3 Normal;
-out vec3 FragPos;
-
-uniform mat4 model;
-uniform mat4 view;
-uniform mat4 proj;
-
-void main() {
-    gl_Position = proj * view * model * vec4(position, 1.0);
-    FragPos = vec3(model * vec4(position, 1.0));
-    Normal = mat3(model) * normal;
-}
+#version 330 
+
+layout(location = 0) in vec3 position;
+layout(location = 1) in vec3 normal;
+layout(location = 2) in vec3 texCoord;
+
+out vec3 Normal;
+out vec3 FragPos;
+
+uniform mat4 model;
+uniform mat4 view;
+uniform mat4 proj;
+
+void main() {
+    gl_Position = proj * view * model * vec4(position, 1.0);
+    FragPos = vec3(model * vec4(position, 1.0));
+    Normal = mat3(model) * normal;
+}

legacy/really-legacy/resources/shaders/simple.frag

@@ -1,7 +1,7 @@
-#version 330
-
-out vec4 outColour;
-
-void main() {
-    outColour = vec4(0.58, 0.61, 0.627, 1.0);
-}
+#version 330
+
+out vec4 outColour;
+
+void main() {
+    outColour = vec4(0.58, 0.61, 0.627, 1.0);
+}

legacy/really-legacy/resources/shaders/simple.vert

@@ -1,11 +1,11 @@
-#version 330 
-
-in vec3 position;
-
-uniform mat4 model;
-uniform mat4 view;
-uniform mat4 proj;
-
-void main() {
-    gl_Position = proj * view * model * vec4(position, 1.0);
-}
+#version 330 
+
+in vec3 position;
+
+uniform mat4 model;
+uniform mat4 view;
+uniform mat4 proj;
+
+void main() {
+    gl_Position = proj * view * model * vec4(position, 1.0);
+}

legacy/really-legacy/shader.cpp

@@ -1,167 +1,167 @@
-#include "shader.h"
-
-#include <iostream>
-#include <fstream>
-
-Shader::Shader(Logger& logger)
-	: logger(logger) {
-    m_program = glCreateProgram();
-}
-
-Shader& Shader::use() {
-    glUseProgram(m_program);
-    return *this;
-}
-
-Shader& Shader::link() {
-    glLinkProgram(m_program);
-    return *this;
-}
-
-Shader& Shader::attatch() {
-    glAttachShader(m_program, m_vert);
-    glAttachShader(m_program, m_frag);
-    return *this;
-}
-
-std::string readShader(std::string source) {
-    std::ifstream t(source);
-    std::string shaderCode((std::istreambuf_iterator<char>(t)),
-                            std::istreambuf_iterator<char>());
-    return shaderCode;
-}
-
-Shader& Shader::load(GLenum type, std::string sourceLoc) {
-    const char* source = readShader(sourceLoc).c_str();
-
-    if (type == GL_VERTEX_SHADER) {
-        m_vertLoc = sourceLoc;
-        m_vertSource = (std::string)source;
-        m_vert = glCreateShader(GL_VERTEX_SHADER);
-        glShaderSource(m_vert, 1, &source, NULL);
-        glCompileShader(m_vert);
-
-        glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
-        if (m_status == GL_FALSE) {
-            char buf[512];
-            glGetShaderInfoLog(m_vert, 512, NULL, buf);
-			logger << LOGGER_ERROR << buf << LOGGER_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;
-        m_frag = glCreateShader(GL_FRAGMENT_SHADER);
-        glShaderSource(m_frag, 1, &source, NULL);
-        glCompileShader(m_frag);
-        
-        glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
-        if (m_status == GL_FALSE) {
-            char buf[512];
-            glGetShaderInfoLog(m_frag, 512, NULL, buf);
-			logger << LOGGER_ERROR << buf << LOGGER_ENDL;
-		}
-
-        logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
-    }
-
-    return *this;
-}
-
-Shader& Shader::load(std::string sourceLoc) {
-    m_vertLoc = sourceLoc + ".vert";
-    m_fragLoc = sourceLoc + ".frag";
-
-    m_vertSource = readShader(m_vertLoc);
-    m_fragSource = readShader(m_fragLoc);
-
-    m_vert = glCreateShader(GL_VERTEX_SHADER);
-    m_frag = glCreateShader(GL_FRAGMENT_SHADER);
-
-    const char* vertSource = m_vertSource.c_str();
-    glShaderSource(m_vert, 1, &vertSource, NULL);
-    glCompileShader(m_vert);
-
-    const char* fragSource = m_fragSource.c_str();
-    glShaderSource(m_frag, 1, &fragSource, NULL);
-    glCompileShader(m_frag);
-
-    glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
-    if (m_status == GL_FALSE) {
-        char buf[512];
-        glGetShaderInfoLog(m_vert, 512, NULL, buf);
-		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);
-		logger << LOGGER_ERROR << buf << LOGGER_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;
-}
-
-Shader& Shader::reload() {
-	glDeleteProgram(m_program);
-	glDeleteShader(m_vert);
-	glDeleteShader(m_frag);
-
-	m_vertSource = readShader(m_vertLoc);
-	m_fragSource = readShader(m_fragLoc);
-
-	m_vert = glCreateShader(GL_VERTEX_SHADER);
-	m_frag = glCreateShader(GL_FRAGMENT_SHADER);
-
-	const char* vertSource = m_vertSource.c_str();
-	glShaderSource(m_vert, 1, &vertSource, NULL);
-	glCompileShader(m_vert);
-
-	const char* fragSource = m_fragSource.c_str();
-	glShaderSource(m_frag, 1, &fragSource, NULL);
-	glCompileShader(m_frag);
-
-	glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
-	if (m_status == GL_FALSE) {
-		char buf[512];
-		glGetShaderInfoLog(m_vert, 512, NULL, buf);
-		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);
-		logger << LOGGER_ERROR << buf << LOGGER_ENDL;
-	}
-
-	logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
-	logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
-
-	link();
-	attatch();
-
-	return *this;
-}
-
-GLuint Shader::getProgram() {
-    return m_program;
-}
-
-GLuint Shader::getVertex() {
-    return m_vert;
-}
-
-GLuint Shader::getFragment() {
-    return m_frag;
-}
-
-Shader::~Shader() {
-    glDeleteProgram(m_program);
-    glDeleteShader(m_vert);
-    glDeleteShader(m_frag);
-}
+#include "shader.h"
+
+#include <iostream>
+#include <fstream>
+
+Shader::Shader(Logger& logger)
+	: logger(logger) {
+    m_program = glCreateProgram();
+}
+
+Shader& Shader::use() {
+    glUseProgram(m_program);
+    return *this;
+}
+
+Shader& Shader::link() {
+    glLinkProgram(m_program);
+    return *this;
+}
+
+Shader& Shader::attatch() {
+    glAttachShader(m_program, m_vert);
+    glAttachShader(m_program, m_frag);
+    return *this;
+}
+
+std::string readShader(std::string source) {
+    std::ifstream t(source);
+    std::string shaderCode((std::istreambuf_iterator<char>(t)),
+                            std::istreambuf_iterator<char>());
+    return shaderCode;
+}
+
+Shader& Shader::load(GLenum type, std::string sourceLoc) {
+    const char* source = readShader(sourceLoc).c_str();
+
+    if (type == GL_VERTEX_SHADER) {
+        m_vertLoc = sourceLoc;
+        m_vertSource = (std::string)source;
+        m_vert = glCreateShader(GL_VERTEX_SHADER);
+        glShaderSource(m_vert, 1, &source, NULL);
+        glCompileShader(m_vert);
+
+        glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
+        if (m_status == GL_FALSE) {
+            char buf[512];
+            glGetShaderInfoLog(m_vert, 512, NULL, buf);
+			logger << LOGGER_ERROR << buf << LOGGER_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;
+        m_frag = glCreateShader(GL_FRAGMENT_SHADER);
+        glShaderSource(m_frag, 1, &source, NULL);
+        glCompileShader(m_frag);
+        
+        glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
+        if (m_status == GL_FALSE) {
+            char buf[512];
+            glGetShaderInfoLog(m_frag, 512, NULL, buf);
+			logger << LOGGER_ERROR << buf << LOGGER_ENDL;
+		}
+
+        logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
+    }
+
+    return *this;
+}
+
+Shader& Shader::load(std::string sourceLoc) {
+    m_vertLoc = sourceLoc + ".vert";
+    m_fragLoc = sourceLoc + ".frag";
+
+    m_vertSource = readShader(m_vertLoc);
+    m_fragSource = readShader(m_fragLoc);
+
+    m_vert = glCreateShader(GL_VERTEX_SHADER);
+    m_frag = glCreateShader(GL_FRAGMENT_SHADER);
+
+    const char* vertSource = m_vertSource.c_str();
+    glShaderSource(m_vert, 1, &vertSource, NULL);
+    glCompileShader(m_vert);
+
+    const char* fragSource = m_fragSource.c_str();
+    glShaderSource(m_frag, 1, &fragSource, NULL);
+    glCompileShader(m_frag);
+
+    glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
+    if (m_status == GL_FALSE) {
+        char buf[512];
+        glGetShaderInfoLog(m_vert, 512, NULL, buf);
+		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);
+		logger << LOGGER_ERROR << buf << LOGGER_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;
+}
+
+Shader& Shader::reload() {
+	glDeleteProgram(m_program);
+	glDeleteShader(m_vert);
+	glDeleteShader(m_frag);
+
+	m_vertSource = readShader(m_vertLoc);
+	m_fragSource = readShader(m_fragLoc);
+
+	m_vert = glCreateShader(GL_VERTEX_SHADER);
+	m_frag = glCreateShader(GL_FRAGMENT_SHADER);
+
+	const char* vertSource = m_vertSource.c_str();
+	glShaderSource(m_vert, 1, &vertSource, NULL);
+	glCompileShader(m_vert);
+
+	const char* fragSource = m_fragSource.c_str();
+	glShaderSource(m_frag, 1, &fragSource, NULL);
+	glCompileShader(m_frag);
+
+	glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
+	if (m_status == GL_FALSE) {
+		char buf[512];
+		glGetShaderInfoLog(m_vert, 512, NULL, buf);
+		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);
+		logger << LOGGER_ERROR << buf << LOGGER_ENDL;
+	}
+
+	logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
+	logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
+
+	link();
+	attatch();
+
+	return *this;
+}
+
+GLuint Shader::getProgram() {
+    return m_program;
+}
+
+GLuint Shader::getVertex() {
+    return m_vert;
+}
+
+GLuint Shader::getFragment() {
+    return m_frag;
+}
+
+Shader::~Shader() {
+    glDeleteProgram(m_program);
+    glDeleteShader(m_vert);
+    glDeleteShader(m_frag);
+}

legacy/really-legacy/shader.h

@@ -1,42 +1,42 @@
-#ifndef SRC_SHADER_H_
-#define SRC_SHADER_H_
-
-#include <glad/glad.hpp>
-#include <string>
-#include <logger.h>
-
-class Shader {
-public:
-	Shader(Logger& logger);
-
-    Shader& use();
-    Shader& link();
-    Shader& attatch();
-    Shader& load(GLenum type, std::string sourceLoc);
-    Shader& load(std::string sourceLoc);
-	Shader& reload();
-
-    GLuint getProgram();
-    GLuint getVertex();
-    GLuint getFragment();
-
-    virtual ~Shader();
-private:
-    Shader(Shader const &) = delete;
-    Shader & operator=(Shader const &) = delete;
-  
-    GLuint m_program;
-    GLuint m_vert;
-    GLuint m_frag;
-
-    std::string m_vertSource;
-    std::string m_fragSource;
-    std::string m_vertLoc;
-    std::string m_fragLoc;
-
-	Logger& logger;
-
-    GLint m_status;
-};
-
-#endif
+#ifndef SRC_SHADER_H_
+#define SRC_SHADER_H_
+
+#include <glad/glad.hpp>
+#include <string>
+#include <logger.h>
+
+class Shader {
+public:
+	Shader(Logger& logger);
+
+    Shader& use();
+    Shader& link();
+    Shader& attatch();
+    Shader& load(GLenum type, std::string sourceLoc);
+    Shader& load(std::string sourceLoc);
+	Shader& reload();
+
+    GLuint getProgram();
+    GLuint getVertex();
+    GLuint getFragment();
+
+    virtual ~Shader();
+private:
+    Shader(Shader const &) = delete;
+    Shader & operator=(Shader const &) = delete;
+  
+    GLuint m_program;
+    GLuint m_vert;
+    GLuint m_frag;
+
+    std::string m_vertSource;
+    std::string m_fragSource;
+    std::string m_vertLoc;
+    std::string m_fragLoc;
+
+	Logger& logger;
+
+    GLint m_status;
+};
+
+#endif

legacy/really-legacy/timers.h

@@ -1,36 +1,36 @@
-#ifndef SRC_TIMERS_H_
-#define SRC_TIMERS_H_
-
-// General includes
-#include <chrono>
-
-// GL includes
-#if _WIN32
-#include <SDL.h>
-#else
-#include <SDL2/SDL.h>
-#endif
-
-// Custom includes
-#include <logger.h>
-
-std::chrono::high_resolution_clock timer;
-auto FPSCalculateLast = timer.now();
-auto FPSClock = SDL_GetTicks();
-
-auto UpdateClock = SDL_GetTicks();
-
-void FPSCount(Logger& logger) {
-    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();
-}
-
-bool UPSTimer() {
-    return (SDL_GetTicks() - UpdateClock >= 10);
-}
-
-#endif
+#ifndef SRC_TIMERS_H_
+#define SRC_TIMERS_H_
+
+// General includes
+#include <chrono>
+
+// GL includes
+#if _WIN32
+#include <SDL.h>
+#else
+#include <SDL2/SDL.h>
+#endif
+
+// Custom includes
+#include <logger.h>
+
+std::chrono::high_resolution_clock timer;
+auto FPSCalculateLast = timer.now();
+auto FPSClock = SDL_GetTicks();
+
+auto UpdateClock = SDL_GetTicks();
+
+void FPSCount(Logger& logger) {
+    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();
+}
+
+bool UPSTimer() {
+    return (SDL_GetTicks() - UpdateClock >= 10);
+}
+
+#endif

legacy/resources/shaders/shadowmap.frag

@@ -1,7 +0,0 @@
-#version 330
-
-out float fragdepth;
-
-void main(){
-    gl_FragDepth = gl_FragCoord.z;
-}

legacy/resources/shaders/shadowmap.vert

@@ -1,10 +0,0 @@
-#version 330
-
-in vec3 vertPos;
-
-uniform mat4 lightSpaceMatrix;
-uniform mat4 model;
-
-void main() {
-    gl_Position = lightSpaceMatrix * model * vec4(vertPos, 1.0);
-}

legacy/src/camera.cpp

@@ -0,0 +1,88 @@
+#include "camera.h"
+
+Camera::Camera() {
+
+}
+
+void Camera::updateView() {
+    //roll can be removed from here. because is not actually used in FPS camera
+    glm::mat4 matRoll  = glm::mat4(1.0f);//identity matrix; 
+    glm::mat4 matPitch = glm::mat4(1.0f);//identity matrix
+    glm::mat4 matYaw   = glm::mat4(1.0f);//identity matrix
+    
+    //roll, pitch and yaw are used to store our angles in our class
+    matRoll  = glm::rotate(matRoll,  roll,  glm::vec3(0.0f, 0.0f, 1.0f));
+    matPitch = glm::rotate(matPitch, pitch, glm::vec3(1.0f, 0.0f, 0.0f));
+    matYaw   = glm::rotate(matYaw,   yaw,   glm::vec3(0.0f, 1.0f, 0.0f));
+    
+    //order matters
+    glm::mat4 rotate = matRoll * matPitch * matYaw;
+    
+    glm::mat4 translate = glm::mat4(1.0f);
+    translate = glm::translate(translate, -eyeVector);
+    
+    viewMatrix = rotate * translate;
+}
+
+glm::mat4 Camera::getViewMatrix() {
+    return viewMatrix;
+}
+
+glm::vec3 Camera::getPos() {
+    return eyeVector;
+}
+
+void Camera::handleMouse(SDL_Event e) {
+    if (e.type != SDL_MOUSEMOTION)
+        return;
+
+
+    float mouseDX = e.motion.xrel;
+    float mouseDY = e.motion.yrel;
+
+    glm::vec2 mouseDelta {mouseDX, mouseDY};
+
+    mouseMoved(mouseDelta);
+}
+
+void Camera::moveCamera() {
+    float dx = 0; //how much we strafe on x
+    float dz = 0; //how much we walk on z
+
+    const Uint8* state = SDL_GetKeyboardState(NULL);
+
+    if (state[SDL_SCANCODE_W])
+        dz += 2;
+    if (state[SDL_SCANCODE_S])
+        dz += -2;
+    if (state[SDL_SCANCODE_A])
+        dx += -2;
+    if (state[SDL_SCANCODE_D])
+        dx += 2;
+    // if (state[SDL_SCANCODE_Z])
+
+    // if (state[SDL_SCANCODE_LSHIFT])
+    
+    
+    //get current view matrix
+    glm::mat4 mat = getViewMatrix();
+    //row major
+    glm::vec3 forward(mat[0][2], mat[1][2], mat[2][2]);
+    glm::vec3 strafe (mat[0][0], mat[1][0], mat[2][0]);
+        
+    //forward vector must be negative to look forward. 
+    //read :http://in2gpu.com/2015/05/17/view-matrix/
+    eyeVector += (-dz * forward + dx * strafe) * cameraSpeed;
+        
+    //update the view matrix
+    updateView();
+}
+
+void Camera::mouseMoved(glm::vec2 mouseDelta) {
+    //note that yaw and pitch must be converted to radians.
+    //this is done in UpdateView() by glm::rotate
+    yaw   += mouseSensitivity * mouseDelta.x;
+    pitch += mouseSensitivity * mouseDelta.y;
+    
+    updateView();
+}

legacy/src/camera.h

@@ -0,0 +1,35 @@
+#ifndef SMHENGINE_SRC_CAMERA_H_
+#define SMHENGINE_SRC_CAMERA_H_
+
+#if _WIN32
+#include <SDL.h>
+#else
+#include <SDL2/SDL.h>
+#endif
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+class Camera {
+public:
+    Camera();
+
+    void updateView();
+    glm::mat4 getViewMatrix();
+    glm::vec3 getPos();
+
+    void handleMouse(SDL_Event e);
+    void moveCamera();
+    void mouseMoved(glm::vec2 mouseDelta);
+
+    float mouseSensitivity = 0.0025f;
+    float cameraSpeed = 1.12f;
+
+private:
+    float roll, pitch, yaw;
+    glm::vec3 eyeVector;
+    glm::mat4 viewMatrix;
+};
+
+#endif

legacy/src/display.cpp

@@ -1,197 +1,209 @@
-#include "display.h"
-
-Display::Display(std::string name, Logger& logger, int w, int h,
-                 SMH_VSYNC_DISPLAY_MODE vsyncMode,
-                 SMH_MXAA_MODE mxaaMode)
-                    : logger(logger) {
-
-    MXAAMode = mxaaMode;
-    VSyncMode = vsyncMode;
-
-    logger << LOGGER_INFO << "Initializing display" << LOGGER_ENDL;
-	SDL_Init(SDL_INIT_EVERYTHING);
-
-	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
-	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
-	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
-	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
-	SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
-	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-
-	// MXAA
-    if (mxaaMode != MXAA_DEFAULT || mxaaMode != MXAA_DISABLED) {
-        int mxaaLevel = 1;
-        std::string smxaaLevel = "1";
-
-        switch (mxaaMode) {
-            case MXAA_ENABLED:
-            case MXAA_2X:
-                mxaaLevel = 2;
-                smxaaLevel = "2";
-                break;
-            case MXAA_4X:
-                mxaaLevel = 4;
-                smxaaLevel = "4";
-                break;
-            case MXAA_8X:
-                mxaaLevel = 8;
-                smxaaLevel = "8";
-                break;
-			case MXAA_16X:
-				mxaaLevel = 16;
-				smxaaLevel = "16";
-				break;
-            default:
-                mxaaLevel = 2;
-                smxaaLevel = "2";
-                break;
-        }
-        
-        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
-        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mxaaLevel);
-        SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, smxaaLevel.c_str());
-        logger << LOGGER_INFO << "MXAA set to " << mxaaLevel << "xMSAA" << LOGGER_ENDL;
-    } else {
-        logger << LOGGER_INFO << "MXAA disabled" << LOGGER_ENDL;
-    }
-
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
-
-    // Create GL window
-    logger << LOGGER_INFO << "Creating window" << LOGGER_ENDL;
-	window = SDL_CreateWindow(name.c_str(),
-		SDL_WINDOWPOS_CENTERED,
-		SDL_WINDOWPOS_CENTERED, w, h,
-		SDL_WINDOW_OPENGL);
-    // Create GL context
-    logger << LOGGER_INFO << "Creating OpenGL context" << LOGGER_ENDL;
-	glContext = SDL_GL_CreateContext(window);
-
-    // Set VSYNC swap interval
-    if (vsyncMode == VSYNC_DEFAULT || vsyncMode == VSYNC_ENABLED) {
-        SDL_GL_SetSwapInterval(1);
-        logger << LOGGER_INFO << "VSync enabled" << LOGGER_ENDL;
-    }
-    if (vsyncMode == VSYNC_DISABLED) {
-        SDL_GL_SetSwapInterval(0);
-        logger << LOGGER_INFO << "VSync disabled" << LOGGER_ENDL;
-    }
-
-    logger << LOGGER_INFO << "Display set up" << LOGGER_ENDL;
-
-    // Load OpenGL
-	gladLoadGLLoader(SDL_GL_GetProcAddress);
-	glEnable(GL_MULTISAMPLE);
-    logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL;
-    logger << LOGGER_ENDL;
-    isClosed = false;
-}
-
-
-
-
-
-Display::Display(std::string name, Logger& logger, int w, int h,
-                 SMH_MXAA_MODE mxaaMode, 
-                 SMH_VSYNC_DISPLAY_MODE vsyncMode)
-                    : logger(logger) {
-
-    MXAAMode = mxaaMode;
-    VSyncMode = vsyncMode;
-
-    logger << LOGGER_INFO << "Initializing display" << LOGGER_ENDL;
-	SDL_Init(SDL_INIT_EVERYTHING);
-
-	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
-	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
-	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
-	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
-	SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
-	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-
-	// MXAA
-    if (mxaaMode != MXAA_DEFAULT || mxaaMode != MXAA_DISABLED) {
-        int mxaaLevel = 1;
-        std::string smxaaLevel = "1";
-
-        switch (mxaaMode) {
-            case MXAA_ENABLED:
-            case MXAA_2X:
-                mxaaLevel = 2;
-                smxaaLevel = "2";
-                break;
-            case MXAA_4X:
-                mxaaLevel = 4;
-                smxaaLevel = "4";
-                break;
-            case MXAA_8X:
-                mxaaLevel = 8;
-                smxaaLevel = "8";
-                break;
-			case MXAA_16X:
-				mxaaLevel = 16;
-				smxaaLevel = "16";
-				break;
-            default:
-                mxaaLevel = 2;
-                smxaaLevel = "2";
-                break;
-        }
-        
-        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
-        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mxaaLevel);
-        SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, smxaaLevel.c_str());
-        logger << LOGGER_INFO << "MXAA set to " << mxaaLevel << "xMSAA" << LOGGER_ENDL;
-    } else {
-        logger << LOGGER_INFO << "MXAA disabled" << LOGGER_ENDL;
-    }
-
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
-
-    // Create GL window
-    logger << LOGGER_INFO << "Creating window" << LOGGER_ENDL;
-	window = SDL_CreateWindow(name.c_str(),
-		SDL_WINDOWPOS_CENTERED,
-		SDL_WINDOWPOS_CENTERED, w, h,
-		SDL_WINDOW_OPENGL);
-    // Create GL context
-    logger << LOGGER_INFO << "Creating OpenGL context" << LOGGER_ENDL;
-	glContext = SDL_GL_CreateContext(window);
-
-    // Set VSYNC swap interval
-    if (vsyncMode == VSYNC_DEFAULT || vsyncMode == VSYNC_ENABLED) {
-        SDL_GL_SetSwapInterval(1);
-        logger << LOGGER_INFO << "VSync enabled" << LOGGER_ENDL;
-    }
-    if (vsyncMode == VSYNC_DISABLED) {
-        SDL_GL_SetSwapInterval(0);
-        logger << LOGGER_INFO << "VSync disabled" << LOGGER_ENDL;
-    }
-
-    logger << LOGGER_INFO << "Display set up" << LOGGER_ENDL;
-
-    // Load OpenGL
-	gladLoadGLLoader(SDL_GL_GetProcAddress);
-	glEnable(GL_MULTISAMPLE);
-    logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL;
-    logger << LOGGER_ENDL;
-    isClosed = false;
-}
-
-void Display::setName(std::string name) {
-    SDL_SetWindowTitle(window, name.c_str());
-}
-
-void Display::update() {
-	SDL_GL_SwapWindow(window);
-
-	glClear(GL_DEPTH_BUFFER_BIT);
-	const float clear[] = { 0.1f, 0.45f, 0.9f, 1.0f };
-	glClearBufferfv(GL_COLOR, 0, clear);
-}
-
-Display::~Display() {
-    SDL_DestroyWindow(window);
-}
+#include "display.h"
+
+Display::Display(std::string name, Logger& logger, int w, int h,
+                 SMH_VSYNC_DISPLAY_MODE vsyncMode,
+                 SMH_MXAA_MODE mxaaMode)
+                    : logger(logger) {
+
+    MXAAMode = mxaaMode;
+    VSyncMode = vsyncMode;
+
+    logger << LOGGER_INFO << "Initializing display" << LOGGER_ENDL;
+	SDL_Init(SDL_INIT_EVERYTHING);
+
+	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
+	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+	// MXAA
+    if (mxaaMode != MXAA_DEFAULT || mxaaMode != MXAA_DISABLED) {
+        int mxaaLevel = 1;
+        std::string smxaaLevel = "1";
+
+        switch (mxaaMode) {
+            case MXAA_ENABLED:
+            case MXAA_2X:
+                mxaaLevel = 2;
+                smxaaLevel = "2";
+                break;
+            case MXAA_4X:
+                mxaaLevel = 4;
+                smxaaLevel = "4";
+                break;
+            case MXAA_8X:
+                mxaaLevel = 8;
+                smxaaLevel = "8";
+                break;
+			case MXAA_16X:
+				mxaaLevel = 16;
+				smxaaLevel = "16";
+				break;
+            default:
+                mxaaLevel = 2;
+                smxaaLevel = "2";
+                break;
+        }
+        
+        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
+        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mxaaLevel);
+        SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, smxaaLevel.c_str());
+        logger << LOGGER_INFO << "MXAA set to " << mxaaLevel << "xMSAA" << LOGGER_ENDL;
+    } else {
+        logger << LOGGER_INFO << "MXAA disabled" << LOGGER_ENDL;
+    }
+
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
+
+    // Create GL window
+    logger << LOGGER_INFO << "Creating window" << LOGGER_ENDL;
+	window = SDL_CreateWindow(name.c_str(),
+		SDL_WINDOWPOS_CENTERED,
+		SDL_WINDOWPOS_CENTERED, w, h,
+		SDL_WINDOW_OPENGL);
+    // Create GL context
+    logger << LOGGER_INFO << "Creating OpenGL context" << LOGGER_ENDL;
+	glContext = SDL_GL_CreateContext(window);
+
+	// SDL_WarpMouseInWindow(window, w / 2, h / 2);
+	// SDL_SetRelativeMouseMode(SDL_TRUE);
+
+    // Set VSYNC swap interval
+    if (vsyncMode == VSYNC_DEFAULT || vsyncMode == VSYNC_ENABLED) {
+        SDL_GL_SetSwapInterval(1);
+        logger << LOGGER_INFO << "VSync enabled" << LOGGER_ENDL;
+    }
+    if (vsyncMode == VSYNC_DISABLED) {
+        SDL_GL_SetSwapInterval(0);
+        logger << LOGGER_INFO << "VSync disabled" << LOGGER_ENDL;
+    }
+
+    logger << LOGGER_INFO << "Display set up" << LOGGER_ENDL;
+
+    // Load OpenGL
+	gladLoadGLLoader(SDL_GL_GetProcAddress);
+	glEnable(GL_MULTISAMPLE);
+    glEnable(GL_DEPTH_TEST);
+    glEnable(GL_CULL_FACE);
+	glCullFace(GL_BACK);
+    logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL;
+    logger << LOGGER_ENDL;
+    isClosed = false;
+}
+
+
+
+
+
+Display::Display(std::string name, Logger& logger, int w, int h,
+                 SMH_MXAA_MODE mxaaMode, 
+                 SMH_VSYNC_DISPLAY_MODE vsyncMode)
+                    : logger(logger) {
+
+    MXAAMode = mxaaMode;
+    VSyncMode = vsyncMode;
+
+    logger << LOGGER_INFO << "Initializing display" << LOGGER_ENDL;
+	SDL_Init(SDL_INIT_EVERYTHING);
+
+	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
+	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+	// MXAA
+    if (mxaaMode != MXAA_DEFAULT || mxaaMode != MXAA_DISABLED) {
+        int mxaaLevel = 1;
+        std::string smxaaLevel = "1";
+
+        switch (mxaaMode) {
+            case MXAA_ENABLED:
+            case MXAA_2X:
+                mxaaLevel = 2;
+                smxaaLevel = "2";
+                break;
+            case MXAA_4X:
+                mxaaLevel = 4;
+                smxaaLevel = "4";
+                break;
+            case MXAA_8X:
+                mxaaLevel = 8;
+                smxaaLevel = "8";
+                break;
+			case MXAA_16X:
+				mxaaLevel = 16;
+				smxaaLevel = "16";
+				break;
+            default:
+                mxaaLevel = 2;
+                smxaaLevel = "2";
+                break;
+        }
+        
+        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
+        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mxaaLevel);
+        SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, smxaaLevel.c_str());
+        logger << LOGGER_INFO << "MXAA set to " << mxaaLevel << "xMSAA" << LOGGER_ENDL;
+    } else {
+        logger << LOGGER_INFO << "MXAA disabled" << LOGGER_ENDL;
+    }
+
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
+
+    // Create GL window
+    logger << LOGGER_INFO << "Creating window" << LOGGER_ENDL;
+	window = SDL_CreateWindow(name.c_str(),
+		SDL_WINDOWPOS_CENTERED,
+		SDL_WINDOWPOS_CENTERED, w, h,
+		SDL_WINDOW_OPENGL);
+    // Create GL context
+    logger << LOGGER_INFO << "Creating OpenGL context" << LOGGER_ENDL;
+	glContext = SDL_GL_CreateContext(window);
+
+	// SDL_WarpMouseInWindow(window, w / 2, h / 2);
+	// SDL_SetRelativeMouseMode(SDL_TRUE);
+
+    // Set VSYNC swap interval
+    if (vsyncMode == VSYNC_DEFAULT || vsyncMode == VSYNC_ENABLED) {
+        SDL_GL_SetSwapInterval(1);
+        logger << LOGGER_INFO << "VSync enabled" << LOGGER_ENDL;
+    }
+    if (vsyncMode == VSYNC_DISABLED) {
+        SDL_GL_SetSwapInterval(0);
+        logger << LOGGER_INFO << "VSync disabled" << LOGGER_ENDL;
+    }
+
+    logger << LOGGER_INFO << "Display set up" << LOGGER_ENDL;
+
+    // Load OpenGL
+	gladLoadGLLoader(SDL_GL_GetProcAddress);
+	glEnable(GL_MULTISAMPLE);
+    glEnable(GL_DEPTH_TEST);
+    glEnable(GL_CULL_FACE);
+	glCullFace(GL_BACK);
+    logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL;
+    logger << LOGGER_ENDL;
+    isClosed = false;
+}
+
+void Display::setName(std::string name) {
+    SDL_SetWindowTitle(window, name.c_str());
+}
+
+void Display::update() {
+	SDL_GL_SwapWindow(window);
+
+	glClear(GL_DEPTH_BUFFER_BIT);
+	const float clear[] = { 0.1f, 0.45f, 0.9f, 1.0f };
+	glClearBufferfv(GL_COLOR, 0, clear);
+}
+
+Display::~Display() {
+    SDL_DestroyWindow(window);
+}

legacy/src/display.h

@@ -1,61 +1,61 @@
-#ifndef SMHENGINE_SRC_DISPLAY_H_
-#define SMHENGINE_SRC_DISPLAY_H_
-
-#include <string>
-
-#include <glad/glad.hpp>
-
-// SDL includes different on windows
-// the way i have it set up so i gotta
-// do it like this unfortunately 
-#if _WIN32
-#include <SDL.h>
-#else
-#include <SDL2/SDL.h>
-#endif
-
-#include <logger.h>
-
-typedef enum {
-    VSYNC_DEFAULT,
-    VSYNC_DISABLED,
-    VSYNC_ENABLED,
-} SMH_VSYNC_DISPLAY_MODE;
-
-typedef enum {
-	MXAA_DEFAULT,
-	MXAA_DISABLED,
-	MXAA_ENABLED,
-	MXAA_2X,
-	MXAA_4X,
-	MXAA_8X,
-	MXAA_16X
-} SMH_MXAA_MODE;
-
-class Display {
-public:
-    Display(std::string name, Logger& logger, int w, int h,
-            SMH_VSYNC_DISPLAY_MODE vsyncMode = VSYNC_DEFAULT, 
-            SMH_MXAA_MODE mxaaMode = MXAA_DEFAULT);
-
-    Display(std::string name, Logger& logger, int w, int h,
-            SMH_MXAA_MODE mxaaMode = MXAA_DEFAULT, 
-            SMH_VSYNC_DISPLAY_MODE vsyncMode = VSYNC_DEFAULT);
-
-    void setName(std::string name);
-	void update();
-
-    bool isClosed = true;
-
-    SDL_Window* window;
-    SDL_GLContext glContext;
-
-    SMH_VSYNC_DISPLAY_MODE VSyncMode = VSYNC_DEFAULT;
-    SMH_MXAA_MODE MXAAMode = MXAA_DEFAULT;
-
-    virtual ~Display();
-private:
-    Logger& logger;
-};
-
-#endif
+#ifndef SMHENGINE_SRC_DISPLAY_H_
+#define SMHENGINE_SRC_DISPLAY_H_
+
+#include <string>
+
+#include <glad/glad.hpp>
+
+// SDL includes different on windows
+// the way i have it set up so i gotta
+// do it like this unfortunately 
+#if _WIN32
+#include <SDL.h>
+#else
+#include <SDL2/SDL.h>
+#endif
+
+#include <logger.h>
+
+typedef enum {
+    VSYNC_DEFAULT,
+    VSYNC_DISABLED,
+    VSYNC_ENABLED,
+} SMH_VSYNC_DISPLAY_MODE;
+
+typedef enum {
+	MXAA_DEFAULT,
+	MXAA_DISABLED,
+	MXAA_ENABLED,
+	MXAA_2X,
+	MXAA_4X,
+	MXAA_8X,
+	MXAA_16X
+} SMH_MXAA_MODE;
+
+class Display {
+public:
+    Display(std::string name, Logger& logger, int w, int h,
+            SMH_VSYNC_DISPLAY_MODE vsyncMode = VSYNC_DEFAULT, 
+            SMH_MXAA_MODE mxaaMode = MXAA_DEFAULT);
+
+    Display(std::string name, Logger& logger, int w, int h,
+            SMH_MXAA_MODE mxaaMode = MXAA_DEFAULT, 
+            SMH_VSYNC_DISPLAY_MODE vsyncMode = VSYNC_DEFAULT);
+
+    void setName(std::string name);
+	void update();
+
+    bool isClosed = true;
+
+    SDL_Window* window;
+    SDL_GLContext glContext;
+
+    SMH_VSYNC_DISPLAY_MODE VSyncMode = VSYNC_DEFAULT;
+    SMH_MXAA_MODE MXAAMode = MXAA_DEFAULT;
+
+    virtual ~Display();
+private:
+    Logger& logger;
+};
+
+#endif

legacy/src/main.cpp

@@ -0,0 +1,72 @@
+// General includes
+#include <chrono>
+#include <vector>
+
+// #include <glm/glm.hpp>
+// #include <glm/gtc/matrix_transform.hpp>
+// #include <glm/gtc/type_ptr.hpp>
+	
+// Custom includes
+#define LOGGER_DEFINITION
+#include <logger.h>
+
+#include "display.h"
+#include "camera.h"
+#include "shader.h"
+#include "model.h"
+
+int main (int argc, char** argv) {
+
+    std::cout << "-----------------------------\n"
+              << "----- SMH Render Engine -----\n"
+              << "-------- Version 0.0 --------\n"
+              << "----- ©Benjamin Kyd 2019 ----\n"
+              << "-----------------------------\n\n";
+
+    Logger logger;
+
+    Display display{"SMH Engine", logger, 1280, 720, MXAA_16X, VSYNC_ENABLED};
+
+    Camera camera;
+    camera.mouseSensitivity = 0.0012f;
+    camera.cameraSpeed = 1.0f;
+
+	Shader shader;
+	shader.load("./resources/shaders/phong").attatch().link().use();
+
+	Mesh mesh{ "./resources/lucy.obj" };
+	mesh.setup();
+
+    SDL_Event e;
+    while (!display.isClosed) {
+        camera.moveCamera();
+
+        while (SDL_PollEvent(&e)) {
+            if (e.type == SDL_QUIT)
+				display.isClosed = true;
+			//if (e.key.keysym.sym == SDLK_t) {
+			//	SDL_SetRelativeMouseMode(SDL_GetRelativeMouseMode() == SDL_TRUE ? SDL_FALSE : SDL_TRUE);
+			//}
+            camera.handleMouse(e);
+        }
+
+        const Uint8* state = SDL_GetKeyboardState(NULL);
+
+        if (state[SDL_SCANCODE_Q]) {
+            mesh.rotation += -1.5f;
+        }
+
+        if (state[SDL_SCANCODE_E]) {
+            mesh.rotation += 1.5f;
+        }
+
+		mesh.bind();
+		mesh.render(shader, camera);
+		mesh.unbind();
+
+		display.update();
+	}
+
+
+    return 0;
+}

legacy/src/material.cpp

@@ -0,0 +1,43 @@
+#include "material.h"
+
+Material::Material() {
+
+}
+
+Material::Material(std::string objPath) {
+	// Logger logger;
+	// objl::Loader loader;
+	// bool canLoad = loader.LoadFile(objPath);
+
+	// if (!canLoad) {
+	// 	logger << LOGGER_ERROR << "Cannot load material '" << objPath << "'" << LOGGER_ENDL;
+	// 	return;
+	// }
+
+	// loadFromObj(loader.LoadedMeshes[0]);
+}
+
+// Material::Material(objl::Mesh objMesh) {
+// 	loadFromObj(objMesh);
+// }
+
+// void Material::loadFromObj(objl::Mesh objMesh) {
+// 	loadFromMat(objMesh.MeshMaterial);
+// }
+
+// void Material::loadFromMat(objl::Material mat) {
+// 	this->name = mat.name;
+// 	OBJLVec3toGLM(mat.Ka, this->Ka);
+// 	OBJLVec3toGLM(mat.Kd, this->Kd);
+// 	OBJLVec3toGLM(mat.Ks, this->Ks);
+// 	this->Ns = mat.Ns;
+// 	this->Ni = mat.Ni;
+// 	this->d = mat.d;
+// 	this->illum = mat.illum;
+// 	this->map_Ka = mat.map_Ka;
+// 	this->map_Kd = mat.map_Kd;
+// 	this->map_Ks = mat.map_Ks;
+// 	this->map_Ns = mat.map_Ns;
+// 	this->map_d = mat.map_d;
+// 	this->map_bump = mat.map_bump;
+// }

legacy/src/material.h

@@ -1,58 +1,56 @@
-#ifndef SMHENGINE_SRC_MATERIAL_H_
-#define SMHENGINE_SRC_MATERIAL_H_
-
-#include <string>
-#include <vector>
-
-#include <glad/glad.hpp>
-
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtc/type_ptr.hpp>
-
-#include <OBJLoader.h>
-
-#include <logger.h>
-#include "./util/util.h"
-
-class Material {
-public:
-	Material();
-	Material(std::string objPath);
-	Material(objl::Mesh objMesh);
-
-	void loadFromObj(objl::Mesh objMesh);
-	void loadFromMat(objl::Material mat);
-
-	// Material Name
-	std::string name;
-	// Ambient Color
-	glm::vec3 Ka;
-	// Diffuse Color
-	glm::vec3 Kd;
-	// Specular Color
-	glm::vec3 Ks;
-	// Specular Exponent
-	float Ns;
-	// Optical Density
-	float Ni;
-	// Dissolve
-	float d;
-	// Illumination model 0->10
-	// TODO: Make an enum for this
-	int illum;
-	// Ambient Texture Map
-	std::string map_Ka;
-	// Diffuse Texture Map
-	std::string map_Kd;
-	// Specular Texture Map
-	std::string map_Ks;
-	// Specular Hightlight Map
-	std::string map_Ns;
-	// Alpha Texture Map
-	std::string map_d;
-	// Bump Map
-	std::string map_bump;
-};
-
-#endif
+#ifndef SMHENGINE_SRC_MATERIAL_H_
+#define SMHENGINE_SRC_MATERIAL_H_
+
+#include <string>
+#include <vector>
+
+#include <glad/glad.hpp>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+#include <logger.h>
+#include "./util/util.h"
+
+class Material {
+public:
+	Material();
+	Material(std::string objPath);
+	// Material(objl::Mesh objMesh);
+
+	// void loadFromObj(objl::Mesh objMesh);
+	// void loadFromMat(objl::Material mat);
+
+	// Material Name
+	std::string name;
+	// Ambient Color
+	glm::vec3 Ka;
+	// Diffuse Color
+	glm::vec3 Kd;
+	// Specular Color
+	glm::vec3 Ks;
+	// Specular Exponent
+	float Ns;
+	// Optical Density
+	float Ni;
+	// Dissolve
+	float d;
+	// Illumination model 0->10
+	// TODO: Make an enum for this
+	int illum;
+	// Ambient Texture Map
+	std::string map_Ka;
+	// Diffuse Texture Map
+	std::string map_Kd;
+	// Specular Texture Map
+	std::string map_Ks;
+	// Specular Hightlight Map
+	std::string map_Ns;
+	// Alpha Texture Map
+	std::string map_d;
+	// Bump Map
+	std::string map_bump;
+};
+
+#endif

legacy/src/mesh.cpp

@@ -1,128 +1,130 @@
-#include "mesh.h"
-
-Mesh::Mesh() {
-	
-}
-
-Mesh::Mesh(std::string objPath) {
-	Logger logger;
-
-	ObjLMesh mesh;
-	std::string warn, err;
-
-	bool canLoad = tinyobj::LoadObj(&mesh.attrib, &mesh.shapes, &mesh.materials, &warn, &err, objPath.c_str());
-
-	if (!err.empty() || !canLoad) {
-		logger << LOGGER_ERROR << "Cannot load obj '" << objPath << "' :" << err << LOGGER_ENDL;
-		return;
-	}
-
-	if (!warn.empty()) {
-		logger << LOGGER_WARN << "Warning from obj loader while loading obj '" << objPath << "' :" << warn << LOGGER_ENDL;
-	}
-
-	logger << LOGGER_INFO << "Loaded: " << objPath << LOGGER_ENDL;
-
-	loadFromObj(mesh);
-}
-
-Mesh::Mesh(ObjLMesh mesh) {
-	// loadFromObj(objMesh);
-}
-
-void Mesh::loadFromObj(ObjLMesh mesh) {
-	OBJLtoGLM(mesh, vertices, normals, texCoords);
-	OBJLtoIndices(mesh, indices);
-
-	//Logger logger;
-	//for (int i = 0; i < 100; i++) {
-	//	logger << LOGGER_DEBUG << normals[i].x << " " << normals[i].y << " " << normals[i].z << LOGGER_ENDL;
-	//}
-}
-
-void Mesh::setup() {
-	Logger logger;
-
-	glGenVertexArrays(1, &VAOid);
-	glGenBuffers(1, &vertexBuffer);
-	glGenBuffers(1, &indexBuffer);
-
-	glBindVertexArray(VAOid);
-
-	glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
-
-	std::vector<glm::vec3> toGpu;
-	toGpu.insert(toGpu.end(), vertices.begin(), vertices.end());
-	toGpu.insert(toGpu.end(), normals.begin(), normals.end());
-	toGpu.insert(toGpu.end(), texCoords.begin(), texCoords.end());
-
-	glBufferData(GL_ARRAY_BUFFER, toGpu.size() * sizeof(glm::vec3), 
-				 &toGpu[0], GL_STATIC_DRAW);
-
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
-	glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLuint),
-				 &indices[0], GL_STATIC_DRAW);
-
-	// Positions
-	glEnableVertexAttribArray(0);
-	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 
-						 (const void*)0);
-
-	// Normals
-	glEnableVertexAttribArray(1);
-	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 
-						 (const void*)(vertices.size() * sizeof(glm::vec3)));
-
-	// TexCoords
-	glEnableVertexAttribArray(2);
-	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, 
-						 (const void*)((vertices.size() + texCoords.size()) * sizeof(glm::vec3)));
-
-	logger << LOGGER_INFO << "Mesh " << name << " setup" << LOGGER_ENDL;
-
-	glBindVertexArray(0);
-}
-
-void Mesh::bind() {
-	glBindVertexArray(VAOid);
-}
-
-void Mesh::render(Shader& shader) {
-
-	// Model matrice
-	glm::mat4 model = glm::mat4(1.0f);
-	model = glm::translate(model, { -17.0f, -17.0f, -17.0f });
-	model = glm::rotate(model, glm::radians(-160.0f), glm::vec3(0.0f, 1.0f, 0.0f));
-	// Gets uniform for model matrice, to be used later
-	GLint uniTrans = glGetUniformLocation(shader.getProgram(), "model");
-	glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
-
-
-	// View matrice
-	glm::mat4 view = glm::lookAt(
-		glm::vec3(1.0f, 1.0f, 1.0f),
-		glm::vec3(0.0f, 0.4f, 0.0f),
-		glm::vec3(0.0f, 1.0f, 0.0f)
-	);
-	// Get uniform and send it to the GPU
-	GLint uniView = glGetUniformLocation(shader.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);//camera.perspective;
-	// Get uniform and send it to the GPU
-	GLint uniProj = glGetUniformLocation(shader.getProgram(), "proj");
-	glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
-
-
-	glm::vec3 lightPos = { -2.0f, 4.0f, -1.0f };
-
-	GLint uniLight = glGetUniformLocation(shader.getProgram(), "lightpos");
-	glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(lightPos));
-
-	glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
-}
-
-void Mesh::unbind() {
-	glBindVertexArray(0);
-}
+#include "mesh.h"
+#include "camera.h"
+
+Mesh::Mesh() {
+	
+}
+
+Mesh::Mesh(std::string objPath) {
+	Logger logger;
+
+	ObjLMesh mesh;
+	std::string warn, err;
+
+	bool canLoad = tinyobj::LoadObj(&mesh.attrib, &mesh.shapes, &mesh.materials, &warn, &err, objPath.c_str());
+
+	if (!err.empty() || !canLoad) {
+		logger << LOGGER_ERROR << "Cannot load obj '" << objPath << "': " << err << LOGGER_ENDL;
+		return;
+	}
+
+	if (!warn.empty()) {
+		logger << LOGGER_WARN << "Warning from obj loader while loading obj '" << objPath << "': " << warn << LOGGER_ENDL;
+	}
+
+	logger << LOGGER_INFO << "Loaded: " << objPath << LOGGER_ENDL;
+
+	loadFromObj(mesh);
+}
+
+Mesh::Mesh(ObjLMesh mesh) {
+	// loadFromObj(objMesh);
+}
+
+void Mesh::loadFromObj(ObjLMesh mesh) {
+	OBJLtoGLM(mesh, vertices, normals, texCoords, indices);
+	// OBJLtoIndices(mesh, indices);E
+
+	//Logger logger;
+	//for (int i = 0; i < 100; i++) {
+	//	logger << LOGGER_DEBUG << normals[i].x << " " << normals[i].y << " " << normals[i].z << LOGGER_ENDL;
+	//}
+}
+
+void Mesh::setup() {
+	Logger logger;
+
+	glGenVertexArrays(1, &VAOid);
+	glGenBuffers(1, &vertexBuffer);
+	glGenBuffers(1, &indexBuffer);
+
+	glBindVertexArray(VAOid);
+
+	glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
+
+	std::vector<glm::vec3> toGpu;
+	toGpu.insert(toGpu.end(), vertices.begin(), vertices.end());
+	toGpu.insert(toGpu.end(), normals.begin(), normals.end());
+	toGpu.insert(toGpu.end(), texCoords.begin(), texCoords.end());
+
+	glBufferData(GL_ARRAY_BUFFER, toGpu.size() * sizeof(glm::vec3), 
+				 &toGpu[0], GL_STATIC_DRAW);
+
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLuint),
+				 &indices[0], GL_STATIC_DRAW);
+
+	// Positions
+	glEnableVertexAttribArray(0);
+	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 
+						 (const void*)0);
+
+	// Normals
+	glEnableVertexAttribArray(1);
+	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 
+						 (const void*)(vertices.size() * sizeof(glm::vec3)));
+
+	// TexCoords
+	glEnableVertexAttribArray(2);
+	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, 
+						 (const void*)((vertices.size() + texCoords.size()) * sizeof(glm::vec3)));
+
+	logger << LOGGER_INFO << "Mesh setup" << LOGGER_ENDL;
+
+	glBindVertexArray(0);
+}
+
+void Mesh::bind() {
+	glBindVertexArray(VAOid);
+}
+
+void Mesh::render(Shader& shader, Camera& camera) {
+
+	// Model matrice
+	glm::mat4 model = glm::mat4(1.0f);
+	model = glm::translate(model, { -170.0f, -170.0f, -170.0f });
+	model = glm::rotate(model, glm::radians(-160.0f + this->rotation), glm::vec3(0.0f, 1.0f, 0.0f));
+	GLint uniTrans = glGetUniformLocation(shader.getProgram(), "model");
+	glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
+
+	// // View matrice
+	// glm::mat4 view = glm::lookAt(
+	// 	glm::vec3(1.0f, 1.0f, 1.0f),
+	// 	glm::vec3(0.0f, 0.4f, 0.0f),
+	// 	glm::vec3(0.0f, 1.0f, 0.0f)
+	// );
+	// Get uniform and send it to the GPU
+	GLint uniView = glGetUniformLocation(shader.getProgram(), "view");
+	glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(camera.getViewMatrix()));
+
+	// 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(shader.getProgram(), "proj");
+	glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
+
+
+	glm::vec3 lightPos = { -270.0f, -270.0f, -1.0f };
+
+	GLint uniLight = glGetUniformLocation(shader.getProgram(), "lightPos");
+	glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(lightPos));
+
+	GLint uniCamPos = glGetUniformLocation(shader.getProgram(), "viewPos");
+	glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(camera.getPos()));
+
+	glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
+}
+
+void Mesh::unbind() {
+	glBindVertexArray(0);
+}

legacy/src/mesh.h

@@ -1,65 +1,68 @@
-#ifndef SMHENGINE_SRC_MESH_H_
-#define SMHENGINE_SRC_MESH_H_
-
-#include <string>
-#include <vector>
-
-#include <glad/glad.hpp>
-
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtc/type_ptr.hpp>
-
-#include <tiny_obj_loader.h>
-
-#include <logger.h>
-#include "shader.h"
-#include "./util/util.h"
-
-// Not in use yet
-// Will be used as a vector, enabling
-// the use of strides when sending the 
-// vertex data to the GPU
-struct Vertex {
-	glm::vec3 vertice;
-	glm::vec3 normal;
-	glm::vec2 texCoord;
-};
-
-
-// For easy passing around of the tinyobj
-// mesh structures
-struct ObjLMesh {
-    tinyobj::attrib_t attrib;
-    std::vector<tinyobj::shape_t> shapes;
-    std::vector<tinyobj::material_t> materials;
-};
-
-class Mesh {
-public:
-    Mesh();
-    Mesh(std::string objPath);
-	Mesh(ObjLMesh mesh);
-
-	void loadFromObj(ObjLMesh mesh);
-    void setup();
-
-    void bind();
-    void render(Shader& shader);
-    static void unbind();
-
-    GLuint VAOid;
-
-	std::string name;
-    std::vector<glm::vec3> vertices;
-    std::vector<glm::vec3> normals;
-	// This is a vec3 so it can all pop into
-	//one buffer :)
-    std::vector<glm::vec3> texCoords;
-    std::vector<unsigned int> indices;
-private:
-    GLuint vertexBuffer;
-    GLuint indexBuffer;
-};
-
-#endif
+#ifndef SMHENGINE_SRC_MESH_H_
+#define SMHENGINE_SRC_MESH_H_
+
+#include <string>
+#include <vector>
+
+#include <glad/glad.hpp>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+#include <tiny_obj_loader.h>
+
+#include <logger.h>
+#include "shader.h"
+#include "./util/util.h"
+
+class Camera;
+
+// Not in use yet
+// Will be used as a vector, enabling
+// the use of strides when sending the 
+// vertex data to the GPU
+struct Vertex {
+	glm::vec3 vertice;
+	glm::vec3 normal;
+	glm::vec2 texCoord;
+};
+
+// For easy passing around of the tinyobj
+// mesh structures
+struct ObjLMesh {
+    tinyobj::attrib_t attrib;
+    std::vector<tinyobj::shape_t> shapes;
+    std::vector<tinyobj::material_t> materials;
+};
+
+class Mesh {
+public:
+    Mesh();
+    Mesh(std::string objPath);
+	Mesh(ObjLMesh mesh);
+
+	void loadFromObj(ObjLMesh mesh);
+    void setup();
+
+    void bind();
+    void render(Shader& shader, Camera& camera);
+    static void unbind();
+
+    GLuint VAOid;
+
+	std::string name;
+    std::vector<glm::vec3> vertices;
+    std::vector<glm::vec3> normals;
+	// This is a vec3 so it can all pop into
+	//one buffer :)
+    std::vector<glm::vec3> texCoords;
+    std::vector<unsigned int> indices;
+
+    float rotation = 0.0f;
+private:
+    GLuint vertexBuffer;
+    GLuint indexBuffer;
+};
+
+#endif

legacy/src/model.h

@@ -10,8 +10,6 @@
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
 
-#include <OBJLoader.h>
-
 #include <logger.h>
 
 #include "mesh.h"

legacy/src/shader.cpp

@@ -1,168 +1,168 @@
-#include "shader.h"
-
-#include <iostream>
-#include <fstream>
-
-Shader::Shader()
-	: logger(*new Logger) {
-	m_program = glCreateProgram();
-}
-
-Shader& Shader::use() {
-	glUseProgram(m_program);
-	return *this;
-}
-
-Shader& Shader::link() {
-	glLinkProgram(m_program);
-	return *this;
-}
-
-Shader& Shader::attatch() {
-	glAttachShader(m_program, m_vert);
-	glAttachShader(m_program, m_frag);
-	return *this;
-}
-
-std::string readShader(std::string source) {
-	std::ifstream t(source);
-	std::string shaderCode((std::istreambuf_iterator<char>(t)),
-		std::istreambuf_iterator<char>());
-	return shaderCode;
-}
-
-Shader& Shader::load(GLenum type, std::string sourceLoc) {
-	const char* source = readShader(sourceLoc).c_str();
-
-	if (type == GL_VERTEX_SHADER) {
-		m_vertLoc = sourceLoc;
-		m_vertSource = (std::string)source;
-		m_vert = glCreateShader(GL_VERTEX_SHADER);
-		glShaderSource(m_vert, 1, &source, NULL);
-		glCompileShader(m_vert);
-
-		glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
-		if (m_status == GL_FALSE) {
-			char buf[512];
-			glGetShaderInfoLog(m_vert, 512, NULL, buf);
-			logger << LOGGER_ERROR << buf << LOGGER_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;
-		m_frag = glCreateShader(GL_FRAGMENT_SHADER);
-		glShaderSource(m_frag, 1, &source, NULL);
-		glCompileShader(m_frag);
-
-		glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
-		if (m_status == GL_FALSE) {
-			char buf[512];
-			glGetShaderInfoLog(m_frag, 512, NULL, buf);
-			logger << LOGGER_ERROR << buf << LOGGER_ENDL;
-		}
-
-		logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
-	}
-
-	return *this;
-}
-
-Shader& Shader::load(std::string sourceLoc) {
-	m_vertLoc = sourceLoc + ".vert";
-	m_fragLoc = sourceLoc + ".frag";
-
-	m_vertSource = readShader(m_vertLoc);
-	m_fragSource = readShader(m_fragLoc);
-
-	m_vert = glCreateShader(GL_VERTEX_SHADER);
-	m_frag = glCreateShader(GL_FRAGMENT_SHADER);
-
-	const char* vertSource = m_vertSource.c_str();
-	glShaderSource(m_vert, 1, &vertSource, NULL);
-	glCompileShader(m_vert);
-
-	const char* fragSource = m_fragSource.c_str();
-	glShaderSource(m_frag, 1, &fragSource, NULL);
-	glCompileShader(m_frag);
-
-	glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
-	if (m_status == GL_FALSE) {
-		char buf[512];
-		glGetShaderInfoLog(m_vert, 512, NULL, buf);
-		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);
-		logger << LOGGER_ERROR << buf << LOGGER_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;
-}
-
-Shader& Shader::reload() {
-	glDeleteProgram(m_program);
-	glDeleteShader(m_vert);
-	glDeleteShader(m_frag);
-
-	m_vertSource = readShader(m_vertLoc);
-	m_fragSource = readShader(m_fragLoc);
-
-	m_vert = glCreateShader(GL_VERTEX_SHADER);
-	m_frag = glCreateShader(GL_FRAGMENT_SHADER);
-
-	const char* vertSource = m_vertSource.c_str();
-	glShaderSource(m_vert, 1, &vertSource, NULL);
-	glCompileShader(m_vert);
-
-	const char* fragSource = m_fragSource.c_str();
-	glShaderSource(m_frag, 1, &fragSource, NULL);
-	glCompileShader(m_frag);
-
-	glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
-	if (m_status == GL_FALSE) {
-		char buf[512];
-		glGetShaderInfoLog(m_vert, 512, NULL, buf);
-		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);
-		logger << LOGGER_ERROR << buf << LOGGER_ENDL;
-	}
-
-	logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
-	logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
-
-	link();
-	attatch();
-
-	return *this;
-}
-
-GLuint Shader::getProgram() {
-	return m_program;
-}
-
-GLuint Shader::getVertex() {
-	return m_vert;
-}
-
-GLuint Shader::getFragment() {
-	return m_frag;
-}
-
-Shader::~Shader() {
-	glDeleteProgram(m_program);
-	glDeleteShader(m_vert);
-	glDeleteShader(m_frag);
-}
+#include "shader.h"
+
+#include <iostream>
+#include <fstream>
+
+Shader::Shader()
+	: logger(*new Logger) {
+	m_program = glCreateProgram();
+}
+
+Shader& Shader::use() {
+	glUseProgram(m_program);
+	return *this;
+}
+
+Shader& Shader::link() {
+	glLinkProgram(m_program);
+	return *this;
+}
+
+Shader& Shader::attatch() {
+	glAttachShader(m_program, m_vert);
+	glAttachShader(m_program, m_frag);
+	return *this;
+}
+
+std::string readShader(std::string source) {
+	std::ifstream t(source);
+	std::string shaderCode((std::istreambuf_iterator<char>(t)),
+		std::istreambuf_iterator<char>());
+	return shaderCode;
+}
+
+Shader& Shader::load(GLenum type, std::string sourceLoc) {
+	const char* source = readShader(sourceLoc).c_str();
+
+	if (type == GL_VERTEX_SHADER) {
+		m_vertLoc = sourceLoc;
+		m_vertSource = (std::string)source;
+		m_vert = glCreateShader(GL_VERTEX_SHADER);
+		glShaderSource(m_vert, 1, &source, NULL);
+		glCompileShader(m_vert);
+
+		glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
+		if (m_status == GL_FALSE) {
+			char buf[512];
+			glGetShaderInfoLog(m_vert, 512, NULL, buf);
+			logger << LOGGER_ERROR << buf << LOGGER_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;
+		m_frag = glCreateShader(GL_FRAGMENT_SHADER);
+		glShaderSource(m_frag, 1, &source, NULL);
+		glCompileShader(m_frag);
+
+		glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
+		if (m_status == GL_FALSE) {
+			char buf[512];
+			glGetShaderInfoLog(m_frag, 512, NULL, buf);
+			logger << LOGGER_ERROR << buf << LOGGER_ENDL;
+		}
+
+		logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
+	}
+
+	return *this;
+}
+
+Shader& Shader::load(std::string sourceLoc) {
+	m_vertLoc = sourceLoc + ".vert";
+	m_fragLoc = sourceLoc + ".frag";
+
+	m_vertSource = readShader(m_vertLoc);
+	m_fragSource = readShader(m_fragLoc);
+
+	m_vert = glCreateShader(GL_VERTEX_SHADER);
+	m_frag = glCreateShader(GL_FRAGMENT_SHADER);
+
+	const char* vertSource = m_vertSource.c_str();
+	glShaderSource(m_vert, 1, &vertSource, NULL);
+	glCompileShader(m_vert);
+
+	const char* fragSource = m_fragSource.c_str();
+	glShaderSource(m_frag, 1, &fragSource, NULL);
+	glCompileShader(m_frag);
+
+	glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
+	if (m_status == GL_FALSE) {
+		char buf[512];
+		glGetShaderInfoLog(m_vert, 512, NULL, buf);
+		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);
+		logger << LOGGER_ERROR << buf << LOGGER_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;
+}
+
+Shader& Shader::reload() {
+	glDeleteProgram(m_program);
+	glDeleteShader(m_vert);
+	glDeleteShader(m_frag);
+
+	m_vertSource = readShader(m_vertLoc);
+	m_fragSource = readShader(m_fragLoc);
+
+	m_vert = glCreateShader(GL_VERTEX_SHADER);
+	m_frag = glCreateShader(GL_FRAGMENT_SHADER);
+
+	const char* vertSource = m_vertSource.c_str();
+	glShaderSource(m_vert, 1, &vertSource, NULL);
+	glCompileShader(m_vert);
+
+	const char* fragSource = m_fragSource.c_str();
+	glShaderSource(m_frag, 1, &fragSource, NULL);
+	glCompileShader(m_frag);
+
+	glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
+	if (m_status == GL_FALSE) {
+		char buf[512];
+		glGetShaderInfoLog(m_vert, 512, NULL, buf);
+		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);
+		logger << LOGGER_ERROR << buf << LOGGER_ENDL;
+	}
+
+	logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
+	logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
+
+	link();
+	attatch();
+
+	return *this;
+}
+
+GLuint Shader::getProgram() {
+	return m_program;
+}
+
+GLuint Shader::getVertex() {
+	return m_vert;
+}
+
+GLuint Shader::getFragment() {
+	return m_frag;
+}
+
+Shader::~Shader() {
+	glDeleteProgram(m_program);
+	glDeleteShader(m_vert);
+	glDeleteShader(m_frag);
+}

legacy/src/shader.h

@@ -1,42 +1,42 @@
-#ifndef SMHENGINE_SRC_SHADER_H_
-#define SMHENGINE_SRC_SHADER_H_
-
-#include <glad/glad.hpp>
-#include <string>
-#include <logger.h>
-
-class Shader {
-public:
-	Shader();
-
-	Shader& use();
-	Shader& link();
-	Shader& attatch();
-	Shader& load(GLenum type, std::string sourceLoc);
-	Shader& load(std::string sourceLoc);
-	Shader& reload();
-
-	GLuint getProgram();
-	GLuint getVertex();
-	GLuint getFragment();
-
-	virtual ~Shader();
-private:
-	Shader(Shader const &) = delete;
-	Shader & operator=(Shader const &) = delete;
-
-	GLuint m_program;
-	GLuint m_vert;
-	GLuint m_frag;
-
-	std::string m_vertSource;
-	std::string m_fragSource;
-	std::string m_vertLoc;
-	std::string m_fragLoc;
-
-	Logger& logger;
-
-	GLint m_status;
-};
-
-#endif
+#ifndef SMHENGINE_SRC_SHADER_H_
+#define SMHENGINE_SRC_SHADER_H_
+
+#include <glad/glad.hpp>
+#include <string>
+#include <logger.h>
+
+class Shader {
+public:
+	Shader();
+
+	Shader& use();
+	Shader& link();
+	Shader& attatch();
+	Shader& load(GLenum type, std::string sourceLoc);
+	Shader& load(std::string sourceLoc);
+	Shader& reload();
+
+	GLuint getProgram();
+	GLuint getVertex();
+	GLuint getFragment();
+
+	virtual ~Shader();
+private:
+	Shader(Shader const &) = delete;
+	Shader & operator=(Shader const &) = delete;
+
+	GLuint m_program;
+	GLuint m_vert;
+	GLuint m_frag;
+
+	std::string m_vertSource;
+	std::string m_fragSource;
+	std::string m_vertLoc;
+	std::string m_fragLoc;
+
+	Logger& logger;
+
+	GLint m_status;
+};
+
+#endif

legacy/src/tiny_obj_loader.cpp

@@ -0,0 +1,2 @@
+#define TINYOBJLOADER_IMPLEMENTATION // define this in only *one* .cc
+#include "tiny_obj_loader.h"

legacy/src/util/util.cpp

@@ -0,0 +1,79 @@
+#include "util.h"
+
+#include <unordered_map>
+
+#include <logger.h>
+
+#include "../mesh.h"
+
+
+void OBJLtoGLM(ObjLMesh& mesh, 
+               std::vector<glm::vec3>& outVert,
+               std::vector<glm::vec3>& outNorm,
+               std::vector<glm::vec3>& outTexCoord,
+               std::vector<GLuint>& outIndices) {
+
+    std::unordered_map<glm::vec3, uint64_t> uniqueVertices {{{1.0f, 1.0f, 1.0f}, 1}};
+
+    for (const auto &shape : mesh.shapes) {
+        for (const auto& index : shape.mesh.indices) {
+            glm::vec3 vertex {
+                mesh.attrib.vertices[3 * index.vertex_index + 0],
+                mesh.attrib.vertices[3 * index.vertex_index + 1],
+                mesh.attrib.vertices[3 * index.vertex_index + 2]
+            };
+
+            // outNorm.push_back({
+            //     mesh.attrib.normals[3 * index.normal_index + 0],
+            //     mesh.attrib.normals[3 * index.normal_index + 1],
+            //     mesh.attrib.normals[3 * index.normal_index + 2]
+            // });
+
+            // outTexCoord.push_back({
+            //     mesh.attrib.texcoords[2 * index.texcoord_index + 0],
+            //     mesh.attrib.texcoords[2 * index.texcoord_index + 1],
+            //     0.0f
+            // });
+
+            if (uniqueVertices.count(vertex) == 0) {
+                uniqueVertices[vertex] = static_cast<uint32_t>(outVert.size());
+                outVert.push_back(vertex);
+            }
+
+            outIndices.push_back(uniqueVertices[vertex]);
+        }
+    }
+
+    ComputeNormals(outNorm, outVert, outIndices);
+}
+
+void ComputeNormals(std::vector<glm::vec3>& normals, 
+                    std::vector<glm::vec3>& vertices,
+                    std::vector<GLuint>& elements) {
+
+    normals.resize(vertices.size(), glm::vec3(0.0, 0.0, 0.0));
+    for (int i = 0; i < elements.size(); i += 3) {
+        GLushort ia = elements[i];
+        GLushort ib = elements[i+1];
+        GLushort ic = elements[i+2];
+        glm::vec3 normal = glm::normalize(glm::cross(
+        glm::vec3(vertices[ib]) - glm::vec3(vertices[ia]),
+        glm::vec3(vertices[ic]) - glm::vec3(vertices[ia])));
+        normals[ia] = normals[ib] = normals[ic] = normal;
+    }
+}
+
+void UintToGLuint(ObjLMesh& mesh,
+                  std::vector<GLuint>& outIndices) {
+    
+}
+
+
+
+// void OBJLVec3toGLM(objl::Vector3& inVec, glm::vec3& outVec) {
+
+// 	outVec.x = inVec.X;
+// 	outVec.y = inVec.Y;
+// 	outVec.z = inVec.Z;
+
+// }

legacy/src/util/util.h

@@ -2,16 +2,19 @@
 #define SMHENGINE_SRC_UTIL_UTUL_H_
 
 #include <glad/glad.hpp>
+// This is so that i can use 
+// glm::vec3 inside of an
+// std::unordered_map as it's
+// experimental for some reason
+// smh
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/hash.hpp>
 #include <glm/glm.hpp>
 #include <vector>
 
 #include <tiny_obj_loader.h>
 
-struct ObjLMesh {
-    tinyobj::attrib_t attrib;
-    std::vector<tinyobj::shape_t> shapes;
-    std::vector<tinyobj::material_t> materials;
-};
+struct ObjLMesh;
 
 void OBJLtoGLM(ObjLMesh& mesh, 
                std::vector<glm::vec3>& outVert,
@@ -19,6 +22,10 @@ void OBJLtoGLM(ObjLMesh& mesh,
                std::vector<glm::vec3>& outTexCoord,
                std::vector<GLuint>& outIndices);
 
+void ComputeNormals(std::vector<glm::vec3>& normals, 
+                    std::vector<glm::vec3>& vertices,
+                    std::vector<GLuint>& elements);
+
 void UintToGLuint(ObjLMesh& mesh,
                   std::vector<GLuint>& outIndices);
 

resources/shaders/phong.frag

@@ -1,16 +1,16 @@
-#version 330
+#version 330 core
 
 in vec3 Normal;
 in vec3 FragPos;
-// in vec4 FragPosLightSpace;
+in vec4 FragPosLightSpace;
 
 uniform vec3 lightPos;
+uniform vec3 viewPos;
 
 out vec4 outColour;
 
-vec3 viewPos = vec3(0.0, 0.0, 0.0);
 vec3 objectColour = vec3(1.0, 1.0, 1.0);
-vec3 lightColour = vec3(0.7, 0.0, 0.65);
+vec3 lightColour = vec3(0.7, 0.3, 0.65);
 // vec3 lightColour = vec3(0.3, 0.85, 1.0);
 
 void main() {
@@ -21,7 +21,7 @@ void main() {
     vec3 diffuse = diff * lightColour;
 
 
-    float specularStrength = 0;
+    float specularStrength = 1;
 
     vec3 viewDir = normalize(viewPos - FragPos);
     vec3 reflectDir = reflect(-lightDir, normal);
@@ -30,7 +30,7 @@ void main() {
     vec3 specular = specularStrength * spec * lightColour;
 
 
-    float ambientStrength = 0.4;
+    float ambientStrength = 0.1;
     vec3 ambient = ambientStrength * lightColour;
 
     vec3 result = (ambient + diffuse + specular) * objectColour;   

resources/shaders/phong.vert

@@ -1,21 +1,22 @@
-#version 330 
-
-in vec3 position;
-in vec3 normal;
-
-out vec3 Normal;
-out vec3 FragPos;
-out vec4 FragPosLightSpace;
-
-uniform mat4 model;
-uniform mat4 view;
-uniform mat4 proj;
-
-uniform mat4 lightSpaceMatrix;
-
-void main() {
-    gl_Position = proj * view * model * vec4(position, 1.0);
-    FragPos = vec3(model * vec4(position, 1.0));
-    FragPosLightSpace = lightSpaceMatrix * vec4(FragPos, 1.0);
-    Normal = mat3(model) * normal;
-}
+#version 330 core
+
+layout (location = 0) in vec3 position;
+layout (location = 1) in vec3 normal;
+layout (location = 2) in vec3 texCoord;
+
+out vec3 Normal;
+out vec3 FragPos;
+// out vec4 FragPosLightSpace;
+
+uniform mat4 model;
+uniform mat4 view;
+uniform mat4 proj;
+
+// uniform mat4 lightSpaceMatrix;
+
+void main() {
+    gl_Position = proj * view * model * vec4(position, 1.0);
+    FragPos = vec3(model * vec4(position, 1.0));
+    // FragPosLightSpace = lightSpaceMatrix * vec4(FragPos, 1.0);
+    Normal = mat3(model) * normal;
+}

resources/sponza.mtl

@@ -0,0 +1,316 @@
+# 3ds Max Wavefront OBJ Exporter v0.97b - (c)2007 guruware
+# File Created: 26.07.2011 17:00:30
+
+newmtl sp_00_luk_mali
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.745098 0.709804 0.674510
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka SP_LUK.JPG
+	map_Kd SP_LUK.JPG
+	map_bump sp_luk-bump.JPG
+	bump sp_luk-bump.JPG
+
+newmtl sp_svod_kapitel
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.713726 0.705882 0.658824
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka 00_SKAP.JPG
+	map_Kd 00_SKAP.JPG
+	map_bump 00_SKAP.JPG
+	bump 00_SKAP.JPG
+
+newmtl sp_01_stub_baza_
+	Ns 19.999998
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.784314 0.784314 0.784314
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+
+newmtl sp_01_stub_kut
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.737255 0.709804 0.670588
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka 01_STUB.JPG
+	map_Kd 01_STUB.JPG
+	map_bump 01_STUB-bump.jpg
+	bump 01_STUB-bump.jpg
+
+newmtl sp_00_stup
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.737255 0.709804 0.670588
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka 01_STUB.JPG
+	map_Kd 01_STUB.JPG
+	map_bump 01_STUB-bump.jpg
+	bump 01_STUB-bump.jpg
+
+newmtl sp_01_stub_baza
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.800000 0.784314 0.749020
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka 01_S_BA.JPG
+	map_Kd 01_S_BA.JPG
+	map_bump 01_S_BA.JPG
+	bump 01_S_BA.JPG
+
+newmtl sp_00_luk_mal1
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.745098 0.709804 0.674510
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka 01_ST_KP.JPG
+	map_Kd 01_ST_KP.JPG
+	map_bump 01_St_kp-bump.jpg
+	bump 01_St_kp-bump.jpg
+
+newmtl sp_01_stub
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.737255 0.709804 0.670588
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka 01_STUB.JPG
+	map_Kd 01_STUB.JPG
+	map_bump 01_STUB-bump.jpg
+	bump 01_STUB-bump.jpg
+
+newmtl sp_01_stup
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.827451 0.800000 0.768628
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka X01_ST.JPG
+	map_Kd X01_ST.JPG
+
+newmtl sp_vijenac
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.713726 0.705882 0.658824
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka 00_SKAP.JPG
+	map_Kd 00_SKAP.JPG
+	map_bump 00_SKAP.JPG
+	bump 00_SKAP.JPG
+
+newmtl sp_00_svod
+	Ns 1.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.145098 0.145098 0.145098
+	Kd 0.941177 0.866667 0.737255
+	Ks 0.034039 0.032314 0.029333
+	Ke 0.000000 0.000000 0.000000
+        map_Kd KAMEN-stup.JPG
+        map_Ka KAMEN-stup.JPG
+        map_bump KAMEN-stup.jpg
+        bump KAMEN-stup.jpg
+
+newmtl sp_02_reljef
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.529412 0.498039 0.490196
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka RELJEF.JPG
+	map_Kd RELJEF.JPG
+	map_bump reljef-bump.jpg
+	bump reljef-bump.jpg
+
+newmtl sp_01_luk_a
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.745098 0.709804 0.674510
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka SP_LUK.JPG
+	map_Kd SP_LUK.JPG
+	map_bump sp_luk-bump.JPG
+	bump sp_luk-bump.JPG
+
+newmtl sp_zid_vani
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.627451 0.572549 0.560784
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka KAMEN.JPG
+	map_Kd KAMEN.JPG
+	map_bump KAMEN-bump.jpg
+	bump KAMEN-bump.jpg
+
+newmtl sp_01_stup_baza
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.800000 0.784314 0.749020
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka 01_S_BA.JPG
+	map_Kd 01_S_BA.JPG
+	map_bump 01_S_BA.JPG
+	bump 01_S_BA.JPG
+
+newmtl sp_00_zid
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.627451 0.572549 0.560784
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka KAMEN.JPG
+	map_Kd KAMEN.JPG
+	map_bump KAMEN-bump.jpg
+	bump KAMEN-bump.jpg
+
+newmtl sp_00_prozor
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 1.000000 1.000000 1.000000
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka PROZOR1.JPG
+	map_Kd PROZOR1.JPG
+	map_bump PROZOR1.JPG
+	bump PROZOR1.JPG
+
+newmtl sp_00_vrata_krug
+	Ns 19.999998
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.784314 0.784314 0.784314
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka VRATA_KR.JPG
+	map_Kd VRATA_KR.JPG
+	map_bump VRATA_KR.JPG
+	bump VRATA_KR.JPG
+
+newmtl sp_00_pod
+	Ns 50.000000
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.627451 0.572549 0.560784
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka KAMEN.JPG
+	map_Kd KAMEN.JPG
+	map_bump KAMEN-bump.jpg
+	bump KAMEN-bump.jpg
+
+newmtl sp_00_vrata_kock
+	Ns 19.999998
+	Ni 1.500000
+	d 1.000000
+	Tr 0.000000
+	Tf 1.000000 1.000000 1.000000 
+	illum 2
+	Ka 0.000000 0.000000 0.000000
+	Kd 0.784314 0.784314 0.784314
+	Ks 0.000000 0.000000 0.000000
+	Ke 0.000000 0.000000 0.000000
+	map_Ka VRATA_KO.JPG
+	map_Kd VRATA_KO.JPG
+	map_bump VRATA_KO.JPG
+	bump VRATA_KO.JPG

resources/test.obj

@@ -0,0 +1,28 @@
+o Cube
+s 1
+v 1.000000 -1.000000 -1.000000
+v 1.000000 -1.000000 1.000000
+v -1.000000 -1.000000 1.000000
+v -1.000000 -1.000000 -1.000000
+v 1.000000 1.000000 -1.000000
+v 1.000000 1.000000 1.000000
+v -1.000000 1.000000 1.000000
+v -1.000000 1.000000 -1.000000
+vn 0.000000 -1.000000 0.000000
+vn 0.000000 1.000000 0.000000
+vn 1.000000 0.000000 0.000000
+vn 0.000000 0.000000 1.000000
+vn -1.000000 0.000000 0.000000
+vn 0.000000 0.000000 -1.000000
+f 1/2/1 3//1 2//1
+f 5//2 8//2 6//2
+f 1//3 5//3 2//3
+f 2//4 6//4 3//4
+f 3//5 8//5 7//5
+f 5//6 8//6 1//6
+f 4//1 3//1 1//1
+f 8//2 7//2 6//2
+f 5//3 6//3 2//3
+f 6//4 7//4 3//4
+f 4//5 8//5 3//5
+f 1//6 4//6 8//6

resources/test1.obj

@@ -0,0 +1,39 @@
+# Blender v2.79 (sub 0) OBJ File: ''
+# www.blender.org
+mtllib test.mtl
+o Cube
+v 1.000000 -1.000000 -1.000000
+v 1.000000 -1.000000 1.000000
+v -1.000000 -1.000000 1.000000
+v -1.000000 -1.000000 -1.000000
+v 1.000000 1.000000 -0.999999
+v 0.985777 1.192230 2.337569
+v -1.377941 1.709185 1.023966
+v -1.000000 1.000000 -1.000000
+v 0.517399 2.721372 1.811071
+v -1.866757 2.621557 0.910967
+v 0.548957 1.837827 -1.224019
+v -1.690411 2.280694 -1.395202
+v -0.783580 1.471610 2.999746
+v -1.362162 2.293163 2.078320
+v -0.980705 2.326940 1.789054
+vn 0.0000 -1.0000 0.0000
+vn 0.1613 0.9751 -0.1521
+vn 1.0000 0.0026 0.0026
+vn -0.3069 -0.2775 0.9104
+vn -0.9937 -0.0793 -0.0793
+vn 0.0000 0.0000 -1.0000
+vn -0.4940 -0.8691 -0.0268
+usemtl Material
+s off
+f 1//1 2//1 3//1 4//1
+f 5//2 8//2 7//2 6//2
+f 1//3 5//3 6//3 2//3
+f 2//4 6//4 7//4 3//4
+f 3//5 7//5 8//5 4//5
+f 5//6 1//6 4//6 8//6
+f 6//7 13//7 14//7 15//7 7//7
+l 6 9
+l 7 10
+l 5 11
+l 8 12

src/main.cpp

@@ -1,50 +1,6 @@
-// General includes
-#include <chrono>
-#include <vector>
-
-// #include <glm/glm.hpp>
-// #include <glm/gtc/matrix_transform.hpp>
-// #include <glm/gtc/type_ptr.hpp>
-
-// Custom includes
-#define TINYOBJLOADER_IMPLEMENTATION
-#define LOGGER_DEFINITION
-#include <logger.h>
-
-#include "display.h"
-#include "shader.h"
-#include "model.h"
-
-int main (int argc, char** argv) {
-
-    std::cout << "-----------------------------\n"
-              << "----- SMH Render Engine -----\n"
-              << "-------- Version 0.0 --------\n"
-              << "----- ©Benjamin Kyd 2019 ----\n"
-              << "-----------------------------\n\n";
-
-    Logger logger;
-
-    Display display{"SMH Engine", logger, 1280, 720, MXAA_16X, VSYNC_ENABLED};
-
-	Shader shader;
-	shader.load("./resources/shaders/phong").attatch().link().use();
-
-	Mesh mesh{ "./resources/dragon.obj" };
-	mesh.setup();
-
-    SDL_Event e;
-    while (!display.isClosed) {
-        while (SDL_PollEvent(&e))
-            if (e.type == SDL_QUIT || e.key.keysym.sym == SDLK_ESCAPE)
-				display.isClosed = true;
-
-		mesh.bind();
-		mesh.render(shader);
-		mesh.unbind();
-
-		display.update();
-    }
+#include <iostream>
 
+int main(int argc, char** argv) {
+    std::cout << "bruh" << std::endl;
     return 0;
 }

src/material.cpp

@@ -1,43 +0,0 @@
-#include "material.h"
-
-Material::Material() {
-
-}
-
-Material::Material(std::string objPath) {
-	Logger logger;
-	objl::Loader loader;
-	bool canLoad = loader.LoadFile(objPath);
-
-	if (!canLoad) {
-		logger << LOGGER_ERROR << "Cannot load material '" << objPath << "'" << LOGGER_ENDL;
-		return;
-	}
-
-	loadFromObj(loader.LoadedMeshes[0]);
-}
-
-Material::Material(objl::Mesh objMesh) {
-	loadFromObj(objMesh);
-}
-
-void Material::loadFromObj(objl::Mesh objMesh) {
-	loadFromMat(objMesh.MeshMaterial);
-}
-
-void Material::loadFromMat(objl::Material mat) {
-	this->name = mat.name;
-	OBJLVec3toGLM(mat.Ka, this->Ka);
-	OBJLVec3toGLM(mat.Kd, this->Kd);
-	OBJLVec3toGLM(mat.Ks, this->Ks);
-	this->Ns = mat.Ns;
-	this->Ni = mat.Ni;
-	this->d = mat.d;
-	this->illum = mat.illum;
-	this->map_Ka = mat.map_Ka;
-	this->map_Kd = mat.map_Kd;
-	this->map_Ks = mat.map_Ks;
-	this->map_Ns = mat.map_Ns;
-	this->map_d = mat.map_d;
-	this->map_bump = mat.map_bump;
-}

src/util/util.cpp

@@ -1,49 +0,0 @@
-#include "util.h"
-
-#include <logger.h>
-
-void OBJLtoGLM(ObjLMesh& mesh, 
-               std::vector<glm::vec3>& outVert,
-               std::vector<glm::vec3>& outNorm,
-               std::vector<glm::vec3>& outTexCoord,
-               std::vector<GLuint>& outIndices) {
-
-    for (const auto &shape : mesh.shapes) {
-        for (const auto& index : shape.mesh.indices) {
-
-            outVert.push_back({
-                mesh.attrib.vertices[3 * index.vertex_index + 0],
-                mesh.attrib.vertices[3 * index.vertex_index + 1],
-                mesh.attrib.vertices[3 * index.vertex_index + 2]
-            });
-
-            outNorm.push_back({
-                mesh.attrib.normals[0],
-                mesh.attrib.normals[0],
-                mesh.attrib.normals[0]
-            });
-
-            outTexCoord.push_back({
-                mesh.attrib.texcoords[2 * index.texcoord_index + 0],
-                mesh.attrib.texcoords[2 * index.texcoord_index + 1],
-                0.0f
-            });
-        }
-    }
-
-}
-
-void UintToGLuint(ObjLMesh& mesh,
-                  std::vector<GLuint>& outIndices) {
-    
-}
-
-
-
-// void OBJLVec3toGLM(objl::Vector3& inVec, glm::vec3& outVec) {
-
-// 	outVec.x = inVec.X;
-// 	outVec.y = inVec.Y;
-// 	outVec.z = inVec.Z;
-
-// }