Implemented basic containers and ref pointers

CMakeLists.txt

@@ -1,9 +1,25 @@
 cmake_minimum_required(VERSION 3.15)
 
+set(CMAKE_CXX_STANDARD_REQUIRED 17)
+
 # Handle superbuild first
 option (USE_SUPERBUILD "Whether or not a superbuild should be invoked" ON)
 
-set (GLOBAL_OUTPUT_PATH ${CMAKE_BINARY_DIR})
+set(ENGINE_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/src/Engine)
+set(EXTERNAL_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/external)
+set(SLANG_ROOT ${EXTERNAL_ROOT}/slang)
+set(BOOST_ROOT ${EXTERNAL_ROOT}/boost)
+set(GLM_ROOT ${EXTERNAL_ROOT}/glm)
+set(GLFW_ROOT ${EXTERNAL_ROOT}/glfw)
+set(CMAKE_BINARY_DIR ${CMAKE_CURRENT_SOURCE_DIR}/bin/${CMAKE_BUILD_TYPE})
+set(RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+set(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR})
+
+# Configuration types
+SET(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "Configs" FORCE)
+IF(DEFINED CMAKE_BUILD_TYPE AND CMAKE_VERSION VERSION_GREATER "2.8")
+  SET_PROPERTY(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS  ${CMAKE_CONFIGURATION_TYPES})
+ENDIF()
 
 set(Boost_USE_STATIC_LIBS ON)
 set(Boost_LIB_PREFIX lib)
@@ -26,12 +42,19 @@ include_directories(${GLFW_INCLUDE_DIRS})
 include_directories(${GLM_INCLUDE_DIRS})
 include_directories(${Vulkan_INCLUDE_DIR})
 include_directories(${Boost_INCLUDE_DIRS})
+include_directories(${SLANG_INCLUDE_DIRS})
+include_directories(src/Engine)
 add_definitions(${GLM_DEFINITIONS})
-add_definitions(${VULKAN_DEFINITIONS})
-add_definitions(${BOOST_DEFINITIONS})
-add_executable(SeeleEngine src/Engine/main.cpp src/Engine/Graphics/Graphics.cpp)
+add_definitions(${Vulkan_DEFINITIONS})
+add_definitions(${Boost_DEFINITIONS})
+add_executable(SeeleEngine "")
+add_subdirectory(src/)
 target_link_libraries(SeeleEngine ${Boost_LIBRARIES})
 target_link_libraries(SeeleEngine ${Vulkan_LIBRARY})
 target_link_libraries(SeeleEngine ${GLFW_LIBRARY})
+target_link_libraries(SeeleEngine ${SLANG_LIBRARY})
+
+add_subdirectory(test/)
+
+add_custom_command(TARGET SeeleEngine POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different ${DEPENDENT_BINARIES} $<TARGET_FILE_DIR:SeeleEngine>)
 
-message(STATUS "TEST")

CMakeSettings.json

@@ -1,17 +1,16 @@
 {
   "configurations": [
     {
-      "name": "x64-Debug",
+      "name": "Debug",
       "generator": "Ninja",
       "configurationType": "Debug",
-      "inheritEnvironments": [ "msvc_x64" ],
+      "inheritEnvironments": [ "msvc_x64_x64" ],
       "buildRoot": "${projectDir}\\bin\\${name}",
-      "installRoot": "${projectDir}\\out\\install\\${name}",
+      "installRoot": "${projectDir}\\install\\${name}",
       "cmakeCommandArgs": "",
-      "buildCommandArgs": "",
+      "buildCommandArgs": "-v",
       "ctestCommandArgs": "",
-      "variables": [],
-      "intelliSenseMode": "windows-clang-x86"
+      "variables": []
     }
   ]
 }

cmake/SuperBuild.cmake

@@ -4,33 +4,39 @@ set_property(DIRECTORY PROPERTY EP_BASE external)
 
 set(DEPENDENCIES)
 set(EXTRA_CMAKE_ARGS)
+set(DEPENDENT_BINARIES "")
 
 #-------------BOOST----------------
 list(APPEND DEPENDENCIES boost)
+if(WIN32)
+	set(BOOTSTRAP_EXTENSION bat)
+elseif(UNIX)
+	set(BOOTSTRAP_EXTENSION sh)
+endif()
 ExternalProject_Add(boost
-	SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external/boost
-	CONFIGURE_COMMAND ./bootstrap.sh --with-libraries=serialization
+	SOURCE_DIR ${BOOST_ROOT}
+	UPDATE_COMMAND ""
+	CONFIGURE_COMMAND ./bootstrap.${BOOTSTRAP_EXTENSION} --with-libraries=serialization,test
 	BUILD_COMMAND ./b2 link=static
 	BUILD_IN_SOURCE 1
 	INSTALL_COMMAND "")
 
 list (APPEND EXTRA_CMAKE_ARGS
-	-DBOOST_ROOT=${CMAKE_CURRENT_SOURCE_DIR}/external/boost
 	-DBoost_NO_SYSTEM_PATHS=ON)
 
 #----------------GLM-----------------------
 list(APPEND DEPENDENCIES glm)
 ExternalProject_Add(glm
-	SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external/glm
-	BINARY_DIR ${CMAKE_BINARY_DIR}/lib
+	SOURCE_DIR ${GLM_ROOT}
 	CONFIGURE_COMMAND ""
 	BUILD_COMMAND ""
 	INSTALL_COMMAND "")
 
 list(APPEND EXTRA_CMAKE_ARGS
-	-DGLM_INCLUDE_DIRS=${CMAKE_CURRENT_SOURCE_DIR}/external/glm
+	-DGLM_INCLUDE_DIRS=${GLM_ROOT}
 	)
 
+
 #--------------GLFW------------------------------
 list(APPEND DEPENDENCIES glfw)
 set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
@@ -38,31 +44,40 @@ set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
 set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
 
 ExternalProject_Add(glfw
-	SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external/glfw
-	BINARY_DIR ${CMAKE_BINARY_DIR}/lib/glfw
+	SOURCE_DIR ${GLFW_ROOT}
+	BINARY_DIR ${CMAKE_BINARY_DIR}/lib
 	INSTALL_COMMAND "")
 
 list(APPEND EXTRA_CMAKE_ARGS
-	-DGLFW_INCLUDE_DIRS=${CMAKE_CURRENT_SOURCE_DIR}/external/glfw/include
-	-DGLFW_LIBRARY=${CMAKE_BINARY_DIR}/lib/glfw/src/glfw3.lib
+	-DGLFW_INCLUDE_DIRS=${GLFW_ROOT}/include
+	-DGLFW_LIBRARY=${CMAKE_BINARY_DIR}/lib/src/glfw3.lib
 	)
 
 #--------------SLang------------------------------
 list(APPEND DEPENDENCIES slang)
 ExternalProject_Add(slang
-	SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external/slang
+	SOURCE_DIR ${SLANG_ROOT}
 	BINARY_DIR ${CMAKE_BINARY_DIR}/lib
 	CONFIGURE_COMMAND ""
-	
-	BUILD_COMMAND msbuild -m /p:WindowsTargetPlatformVersion=10.0 ${CMAKE_SOURCE_DIR}/external/slang/slang.sln
-
+	BUILD_COMMAND ""
+	# BUILD_COMMAND devenv /upgrade ${SLANG_ROOT}/source/slang/slang.vcxproj
+	# 	COMMAND msbuild -m /p:WindowsTargetPlatformVersion=10.0 ${SLANG_ROOT}/source/slang/slang.vcxproj
 	INSTALL_COMMAND "")
 
+list(APPEND EXTRA_CMAKE_ARGS
+	-DSLANG_INCLUDE_DIRS=${EXTERNAL_ROOT}
+	-DSLANG_LIBRARY=${SLANG_ROOT}/bin/windows-x64/${CMAKE_BUILD_TYPE}/slang.lib)
+	
+set(SLANG_DLL)
+string(TOLOWER bin/windows-x64/${CMAKE_BUILD_TYPE}/slang.dll SLANG_DLL)
+list(APPEND DEPENDENT_BINARIES ${SLANG_ROOT}/${SLANG_DLL})
 
+list(APPEND EXTRA_CMAKE_ARGS
+	-DDEPENDENT_BINARIES=${DEPENDENT_BINARIES})
 #-----------------SeeleEngine--------------------
 ExternalProject_Add(SeeleEngine
 	DEPENDS ${DEPENDENCIES}
 	SOURCE_DIR ${PROJECT_SOURCE_DIR}
 	CMAKE_ARGS -DUSE_SUPERBUILD=OFF ${EXTRA_CMAKE_ARGS}
 	INSTALL_COMMAND ""
-	BINARY_DIR ${CMAKE_CURRENT_SOURCE_DIR}/bin)
+	BINARY_DIR ${CMAKE_BINARY_DIR})

src/CMakeLists.txt

@@ -0,0 +1,2 @@
+
+add_subdirectory(Engine/)

src/Engine/CMakeLists.txt

@@ -0,0 +1,8 @@
+target_sources(SeeleEngine
+    PRIVATE
+        MinimalEngine.h
+        main.cpp)
+
+add_subdirectory(Graphics/)
+add_subdirectory(Math/)
+add_subdirectory(Containers/)

src/Engine/Containers/Array.h

@@ -0,0 +1,281 @@
+#pragma once
+#include "MinimalEngine.h"
+#include <assert.h>
+
+#ifndef DEFAULT_ALLOC_SIZE
+#define DEFAULT_ALLOC_SIZE 16
+#endif
+
+namespace Seele 
+{
+	template<typename T>
+	struct Array
+	{
+	public:
+		Array()
+			: allocated(DEFAULT_ALLOC_SIZE)
+			, arraySize(0)
+		{
+			_data = new T[DEFAULT_ALLOC_SIZE];
+			refreshIterators();
+		}
+		Array(size_t size, T value = T())
+			: allocated(size)
+			, arraySize(size)
+		{
+			_data = new T[size];
+			for (int i = 0; i < size; ++i)
+			{
+				_data[i] = value;
+			}
+			refreshIterators();
+		}
+		~Array()
+		{
+			delete _data;
+			_data = nullptr;
+		}
+		template<typename X>
+		class IteratorBase {
+		public:
+			typedef std::forward_iterator_tag iterator_category;
+			typedef X value_type;
+			typedef std::ptrdiff_t difference_type;
+			typedef X& reference;
+			typedef X* pointer;
+
+			IteratorBase(X* x = nullptr)
+				: p(x)
+			{}
+			IteratorBase(const IteratorBase& i)
+				: p(i.p)
+			{}
+			reference operator*() const
+			{
+				return *p;
+			}
+			pointer operator->() const
+			{
+				return p;
+			}
+			inline bool operator!=(const IteratorBase& other)
+			{
+				return p != other.p;
+			}
+			inline bool operator==(const IteratorBase& other)
+			{
+				return p == other.p;
+			}
+			inline bool operator-(const IteratorBase& other)
+			{
+				return p - other.p;
+			}
+			IteratorBase& operator++() {
+				p++;
+				return *this;
+			}
+			IteratorBase operator++(int) {
+				IteratorBase tmp(*this);
+				++*this;
+				return tmp;
+			}
+		private:
+			X* p;
+		};
+		typedef IteratorBase<T> Iterator;
+		typedef IteratorBase<const T> ConstIterator;
+
+		Iterator find(const T& item)
+		{
+			for (int i = 0; i < arraySize; ++i)
+			{
+				if (_data[i] == item)
+				{
+					return Iterator(&_data[i]);
+				}
+			}
+			return endIt;
+		}
+		Iterator begin()
+		{
+			return beginIt;
+		}
+		Iterator end()
+		{
+			return endIt;
+		}
+
+		T& add(const T& item)
+		{
+			if (arraySize == allocated)
+			{
+				allocated += DEFAULT_ALLOC_SIZE;
+				T* tempArray = new T[allocated];
+				std::memcpy(tempArray, _data, arraySize * sizeof(T));
+				delete _data;
+				_data = tempArray;
+			}
+			_data[arraySize++] = item;
+			refreshIterators();
+			return _data[arraySize - 1];
+		}
+		void remove(Iterator it, bool keepOrder = true)
+		{
+			remove(it - beginIt, keepOrder);
+		}
+		void remove(int index, bool keepOrder = true)
+		{
+			if (keepOrder)
+			{
+				std::memcpy(&_data[index], &_data[index + 1], sizeof(T) * (arraySize - index));
+			}
+			else
+			{
+				_data[index] = _data[arraySize - 1];
+			}
+			arraySize--;
+		}
+		void clear()
+		{
+			arraySize = 0;
+			allocated = 0;
+			refreshIterators();
+		}
+		void resize(uint32 newSize)
+		{
+			if (newSize < allocated)
+			{
+				arraySize = newSize;
+			}
+			else
+			{
+				T* newData = new T[newSize];
+				allocated = newSize;
+				std::memcpy(newData, _data, sizeof(T) * arraySize);
+				arraySize = newSize;
+				delete _data;
+				_data = newData;
+			}
+			refreshIterators();
+		}
+		inline uint32 size() const
+		{
+			return arraySize;
+		}
+		inline uint32 capacity() const
+		{
+			return allocated;
+		}
+		inline T* data() const
+		{
+			return _data;
+		}
+		T& back() const
+		{
+			return _data[arraySize - 1];
+		}
+		T& operator[](int index) const
+		{
+			assert(index >= 0 && index < arraySize);
+			return _data[index];
+		}
+	private:
+		void refreshIterators()
+		{
+			beginIt = Iterator(_data);
+			endIt = Iterator(_data + arraySize);
+		}
+		uint32 arraySize;
+		uint32 allocated;
+		Iterator beginIt;
+		Iterator endIt;
+		T* _data;
+	};
+
+	template<typename T, uint32 N>
+	struct StaticArray
+	{
+	public:
+		StaticArray()
+		{
+			beginIt = Iterator(_data);
+			endIt = Iterator(_data + N);
+		}
+		StaticArray(T value)
+		{
+			for (int i = 0; i < N; ++i)
+			{
+				_data[i] = value;
+			}
+			beginIt = Iterator(_data);
+			endIt = Iterator(_data + N);
+		}
+		~StaticArray()
+		{}
+
+		inline uint32 size() const
+		{
+			return N;
+		}
+		inline T* data() const
+		{
+			return _data;
+		}
+		T& operator[](int index)
+		{
+			assert(index >= 0 && index < N);
+			return _data[index];
+		}
+
+		template<typename X>
+		class IteratorBase {
+		public:
+			typedef std::forward_iterator_tag iterator_category;
+			typedef X value_type;
+			typedef std::ptrdiff_t difference_type;
+			typedef X& reference;
+			typedef X* pointer;
+
+			IteratorBase(X* x = nullptr)
+				: p(x)
+			{}
+			IteratorBase(const IteratorBase& i)
+				: p(i.p)
+			{}
+			reference operator*() const
+			{
+				return *p;
+			}
+			pointer operator->() const
+			{
+				return p;
+			}
+			inline bool operator!=(const IteratorBase& other)
+			{
+				return p != other.p;
+			}
+			inline bool operator==(const IteratorBase& other)
+			{
+				return p == other.p;
+			}
+			IteratorBase& operator++() {
+				p++;
+				return *this;
+			}
+			IteratorBase operator++(int) {
+				IteratorBase tmp(*this);
+				++*this;
+				return tmp;
+			}
+		private:
+			X* p;
+		};
+		typedef IteratorBase<T> Iterator;
+		typedef IteratorBase<const T> ConstIterator;
+
+	private:
+		T _data[N];
+		Iterator beginIt;
+		Iterator endIt;
+	};
+}

src/Engine/Containers/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(SeeleEngine
+	PRIVATE
+		Array.h)

src/Engine/Containers/Map.h

@@ -0,0 +1,262 @@
+#pragma once
+#include "Array.h"
+
+namespace Seele
+{
+	template<typename K, typename V>
+	struct Pair
+	{
+	public:
+		Pair()
+			: key(K())
+			, value(V())
+		{}
+		Pair(K key, V value)
+			: key(key)
+			, value(value)
+		{}
+		K key;
+		V value;
+	};
+	template<typename K, typename V>
+	struct Map
+	{
+	private:
+		struct Node
+		{
+			Pair<K, V> pair;
+			Node* leftChild;
+			Node* rightChild;
+			Node(const K& key)
+				: leftChild(nullptr)
+				, rightChild(nullptr)
+				, pair(key, V())
+			{}
+			Node()
+				: leftChild(nullptr)
+				, rightChild(nullptr)
+				, pair(K(), V())
+			{}
+		};
+
+	public:
+		Map()
+			: root(nullptr)
+		{}
+		~Map()
+		{}
+		V& operator[](const K& key)
+		{
+			root = splay(root, key);
+			if (root == nullptr || root->pair.key < key || key < root->pair.key)
+			{
+				root = insert(root, key);
+			}
+			refreshIterators();
+			return root->pair.value;
+		}
+		class Iterator {
+		public:
+			typedef std::bidirectional_iterator_tag iterator_category;
+			typedef Pair<K, V> value_type;
+			typedef std::ptrdiff_t difference_type;
+			typedef Pair<K, V>& reference;
+			typedef Pair<K, V>* pointer;
+
+			Iterator(Node* x = nullptr)
+				: node(x)
+			{
+			}
+			Iterator(const Iterator& i)
+				: node(i.node)
+			{}
+			reference operator*() const
+			{
+				return node->pair;
+			}
+			pointer operator->() const
+			{
+				return &node->pair;
+			}
+			inline bool operator!=(const Iterator& other)
+			{
+				return node != other.node;
+			}
+			inline bool operator==(const Iterator& other)
+			{
+				return node == other.node;
+			}
+			Iterator& operator++() {
+				node++;
+				return *this;
+			}
+			Iterator& operator--() {
+				node--;
+				return *this;
+			}
+			Iterator operator--(int) {
+				Iterator tmp(*this);
+				++* this;
+				return tmp;
+			}
+			Iterator operator++(int) {
+				Iterator tmp(*this);
+				++* this;
+				return tmp;
+			}
+		private:
+			Node* node;
+		};
+		Iterator find(const K& key)
+		{
+			root = splay(root, key);
+			if (root == nullptr || root->pair.key != key)
+			{
+				return endIt;
+			}
+			return Iterator(root);
+		}
+		bool exists(const K& key)
+		{
+			return find(key) != endIt;
+		}
+		Iterator begin() const
+		{
+			return beginIt;
+		}
+		Iterator end() const
+		{
+			return endIt;
+		}
+	private:
+		void refreshIterators()
+		{
+			beginIt = Iterator(&nodes[0]);
+			endIt = Iterator(&nodes[0] + nodes.size());
+		}
+		Node* root;
+		Array<Node> nodes;
+		Iterator beginIt;
+		Iterator endIt;
+		Node* rotateRight(Node* node)
+		{
+			Node* y = node->leftChild;
+			node->leftChild = y->rightChild;
+			y->rightChild = node;
+			return y;
+		}
+		Node* rotateLeft(Node* node)
+		{
+			Node* y = node->rightChild;
+			node->rightChild = y->leftChild;
+			y->leftChild = node;
+			return y;
+		}
+		Node* makeNode(const K& key)
+		{
+			return &nodes.add(Node(key));
+		}
+		Node* insert(Node* root, const K& key)
+		{
+			if (root == nullptr) return makeNode(key);
+
+			root = splay(root, key);
+
+			if (!(root->pair.key < key || key < root->pair.key)) return root;
+
+			Node* newNode = makeNode(key);
+
+			if (key < root->pair.key)
+			{
+				newNode->rightChild = root;
+				newNode->leftChild = root->leftChild;
+				root->leftChild = nullptr;
+			}
+			else
+			{
+				newNode->leftChild = root;
+				newNode->rightChild = root->rightChild;
+				root->rightChild = nullptr;
+			}
+			return newNode;
+		}
+		Node* remove(Node* root, const K& key)
+		{
+			Node* temp;
+			if (!root)
+				return nullptr;
+
+			root = splay(root, key);
+
+			if (key != root->pair.key)
+				return root;
+
+			if (!root->leftChild)
+			{
+				temp = root;
+				root = root->rightChild;
+			}
+			else
+			{
+				temp = root;
+
+				root = splay(root->leftChild, key);
+				root->rightChild = temp->rightChild;
+			}
+			nodes.remove(temp);
+			delete temp;
+			return root;
+		}
+		Node* splay(Node* root, const K& key)
+		{
+			if (root == nullptr || !(root->pair.key < key || key < root->pair.key))
+			{
+				return root;
+			}
+
+			if (key < root->pair.key)
+			{
+				if (root->leftChild == nullptr)
+					return root;
+
+				if (key < root->leftChild->pair.key)
+				{
+					root->leftChild->leftChild = splay(root->leftChild->leftChild, key);
+
+					root = rotateRight(root);
+				}
+				else if (root->leftChild->pair.key < key)
+				{
+					root->leftChild->rightChild = splay(root->leftChild->rightChild, key);
+
+					if (root->leftChild->rightChild != nullptr)
+					{
+						root->leftChild = rotateLeft(root->leftChild);
+					}
+				}
+				return (root->leftChild == nullptr) ? root : rotateRight(root);
+			}
+			else
+			{
+				if (root->rightChild == nullptr)
+					return root;
+
+				if (key < root->rightChild->pair.key)
+				{
+					root->rightChild->leftChild = splay(root->rightChild->leftChild, key);
+
+					if (root->rightChild->leftChild != nullptr)
+					{
+						root->rightChild = rotateRight(root->rightChild);
+					}
+				}
+				else if (root->rightChild->pair.key < key)
+				{
+					root->rightChild->rightChild = splay(root->rightChild->rightChild, key);
+					root = rotateLeft(root);
+				}
+				return (root->rightChild == nullptr) ? root : rotateLeft(root);
+			}
+		}
+	};
+}

src/Engine/Graphics/CMakeLists.txt

@@ -0,0 +1,12 @@
+target_sources(SeeleEngine
+    PRIVATE
+        Graphics.h
+        Graphics.cpp
+        View.h
+        WindowManager.h
+        WindowManager.cpp
+        Window.h
+        Window.cpp
+        GraphicsResources.h)
+
+add_subdirectory(Vulkan/)

src/Engine/Graphics/Graphics.cpp

@@ -1,11 +1,20 @@
 #include "Graphics.h"
+#include <iostream>
+#include <map>
 
-Graphics::Graphics()
+Seele::Graphics::Graphics()
 {
-
+	Array<uint8> arr;
+	arr.add('2');
+	arr.add('4');
+	std::cout << "Test" << std::endl;
+	for (auto a : arr)
+	{
+		std::cout << "Element: " << a << std::endl;
+	}
 }
 
-Graphics::~Graphics()
+Seele::Graphics::~Graphics()
 {
 
 }

src/Engine/Graphics/Graphics.h

@@ -1,6 +1,28 @@
-class Graphics
-{
-public:
-	Graphics();
-	~Graphics();
-};
+#pragma once
+#include "MinimalEngine.h"
+#include "GraphicsResources.h"
+
+namespace Seele {
+	class Window;
+	class Graphics
+	{
+	public:
+		static Graphics& getInstance()
+		{
+			static Graphics instance;
+
+			return instance;
+		}
+		void init(GraphicsInitializer initializer);
+		void beginFrame();
+		void endFrame();
+	
+	//Singleton
+	private:
+		Graphics();
+		Graphics(Graphics const&) = delete;
+		void operator=(Graphics const&) = delete;
+		~Graphics();
+
+	};
+}

src/Engine/Graphics/GraphicsResources.h

@@ -0,0 +1,9 @@
+#pragma once
+
+namespace Seele
+{
+	struct GraphicsInitializer
+	{
+		const char* windowLayoutFile;
+	};
+}

src/Engine/Graphics/View.h

@@ -0,0 +1,10 @@
+#pragma once
+#include "Window.h"
+
+// A view is a part of the window, which can be anything from a viewport to an editor
+class View
+{
+public:
+private:
+	Window::Section* owner;
+};

src/Engine/Graphics/Window.cpp

@@ -0,0 +1,12 @@
+#include "Window.h"
+#include "Graphics.h"
+#include <iostream>
+
+Seele::Window::Window(const WindowCreateInfo& createInfo)
+{
+}
+
+Seele::Window::~Window()
+{
+
+}

src/Engine/Graphics/Window.h

@@ -0,0 +1,39 @@
+#pragma once
+#include "MinimalEngine.h"
+namespace Seele {
+	struct WindowCreateInfo
+	{
+		int32 width;
+		int32 height;
+		const char* title;
+	};
+	class Window
+	{
+	public:
+		Window(const WindowCreateInfo& createInfo);
+		~Window();
+	private:
+		// A window is divided into 5 sections, using a border layout
+		// +--------------TOP------------------+
+		// |								   |
+		// L								   R
+		// E								   I
+		// F			CENTER				   G
+		// T								   H
+		// |								   T
+		// +-------------BOTTOM----------------+
+		// In every section, there can be any number
+		// of views, when there are multiple, they stack to tabs
+		struct Section
+		{
+
+		};
+		Section top;
+		Section bot;
+		Section left;
+		Section right;
+		Section center;
+		uint32 width;
+		uint32 height;
+	};
+}

src/Engine/Graphics/WindowManager.cpp

@@ -0,0 +1,16 @@
+#include "WindowManager.h"
+
+Seele::WindowManager::WindowManager(GraphicsInitializer initializer)
+{
+	//TODO Parse layout file
+	WindowCreateInfo mainWindowInfo;
+	mainWindowInfo.title = "SeeleEngine";
+	mainWindowInfo.width = 1280;
+	mainWindowInfo.height = 720;
+	Window* mainWindow = new Window(mainWindowInfo);
+	windows.add(mainWindow);
+}
+
+Seele::WindowManager::~WindowManager()
+{
+}

src/Engine/Graphics/WindowManager.h

@@ -0,0 +1,16 @@
+#pragma once
+#include "GraphicsResources.h"
+#include "Window.h"
+#include "Containers/Array.h"
+
+namespace Seele
+{
+	class WindowManager
+	{
+	public:
+		WindowManager(GraphicsInitializer initializer);
+		~WindowManager();
+	private:
+		Array<RefPtr<Window>> windows;
+	};
+}

src/Engine/Math/CMakeLists.txt

@@ -0,0 +1,5 @@
+target_sources(SeeleEngine
+	PRIVATE
+		Math.h
+		Matrix.h
+		Vector.h)

src/Engine/Math/Matrix.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <glm/mat2x2.hpp>
+#include <glm/mat3x3.hpp>
+#include <glm/mat4x4.hpp>
+namespace Seele {
+	typedef glm::mat2 Matrix2;
+	typedef glm::mat3 Matrix3;
+	typedef glm::mat4 Matrix4;
+}

src/Engine/Math/Vector.h

@@ -0,0 +1,17 @@
+#pragma once
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+#include <glm/vec4.hpp>
+namespace Seele {
+	typedef glm::vec2 Vector2;
+	typedef glm::vec3 Vector3;
+	typedef glm::vec4 Vector4;
+
+	typedef glm::uvec2 UVector2;
+	typedef glm::uvec3 UVector3;
+	typedef glm::uvec4 UVector4;
+
+	typedef glm::ivec2 IVector2;
+	typedef glm::ivec3 IVector3;
+	typedef glm::ivec4 IVector4;
+}

src/Engine/MinimalEngine.h

@@ -0,0 +1,129 @@
+#pragma once
+#include <stdint.h>
+#include <array>
+#include <memory>
+#include <atomic>
+
+namespace Seele
+{
+	typedef uint64_t uint64;
+	typedef uint32_t uint32;
+	typedef uint16_t uint16;
+	typedef uint8_t uint8;
+
+	typedef int64_t int64;
+	typedef int32_t int32;
+	typedef int16_t int16;
+	typedef int8_t int8;
+
+
+	template<typename T>
+	class RefPtr
+	{
+	public:
+		RefPtr(T* ptr)
+		{
+			object = new RefObject(ptr);
+		}
+		RefPtr(const RefPtr& other)
+			: object(other.object)
+		{
+			object->addRef();
+		}
+		RefPtr& operator=(const RefPtr& other)
+		{
+			if (this != &other)
+			{
+				object->removeRef();
+				object = other->object;
+				object->addRef();
+			}
+			return *this;
+		}
+		~RefPtr()
+		{
+			object->removeRef();
+		}
+		T* operator->()
+		{
+			return object->getHandle();
+		}
+	private:
+		class RefObject
+		{
+		public:
+			RefObject(T* ptr)
+				: handle(ptr)
+				, refCount(1)
+			{
+			}
+			RefObject(const RefObject& rhs)
+				: handle(rhs.handle)
+				, refCount(rhs.refCount)
+			{
+
+			}
+			~RefObject()
+			{}
+
+			void addRef()
+			{
+				refCount++;
+			}
+			void removeRef()
+			{
+				refCount--;
+				if (refCount.load() <= 0)
+				{
+					delete handle;
+					handle = nullptr;
+					delete this;
+				}
+			}
+			inline T* getHandle() const
+			{
+				return handle;
+			}
+		private:
+			T* handle;
+			std::atomic_uint64_t refCount;
+		};
+		RefObject* object;
+	};
+
+	template<typename T>
+	class UniquePtr
+	{
+	public:
+		UniquePtr(T* ptr)
+			: handle(ptr)
+		{}
+		UniquePtr(const UniquePtr& rhs) = delete;
+		UniquePtr(UniquePtr&& rhs) noexcept
+			: handle(rhs.handle)
+		{
+			rhs.handle = nullptr;
+		}
+		UniquePtr& operator=(const UniquePtr& rhs) = delete;
+		UniquePtr& operator=(UniquePtr&& rhs)
+		{
+			handle = rhs.handle;
+			rhs.handle = nullptr;
+			return *this;
+		}
+		~UniquePtr()
+		{
+			delete handle;
+		}
+		T* operator->()
+		{
+			return handle;
+		}
+		bool isValid()
+		{
+			return handle != nullptr;
+		}
+	private:
+		T* handle;
+	};
+}

src/Engine/main.cpp

@@ -7,6 +7,7 @@
 #include <vulkan/vulkan.h>
 #include <glm/vec4.hpp>
 #include <GLFW/glfw3.h>
+#include "Graphics/Graphics.h"
 
 /////////////////////////////////////////////////////////////
 // gps coordinate
@@ -44,7 +45,7 @@ int main() {
     // create class instance
     const gps_position g(35, 59, 24.567f);
 
-    // save data to archive
+    // save _data to archive
     {
         boost::archive::text_oarchive oa(ofs);
         // write class instance to archive
@@ -65,7 +66,9 @@ int main() {
     std::cout << "Hello World! " << std::endl;
     VkInstance instance;
     glm::vec4 vector(0, 1, 0, 1);
+    Seele::Graphics& graphics = Seele::Graphics::getInstance();
     std::cout << vector.y << std::endl;
     std::cout << glfwInit() << std::endl;
+
     return 0;
 }

test/CMakeLists.txt

@@ -0,0 +1,13 @@
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ".")
+
+find_package(Boost COMPONENTS unit_test_framework REQUIRED)
+
+include_directories(${ENGINE_ROOT})
+include_directories(${Boost_INCLUDE_DIRS})
+
+add_executable(Seele_unit_tests "")
+add_subdirectory(Engine/)
+target_link_libraries(Seele_unit_tests ${Boost_LIBRARIES})
+
+enable_testing()
+add_test(SeeleEngineTest Seele_unit_tests)

test/Engine/CMakeLists.txt

@@ -0,0 +1,6 @@
+target_sources(Seele_unit_tests
+	PRIVATE
+		EngineTest.h
+		EngineTest.cpp)
+target_include_directories(Seele_unit_tests PUBLIC ./)
+add_subdirectory(Containers/)

test/Engine/Containers/Array.cpp

@@ -0,0 +1,141 @@
+#include "EngineTest.h"
+#include "Containers/Array.h"
+#define BOOST_TEST_MODULE SeeleEngine
+#include <boost/test/unit_test.hpp>
+
+using namespace Seele;
+
+BOOST_AUTO_TEST_SUITE(Array_Suite)
+
+BOOST_AUTO_TEST_CASE(empty_constructur)
+{
+	Array<uint8> array;
+	BOOST_CHECK_EQUAL(array.size(), 0);
+}
+
+BOOST_AUTO_TEST_CASE(initialial_size)
+{
+	Array<uint8> array(3);
+	BOOST_CHECK_EQUAL(array.size(), 3);
+}
+
+BOOST_AUTO_TEST_CASE(resize)
+{
+	Array<uint8> array;
+	array.add(2);
+	array.add(3);
+	BOOST_CHECK_EQUAL(array.size(), 2);
+	array.resize(5);
+	BOOST_CHECK_EQUAL(array.size(), 5);
+}
+BOOST_AUTO_TEST_CASE(clear)
+{
+	Array<uint8> array;
+	array.add(3);
+	array.add(2);
+	array.add(6);
+	BOOST_CHECK_EQUAL(array.size(), 3);
+	array.clear();
+	BOOST_CHECK_EQUAL(array.size(), 0);
+}
+BOOST_AUTO_TEST_CASE(remove_keeporder)
+{
+	Array<uint8> array;
+	array.add(1);
+	array.add(2);
+	array.add(3);
+	array.add(4);
+	array.add(5);
+	array.remove(1);
+	BOOST_CHECK_EQUAL(array[1], 3);
+	BOOST_CHECK_EQUAL(array[2], 4);
+	BOOST_CHECK_EQUAL(array[3], 5);
+	BOOST_CHECK_EQUAL(array.size(), 4);
+}
+
+BOOST_AUTO_TEST_CASE(remove_swap)
+{
+	Array<uint8> array;
+	array.add(1);
+	array.add(2);
+	array.add(3);
+	array.add(4);
+	array.add(5);
+	array.remove(1, false);
+	BOOST_CHECK_EQUAL(array[1], 5);
+	BOOST_CHECK_EQUAL(array[2], 3);
+	BOOST_CHECK_EQUAL(array[3], 4);
+	BOOST_CHECK_EQUAL(array.size(), 4);
+}
+
+BOOST_AUTO_TEST_CASE(remove_iterator)
+{
+	Array<uint8> array;
+	array.add(1);
+	array.add(2);
+	array.add(3);
+	array.add(4);
+	array.add(5);
+	array.remove(array.find(1), false);
+	BOOST_CHECK_EQUAL(array[0], 5);
+	BOOST_CHECK_EQUAL(array[1], 2);
+	BOOST_CHECK_EQUAL(array[2], 3);
+	BOOST_CHECK_EQUAL(array[3], 4);
+	BOOST_CHECK_EQUAL(array.size(), 4);
+}
+
+BOOST_AUTO_TEST_CASE(remove_iterator_keep_order)
+{
+	Array<uint8> array;
+	array.add(1);
+	array.add(2);
+	array.add(3);
+	array.add(4);
+	array.add(5);
+	array.remove(array.find(1));
+	BOOST_CHECK_EQUAL(array[0], 2);
+	BOOST_CHECK_EQUAL(array[1], 3);
+	BOOST_CHECK_EQUAL(array[2], 4);
+	BOOST_CHECK_EQUAL(array[3], 5);
+	BOOST_CHECK_EQUAL(array.size(), 4);
+}
+
+BOOST_AUTO_TEST_CASE(random_access)
+{
+	Array<uint8> array;
+	array.add(4);
+	array.add(5);
+	array.add(6);
+	BOOST_CHECK_EQUAL(array[2], 6);
+	BOOST_CHECK_EQUAL(array[0], 4);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+
+BOOST_AUTO_TEST_SUITE(StaticArray_Suite)
+
+BOOST_AUTO_TEST_CASE(empty_constructur)
+{
+	StaticArray<uint8, 2> array;
+	BOOST_CHECK_EQUAL(array.size(), 2);
+}
+
+BOOST_AUTO_TEST_CASE(initialial_size)
+{
+	StaticArray<uint8, 3> array(3);
+	BOOST_CHECK_EQUAL(array.size(), 3);
+	BOOST_CHECK_EQUAL(array[1], 3);
+}
+
+BOOST_AUTO_TEST_CASE(random_access)
+{
+	StaticArray<uint8, 3> array;
+	array[0] = 4;
+	array[1] = 5;
+	array[2] = 6;
+	BOOST_CHECK_EQUAL(array[0], 4);
+	BOOST_CHECK_EQUAL(array[2], 6);
+}
+
+BOOST_AUTO_TEST_SUITE_END()

test/Engine/Containers/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(Seele_unit_tests
+	PRIVATE
+		Array.cpp
+		Map.cpp)

test/Engine/Containers/Map.cpp

@@ -0,0 +1,67 @@
+#include "EngineTest.h"
+#include "Containers/Map.h"
+#include <boost/test/unit_test.hpp>
+
+using namespace Seele;
+
+BOOST_AUTO_TEST_SUITE(CachedMap)
+
+BOOST_AUTO_TEST_CASE(insert_find_basic)
+{
+	Map<int, int> map;
+	map[2] = 3;
+	map[1] = 5;
+	map[6] = 4;
+	map[4] = 7;
+	BOOST_REQUIRE_EQUAL(map[2], 3);
+	BOOST_REQUIRE_EQUAL(map[1], 5);
+	BOOST_REQUIRE_EQUAL(map[6], 4);
+	BOOST_REQUIRE_EQUAL(map[4], 7);
+	map[2] = 5;
+	map[4] = 4;
+	BOOST_REQUIRE_EQUAL(map[2], 5);
+	BOOST_REQUIRE_EQUAL(map[4], 4);
+}
+
+BOOST_AUTO_TEST_CASE(for_each)
+{
+	Map<int, int> map;
+	map[2] = 3;
+	map[1] = 5;
+	map[6] = 4;
+	map[4] = 7;
+	int count = 0;
+	for (auto entry : map)
+	{
+		count++;
+	}
+	BOOST_REQUIRE_EQUAL(count, 4);
+}
+
+BOOST_AUTO_TEST_CASE(key_exists)
+{
+	Map<int, int> map;
+	map[2] = 3;
+	BOOST_REQUIRE_EQUAL(map.exists(2), true);
+	BOOST_REQUIRE_EQUAL(map.exists(4), false);
+}
+
+BOOST_AUTO_TEST_CASE(custom_key)
+{
+	struct Key
+	{
+		int id;
+		bool operator<(const Key& other) const
+		{
+			return id < other.id;
+		}
+	};
+	Map<Key, int> map;
+	map[Key{ 2 }] = 3;
+	map[Key{ 3 }] = 4;
+	BOOST_REQUIRE_EQUAL(map[Key{ 2 }], 3);
+	BOOST_REQUIRE_EQUAL(map[Key{ 3 }], 4);
+
+}
+
+BOOST_AUTO_TEST_SUITE_END()

test/Engine/EngineTest.cpp

@@ -0,0 +1,42 @@
+#include "EngineTest.h"
+#include "MinimalEngine.h"
+#include <boost/test/unit_test.hpp>
+
+using namespace Seele;
+
+BOOST_AUTO_TEST_SUITE(RefPtr)
+
+struct TestStruct
+{
+	TestStruct()
+		: data(10)
+	{
+	}
+	~TestStruct()
+	{
+	}
+	uint32 data;
+};
+BOOST_AUTO_TEST_CASE(basic_refcount)
+{
+	{
+		Seele::RefPtr<TestStruct> ptr = new TestStruct();
+		BOOST_REQUIRE_EQUAL(ptr->data, 10);
+		{
+			Seele::RefPtr<TestStruct> secondPtr = ptr;
+			BOOST_REQUIRE_EQUAL(secondPtr->data, 10);
+			BOOST_REQUIRE_EQUAL(ptr->data, 10);
+		}
+		BOOST_REQUIRE_EQUAL(ptr->data, 10);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(unique_ptr)
+{
+	UniquePtr<TestStruct> uptr = new TestStruct();
+	UniquePtr<TestStruct> uptr2 = std::move(uptr);
+	BOOST_REQUIRE_EQUAL(uptr2->data, 10);
+	BOOST_REQUIRE_EQUAL(uptr.isValid(), false);
+}
+
+BOOST_AUTO_TEST_SUITE_END()

test/Engine/EngineTest.h

@@ -0,0 +1 @@
+#pragma once