Initial commit

Author: adam4813

.gitignore

@@ -0,0 +1,48 @@
+build/
+lib/
+bin/
+raknet/
+.gitattributes
+
+## Vim
+*~
+*.swp
+
+## eclipse
+.cproject
+.project
+.settings
+
+#################################
+## Code::Blocks
+#################################
+*.bmarks
+*.cbp
+*.layout
+*_build_log.html
+
+################################
+# CMake
+################################
+CMakeCache.txt
+CMakeFiles/
+CMakeScripts/
+cmake_install.cmake
+compile_commands.json
+cscope.out
+*.cscope_file_list
+*.depend
+# We don't want to see Makefiles modifications
+Makefile
+
+################################
+#Xcode
+################################
+
+trillek-client-core.build
+trillek-client-core.xcodeproj
+
+###############################
+# NetBean
+###############################
+nbproject/

CMakeLists.txt

@@ -0,0 +1,85 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+
+PROJECT("VoxelVolution")
+
+# Set the directory of cmake modules
+SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/modules")
+
+# Put the executable in the bin folder
+SET(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
+
+# find all source files in the src directory
+FILE(GLOB_RECURSE VV_SRC "src/*.cpp")
+
+# find all the files in the includes directory
+FILE(GLOB_RECURSE VV_INCLUDES "include/*.h" "include/*.hpp")
+
+#Check if we can build with the current tool chain
+INCLUDE(SetCompilerFlags)
+
+SET(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} ${CMAKE_SOURCE_DIR}/include/)
+INCLUDE_DIRECTORIES("${CMAKE_SOURCE_DIR}/include/")
+
+# If we are on windows add in the local search directories as well.
+IF (WIN32 AND NOT MINGW) # Windows
+	SET(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} ${CMAKE_SOURCE_DIR}/lib/include/)
+	INCLUDE_DIRECTORIES("${CMAKE_SOURCE_DIR}/lib/include/")
+	LINK_DIRECTORIES("${CMAKE_SOURCE_DIR}/lib/")
+	SET(CMAKE_LIBRARY_PATH ${CMAKE_SOURCE_DIR}/lib/)
+ENDIF (WIN32 AND NOT MINGW)
+
+FIND_PACKAGE(GLM REQUIRED)
+FIND_PACKAGE(OpenGL REQUIRED)
+FIND_PACKAGE(GLFW3 REQUIRED)
+
+# Give these some dummy values and if the platform is LINUX or OSX they will be set accordingly.
+SET(X11_LIBRARIES "")
+SET(OSX_LIBRARIES "")
+
+IF (NOT APPLE) # X11 and GLEW are not needed on OSX.
+	FIND_PACKAGE(X11)
+	FIND_PACKAGE(GLEW REQUIRED) # We find GLEW here as OSX doesn't need it.
+ENDIF (NOT APPLE)
+
+IF (APPLE) # Mac OSX
+	SET(GLEW_LIBRARY "") # Set a dummy value for GLEW.
+
+	SET(CMAKE_XCODE_ATTRIBUTE_SUPPORTED_PLATFORMS macosx)
+
+	# Need the 10.7 SDK or later.
+	EXECUTE_PROCESS(COMMAND xcodebuild -sdk macosx -version SDKVersion OUTPUT_VARIABLE OSX_SDK_VERSION)
+	IF (NOT (OSX_SDK_VERSION VERSION_GREATER 10.7 OR OSX_SDK_VERSION VERSION_EQUAL 10.7))
+		MESSAGE(FATAL_ERROR "The installed version of Xcode does not support the 10.7 SDK or later.  Please upgrade Xcode and try again.")
+	ENDIF (NOT (OSX_SDK_VERSION VERSION_GREATER 10.7 OR OSX_SDK_VERSION VERSION_EQUAL 10.7))
+
+	# Configure the project to use the correct SDK.
+	IF (XCODE_VERSION)
+		SET(CMAKE_OSX_SYSROOT macosx)
+	ELSE (XCODE_VERSION)
+		# Non-Xcode generators need the full path.
+		EXECUTE_PROCESS(COMMAND xcodebuild -sdk macosx -version Path | head -n 1 OUTPUT_VARIABLE CMAKE_OSX_SYSROOT)
+		STRING(REGEX REPLACE "(\r?\n)+$" "" CMAKE_OSX_SYSROOT "${CMAKE_OSX_SYSROOT}")
+	ENDIF (XCODE_VERSION)
+
+	# Can deploy back to 10.7, the first OS X to support the GL Core.
+	SET(CMAKE_OSX_DEPLOYMENT_TARGET 10.7)
+
+	# Need Core Foundation and libobjc.
+	SET(OSX_LIBRARIES "-framework CoreFoundation /usr/lib/libobjc.dylib")
+ENDIF (APPLE)
+
+# define all required external libraries
+set(VV_ALL_LIBS
+	${OPENGL_LIBRARIES}
+	${GLFW3_LIBRARIES}
+	${X11_LIBRARIES}
+	${OSX_LIBRARIES}
+	${GLEW_LIBRARIES}
+)
+
+ADD_EXECUTABLE("VoxelVolution"
+	${VV_SRC}
+	${VV_INCLUDES}
+)
+
+TARGET_LINK_LIBRARIES("VoxelVolution" ${VV_ALL_LIBS})

assets/basic.frag

@@ -0,0 +1,7 @@
+#version 330 core
+in vec3 pass_Color;
+out vec4 color;
+ 
+void main(){
+    color = vec4(pass_Color, 1.0);
+}

assets/basic.vert

@@ -0,0 +1,13 @@
+#version 330 
+layout(location = 0) in vec3 in_Position;
+layout(location = 1) in vec3 in_Color;
+uniform mat4 model;
+uniform mat4 view;
+uniform mat4 projection;
+out vec3 pass_Color;
+void main(void)
+{
+mat4 mvp = projection * view * model;
+gl_Position = mvp * vec4(in_Position, 1.0);
+pass_Color = in_Color;
+}

assets/overlay.frag

@@ -0,0 +1,8 @@
+#version 330 core
+in vec3 pass_Color;
+out vec4 color;
+ 
+void main(){
+    gl_FragCoord.z - (1.0f / 1600000.0);
+    color = vec4(0.0,0.0,0.0,1.0);
+}

include/command-queue.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <queue>
+#include <memory>
+#include <atomic>
+#include "multiton.hpp"
+
+namespace vv {
+	// Base class used for commands. T is the command id type (e.g. enum, int, char).
+	template <typename T>
+	struct Command {
+		Command(T c, GUID entity_id) : command(c), entity_id(entity_id) { }
+		T command;
+		GUID entity_id;
+	};
+
+	// T is the command id type (e.g. enum, int, char), and U is the derived command type.
+	template <class T>
+	class CommandQueue {
+	public:
+		CommandQueue() :
+			local_queue(new std::queue<std::shared_ptr<Command<T>>>()) { }
+		~CommandQueue() { }
+
+		template <typename U, typename V>
+		static void QueueCommand(const T c, const GUID entity_id, V data = nullptr) {
+			auto command = std::make_shared<U>(c, entity_id, data);
+			(*global_queue).push(command);
+		}
+
+		static void QueueCommand(const T c, const GUID entity_id) {
+			auto command = std::make_shared<Command<T>>(c, entity_id);
+			(*global_queue).push(command);
+		}
+	protected:
+		static std::atomic<std::queue<std::shared_ptr<Command<T>>>*> global_queue;
+		std::queue<std::shared_ptr<Command<T>>>* local_queue;
+	};
+}

include/dispatcher.hpp

@@ -0,0 +1,179 @@
+#pragma once
+
+#include <list>
+#include <map>
+#include <memory>
+#include <mutex>
+
+#include "multiton.hpp"
+
+namespace vv {
+	// Base class for data change subscriptions.
+	template <typename T>
+	class Subscriber {
+	public:
+		virtual void Notify(const GUID entity_id, const T* data) { }
+		virtual void Notify(const T* data) { }
+		virtual void Notify(const GUID entity_id, const T data) { }
+		virtual void Notify(const T data) { }
+	};
+
+	// Dispatches data change notifications to the various subscribers.
+	template <typename T>
+	class Dispatcher final {
+	private:
+		Dispatcher() { }
+		Dispatcher(const Dispatcher& right) {
+			instance = right.instance;
+		}
+		Dispatcher& operator=(const Dispatcher& right) {
+			if (this != &right) {
+				instance = right.instance;
+			}
+
+			return *this;
+		}
+		static std::once_flag only_one;
+		static std::shared_ptr<Dispatcher<T>> instance;
+	public:
+		static std::shared_ptr<Dispatcher<T>> GetInstance() {
+			std::call_once(Dispatcher::only_one,
+				[ ] () {
+				Dispatcher<T>::instance.reset(new Dispatcher<T>());
+			}
+			);
+
+			return Dispatcher<T>::instance;
+		}
+		~Dispatcher() { }
+
+		/**
+		 * \brief Subscribes to be notified of data change events.
+		 *
+		 * \param const unsigned int entity_id ID of the entity to subscribe to.
+		 * \param const Subscriber<T>* subscriber The subscriber to add.
+		 * \return void
+		 */
+		void Subscribe(const GUID entity_id, Subscriber<T>* subscriber) {
+			auto sube = this->subcriberss.find(entity_id);
+			if (sube == this->subcriberss.end()) {
+				// no subscriptions for entity, add the entity and subscriber
+				this->subcriberss[entity_id].push_back(subscriber);
+				return;
+			}
+			else {
+				// check if subscriber already exists
+				for (auto sub : sube->second) {
+					if (sub == subscriber) {
+						return; // already subscribed
+					}
+				}
+				sube->second.push_back(subscriber);
+			}
+		}
+
+		/**
+		 * \brief Subscribes to be notified of data change events for any entity ID.
+		 *
+		 * \param const Subscriber<T>* subscriber The subscriber to add.
+		 * \return void
+		 */
+		void Subscribe(Subscriber<T>* subscriber) {
+			this->subcriberss[0].push_back(subscriber);
+		}
+
+		/**
+		 * \brief Unsubscribes to notification of data change events.
+		 *
+		 * \param const unsigned int entity_id ID of the entity to unsubscribe from.
+		 * \param const Subscriber<T>* subscriber The subscriber to remove.
+		 * \return void
+		 */
+		void Unsubscribe(const GUID entity_id, Subscriber<T>* subscriber) {
+			if (this->subcriberss.find(entity_id) != this->subcriberss.end()) {
+				this->subcriberss[entity_id].remove(subscriber);
+			}
+		}
+
+		/**
+		 * \brief Unsubscribes to notification of data change events.
+		 *
+		 * \param const Subscriber<T>* subscriber The subscriber to remove.
+		 * \return void
+		 */
+		void Unsubscribe(Subscriber<T>* subscriber) {
+			if (this->subcriberss.find(0) != this->subcriberss.end()) {
+				this->subcriberss[0].remove(subscriber);
+			}
+		}
+
+		/**
+		 * \brief Called to notify all subscribers that the data has changed.
+		 *
+		 * \param const unsigned int entity_id ID of the entity to update.
+		 * \param const T* data The changed data.
+		 * \return void
+		 */
+		void NotifySubscribers(const GUID entity_id, const T* data) {
+			if (this->subcriberss.find(entity_id) != this->subcriberss.end()) {
+				auto subscriber_list = this->subcriberss.at(entity_id);
+				for (Subscriber<T>* subscriber : subscriber_list) {
+					subscriber->Notify(entity_id, data);
+				}
+			}
+
+			if (this->subcriberss.find(0) != this->subcriberss.end()) {
+				auto subscriber_list = this->subcriberss.at(0);
+				for (Subscriber<T>* subscriber : subscriber_list) {
+					subscriber->Notify(entity_id, data);
+				}
+			}
+		}
+		void NotifySubscribers(const GUID entity_id, const T data) {
+			if (this->subcriberss.find(entity_id) != this->subcriberss.end()) {
+				auto subscriber_list = this->subcriberss.at(entity_id);
+				for (Subscriber<T>* subscriber : subscriber_list) {
+					subscriber->Notify(entity_id, data);
+				}
+			}
+
+			if (this->subcriberss.find(0) != this->subcriberss.end()) {
+				auto subscriber_list = this->subcriberss.at(0);
+				for (Subscriber<T>* subscriber : subscriber_list) {
+					subscriber->Notify(entity_id, data);
+				}
+			}
+		}
+
+		/**
+		 * \brief Called to notify all subscribers for entity ID 0 that the data has changed.
+		 *
+		 * \param const T* data The changed data.
+		 * \return void
+		 */
+		void NotifySubscribers(const T* data) {
+			if (this->subcriberss.find(0) != this->subcriberss.end()) {
+				auto subscriber_list = this->subcriberss.at(0);
+				for (Subscriber<T>* subscriber : subscriber_list) {
+					subscriber->Notify(data);
+				}
+			}
+		}
+		void NotifySubscribers(const T data) {
+			if (this->subcriberss.find(0) != this->subcriberss.end()) {
+				auto subscriber_list = this->subcriberss.at(0);
+				for (Subscriber<T>* subscriber : subscriber_list) {
+					subscriber->Notify(data);
+				}
+			}
+		}
+	private:
+		std::map<GUID, std::list<Subscriber<T>*>> subcriberss;
+	};
+
+	template<typename T>
+	std::once_flag Dispatcher<T>::only_one;
+
+	template<typename T>
+	std::shared_ptr<Dispatcher<T>> Dispatcher<T>::instance = nullptr;
+}

include/material.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <memory>
+
+#ifndef __APPLE__
+#include <GL/glew.h>
+#else
+#include <OpenGL/gl3.h>
+#endif
+
+namespace vv {
+	class Shader;
+
+	typedef Multiton<std::string, std::shared_ptr<Material>> MaterialMap;
+
+	class Material {
+	public:
+		Material(const std::weak_ptr<Shader> shader) : shader(shader), fill_mode(GL_FILL) { }
+
+		GLenum GetFillMode() {
+			return this->fill_mode;
+		}
+
+		void SetFillMode(const GLenum mode) {
+			switch (mode) {
+			case GL_LINE:
+			case GL_FILL:
+			this->fill_mode = mode;
+			break;
+			default:
+			this->fill_mode = GL_FILL;
+			}
+		}
+
+		std::weak_ptr<Shader> GetShader() {
+			return this->shader;
+		}
+	private:
+		GLenum fill_mode;
+		std::weak_ptr<Shader> shader;
+	};
+}

include/multiton.hpp

@@ -0,0 +1,98 @@
+#pragma once
+
+#include <map>
+
+namespace vv {
+	typedef long long GUID;
+
+	/* Based class to be used for instace or state storage.
+	*
+	* This is useful in place of static instances or globals. Derived classes
+	* can operate on the static instance member using instances of the derived
+	* class. This could allow, for example, and animation controller to derive
+	* from this and have each instance use a separate animation sequence, but
+	* all animation instance data would be stored in one map.
+	*
+	* Additionally by encapsulating the maps in this pattern we provide better
+	* data hiding and can better control access methods to the instance data.
+	*
+	* Modeled after http://en.wikipedia.org/wiki/Multiton_pattern.
+	*/
+	template <typename ID, typename T>
+	class Multiton {
+	public:
+		/**
+		* \brief Get the default instance.
+		*
+		* \return T The default instance.
+		*/
+		static T Default() {
+			return default_value;
+		}
+
+		/**
+		* \brief Set the default instance.
+		*
+		* \return void
+		*/
+		static void Default(const T value) {
+			default_value = value;
+		}
+
+		static typename std::map<ID, T>::const_iterator Begin() {
+			return instances.begin();
+		}
+
+		static typename std::map<ID, T>::const_iterator End() {
+			return instances.end();
+		}
+
+		/**
+		* \brief Get the instance for the given ID.
+		*
+		* This doesn't create an instanc if the ID doesn't exist.
+		* Instead it just returns the default.
+		* \param[in] const ID The ID of the instace to get.
+		* \return T The ID's instacnce or the default one.
+		*/
+		static T Get(const ID id) {
+			if (instances.find(id) != instances.end()) {
+				return instances.at(id);
+			}
+			return default_value;
+		}
+
+		/**
+		* \brief Set (or add/create) an instance for the given ID.
+		*
+		* \param[in] const ID id The ID of the instance to set.
+		* \param[in] T instance The ID's instance.
+		* \return void
+		*/
+		static void Set(const ID id, const T instance) {
+			instances[id] = instance;
+		}
+
+		/**
+		* \brief Remove the instance for the given ID.
+		*
+		* \param[in] const ID id The ID of the instance to remove.
+		* \return void
+		*/
+		static void Remove(const ID id) {
+			instances.erase(id);
+		}
+	protected:
+		static T default_value; // Default instance.
+
+		// TODO: Replace this with a weak_ptr to allow pruning?
+		static std::map<ID, T> instances; // Mapping of ID to instance.
+	};
+
+
+	template <typename ID, typename T>
+	std::map<ID, T> Multiton<ID, T>::instances;
+
+	template <typename ID, typename T>
+	T Multiton<ID, T>::default_value;
+}

include/os.hpp

@@ -0,0 +1,239 @@
+#pragma once
+
+#ifndef __APPLE__
+#include <GL/glew.h>
+#ifndef __unix
+#include <GL/wglew.h>
+#endif
+#endif
+
+#include <GLFW/glfw3.h>
+#include <string>
+#include <chrono>
+
+namespace vv {
+	struct KeyboardEvent {
+		enum KEY_ACTION { KEY_DOWN, KEY_UP, KEY_REPEAT, KEY_CHAR };
+		int key;
+		int scancode;
+		KEY_ACTION action;
+		int mods;
+	};
+
+	struct MouseBtnEvent {
+		enum MOUSE_BTN_ACTION { DOWN, UP };
+		enum MOUSE_BTN { LEFT, RIGHT, MIDDLE };
+		MOUSE_BTN_ACTION action;
+		MOUSE_BTN button;
+	};
+
+	struct MouseMoveEvent {
+		double norm_x, norm_y; // Resolution independent new x, y (0-1) from upper-left to lower-right.
+		int old_x, old_y; // Client space old x, y.
+		int new_x, new_y; // Client space new x, y.
+	};
+
+	class OS {
+	public:
+		OS() : mouse_lock(false) { }
+		~OS() { }
+
+		/**
+		* \brief Initialize the rendering window and makes the window's context the current one.
+		*
+		* \param[in] const unsigned int width, height The window's client width and height
+		* \param[in] const std::string title The title to show in the title bar and task manager.
+		* \return bool If creation was successful or not.
+		*/
+		bool InitializeWindow(const int width, const int height, const std::string title,
+			const unsigned int glMajor = 3, const unsigned int glMinor = 2);
+
+		/** \brief Make the context of the window current for the calling thread
+		*
+		*/
+		void MakeCurrent();
+
+		/** \brief Detach the context of the window from the calling thread
+		*
+		*/
+		void DetachContext();
+
+		/**
+		* \brief Calls GLFWTerminate to close the window.
+		*
+		* This is a static method so it can be called from anywhere to terminate the current winodw.
+		* \return void
+		*/
+		static void Terminate();
+
+		/**
+		* \brief Checks if the window is closing.
+		*
+		* \return bool True if the window is closing.
+		*/
+		bool Closing();
+
+		/**
+		* \brief Swap the front and back buffers. Call after rendering.
+		*
+		* \return void
+		*/
+		void SwapBuffers();
+
+		/**
+		* \brief Processes events in the OS message event loop.
+		*
+		*/
+		void OSMessageLoop();
+
+		/**
+		* \brief Gets the cached window width.
+		*
+		* \return int The window width.
+		*/
+		int GetWindowWidth();
+
+		/**
+		* \brief Gets the cached window height.
+		*
+		* \return int The window height.
+		*/
+		int GetWindowHeight();
+
+		/**
+		* \brief Returns the time since the start of the program.
+		*
+		* \return double The number of nanoseconds that have pass since the last call.
+		* that have passed.
+		*/
+		double GetDeltaTime();
+
+		/**
+		* \brief Callback for when the window is resized.
+		*
+		* \param[in] GLFWwindow* window
+		* \param[in] int width, height The new client width and height of the window.
+		* \return void
+		*/
+		static void WindowResized(GLFWwindow* window, int width, int height);
+
+		/**
+		* \brief Callback for keyboard events.
+		*
+		* \param[in] GLFWwindow* window
+		* \param[in] int key ASCII key number.
+		* \param[in] int scancode The converted key value
+		* \param[in] int action The event type.
+		* \param[in] int mods Modifier keys.
+		* \return void
+		*/
+		static void KeyboardEventCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
+
+		/**
+		* \brief Callback for unicode character event.
+		*
+		* This is different from just a normal keyboard event as it has been translated and modified by
+		* the OS and is just like typing into a text editor.
+		* \param[in] GLFWwindow* window
+		* \param[in] unsigned int uchar The unicode character key code.
+		* \return void
+		*/
+		static void CharacterEventCallback(GLFWwindow* window, unsigned int uchar);
+
+		/**
+		* \brief Callback for mouse move events.
+		*
+		* \param[in] GLFWwindow* window
+		* \param[in] double x, y The new x and y coordinate of the mouse in screen coordinates.
+		* \return void
+		*/
+		static void MouseMoveEventCallback(GLFWwindow* window, double x, double y);
+
+		/**
+		* \brief Callback for mouse button events.
+		*
+		* \param[in] GLFWwindow* window
+		* \param[in] int button The button that the action occurred on.
+		* \param[in] int action The action that occurred.
+		* \param[in] int mods Modifier keys.
+		* \return void
+		*/
+		static void MouseButtonEventCallback(GLFWwindow* window, int button, int action, int mods);
+
+		/**
+		* \brief Callback for window focus change events.
+		*
+		* \param[in] GLFWwindow* window
+		* \param[in] int focused GL_TRUE if focused, GL_FALSE if unfocused.
+		* \return void
+		*/
+		static void WindowFocusChangeCallback(GLFWwindow* window, int focused);
+
+		/**
+		* \brief Toggles wether the mouse cursor should be locked to the current window.
+		*
+		* \return void
+		*/
+		void ToggleMouseLock();
+
+		/**
+		* \brief Sets the mouse cursor position relative to the upper-left corner of the window.
+		*
+		* \param[in] double x, y The new x and y coordinate of the mouse in screen coordinates.
+		* \return void
+		*/
+		void SetMousePosition(const double x, const double y);
+	private:
+		/**
+		* \brief Updates the internal size variables from the windowResized callback.
+		*
+		* \param[in] const int width, height The new client width and height of the window
+		* \return void
+		*/
+		void UpdateWindowSize(const int width, const int height);
+
+		/**
+		* \brief Dispatches keyboard events from the callback.
+		*
+		* \param[in] const int key ASCII key number.
+		* \param[in] const int scancode The converted key value
+		* \param[in] const int action The event type.
+		* \param[in] const int mods Modifier keys.
+		* \return void
+		*/
+		void DispatchKeyboardEvent(const int key, const int scancode, const int action, const int mods);
+
+		/**
+		* \brief Dispatches a character event.
+		*
+		* \param[in] const unsigned int uchar The unicode character key code.
+		* \return void
+		*/
+		void DispatchCharacterEvent(const unsigned int uchar);
+
+		/**
+		* \brief Dispatches mouse movement events.
+		*
+		* It determines the changes in mouse position and stores the new position for later.
+		* \param[in] const double x, y The new x and y coordinate of the mouse in screen coordinates.
+		* \return void
+		*/
+		void DispatchMouseMoveEvent(const double x, const double y);
+
+		/**
+		* \brief Dispatches mouse button events from the callback.
+		*
+		* \param[in] const int button The button that the action occurred on.
+		* \param[in] const int action The action that occurred.
+		* \param[in] const int mods Modifier keys.
+		* \return void
+		*/
+		void DispatchMouseButtonEvent(const int button, const int action, const int mods);
+
+		GLFWwindow* window;
+		int client_width, client_height; // Current window's client width and height.
+		double old_mouse_x, old_mouse_y;
+		double last_time; // The time at the last call to GetDeltaTime().
+		bool mouse_lock; // If mouse lock is enabled causing the cursor to snap to mid-window each movement event.
+	};
+}

include/polygonmeshdata.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <vector>
+#include <memory>
+#include <map>
+#include "vertexbuffer.hpp"
+
+namespace vv {
+	class Material;
+
+	class PolygonMeshData {
+	public:
+		void SetMaterial(std::weak_ptr<Material> m, size_t submesh = 0) {
+			this->materials[submesh] = m;
+		}
+
+		// Returns the Material for specified submesh.
+		std::weak_ptr<Material> GetMaterial(size_t submesh = 0) {
+			if (this->materials.find(submesh) != this->materials.end()) {
+				return this->materials[submesh];
+			}
+		}
+
+		void AddVertex(Vertex v, size_t submesh = 0) {
+			this->verts[submesh].push_back(v);
+		}
+
+		// Returns the vertex buffer for specified submesh.
+		const std::vector<Vertex>& GetVertexBuffer(size_t submesh = 0) {
+			if (this->verts.find(submesh) != this->verts.end()) {
+				return this->verts[submesh];
+			}
+		}
+
+		void AddIndex(unsigned int i, size_t submesh = 0) {
+			this->indicies[submesh].push_back(i);
+		}
+
+		// Returns the index buffer for specified submesh.
+		const std::vector<unsigned int>& GetIndexBuffer(size_t submesh = 0) {
+			if (this->indicies.find(submesh) != this->indicies.end()) {
+				return this->indicies[submesh];
+			}
+		}
+	private:
+		std::map<size_t, std::weak_ptr<Material>> materials;
+		std::map<size_t, std::vector<Vertex>> verts;
+		std::map<size_t, std::vector<unsigned int>> indicies;
+	};
+}

include/render-system.hpp

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <memory>
+#include <list>
+#include <map>
+#include <atomic>
+#include <queue>
+#include <glm/mat4x4.hpp>
+#include <glm/gtc/quaternion.hpp>
+
+#ifndef __APPLE__
+#include <GL/glew.h>
+#else
+#include <OpenGL/gl3.h>
+#endif
+
+#include "multiton.hpp"
+#include "command-queue.hpp"
+
+namespace vv {
+	struct VertexBuffer;
+	class Material;
+
+	enum RS_COMMAND {
+		VIEW_ADD,
+		VIEW_UPDATE,
+		VIEW_ACTIVATE,
+		VIEW_REMOVE,
+		MODEL_MATRIX_ADD,
+		MODEL_MATRIX_UPDATE,
+		MODEL_MATRIX_REMOVE,
+		VB_ADD,
+		VB_REMOVE,
+	};
+
+	template <typename T>
+	struct RenderCommand : Command < RS_COMMAND > {
+		RenderCommand(const RS_COMMAND rs_c, const GUID entity_id, T data) :
+			Command(rs_c, entity_id), data(data) { }
+		T data;
+	};
+
+	struct ModelMatrix {
+		glm::mat4 transform;
+	};
+
+	typedef Multiton<GUID, std::shared_ptr<ModelMatrix>> ModelMatrixMap;
+
+	class RenderSystem : public CommandQueue < RS_COMMAND > {
+	public:
+		RenderSystem();
+
+		void SetViewportSize(const unsigned int width, const unsigned int height);
+
+		void Update(const double delta);
+
+		void AddVertexBuffer(const std::weak_ptr<Material> mat, const std::weak_ptr<VertexBuffer> buffer, const GUID entity_id);
+
+	protected:
+		void ProcessCommandQueue();
+
+		void UpdateModelMatrix(const GUID entity_id);
+
+		void RemoveModelMatrix(const GUID entity_id);
+
+		void UpdateViewMatrix(const GUID eneity_id);
+
+		//void CreateVertexBuffer(GUID entity_id, const std::vector<Vertex>& verts, const std::vector<GLuint>& indicies);
+	private:
+		glm::mat4 projection;
+		std::map<GUID, glm::mat4> views;
+		GUID current_view;
+		unsigned int window_width, window_height;
+		std::map<std::weak_ptr<Material>, std::pair<std::weak_ptr<VertexBuffer>, std::list<GUID>>, std::owner_less<std::weak_ptr<Material>>> buffers;
+	};
+}

include/shader.hpp

@@ -0,0 +1,167 @@
+#pragma once
+
+#ifndef __APPLE__
+#include <GL/glew.h>
+#else
+#include <OpenGL/gl3.h>
+#endif
+
+#include <string>
+#include <map>
+#include <vector>
+#include <fstream>
+#include <iostream>
+
+namespace vv {
+	class Shader;
+
+	typedef Multiton<std::string, std::shared_ptr<Shader>> ShaderMap;
+
+	class Shader {
+	public:
+		enum ShaderType : GLenum {
+			VERTEX = GL_VERTEX_SHADER,
+			FRAGMENT = GL_FRAGMENT_SHADER,
+			GEOMETRY = GL_GEOMETRY_SHADER,
+		};
+
+
+		Shader::Shader() : program(0) { }
+
+		Shader::~Shader() {
+			DeleteProgram();
+		}
+
+		void DeleteProgram() {
+			if (this->program != 0) {
+				glDeleteProgram(this->program);
+			}
+			this->program = 0;
+			for (auto s : this->shaders) {
+				glDeleteShader(s);
+			}
+			this->shaders.clear();
+		}
+
+		void LoadFromFile(const ShaderType type, const std::string fname) {
+			std::ifstream fp;
+			fp.open(fname, std::ios_base::in);
+			if (fp.is_open()) {
+				std::string buffer(std::istreambuf_iterator<char>(fp), (std::istreambuf_iterator<char>()));
+				LoadFromString(type, buffer);
+			}
+		}
+
+		void LoadFromString(const ShaderType type, const std::string source) {
+			glGetError();
+			GLuint shader = glCreateShader(type);
+			if (glGetError()) {
+				return;
+			}
+
+			GLint length = source.length();
+			const GLchar *str = source.data();
+			glShaderSource(shader, 1, &str, &length);
+			if (glGetError()) {
+				return;
+			}
+
+			glCompileShader(shader);
+			if (glGetError()) {
+				return;
+			}
+			GLint status;
+			glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
+			if (status == GL_FALSE) {
+				GLint log_length;
+				glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
+				GLchar *info_log = new GLchar[log_length];
+				glGetShaderInfoLog(shader, log_length, NULL, info_log);
+				std::cout << "Error compiling shader: " << info_log;
+				delete[] info_log;
+			}
+			if (glGetError()) {
+				return;
+			}
+			this->shaders.push_back(shader);
+		}
+
+		void Build() {
+			this->program = glCreateProgram();
+
+			for (auto shader : this->shaders) {
+				glAttachShader(this->program, shader);
+			}
+
+			glLinkProgram(this->program);
+
+			GLint is_linked = 0;
+			glGetProgramiv(this->program, GL_LINK_STATUS, (int *)&is_linked);
+			if (is_linked == GL_FALSE) {
+				GLint max_length = 0;
+				glGetProgramiv(this->program, GL_INFO_LOG_LENGTH, &max_length);
+
+				std::vector<GLchar> info_log(max_length);
+				glGetProgramInfoLog(this->program, max_length, &max_length, &info_log[0]);
+				std::copy(info_log.begin(), info_log.end(), std::ostream_iterator<GLchar>(std::cout, ""));
+
+				DeleteProgram();
+
+				return;
+			}
+
+			for (auto shader : this->shaders) {
+				glDetachShader(this->program, shader);
+			}
+		}
+
+		void Use() {
+			glUseProgram(this->program);
+		}
+
+		void UnUse() {
+			glUseProgram(0);
+		}
+
+		void ActivateTextureUnit(const GLuint unit, const GLuint name) {
+
+		}
+
+		static void DeactivateTextureUnit(const GLuint unit) {
+
+		}
+
+		GLint GetUniform(const std::string name) {
+			if (this->uniforms.find(name) != this->uniforms.end()) {
+				return this->uniforms.at(name);
+			}
+			else {
+				GLint uniform_id = glGetUniformLocation(this->program, name.c_str());
+				if (uniform_id) {
+					this->uniforms[name] = uniform_id;
+				}
+				return uniform_id;
+			}
+			return 0;
+		}
+
+		GLint GetAttribute(const std::string name) {
+			if (this->attributes.find(name) != this->attributes.end()) {
+				return this->attributes.at(name);
+			}
+			else {
+				GLint attribute_id = glGetAttribLocation(this->program, name.c_str());
+				if (attribute_id) {
+					this->attributes[name] = attribute_id;
+				}
+				return attribute_id;
+			}
+			return 0;
+		}
+	private:
+		GLuint program;
+		std::vector<GLuint> shaders;
+		std::map<std::string, GLint> attributes;
+		std::map<std::string, GLint> uniforms;
+	};
+}

include/transform.hpp

@@ -0,0 +1,133 @@
+#pragma once
+
+#include <memory>
+#include <glm/glm.hpp>
+#include <glm/gtx/quaternion.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include "multiton.hpp"
+
+namespace vv {
+	enum TRANSFORM_COMMAND { TRANSFORM_ADDED, TRANSFORM_UPDATED, TRANSFORM_REMOVED };
+
+	class Transform;
+	typedef Multiton<GUID, std::shared_ptr<Transform>> TransformMap;
+
+	static glm::vec3 FORWARD_VECTOR(0.0f, 0.0f, -1.0f);
+	static glm::vec3 UP_VECTOR(0.0f, 1.0f, 0.0f);
+	static glm::vec3 RIGHT_VECTOR(1.0f, 0.0f, 0.0f);
+
+	class Transform final {
+	public:
+		Transform() : Transform(0) { };
+
+		Transform(GUID entity_id);
+		/**
+		 * \brief Translates by the provided amount relative to the current translation.
+		 *
+		 * \param[in] const glm::vec3 amount The amount to translate by.
+		 */
+		void Translate(const glm::vec3 amount);
+
+		/**
+		 * \brief Rotates by the provided amount relative to the current rotation.
+		 *
+		 * The arguments are in the form of (rotation about x, rotation about y, rotation about z).
+		 * The orientation is also updated by computing the axis-angle.
+		 * \param[in] const glm::vec3 amount The amount to rotate by.
+		 */
+		void Rotate(const glm::vec3 amount);
+
+		/**
+		 * \brief Translates by the provided amount relative to the current translation and orientation.
+		 *
+		 * \param[in] const glm::vec3 amount The amount to translate by.
+		 */
+		void OrientedTranslate(const glm::vec3 amount);
+
+		/**
+		 * \brief Rotates by the provided amount relative to the current rotation and orientation.
+		 *
+		 * The arguments are in the form of (rotation about x, rotation about y, rotation about z).
+		 * The orientation is also updated by computing the axis-angle.
+		 * \param[in] const glm::vec3 amount The amount to rotate by.
+		 */
+		void OrientedRotate(const glm::vec3 amount);
+
+		/**
+		 * \brief Scales by the provided amount relative to the current scale.
+		 *
+		 * The current scale is multiplied by the given amount.
+		 * \param[in] const glm::vec3 amount The amount to scale by.
+		 */
+		void Scale(const glm::vec3 amount);
+
+		/**
+		 * \brief Sets the translation.
+		 *
+		 * \param[in] const glm::vec3 new_translation The new translation.
+		 */
+		void SetTranslation(const glm::vec3 new_translation);
+
+		/**
+		 * \brief Sets the rotation.
+		 *
+		 * The arguments are in the form of (rotation about x, rotation about y, rotation about z).
+		 * The orientation is also set by computing the axis-angle.
+		 * \param[in] const glm::vec3 new_rotation The new rotation.
+		 */
+		void SetRotation(const glm::vec3 new_rotation);
+
+		/**
+		 * \brief Sets the rotation.
+		 *
+		 * \param[in] const glm::quat new_orientation The new orientation.
+		 */
+		void SetOrientation(const glm::quat new_orientation);
+
+		/**
+		 * \brief Sets the scale.
+		 *
+		 * \param[in] const glm::vec3 new_scale The new scale.
+		 */
+		void SetScale(const glm::vec3 new_scale);
+
+		/**
+		 * \brief Translates by the provided amount relative to the current translation
+		 *
+		 * \return glm::vec3 The current transform.
+		 */
+		glm::vec3 GetTranslation() const;
+
+		/**
+		 * \brief Returns the current rotation, not orientation.
+		 *
+		 * \return glm::vec3 The current rotation.
+		 */
+		glm::vec3 GetRotation() const;
+
+		/**
+		 * \brief Returns the current orientation, not rotation.
+		 *
+		 * \return glm::quat The current orientation.
+		 */
+		glm::quat GetOrientation() const;
+
+		/**
+		 * \brief Returns the current scale.
+		 *
+		 * \return glm::vec3 The current scale.
+		 */
+		glm::vec3 GetScale() const;
+
+		GUID GetEntityID() const {
+			return this->entity_id;
+		}
+	private:
+		glm::vec3 translation;
+		glm::vec3 rotation;
+		glm::vec3 scale;
+		glm::quat orientation;
+		GUID entity_id;
+	};
+
+}

include/vertexbuffer.hpp

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <vector>
+#include <memory>
+
+#include "multiton.hpp"
+
+#ifndef __APPLE__
+#include <GL/glew.h>
+#else
+#include <OpenGL/gl3.h>
+#endif
+
+namespace vv {
+	struct VertexBuffer;
+	typedef Multiton<GUID, std::shared_ptr<VertexBuffer>> VertexBufferMap;
+
+	// TODO: Move to Mesh class file
+	struct Vertex {
+		Vertex(const float x = 0.0f, const float y = 0.0f, const float z = 0.0f, const float r = 0.0f, const float g = 0.0f, const float b = 0.0f) {
+			this->position[0] = x; this->position[1] = y; this->position[2] = z;
+			this->color[0] = r; this->color[1] = g; this->color[2] = b;
+		}
+		float position[3];
+		float color[3];
+	};
+
+	// Holds vertex and index buffer "names".
+	struct VertexBuffer {
+		VertexBuffer() : vao(0), vbo(0), ibo(0), vertex_count(0), index_count(0) { }
+		void Buffer(const std::vector<Vertex>& verts, const std::vector<GLuint>& indicies) {
+			if (!this->vao) {
+				glGenVertexArrays(1, &this->vao);
+			}
+			if (!this->vbo) {
+				glGenBuffers(1, &this->vbo);
+			}
+			if (!this->ibo) {
+				glGenBuffers(1, &this->ibo);
+			}
+
+			glBindVertexArray(this->vao);
+			glBindBuffer(GL_ARRAY_BUFFER, this->vbo);
+			// If the size hasn't changed we can call update
+			if (this->vertex_count >= verts.size()) {
+				auto* buffer = glMapBufferRange(GL_ARRAY_BUFFER, 0, verts.size() * sizeof(Vertex), GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
+				if (buffer) {
+					memcpy(buffer, &verts[0], verts.size() * sizeof(Vertex));
+					glUnmapBuffer(GL_ARRAY_BUFFER);
+				}
+				else {
+					//std::err << "glMapBufferRange() failed" << __LINE__ << __FILE__ << std::endl;
+				}
+			}
+			else {
+				glBufferData(GL_ARRAY_BUFFER, verts.size() * sizeof(Vertex), &verts[0], GL_STATIC_DRAW);
+				this->vertex_count = verts.size();
+			}
+
+			glVertexAttribPointer((GLuint)0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)offsetof(Vertex, position));
+			glEnableVertexAttribArray(0);
+			glVertexAttribPointer((GLuint)1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)offsetof(Vertex, color));
+			glEnableVertexAttribArray(1);
+
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->ibo);
+			if (this->index_count >= indicies.size()) {
+				auto* buffer = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0, indicies.size() * sizeof(GLuint), GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
+				if (buffer) {
+					memcpy(buffer, &indicies[0], indicies.size() * sizeof(Vertex));
+					glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
+				}
+				else {
+					//std::err << "glMapBufferRange() failed" << __LINE__ << __FILE__ << std::endl;
+				}
+			}
+			else {
+				glBufferData(GL_ELEMENT_ARRAY_BUFFER, indicies.size() * sizeof(GLuint), &indicies[0], GL_STATIC_DRAW);
+				this->index_count = indicies.size();
+			}
+			glBindVertexArray(0);
+		}
+		GLuint vao, vbo, ibo;
+		size_t vertex_count;
+		size_t index_count;
+	};
+}

include/voxelvolume.hpp

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <unordered_map>
+#include <map>
+#include <vector>
+#include <queue>
+
+#include "command-queue.hpp"
+
+namespace vv {
+	struct Vertex;
+
+	struct Voxel {
+		Voxel() {
+			this->neighbors[UP] = nullptr; this->neighbors[DOWN] = nullptr;
+			this->neighbors[LEFT] = nullptr; this->neighbors[RIGHT] = nullptr;
+			this->neighbors[FRONT] = nullptr; this->neighbors[BACK] = nullptr;
+		}
+		enum NEIGHBORS { UP = 0, DOWN, LEFT, RIGHT, FRONT, BACK };
+		float color[3];
+		Voxel* neighbors[6];
+	};
+
+	enum VOXEL_COMMAND { VOXEL_ADD, VOXEL_REMOVE };
+
+	struct VoxelCommand : Command < VOXEL_COMMAND > {
+		VoxelCommand(const VOXEL_COMMAND voxel_c, const GUID entity_id, std::tuple<short, short, short> position) :
+			Command(voxel_c, entity_id) {
+			this->row = std::get<0>(position);
+			this->column = std::get<1>(position);
+			this->slice = std::get<2>(position);
+		}
+		short row, column, slice;
+	};
+
+	class VoxelVolume : public CommandQueue < VOXEL_COMMAND > {
+	public:
+		VoxelVolume();
+		~VoxelVolume();
+
+	protected:
+		// All values are relative to the front orientation and centered on the root voxel.
+		// Slize is depth (away from the screen is positive). Row is up/down. Column is left/right.
+		// Therefore adding a voxel to the front face is AddVoxel(0, 0, 1).
+		void AddVoxel(const short row, const short column, const short slice);
+
+		// See AddVoxel().
+		void RemoveVoxel(const short row, const short column, const short slice);
+
+		void ProcessCommandQueue();
+	public:
+		// Iterates over all the actions queued before the call to update.
+		void Update(double delta);
+
+		// Generates a vertex (and index) buffer for the current voxel state.
+		void UpdateVertexBuffers();
+
+		// Returns the vertex buffer.
+		const std::vector<Vertex>& GetVertexBuffer() {
+			return this->verts;
+		}
+
+		// Returns the index buffer.
+		const std::vector<unsigned int>& GetIndexBuffer() {
+			return this->indicies;
+		}
+	private:
+		std::unordered_map<long long, Voxel> voxels;
+		std::vector<Vertex> verts;
+		std::vector<unsigned int> indicies;
+		std::map<std::tuple<float, float, float>, unsigned int> index_list;
+	};
+}

modules/FindGLEW.cmake

@@ -0,0 +1,46 @@
+# - Find the OpenGL Extension Wrangler Library (GLEW)
+# This module defines the following variables:
+#  GLEW_INCLUDE_DIRS - include directories for GLEW
+#  GLEW_LIBRARIES - libraries to link against GLEW
+#  GLEW_FOUND - true IF GLEW has been found and can be used
+
+#=============================================================================
+# Copyright 2012 Benjamin Eikel
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+find_path(GLEW_INCLUDE_DIR GL/glew.h)
+SET(GLEW_DEBUG_NAMES glew32_debug)
+SET(GLEW_NAMES glew32)
+add_definitions(-DGLEW_STATIC)
+
+# Reset the variables so that find_library will rescan in case we changed from static to none (or vice versa).
+UNSET(GLEW_LIBRARY)
+UNSET(GLEW_DEBUG_LIBRARY)
+
+FIND_LIBRARY(GLEW_LIBRARY NAMES ${GLEW_NAMES} PATH_SUFFIXES x64 amd64 lib64)
+FIND_LIBRARY(GLEW_DEBUG_LIBRARY NAMES ${GLEW_DEBUG_NAMES} PATH_SUFFIXES x64 amd64 lib64)
+
+IF(NOT GLEW_DEBUG_LIBRARY AND GLEW_LIBRARY)
+	SET(GLEW_DEBUG_LIBRARY ${GLEW_LIBRARY})
+ENDIF(NOT GLEW_DEBUG_LIBRARY AND GLEW_LIBRARY)
+
+SET(GLEW_INCLUDE_DIRS ${GLEW_INCLUDE_DIR})
+SET(GLEW_LIBRARIES debug ${GLEW_DEBUG_LIBRARY} optimized ${GLEW_LIBRARY})
+
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(  GLEW
+									DEFAULT_MSG
+									GLEW_LIBRARIES
+									GLEW_INCLUDE_DIR
+									)
+
+MARK_AS_ADVANCED(GLEW_INCLUDE_DIR GLEW_LIBRARY GLEW_DEBUG_LIBRARY)

modules/FindGLFW3.cmake

@@ -0,0 +1,66 @@
+#
+# Try to find GLFW library and include path.
+# Once done this will define
+#
+# GLFW3_FOUND
+# GLFW3_INCLUDE_PATH
+# GLFW3_LIBRARY
+#
+
+IF(WIN32)
+	FIND_PATH( GLFW3_INCLUDE_PATH GLFW/glfw3.h
+		$ENV{PROGRAMFILES}/GLFW/include
+		${GLFW_ROOT_DIR}/include
+		DOC "The directory where GLFW/glfw3.h resides")
+
+	FIND_LIBRARY( GLFW3_LIBRARY
+		NAMES glfw3 glfw3dll
+		PATHS
+		$ENV{PROGRAMFILES}/GLFW/lib
+		${GLFW_ROOT_DIR}/lib
+		PATH_SUFFIXES x64 amd64
+		DOC "The GLFW library")
+	FIND_LIBRARY( GLFW3_DEBUG_LIBRARY
+		NAMES glfw3_debug glfw3dll
+		PATHS
+		$ENV{PROGRAMFILES}/GLFW/lib
+		${GLFW_ROOT_DIR}/lib
+		PATH_SUFFIXES x64 amd64
+		DOC "The GLFW library")
+ELSE(WIN32)
+	FIND_PATH( GLFW3_INCLUDE_PATH GLFW/glfw3.h
+		/usr/include
+		/usr/local/include
+		/sw/include
+		/opt/local/include
+		${GLFW_ROOT_DIR}/include
+		DOC "The directory where GLFW/glfw3.h resides")
+	IF(APPLE)
+		# For the case where GLFW is installed in a non-standard lib path such as /opt or /sw
+		INCLUDE_DIRECTORIES( "${GLFW3_INCLUDE_PATH}" )
+	ENDIF(APPLE)
+
+	FIND_LIBRARY( GLFW3_LIBRARY
+		NAMES libglfw.so libglfw.so.3 libglfw.so.3.0 glfw.3 glfw3
+		PATHS
+		/usr/lib64
+		/usr/lib
+		/usr/local/lib64
+		/usr/local/lib
+		/sw/lib
+		/opt/local/lib
+		${GLFW_ROOT_DIR}/lib
+		DOC "The GLFW library")
+ENDIF(WIN32)
+
+IF(NOT GLFW3_DEBUG_LIBRARY AND GLFW3_LIBRARY)
+	SET(GLFW3_DEBUG_LIBRARY ${GLFW3_LIBRARY})
+ENDIF()
+
+set(GLFW3_INCLUDE_PATH ${GLFW3_INCLUDE_PATH})
+set(GLFW3_LIBRARIES debug ${GLFW3_DEBUG_LIBRARY} optimized ${GLFW3_LIBRARY})
+
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(GLFW3 DEFAULT_MESSAGE GLFW3_LIBRARIES GLFW3_INCLUDE_PATH)
+
+mark_as_advanced(GLFW3_LIBRARIES GLFW3_INCLUDE_PATH GLFW3_LIBRARY GLFW3_DEBUG_LIBRARY)

modules/FindGLM.cmake

@@ -0,0 +1,63 @@
+# FindGLM - attempts to locate the glm matrix/vector library.
+#
+# This module defines the following variables (on success):
+#   GLM_INCLUDE_DIRS  - where to find glm/glm.hpp
+#   GLM_FOUND         - if the library was successfully located
+#
+# It is trying a few standard installation locations, but can be customized
+# with the following variables:
+#   GLM_ROOT_DIR      - root directory of a glm installation
+#                       Headers are expected to be found in either:
+#                       <GLM_ROOT_DIR>/glm/glm.hpp           OR
+#                       <GLM_ROOT_DIR>/include/glm/glm.hpp
+#                       This variable can either be a cmake or environment
+#                       variable. Note however that changing the value
+#                       of the environment varible will NOT result in
+#                       re-running the header search and therefore NOT
+#                       adjust the variables set by this module.
+
+#=============================================================================
+# Copyright 2012 Carsten Neumann
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# default search dirs
+SET(_glm_HEADER_SEARCH_DIRS
+	"/usr/include"
+	"/usr/local/include")
+
+# check environment variable
+SET(_glm_ENV_ROOT_DIR "$ENV{GLM_ROOT_DIR}")
+
+IF(NOT GLM_ROOT_DIR AND _glm_ENV_ROOT_DIR)
+	SET(GLM_ROOT_DIR "${_glm_ENV_ROOT_DIR}")
+ENDIF(NOT GLM_ROOT_DIR AND _glm_ENV_ROOT_DIR)
+
+# put user specified location at beginning of search
+IF(GLM_ROOT_DIR)
+	SET(_glm_HEADER_SEARCH_DIRS "${GLM_ROOT_DIR}"
+								"${GLM_ROOT_DIR}/include"
+								 ${_glm_HEADER_SEARCH_DIRS})
+ENDIF(GLM_ROOT_DIR)
+
+# locate header
+FIND_PATH(GLM_INCLUDE_DIR "glm/glm.hpp"
+	PATHS ${_glm_HEADER_SEARCH_DIRS})
+
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(GLM DEFAULT_MSG
+	GLM_INCLUDE_DIR)
+
+IF(GLM_FOUND)
+	SET(GLM_INCLUDE_DIRS "${GLM_INCLUDE_DIR}")
+	mark_as_advanced(GLM_INCLUDE_DIR)
+	MESSAGE(STATUS "GLM_INCLUDE_DIR = ${GLM_INCLUDE_DIR}")
+ENDIF(GLM_FOUND)

modules/SetCompilerFlags.cmake

@@ -0,0 +1,34 @@
+# check for gcc version to set c++11 or c++0x.
+# thanks to http://stackoverflow.com/questions/10984442/how-to-detect-c11-support-of-a-compiler-with-cmake .
+IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+	execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
+	IF (GCC_VERSION VERSION_GREATER 4.7 OR GCC_VERSION VERSION_EQUAL 4.7)
+		MESSAGE("Supported GCC!")
+		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+	ENDIF (GCC_VERSION VERSION_GREATER 4.7 OR GCC_VERSION VERSION_EQUAL 4.7)
+ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") # Clang 3.3 and up support c++11.
+	MESSAGE("Clang Version: " ${CMAKE_CXX_COMPILER_VERSION})
+	# On OS X, Clang 3.3 would be Clang/LLVM 5.0.
+	IF (APPLE)
+		SET(CLANG_MIN_VERSION 5.0)
+	ELSE (APPLE)
+		SET(CLANG_MIN_VERSION 3.3)
+	ENDIF (APPLE)
+	IF (NOT (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER CLANG_MIN_VERSION OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL CLANG_MIN_VERSION))
+		# clang 3.3 is the first release that completley implements the c++11 standard.
+		# However, most of c++11 was implemented in previous versions.
+		MESSAGE("clang ${CMAKE_CXX_COMPILER_VERSION} does not completely support c++11. This may cause some problems in the future. We recommend upgrading to clang-3.3 (Xcode 5.0) or greater.")
+	ENDIF (NOT (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER CLANG_MIN_VERSION OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL CLANG_MIN_VERSION))
+	# compiler is clang 3.3 or higher. Force c++11 and use libc++.
+	IF (XCODE_VERSION)
+		SET(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD c++11)
+		SET(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY libc++)
+	ELSE (XCODE_VERSION)
+		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -stdlib=libc++")
+	ENDIF (XCODE_VERSION)
+	UNSET(CLANG_MIN_VERSION)
+ELSEIF (MSVC AND (MSVC_VERSION GREATER 1699))
+		MESSAGE("Supported Visual Studio!")
+ELSE ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+	MESSAGE(FATAL_ERROR "Your C++ compiler does not support C++11.")
+ENDIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")

src/main.cpp

@@ -0,0 +1,114 @@
+#include "os.hpp"
+#include "dispatcher.hpp"
+#include "render-system.hpp"
+#include "vertexbuffer.hpp"
+#include "shader.hpp"
+#include "multiton.hpp"
+#include "voxelvolume.hpp"
+#include "transform.hpp"
+#include "material.hpp"
+#include <glm/gtc/matrix_transform.hpp>
+
+struct CameraMover : public vv::Subscriber < vv::KeyboardEvent > {
+	CameraMover() {
+		vv::Dispatcher<vv::KeyboardEvent>::GetInstance()->Subscribe(this);
+	}
+	void Notify(const vv::KeyboardEvent* data) {
+		auto transform = vv::TransformMap::Get(1);
+		switch (data->action) {
+		case vv::KeyboardEvent::KEY_UP:
+		switch (data->key) {
+		case GLFW_KEY_A:
+		transform->OrientedRotate(glm::vec3(0.0, glm::radians(10.0f), 0.0));
+		break;
+		case GLFW_KEY_D:
+		transform->OrientedRotate(glm::vec3(0.0, glm::radians(-10.0f), 0.0));
+		break;
+		case GLFW_KEY_W:
+		transform->OrientedTranslate(glm::vec3(0.0, 0.0, -1.0));
+		break;
+		case GLFW_KEY_S:
+		transform->OrientedTranslate(glm::vec3(0.0, 0.0, 1.0));
+		break;
+		case GLFW_KEY_SPACE:
+		vv::RenderSystem::QueueCommand(vv::VIEW_ACTIVATE, 1);
+		break;
+		}
+		vv::RenderSystem::QueueCommand(vv::MODEL_MATRIX_UPDATE, 1);
+		break;
+		default:
+		break;
+		}
+	}
+};
+
+int main(int argc, void* argv) {
+	vv::OS os;
+
+	os.InitializeWindow(800, 600, "VoxelVolution 0.1", 3, 2);
+
+	vv::RenderSystem rs;
+
+	rs.SetViewportSize(800, 600);
+
+	vv::VoxelVolume voxvol;
+
+	auto s = std::make_shared<vv::Shader>();
+	s->LoadFromFile(vv::Shader::VERTEX, "basic.vert");
+	s->LoadFromFile(vv::Shader::FRAGMENT, "basic.frag");
+	s->Build();
+	vv::ShaderMap::Set("shader1", s);
+
+	auto basic_fill = std::make_shared<vv::Material>(s);
+	vv::MaterialMap::Set("material_basic", basic_fill);
+
+	auto s_overlay = std::make_shared<vv::Shader>();
+	s_overlay->LoadFromFile(vv::Shader::VERTEX, "basic.vert");
+	s_overlay->LoadFromFile(vv::Shader::FRAGMENT, "overlay.frag");
+	s_overlay->Build();
+	vv::ShaderMap::Set("shader_overlay", s_overlay);
+
+	auto overlay = std::make_shared<vv::Material>(s_overlay);
+	overlay->SetFillMode(GL_LINE);
+	vv::MaterialMap::Set("material_overlay", overlay);
+
+	auto voxvol_transform = std::make_shared<vv::Transform>();
+	vv::TransformMap::Set(100, voxvol_transform);
+	auto vb = std::make_shared<vv::VertexBuffer>();
+	vv::VertexBufferMap::Set(100, vb);
+
+	vv::VoxelVolume::QueueCommand<vv::VoxelCommand, std::tuple<short, short, short>>(vv::VOXEL_ADD, 100, std::tuple<short, short, short>(0, 1, 1));
+	vv::VoxelVolume::QueueCommand<vv::VoxelCommand, std::tuple<short, short, short>>(vv::VOXEL_ADD, 100, std::tuple<short, short, short>(0, -1, 1));
+	vv::VoxelVolume::QueueCommand<vv::VoxelCommand, std::tuple<short, short, short>>(vv::VOXEL_ADD, 100, std::tuple<short, short, short>(0, -1, 0));
+	vv::VoxelVolume::QueueCommand<vv::VoxelCommand, std::tuple<short, short, short>>(vv::VOXEL_ADD, 100, std::tuple<short, short, short>(0, -1, -1));
+	vv::VoxelVolume::QueueCommand<vv::VoxelCommand, std::tuple<short, short, short>>(vv::VOXEL_ADD, 100, std::tuple<short, short, short>(1, -1, 1));
+
+	voxvol.Update(0.0);
+	vb->Buffer(voxvol.GetVertexBuffer(), voxvol.GetIndexBuffer());
+	rs.AddVertexBuffer(basic_fill, vb, 100);
+	rs.AddVertexBuffer(overlay, vb, 100);
+
+	auto vb2 = std::make_shared<vv::VertexBuffer>();
+	vv::VertexBufferMap::Set(1, vb2);
+	vb2->Buffer(voxvol.GetVertexBuffer(), voxvol.GetIndexBuffer());
+	rs.AddVertexBuffer(basic_fill, vb2, 1);
+
+	auto camera_transform = std::make_shared<vv::Transform>();
+	vv::TransformMap::Set(1, camera_transform);
+	vv::RenderSystem::QueueCommand(vv::VIEW_ACTIVATE, 1);
+	vv::RenderSystem::QueueCommand(vv::MODEL_MATRIX_ADD, 1);
+
+	auto camera_transform2 = std::make_shared<vv::Transform>();
+	vv::TransformMap::Set(2, camera_transform2);
+	vv::RenderSystem::QueueCommand(vv::MODEL_MATRIX_ADD, 2);
+
+	CameraMover cam_mover;
+
+	while (!os.Closing()) {
+		rs.Update(os.GetDeltaTime());
+		os.OSMessageLoop();
+		os.SwapBuffers();
+	}
+
+	return 0;
+}

src/os.cpp

@@ -0,0 +1,275 @@
+#include "os.hpp"
+
+#include <iostream>
+#include "dispatcher.hpp"
+
+#ifdef __APPLE__
+// Needed so we can disable retina support for our window.
+#define GLFW_EXPOSE_NATIVE_COCOA 1
+#define GLFW_EXPOSE_NATIVE_NSGL 1
+#include <GLFW/glfw3native.h>
+// We can't just include objc/runtime.h and objc/message.h because glfw is too forward thinking for its own good.
+typedef void* SEL;
+extern "C" id objc_msgSend(id self, SEL op, ...);
+extern "C" SEL sel_getUid(const char *str);
+#endif
+
+namespace vv {
+
+	// Error helper function used by GLFW for error messaging.
+	// Currently outputs to std::cout.
+	static void ErrorCallback(int error, const char* description) {
+		std::cout << description << std::endl;
+	}
+
+	bool OS::InitializeWindow(const int width, const int height, const std::string title,
+		const unsigned int glMajor /*= 3*/, const unsigned int glMinor /*= 2*/) {
+		glfwSetErrorCallback(ErrorCallback);
+
+		// Initialize the library.
+		if (glfwInit() != GL_TRUE) {
+			return false;
+		}
+
+		glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
+		glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, glMajor);
+		glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, glMinor);
+
+#ifndef __APPLE__
+#ifdef _DEBUG
+		glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);
+#else
+		glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+#endif
+#else
+		glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+#endif
+
+		// Create a windowed mode window and its OpenGL context.
+		this->window = glfwCreateWindow(width, height, title.c_str(), NULL, NULL);
+
+		if (!this->window) {
+			glfwTerminate();
+			return false;
+		}
+
+		this->client_width = width;
+		this->client_height = height;
+
+#ifdef __APPLE__
+		// Force retina displays to create a 1x framebuffer so we don't choke our fillrate.
+		id cocoaWindow = glfwGetCocoaWindow(this->window);
+		id cocoaGLView = ((id (*)(id, SEL)) objc_msgSend)(cocoaWindow, sel_getUid("contentView"));
+		((void (*)(id, SEL, bool)) objc_msgSend)(cocoaGLView, sel_getUid("setWantsBestResolutionOpenGLSurface:"), false);
+#endif
+
+		// attach the context
+		glfwMakeContextCurrent(this->window);
+
+#ifndef __APPLE__
+		// setting glewExperimental fixes a glfw context problem
+		// (tested on Ubuntu 13.04)
+		glewExperimental = GL_TRUE;
+
+		// Init GLEW.
+		GLuint error = glewInit();
+		if (error != GLEW_OK) {
+			return false;
+		}
+#endif
+
+		// Associate a pointer for this instance with this window.
+		glfwSetWindowUserPointer(this->window, this);
+
+		// Set up some callbacks.
+		glfwSetWindowSizeCallback(this->window, &OS::WindowResized);
+		glfwSetKeyCallback(this->window, &OS::KeyboardEventCallback);
+		glfwSetCursorPosCallback(this->window, &OS::MouseMoveEventCallback);
+		glfwSetCharCallback(this->window, &OS::CharacterEventCallback);
+		glfwSetMouseButtonCallback(this->window, &OS::MouseButtonEventCallback);
+		glfwSetWindowFocusCallback(this->window, &OS::WindowFocusChangeCallback);
+
+		glfwGetCursorPos(this->window, &this->old_mouse_x, &this->old_mouse_y);
+
+		return true;
+	}
+
+	void OS::MakeCurrent() {
+		glfwMakeContextCurrent(this->window);
+	}
+
+	void OS::DetachContext() {
+		glfwMakeContextCurrent(NULL);
+	}
+
+	void OS::Terminate() {
+		glfwTerminate();
+	}
+
+	bool OS::Closing() {
+		return glfwWindowShouldClose(this->window) > 0;
+	}
+
+	void OS::SwapBuffers() {
+		glfwSwapBuffers(this->window);
+	}
+
+	void OS::OSMessageLoop() {
+		glfwPollEvents();
+	}
+
+	int OS::GetWindowWidth() {
+		return this->client_width;
+	}
+
+	int OS::GetWindowHeight() {
+		return this->client_height;
+	}
+
+	double OS::GetDeltaTime() {
+		double new_time = glfwGetTime();
+		double delta_time = new_time - this->last_time;
+		this->last_time = new_time;
+		return delta_time;
+	}
+
+	void OS::WindowResized(GLFWwindow* window, int width, int height) {
+		// Get the user pointer and cast it.
+		OS* os = static_cast<OS*>(glfwGetWindowUserPointer(window));
+
+		if (os) {
+			os->UpdateWindowSize(width, height);
+		}
+	}
+
+	void OS::KeyboardEventCallback(GLFWwindow* window, int key, int scancode, int action, int mods) {
+		// Get the user pointer and cast it.
+		OS* os = static_cast<OS*>(glfwGetWindowUserPointer(window));
+
+		if (os) {
+			os->DispatchKeyboardEvent(key, scancode, action, mods);
+		}
+	}
+
+	void OS::CharacterEventCallback(GLFWwindow* window, unsigned int uchar) {
+		// Get the user pointer and cast it.
+		OS* os = static_cast<OS*>(glfwGetWindowUserPointer(window));
+
+		if (os) {
+			os->DispatchCharacterEvent(uchar);
+		}
+	}
+
+	void OS::MouseMoveEventCallback(GLFWwindow* window, double x, double y) {
+		// Get the user pointer and cast it.
+		OS* os = static_cast<OS*>(glfwGetWindowUserPointer(window));
+
+		if (os) {
+			os->DispatchMouseMoveEvent(x, y);
+		}
+	}
+
+	void OS::MouseButtonEventCallback(GLFWwindow* window, int button, int action, int mods) {
+		// Get the user pointer and cast it.
+		OS* os = static_cast<OS*>(glfwGetWindowUserPointer(window));
+
+		if (os) {
+			os->DispatchMouseButtonEvent(button, action, mods);
+		}
+	}
+
+	void OS::WindowFocusChangeCallback(GLFWwindow* window, int focused) {
+		if (focused == GL_FALSE) {
+			// Get the user pointer and cast it.
+			OS* os = static_cast<OS*>(glfwGetWindowUserPointer(window));
+
+			if (os) {
+				// TODO: Implement a DispatchWindowFocusEvent() method in OS
+				// TODO: Dispatch a focus changed event.
+			}
+		}
+	}
+
+	void OS::UpdateWindowSize(const int width, const int height) {
+		this->client_width = width;
+		this->client_height = height;
+	}
+
+	void OS::DispatchKeyboardEvent(const int key, const int scancode, const int action, const int mods) {
+		KeyboardEvent key_event;
+		if (action == GLFW_PRESS) {
+			key_event = { key, scancode, KeyboardEvent::KEY_DOWN, mods };
+		}
+		else if (action == GLFW_REPEAT) {
+			key_event = { key, scancode, KeyboardEvent::KEY_REPEAT, mods };
+		}
+		else if (action == GLFW_RELEASE) {
+			key_event = { key, scancode, KeyboardEvent::KEY_UP, mods };
+		}
+
+		Dispatcher<KeyboardEvent>::GetInstance()->NotifySubscribers(&key_event);
+	}
+
+	void OS::DispatchCharacterEvent(const unsigned int uchar) {
+		KeyboardEvent key_event { (const int)uchar, 0, KeyboardEvent::KEY_CHAR, 0 };
+		Dispatcher<KeyboardEvent>::GetInstance()->NotifySubscribers(&key_event);
+	}
+
+	void OS::DispatchMouseMoveEvent(const double x, const double y) {
+		MouseMoveEvent mmov_event = {
+			static_cast<double>(x) / this->client_width,
+			static_cast<double>(y) / this->client_height,
+			static_cast<int>(this->old_mouse_x),
+			static_cast<int>(this->old_mouse_y),
+			static_cast<int>(x),
+			static_cast<int>(y)
+		};
+		Dispatcher<MouseMoveEvent>::GetInstance()->NotifySubscribers(&mmov_event);
+
+		// If we are in mouse lock we will snap the mouse to the middle of the screen.
+		if (this->mouse_lock) {
+			this->old_mouse_x = this->client_width / 2;
+			this->old_mouse_y = this->client_height / 2;
+			glfwSetCursorPos(this->window, this->old_mouse_x, this->old_mouse_y);
+		}
+		else {
+			this->old_mouse_x = x;
+			this->old_mouse_y = y;
+		}
+	}
+
+	void OS::DispatchMouseButtonEvent(const int button, const int action, const int mods) {
+		MouseBtnEvent mbtn_event;
+		if (action == GLFW_PRESS) {
+			mbtn_event.action = MouseBtnEvent::DOWN;
+		}
+		else {
+			mbtn_event.action = MouseBtnEvent::UP;
+		}
+		if (button == GLFW_MOUSE_BUTTON_LEFT) {
+			mbtn_event.button = MouseBtnEvent::LEFT;
+		}
+		else if (button == GLFW_MOUSE_BUTTON_RIGHT) {
+			mbtn_event.button = MouseBtnEvent::RIGHT;
+		}
+		else if (button == GLFW_MOUSE_BUTTON_MIDDLE) {
+			mbtn_event.button = MouseBtnEvent::MIDDLE;
+		}
+		Dispatcher<MouseBtnEvent>::GetInstance()->NotifySubscribers(&mbtn_event);
+	}
+
+	void OS::ToggleMouseLock() {
+		this->mouse_lock = !this->mouse_lock;
+		if (this->mouse_lock) {
+			glfwSetInputMode(this->window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+		}
+		else {
+			glfwSetInputMode(this->window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+		}
+	}
+
+	void OS::SetMousePosition(const double x, const double y) {
+		glfwSetCursorPos(this->window, x, y);
+	}
+
+}

src/render-system.cpp

@@ -0,0 +1,212 @@
+#include "render-system.hpp"
+#include <glm/gtc/matrix_transform.hpp>
+#include <iostream>
+#include <thread>
+
+#include "shader.hpp"
+#include "vertexbuffer.hpp"
+#include "transform.hpp"
+#include "material.hpp"
+
+namespace vv {
+	class Texture {
+	public:
+		GLuint name;
+	};
+
+	typedef Multiton<std::string, std::shared_ptr<Texture>> TextureMap;
+
+	std::atomic<std::queue<std::shared_ptr<Command<RS_COMMAND>>>*> RenderSystem::global_queue = new std::queue<std::shared_ptr<Command<RS_COMMAND>>>();
+
+	RenderSystem::RenderSystem() : current_view(0) {
+		auto err = glGetError();
+		if (err) {
+			return;
+		}
+		// Use the GL3 way to get the version number
+		int gl_version[3];
+		glGetIntegerv(GL_MAJOR_VERSION, &gl_version[0]);
+		glGetIntegerv(GL_MINOR_VERSION, &gl_version[1]);
+		if (err) {
+			return;
+		}
+		int opengl_version = gl_version[0] * 100 + gl_version[1] * 10;
+
+		if (opengl_version < 300) {
+			std::cerr << "OpenGL version " << opengl_version << std::endl;
+			assert(opengl_version >= 300);
+		}
+
+		SetViewportSize(800, 600);
+		glEnable(GL_DEPTH_TEST);
+		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+	}
+
+	void RenderSystem::SetViewportSize(const unsigned int width, const unsigned int height) {
+		this->window_height = height;
+		this->window_width = width;
+
+		float aspect_ratio = static_cast<float>(this->window_width) / static_cast<float>(this->window_height);
+		if (aspect_ratio < 1.0f) {
+			aspect_ratio = 4.0f / 3.0f;
+		}
+
+		this->projection = glm::perspective(
+			glm::radians(45.0f),
+			aspect_ratio,
+			0.1f,
+			10000.0f
+			);
+	}
+
+	void RenderSystem::ProcessCommandQueue() {
+		auto queue = global_queue.exchange(this->local_queue);
+
+		while (!queue->empty()) {
+			auto action = queue->front();
+			queue->pop();
+
+			switch (action->command) {
+			case RS_COMMAND::VIEW_ACTIVATE:
+			this->current_view = action->entity_id;
+			case RS_COMMAND::VIEW_ADD:
+			case RS_COMMAND::VIEW_UPDATE:
+			UpdateViewMatrix(action->entity_id);
+			break;
+			case RS_COMMAND::VIEW_REMOVE:
+			this->views.erase(action->entity_id);
+			break;
+			case RS_COMMAND::MODEL_MATRIX_ADD:
+			case RS_COMMAND::MODEL_MATRIX_UPDATE:
+			UpdateModelMatrix(action->entity_id);
+			break;
+			case RS_COMMAND::MODEL_MATRIX_REMOVE:
+			RemoveModelMatrix(action->entity_id);
+			break;
+			case RS_COMMAND::VB_ADD:
+			/*auto cast_command = static_cast<RenderCommand<std::weak_ptr<vv::VertexBuffer>>*>(action);
+			if (cast_command->data.lock()) {
+			cast_command->data.reset();
+			}*/
+			break;
+			}
+		}
+	}
+
+	void RenderSystem::Update(const double delta) {
+		ProcessCommandQueue();
+		static float red = 0.3f, blue = 0.3f, green = 0.3f;
+
+		glClearColor(red, green, blue, 1.0f);
+		glViewport(0, 0, this->window_width, this->window_height);
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+
+		auto camera_matrix = this->views[this->current_view];
+
+		for (auto material_group : this->buffers) {
+			auto material = material_group.first.lock();
+			if (!material) {
+				continue;
+			}
+			glPolygonMode(GL_FRONT_AND_BACK, material->GetFillMode());
+			auto shader = material->GetShader().lock();
+			if (!material) {
+				continue;
+			}
+			shader->Use();
+
+			glUniformMatrix4fv(shader->GetUniform("view"), 1, GL_FALSE, &camera_matrix[0][0]);
+			glUniformMatrix4fv(shader->GetUniform("projection"), 1, GL_FALSE, &this->projection[0][0]);
+			GLint model_index = shader->GetUniform("model");
+
+			auto vb = material_group.second.first.lock();
+			if (!vb) {
+				continue;
+			}
+			glBindVertexArray(vb->vao);
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vb->ibo);
+			/*for (size_t i = 0; i < mesh_group.second.textures.size(); ++i) {
+				auto tex = mesh_group.second.textures[i].lock();
+				GLuint name = 0;
+				if (tex) {
+				name = tex->name;
+				}
+				shader->ActivateTextureUnit(i, name);
+				}*/
+
+			for (GUID entity_id : material_group.second.second) {
+				auto transform = ModelMatrixMap::Get(entity_id);
+				if (transform) {
+					glUniformMatrix4fv(model_index, 1, GL_FALSE,
+						&transform->transform[0][0]);
+				}
+				else {
+					static glm::mat4 identity(1.0);
+					glUniformMatrix4fv(model_index, 1, GL_FALSE,
+						&identity[0][0]);
+				}
+				/*auto renanim = ren_group.animations.find(entity_id);
+				if (renanim != ren_group.animations.end()) {
+				glUniform1i(u_animate_loc, 1);
+				auto &animmatricies = renanim->second->matrices;
+				glUniformMatrix4fv(u_animatrix_loc, animmatricies.size(), GL_FALSE, &animmatricies[0][0][0]);
+				}
+				else {
+				glUniform1i(u_animate_loc, 0);
+				}*/
+				glDrawElements(GL_TRIANGLES, vb->index_count, GL_UNSIGNED_INT, 0);
+			}
+
+			shader->UnUse();
+		}
+	}
+
+	void RenderSystem::AddVertexBuffer(const std::weak_ptr<Material> mat, const std::weak_ptr<VertexBuffer> buffer, const GUID entity_id) {
+		auto mat1 = mat.lock();
+		for (auto material_group : this->buffers) {
+			auto mat2 = material_group.first.lock();
+			if ((mat1 && mat2) && (mat1 == mat2)) {
+				auto vb1 = buffer.lock();
+				auto vb2 = material_group.second.first.lock();
+				if ((vb1 && vb2) && (vb1 == vb2)) {
+					material_group.second.second.push_back(entity_id);
+					return;
+				}
+			}
+		}
+		std::list<GUID> entity_list;
+		entity_list.push_back(entity_id);
+		this->buffers[mat] = std::make_pair(buffer, std::move(entity_list));
+	}
+
+	void RenderSystem::UpdateModelMatrix(const GUID entity_id) {
+		auto model_matrix = ModelMatrixMap::Get(entity_id);
+		auto transform = TransformMap::Get(entity_id);
+		if (!model_matrix && transform) {
+			model_matrix = std::make_shared<ModelMatrix>();
+			ModelMatrixMap::Set(entity_id, model_matrix);
+		}
+		else if (!transform) {
+			return;
+		}
+
+		auto camera_translation = transform->GetTranslation();
+		auto camera_orientation = transform->GetOrientation();
+		model_matrix->transform = glm::translate(glm::mat4(1.0), camera_translation) * glm::mat4_cast(camera_orientation);
+		if (this->views.find(entity_id) != this->views.end()) {
+			UpdateViewMatrix(entity_id);
+		}
+	}
+
+	void RenderSystem::RemoveModelMatrix(const GUID entity_id) {
+		ModelMatrixMap::Remove(entity_id);
+	}
+
+	void RenderSystem::UpdateViewMatrix(const GUID entity_id) {
+		auto model_matrix = ModelMatrixMap::Get(entity_id);
+		if (!model_matrix) {
+			return;
+		}
+		this->views[entity_id] = glm::inverse(model_matrix->transform);
+	}
+}

src/transform.cpp

@@ -0,0 +1,90 @@
+#include "transform.hpp"
+
+namespace vv {
+	Transform::Transform(GUID entity_id) :
+		orientation(glm::quat(1, 0, 0, 0)), scale(1.0f), entity_id(entity_id) { }
+
+	void Transform::Translate(const glm::vec3 amount) {
+		this->translation += amount;
+	}
+
+	void Transform::Rotate(const glm::vec3 amount) {
+		this->rotation += amount;
+
+		glm::quat change(this->rotation);
+		this->orientation = glm::normalize(change * this->orientation);
+	}
+
+	void Transform::OrientedTranslate(const glm::vec3 amount) {
+		this->translation += this->orientation * amount;
+	}
+
+	void Transform::OrientedRotate(const glm::vec3 amount) {
+		this->rotation += amount;
+
+		glm::quat qX = glm::angleAxis(amount.x, this->orientation * RIGHT_VECTOR);
+		glm::quat qY = glm::angleAxis(amount.y, this->orientation * UP_VECTOR);
+		glm::quat qZ = glm::angleAxis(amount.z, this->orientation * glm::vec3(0.0, 0.0, 1.0)); // Z axis not Forward
+		glm::quat change = qX * qY * qZ;
+
+		this->orientation = glm::normalize(change * this->orientation);
+	}
+
+	void Transform::Scale(const glm::vec3 amount) {
+		this->scale *= amount;
+	}
+
+	void Transform::SetTranslation(const glm::vec3 new_translation) {
+		this->translation = new_translation;
+	}
+
+	void Transform::SetRotation(const glm::vec3 new_rotation) {
+		this->orientation = glm::normalize(glm::quat(new_rotation));
+		this->rotation.x = atan2(2.0f * (this->orientation.y * this->orientation.z +
+			this->orientation.w * this->orientation.x),
+			this->orientation.w * this->orientation.w - this->orientation.x *
+			this->orientation.x - this->orientation.y * this->orientation.y +
+			this->orientation.z * this->orientation.z);
+		this->rotation.y = glm::asin(-2.0f * (this->orientation.x * this->orientation.z - this->orientation.w * this->orientation.y));
+		this->rotation.z = atan2(2.0f * (this->orientation.x * this->orientation.y +
+			this->orientation.w * this->orientation.z),
+			this->orientation.w * this->orientation.w + this->orientation.x *
+			this->orientation.x - this->orientation.y * this->orientation.y -
+			this->orientation.z * this->orientation.z);
+	}
+
+	void Transform::SetOrientation(const glm::quat new_orientation) {
+		this->orientation = new_orientation;
+		this->rotation.x = atan2(2.0f * (this->orientation.y * this->orientation.z +
+			this->orientation.w * this->orientation.x),
+			this->orientation.w * this->orientation.w - this->orientation.x *
+			this->orientation.x - this->orientation.y * this->orientation.y +
+			this->orientation.z * this->orientation.z);
+		this->rotation.y = glm::asin(-2.0f * (this->orientation.x * this->orientation.z - this->orientation.w * this->orientation.y));
+		this->rotation.z = atan2(2.0f * (this->orientation.x * this->orientation.y +
+			this->orientation.w * this->orientation.z),
+			this->orientation.w * this->orientation.w + this->orientation.x *
+			this->orientation.x - this->orientation.y * this->orientation.y -
+			this->orientation.z * this->orientation.z);
+	}
+
+	void Transform::SetScale(const glm::vec3 new_scale) {
+		this->scale = new_scale;
+	}
+
+	glm::vec3 Transform::GetTranslation() const {
+		return this->translation;
+	}
+
+	glm::vec3 Transform::GetRotation() const {
+		return this->rotation;
+	}
+
+	glm::quat Transform::GetOrientation() const {
+		return this->orientation;
+	}
+
+	glm::vec3 Transform::GetScale() const {
+		return this->scale;
+	}
+}

src/voxelvolume.cpp

@@ -0,0 +1,171 @@
+#include "voxelvolume.hpp"
+#include "vertexbuffer.hpp"
+
+namespace vv {
+	std::atomic<std::queue<std::shared_ptr<Command<VOXEL_COMMAND>>>*> VoxelVolume::global_queue = new std::queue<std::shared_ptr<Command<VOXEL_COMMAND>>>();
+
+	VoxelVolume::VoxelVolume() { }
+
+	VoxelVolume::~VoxelVolume() { }
+
+	void VoxelVolume::AddVoxel(const short row, const short column, const short slice) {
+		Voxel v;
+		long long index = (unsigned long long(row & 0xFFFF) << 32) + (unsigned int(column & 0xFFFF) << 16) + unsigned(slice & 0xFFFF);
+
+		if (this->voxels.find(index) == this->voxels.end()) {
+			this->voxels[index] = v;
+
+			// Since we are adding a voxel we must set the new voxels neighors.
+			long long up_index, down_index, left_index, right_index, back_index, front_index;
+			up_index = (unsigned long long((row + 1) & 0xFFFF) << 32) + (unsigned int(column & 0xFFFF) << 16) + unsigned(slice & 0xFFFF);
+			down_index = (unsigned long long((row - 1) & 0xFFFF) << 32) + (unsigned int(column & 0xFFFF) << 16) + unsigned(slice & 0xFFFF);
+			left_index = (unsigned long long(row & 0xFFFF) << 32) + (unsigned int((column - 1) & 0xFFFF) << 16) + unsigned(slice & 0xFFFF);
+			right_index = (unsigned long long(row & 0xFFFF) << 32) + (unsigned int((column + 1) & 0xFFFF) << 16) + unsigned(slice & 0xFFFF);
+			front_index = (unsigned long long(row & 0xFFFF) << 32) + (unsigned int(column & 0xFFFF) << 16) + unsigned((slice - 1) & 0xFFFF);
+			back_index = (unsigned long long(row & 0xFFFF) << 32) + (unsigned int(column & 0xFFFF) << 16) + unsigned((slice + 1) & 0xFFFF);
+
+			if (this->voxels.find(up_index) != this->voxels.end()) {
+				v.neighbors[Voxel::UP] = &this->voxels[up_index];
+				this->voxels[up_index].neighbors[Voxel::DOWN] = &this->voxels[index];
+			}
+			if (this->voxels.find(down_index) != this->voxels.end()) {
+				v.neighbors[Voxel::DOWN] = &this->voxels[down_index];
+				this->voxels[down_index].neighbors[Voxel::UP] = &this->voxels[index];
+			}
+			if (this->voxels.find(left_index) != this->voxels.end()) {
+				v.neighbors[Voxel::LEFT] = &this->voxels[left_index];
+				this->voxels[left_index].neighbors[Voxel::RIGHT] = &this->voxels[index];
+			}
+			if (this->voxels.find(right_index) != this->voxels.end()) {
+				v.neighbors[Voxel::RIGHT] = &this->voxels[right_index];
+				this->voxels[right_index].neighbors[Voxel::LEFT] = &this->voxels[index];
+			}
+			if (this->voxels.find(front_index) != this->voxels.end()) {
+				v.neighbors[Voxel::FRONT] = &this->voxels[front_index];
+				this->voxels[front_index].neighbors[Voxel::BACK] = &this->voxels[index];
+			}
+			if (this->voxels.find(back_index) != this->voxels.end()) {
+				v.neighbors[Voxel::BACK] = &this->voxels[back_index];
+				this->voxels[back_index].neighbors[Voxel::FRONT] = &this->voxels[index];
+			}
+		}
+	}
+
+	void VoxelVolume::RemoveVoxel(const short row, const short column, const short slice) {
+		long long index = (unsigned long long(row & 0xFFFF) << 32) + (unsigned int(column & 0xFFFF) << 16) + unsigned(slice & 0xFFFF);
+
+		if (this->voxels.find(index) != this->voxels.end()) {
+			Voxel& v = this->voxels[index];
+
+			long long up_index, down_index, left_index, right_index, back_index, front_index;
+			up_index = (unsigned long long((row + 1) & 0xFFFF) << 32) + (unsigned int(column & 0xFFFF) << 16) + unsigned(slice & 0xFFFF);
+			down_index = (unsigned long long((row - 1) & 0xFFFF) << 32) + (unsigned int(column & 0xFFFF) << 16) + unsigned(slice & 0xFFFF);
+			left_index = (unsigned long long(row & 0xFFFF) << 32) + (unsigned int((column - 1) & 0xFFFF) << 16) + unsigned(slice & 0xFFFF);
+			right_index = (unsigned long long(row & 0xFFFF) << 32) + (unsigned int((column + 1) & 0xFFFF) << 16) + unsigned(slice & 0xFFFF);
+			front_index = (unsigned long long(row & 0xFFFF) << 32) + (unsigned int(column & 0xFFFF) << 16) + unsigned((slice - 1) & 0xFFFF);
+			back_index = (unsigned long long(row & 0xFFFF) << 32) + (unsigned int(column & 0xFFFF) << 16) + unsigned((slice + 1) & 0xFFFF);
+
+			if (this->voxels.find(up_index) != this->voxels.end()) {
+				this->voxels[up_index].neighbors[Voxel::DOWN] = nullptr;
+			}
+			if (this->voxels.find(down_index) != this->voxels.end()) {
+				this->voxels[down_index].neighbors[Voxel::UP] = nullptr;
+			}
+			if (this->voxels.find(left_index) != this->voxels.end()) {
+				this->voxels[left_index].neighbors[Voxel::RIGHT] = nullptr;
+			}
+			if (this->voxels.find(right_index) != this->voxels.end()) {
+				this->voxels[right_index].neighbors[Voxel::LEFT] = nullptr;
+			}
+			if (this->voxels.find(front_index) != this->voxels.end()) {
+				this->voxels[front_index].neighbors[Voxel::BACK] = nullptr;
+			}
+			if (this->voxels.find(back_index) != this->voxels.end()) {
+				this->voxels[back_index].neighbors[Voxel::FRONT] = nullptr;
+			}
+			this->voxels.erase(index);
+		}
+	}
+
+	void VoxelVolume::Update(double delta) {
+		ProcessCommandQueue();
+		UpdateVertexBuffers();
+	}
+
+	void VoxelVolume::ProcessCommandQueue() {
+		auto queue = global_queue.exchange(this->local_queue);
+
+		while (!queue->empty()) {
+			auto action = queue->front();
+			queue->pop();
+			auto voxel_action = static_cast<VoxelCommand*>(action.get());
+
+			switch (action->command) {
+			case VOXEL_ADD:
+			AddVoxel(voxel_action->row, voxel_action->column, voxel_action->slice);
+			break;
+			case VOXEL_REMOVE:
+			RemoveVoxel(voxel_action->row, voxel_action->column, voxel_action->slice);
+			break;
+			}
+		}
+	}
+
+	void VoxelVolume::UpdateVertexBuffers() {
+		this->verts.clear();
+		this->index_list.clear();
+		this->indicies.clear();
+		static std::vector<Vertex> IdentityVerts({
+			// Front
+			Vertex(-1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f),	// Bottom left
+			Vertex(1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 0.0f),	// Bottom right
+			Vertex(1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f),		// Top right
+			Vertex(-1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f),	// Top Left
+			// Back
+			Vertex(-1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f),	// Bottom left
+			Vertex(1.0f, -1.0f, -1.0f, 0.0f, 1.0f, 0.0f),	// Bottom right
+			Vertex(1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f),	// Top right
+			Vertex(-1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f)	// Top left
+		});
+
+		for (auto v : this->voxels) {
+			short row = short((v.first & 0xFFFF00000000) >> 32);
+			short column = short((v.first & 0xFFFF0000) >> 16);
+			short slice = short(v.first & 0xFFFF);
+			GLuint index[8];
+
+			for (size_t i = 0; i < 8; ++i) {
+				auto vert_position = std::make_tuple(IdentityVerts[i].position[0] + column * 2,
+					IdentityVerts[i].position[1] + row * 2, IdentityVerts[i].position[2] + slice * 2);
+
+				if (this->index_list.find(vert_position) == this->index_list.end()) {
+					this->verts.push_back(Vertex(IdentityVerts[i].position[0] + column * 2,
+						IdentityVerts[i].position[1] + row * 2, IdentityVerts[i].position[2] + slice * 2,
+						IdentityVerts[i].color[0], IdentityVerts[i].color[1], IdentityVerts[i].color[2]));
+					//v.second.color[0], v.second.color[1], v.second.color[2]));
+					this->index_list[vert_position] = this->index_list.size();
+				}
+				index[i] = this->index_list[vert_position];
+			}
+
+			// Front
+			this->indicies.push_back(index[0]); this->indicies.push_back(index[1]); this->indicies.push_back(index[2]);
+			this->indicies.push_back(index[2]); this->indicies.push_back(index[3]); this->indicies.push_back(index[0]);
+			// Top
+			this->indicies.push_back(index[3]); this->indicies.push_back(index[2]); this->indicies.push_back(index[6]);
+			this->indicies.push_back(index[6]); this->indicies.push_back(index[7]); this->indicies.push_back(index[3]);
+			// Back
+			this->indicies.push_back(index[7]); this->indicies.push_back(index[6]); this->indicies.push_back(index[5]);
+			this->indicies.push_back(index[5]); this->indicies.push_back(index[4]); this->indicies.push_back(index[7]);
+			// Bottom
+			this->indicies.push_back(index[4]); this->indicies.push_back(index[5]); this->indicies.push_back(index[1]);
+			this->indicies.push_back(index[1]); this->indicies.push_back(index[0]); this->indicies.push_back(index[4]);
+			// Left
+			this->indicies.push_back(index[4]); this->indicies.push_back(index[0]); this->indicies.push_back(index[3]);
+			this->indicies.push_back(index[3]); this->indicies.push_back(index[7]); this->indicies.push_back(index[4]);
+			// Right
+			this->indicies.push_back(index[1]); this->indicies.push_back(index[5]); this->indicies.push_back(index[6]);
+			this->indicies.push_back(index[6]); this->indicies.push_back(index[2]); this->indicies.push_back(index[1]);
+		}
+	}
+}