Heavy buffer update, window update, object tracking

Nuked old window class outta orbit!
Lots of stuff, ending with Window restruct
2026-10-11 13:32:47 -05:00 · 2026-10-11 13:32:47 -05:00 · 2026-10-11 13:32:47 -05:00 · 2026-10-11 13:32:27 -05:00
27 changed files with 886 additions and 1298 deletions
@@ -5,4 +5,5 @@ CMakeCache.txt
 docs/*
 !docs/CMake*
 !docs/Doxyfile.in
-!.clangd
+!.clangd
+.glsld
@@ -13,10 +13,10 @@ 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/Errors.hpp
    ./include/NBCore/ErrorsImpl.hpp
@@ -1,214 +0,0 @@
-#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
@@ -2,9 +2,7 @@
 #ifndef _NB_TYPE_TRAITS
 #define _NB_TYPE_TRAITS

-#include <tuple>
 #include <type_traits>
-#include <vector>

 namespace nb {

@@ -31,6 +29,14 @@ namespace detail {
    };
 } // namespace detail

+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>
@@ -90,37 +96,6 @@ 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;

@@ -156,48 +131,6 @@ 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
@@ -2,7 +2,6 @@
 #ifndef _NB_CORE_TYPES
 #define _NB_CORE_TYPES

-#include <exception>
 #include <memory>
 #include <unordered_map>
 #include <vector>
@@ -0,0 +1,17 @@
+#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
@@ -30,23 +30,26 @@ 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
 )

@@ -57,7 +57,8 @@ 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;
@@ -69,17 +70,16 @@ 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));
        }
-        bind();
+        this->bind();
        return _id;
    } 
    virtual void remove() override {
        if (_id) {
-            unbind();
+            this->unbind();
            OPENGL_CALL(glDeleteBuffers(1, &_id));
            _id = 0;
        }
@@ -88,6 +88,8 @@ 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);

@@ -151,67 +153,108 @@ protected:

 }; */

-class ArrayBuffer : public Buffer {
+class UniformBuffer : public Buffer {
+    protected:
+    GLuint _index;
+
    public:
-    template<typename T>
-    ArrayBuffer(const std::vector<T>& data, GLenum usage=GL_STATIC_DRAW)
-    : Buffer(GL_ARRAY_BUFFER) {
-        Buffer::data(vectorToBytes(data), usage);
-    }
+    UniformBuffer();
+    void bind() const override;
+    GLuint bufferIndex() const;
+    GLuint bufferIndex(GLuint);
+
 };

-class ElementBuffer : protected Buffer {
+template<typename T>
+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:
-    GLenum _glslType;
-    size_t _typeSize;
+    using Codes = BufferError::Codes;
+    using OpenGLObject::_id;
+    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::usage;
    using Buffer::unbind;
-    ElementBuffer();
+    using Buffer::usage;
+    using Buffer::size;
    template<typename T>
-    ElementBuffer(const T* const data_ptr, size_t size, GLenum usage=GL_STATIC_DRAW)
-    : 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);
+    ElementBuffer(const std::vector<T>& indices, GLenum usage=GL_STATIC_DRAW) : Buffer(GL_ELEMENT_ARRAY_BUFFER) {
+        data(indices, usage);
    }

+    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);
+    }

 };

@@ -1,83 +0,0 @@
-#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
@@ -158,6 +158,8 @@ class Image<Pixel<T, Channels...>> {
    using Codes = ImageError::Codes;
    bool _data_managed;
    T* _data;
+    Image(unsigned int x, unsigned int y, T* data, bool managed)
+        : width(x), height(y), _data(data), _data_managed(managed) {}
    void clear() {
        if (_data_managed) {
            delete[] _data;
@@ -171,19 +173,21 @@ class Image<Pixel<T, Channels...>> {
    static constexpr size_t NumberChannels = sizeof...(Channels);
    const unsigned int width;
    const unsigned int height;
-    static Image&& CreateImageStorage(
+    static Image CreateImageStorage(
        unsigned int width,
        unsigned int height,
        T* data=nullptr
    ) {
        unsigned int data_size = NumberChannels*width*height*sizeof(T);
        T* data_ptr = new T[data_size];
-        auto& ret = Image(width, height, data_ptr);
+        Image ret(width, height, data_ptr, true);
        if (data) {
            std::memcpy(data_ptr, data, data_size);
+        } else {
+            std::memset(data_ptr, 0x00, data_size);
        }
        ret._data_managed = true;
-        return std::move(ret);
+        return ret;
    }
    Image(unsigned int x, unsigned int y, T* data=nullptr) 
        : width(x), height(y), _data(data), _data_managed(false) {}
@@ -201,8 +205,13 @@ class Image<Pixel<T, Channels...>> {
        }
        const Error<> sizeErr = sizeCompare(cpy);
        if (sizeErr.code!=1) { THROW(sizeErr); }
-        _data = cpy._data;
-        return this;
+        if (!cpy._data_managed) {
+            _data = cpy._data;
+            _data_managed = false;
+        } else {
+            *this = cpy.copy();
+        }
+        return *this;
    }
    Image& operator=(Image&& mv) {
        if (_data_managed) {
@@ -213,7 +222,7 @@ class Image<Pixel<T, Channels...>> {
        _data = mv._data;
        _data_managed = mv._data_managed;
        mv._data_managed = false;
-        return this;
+        return *this;
    }

    virtual ~Image() {
@@ -221,7 +230,7 @@ class Image<Pixel<T, Channels...>> {
    }

    const T* data() const { return _data; }
-    Image<PixelType>&& copy() const {
+    Image<PixelType> copy() const {
        return CreateImageStorage(width, height, _data);
    }
    PixelReference<PixelType> at(unsigned int x, unsigned int y) {
@@ -0,0 +1,81 @@
+#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
@@ -11,6 +11,7 @@ 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>;
@@ -32,6 +33,7 @@ class OpenGLError : public Error<OpenGLError> {
    static const std::string type;
    static const ErrorCodeMap ErrorMessages;
    static OpenGLError status();
+    static OpenGLError status(const std::string& note);
 };

 class OpenGLObjectError : public Error<OpenGLObjectError> {
@@ -41,7 +43,7 @@ class OpenGLObjectError : public Error<OpenGLObjectError> {
    using Base::Base;

    enum Codes : unsigned int {
-        UNDEFINED, HANGING_OBJECT, INVALID_OBJECT
+        UNDEFINED, HANGING_OBJECT, INVALID_OBJECT, INVALID_CONTEXT
    };

    static const std::string type;
@@ -60,13 +62,16 @@ class OpenGLObject {
    virtual void unbind() const = 0;
    GLuint id() const { return _id; }
    
+    
    protected:
    using Codes = OpenGLObjectError::Codes;
-    OpenGLObject() = default;
+    OpenGLObject();
    
+    void checkObjectContextValidity();
    virtual GLuint declare() = 0;
    virtual void remove() = 0;

+    const GLFWwindow* const _arena;
    GLuint _id = 0;
 };

@@ -80,21 +85,21 @@ class OpenGLObject {
                unsigned int line,
                Fn fn
            ) {
-                auto check_ = [file, line]() {
+                auto check_ = [file, line](const std::string& note="") {
                    const auto no_err = nb::OpenGLError::NO_ERROR;
-                    auto stat = nb::OpenGLError::status();
+                    auto stat = nb::OpenGLError::status(note);
                    if (stat.code != no_err) {
                        THROW_W_CODE_LOC(file, line, stat);
                    }
                };
                if constexpr(std::is_same_v<std::invoke_result_t<Fn>, void>) {
-                    check_();
+                    check_("Pre-call state");
                    fn();
-                    check_();
+                    check_("Post-call state");
                } else {
-                    check_();
+                    check_("Pre-call state");
                    auto ret = fn();
-                    check_();
+                    check_("Post-call state");
                    return ret;
                }
            }
@@ -9,6 +9,7 @@
 #include <NBCore/Errors.hpp>
 #include <NBCore/Utils.hpp>

+#include <NBGraphics/Buffers.hpp>
 #include <NBGraphics/OGLObjects.hpp>

 namespace nb {
@@ -112,17 +113,22 @@ class Program : public OpenGLObject {
    Program& operator=(Program&&) = delete;
    operator bool();
    ~Program() { remove(); }
-    virtual void bind() const override {
+    void bind() const override {
        OPENGL_CALL(glUseProgram(_id));
    }
-    virtual void unbind() const override { /* TODO: Some warning of some kind perhaps*/ }
+    void unbind() const override { /* TODO: Some warning of some kind perhaps*/ }
    GLint status(GLenum) const;
    std::string log() const;
+    void setUniform(const std::string& blockname, std::shared_ptr<UniformBuffer>);
+    void setUniformBinding(const std::string& blockname, GLuint index);
+    GLuint getUniformBinding(const std::string& blockname) const;
+
    friend Base;

    protected:
    using Base::_id;
    GLint _success;
+    std::unordered_map<std::string, GLuint> _uniformBindings;
    virtual GLuint declare() override {
        if (!_id) {
            _id = OPENGL_CALL(glCreateProgram());
@@ -24,11 +24,11 @@ class RenderTarget : public OpenGLObject {
    using Base = OpenGLObject;
    using Base::_id;
    RenderTarget(GLenum target) : Target(target) {}
-    RenderTarget(RenderTarget&& rhs) 
-    : Target(rhs.Target), Base(std::move(rhs)) {}

    public:
    using Base::id;
+    RenderTarget(RenderTarget&& mv);
+    RenderTarget& operator=(RenderTarget&& mv);
    const GLenum Target;
 };

@@ -57,8 +57,10 @@ class Texture : public RenderTarget {
    public:
    using Base::id;
    using Base::Target;
-
-    virtual void bind() const override {
+    Texture(Texture&& mv);
+    Texture& operator=(Texture&& mv);
+    
+    void bind() const override {
        if (_id) {
            OPENGL_CALL(glBindTexture(Target, _id));
        } else {
@@ -68,7 +70,7 @@ class Texture : public RenderTarget {
            ));
        }
    }
-    virtual void unbind() const override {
+    void unbind() const override {
        OPENGL_CALL(glBindTexture(Target, 0));
    }

@@ -119,13 +121,6 @@ struct OGLPixelFormat;
 template<typename T, typename... Channels>
 struct OGLPixelFormat<Pixel<T, Channels...>>;

-template<>
-struct OGLPixelFormat<Pixel<uint8_t, Red, Green, Blue>> {
-    static constexpr GLenum glBase = GL_RGB;
-    static constexpr GLenum glFormat = GL_RGB8UI;
-    static constexpr GLenum glData = GL_UNSIGNED_BYTE;
-};
-
 template<>
 struct OGLPixelFormat<Pixel<uint8_t, Red, Green, Blue, Alpha>> {
    static constexpr GLenum glBase = GL_RGBA;
@@ -133,6 +128,27 @@ struct OGLPixelFormat<Pixel<uint8_t, Red, Green, Blue, Alpha>> {
    static constexpr GLenum glData = GL_UNSIGNED_BYTE;
 };

+template<>
+struct OGLPixelFormat<Pixel<float, Red, Green, Blue, Alpha>> {
+    static constexpr GLenum glBase = GL_RGBA;
+    static constexpr GLenum glFormat = GL_RGBA32F;
+    static constexpr GLenum glData = GL_FLOAT;
+};
+
+template<>
+struct OGLPixelFormat<Pixel<uint8_t, Red, Green, Blue>> {
+    static constexpr GLenum glBase = GL_RGB;
+    static constexpr GLenum glFormat = GL_RGB8UI;
+    static constexpr GLenum glData = GL_UNSIGNED_BYTE;
+};
+
+template<>
+struct OGLPixelFormat<Pixel<float, Red, Green, Blue>> {
+    static constexpr GLenum glBase = GL_RGB;
+    static constexpr GLenum glFormat = GL_RGB32F;
+    static constexpr GLenum glData = GL_FLOAT;
+};
+
 template<>
 struct OGLPixelFormat<Pixel<float, Red, Green>> {
    static constexpr GLenum glBase = GL_RG;
@@ -140,6 +156,13 @@ struct OGLPixelFormat<Pixel<float, Red, Green>> {
    static constexpr GLenum glData = GL_FLOAT;
 };

+template<>
+struct OGLPixelFormat<Pixel<float, Red>> {
+    static constexpr GLenum glBase = GL_RED;
+    static constexpr GLenum glFormat = GL_R32F;
+    static constexpr GLenum glData = GL_FLOAT;
+};
+
 template<typename T>
 class Texture2D;

@@ -226,5 +249,19 @@ class Texture1D<Pixel<T, Channels...>> : public Texture {
    }
 };

+template <typename T>
+class Texture1DArray;
+
+template <typename... T>
+class Texture1DArray<Pixel<T...>> : public Texture {
+    protected:
+
+    public:
+    using Texture::generateMipmaps;
+    Texture1DArray() : Texture(GL_TEXTURE_1D_ARRAY) {
+
+    }
+};
+
 } // namespace nb
 #endif // _NB_TEXTURES
@@ -8,6 +8,7 @@

 #include <NBGraphics/Buffers.hpp>
 #include <NBGraphics/OGLObjects.hpp>
+#include <NBGraphics/VertexData.hpp>


 namespace nb {
@@ -33,32 +34,13 @@ 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(va.GLSLType) * va.GLSLSize;
+    return (i%va.layout.stride) < GLSLTypeSize(TypeToGLSL[va.type]) * va.size;
 }

-typedef std::vector<VertexAttribute> VertexAttributeList;
-typedef std::vector<VertexAttributePointer> VertexAttributePointerList;
+typedef std::vector<VertexData> VertexDataList;
+typedef std::vector<VertexDataPointer> VertexDataPointerList;

 class VAOError : public Error<VAOError> {
    using Base = Error<VAOError>;
@@ -78,10 +60,30 @@ 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 VertexAttributePointerList&);
+    VAO(const VertexDataPointerList&);
    VAO(VAO&&);

    VAO& operator=(VAO&&);
@@ -100,34 +102,15 @@ class VAO : public OpenGLObject {
        OPENGL_CALL(glBindVertexArray(0));
    }

-    VertexAttributePointerList attributes() const;
-    VertexAttributePointerList attributes(const VertexAttributePointerList&);
-    VertexAttributePointer attr(GLuint) const;
+    VertexDataPointerList attributes() const;
+    VertexDataPointerList attributes(const VertexDataPointerList&);
+    VertexDataPointerList attributes(const VertexDataList&);
+    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> {
@@ -144,97 +127,5 @@ 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
@@ -0,0 +1,43 @@
+#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
@@ -6,8 +6,9 @@
 #include <NBGraphics/OGLObjects.hpp>

 #include <array>
-#include <map>
+#include <memory>
 #include <string>
+#include <vector>

 #include <NBCore/Errors.hpp>
 #include <NBCore/Utils.hpp>
@@ -21,67 +22,98 @@ class GLFWError : public Error<GLFWError> {
    using Base::Base;

    enum Codes : unsigned int {
-        UNDEFINED, INIT_FAILED, GLFW_INTIALIZED, GLAD_FAILED
+        UNDEFINED, INIT_FAILED, GLFW_INTIALIZED, GLAD_FAILED,
+        NOT_MAIN, WINDOW_FAILED
    };

    static const std::string type;
    static const ErrorCodeMap ErrorMessages;
 };

-class WindowError : public Error<WindowError> {
-    using Base = Error<WindowError>;
+class OGLWindow {
+    using GLFWHint = std::array<int, 2>;
+    private:
+    static inline void CheckForMainThread() {
+        if (nb::CurrentTID != nb::MainTID) {
+            THROW(GLFWError(GLFWError::Codes::NOT_MAIN));
+        }
+    }
+
+    protected:
+    static std::atomic<unsigned int> _count;
+    static std::atomic<bool> _glfwInitialized;
+    static thread_local GLFWwindow* _currWindow;
+    static thread_local const GLFWwindow* _currArena;
+    
+    static void SetHintInteger(const std::array<int, 2>&);
+    static void SetHintString(const std::tuple<int, std::string>&);
+    
+    std::string _title;
+    GLFWwindow* _window_ptr;
+    const GLFWwindow* _arena;
+
+    OGLWindow(
+        unsigned int,
+        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:
-    using Base::Base;
-
-    enum Codes : unsigned int {
-        UNDEFINED, INITIALIZED_WINDOW, NO_GLFW, INIT_FAILED
+    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 const std::string type;
-    static const ErrorCodeMap ErrorMessages;
-};
+    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 const GLFWwindow* GetCurrentObjectArena() { return _currArena; }
+    static GLFWwindow* MakeCurrent(const std::shared_ptr<OGLWindow>&);
+    static inline GLFWwindow* DropCurrent() { return MakeCurrent(nullptr); }
+    static void DestroyWindow(std::shared_ptr<OGLWindow>&);
+    static std::shared_ptr<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={}
+    );
+    static std::shared_ptr<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={}
+    );
+    OGLWindow(OGLWindow&&) = delete;
+    OGLWindow(const OGLWindow&) = delete;
+    ~OGLWindow();
+    inline bool operator==(const OGLWindow& rhs) { return _window_ptr==rhs._window_ptr; }

-class Window {
-public:
-    static bool StrictInitialization;
-    
-    static int getGLFWHint(int);
-    static int setGLFWHint(int, int);
-    static Window* getCurrent();
+    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;
+    inline void processEvents() const { CheckForMainThread(); glfwPollEvents(); }
+    inline void refresh() const { glfwSwapBuffers(_window_ptr); }

-    Window(const std::array<uint16_t, 2>, const char*, GLFWmonitor* initMonitor=NULL, GLFWwindow* initWindow=NULL);
-    Window(const uint16_t, const uint16_t, const char*, GLFWmonitor* initMonitor=NULL, GLFWwindow* initWindow=NULL);
-    ~Window();
-
-    int getWindowHint(int) const;
-    GLFWwindow* getWindow() const;
-    std::array<uint16_t, 2> getSize() const;
-    float getAspectRatio() const;
-    std::string getName() const;
-    
-    int init();
-    int setWindowHint(int, int);
-    void setCurrent();
-    void resize(const std::array<uint16_t, 2>);
-    void resize(const uint16_t x, const uint16_t y);
-
-protected:
-    static std::map<GLFWwindow*, Window*> WindowContexts;
-    static std::map<int, int> GLFWHints;
-    static Window* _current;
-    static bool _glfw_init;
-    static bool checkKillGLFW();
-
-    std::map<int, int> windowHints;
-    std::array<uint16_t, 2> windowSize;
-    float _aspect_ratio;
-    std::string windowName;
-    GLFWwindow* window;
-    GLFWmonitor* monitor;
-    GLFWwindow* shareWindow;
-    bool _init = false;
-    int gladResponse = -1;
+    void setSize(unsigned int x, unsigned int y);
+    void setTitle(const std::string&);
+    void shouldClose(bool);
+/*     template<enum Callbacks, typename Func>
+    void setCallBack(Func); */
 };

 };
@@ -12,10 +12,21 @@ 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);
 }
@@ -74,17 +85,21 @@ void Buffer::subdata(const ByteVector& data_, GLintptr offset_) {
    subdata(data_.data(), size_);
 }

-ElementBuffer::ElementBuffer() : Buffer(GL_ELEMENT_ARRAY_BUFFER) {}
+// class UniformBuffer
+UniformBuffer::UniformBuffer() : Buffer(GL_UNIFORM_BUFFER) {}

-ByteVector ElementBuffer::data() const {
-    return data();
+void UniformBuffer::bind() const {
+    Buffer::bind();
+    OPENGL_CALL(glBindBufferBase(GL_UNIFORM_BUFFER, _index, id()));
 }

-size_t ElementBuffer::size() const { return _size / _typeSize; }
+GLuint UniformBuffer::bufferIndex() const { return _index; }

-size_t ElementBuffer::typeSize() const { return _typeSize; }
+GLuint UniformBuffer::bufferIndex(GLuint idx) {
+    return (_index = idx);
+}

-GLenum ElementBuffer::glslType() const { return _glslType; }
+// class ElementBuffer

 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);
@@ -93,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, size_t 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, size_t 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, size_t offset=0);
-template void ElementBuffer::subdata<uint32_t>(const std::vector<uint32_t>& data, size_t offset=0);
+template void ElementBuffer::subdata<uint8_t>(const uint8_t* const data, size_t size, GLintptr offset=0);
+template void ElementBuffer::subdata<uint16_t>(const uint16_t* const data, size_t size, GLintptr offset=0);
+template void ElementBuffer::subdata<uint32_t>(const uint32_t* const data, size_t size, GLintptr offset=0);
+template void ElementBuffer::subdata<uint8_t>(const std::vector<uint8_t>& data, GLintptr offset=0);
+template void ElementBuffer::subdata<uint16_t>(const std::vector<uint16_t>& data, GLintptr offset=0);
+template void ElementBuffer::subdata<uint32_t>(const std::vector<uint32_t>& data, GLintptr offset=0);

 }
@@ -1,307 +0,0 @@
-#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();
-}
-
-}
@@ -0,0 +1,73 @@
+#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
@@ -1,4 +1,5 @@
 #include <NBGraphics/OGLObjects.hpp>
+#include <NBGraphics/Window.hpp>

 #ifndef GLENUMSTRPAIR
    #define GLENUMSTRPAIR(x) {x, #x}
@@ -10,7 +11,8 @@ const std::string OpenGLObjectError::type = "nb::OpenGLObjectError";
 const ErrorCodeMap OpenGLObjectError::ErrorMessages = {
    { OpenGLObjectError::Codes::UNDEFINED, "Error" },
    {OpenGLObjectError::Codes::HANGING_OBJECT, "Attempting to leave a hanging OpenGL object"},
-    {OpenGLObjectError::Codes::INVALID_OBJECT, "Attempting operation with invalid object"}
+    {OpenGLObjectError::Codes::INVALID_OBJECT, "Attempting operation with invalid object"},
+    {OpenGLObjectError::Codes::INVALID_CONTEXT, "Object not valid with current OpengGL context"}
 };

 const std::string OpenGLError::type = "nb::OpenGLError";
@@ -30,11 +32,39 @@ OpenGLError OpenGLError::status() {
    return OpenGLError(glGetError());
 }

-OpenGLObject::OpenGLObject(OpenGLObject&& rval) {
+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()) {
+        THROW(OpenGLObjectError(OpenGLObjectError::INVALID_CONTEXT));
+    }
+}
+
+OpenGLObject::OpenGLObject(OpenGLObject&& rval) : _arena(rval._arena) {
+    checkObjectContextValidity();
    *this = std::move(rval);
 }

+OpenGLObject::OpenGLObject() : _arena(OGLWindow::GetCurrentObjectArena()) {}
+
 OpenGLObject& OpenGLObject::operator=(OpenGLObject&& rhs) {
+    rhs.checkObjectContextValidity();
    if (_id) { THROW(OpenGLObjectError(Codes::HANGING_OBJECT)); }
    _id = rhs._id;
    rhs._id = 0;
@@ -60,6 +90,10 @@ 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
@@ -15,6 +15,8 @@ const ErrorCodeMap ProgramError::ErrorMessages = {
    {ProgramErrCodes::LINKING_ERROR, "Linker error"}
 };

+// class Shader
+
 Shader::Shader(GLenum target_, const std::string& source_) 
 : Shader(target_, std::vector<std::string>({source_})) {}

@@ -54,6 +56,8 @@ std::string Shader::log() const {
    return ret; 
 }

+// class Program
+
 Program::Program(SharedVector<Shader> shaders_) {
    declare();
    for (auto shad_ptr : shaders_) {
@@ -83,6 +87,26 @@ std::string Program::log() const {
    return ret; 
 }

+void Program::setUniform(const std::string& blockname, std::shared_ptr<UniformBuffer> buffer) {
+    declare();
+    auto idx = OPENGL_CALL(glGetUniformBlockIndex(id(), blockname.data()));
+    if (idx == GL_INVALID_INDEX) {
+        THROW("something");
+    }
+    this->setUniformBinding(blockname, buffer->bufferIndex());
+    OPENGL_CALL(glUniformBlockBinding(
+        id(),
+        idx,
+        _uniformBindings[blockname]
+    ));
+}

+void Program::setUniformBinding(const std::string& blockname, GLuint index) {
+    _uniformBindings[blockname] = index;
+}
+
+GLuint Program::getUniformBinding(const std::string& blockname) const {
+    return _uniformBindings.at(blockname);
+}

 }
@@ -2,6 +2,33 @@

 namespace nb {

+// class RenderTarget
+
+RenderTarget::RenderTarget(RenderTarget&& mv) : Target(mv.Target) {
+    *this = std::move(mv);
+}
+
+RenderTarget& RenderTarget::operator=(RenderTarget&& mv) {
+    if (mv.Target != Target) {
+        THROW(OpenGLObjectError(
+            OpenGLObjectError::INVALID_OBJECT,
+            "Cannot assign RenderTarget of different types."
+        ));
+    }
+    Base::operator=(std::move(mv));
+    return *this;
+}
+
+// class Texture
 Texture::Texture(GLenum target_) : Base(target_) {}

+Texture::Texture(Texture&& mv) : Base(mv.Target) {
+    *this = std::move(mv);
+}
+
+Texture& Texture::operator=(Texture&& mv) {
+    Base::operator=(std::move(mv));
+    return *this;
+}
+
 } // namespace nb
@@ -1,3 +1,6 @@
+#pragma clang diagnostic ignored "-Wint-to-pointer-cast"
+#pragma GCC diagnostic ignored "-Wint-to-pointer-cast"
+
 #include <NBGraphics/VertexArray.hpp>

 namespace nb {
@@ -16,7 +19,7 @@ const ErrorCodeMap VertexError::ErrorMessages = {
    { VertexError::MISALIGNED_DATA, "Data does not match vertex layout"}
 };

-VAO::VAO(const VertexAttributePointerList& attr_ptrs) {
+VAO::VAO(const VertexDataPointerList& attr_ptrs) {
    attributes(attr_ptrs);
 }

@@ -26,41 +29,58 @@ VAO::VAO(VAO&& other) {

 VAO& VAO::operator=(VAO&& rhs) {
    OpenGLObject::operator=(std::move(rhs));
-    _attrs = rhs._attrs;
-    rhs._attrs = {};
+    _vertexdata = rhs._vertexdata;
+    rhs._vertexdata = {};
    return *this;
 }

-VertexAttributePointerList VAO::attributes() const {
-    return _attrs;
+VertexDataPointerList VAO::attributes() const {
+    return _vertexdata;
 }

-VertexAttributePointerList VAO::attributes(const VertexAttributePointerList& attrs_) {
+VertexDataPointerList VAO::attributes(const VertexDataPointerList& vertdatalist) {
    declare();
    disable();
-    _attrs = attrs_;
+    _vertexdata = vertdatalist;
    bind();
-    for (auto attr_ptr : attrs_) {
-        OPENGL_CALL(glBindBuffer(GL_ARRAY_BUFFER, attr_ptr.buffer));
-        GLuint idx = attr_ptr.index; 
-        OPENGL_CALL(glVertexAttribPointer(
-            idx,
-            attr_ptr.attribute.GLSLSize,
-            attr_ptr.attribute.GLSLType,
-            attr_ptr.attribute.GLSLNormalization,
-            attr_ptr.attribute.layout.stride,
-            (void*)attr_ptr.attribute.layout.offset
-        ));
-        OPENGL_CALL(glEnableVertexAttribArray(idx));
+    for (const auto vdata : _vertexdata) {
+        OPENGL_CALL(glBindBuffer(GL_ARRAY_BUFFER, vdata.vertexdata->data->id()));
+        for (const auto attr : vdata.vertexdata->attributes) {
+            GLuint idx = vdata.index; 
+            OPENGL_CALL(glVertexAttribPointer(
+                idx,
+                attr.size,
+                TypeToGLSL[attr.type],
+                attr.normalized,
+                attr.layout.stride,
+                (const void*) attr.layout.offset
+            ));
+            OPENGL_CALL(glEnableVertexAttribArray(idx));
+            if (attr.layout.divisor) {
+                OPENGL_CALL(glVertexAttribDivisor(idx, attr.layout.divisor));
+            }
+        }
    }
    unbind();
-    return _attrs;
+    enable();
+    return _vertexdata;
 }

-VertexAttributePointer VAO::attr(GLuint idx) const {
-    for (auto attr_ptr : _attrs) {
-        if (idx == attr_ptr.index) {
-            return attr_ptr;
+VertexDataPointerList VAO::attributes(const VertexDataList& vertdatalist) {
+    VertexDataPointerList vdatas;
+    for (unsigned int i = 0; i < vertdatalist.size(); ++i) {
+        vdatas.emplace_back(VertexDataPointer{
+            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));
@@ -69,8 +89,8 @@ VertexAttributePointer VAO::attr(GLuint idx) const {
 void VAO::enable() const {
    if (_id) {
        bind();
-        for(auto attr_ptr : _attrs) {
-            OPENGL_CALL(glEnableVertexAttribArray(attr_ptr.index));
+        for(auto vdata : _vertexdata) {
+            OPENGL_CALL(glEnableVertexAttribArray(vdata.index));
        }
        unbind();
    }
@@ -79,7 +99,7 @@ void VAO::enable() const {
 void VAO::enable(GLuint idx) const {
    if(_id) {
        bind();
-        OPENGL_CALL(glEnableVertexAttribArray(attr(idx).index)); 
+        OPENGL_CALL(glEnableVertexAttribArray(attribute(idx).index)); 
        unbind();
    }
 }
@@ -87,8 +107,8 @@ void VAO::enable(GLuint idx) const {
 void VAO::disable() const {
    if(_id) {
        bind();
-        for(auto attr_ptr : _attrs) {
-            OPENGL_CALL(glDisableVertexAttribArray(attr_ptr.index)); 
+        for(auto vdata : _vertexdata) {
+            OPENGL_CALL(glDisableVertexAttribArray(vdata.index)); 
        }
        unbind();
    }
@@ -97,157 +117,10 @@ void VAO::disable() const {
 void VAO::disable(GLuint idx) const {
    if(_id) {
        bind();
-        OPENGL_CALL(glDisableVertexAttribArray(attr(idx).index)); 
+        OPENGL_CALL(glDisableVertexAttribArray(attribute(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
@@ -0,0 +1,16 @@
+#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
@@ -2,185 +2,212 @@

 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 = {
    {GLFWCodes::UNDEFINED, "Error"},
    {GLFWCodes::INIT_FAILED, "GLFW initialization failed"},
    {GLFWCodes::GLFW_INTIALIZED, "GLFW has already been initialized"},
-    {GLFWCodes::GLAD_FAILED, "GLAD initialization failed"}
+    {GLFWCodes::GLAD_FAILED, "GLAD initialization failed"},
+    {GLFWCodes::NOT_MAIN, "Action can only be done on main thread"},
+    {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 OGLWindow

-int Window::getGLFWHint(int hint_key) {
-    if (GLFWHints.find(hint_key) == GLFWHints.end()) {
-        return 0;
-    } else {
-        return GLFWHints.at(hint_key);
+std::atomic<bool> OGLWindow::_glfwInitialized = false;
+thread_local GLFWwindow* OGLWindow::_currWindow = nullptr;
+thread_local const GLFWwindow* OGLWindow::_currArena = nullptr;
+std::atomic<unsigned int> OGLWindow::_count = 0;
+
+bool OGLWindow::InitGLFW(const std::vector<GLFWHint>& hints) {
+    if (nb::MainTID != GetTID()) {
+        THROW(GLFWError(GLFWError::NOT_MAIN));
    }
-}
-
-int Window::setGLFWHint(int hint_key, int hint_val) {
-    if (Window::_glfw_init) {
-        THROW(GLFWError(GLFWCodes::GLFW_INTIALIZED));
-    } else {
-        GLFWHints[hint_key] = hint_val;
+    if (!IsGLFWInitialized()) {
+        for (const auto& hint : hints) {
+            glfwInitHint(hint[0], hint[1]);
+        }
+        if (glfwInit()) {
+            OGLWindow::_glfwInitialized.store(true, std::memory_order_release);
+        } else {
+            THROW(GLFWError(GLFWError::INIT_FAILED));
+        }
    }
-    return GLFWHints[hint_key];
+    return IsGLFWInitialized();
 }

-Window* Window::getCurrent() {
-    return _current;
-}
-
-bool Window::checkKillGLFW() {
-    if(Window::WindowContexts.size() == 0 && _glfw_init) {
+bool OGLWindow::TerminateGLFW() {
+    if (nb::MainTID != GetTID()) {
+        THROW(GLFWError(GLFWError::NOT_MAIN));
+    }
+    if (IsGLFWInitialized()) {
        glfwTerminate();
-        Window::_glfw_init = false;
-        return true;
+        OGLWindow::_glfwInitialized.store(false, std::memory_order_release);
    }
-    return false;
+    return !IsGLFWInitialized();
 }

-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;
-    }
+void OGLWindow::SetHintInteger(const std::array<int, 2>& hint) {
+    CheckForMainThread();
+    glfwWindowHint(hint[0], hint[1]);
 }

-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 OGLWindow::SetHintString(const std::tuple<int, std::string>& hint) {
+    CheckForMainThread();
+    glfwWindowHintString(std::get<0>(hint), std::get<1>(hint).c_str());
 }

-void Window::setCurrent() {
-    _current = this;
-    glfwMakeContextCurrent(window);
-}
-
-int Window::getWindowHint(int hint_key) const {
-    if (windowHints.find(hint_key) == windowHints.end()) {
-        return 0;
+GLFWwindow* OGLWindow::MakeCurrent(const std::shared_ptr<OGLWindow>& window) {
+    auto tmp = _currWindow;
+    _currWindow = window->getWindowPtr();
+    if (window) {
+        glfwMakeContextCurrent(_currWindow);
+        _currArena = window->_arena;
    } else {
-        return windowHints.at(hint_key);
+        glfwMakeContextCurrent(nullptr);
+        _currArena = nullptr;
    }
+    return tmp;
 }

-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];
-} 
+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
+    ) );
+}

-int Window::init() {
-    if (!_glfw_init) {
-        THROW(WindowError(WindowErrorCodes::NO_GLFW));
-    }
-    for (const auto& hint : windowHints) {
-        glfwWindowHint(hint.first, hint.second);
-    }
+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()
+    ) );
+}

-    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));
+OGLWindow::OGLWindow(
+    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,
+    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,
+        _title.c_str(), 
+        NULL,
+        sharingContext
+    );
+    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);
+}
+
+OGLWindow::~OGLWindow() {
+    CheckForMainThread();
+    if (_window_ptr) {
+        if (_window_ptr == _currWindow) {
+            _currWindow = nullptr;
+            _currArena = nullptr;
+        }
+        glfwDestroyWindow(_window_ptr);
+        _count.fetch_add(-1);
+        if (!_count.load()) {
+            TerminateGLFW();
        }
    }
-    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;
+void OGLWindow::detachWindow() {
+    _title = "";
+    _window_ptr = nullptr;
+    _arena = nullptr;
 }

-float Window::getAspectRatio() const { return _aspect_ratio; }
-
-std::array<uint16_t, 2> Window::getSize() const {
-    return windowSize;
+int OGLWindow::getWindowAttribute(int attr) const {
+    CheckForMainThread();
+    return glfwGetWindowAttrib(_window_ptr, attr);
 }

-std::string Window::getName() const {
-    return windowName;
+std::array<int, 2> OGLWindow::getSize() const {
+    CheckForMainThread();
+    int x, y;
+    glfwGetWindowSize(_window_ptr, &x, &y);
+    return {x, y};
 }

-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]);
+bool OGLWindow::shouldClose() const {
+    CheckForMainThread();
+    return glfwWindowShouldClose(_window_ptr);
 }

-void Window::resize(const uint16_t x, const uint16_t y) { resize({x, y}); }
+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);
+}
+
+void OGLWindow::setTitle(const std::string& name) {
+    CheckForMainThread();
+    _title = 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);
+} */

 };
@@ -4,18 +4,23 @@

 #include <NBCore/Errors.hpp>
 #include <NBGraphics/Image.hpp>
+#include <NBGraphics/Mesh.hpp>
 #include <NBGraphics/ProgramPipeline.hpp>
-#include <NBGraphics/VertexArray.hpp>
+#include <NBGraphics/VertexData.hpp>
 #include <NBGraphics/Window.hpp>
 #include <NBGraphics/Textures.hpp>


 int main() {
    LOG("Howdy!");
-    nb::Window window(400, 400, "Hello!");
-    window.setWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-    window.setWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
-    window.init();
+    auto window = nb::OGLWindow::CreateWindow(
+        400,
+        400,
+        "Howdy!", 
+        {{GLFW_CONTEXT_VERSION_MAJOR, 3},
+        {GLFW_CONTEXT_VERSION_MINOR, 3}}
+    );
+    nb::OGLWindow::MakeCurrent(window);

    auto vert = std::make_shared<nb::Shader>(
        GL_VERTEX_SHADER,
@@ -56,17 +61,15 @@ int main() {

    std::vector<uint32_t> indxs = {0, 1, 2};

-    nb::VertexGroup tri(data, {
-        nb::VertexAttribute{
+    nb::IndexedMesh tri(GL_TRIANGLES, data, {nb::VertexAttribute{
            2,
-            GL_FLOAT,
+            nb::TypeCodes::FLOAT32,
            false,
            {0, 8}
-        },
-    }, indxs);
+        }}, indxs);
    LOG(prog.log());

-    GLFWwindow* window_ptr = window.getWindow();
+    GLFWwindow* window_ptr = window->getWindowPtr();
    while(!glfwWindowShouldClose(window_ptr)) {
        OPENGL_CALL(glClearColor(0.2f, 0.3f, 0.3f, 1.0f));
        OPENGL_CALL(glClear(GL_COLOR_BUFFER_BIT));
Author	SHA1	Message	Date
NaifBanana	06f261b793	Heavy buffer update, window update, object tracking	2026-10-11 13:32:47 -05:00
NaifBanana	e76ef32c45	Nuked old window class outta orbit!	2026-10-11 13:32:47 -05:00
NaifBanana	f49650744a	Lots of stuff, ending with Window restruct	2026-10-11 13:32:47 -05:00
NaifBanana	ab56a2cc95	Minor cleanup and added some Type utils	2026-10-11 13:32:27 -05:00