Lots of stuff, ending with Window restruct

.gitignore

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

CMakeLists.txt

@@ -28,32 +28,45 @@ 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 "Building for Windows")
@@ -93,7 +106,7 @@ 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)

engine/NBCore/CMakeLists.txt

@@ -13,12 +13,11 @@ toAbsolutePath(NB_CORE_SOURCE
     ./src/Logger.cpp
     ./src/Processes.cpp
     ./src/StringUtils.cpp
-    ./src/TypeTraits.cpp
     ./src/Utils.cpp
 )
 toAbsolutePath(NB_CORE_INCLUDE
+    ./include/NBCore/ANSITerm.hpp
     ./include/NBCore/DataSink.hpp
-	./include/NBCore/DataTypes.hpp
     ./include/NBCore/Errors.hpp
     ./include/NBCore/ErrorsImpl.hpp
     ./include/NBCore/Logger.hpp

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/DataTypes.hpp

@@ -1,71 +0,0 @@
-#pragma once
-#include <cstring>
-#ifndef _NB_DATA_TYPES
-#define _NB_DATA_TYPES
-
-#include <algorithm>
-#include <array>
-#include <memory>
-
-namespace nb {
-
-template<typename T, unsigned int N>
-class NDArray {
-	protected:	
-		std::unique_ptr<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:
-	const std::array<unsigned int, N> dimensions;
-	const unsigned int totalSize;
-	static constexpr unsigned int NumberDimensions = N;
-	NDArray(
-		const std::array<unsigned int, N>& dimensions_,
-		T* data_=nullptr
-	) : 
-		dimensions(dimensions_),
-		totalSize(calculateTotalSize(dimensions_))
-	{
-		if (data_) { data(data_); }
-	}
-	NDArray(
-		const std::array<unsigned int, N>& dimensions_,
-		const T* data_
-	) : NDArray(dimensions_) { data(data_); }
-
-	unsigned int coordinateToIndex(const std::array<T, N>& 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 const T& at(const std::array<T, N>& coord) const {
-		return _data[coordinateToIndex(coord)];
-	}
-	inline std::shared_ptr<T> data() const { return _data; }
-
-	inline T& at(const std::array<T, N>& coord) {
-		return _data[coordinateToIndex(coord)];
-	}
-	inline T* data(const T* data_) {
-		_data = std::make_unique<T[]>(totalSize);
-		std::memcpy(_data.get(), data_, totalSize * sizeof(T));
-		return _data.get();
-	}
-
-	
-	
-}; // namespace nb
-
-}
-#endif // _NB_DATA_TYPES

engine/NBCore/include/NBCore/TypeTraits.hpp

@@ -2,8 +2,9 @@
 #ifndef _NB_TYPE_TRAITS
 #define _NB_TYPE_TRAITS
 
+#include <tuple>
 #include <type_traits>
-#include <utility>
+#include <vector>
 
 namespace nb {
 
@@ -30,17 +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); }
-
-enum TypeCodes {
-    UINT8, UINT16, UINT32, UINT64, INT8, INT16, INT32, INT64,
-    FLOAT16, FLOAT32, DOUBLE64, BOOL, NONE
-};
-
-template<typename T>
-static constexpr TypeCodes GetTypeEnum = NONE;
-
 struct NoneType{};
 
 template<typename T, unsigned int Arg>
@@ -100,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;
 
@@ -135,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,7 +1,8 @@
 #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>

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,5 +1,6 @@
 cmake_minimum_required(VERSION 3.26.0)
 
+if (NB_BUILD_TESTS)
     enable_testing()
     include(GoogleTest)
     add_executable(TestCore
@@ -20,4 +21,4 @@ target_link_libraries(LoggerTest
     )
 
     gtest_discover_tests(TestCore)
-
+endif()

engine/NBCore/tests/testUtils.cpp

@@ -3,7 +3,6 @@
 #include <gtest/gtest.h>
 
 #include <string>
-#include <NBCore/DataTypes.hpp>
 #include <NBCore/TypeTraits.hpp>
 #include <NBCore/StringUtils.hpp>
 
@@ -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; };
@@ -107,22 +145,4 @@ TEST(UtilsTest, TestIsDetected) {
     ASSERT_TRUE(ret);
 }
 
-TEST(DataTypesTests, TestNDArray) {
-	float* data_f = new float[9] {0,1,2,3,4,5,6,7,8};
-	nb::NDArray<float, 2> arr({3, 3}, data_f);
-	ASSERT_FLOAT_EQ(data_f[4], arr.at({1,1}));
-	arr.at({1,1}) = 0.5;
-	ASSERT_FLOAT_EQ(0.5, arr.at({1,1}));
-	delete[] data_f;
-
-	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_EQ(data_ui[5], arr3d.at({1,0,1}));
-	arr3d.at({0,1,1}) = 23;
-	ASSERT_EQ(23, arr3d.at({0,1,1}));
-	delete[] data_ui;
-
-
-}
-
 } // namespace nb

engine/NBGraphics/CMakeLists.txt

@@ -30,26 +30,23 @@ toAbsolutePath(NB_GRAPHICS_SOURCE
     ./src/Buffers.cpp
     ./src/FrameBuffers.cpp
     ./src/Image.cpp
-    ./src/Mesh.cpp
     ./src/OGLObjects.cpp
     ./src/ProgramPipeline.cpp
     ./src/Textures.cpp
     ./src/VertexArray.cpp
-    ./src/VertexData.cpp
     ./src/Window.cpp
 )
 toAbsolutePath(NB_GRAPHICS_INCLUDE
     ./include/NBGraphics/Buffers.hpp
     ./include/NBGraphics/Camera.hpp
+    ./include/NBGraphics/Draw.hpp
     ./include/NBGraphics/FrameBuffers.hpp
     ./include/NBGraphics/GLLoad.hpp
     ./include/NBGraphics/Image.hpp
-    ./include/NBGraphics/Mesh.hpp
     ./include/NBGraphics/OGLObjects.hpp
     ./include/NBGraphics/ProgramPipeline.hpp
     ./include/NBGraphics/Textures.hpp
     ./include/NBGraphics/VertexArray.hpp
-    ./include/NBGraphics/VertexData.hpp
     ./include/NBGraphics/Window.hpp
 )
 

engine/NBGraphics/include/NBGraphics/Buffers.hpp

@@ -57,8 +57,7 @@ class BufferError : public Error<BufferError> {
     enum Codes : unsigned int {
         UNDEFINED,
         DATA_OVERFLOW,
-        DATA_ERROR,
+        DATA_ERROR
-        BAD_DATA_TYPE
     };
     static const std::string type;
     static const ErrorCodeMap ErrorMessages;
@@ -70,6 +69,7 @@ class Buffer : public OpenGLObject {
     using OpenGLObject::_id;
     GLenum _usage = GL_STATIC_DRAW;
     size_t _size;
+    Buffer(GLenum target) : Target(target) {}
     virtual GLuint declare() override {
         if (!_id) {
             OPENGL_CALL(glGenBuffers(1, &_id));
@@ -88,8 +88,6 @@ class Buffer : public OpenGLObject {
     public:
     const GLenum Target;
     using OpenGLObject::OpenGLObject;
-    Buffer(GLenum target);
-    Buffer(GLenum target, const ByteVector&, GLenum usage=GL_STATIC_DRAW);
     Buffer(Buffer&& other);
     Buffer& operator=(Buffer&& rhs);
 
@@ -153,6 +151,15 @@ protected:
 
 }; */
 
+class ArrayBuffer : public Buffer {
+    public:
+    template<typename T>
+    ArrayBuffer(const std::vector<T>& data, GLenum usage=GL_STATIC_DRAW)
+    : Buffer(GL_ARRAY_BUFFER) {
+        Buffer::data(vectorToBytes(data), usage);
+    }
+};
+
 class UniformBuffer : public Buffer {
     protected:
     GLuint _index;
@@ -165,96 +172,58 @@ class UniformBuffer : public Buffer {
 
 };
 
-template<typename T>
+class ElementBuffer : protected Buffer {
-struct IsValidGLElementIndexType {
-    static constexpr bool value = false;
-
-};
-
-template<typename T>
-struct ValidGLElementIndexType {
-    static constexpr bool value = true;
-    static constexpr GLenum glsltype = GLSLType<T>::value;
-};
-
-
-template<>
-struct IsValidGLElementIndexType<uint8_t> : public ValidGLElementIndexType<uint8_t> {};
-template<>
-struct IsValidGLElementIndexType<uint16_t> : public ValidGLElementIndexType<uint16_t> {};
-template<>
-struct IsValidGLElementIndexType<uint32_t> : public ValidGLElementIndexType<uint32_t> {};
-
-class ElementBuffer : Buffer {
-    private:
-    template<typename T>
-    inline void checkForElementDataType() {
-        static_assert(IsValidGLElementIndexType<T>::value, 
-            "ElementBuffer data type must resolve to one of GL_UNSIGNED_BYTE,"
-            "GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT"
-        );
-    }
-    
     protected:
-    using Codes = BufferError::Codes;
+    GLenum _glslType;
-    using OpenGLObject::_id;
+    size_t _typeSize;
-    using Buffer::_usage;
-    using Buffer::_size;
-    using Buffer::declare;
-    using Buffer::remove;
-    GLenum _datatype;
-    template<typename T>
-    inline void checkDatatypeConsistency() {
-        if (_datatype != ValidGLElementIndexType<T>::value) {
-            THROW(BufferError(
-                Codes::BAD_DATA_TYPE,
-                GLenumTable[ValidGLElementIndexType<T>::value] + " not same as buffer "
-                "data type "+GLenumTable[_datatype]
-            ));
-        }
-    }
 
     public:
     using Buffer::Target;
-    using Buffer::OpenGLObject;
     using Buffer::bind;
-    using Buffer::unbind;
     using Buffer::usage;
-    using Buffer::size;
+    using Buffer::unbind;
+    ElementBuffer();
     template<typename T>
-    ElementBuffer(const std::vector<T>& indices, GLenum usage=GL_STATIC_DRAW) : Buffer(GL_ELEMENT_ARRAY_BUFFER) {
+    ElementBuffer(const T* const data_ptr, size_t size, GLenum usage=GL_STATIC_DRAW)
-        data(indices, usage);
+    : Buffer(GL_ELEMENT_ARRAY_BUFFER) {
+        data(data_ptr, size, usage);
+    }
+    template<typename T>
+    ElementBuffer(const std::vector<T>& data_, GLenum usage_=GL_STATIC_DRAW)
+    : ElementBuffer(data_.data(), data_.size(), usage_) {}
+    
+    size_t size() const;
+    size_t typeSize() const;
+    ByteVector data() const;
+    GLenum glslType() const;
+    template<typename T>
+    void data(const T* data_, size_t size_, GLenum usage_=GL_STATIC_DRAW) {
+        declare();
+        using TypeInfo = GLSLType<T>;
+        _typeSize = TypeInfo::size;
+        Buffer::data(data_, size_*_typeSize, usage_);
+        _glslType = TypeInfo::value;
+    }
+    template<typename T>
+    void data(const std::vector<T>& data_, GLenum usage_=GL_STATIC_DRAW) {
+        data(data_.data(), data_.size(), usage_);
+    }
+    template<typename T>
+    void subdata(const T* data, size_t size, size_t offset) {
+        using TypeInfo = GLSLType<T>;
+        if ( _glslType != TypeInfo::value ) {
+            THROW( BufferError(
+                Codes::DATA_ERROR,
+                "Check element buffer data types"
+            ) );
+        }
+        Buffer::subdata(data, size*_typeSize, offset);
+    }
+    template<typename T>
+    void subdata(const std::vector<T>& data, size_t offset=0) {
+        subdata(data.data(), data.size(), offset);
     }
 
-    inline GLenum datatype() { return _datatype; }
-
-    template<typename T>
-    void data(const std::vector<T>& data, GLenum usage=GL_STATIC_DRAW) {
-        checkForElementDataType<T>();
-        _datatype = ValidGLElementIndexType<T>::glsltype;
-        Buffer::data(vectorToBytes(data), usage);
-    }
-    
-    template<typename T>
-    void data(const T* data, size_t size, GLenum usage=GL_STATIC_DRAW) {
-        checkForElementDataType<T>();
-        _datatype = ValidGLElementIndexType<T>::glsltype;
-        Buffer::data((void*)data, size * sizeof(T), usage);
-    }
-    
-    template<typename T>
-    void subdata(const T* data, size_t size, GLintptr offset=0) {
-        checkForElementDataType<T>();
-        checkDatatypeConsistency<T>();
-        Buffer::subdata((void*)data, size * sizeof(T), offset);
-    }
-    
-    template<typename T>
-    void subdata(const std::vector<T>& data_, GLintptr offset=0) {
-        checkForElementDataType<T>();
-        checkDatatypeConsistency<T>();
-        Buffer::subdata(vectorToBytes(data_), offset);
-    }
 
 };
 

engine/NBGraphics/include/NBGraphics/Draw.hpp

@@ -0,0 +1,83 @@
+#pragma once
+#ifndef _NB_DRAW
+#define _NB_DRAW
+
+#include <NBGraphics/GLLoad.hpp>
+
+#include <exception>
+#include <map>
+#include <string>
+#include <vector>
+
+#include <NBGraphics/Buffers.hpp>
+#include <NBGraphics/VertexArray.hpp>
+
+#define THROW_DRAW_ERROR(msg) throw DrawError(msg, __FILE__, __LINE__);
+
+namespace nb{
+
+class DrawError : public std::runtime_error {
+public:
+    DrawError(const std::string&, const std::string& file="", int line=-1);
+};
+
+uint8_t VerticesFromPrimitives(GLenum, unsigned int num_prims=1);
+
+uint8_t PrimitivesFromVertices(GLenum, unsigned int);
+
+void copyVertexAttribute(const VertexAttribute&, VertexAttribute&);
+
+class DrawBuffer {
+public:
+typedef std::shared_ptr<Buffer> BufferManagerPointer;
+    DrawBuffer(VertexAttributeList, GLenum prim_type=GL_TRIANGLES);
+    //DrawBuffer(std::initializer_list<VertexAttribute>, std::initializer_list<VertexAttributePointer>);
+
+    unsigned int vertSize() const;
+    const std::shared_ptr<ShaderProgram> shader() const;
+    unsigned int elementBufferID() const;
+    unsigned int vertexBufferID() const;
+    virtual void draw() const;
+    RawVec vertAttrData(unsigned int);
+
+    VertexAttributeList changeVertLayout(unsigned int, VertexAttributePointer);
+    RawVec vertAttrData(unsigned int, const RawVec&);
+    virtual void elementData(const std::vector<unsigned int>&);
+    virtual void elementData(unsigned int);
+    virtual void elementData(const std::vector<unsigned int>&, unsigned int offset);
+    virtual void vertexData(const RawVec&);
+    virtual void vertexData(unsigned int num_verts);
+    virtual void vertexData(const RawVec&, unsigned int offset);
+
+    BufferManagerPointer _vert_data;
+    BufferManagerPointer _elmt_data;
+    VAOManager _VAO;
+    const GLenum _gl_primitive_type=0;
+    virtual VertexAttributeList defaultVAO(VertexAttributeList);
+    
+    unsigned int _num_verts, _num_prims;
+protected:
+};
+
+class DrawInstanceBuffer : public DrawBuffer {
+public:
+    DrawInstanceBuffer(VertexAttributeList, VertexAttributeList, GLenum primt_type=GL_TRIANGLES);
+
+    unsigned int instSize() const;
+    unsigned int instanceBufferID() const;
+    virtual void draw() const override;
+
+    VertexAttributeList changeInstanceLayout(unsigned int, VertexAttributePointer);
+    virtual void instanceData(const RawVec&);
+    virtual void instanceData(unsigned int);
+    virtual void instanceData(const RawVec&, unsigned int offset);
+
+    BufferManagerPointer _inst_data;
+    virtual VertexAttributeList defaultVAO(VertexAttributeList);
+    unsigned int _num_inst;
+    
+protected:
+};
+
+}
+#endif

engine/NBGraphics/include/NBGraphics/Mesh.hpp

@@ -1,81 +0,0 @@
-#pragma once
-#ifndef _NB_MESH
-#define _NB_MESH
-
-#include <NBGraphics/GLLoad.hpp>
-
-#include <NBGraphics/Buffers.hpp>
-#include <NBGraphics/VertexArray.hpp>
-#include <NBGraphics/VertexData.hpp>
-
-namespace nb{
-
-class Mesh {
-    protected:
-    const GLenum _primitive;
-    const unsigned int _count;
-    std::shared_ptr<VAO> _vao;
-
-    public:
-    Mesh(
-        VertexDataPointerList vao,
-        unsigned int count,
-        GLenum primitive=GL_TRIANGLES
-    );
-    Mesh(GLenum primitive, const std::shared_ptr<VAO>& vertex_array,  unsigned int count);
-    Mesh(GLenum primitive, const VertexData& vertex_data,  unsigned int count);
-    Mesh(
-        GLenum primitive,
-        const ByteVector& data,
-        unsigned int count,
-        const std::vector<VertexAttribute>& attributes
-    );
-
-    Mesh(Mesh&&);
-    Mesh(const Mesh&&) = delete;
-    Mesh& operator=(Mesh&&) = delete;
-    Mesh& operator=(const Mesh&) = delete;
-
-    inline virtual void draw() const { this->draw(_count); }
-    inline virtual void draw(unsigned int count) const { this->draw(0, count); }
-    virtual void draw(unsigned int offset, unsigned int count) const;
-    inline GLenum primitive() const { return _primitive; }
-    inline unsigned int count() const { return _count; }
-    inline std::shared_ptr<VAO> vao() const { return _vao; }
-};
-
-class InstancedMesh : public Mesh {
-    protected:
-    using Mesh::_primitive;
-    using Mesh::_count;
-    using Mesh::_vao;
-
-    public:
-    virtual void draw(unsigned int offset, unsigned int count) const;
-};
-
-class IndexedMesh : public Mesh {
-    protected:
-    std::shared_ptr<ElementBuffer> _ebo;
-
-    public:
-    template<typename T>
-    IndexedMesh(
-        GLenum primitive,
-        const ByteVector& data,
-        const std::vector<VertexAttribute>& attributes,
-        const std::vector<T>& indices
-    ) : Mesh(primitive, data, indices.size(), attributes) {
-        _vao->bind();
-        _ebo = std::make_shared<ElementBuffer>(indices);
-    }
-
-    using Mesh::draw;
-    virtual void draw(unsigned int offset, unsigned int count) const;
-};
-
-class InstancedIndexedMesh : virtual public IndexedMesh {};
-
-
-}
-#endif

engine/NBGraphics/include/NBGraphics/OGLObjects.hpp

@@ -11,7 +11,6 @@ namespace nb {
 typedef ConstantMap<GLenum, std::string> GLEnumTableType;
 
 extern const GLEnumTableType GLenumTable;
-extern const ConstantMap<TypeCodes, GLint> TypeToGLSL;
 
 class OpenGLError : public Error<OpenGLError> {
     using Base = Error<OpenGLError>;

engine/NBGraphics/include/NBGraphics/VertexArray.hpp

@@ -8,7 +8,6 @@
 
 #include <NBGraphics/Buffers.hpp>
 #include <NBGraphics/OGLObjects.hpp>
-#include <NBGraphics/VertexData.hpp>
 
 
 namespace nb {
@@ -34,13 +33,32 @@ static uint8_t GLSLTypeSize(GLenum type) {
     }
 }
 
+struct VertexAttributeLayout {
+    int32_t offset = 0;
+    GLsizei stride = 0;
+    GLuint divisor = 0;
+};
+
+struct VertexAttribute {
+    GLint GLSLSize;
+    GLenum GLSLType;
+    GLboolean GLSLNormalization;
+    VertexAttributeLayout layout;
+};
+
+struct VertexAttributePointer {
+    VertexAttribute attribute;
+    GLuint buffer;
+    GLuint index;
+};
+
 static bool isIndexInVertexAttribute(int i, const VertexAttribute& va) {
     if ((i -= va.layout.offset) < 0) { return false; }
-    return (i%va.layout.stride) < GLSLTypeSize(TypeToGLSL[va.type]) * va.size;
+    return (i%va.layout.stride) < GLSLTypeSize(va.GLSLType) * va.GLSLSize;
 }
 
-typedef std::vector<VertexData> VertexDataList;
+typedef std::vector<VertexAttribute> VertexAttributeList;
-typedef std::vector<VertexDataPointer> VertexDataPointerList;
+typedef std::vector<VertexAttributePointer> VertexAttributePointerList;
 
 class VAOError : public Error<VAOError> {
     using Base = Error<VAOError>;
@@ -60,30 +78,10 @@ class VAO : public OpenGLObject {
     using Base = OpenGLObject;
     using Codes = VAOError::Codes;
 
-    protected:
-    using Base::_id;
-    VertexDataPointerList _vertexdata;
-
-    virtual void remove() override {
-        if(_id) {
-            disable();
-            bind();
-            OPENGL_CALL(glDeleteVertexArrays(1, &_id));
-            _id = 0;
-        }
-    }
-    virtual GLuint declare() override {
-        if (!_id) {
-            OPENGL_CALL(glGenVertexArrays(1, &_id));
-        }
-        bind();
-        return _id;
-    }
-
     public:
     using Base::Base;
     VAO() = default;
-    VAO(const VertexDataPointerList&);
+    VAO(const VertexAttributePointerList&);
     VAO(VAO&&);
 
     VAO& operator=(VAO&&);
@@ -102,15 +100,34 @@ class VAO : public OpenGLObject {
         OPENGL_CALL(glBindVertexArray(0));
     }
 
-    VertexDataPointerList attributes() const;
+    VertexAttributePointerList attributes() const;
-    VertexDataPointerList attributes(const VertexDataPointerList&);
+    VertexAttributePointerList attributes(const VertexAttributePointerList&);
-    VertexDataPointerList attributes(const VertexDataList&);
+    VertexAttributePointer attr(GLuint) const;
-    VertexDataPointer attribute(GLuint) const;
     void enable() const;
     void enable(GLuint) const;
     void disable() const;
     void disable(GLuint) const;
 
+    protected:
+    using Base::_id;
+    VertexAttributePointerList _attrs;
+
+    virtual void remove() override {
+        if(_id) {
+            disable();
+            bind();
+            OPENGL_CALL(glDeleteVertexArrays(1, &_id));
+            _id = 0;
+        }
+    }
+    virtual GLuint declare() override {
+        if (!_id) {
+            OPENGL_CALL(glGenVertexArrays(1, &_id));
+        }
+        bind();
+        return _id;
+    }
+
 };
 
 class VertexError : public Error<VertexError> {
@@ -127,5 +144,97 @@ class VertexError : public Error<VertexError> {
 
 };
 
+using VBO = ArrayBuffer;
+using VertBufVec = SharedVector<VBO>;
+using EBO = ElementBuffer;
+
+struct VertexData {
+    std::shared_ptr<VBO> vbo;
+    VertexAttributeList attrs;
+};
+
+using VertexDataVec = std::vector<VertexData>;
+
+class VertexGroup {
+    protected:
+    using Codes = VertexError::Codes;
+    VertexDataVec _vertex_data;
+    std::shared_ptr<EBO> _ebo;
+    std::shared_ptr<VAO> _vao;
+    GLenum _primitive;
+
+    public:
+    GLenum primitive=GL_TRIANGLES;
+    VertexGroup(VertexGroup&&);
+    VertexGroup& operator=(VertexGroup&&);
+    
+    VertexGroup(
+        const VertexDataVec& vertex_data,
+        const std::shared_ptr<EBO>& ebo
+    )
+    : _vao(std::make_shared<VAO>()), _ebo(ebo) {
+        setBuffers(vertex_data);
+    }
+
+    template<typename... T>
+    VertexGroup(
+        const VertexDataVec& vertex_data,
+        T... args
+    )
+    : VertexGroup(vertex_data, std::make_shared<EBO>(args...)) {
+        setBuffers(vertex_data);
+    }
+    
+    template<typename... T>
+    VertexGroup(
+        const VertexData& vertex_data,
+        T... args
+    )
+    : VertexGroup(VertexDataVec{vertex_data}, args...) {}
+    
+    template<typename... T>
+    VertexGroup(
+        const ByteVector& vertex_data,
+        const VertexAttributeList& vertex_specification,
+        T... args
+    ) : VertexGroup({
+        std::make_shared<VBO>(vertex_data),
+        vertex_specification},
+        args...
+    ) {}
+
+    void bind() const {
+        _vao->bind();
+        _ebo->bind();
+    }
+    void unbind() const {
+        _vao->unbind();
+        _ebo->unbind();
+    }
+
+    void draw() const;
+
+    VertexDataVec getBuffers();
+    VertexData getBuffers(size_t);
+    size_t setBuffers(const VertexDataVec&);
+    size_t addBuffer(const VertexData&);
+    size_t addBuffer(const ByteVector& data, const VertexAttributeList& attrs);
+    VertexDataVec dropBuffers();
+    VertexData dropBuffer(size_t);
+
+    VertexAttributePointer attribute(size_t) const;
+    void enableAttr(GLuint);
+    void disableAttr(GLuint);
+    void enableBuffer(size_t);
+    void disableBuffer(size_t);
+    void enable();
+    void disable();
+
+    std::shared_ptr<EBO> indices() const;
+    std::shared_ptr<EBO> indices(const std::vector<unsigned int>& data);
+    std::shared_ptr<EBO> indices(std::shared_ptr<EBO> buffer);
+
+};
+
 } // namespace nb
 #endif // _NB_VERTEX_ARRAY

engine/NBGraphics/include/NBGraphics/VertexData.hpp

@@ -1,43 +0,0 @@
-#pragma once
-#ifndef _NB_VERTEX_DATA
-#define _NB_VERTEX_DATA
-
-#include <memory>
-#include <vector>
-
-#include <NBCore/TypeTraits.hpp>
-#include <NBCore/Utils.hpp>
-#include <NBGraphics/Buffers.hpp>
-#include <NBGraphics/GLLoad.hpp>
-
-// #include <NBGraphics/VertexArray.hpp>
-
-namespace nb {
-
-struct VertexAtrributeLayout {
-    unsigned int offset = 0;
-    int stride = 0;
-    unsigned int divisor = 0;
-};
-
-struct VertexAttribute {
-    unsigned int size;
-    TypeCodes type;
-    bool normalized;
-    VertexAtrributeLayout layout;
-};
-
-struct VertexData {
-    std::shared_ptr<Buffer> data;
-    std::vector<VertexAttribute> attributes;
-    VertexData(std::shared_ptr<Buffer>, const std::vector<VertexAttribute>&);
-    VertexData(const ByteVector&, const std::vector<VertexAttribute>&);
-};
-
-struct VertexDataPointer {
-    std::shared_ptr<VertexData> vertexdata;
-    unsigned int index;
-};
-
-} //  namespace nb
-#endif

engine/NBGraphics/include/NBGraphics/Window.hpp

@@ -6,11 +6,9 @@
 #include <NBGraphics/OGLObjects.hpp>
 
 #include <array>
-#include <functional>
+#include <map>
 #include <memory>
 #include <string>
-#include <type_traits>
-#include <utility>
 #include <vector>
 
 #include <NBCore/Errors.hpp>
@@ -33,86 +31,64 @@ class GLFWError : public Error<GLFWError> {
     static const ErrorCodeMap ErrorMessages;
 };
 
-class OGLWindow;
+class WindowError : public Error<WindowError> {
+    using Base = Error<WindowError>;
 
-enum WindowCallbacks {
+    public:
-    KEY, CHAR, CHAR_MODS, MOUSE_BUTTON, CURSOR_POS, CURSOR_ENTER,
+    using Base::Base;
-    SCROLL, DROP, WINDOW_POS, WINDOW_SIZE, WINDOW_CLOSE, WINDOW_REFRESH,
+
-    WINDOW_FOCUS, WINDOW_ICONIFY, WINDOW_MAX, FRAMEBUFFER_SIZE, WINDOW_SCALE,
+    enum Codes : unsigned int {
+        UNDEFINED, INITIALIZED_WINDOW, NO_GLFW, INIT_FAILED
     };
 
-template<WindowCallbacks>
+    static const std::string type;
-struct OGLWindowCallbacks;
+    static const ErrorCodeMap ErrorMessages;
+};
 
-template<>
+class Window {
-struct OGLWindowCallbacks<WindowCallbacks::KEY> {
+public:
-    using type = typename std::function<void(OGLWindow*, int, int, int, int)>;
+    static bool StrictInitialization;
-};
+    
-template<>
+    static int getGLFWHint(int);
-struct OGLWindowCallbacks<WindowCallbacks::CHAR> {
+    static int setGLFWHint(int, int);
-    using type = typename std::function<void(OGLWindow*, unsigned int)>;
+    static Window* getCurrent();
-};
+
-template<>
+    Window(const std::array<uint16_t, 2>, const char*, GLFWmonitor* initMonitor=NULL, GLFWwindow* initWindow=NULL);
-struct OGLWindowCallbacks<WindowCallbacks::CHAR_MODS> {
+    Window(const uint16_t, const uint16_t, const char*, GLFWmonitor* initMonitor=NULL, GLFWwindow* initWindow=NULL);
-    using type = typename std::function<void(OGLWindow*, unsigned int, int)>;
+    ~Window();
-};
+
-template<>
+    int getWindowHint(int) const;
-struct OGLWindowCallbacks<WindowCallbacks::CURSOR_ENTER> {
+    GLFWwindow* getWindow() const;
-    using type = typename std::function<void(OGLWindow*, int)>;
+    std::array<uint16_t, 2> getSize() const;
-};
+    float getAspectRatio() const;
-template<>
+    std::string getName() const;
-struct OGLWindowCallbacks<WindowCallbacks::CURSOR_POS> {
+    
-    using type = typename std::function<void(OGLWindow*, double, double)>;
+    int init();
-};
+    int setWindowHint(int, int);
-template<>
+    void setCurrent();
-struct OGLWindowCallbacks<WindowCallbacks::MOUSE_BUTTON> {
+    void resize(const std::array<uint16_t, 2>);
-    using type = typename std::function<void(OGLWindow*, int, int, int)>;
+    void resize(const uint16_t x, const uint16_t y);
-};
+
-template<>
+protected:
-struct OGLWindowCallbacks<WindowCallbacks::SCROLL> {
+    static std::map<GLFWwindow*, Window*> WindowContexts;
-    using type = typename std::function<void(OGLWindow*, double, double)>;
+    static std::map<int, int> GLFWHints;
-};
+    static Window* _current;
-template<>
+    static bool _glfw_init;
-struct OGLWindowCallbacks<WindowCallbacks::DROP> {
+    static bool checkKillGLFW();
-    using type = typename std::function<void(OGLWindow*, int, const char**)>;
+
-};
+    std::map<int, int> windowHints;
-template<>
+    std::array<uint16_t, 2> windowSize;
-struct OGLWindowCallbacks<WindowCallbacks::WINDOW_POS> {
+    float _aspect_ratio;
-    using type = typename std::function<void(OGLWindow*, int, int)>;
+    std::string windowName;
-};
+    GLFWwindow* window;
-template<>
+    GLFWmonitor* monitor;
-struct OGLWindowCallbacks<WindowCallbacks::WINDOW_SIZE> {
+    GLFWwindow* shareWindow;
-    using type = typename std::function<void(OGLWindow*, int, int)>;
+    bool _init = false;
-};
+    int gladResponse = -1;
-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 OGLObjectArena;
+
 class OGLWindow {
     using GLFWHint = std::array<int, 2>;
     private:
@@ -125,170 +101,54 @@ class OGLWindow {
     protected:
     static std::atomic<unsigned int> _count;
     static std::atomic<bool> _glfwInitialized;
-    static thread_local GLFWwindow* _currWindow;
+    static thread_local std::shared_ptr<OGLWindow> _currWindow;
-    static thread_local const GLFWwindow* _currArena;
+    static thread_local GLFWwindow* _currArena;
-    
-    template<typename T>
-    static void SetHint(std::pair<int, T> hint) {
-        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;
+    GLFWwindow* _arena;
+
+    static void SetHintInteger(const std::array<int, 2>&);
+    static void SetHintString(const std::tuple<int, std::string>&);
 
     OGLWindow(
-        unsigned int x,
+        unsigned int,
-        unsigned int y,
+        unsigned int,
         const std::string&,
-        GLFWwindow* sharingContext = NULL
+        const std::vector<std::array<int, 2>>&,
+        const std::vector<std::tuple<int, std::string>>&
     );
 
-    GLFWwindow* makeCurrent() const;
-    void detachWindow();
-
     public:
-
     static inline bool IsGLFWInitialized() { return _glfwInitialized; }
     static bool InitGLFW(const std::vector<GLFWHint>& hints={});
     static bool TerminateGLFW();
-    static inline GLFWwindow* GetCurrentWindow() { return _currWindow; }
+    static inline std::shared_ptr<OGLWindow> getCurrentWindow() { return _currWindow; }
-    static inline const GLFWwindow* GetCurrentObjectArena() { return _currArena; }
+    static inline const GLFWwindow* getCurrentObjectArena() { return _currArena; }
-    static GLFWwindow* MakeCurrent(const std::shared_ptr<OGLWindow>&);
+    static std::shared_ptr<OGLWindow> MakeCurrent(const std::shared_ptr<OGLWindow>&);
-    static inline GLFWwindow* DropCurrent() { return MakeCurrent(nullptr); }
+    static inline std::shared_ptr<OGLWindow> 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,
-        const std::pair<int, T>&... windowHints
-    ) {
-        (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();
     inline bool operator==(const OGLWindow& rhs) { return _window_ptr==rhs._window_ptr; }
 
+
     int getWindowAttribute(int) const;
     inline GLFWwindow* getWindowPtr() const { return _window_ptr; }
-    inline const GLFWwindow* getObjectArena() const { return _arena; }
     inline std::string getTitle() const { return _title; }
     std::array<int, 2> getSize() const;
-    bool shouldClose() const;
+    std::shared_ptr<OGLWindow> makeSharedContext();
-    inline void pollEvents() const { CheckForMainThread(); glfwPollEvents(); }
-    inline void swapBuffers() const { glfwSwapBuffers(_window_ptr); }
 
+    void makeCurrent() const;
     void setSize(unsigned int x, unsigned int y);
     void setTitle(const std::string&);
-    void shouldClose(bool);
-
-    template<WindowCallbacks CallbackType, typename CallbackFunc>
-    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/Buffers.cpp

@@ -12,21 +12,10 @@ const std::string BufferError::type = "nb::BufferError";
 const ErrorCodeMap BufferError::ErrorMessages = {
     { BufferErrorCodes::UNDEFINED, "Error" },
     { BufferErrorCodes::DATA_OVERFLOW, "Attempting buffer overflow" },
-    { BufferErrorCodes::DATA_ERROR, "Invalid memory operation" },
+    {BufferErrorCodes::DATA_ERROR, "Invalid memory operation"}
-    { BufferErrorCodes::BAD_DATA_TYPE, "Entered data type not allowed for buffer type"}
+
 };
 
-//  class Buffer
-
-Buffer::Buffer(GLenum target_) : OpenGLObject(), Target(target_) {
-    declare();
-} 
-
-Buffer::Buffer(GLenum target_, const ByteVector& data_, GLenum usage_) : Buffer(target_) {
-    bind();
-    data(data_, usage_);
-}
-
 Buffer::Buffer(Buffer&& rval) : Target(rval.Target) {
     *this = std::move(rval);
 }
@@ -100,6 +89,17 @@ GLuint UniformBuffer::bufferIndex(GLuint idx) {
 }
 
 // class ElementBuffer
+ElementBuffer::ElementBuffer() : Buffer(GL_ELEMENT_ARRAY_BUFFER) {}
+
+ByteVector ElementBuffer::data() const {
+    return data();
+}
+
+size_t ElementBuffer::size() const { return _size / _typeSize; }
+
+size_t ElementBuffer::typeSize() const { return _typeSize; }
+
+GLenum ElementBuffer::glslType() const { return _glslType; }
 
 template void ElementBuffer::data<uint8_t>(const std::vector<uint8_t>& data, GLenum usage);
 template void ElementBuffer::data<uint16_t>(const std::vector<uint16_t>& data, GLenum usage);
@@ -108,11 +108,11 @@ template void ElementBuffer::data<uint8_t>(const uint8_t* const data, size_t siz
 template void ElementBuffer::data<uint16_t>(const uint16_t* const data, size_t size, GLenum usage);
 template void ElementBuffer::data<uint32_t>(const uint32_t* const data, size_t size, GLenum usage);
 
-template void ElementBuffer::subdata<uint8_t>(const uint8_t* const data, size_t size, GLintptr offset=0);
+template void ElementBuffer::subdata<uint8_t>(const uint8_t* const data, size_t size, size_t offset=0);
-template void ElementBuffer::subdata<uint16_t>(const uint16_t* const data, size_t size, GLintptr offset=0);
+template void ElementBuffer::subdata<uint16_t>(const uint16_t* const data, size_t size, size_t offset=0);
-template void ElementBuffer::subdata<uint32_t>(const uint32_t* const data, size_t size, GLintptr offset=0);
+template void ElementBuffer::subdata<uint32_t>(const uint32_t* const data, size_t size, size_t offset=0);
-template void ElementBuffer::subdata<uint8_t>(const std::vector<uint8_t>& data, GLintptr offset=0);
+template void ElementBuffer::subdata<uint8_t>(const std::vector<uint8_t>& data, size_t offset=0);
-template void ElementBuffer::subdata<uint16_t>(const std::vector<uint16_t>& data, GLintptr offset=0);
+template void ElementBuffer::subdata<uint16_t>(const std::vector<uint16_t>& data, size_t offset=0);
-template void ElementBuffer::subdata<uint32_t>(const std::vector<uint32_t>& data, GLintptr offset=0);
+template void ElementBuffer::subdata<uint32_t>(const std::vector<uint32_t>& data, size_t offset=0);
 
 }

engine/NBGraphics/src/Draw.cpp

@@ -0,0 +1,307 @@
+#include <NBGraphics/Draw.hpp>
+
+namespace NB{
+
+DrawError::DrawError(
+    const std::string& msg,
+    const std::string& file,
+    int line) : std::runtime_error(NB::formatDebugString(msg, file, line)) {}
+
+uint8_t VerticesFromPrimitives(GLenum type, unsigned int num_prims) {
+    switch(type) {
+    case GL_POINTS:
+        return num_prims;
+    case GL_LINES:
+        return num_prims*2;
+        break;
+    case GL_LINE_STRIP:
+        return num_prims+1;
+        break;
+    case GL_LINE_LOOP:
+        return num_prims;
+        break;
+    case GL_TRIANGLES:
+        return num_prims*3;
+        break;
+    case GL_TRIANGLE_STRIP:
+    case GL_TRIANGLE_FAN:
+        return num_prims+2;
+        break;
+    case GL_QUADS:
+        return 4*num_prims;
+        break;
+    case GL_QUAD_STRIP:
+        return 2*num_prims+2;
+        break;
+    default:
+        return num_prims;
+        break;
+    }
+}
+
+uint8_t PrimitivesFromVertices(GLenum type, unsigned int num_verts) {
+    switch(type) {
+    case GL_POINTS:
+        return num_verts;
+    case GL_LINES:
+        return num_verts/2;
+        break;
+    case GL_LINE_STRIP:
+        return num_verts-1;
+        break;
+    case GL_LINE_LOOP:
+        return num_verts;
+        break;
+    case GL_TRIANGLES:
+        return num_verts/3;
+        break;
+    case GL_TRIANGLE_STRIP:
+    case GL_TRIANGLE_FAN:
+        return num_verts-2;
+        break;
+    case GL_QUADS:
+        return num_verts/4;
+        break;
+    case GL_QUAD_STRIP:
+        return num_verts/2 - 1;
+        break;
+    default:
+        return num_verts;
+        break;
+    }
+}
+
+
+// DrawBuffer class
+DrawBuffer::DrawBuffer(VertexAttributeList vas, GLenum prim_type)
+: _gl_primitive_type(prim_type), _VAO() {
+    _vert_data = std::make_shared<Buffer>(GL_ARRAY_BUFFER);
+    _elmt_data = std::make_shared<Buffer>(GL_ELEMENT_ARRAY_BUFFER);
+    _VAO.addVBO(_vert_data);
+    _VAO.changeEBO(_elmt_data);
+    try {
+        throw _VAO.checkValid(vas);
+    } catch (VAOError vaoe) {
+        if (vaoe.error) {
+            _VAO.addVertexAttributes(DrawBuffer::defaultVAO(vas));
+        } else {
+            _VAO.addVertexAttributes(vas);
+        }
+    }
+}
+
+VertexAttributeList DrawBuffer::defaultVAO(VertexAttributeList vert_attrs) {
+    GLuint vert_id = _vert_data->id();
+    unsigned int vert_size = 0;
+    for (const VertexAttribute& va : vert_attrs) {
+        vert_size += va.GLSLSize * GLSLTypeSize(va.GLSLType);
+    }
+    unsigned int curr_byte = 0;
+    for (VertexAttribute& va : vert_attrs) {
+        va.ptr.buffer = vert_id;
+        va.ptr.stride = vert_size;
+        va.ptr.offset = curr_byte;
+        va.ptr.divisor = 0;
+        curr_byte += va.GLSLSize * GLSLTypeSize(va.GLSLType);
+    }
+    return vert_attrs;
+}
+
+VertexAttributeList DrawBuffer::changeVertLayout(unsigned int i, VertexAttributePointer vap) {
+    GLuint vert_id = _vert_data->id();
+    vap.buffer = (vap.buffer) ? vap.buffer : vert_id;
+    VertexAttributeList vas = _VAO.getLayout();
+    unsigned int idx = 0;
+    for (const VertexAttribute& va : vas) {
+        if (va.ptr.buffer == vert_id) {
+            if (idx == i) {
+                return _VAO.changeLayout(i, vap);
+            }
+            idx++;
+        }
+    }
+    THROW_DRAW_ERROR("Could not find vertex attribute with index " + std::to_string(i));
+}
+
+unsigned int DrawBuffer::vertSize() const { return _VAO.vertSize(_vert_data->id()); }
+
+void DrawBuffer::draw() const {
+    _VAO.bind();
+    glDrawElements(_gl_primitive_type, _elmt_data->size() / GLSLTypeSize(GL_INT), GL_UNSIGNED_INT, 0);
+    _VAO.unbind();
+}
+
+unsigned int DrawBuffer::elementBufferID() const { return _elmt_data->id(); }
+
+unsigned int DrawBuffer::vertexBufferID() const { return _vert_data->id(); }
+
+RawVec DrawBuffer::vertAttrData(unsigned int i) {
+    if (!_vert_data->isInitialized()) {
+        throw DrawError("Vertex buffer is not initialized.");
+    }
+    return _VAO.attributeData(i);
+}
+
+RawVec DrawBuffer::vertAttrData(unsigned int i, const RawVec& newdata) {
+    if (!(_vert_data->isInitialized())) {
+        VertexAttribute va = _VAO.getLayout()[i];
+        vertexData(newdata.size() / (va.GLSLSize*GLSLTypeSize(va.GLSLType)));
+        std::cout << "From DrawBuffer::vertAttrData(int, RawVec) - vert buf size: " << _vert_data->size() << "\n";
+    }
+    return _VAO.attributeData(i, newdata);
+}
+
+void DrawBuffer::elementData(unsigned int num_prims) {
+    elementData(std::vector<unsigned int>(VerticesFromPrimitives(_gl_primitive_type, num_prims)));
+}
+
+void DrawBuffer::elementData(const std::vector<unsigned int>& elements) {
+    _num_prims = PrimitivesFromVertices(_gl_primitive_type, elements.size());
+    _elmt_data->data(vectorToRaw(elements));
+}
+
+void DrawBuffer::elementData(const std::vector<unsigned int>& elements, unsigned int offset) {
+    _VAO.bind();
+    if (!_elmt_data->isInitialized()) {
+        std::vector<unsigned int> init_elmts(elements);
+        init_elmts.insert(init_elmts.cbegin(), offset, 0);
+        elementData(init_elmts, 0);
+    } else {
+        _elmt_data->data(vectorToRaw(elements), offset);
+    }
+    _VAO.unbind();
+}
+
+void DrawBuffer::vertexData(unsigned int num_verts) {
+    vertexData(RawVec(num_verts * vertSize()));
+}
+
+void DrawBuffer::vertexData(const RawVec& vert_data) {
+    // Check for uninitialized Vertex Pointers. If so, will fallback to default VAO setup.
+    // Otherwise, set VAO to provided Vertex Atributes.
+    int vert_size = vertSize();
+    if (vert_data.size() % vert_size != 0) {
+        THROW_DRAW_ERROR("Initializing data does not match vertex size of " + std::to_string(vert_size) + ".");
+    }
+    _num_verts = vert_data.size() / vert_size;
+    // TODO: Make it not static draw all the time
+
+    _VAO.bind();
+    _vert_data->data(vert_data);
+    _VAO.unbind();
+}
+
+void DrawBuffer::vertexData(const RawVec& data, unsigned int offset) {
+    _VAO.bind();
+    if (!_vert_data->isInitialized()) {
+        RawVec load_data(offset);
+        load_data.insert(load_data.end(), data.begin(), data.end());
+        vertexData(load_data, 0);
+    } else {
+        try{
+            _vert_data->data(data, offset);
+        } catch(BufferError& e) {
+            THROW_DRAW_ERROR("NB::BufferError in loadVBO:\n\t" + std::string(e.what()));
+        }
+    }
+    _VAO.unbind();
+}
+
+// DrawInstanceBufferClass
+DrawInstanceBuffer::DrawInstanceBuffer(
+    VertexAttributeList vert_vas,
+    VertexAttributeList inst_vas,
+    GLenum prim_type
+): DrawBuffer(vert_vas, prim_type) {
+    _inst_data = std::make_shared<Buffer>(GL_ARRAY_BUFFER);
+    _VAO.addVBO(_inst_data);
+    try {
+        throw _VAO.checkValid(inst_vas);
+    } catch (VAOError vaoe) {
+        if (vaoe.error) {
+            _VAO.addVertexAttributes(defaultVAO(inst_vas));
+        } else {
+            _VAO.addVertexAttributes(inst_vas);
+        }
+    }
+}
+
+unsigned int DrawInstanceBuffer::instSize() const { return _VAO.vertSize(_inst_data->id()); }
+
+unsigned int DrawInstanceBuffer::instanceBufferID() const { return _inst_data->id(); }
+
+void DrawInstanceBuffer::instanceData(unsigned int num_inst) {
+    instanceData(RawVec(instSize() * num_inst));
+}
+
+void DrawInstanceBuffer::instanceData(const RawVec& inst_data) {
+    int inst_size = instSize();
+    if (inst_data.size() % inst_size != 0) {
+        THROW_DRAW_ERROR("Initializing data does not match instance size of " + std::to_string(inst_size) + ".");
+    }
+    _num_inst = inst_data.size() / inst_size;
+    
+    _VAO.bind();
+    _inst_data->data(inst_data);
+    _VAO.unbind();
+}
+
+void DrawInstanceBuffer::instanceData(const RawVec& data, unsigned int offset) {
+    _VAO.bind();
+    if (!_inst_data->isInitialized()) {
+        RawVec load_data(offset);
+        load_data.insert(load_data.end(), data.begin(), data.end());
+        instanceData(load_data, 0);
+    } else {
+        try{
+            _inst_data->data(data, offset);
+        } catch(BufferError& e) {
+            THROW_DRAW_ERROR("NB::BufferError in loadIBO:\n\t" + std::string(e.what()));
+        }
+    }
+    _VAO.unbind();
+}
+
+VertexAttributeList DrawInstanceBuffer::defaultVAO(VertexAttributeList inst_attrs) {
+    GLuint inst_id = _inst_data->id();
+    unsigned int vert_size = 0;
+    for (const VertexAttribute& va : inst_attrs) {
+        vert_size += va.GLSLSize * GLSLTypeSize(va.GLSLType);
+    }
+    unsigned int curr_byte = 0;
+    for (VertexAttribute& va : inst_attrs) {
+        va.ptr.buffer = inst_id;
+        va.ptr.stride = vert_size;
+        va.ptr.offset = curr_byte;
+        va.ptr.divisor = 1;
+        curr_byte += va.GLSLSize * GLSLTypeSize(va.GLSLType);
+    }
+    return inst_attrs;
+}
+
+VertexAttributeList DrawInstanceBuffer::changeInstanceLayout(unsigned int i, VertexAttributePointer vap) {
+    GLuint inst_id = _inst_data->id();
+    vap.buffer = (vap.buffer) ? vap.buffer : inst_id;
+    VertexAttributeList vas = _VAO.getLayout();
+    unsigned int vas_size = vas.size();
+    unsigned int inst_idx = 0;
+    unsigned int idx = 0;
+    for (const VertexAttribute& va : vas) {
+        if (va.ptr.buffer == inst_id) {
+            if (inst_idx == i) {
+                return _VAO.changeLayout(idx, vap);
+            }
+            inst_idx++;
+        }
+        idx++;
+    }
+    THROW_DRAW_ERROR("Could not find instance attribute with index " + std::to_string(i));
+}
+
+void DrawInstanceBuffer::draw() const {
+    _VAO.bind();
+    glDrawElementsInstanced(_gl_primitive_type, _elmt_data->size() / GLSLTypeSize(GL_UNSIGNED_INT), GL_UNSIGNED_INT, (void*)_elmt_data->id(), _num_inst);
+    _VAO.unbind();
+}
+
+}

engine/NBGraphics/src/Mesh.cpp

@@ -1,73 +0,0 @@
-#pragma clang diagnostic ignored "-Wint-to-pointer-cast"
-#pragma GCC diagnostic ignored "-Wint-to-pointer-cast"
-
-#include <NBGraphics/Mesh.hpp>
-
-namespace nb{
-
-// class Mesh
-Mesh::Mesh(
-    VertexDataPointerList vertexdata_,
-    unsigned int count_,
-    GLenum primitive_
-) : 
-    _primitive(primitive_),
-    _count(count_),
-    _vao(std::make_shared<VAO>(vertexdata_))
-{}
-
-Mesh::Mesh(
-    GLenum primitive_,
-    const std::shared_ptr<VAO>& vao_,
-    unsigned int count_
-) :
-    _primitive(primitive_),
-    _count(count_),
-    _vao(vao_)
-{}
-
-Mesh::Mesh(
-    GLenum primitive_,
-    const VertexData& vertex_data_,
-    unsigned int count_
-) : Mesh(primitive_, std::make_shared<VAO>(), count_) {
-    _vao->attributes({vertex_data_});
-}
-
-Mesh::Mesh(
-    GLenum primitive_,
-    const ByteVector& data_,
-    unsigned int count_,
-    const std::vector<VertexAttribute>& attributes_
-) : Mesh(
-    primitive_,
-    VertexData(data_, attributes_),  
-    count_
-) {}
-
-void Mesh::draw(unsigned int offset, unsigned int count) const {
-    _vao->bind();
-    OPENGL_CALL(
-        glDrawArrays(_primitive, offset, count);
-    );
-}
-
-// class InstancedMesh
-
-void InstancedMesh::draw(unsigned int offset, unsigned instancecount) const {
-    _vao->bind();
-    OPENGL_CALL(
-        glDrawArraysInstanced(_primitive, 0, _count, instancecount);
-    );
-}
-
-// class IndexMeshes
-
-void IndexedMesh::draw(unsigned int offset, unsigned numindices) const {
-    _vao->bind();
-    OPENGL_CALL(
-        glDrawElements(Mesh::_primitive, _count, _ebo->datatype(), (void*)offset)
-    );
-} 
-
-} // namespace nb

engine/NBGraphics/src/OGLObjects.cpp

@@ -36,22 +36,11 @@ OpenGLError OpenGLError::status(const std::string& note) {
     return OpenGLError(glGetError(), note);
 }
 
-const ConstantMap<TypeCodes, int> TypeToGLSL = {
-    {TypeCodes::FLOAT16, GL_HALF_FLOAT},
-    {TypeCodes::FLOAT32, GL_FLOAT},
-    {TypeCodes::DOUBLE64, GL_DOUBLE},
-    {TypeCodes::INT8, GL_BYTE},
-    {TypeCodes::INT16, GL_SHORT},
-    {TypeCodes::INT32, GL_INT},
-    {TypeCodes::UINT8, GL_UNSIGNED_BYTE},
-    {TypeCodes::UINT16, GL_UNSIGNED_SHORT},
-    {TypeCodes::UINT32, GL_UNSIGNED_INT},
-};
 
 // class OpenGLObject
 
 void OpenGLObject::checkObjectContextValidity() {
-    if (_arena != OGLWindow::GetCurrentObjectArena()) {
+    if (_arena != OGLWindow::getCurrentObjectArena()) {
         THROW(OpenGLObjectError(OpenGLObjectError::INVALID_CONTEXT));
     }
 }
@@ -61,7 +50,7 @@ OpenGLObject::OpenGLObject(OpenGLObject&& rval) : _arena(rval._arena) {
     *this = std::move(rval);
 }
 
-OpenGLObject::OpenGLObject() : _arena(OGLWindow::GetCurrentObjectArena()) {}
+OpenGLObject::OpenGLObject() : _arena(OGLWindow::getCurrentObjectArena()) {}
 
 OpenGLObject& OpenGLObject::operator=(OpenGLObject&& rhs) {
     rhs.checkObjectContextValidity();
@@ -90,10 +79,6 @@ const GLEnumTableType GLenumTable = {
     GLENUMSTRPAIR(GL_RGB8UI),
     GLENUMSTRPAIR(GL_RGBA8UI),
     GLENUMSTRPAIR(GL_RGBA),
-    GLENUMSTRPAIR(GL_ELEMENT_ARRAY_BUFFER),
-    GLENUMSTRPAIR(GL_UNSIGNED_INT),
-    GLENUMSTRPAIR(GL_UNSIGNED_SHORT),
-    GLENUMSTRPAIR(GL_UNSIGNED_BYTE),
 };
 
 } // namespace nb

engine/NBGraphics/src/VertexArray.cpp

@@ -1,6 +1,3 @@
-#pragma clang diagnostic ignored "-Wint-to-pointer-cast"
-#pragma GCC diagnostic ignored "-Wint-to-pointer-cast"
-
 #include <NBGraphics/VertexArray.hpp>
 
 namespace nb {
@@ -19,7 +16,7 @@ const ErrorCodeMap VertexError::ErrorMessages = {
     { VertexError::MISALIGNED_DATA, "Data does not match vertex layout"}
 };
 
-VAO::VAO(const VertexDataPointerList& attr_ptrs) {
+VAO::VAO(const VertexAttributePointerList& attr_ptrs) {
     attributes(attr_ptrs);
 }
 
@@ -29,58 +26,41 @@ VAO::VAO(VAO&& other) {
 
 VAO& VAO::operator=(VAO&& rhs) {
     OpenGLObject::operator=(std::move(rhs));
-    _vertexdata = rhs._vertexdata;
+    _attrs = rhs._attrs;
-    rhs._vertexdata = {};
+    rhs._attrs = {};
     return *this;
 }
 
-VertexDataPointerList VAO::attributes() const {
+VertexAttributePointerList VAO::attributes() const {
-    return _vertexdata;
+    return _attrs;
 }
 
-VertexDataPointerList VAO::attributes(const VertexDataPointerList& vertdatalist) {
+VertexAttributePointerList VAO::attributes(const VertexAttributePointerList& attrs_) {
     declare();
     disable();
-    _vertexdata = vertdatalist;
+    _attrs = attrs_;
     bind();
-    for (const auto vdata : _vertexdata) {
+    for (auto attr_ptr : attrs_) {
-        OPENGL_CALL(glBindBuffer(GL_ARRAY_BUFFER, vdata.vertexdata->data->id()));
+        OPENGL_CALL(glBindBuffer(GL_ARRAY_BUFFER, attr_ptr.buffer));
-        for (const auto attr : vdata.vertexdata->attributes) {
+        GLuint idx = attr_ptr.index; 
-            GLuint idx = vdata.index; 
         OPENGL_CALL(glVertexAttribPointer(
             idx,
-                attr.size,
+            attr_ptr.attribute.GLSLSize,
-                TypeToGLSL[attr.type],
+            attr_ptr.attribute.GLSLType,
-                attr.normalized,
+            attr_ptr.attribute.GLSLNormalization,
-                attr.layout.stride,
+            attr_ptr.attribute.layout.stride,
-                (const void*) attr.layout.offset
+            (void*)attr_ptr.attribute.layout.offset
         ));
         OPENGL_CALL(glEnableVertexAttribArray(idx));
-            if (attr.layout.divisor) {
-                OPENGL_CALL(glVertexAttribDivisor(idx, attr.layout.divisor));
-            }
-        }
     }
     unbind();
-    enable();
+    return _attrs;
-    return _vertexdata;
 }
 
-VertexDataPointerList VAO::attributes(const VertexDataList& vertdatalist) {
+VertexAttributePointer VAO::attr(GLuint idx) const {
-    VertexDataPointerList vdatas;
+    for (auto attr_ptr : _attrs) {
-    for (unsigned int i = 0; i < vertdatalist.size(); ++i) {
+        if (idx == attr_ptr.index) {
-        vdatas.emplace_back(VertexDataPointer{
+            return attr_ptr;
-            std::make_shared<VertexData>(vertdatalist[i]),
-            i
-        });
-    }
-    return attributes(vdatas);
-}
-
-VertexDataPointer VAO::attribute(GLuint idx) const {
-    for (auto vdata : _vertexdata) {
-        if (idx == vdata.index) {
-            return vdata;
         }
     }
     THROW(VAOError(Codes::INVALID_ATTRIBUTE));
@@ -89,8 +69,8 @@ VertexDataPointer VAO::attribute(GLuint idx) const {
 void VAO::enable() const {
     if (_id) {
         bind();
-        for(auto vdata : _vertexdata) {
+        for(auto attr_ptr : _attrs) {
-            OPENGL_CALL(glEnableVertexAttribArray(vdata.index));
+            OPENGL_CALL(glEnableVertexAttribArray(attr_ptr.index));
         }
         unbind();
     }
@@ -99,7 +79,7 @@ void VAO::enable() const {
 void VAO::enable(GLuint idx) const {
     if(_id) {
         bind();
-        OPENGL_CALL(glEnableVertexAttribArray(attribute(idx).index)); 
+        OPENGL_CALL(glEnableVertexAttribArray(attr(idx).index)); 
         unbind();
     }
 }
@@ -107,8 +87,8 @@ void VAO::enable(GLuint idx) const {
 void VAO::disable() const {
     if(_id) {
         bind();
-        for(auto vdata : _vertexdata) {
+        for(auto attr_ptr : _attrs) {
-            OPENGL_CALL(glDisableVertexAttribArray(vdata.index)); 
+            OPENGL_CALL(glDisableVertexAttribArray(attr_ptr.index)); 
         }
         unbind();
     }
@@ -117,10 +97,157 @@ void VAO::disable() const {
 void VAO::disable(GLuint idx) const {
     if(_id) {
         bind();
-        OPENGL_CALL(glDisableVertexAttribArray(attribute(idx).index)); 
+        OPENGL_CALL(glDisableVertexAttribArray(attr(idx).index)); 
         unbind();
     }
 }
 
+VertexGroup::VertexGroup(VertexGroup&& other) {
+    *this = std::move(other);
+}
+
+VertexGroup& VertexGroup::operator=(VertexGroup&& rhs) {
+    _vertex_data = rhs._vertex_data;
+    _ebo = rhs._ebo;
+    _vao = rhs._vao;
+
+    rhs._vertex_data = {};
+    rhs._ebo = nullptr;
+    rhs._vao = nullptr;
+
+    return *this;
+}
+
+void VertexGroup::draw() const {
+    bind();
+    OPENGL_CALL(
+        glDrawElements(primitive, _ebo->size(), _ebo->glslType(), 0)
+    );
+}
+
+size_t VertexGroup::addBuffer(const VertexData& vertex_data_) {
+    VertexData data = vertex_data_;
+    _vertex_data.emplace_back(data);
+    VertexAttributePointerList attrs = _vao->attributes();
+    GLuint idx = attrs.size();
+    for (const auto& attr : data.attrs) {
+        attrs.emplace_back(
+            VertexAttributePointer{attr, data.vbo->id(),idx}
+        );
+        idx++;
+    }
+    _vao->attributes(attrs);
+    return _vertex_data.size();
+}
+
+size_t VertexGroup::addBuffer(const ByteVector& data_, const VertexAttributeList& attrs_) {
+    return addBuffer({
+        std::make_shared<VBO>(data_),
+        attrs_
+    });
+}
+
+VertexData VertexGroup::getBuffers(size_t idx) {
+    return _vertex_data[idx];
+}
+
+ VertexDataVec VertexGroup::getBuffers() {
+    return _vertex_data;
+}
+
+size_t VertexGroup::setBuffers(const VertexDataVec& vertex_data_) {
+    _vertex_data = vertex_data_;
+    VertexAttributePointerList attr_ptrs;
+    GLuint idx = 0;
+    for (const auto& data : _vertex_data) {
+        for (const auto& attr : data.attrs) {
+            attr_ptrs.emplace_back(
+                VertexAttributePointer{attr, data.vbo->id(), idx}
+            );
+            idx++;
+        }
+    }
+    _vao->attributes(attr_ptrs);
+    return _vertex_data.size();
+}
+
+VertexDataVec VertexGroup::dropBuffers() {
+    auto ret = _vertex_data;
+    setBuffers({});
+    return ret;
+}
+
+VertexData VertexGroup::dropBuffer(size_t idx) {
+    if (idx >= _vertex_data.size()) {
+        THROW(Error(Error<>::OUT_OF_RANGE));
+    }
+    VertexDataVec tmp;
+    VertexData ret;
+    size_t i = 0;
+    for (auto buf : _vertex_data) {
+        if (i == idx) {
+            ret = tmp[idx];
+        } else {
+            tmp.emplace_back(buf);
+        }
+        i++;
+    }
+    setBuffers(tmp);
+    return ret;
+}
+
+VertexAttributePointer VertexGroup::attribute(size_t idx_) const {
+    return _vao->attr(idx_);
+}
+
+void VertexGroup::enableAttr(GLuint idx) {
+    bind();
+    _vao->enable(idx);
+    unbind();
+}
+
+void VertexGroup::disableAttr(GLuint idx) {
+    bind();
+    _vao->disable(idx);
+    unbind();
+}
+
+void VertexGroup::disableBuffer(size_t idx) {
+    auto buf_idx = _vertex_data[idx].vbo->id();
+    bind();
+    for (auto attr : _vao->attributes()) {
+        if (attr.buffer == buf_idx) {
+            _vao->disable(attr.index);
+        }
+    }
+    unbind();
+}
+
+void VertexGroup::enableBuffer(size_t idx) {
+    auto buf_idx = _vertex_data[idx].vbo->id();
+    bind();
+    for (auto attr : _vao->attributes()) {
+        if (attr.buffer == buf_idx) {
+            _vao->enable(attr.index);
+        }
+    }
+    unbind();
+}
+
+void VertexGroup::enable() { _vao->enable(); }
+
+void VertexGroup::disable() { _vao->disable(); }
+
+std::shared_ptr<EBO> VertexGroup::indices() const { return _ebo; } 
+
+std::shared_ptr<EBO> VertexGroup::indices(const std::vector<uint32_t>& data) {
+    _ebo->data(data);
+    return _ebo;
+}
+
+std::shared_ptr<EBO> VertexGroup::indices(std::shared_ptr<EBO> buffer) {
+    _ebo = buffer;
+    return _ebo;
+}
 
 } // namespace nb

engine/NBGraphics/src/VertexData.cpp

@@ -1,16 +0,0 @@
-#include <NBGraphics/VertexData.hpp>
-
-namespace nb {
-
-VertexData::VertexData(
-    std::shared_ptr<Buffer> data_,
-    const std::vector<VertexAttribute>& attrs_
-) : data(data_), attributes(attrs_) {}
-
-VertexData::VertexData(
-    const ByteVector& data_,
-    const std::vector<VertexAttribute>& attrs_
-) : data(std::make_shared<Buffer>(GL_ARRAY_BUFFER, data_)), 
-    attributes(attrs_) {}
-
-} // namespace nb

engine/NBGraphics/src/Window.cpp

@@ -2,6 +2,20 @@
 
 namespace nb {
 
+std::map<GLFWwindow*, Window*> Window::WindowContexts = {};
+std::map<int, int> Window::GLFWHints = {};
+bool Window::StrictInitialization = true;
+bool Window::_glfw_init = false;
+Window* Window::_current = nullptr;
+static std::map<int, int> defailt_window_hints = {
+    {GLFW_CONTEXT_VERSION_MAJOR, 3},
+    {GLFW_CONTEXT_VERSION_MINOR, 1},
+    {GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE}
+#ifdef _NB_GL_DEBUG_ON
+,   {GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE}
+#endif
+};
+
 using GLFWCodes = GLFWError::Codes;
 const std::string GLFWError::type = "nb::GLFWError";
 const ErrorCodeMap GLFWError::ErrorMessages = {
@@ -13,11 +27,172 @@ const ErrorCodeMap GLFWError::ErrorMessages = {
     {GLFWCodes::WINDOW_FAILED, "Failed to initialize window"}
 };
 
+using WindowErrorCodes = WindowError::Codes;
+const std::string WindowError::type = "nb::WindowError";
+const ErrorCodeMap WindowError::ErrorMessages = {
+    {WindowErrorCodes::UNDEFINED, "Error"},
+    {WindowErrorCodes::INITIALIZED_WINDOW, "Window already initialized"},
+    {WindowErrorCodes::NO_GLFW, "GLFW has not been initialized"},
+    {WindowErrorCodes::INIT_FAILED, "Could not intialized window"}
+};
+
+
+// class Window
+
+int Window::getGLFWHint(int hint_key) {
+    if (GLFWHints.find(hint_key) == GLFWHints.end()) {
+        return 0;
+    } else {
+        return GLFWHints.at(hint_key);
+    }
+}
+
+int Window::setGLFWHint(int hint_key, int hint_val) {
+    if (Window::_glfw_init) {
+        THROW(GLFWError(GLFWCodes::GLFW_INTIALIZED));
+    } else {
+        GLFWHints[hint_key] = hint_val;
+    }
+    return GLFWHints[hint_key];
+}
+
+Window* Window::getCurrent() {
+    return _current;
+}
+
+bool Window::checkKillGLFW() {
+    if(Window::WindowContexts.size() == 0 && _glfw_init) {
+        glfwTerminate();
+        Window::_glfw_init = false;
+        return true;
+    }
+    return false;
+}
+
+Window::Window(const uint16_t x, const uint16_t y, const char* initName, GLFWmonitor* initMonitor, GLFWwindow* initWindow) {
+    if (!Window::_glfw_init) {
+        for (const auto& hint : Window::GLFWHints) {
+            glfwInitHint(hint.first, hint.second);
+        }
+        int glfwResponse = glfwInit();
+        if (glfwResponse) {
+            Window::_glfw_init = true;
+        } else {            
+            if (Window::StrictInitialization) {
+                THROW(GLFWError(GLFWCodes::INIT_FAILED));
+            }
+        }
+    }
+
+    windowSize = {x, y};
+    _aspect_ratio = float(x)/float(y);
+    windowName = std::string(initName);
+    monitor = initMonitor;
+    shareWindow = initWindow;
+
+    for (const auto& hint: defailt_window_hints) {
+        windowHints[hint.first] = hint.second;
+    }
+}
+
+Window::Window(const std::array<uint16_t, 2> initSize, const char* initName, GLFWmonitor* initMonitor, GLFWwindow* initWindow) :
+    Window(initSize[0], initSize[1], initName, initMonitor, initWindow){}
+
+Window::~Window() {
+    glfwSetWindowShouldClose(window, true);
+    glfwDestroyWindow(window);
+    Window::WindowContexts.erase(window);
+    if (Window::WindowContexts.size()==0) {
+        glfwTerminate();
+    }
+}
+
+void Window::setCurrent() {
+    _current = this;
+    glfwMakeContextCurrent(window);
+}
+
+int Window::getWindowHint(int hint_key) const {
+    if (windowHints.find(hint_key) == windowHints.end()) {
+        return 0;
+    } else {
+        return windowHints.at(hint_key);
+    }
+}
+
+int Window::setWindowHint(int hint_key, int hint_val) {
+    if (_init) {
+        THROW(WindowError(WindowErrorCodes::INITIALIZED_WINDOW));
+    } else {
+        windowHints[hint_key] = hint_val;
+    }
+    return windowHints[hint_key];
+} 
+
+int Window::init() {
+    if (!_glfw_init) {
+        THROW(WindowError(WindowErrorCodes::NO_GLFW));
+    }
+    for (const auto& hint : windowHints) {
+        glfwWindowHint(hint.first, hint.second);
+    }
+
+    window = glfwCreateWindow(windowSize[0], windowSize[1], windowName.c_str(), monitor, shareWindow);
+    if (window == NULL) {
+        Window::WindowContexts.erase(window);
+        if (Window::WindowContexts.size()==0 && Window::_glfw_init) { glfwTerminate(); }
+        if (Window::StrictInitialization) {
+            THROW(WindowError(WindowErrorCodes::INIT_FAILED));
+        }
+    }
+    glfwMakeContextCurrent(window);
+    Window::WindowContexts[window] = this;
+
+    gladResponse = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
+    if (!gladResponse) {
+        Window::checkKillGLFW();
+        if (Window::StrictInitialization) {
+            THROW(GLFWError(GLFWCodes::GLAD_FAILED));
+        }
+    }
+
+    _init = true;
+    OPENGL_CALL(
+        glViewport(0, 0, windowSize[0], windowSize[1])
+    );
+    return gladResponse;
+}
+
+GLFWwindow* Window::getWindow() const {
+    return window;
+}
+
+float Window::getAspectRatio() const { return _aspect_ratio; }
+
+std::array<uint16_t, 2> Window::getSize() const {
+    return windowSize;
+}
+
+std::string Window::getName() const {
+    return windowName;
+}
+
+void Window::resize(const std::array<uint16_t, 2> newSize) {
+    windowSize = newSize;
+    _aspect_ratio = float(newSize[0]) / float(newSize[1]);
+    OPENGL_CALL(
+        glViewport(0, 0, windowSize[0], windowSize[1])
+    );
+    glfwSetWindowSize(window, windowSize[0], windowSize[1]);
+}
+
+void Window::resize(const uint16_t x, const uint16_t y) { resize({x, y}); }
+
 // class OGLWindow
 
 std::atomic<bool> OGLWindow::_glfwInitialized = false;
-thread_local GLFWwindow* OGLWindow::_currWindow = nullptr;
+thread_local std::shared_ptr<OGLWindow> OGLWindow::_currWindow = nullptr;
-thread_local const GLFWwindow* OGLWindow::_currArena = nullptr;
+thread_local GLFWwindow* OGLWindow::_currArena = nullptr;
 std::atomic<unsigned int> OGLWindow::_count = 0;
 
 bool OGLWindow::InitGLFW(const std::vector<GLFWHint>& hints) {
@@ -48,50 +223,81 @@ bool OGLWindow::TerminateGLFW() {
     return !IsGLFWInitialized();
 }
 
-GLFWwindow* OGLWindow::MakeCurrent(const std::shared_ptr<OGLWindow>& window) {
+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());
+}
+
+std::shared_ptr<OGLWindow> OGLWindow::MakeCurrent(const std::shared_ptr<OGLWindow>& window) {
     auto tmp = _currWindow;
+    _currWindow = window;
     if (window) {
-        _currWindow = window->getWindowPtr();
+        glfwMakeContextCurrent(_currWindow->_window_ptr);
         _currArena = window->_arena;
     } else {
-        _currWindow = nullptr;
+        glfwMakeContextCurrent(nullptr);
         _currArena = nullptr;
     }
-    glfwMakeContextCurrent(_currWindow);
     return tmp;
 }
 
 OGLWindow::OGLWindow(
     unsigned int x,
     unsigned int y,
-    const std::string&,
+    const std::string& title,
-    GLFWwindow* sharingContext
+    const std::vector<std::array<int, 2>>& integerHints,
-) {
+    const std::vector<std::tuple<int, std::string>>& stringHints
+) : _title(title) {
     CheckForMainThread();
     InitGLFW();
+    for (const auto& hint : integerHints) {
+        SetHintInteger(hint);
+    }
+    for (const auto& hint : stringHints) {
+        SetHintString(hint);
+    }
     _window_ptr = glfwCreateWindow(
         x,
         y,
         _title.c_str(), 
         NULL,
-        sharingContext
+        NULL
     );
     if (_window_ptr == NULL) {
         THROW(GLFWError(GLFWError::Codes::WINDOW_FAILED));
     }
     _arena = _window_ptr;
-    auto tmp = makeCurrent();
     if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
         THROW(GLFWError(GLFWError::Codes::GLAD_FAILED));
     }
-    glfwMakeContextCurrent(tmp);
     OGLWindow::_count.fetch_add(1);
 }
 
+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
+    ) );
+}
+
 OGLWindow::~OGLWindow() {
     CheckForMainThread();
     if (_window_ptr) {
-        if (_window_ptr == _currWindow) {
+        if (_window_ptr == _currWindow->_window_ptr) {
             _currWindow = nullptr;
             _currArena = nullptr;
         }
@@ -103,12 +309,6 @@ OGLWindow::~OGLWindow() {
     }
 }
 
-void OGLWindow::detachWindow() {
-    _title = "";
-    _window_ptr = nullptr;
-    _arena = nullptr;
-}
-
 int OGLWindow::getWindowAttribute(int attr) const {
     CheckForMainThread();
     return glfwGetWindowAttrib(_window_ptr, attr);
@@ -121,22 +321,6 @@ std::array<int, 2> OGLWindow::getSize() const {
     return {x, y};
 }
 
-bool OGLWindow::shouldClose() const {
-    CheckForMainThread();
-    return glfwWindowShouldClose(_window_ptr);
-}
-
-void OGLWindow::shouldClose(bool val) {
-    CheckForMainThread();
-    glfwSetWindowShouldClose(_window_ptr, val);
-}
-
-GLFWwindow* OGLWindow::makeCurrent() const {
-    auto tmp = glfwGetCurrentContext();
-    glfwMakeContextCurrent(_window_ptr);
-    return tmp;
-}
-
 void OGLWindow::setSize(unsigned int x, unsigned int y) {
     CheckForMainThread();
     glfwSetWindowSize(_window_ptr, x, y);

engine/NBGraphics/tests/TestWindow.cpp

@@ -3,11 +3,9 @@
 #include "stb_image.h"
 
 #include <NBCore/Errors.hpp>
-#include <NBCore/TypeTraits.hpp>
 #include <NBGraphics/Image.hpp>
-#include <NBGraphics/Mesh.hpp>
 #include <NBGraphics/ProgramPipeline.hpp>
-#include <NBGraphics/VertexData.hpp>
+#include <NBGraphics/VertexArray.hpp>
 #include <NBGraphics/Window.hpp>
 #include <NBGraphics/Textures.hpp>
 
@@ -18,10 +16,9 @@ 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);
 
     auto vert = std::make_shared<nb::Shader>(
         GL_VERTEX_SHADER,
@@ -62,33 +59,23 @@ int main() {
 
     std::vector<uint32_t> indxs = {0, 1, 2};
 
-    nb::IndexedMesh tri(GL_TRIANGLES, data, {nb::VertexAttribute{
+    nb::VertexGroup tri(data, {
+        nb::VertexAttribute{
             2,
-            nb::TypeCodes::FLOAT32,
+            GL_FLOAT,
             false,
             {0, 8}
-        }}, indxs);
+        },
+    }, 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;