Heavy buffer update, window update, object tracking

.gitignore

@@ -1,11 +1,8 @@
 build/
-.*
+.vscode/
-!.gitignore
-!.clangd
 CMakeFiles/
-CMakeKits.json
 CMakeCache.txt
 docs/*
 !docs/CMake*
 !docs/Doxyfile.in
-
+!.clangd

CMakeLists.txt

@@ -28,43 +28,56 @@ function(toAbsolutePath SETVAR PATHS)
     set(${SETVAR} ${RET_VAL} PARENT_SCOPE)
 endfunction()
 
-if (NOT CMAKE_BUILD_TYPE)
-	set(CMAKE_BUILD_TYPE "Debug")
-endif()
-
 if(CMAKE_BUILD_TYPE STREQUAL "Release")
-	add_compile_definitions(_NB_BUILD_RELEASE)
+    message(STATUS "Targeting Release build")
 elseif(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    message(STATUS "Targeting Debug build")
     set(NB_DEBUG_BUILD ON)
     add_compile_definitions(_NB_BUILD_DEBUG)
 endif()
-message(STATUS "Targeting ${CMAKE_BUILD_TYPE} build")
-
-if (NB_DEBUG_BUILD)
-	set(NB_LOGGING ON)
-	set(NB_BUILD_TESTS ON)
-	set(NB_BUILD_DOCS ON)
-	set(NB_MONITOR_OPENGL_CALLS ON)
-	set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
-endif()
 
+cmake_dependent_option(NB_LOGGING 
+    "Creates a default logger and automatically logs with code locations."
+    ON
+    NB_DEBUG_BUILD
+    OFF
+)
+cmake_dependent_option(NB_BUILD_TESTS
+    "Build unit tests"
+    ON
+    NB_DEBUG_BUILD
+    OFF
+)
+cmake_dependent_option(NB_BUILD_DOCS
+    "Build documentation"
+    ON
+    NB_DEBUG_BUILD
+    OFF
+)
 cmake_dependent_option(NBENGINE_INSTALL
     "Install NBEngine"
     ON
     NB_DEBUG_BUILD
     OFF
 )
+cmake_dependent_option(NB_MONITOR_OPENGL_CALLS
+    "Monitors every OpenGL call for errors"
+    ON
+    NB_DEBUG_BUILD
+    OFF
+)
+
 
 if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
-    message(STATUS "Targeting Windows")
+    message(STATUS "Building for Windows")
     set(NB_TARGET_WINDOWS ON)
 elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    message(STATUS "Targeting Linux")
+    message(STATUS "Building for Linux")
     set(NB_TARGET_LINUX ON)
 endif()
 
 if(NB_BUILD_TESTS)
-	message(STATUS "Targeting tests")
+    message(STATUS "Building tests")
     enable_testing()
     include(FetchContent)
     FetchContent_Declare(
@@ -93,13 +106,13 @@ endif()
 
 get_filename_component(NBENGINE_ROOT ${CMAKE_CURRENT_LIST_DIR} ABSOLUTE)
 
-add_subdirectory(./engine)
+add_subdirectory(./engine ${PROJECT_BINARY_DIR}/${CMAKE_BUILD_TYPE})
 
 # Toggle
 set(NB_REBUILD_DOCS)
 
 if (NB_BUILD_DOCS)
-	add_subdirectory(./docs)
+    add_subdirectory(./docs)
 endif()
 
 include(CMakePackageConfigHelpers)

engine/CMakeLists.txt

@@ -1,17 +1,30 @@
-set(NBENGINE_MODULES
+add_subdirectory(./NBCore)
-	NBCore
-	NBGraphics
-	NBData
-)
 
-set(NB_INCLUDE_FILES "")
+get_target_property(NBCORE_INTERFACE_INCLUDES NBCore INTERFACE_INCLUDE_DIRECTORIES)
-set(NB_SOURCE_FILES "")
+include_directories(${NBCORE_INTERFACE_INCLUDES})
-foreach(module ${NBENGINE_MODULES})
-	add_subdirectory("./${module}")
-	get_target_property(MODULE_INCLUDES ${module} INTERFACE_INCLUDE_DIRECTORIES)
-	list(APPEND NB_INCLUDE_FILES ${MODULE_INCLUDES})
-	list(APPEND NB_SOURCE_FILES ${MODULE_INCLUDES})
-endforeach()
-set(NB_INCLUDE_FILES ${NB_INCLUDE_FILES} PARENT_SCOPE)
-set(NB_SOURCE_FILES ${NB_SOURCE_FILES} PARENT_SCOPE)
 
+#add_subdirectory(./NBEvents)
+add_subdirectory(./NBGraphics)
+add_subdirectory(./NBData)
+
+if (NB_CORE_SOURCE OR NB_EVENTS_SOURCE OR NB_GRAPHICS_SOURCE OR NB_DATA_SOURCE)
+    set(NB_SOURCE_FILES "")
+    list(APPEND NB_SOURCE_FILES 
+        ${NB_CORE_SOURCE}
+        ${NB_GRAPHICS_SOURCE}
+        ${NB_EVENTS_SOURCE}
+        ${NB_DATA_SOURCE}
+    )
+    set(NB_SOURCE_FILES ${NB_SOURCE_FILES} PARENT_SCOPE)
+endif()
+
+if (NB_CORE_INCLUDE OR NB_EVENTS_INCLUDE OR NB_GRAPHICS_INCLUDE OR NB_DATA_INCLUDE)
+    set(NB_INCLUDE_FILES "")
+    list(APPEND NB_INCLUDE_FILES 
+        ${NB_CORE_INCLUDE}
+        ${NB_GRAPHICS_INCLUDE}
+        ${NB_EVENTS_INCLUDE}
+        ${NB_DATA_INCLUDE}
+    )
+    set(NB_INCLUDE_FILES ${NB_INCLUDE_FILES} PARENT_SCOPE)
+endif()

engine/NBCore/CMakeLists.txt

@@ -8,11 +8,17 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 include(GNUInstallDirs)
 include(CMakePackageConfigHelpers)
 
+toAbsolutePath(NB_CORE_SOURCE 
+    ./src/ErrorsImpl.cpp
+    ./src/Logger.cpp
+    ./src/Processes.cpp
+    ./src/StringUtils.cpp
+    ./src/Utils.cpp
+)
 toAbsolutePath(NB_CORE_INCLUDE
-	./include/NBCore/Arrays.hpp
+    ./include/NBCore/ANSITerm.hpp
-	./include/NBCore/CoreTypes.hpp
     ./include/NBCore/DataSink.hpp
-	./include/NBCore/Errors.hpp
+    ./include/NBCore/Errors.hpp
     ./include/NBCore/ErrorsImpl.hpp
     ./include/NBCore/Logger.hpp
     ./include/NBCore/Printer.hpp
@@ -24,14 +30,10 @@ toAbsolutePath(NB_CORE_INCLUDE
     ./include/NBCore/Utils.hpp
 )
 
-add_library(NBCore
+set(NB_CORE_SOURCE ${NB_CORE_SOURCE} PARENT_SCOPE)
-	./src/ErrorsImpl.cpp
+set(NB_CORE_INCLUDE ${NB_CORE_INCLUDE} PARENT_SCOPE)
-    ./src/Logger.cpp
+
-    ./src/Processes.cpp
+add_library(NBCore ${NB_CORE_SOURCE})
-    ./src/StringUtils.cpp
-    ./src/TypeTraits.cpp
-    ./src/Utils.cpp
-)
 add_library(NBEngine::Core ALIAS NBCore)
 target_include_directories(NBCore
     PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"

engine/NBCore/include/NBCore/ANSITerm.hpp

@@ -0,0 +1,214 @@
+#pragma once
+#ifndef _NB_ANSI_TERM
+#define _NB_ANSI_TERM
+
+#include <iostream>
+#include <string>
+#include <type_traits>
+
+/*
+----------- TECH DEBT ------------
+Idk wtf to do here. This was originally to allow me to print 
+to terminal easily, but it's becoming too much of an investment.
+For the time being, drop it.
+
+*/
+
+namespace nb {
+
+template <typename ST, typename U>
+struct SmartText {
+    using Type = ST;
+    using ValType = U;
+    static constexpr bool HasChild = Type::HasChild;
+
+    SmartText() = default;
+};
+
+template <typename Type, typename U>
+struct StyleFormatter : SmartText<StyleFormatter<Type, U>, U> {
+    using Base = SmartText<StyleFormatter<Type, U>, U>;
+    using typename Base::ValType;
+    static constexpr bool HasChild  = true;
+
+    StyleFormatter(const std::string& _fmt, const ValType& _val, const std::string& _closing) :
+        fmt{_fmt}, val{_val}, closing{_closing} {}
+
+    std::string fmt;
+    ValType val;
+    std::string closing;
+};
+
+template <typename Child>
+struct StyleFormatter<Child, void> : SmartText<StyleFormatter<Child, void>, void>{
+    using Base = SmartText<StyleFormatter<Child, void>, void>;
+    using Base::ValType;
+    static constexpr bool HasChild  = false;
+
+    StyleFormatter(const std::string& _fmt) : fmt{_fmt} {}
+
+    std::string fmt;
+};
+
+template <typename U=void>
+struct ANSITextColor;
+
+template <typename U>
+struct ANSITextColor : StyleFormatter<ANSITextColor<U>, U> {
+    using Base = StyleFormatter<ANSITextColor, U>;
+    using typename Base::ValType;
+    using Base::HasChild;
+
+    template <typename = typename std::enable_if<HasChild, U>::type>
+    ANSITextColor(const U& _val) : Base{"\x1b[39m", _val, "\x1b[39m"} {}
+    template <typename = typename std::enable_if<!HasChild, U>>
+    ANSITextColor() : Base{"\x1b[92m"} {}
+};
+
+template <>
+struct ANSITextColor<std::string> : StyleFormatter<ANSITextColor<std::string>, std::string> {
+    using Base = StyleFormatter<ANSITextColor<std::string>, std::string>;
+    static constexpr bool HasChild = Base::HasChild;
+
+    template <std::size_t N>
+    ANSITextColor(char const(&_val) [N]) : Base{"\x1b[92m", _val, "\x1b[39m"} {}
+    ANSITextColor(const char* _val) : Base{"\x1b[92m", _val, "\x1b[39m"} {}
+    ANSITextColor(const std::string& _val) : Base{"\x1b[92m", _val, "\x1b[39m"} {}
+};
+
+} // namespace nb
+
+template<typename Type, typename U>
+std::ostream& operator<<(std::ostream& stream, const nb::StyleFormatter<Type, U>& msg) {
+    if (&stream == &std::cout) {
+        stream << msg.fmt;
+        if (msg.HasChild) {
+            stream << msg.val << msg.closing;
+        }
+    } else {
+        if (msg.HasChild) { stream << msg.val; }
+    }
+    stream << std::flush;
+    return stream;
+}
+
+/* struct CellBase {
+    uint8_t width;
+    uint8_t height;
+};
+
+template <typename T>
+struct Cell : SmartText<Cell<T>, T> {
+    using Base = SmartText<Cell<T>, T>;
+    using typename Base::ValType;
+    using Base::HasChild;
+
+    Cell(const ValType& _val, const uint8_t& w, const uint8_t& h=1)
+        : val(_val), width(w), height(h) {}
+
+    ValType val;
+    uint8_t width;
+
+    uint8_t height;
+};
+
+template <>
+struct Cell<std::string> : SmartText<Cell<std::string>, std::string> {
+    using Base = SmartText<Cell<std::string>, std::string>;
+    using typename Base::ValType;
+    using Base::HasChild;
+
+    template <std::size_t N>
+    Cell( const(&_val) [N], const uint8_t& w, const uint8_t& h=0) : Cell(std::string(_val), w, h) {}
+    Cell(char* _val, const uint8_t& w, const uint8_t& h=0) : Cell(std::string(_val), w, h) {}
+    Cell(const ValType& _val, const uint8_t& w, const uint8_t& h=0)
+    : val(_val), width(w) {
+        unsigned int strsize = _val.size();
+        height = strsize / width;
+        height += (strsize % width) ? 1 : 0;
+    }
+
+    ValType val;
+    uint8_t width;
+
+    uint8_t height;
+};
+
+template <typename T>
+std::ostream& operator<<(std::ostream& stream, const Cell<T>& cll) {
+    if (&stream == &std::cout) {
+        stream << "\x1b[s" << cll.val << "\x1b[u\x1b[" << 1+cll.width << "C\x1b[" << 1+cll.height;
+    }
+    return stream;
+}
+
+template <typename T>
+void ChangeCellHeight(int i, Cell<T>& cll, const unsigned int& h) {
+    if (h < cll.height) { cll.height=h; }
+}
+
+template <typename T>
+void GetTallestCell(int i, Cell<T>& cll, unsigned int& h) {
+    if (cll.height > h) { h = cll.height; }
+}
+
+template <typename... Pack>
+struct TableRow {
+    using RowCells = std::tuple<Cell<Pack>...>;
+    using CellWidths = std::array<int, sizeof...(Pack)>;
+    using DelimiterArray = std::array<std::string, sizeof...(Pack)+1>;
+
+    TableRow(CellWidths&& widths_, DelimiterArray&& delims_, const Pack&... vals_) 
+    : widths(widths_), delimiters(delims_), topBorder("") {
+        nb::ForEach(_cells, GetTallestCell, _height);
+    }
+
+    static constexpr int num_columns = sizeof...(Pack);
+    
+    int height() const { return height; }
+    inline int height(const unsigned int newh) {
+        nb::ForEach(_cells, ChangeCellHeight, newh);
+        return (_height=newh);
+    }
+    
+    const CellWidths widths;
+    const DelimiterArray delimiters;
+    const std::string topBorder;
+    const std::string bottomBorder;
+
+protected:
+    RowCells _cells;
+    int _height;
+
+};
+
+template <typename... Pack>
+std::ostream& operator<<(std::ostream& stream, const TableRow<Pack...>& row) {
+
+}
+
+template<typename... Pack>
+class Table {
+public:
+    Table(const Pack&... _vals) :  row(std::array<int, sizeof...(Pack)>(10), 
+                std::array<std::string, sizeof...(Pack)>(""), _vals...) {}
+private:
+    TableRow<Pack...> row;
+};
+
+} // namespace nb
+
+#ifdef _NB_TARGET_WINDOWS
+template<typename... Types>
+std::ostream& operator<<(std::ostream& stream, const nb::TableRow<Types...>& row) {
+    using PosType = decltype(stream.tellp());
+    constexpr int num_cells = sizeof...(Types);
+
+    int col_num = 0;
+    int col_start = 0;
+
+    return stream;
+}
+#endif // _NB_TARGET_WINDOWS */
+
+#endif // _NB_ANSI_TERM

engine/NBCore/include/NBCore/Arrays.hpp

@@ -1,135 +0,0 @@
-#pragma once
-#ifndef _NB_DATA_TYPES
-#define _NB_DATA_TYPES
-
-#include <algorithm>
-#include <array>
-#include <cstring>
-
-#include <NBCore/Errors.hpp>
-
-namespace nb {
-
-/*!
- *	@brief A multidimensional array template class
- *
- * */
-template<typename T, unsigned int N>
-class NDArray {
-	public:
-	using Coordinate = std::array<unsigned int, N>;
-
-	private:
-	template<unsigned int M>
-	static Coordinate ProjectDimensions(const std::array<unsigned int, M>& dims) {
-		Coordinate p;
-		unsigned int i=0;
-		if constexpr (M > N) {
-			std::for_each(dims.begin(), dims.end(), [&](unsigned int x){
-				if (i < N) {
-					p[i] = x;
-				} else {
-					if (x != 1) {
-						THROW(Error(Error<>::VALUE_ERROR,
-							"Higher dimensions must have a size of 1"
-						));
-					}
-				}
-				i++;
-			});
-		} else if constexpr (M < N) {
-			p.fill(1);
-			std::for_each(dims.begin(), dims.end(), [&](unsigned int x) {p[i] = x; i++;});
-		} else { p = dims; }
-		
-		return p;
-	}
-	
-
-	protected:
-	T* _data;
-	static unsigned int CalculateTotalSize(const std::array<unsigned int, N>& dims) {
-		unsigned int ret = 1;
-		std::for_each(dims.begin(), dims.end(), [&](unsigned int n){
-			ret *= n;
-		});
-		return ret;
-	}
-
-	public:
-	template<typename U, unsigned int M>
-	friend class NDArray;
-
-	static NDArray&& MemoryToNDArray(const Coordinate& dimensions_, T* data_) {
-		auto ret = NDArray(dimensions_);
-		ret._data = data_;
-		return std::move(ret);
-	}
-
-	const Coordinate dimensions;
-	const unsigned int totalSize;
-	NDArray(const Coordinate& dimensions_, T* data_=nullptr) :
-		dimensions(dimensions_), 
-		totalSize(CalculateTotalSize(dimensions_))
-	{
-		if (data_) { data(data_); }
-	}
-	
-
-	NDArray(NDArray&& arr) :
-		dimensions(arr.dimensions),
-		totalSize(arr.totalSize),
-		 _data(std::move(arr._data)) {}
-
-	NDArray(const NDArray& arr)=delete;
-	
-	template<unsigned int M>
-	NDArray(NDArray<T, M>&& arr) : 
-		dimensions(ProjectDimensions<M>(arr.dimensions)),
-		totalSize(arr.totalSize),
-		_data(std::move(arr._data)){} 
-
-	NDArray& operator=(const NDArray& arr) = delete;	
-	NDArray& operator=(NDArray&& arr) = delete; 
-	~NDArray() {
-		if (_data) { delete[] _data; }
-	};
-	
-	unsigned int coordinateToIndex(const Coordinate& coord) const {
-		unsigned int blockSize = 1;
-		unsigned int ret = 0;
-		for (auto i = 0; i < dimensions.size(); ++i) {
-			ret += coord[i] * blockSize;
-			blockSize *= dimensions[i];
-		}
-		return ret;
-	}
-
-	inline NDArray& copy() const {
-		return NDArray(dimensions, _data);
-	}
-	inline const T& at(const Coordinate& coord) const {
-		return operator[](coord);
-	}
-	inline const T* data() const { return _data; }		
-	inline const T& operator[](const Coordinate& coord) const {
-		return _data[coordinateToIndex(coord)];
-	}
-
-	inline T& at(const Coordinate& coord) {
-		return _data[coordinateToIndex(coord)];
-	}
-	inline T* data(const T* data_) {
-		if (!_data) { _data = new T[totalSize]; }
-		std::memcpy(_data, data_, totalSize * sizeof(T));
-		return _data;
-	}
-	inline T& operator[](const Coordinate& coord) {
-		return _data[coordinateToIndex(coord)];
-	}
-
-}; // class NDArray<type, int>
-
-
-} // namespace nb
-#endif // _NB_DATA_TYPES

engine/NBCore/include/NBCore/CoreTypes.hpp

@@ -1,37 +0,0 @@
-#pragma once
-#ifndef _NB_CORE_TYPES
-#define _NB_CORE_TYPES
-
-#include <memory>
-#include <unordered_map>
-#include <vector>
-
-namespace nb {
-template<typename T>
-using SharedVector = std::vector<std::shared_ptr<T>>;
-
-template<typename T>
-using RValueVector = std::vector<T&&>;
-
-using ByteVector = std::vector<uint8_t>;
-
-template<typename A, typename B>
-class ConstantMap : public std::unordered_map<A, B> {
-    using Base = std::unordered_map<A, B>;
-
-    public:
-    using Base::Base;
-    using Base::at;
-    const B& operator[](const A& key) const {
-        return at(key);
-    }
-};
-
-enum TypeCodes {
-    UINT8, UINT16, UINT32, UINT64, INT8, INT16, INT32, INT64,
-    FLOAT16, FLOAT32, DOUBLE64, BOOL, NONE
-};
-
-}; // namespace nb
-
-#endif // _NB_NB_CORE_TYPES

engine/NBCore/include/NBCore/ErrorsImpl.hpp

@@ -8,7 +8,7 @@
 #include <type_traits>
 
 #include <NBCore/StringUtils.hpp>
-#include <NBCore/CoreTypes.hpp>
+#include <NBCore/Utils.hpp>
 
 namespace nb {
 

engine/NBCore/include/NBCore/TypeTraits.hpp

@@ -2,10 +2,9 @@
 #ifndef _NB_TYPE_TRAITS
 #define _NB_TYPE_TRAITS
 
+#include <tuple>
 #include <type_traits>
-#include <utility>
+#include <vector>
-
-#include <NBCore/CoreTypes.hpp>
 
 namespace nb {
 
@@ -32,12 +31,6 @@ namespace detail {
     };
 } // namespace detail
 
-template<typename K, typename V>
-std::pair<K, V> KeyVal(K key, V val) { return std::pair(key, val); }
-
-template<typename T>
-static constexpr TypeCodes GetTypeEnum = NONE;
-
 struct NoneType{};
 
 template<typename T, unsigned int Arg>
@@ -97,6 +90,37 @@ struct RunAndOutput {
     }
 };
 
+template<typename A, typename B>
+using SubtractType = decltype(std::declval<A>() - std::declval<B>());
+
+template<typename A, typename B>
+using MultiplyType = decltype(std::declval<A>() * std::declval<B>());
+
+template<typename A, typename B>
+using AdditionType = decltype(std::declval<A>() + std::declval<B>());
+
+template<typename Func, std::size_t N=0, typename... Pack>
+inline typename std::enable_if<N==sizeof...(Pack), void>::type
+ForEach(std::tuple<Pack...>&, Func) {}
+
+template<typename Func, std::size_t N=0, typename... Pack>
+inline typename std::enable_if<N < sizeof...(Pack), void>::type
+ForEach(std::tuple<Pack...>& tup, Func f) {
+    f(N, std::get<N>(tup));
+    ForEach<N+1, Func, Pack...>(tup, f);
+}
+
+template<std::size_t N=0, typename Func, typename Args, typename... Pack>
+inline typename std::enable_if<N==sizeof...(Pack), void>::type
+ForEach(std::tuple<Pack...>&, Func, const Args&) {}
+
+template<std::size_t N=0, typename Func, typename Args, typename... Pack>
+inline typename std::enable_if<N < sizeof...(Pack), void>::type
+ForEach(std::tuple<Pack...>& tup, Func f, const Args& arg) {
+    f(N, std::get<N>(tup), arg);
+    ForEach<N+1, Func, Args, Pack...>(tup, f, arg);
+}
+
 template<typename T, typename... Pack>
 struct Find;
 
@@ -132,6 +156,48 @@ struct Find<T, U> {
     >::value;
 };
 
+template <typename T, typename Pack1, typename... Pack>
+struct RefPackToPtrVec {
+    RefPackToPtrVec(std::vector<T*> _vec, Pack1& p1, Pack&... packs)
+    : vec(_vec) {
+        static_assert(std::is_base_of<T, Pack1>::value);
+        vec.push_back(&p1);
+        vec = RefPackToPtrVec<T, Pack...>(vec, packs...).vec;
+    }
+
+    RefPackToPtrVec(Pack1& p1, Pack&... packs)
+    : RefPackToPtrVec({}, p1, packs...) {}
+
+    std::vector<T*> vec;
+};
+
+template <typename T, typename Pack>
+struct RefPackToPtrVec<T, Pack> {
+    RefPackToPtrVec(std::vector<T*> _vec, Pack& p1)
+    : vec(_vec) {
+        static_assert(std::is_base_of<T, Pack>::value);
+        vec.push_back(&p1);
+    }
+
+    RefPackToPtrVec(Pack& p1)
+    : RefPackToPtrVec({}, p1) {}
+
+    std::vector<T*> vec;
+};
+
+template <typename T, typename... Pack>
+struct PackIsSameType;
+
+template <typename T, typename PackType>
+struct PackIsSameType<T, PackType> {
+    const bool value = std::is_base_of<T, PackType>::value;
+};
+
+template <typename T, typename FirstPack, typename... Pack>
+struct PackIsSameType<T, FirstPack, Pack...> {
+    const bool value = std::is_base_of<T, FirstPack>::value && PackIsSameType<T, Pack...>::value;
+};
+
 } // namespace nb
 
 #endif // _NB_TYPE_TRAITS

engine/NBCore/include/NBCore/Utils.hpp

@@ -1,14 +1,36 @@
 #pragma once
-#ifndef _NB_UTILTIES
+#ifndef _NB_CORE_TYPES
-#define _NB_UTILTIES
+#define _NB_CORE_TYPES
 
+#include <exception>
+#include <memory>
+#include <unordered_map>
 #include <vector>
 
-#include <NBCore/CoreTypes.hpp>
+// #include <NBCore/Errors.hpp>
-#include <NBCore/Errors.hpp>
 
 namespace nb {
 
+template<typename A, typename B>
+class ConstantMap : public std::unordered_map<A, B> {
+    using Base = std::unordered_map<A, B>;
+
+    public:
+    using Base::Base;
+    using Base::at;
+    const B& operator[](const A& key) const {
+        return at(key);
+    }
+};
+
+template<typename T>
+using SharedVector = std::vector<std::shared_ptr<T>>;
+
+template<typename T>
+using RValueVector = std::vector<T&&>;
+
+using ByteVector = std::vector<uint8_t>;
+
 /* class ObjectManagerError : public Error<ObjectManagerError> {
     using Base = Error<ObjectManagerError>;
 
@@ -46,10 +68,11 @@ ByteVector concatVectorBytes(const std::vector<T>& vec1, const std::vector<S>& v
 template<typename T>
 std::vector<T> bytesToVector(const ByteVector& vec) {
     if (vec.size() % sizeof(T) != 0) {
-         THROW(Error(
+/*         THROW(Error<NoneType>(
             std::runtime_error("Data size does not align to std::vector<" + std::string(typeid(T).name()) + ">.")
-        ));
+        )); */
-	}
+        throw "byyyyeeee";
+    }
     unsigned int num_elmts = vec.size() / sizeof(T);
     std::vector<T> ret(num_elmts);
     memcpy(ret.data(), vec.data(), vec.size());

engine/NBCore/src/TypeTraits.cpp

@@ -1,17 +0,0 @@
-#include <NBCore/TypeTraits.hpp>
-
-namespace nb {
-
-template<> constexpr TypeCodes GetTypeEnum<unsigned char> = TypeCodes::UINT8;
-template<> constexpr TypeCodes GetTypeEnum<unsigned short> = TypeCodes::UINT16;
-template<> constexpr TypeCodes GetTypeEnum<unsigned int> = TypeCodes::UINT32;
-template<> constexpr TypeCodes GetTypeEnum<unsigned long int> = TypeCodes::UINT64;
-template<> constexpr TypeCodes GetTypeEnum<char> = TypeCodes::INT8;
-template<> constexpr TypeCodes GetTypeEnum<short> = TypeCodes::INT16;
-template<> constexpr TypeCodes GetTypeEnum<int> = TypeCodes::INT32;
-template<> constexpr TypeCodes GetTypeEnum<long> = TypeCodes::INT64;
-template<> constexpr TypeCodes GetTypeEnum<float> = TypeCodes::FLOAT32;
-template<> constexpr TypeCodes GetTypeEnum<double> = TypeCodes::DOUBLE64;
-template<> constexpr TypeCodes GetTypeEnum<bool> = TypeCodes::BOOL;    
-
-} // namespace nb

engine/NBCore/tests/CMakeLists.txt

@@ -1,24 +1,24 @@
 cmake_minimum_required(VERSION 3.26.0)
 
-enable_testing()
+if (NB_BUILD_TESTS)
-include(GoogleTest)
+    enable_testing()
-add_executable(TestCore
+    include(GoogleTest)
-	./testArrays.cpp
+    add_executable(TestCore
-	./testErrors.cpp
+        ./testErrors.cpp
-	#./testProcesses.cpp
+        #./testProcesses.cpp
-	./testUtils.cpp
+        ./testUtils.cpp
-)
+    )
-target_link_libraries(TestCore
+    target_link_libraries(TestCore
-	NBCore
+        NBCore
-	GTest::gtest_main
+        GTest::gtest_main
-)
+    )
 
-add_executable(LoggerTest
+    add_executable(LoggerTest
-	./testLogger.cpp
+        ./testLogger.cpp
-)
+    )
-target_link_libraries(LoggerTest
+    target_link_libraries(LoggerTest
-	NBCore
+        NBCore
-)
+    )
-
-gtest_discover_tests(TestCore)
 
+    gtest_discover_tests(TestCore)
+endif()

engine/NBCore/tests/testArrays.cpp

@@ -1,73 +0,0 @@
-#define CODE_ERROR_LOCATIONS
-#include <gtest/gtest.h>
-
-#include <NBCore/Arrays.hpp>
-
-template<unsigned int N>
-using Coord = typename nb::NDArray<uint8_t, N>::Coordinate;
-
-template<typename A, typename B>
-void ASSERT_ARRAY_EQ(A a, B b) {
-	unsigned int n = a.size();
-	for (int i = 0; i < n; ++i) {
-		ASSERT_EQ(a[i], b[i]);
-	}
-}
-
-TEST(TestNDArray, TestBasic) {
-	float* data_f = new float[9] {0,1,2,3,4,5,6,7,8};
-	nb::NDArray<float, 2> arr({3, 3}, data_f);
-	Coord<2> x{1,1};
-	ASSERT_ARRAY_EQ(arr.dimensions, Coord<2>{3,3});
-	ASSERT_FLOAT_EQ(data_f[4], arr.at(x));
-	arr.at(x) = 0.5;
-	ASSERT_FLOAT_EQ(0.5, arr.at(x));
-	delete[] data_f;
-
-	Coord<3> y{1,0,1};
-	unsigned int* data_ui = new unsigned int[8] {0,1,2,3,4,5,6,7};
-	nb::NDArray<unsigned int, 3> arr3d({2,2,2}, data_ui);
-	ASSERT_ARRAY_EQ(arr3d.dimensions, Coord<3>{2,2,2});
-	ASSERT_EQ(data_ui[5], arr3d.at(y));	
-	arr3d[{0,1,1}] = 23;
-	ASSERT_EQ(23, arr3d.at({0,1,1}));
-	delete[] data_ui;
-
-	nb::NDArray<uint8_t, 4> arr4d({4,4,4,4});
-	arr4d[{0,1,2,3}] = 57;
-	ASSERT_ARRAY_EQ(arr4d.dimensions, Coord<4>{4,4,4,4});
-	ASSERT_EQ(57, arr4d.at({0,1,2,3}));
-}
-
-TEST(TestNDArray, TestMove) {
-	unsigned int data_ui[8] = {0,1,2,3,4,5,6,7};
-	nb::NDArray<unsigned int, 2> arr_1({4, 2}, data_ui);
-	nb::NDArray<unsigned int, 2> arr_2(std::move(arr_1));
-	Coord<2> x{2, 1};
-	ASSERT_EQ(arr_1.data(), nullptr);
-	ASSERT_ARRAY_EQ(arr_1.dimensions, arr_2.dimensions);
-	ASSERT_EQ(arr_2.at(x), 6);
-}
-
-TEST(TestNDArray, TestConversion) {
-	nb::NDArray<unsigned int, 2> arr1({3,3});
-	nb::NDArray<unsigned int, 3> arr2(std::move(arr1));
-	ASSERT_EQ(arr1.data(), nullptr);
-	ASSERT_ARRAY_EQ(arr2.dimensions, Coord<3>{3,3,1});
-	nb::NDArray<unsigned int, 2> arr3(std::move(arr2));
-	ASSERT_EQ(arr2.data(), nullptr);
-	ASSERT_ARRAY_EQ(arr3.dimensions, Coord<2>{3,3});
-}
-
-TEST(TestNDArray, TestFromMemory) {
-	auto data = new float[9]{1,2,3,4,5,6,7,8,9};
-	auto arr1 = nb::NDArray<float, 2>::MemoryToNDArray({3,3}, data);
-	ASSERT_EQ(arr1.data(), data);
-	ASSERT_FLOAT_EQ(arr1.at({1,2}), data[5]);
-	auto data2 = new float[9]{9,8,7,6,5,4,3,2,1};
-	arr1.data(data2);
-	ASSERT_EQ(arr1.data(), data);
-	ASSERT_FLOAT_EQ(arr1.at({3,0}), data2[6]);
-	delete[] data2;
-}
-

engine/NBCore/tests/testUtils.cpp

@@ -3,9 +3,8 @@
 #include <gtest/gtest.h>
 
 #include <string>
-#include <NBCore/StringUtils.hpp>
 #include <NBCore/TypeTraits.hpp>
-#include <NBCore/Utils.hpp>
+#include <NBCore/StringUtils.hpp>
 
 namespace nb {
 
@@ -23,7 +22,7 @@ TEST(UtilsTest, TestFindAndReplace) {
 
     tmp = find_and_replace("aeiou", "a", "afa");
     tmp = find_and_replace(tmp, "e", "efe");
-	tmp = find_and_replace(tmp, "i", "ifi");
+    tmp = find_and_replace(tmp, "i", "ifi");
     tmp = find_and_replace(tmp, "o", "ofo");
     tmp = find_and_replace(tmp, "u", "ufu");
     ASSERT_STREQ(
@@ -47,6 +46,7 @@ TEST(UtilsTest, TestFindAndReplaceWstr) {
         find_and_replace<wchar_t>(L"Jeff", L"e", L"efe").c_str(), 
         L"Jefeff"
     );
+
     std::wstring tmp = find_and_replace<wchar_t>(L"Naif", L"a", L"afa");
     ASSERT_STREQ(
         find_and_replace<wchar_t>(tmp, L"i", L"ifi").c_str(), 
@@ -74,6 +74,44 @@ TEST(UtilsTest, TestFindAndReplaceWstr) {
     );
 }
 
+/* TEST(UtilsTest, TestWstrToStr) {
+    ASSERT_STREQ(
+        nb::wstr_to_str(L"Hi!").c_str(), 
+        "Hi!"
+    );
+    ASSERT_STREQ(
+        nb::wstr_to_str(L"Naif").c_str(),
+        "Naif"
+    );
+    ASSERT_STREQ(
+        nb::wstr_to_str(L"\r\r\r\n").c_str(),
+        "\r\r\r\n"
+    );
+    ASSERT_STREQ(
+        nb::wstr_to_str(L"Naif\ttalks\r\ra\t\nlot").c_str(),
+        "Naif\ttalks\r\ra\t\nlot"
+    );
+} */
+
+/* TEST(UtilsTest, TestStrToWstr) {
+    ASSERT_STREQ(
+        nb::str_to_wstr("Hi!").c_str(), 
+        L"Hi!"
+    );
+    ASSERT_STREQ(
+        nb::str_to_wstr("Naif").c_str(),
+        L"Naif"
+    );
+    ASSERT_STREQ(
+        nb::str_to_wstr("\r\r\r\n").c_str(),
+        L"\r\r\r\n"
+    );
+    ASSERT_STREQ(
+        nb::str_to_wstr("Naif\ttalks\r\ra\t\nlot").c_str(),
+        L"Naif\ttalks\r\ra\t\nlot"
+    );
+} */
+
 struct A { bool x(); };
 struct B { bool y(); };
 struct C { bool x(); bool y; };

engine/NBGraphics/include/NBGraphics/Window.hpp

@@ -6,11 +6,8 @@
 #include <NBGraphics/OGLObjects.hpp>
 
 #include <array>
-#include <functional>
 #include <memory>
 #include <string>
-#include <type_traits>
-#include <utility>
 #include <vector>
 
 #include <NBCore/Errors.hpp>
@@ -33,86 +30,6 @@ class GLFWError : public Error<GLFWError> {
     static const ErrorCodeMap ErrorMessages;
 };
 
-class OGLWindow;
-
-enum WindowCallbacks {
-    KEY, CHAR, CHAR_MODS, MOUSE_BUTTON, CURSOR_POS, CURSOR_ENTER,
-    SCROLL, DROP, WINDOW_POS, WINDOW_SIZE, WINDOW_CLOSE, WINDOW_REFRESH,
-    WINDOW_FOCUS, WINDOW_ICONIFY, WINDOW_MAX, FRAMEBUFFER_SIZE, WINDOW_SCALE,
-};
-
-template<WindowCallbacks>
-struct OGLWindowCallbacks;
-
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::KEY> {
-    using type = typename std::function<void(OGLWindow*, int, int, int, int)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::CHAR> {
-    using type = typename std::function<void(OGLWindow*, unsigned int)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::CHAR_MODS> {
-    using type = typename std::function<void(OGLWindow*, unsigned int, int)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::CURSOR_ENTER> {
-    using type = typename std::function<void(OGLWindow*, int)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::CURSOR_POS> {
-    using type = typename std::function<void(OGLWindow*, double, double)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::MOUSE_BUTTON> {
-    using type = typename std::function<void(OGLWindow*, int, int, int)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::SCROLL> {
-    using type = typename std::function<void(OGLWindow*, double, double)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::DROP> {
-    using type = typename std::function<void(OGLWindow*, int, const char**)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::WINDOW_POS> {
-    using type = typename std::function<void(OGLWindow*, int, int)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::WINDOW_SIZE> {
-    using type = typename std::function<void(OGLWindow*, int, int)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::WINDOW_CLOSE> {
-    using type = typename std::function<void(OGLWindow*)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::WINDOW_REFRESH> {
-    using type = typename std::function<void(OGLWindow*)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::WINDOW_FOCUS> {
-    using type = typename std::function<void(OGLWindow*, int)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::WINDOW_ICONIFY> {
-    using type = typename std::function<void(OGLWindow*, int)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::WINDOW_MAX> {
-    using type = typename std::function<void(OGLWindow*, int)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::FRAMEBUFFER_SIZE> {
-    using type = typename std::function<void(OGLWindow*, int, int)>;
-};
-template<>
-struct OGLWindowCallbacks<WindowCallbacks::WINDOW_SCALE> {
-    using type = typename std::function<void(OGLWindow*, int)>;
-};
-
 class OGLWindow {
     using GLFWHint = std::array<int, 2>;
     private:
@@ -128,30 +45,32 @@ class OGLWindow {
     static thread_local GLFWwindow* _currWindow;
     static thread_local const GLFWwindow* _currArena;
     
-    template<typename T>
+    static void SetHintInteger(const std::array<int, 2>&);
-    static void SetHint(std::pair<int, T> hint) {
+    static void SetHintString(const std::tuple<int, std::string>&);
-        if constexpr ( std::is_same_v<T, std::string> ) {
-            glfwWindowHintString(std::get<0>(hint), std::get<1>(hint).c_str());
-        } else if constexpr ( std::is_same_v<T, int> ) {
-            glfwWindowHint(std::get<0>(hint), std::get<1>(hint));
-        }
-    }
     
     std::string _title;
     GLFWwindow* _window_ptr;
     const GLFWwindow* _arena;
 
     OGLWindow(
-        unsigned int x,
+        unsigned int,
-        unsigned int y,
+        unsigned int,
         const std::string&,
+        const std::vector<std::array<int, 2>>&,
+        const std::vector<std::tuple<int, std::string>>&,
         GLFWwindow* sharingContext = NULL
     );
-
     GLFWwindow* makeCurrent() const;
     void detachWindow();
 
     public:
+    enum Callbacks {
+        KEY, CHAR, CHAR_MODS, MOUSE_BUTTON, CURSOR_POS, CURSOR_ENTER,
+        SCROLL, DROP, WINDOW_POS, WINDOW_SIZE, WINDOW_CLOSE, WINDOW_REFRESH,
+        WINDOW_FOCUS, WINDOW_ICONIFY, WINDOW_MAX, FRAMEBUFFER_SIZE, WINDOW_SCALE,
+    };
+    template<typename... T>
+    using CallbackFunc = void(*)(OGLWindow*, T...);
 
     static inline bool IsGLFWInitialized() { return _glfwInitialized; }
     static bool InitGLFW(const std::vector<GLFWHint>& hints={});
@@ -161,38 +80,21 @@ class OGLWindow {
     static GLFWwindow* MakeCurrent(const std::shared_ptr<OGLWindow>&);
     static inline GLFWwindow* DropCurrent() { return MakeCurrent(nullptr); }
     static void DestroyWindow(std::shared_ptr<OGLWindow>&);
-    template <typename... T>
     static std::shared_ptr<OGLWindow> CreateWindow(
         unsigned int x,
         unsigned int y,
         const std::string& title,
-        const std::pair<int, T>&... windowHints
+        const std::vector<std::array<int, 2>>& integerHints={},
-    ) {
+        const std::vector<std::tuple<int, std::string>>& stringHints={}
-        (SetHint(std::pair(windowHints)),... );
+    );
-        return std::shared_ptr<OGLWindow>(new OGLWindow(
-            x,
-            y,
-            title,
-            nullptr
-        ) );
-    }
-    template<typename... T>
     static std::shared_ptr<OGLWindow> CreateSharedWindow(
         unsigned int x,
         unsigned int y,
         const std::string& title,
-        std::shared_ptr<OGLWindow> sharingWindow = NULL,
+        std::shared_ptr<OGLWindow> sharingWindow,
-        const std::pair<int, T>&... windowHints
+        const std::vector<std::array<int, 2>>& integerHints={},
-    ) {
+        const std::vector<std::tuple<int, std::string>>& stringHints={}
-        (SetHint(std::pair(windowHints)),... );
+    );
-        return std::shared_ptr<OGLWindow>(new OGLWindow(
-            x,
-            y,
-            title,
-            sharingWindow->_window_ptr
-        ) );
-    }
-
     OGLWindow(OGLWindow&&) = delete;
     OGLWindow(const OGLWindow&) = delete;
     ~OGLWindow();
@@ -204,91 +106,14 @@ class OGLWindow {
     inline std::string getTitle() const { return _title; }
     std::array<int, 2> getSize() const;
     bool shouldClose() const;
-    inline void pollEvents() const { CheckForMainThread(); glfwPollEvents(); }
+    inline void processEvents() const { CheckForMainThread(); glfwPollEvents(); }
-    inline void swapBuffers() const { glfwSwapBuffers(_window_ptr); }
+    inline void refresh() const { glfwSwapBuffers(_window_ptr); }
 
     void setSize(unsigned int x, unsigned int y);
     void setTitle(const std::string&);
     void shouldClose(bool);
-
+/*     template<enum Callbacks, typename Func>
-    template<WindowCallbacks CallbackType, typename CallbackFunc>
+    void setCallBack(Func); */
-    void setCallback(CallbackFunc callback) {
-        CheckForMainThread();
-        auto tmp = makeCurrent();
-        static auto this_ptr = this;
-        static typename OGLWindowCallbacks<CallbackType>::type tmp_callback = callback;
-        if constexpr (CallbackType == KEY) {
-            glfwSetKeyCallback(_window_ptr, [](GLFWwindow*, int a, int b, int c, int d){
-                tmp_callback(this_ptr, a,b,c,d);
-            });
-        } else if constexpr (CallbackType == CHAR) {
-                glfwSetCharCallback(_window_ptr, [](GLFWwindow*, int a) {
-                tmp_callback(this_ptr, a);
-            });
-        } else if constexpr (CallbackType == CHAR_MODS) {
-                glfwSetCharModsCallback(_window_ptr, [](GLFWwindow*, unsigned int a, int b) {
-                tmp_callback(this_ptr, a, b);
-            });
-        } else if constexpr (CallbackType == CURSOR_ENTER) {
-                glfwSetCursorEnterCallback(_window_ptr, [](GLFWwindow*, int a) {
-                tmp_callback(this_ptr, a);
-            });
-        } else if constexpr (CallbackType == CURSOR_POS) {
-            glfwSetCursorPosCallback(_window_ptr, [](GLFWwindow*, double a, double b){
-                tmp_callback(this_ptr, a,b);
-            });
-        } else if constexpr (CallbackType == MOUSE_BUTTON) {
-            glfwSetMouseButtonCallback(_window_ptr, [](GLFWwindow*, int a, int b, int c){
-                tmp_callback(this_ptr, a,b,c);
-            });
-        } else if constexpr (CallbackType == SCROLL) {
-                glfwSetScrollCallback(_window_ptr, [](GLFWwindow*, double a, double b) {
-                tmp_callback(this_ptr, a,b);
-            });
-        } else if constexpr (CallbackType == DROP) {
-                glfwSetDropCallback(_window_ptr, [](GLFWwindow*, int a, const char** b) {
-                tmp_callback(this_ptr, a, b);
-            });
-        } else if constexpr (CallbackType == WINDOW_POS) {
-            glfwSetWindowPosCallback(_window_ptr, [](GLFWwindow*, int a, int b){
-                tmp_callback(this_ptr, a,b);
-            });
-        } else if constexpr (CallbackType == WINDOW_SIZE) {
-            glfwSetWindowSizeCallback(_window_ptr, [](GLFWwindow*, int a, int b){
-                tmp_callback(this_ptr, a,b);
-            });
-        } else if constexpr (CallbackType == WINDOW_CLOSE) {
-            glfwSetWindowCloseCallback(_window_ptr, [](GLFWwindow*){
-                tmp_callback(this_ptr);
-            });
-        } else if constexpr (CallbackType == WINDOW_REFRESH) {
-            glfwSetWindowRefreshCallback(_window_ptr, [](GLFWwindow*){
-                tmp_callback(this_ptr);
-            });
-        } else if constexpr (CallbackType == WINDOW_FOCUS) {
-            glfwSetWindowFocusCallback(_window_ptr, [](GLFWwindow*, int a) {
-                tmp_callback(this_ptr, a);
-            });
-        } else if constexpr (CallbackType == WINDOW_ICONIFY) {
-                glfwSetWindowIconifyCallback(_window_ptr, [](GLFWwindow*, int a) {
-                tmp_callback(this_ptr, a);
-            });
-        } else if constexpr (CallbackType == WINDOW_MAX) {
-                glfwSetWindowMaximizeCallback(_window_ptr, [](GLFWwindow*, int a) {
-                tmp_callback(this_ptr, a);
-            });
-        } else if constexpr (CallbackType == FRAMEBUFFER_SIZE) {
-                glfwSetFramebufferSizeCallback(_window_ptr, [](GLFWwindow*, int a, int b) {
-                tmp_callback(this_ptr, a, b);
-            });
-        } else if constexpr (CallbackType == WINDOW_SCALE) {
-                glfwSetWindowContentScaleCallback(_window_ptr, [](GLFWwindow*, int a, int b) {
-                tmp_callback(this_ptr, a, b);
-            });
-        } else {
-            static_assert(false, "No matching callback.");
-        }
-    }
 };
 
 };

engine/NBGraphics/src/Window.cpp

@@ -48,27 +48,79 @@ bool OGLWindow::TerminateGLFW() {
     return !IsGLFWInitialized();
 }
 
+void OGLWindow::SetHintInteger(const std::array<int, 2>& hint) {
+    CheckForMainThread();
+    glfwWindowHint(hint[0], hint[1]);
+}
+
+void OGLWindow::SetHintString(const std::tuple<int, std::string>& hint) {
+    CheckForMainThread();
+    glfwWindowHintString(std::get<0>(hint), std::get<1>(hint).c_str());
+}
+
 GLFWwindow* OGLWindow::MakeCurrent(const std::shared_ptr<OGLWindow>& window) {
     auto tmp = _currWindow;
+    _currWindow = window->getWindowPtr();
     if (window) {
-        _currWindow = window->getWindowPtr();
+        glfwMakeContextCurrent(_currWindow);
         _currArena = window->_arena;
     } else {
-        _currWindow = nullptr;
+        glfwMakeContextCurrent(nullptr);
         _currArena = nullptr;
     }
-    glfwMakeContextCurrent(_currWindow);
     return tmp;
 }
 
+std::shared_ptr<OGLWindow> OGLWindow::CreateWindow(
+    unsigned int x,
+    unsigned int y,
+    const std::string& title,
+    const std::vector<std::array<int, 2>>& integerHints,
+    const std::vector<std::tuple<int, std::string>>& stringHints
+) {
+    return std::shared_ptr<OGLWindow>( new OGLWindow(
+        x,
+        y,
+        title,
+        integerHints,
+        stringHints
+    ) );
+}
+
+std::shared_ptr<OGLWindow> OGLWindow::CreateSharedWindow(
+    unsigned int x,
+    unsigned int y,
+    const std::string& title,
+    std::shared_ptr<OGLWindow> sharingWindow,
+    const std::vector<std::array<int, 2>>& integerHints,
+    const std::vector<std::tuple<int, std::string>>& stringHints
+) {
+    return std::shared_ptr<OGLWindow>( new OGLWindow(
+        x,
+        y,
+        title,
+        integerHints,
+        stringHints,
+        sharingWindow->getWindowPtr()
+    ) );
+}
+
 OGLWindow::OGLWindow(
     unsigned int x,
     unsigned int y,
-    const std::string&,
+    const std::string& title,
+    const std::vector<std::array<int, 2>>& integerHints,
+    const std::vector<std::tuple<int, std::string>>& stringHints,
     GLFWwindow* sharingContext
-) {
+) : _title(title) {
     CheckForMainThread();
     InitGLFW();
+    for (const auto& hint : integerHints) {
+        SetHintInteger(hint);
+    }
+    for (const auto& hint : stringHints) {
+        SetHintString(hint);
+    }
     _window_ptr = glfwCreateWindow(
         x,
         y,
@@ -148,4 +200,14 @@ void OGLWindow::setTitle(const std::string& name) {
     glfwSetWindowTitle(_window_ptr, _title.c_str());
 }
 
+/* template<> void OGLWindow::setCallBack<OGLWindow::KEY>( CallbackFunc<int,int,int,int> func) {
+    CheckForMainThread();
+    auto tmp = makeCurrent();
+    auto tmp_func = 
+        [=](GLFWwindow* window, int a, int b, int c, int d){
+            func(this, a, b, c, d);
+        };
+    glfwSetKeyCallback(_window_ptr, tmp_func);
+} */
+
 };

engine/NBGraphics/tests/TestWindow.cpp

@@ -3,7 +3,6 @@
 #include "stb_image.h"
 
 #include <NBCore/Errors.hpp>
-#include <NBCore/TypeTraits.hpp>
 #include <NBGraphics/Image.hpp>
 #include <NBGraphics/Mesh.hpp>
 #include <NBGraphics/ProgramPipeline.hpp>
@@ -18,8 +17,8 @@ int main() {
         400,
         400,
         "Howdy!", 
-        nb::KeyVal(GLFW_CONTEXT_VERSION_MAJOR, 3),
+        {{GLFW_CONTEXT_VERSION_MAJOR, 3},
-        nb::KeyVal(GLFW_CONTEXT_VERSION_MINOR, 3)
+        {GLFW_CONTEXT_VERSION_MINOR, 3}}
     );
     nb::OGLWindow::MakeCurrent(window);
 
@@ -70,25 +69,13 @@ int main() {
         }}, indxs);
     LOG(prog.log());
 
-    using nb::WindowCallbacks;
+    GLFWwindow* window_ptr = window->getWindowPtr();
-
+    while(!glfwWindowShouldClose(window_ptr)) {
-    window->setCallback<nb::KEY>(
-        [](nb::OGLWindow* w, int key, int, int, int)->void{
-        if (key == GLFW_KEY_Q) {
-            w->shouldClose(true);
-        }
-    });
-    window->setCallback<nb::CURSOR_POS>(
-        [](nb::OGLWindow* w, double x, double y)->void{
-            nb::logger.msg("Pos in x is " + std::to_string(x));
-        }
-    );
-    while(!window->shouldClose()) {
         OPENGL_CALL(glClearColor(0.2f, 0.3f, 0.3f, 1.0f));
         OPENGL_CALL(glClear(GL_COLOR_BUFFER_BIT));
         tri.draw();
-        window->pollEvents();
+        glfwPollEvents();
-        window->swapBuffers();
+        glfwSwapBuffers(window_ptr);
     }    
 
     return 0;