Better sinks, better loggers, etx

CMakeLists.txt

@@ -7,6 +7,10 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+include(CMakeDependentOption)
+
 function(toAbsolutePath SETVAR PATHS)
     set(PATHS ${PATHS} ${ARGN})
     set(RET_VAL "")
@@ -28,12 +32,42 @@ if(CMAKE_BUILD_TYPE STREQUAL "Release")
     message(STATUS "Targeting Release build")
 elseif(CMAKE_BUILD_TYPE STREQUAL "Debug")
     message(STATUS "Targeting Debug build")
-    set(NB_LOGGING ON)
+    set(NB_DEBUG_BUILD ON)
-    set(NB_BUILD_TESTS ON)
-    set(NB_BUILD_DOCS ON)
     add_compile_definitions(_NB_BUILD_DEBUG)
 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")
     set(NB_TARGET_WINDOWS ON)
@@ -55,7 +89,6 @@ if(NB_BUILD_TESTS)
         FetchContent_MakeAvailable(gtest)
     endif()
     set(GTEST_COLOR ON)
-    set(GLFW_BUILD_TESTS ON CACHE BOOL "" FORCE)
 endif()
 
 if (NB_LOGGING)
@@ -64,19 +97,16 @@ if (NB_LOGGING)
     add_compile_definitions(_NB_CODE_ERROR_LOCATIONS)
 endif()
 
-if (NB_TARGET_WINDOWS)
+if(NB_TARGET_WINDOWS)
     add_compile_definitions(_NB_TARGET_WINDOWS)
-elseif (NB_TARGET_LINUX)
+endif()
+if(NB_TARGET_LINUX)
     add_compile_definitions(_NB_TARGET_LINUX)
 endif()
 
-# External Dep paths
+get_filename_component(NBENGINE_ROOT ${CMAKE_CURRENT_LIST_DIR} ABSOLUTE)
-set(GLFW_PATH ../glfw/)
-set(GLAD_PATH ../glad/)
-get_filename_component(GLFW_PATH ${GLFW_PATH} ABSOLUTE)
-get_filename_component(GLAD_PATH ${GLAD_PATH} ABSOLUTE)
 
-add_subdirectory(./engine)
+add_subdirectory(./engine ${PROJECT_BINARY_DIR}/${CMAKE_BUILD_TYPE})
 
 # Toggle
 set(NB_REBUILD_DOCS)
@@ -84,3 +114,24 @@ set(NB_REBUILD_DOCS)
 if (NB_BUILD_DOCS)
     add_subdirectory(./docs)
 endif()
+
+include(CMakePackageConfigHelpers)
+configure_package_config_file(
+    "NBEngineConfig.cmake.in"
+    "${PROJECT_BINARY_DIR}/cmake/NBEngineConfig.cmake"
+    INSTALL_DESTINATION ${CMAKE_INSTALL_PREFIX}/cmake
+    PATH_VARS CMAKE_INSTALL_LIBDIR
+)
+write_basic_package_version_file(
+    "${PROJECT_BINARY_DIR}/cmake/NBEngineConfigVersion.cmake"
+    COMPATIBILITY AnyNewerVersion 
+)
+
+if (NBENGINE_INSTALL)
+    include(GNUInstallDirs)
+    install(FILES
+        "${PROJECT_BINARY_DIR}/cmake/NBEngineConfig.cmake"
+        "${PROJECT_BINARY_DIR}/cmake/NBEngineConfigVersion.cmake"
+        DESTINATION "${CMAKE_INSTALL_PREFIX}/cmake"
+    )
+endif()

NBEngineConfig.cmake.in

@@ -0,0 +1,8 @@
+@PACKAGE_INIT@
+set(NBENGINE_PACKAGES
+    NBCore
+    NBGraphics
+)
+foreach(NBENGINE_LIB ${NBENGINE_PACKAGES})
+    include("${CMAKE_CURRENT_LIST_DIR}/${NBENGINE_LIB}Config.cmake")
+endforeach()

engine/CMakeLists.txt

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

engine/NBCore/CMakeLists.txt

@@ -1,3 +1,13 @@
+cmake_minimum_required(VERSION 3.10)
+project(NBCore VERSION 0.1)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+
 toAbsolutePath(NB_CORE_SOURCE 
     ./src/ErrorsImpl.cpp
     ./src/Logger.cpp
@@ -5,28 +15,72 @@ toAbsolutePath(NB_CORE_SOURCE
     ./src/StringUtils.cpp
     ./src/Utils.cpp
 )
-
 toAbsolutePath(NB_CORE_INCLUDE
-    ./ANSITerm.hpp
+    ./include/NBCore/ANSITerm.hpp
-    ./DataSink.hpp
+    ./include/NBCore/DataSink.hpp
-    ./Errors.hpp
+    ./include/NBCore/Errors.hpp
-    ./ErrorsImpl.hpp
+    ./include/NBCore/ErrorsImpl.hpp
-    ./Logger.hpp
+    ./include/NBCore/Logger.hpp
-    ./Processes.hpp
+    ./include/NBCore/Printer.hpp
-    ./StringUtils.hpp
+    ./include/NBCore/Processes.hpp
-    ./ThreadsafeQueue.hpp
+    ./include/NBCore/StringUtils.hpp
-    ./Types.hpp
+    ./include/NBCore/ThreadsafeQueue.hpp
-    ./TypeTraits.hpp
+    ./include/NBCore/Types.hpp
-    ./Utils.hpp
+    ./include/NBCore/TypeTraits.hpp
+    ./include/NBCore/Utils.hpp
 )
 
 set(NB_CORE_SOURCE ${NB_CORE_SOURCE} PARENT_SCOPE)
 set(NB_CORE_INCLUDE ${NB_CORE_INCLUDE} PARENT_SCOPE)
 
 add_library(NBCore ${NB_CORE_SOURCE})
+add_library(NBEngine::Core ALIAS NBCore)
+target_include_directories(NBCore
+    PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
+    PUBLIC "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+)
+export(
+    TARGETS NBCore
+    FILE "${CMAKE_BINARY_DIR}/cmake/NBCoreTargets.cmake"
+    NAMESPACE NBEngine::
+)
+configure_package_config_file(
+    "NBCoreConfig.cmake.in"
+    "${CMAKE_BINARY_DIR}/cmake/NBCoreConfig.cmake"
+    INSTALL_DESTINATION "${CMAKE_INSTALL_PREFIX}/cmake"
+    PATH_VARS CMAKE_INSTALL_LIBDIR
+)
+write_basic_package_version_file(
+    "${CMAKE_BINARY_DIR}/cmake/NBCoreConfigVersion.cmake"
+    COMPATIBILITY AnyNewerVersion 
+)
 
-target_include_directories(NBCore PUBLIC ./.)
+if (NBENGINE_INSTALL)
+    message("Installing NBCore to ${CMAKE_INSTALL_PREFIX}")
+    install(
+        TARGETS NBCore
+        EXPORT NBCoreTargets
+        LIBRARY DESTINATION lib
+        ARCHIVE DESTINATION lib
+        INCLUDES DESTINATION include
+    )
+    install(
+        DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/NBCore"
+        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+        FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp"
+    )
+    install(
+        EXPORT NBCoreTargets
+        DESTINATION "${CMAKE_INSTALL_PREFIX}/cmake"
+        NAMESPACE NBEngine::
+    )
+    install(FILES
+        "${CMAKE_BINARY_DIR}/cmake/NBCoreConfig.cmake"
+        "${CMAKE_BINARY_DIR}/cmake/NBCoreConfigVersion.cmake"
+        DESTINATION "${CMAKE_INSTALL_PREFIX}/CMake"
+    )
+endif()
 
 if (NB_BUILD_TESTS)
-    add_subdirectory(./tests)
+    add_subdirectory(./tests )
 endif()

engine/NBCore/DataSink.hpp

@@ -1,134 +0,0 @@
-#pragma once
-#ifndef _NB_DATASINK
-#define _NB_DATASINK
-
-#include <atomic>
-#include <thread>
-
-#include "ThreadSafeQueue.hpp"
-
-namespace nb {
-
-template<typename DataType>
-class DataSink {
-public:
-    DataSink(const DataSink&) = delete;
-    DataSink(DataSink&&) = delete;
-    DataSink& operator=(const DataSink&) = delete;
-
-    virtual bool isRunning() const noexcept {
-        return _running;
-    }
-    virtual bool stop() noexcept = 0;
-    virtual bool run() = 0;
-    virtual bool in(const DataType&) = 0;
-    
-protected:
-    DataSink() = default;
-
-    std::atomic<bool> _running;
-};
-
-template<typename DataType, typename BufferType, typename ProcessorType>
-class BufferedDataProcessor : public DataSink<DataType> {
-    using Base = DataSink<DataType>;
-public:
-    using Base::Base;
-
-    virtual bool stop() noexcept override { return type_ptr->stop(); }
-    virtual bool run() override { return type_ptr->run(); }
-    virtual bool in(const DataType& val) override { return type_ptr->in(val); }
-
-protected:
-    unsigned int count() const {
-        return type_ptr->count();
-    }
-    void push(const DataType& val) {
-        type_ptr->push(val);
-    }
-    DataType pop() {
-        return type_ptr->pop();
-    }
-    void flush() {
-        type_ptr->flush();
-    }
-    void clear() {
-        type_ptr->clear();
-    }
-    bool process(const DataType& val) {
-        return type_ptr->process(val);
-    }
-
-    using Base::_running;
-
-    BufferType _buffer;
-
-private:
-    ProcessorType* const type_ptr = static_cast<ProcessorType*>(this);
-
-};
-
-template<typename DataType, typename ProcessorType>
-class MultithreadedDataProcessor 
-: public BufferedDataProcessor<DataType, ThreadsafeQueue<DataType>, ProcessorType> {
-    using Base = BufferedDataProcessor<DataType, ThreadsafeQueue<DataType>, ProcessorType>;
-    public:
-    ~MultithreadedDataProcessor() { type_ptr->stop(); }
-
-    bool isRunning() const noexcept override {
-        return this->_running;
-    }
-    bool run() override {
-        if (!type_ptr->isRunning()) {
-            this->_running = true;
-            _runningThread = std::make_shared<std::thread>([&]{
-                while(type_ptr->isRunning()) {
-                    flush();
-                }
-            });
-        }
-        return this->isRunning();
-    }
-    bool stop() noexcept override {
-        if (type_ptr->isRunning()) {
-            this->_running = false;
-            _runningThread->join();
-            _runningThread = nullptr;
-        }
-        return !type_ptr->isRunning();
-    }
-
-    protected:
-    using Base::Base;
-
-    unsigned int count() const {
-        return this->_buffer.size();
-    }
-    void push(const DataType& val) {
-        this->_buffer.push(val);
-    };
-    DataType pop() {
-        std::shared_ptr<DataType> event;
-        this->_buffer.pop(event);
-        this->process(*event);
-        return *event;
-    }
-    void flush() {
-        while(type_ptr->count()) {
-            pop();
-        }
-    }
-    void clear() {
-        this->_buffer.empty();
-    }
-
-    std::shared_ptr<std::thread> _runningThread;
-
-private:
-    ProcessorType* type_ptr = static_cast<ProcessorType*>(this);
-
-};
-
-
-} // namespace nb
-#endif // _NB_DATASINK

engine/NBCore/Errors.hpp

@@ -1,43 +0,0 @@
-#pragma once
-#ifndef _NB_ERROR
-#define _NB_ERROR
-
-#include "ErrorsImpl.hpp"
-#include "Logger.hpp"
-
-namespace nb {
-
-#ifdef _NB_AUTOLOG
-    #ifdef _NB_CODE_ERROR_LOCATIONS
-        #ifndef LOG
-            #define LOG(args...) nb::logger.log(args, __FILE__, __LINE__)
-        #endif // LOG
-        #ifndef WARN
-            #define WARN(args...) nb::logger.warn(args, __FILE__, __LINE__)
-        #endif // WARN
-        #ifndef ERROR
-            #define ERROR(args...) nb::logger.error(args, __FILE__, __LINE__)
-        #endif // ERROR
-    #else
-        #ifndef LOG
-            #define LOG(args...) nb::logger.log(args)
-        #endif // LOG
-        #ifndef WARN
-            #define WARN(args...) nb::logger.warn(args)
-        #endif // WARN
-        #ifndef ERROR
-            #define ERROR(args...) nb::logger.error(args)
-        #endif // ERROR
-    #endif // _NB_CODE_ERROR_LOCATIONS
-#endif // _NB_AUTOLOG
-
-#ifndef THROW
-    #ifdef _NB_AUTOLOG
-        #define THROW(args...) ERROR(args); nb::logger.stop(); throw args
-    #else
-        #define THROW(args...) throw args
-    #endif // _NB_CODE_ERROR_LOCATIONS
-#endif // THROW
-} // namespace nb
-
-#endif // _NB_ERROR

engine/NBCore/Logger.hpp

@@ -1,176 +0,0 @@
-#pragma once
-#ifndef _NB_LOGGER
-#define _NB_LOGGER
-
-#include <chrono>
-#include <ostream>
-#include <thread>
-#include <unordered_map>
-#include <vector>
-
-#include "DataSink.hpp"
-#include "ErrorsImpl.hpp"
-#include "Processes.hpp"
-#include "ThreadSafeQueue.hpp"
-#include "TypeTraits.hpp"
-
-namespace nb {
-
-class ErrorBase;
-
-typedef std::chrono::time_point<
-    std::chrono::system_clock,
-    std::chrono::nanoseconds
-> LoggerTimePoint;
-
-typedef std::string (*LogProcessFunction)(const LoggerTimePoint&, const std::string&);
-typedef std::unordered_map<uint8_t, LogProcessFunction> LogProcessFunctionMap;
-
-template<typename LogType, typename Logger, typename ST=std::ostream*>
-class LoggerBase
-: public MultithreadedDataProcessor<LogType, Logger>{
-    using StreamType = ST;
-    using LoggerType = Logger;
-    using Base = MultithreadedDataProcessor<LogType, LoggerType>;
-
-    public:
-    bool run() override {
-        if (!static_cast<LoggerType*>(this)->isRunning()) {
-            this->_running = true;
-            this->_runningThread = std::make_shared<std::thread>([&]{
-                while(static_cast<LoggerType*>(this)->isRunning()) {
-                    static_cast<LoggerType*>(this)->flush();
-                }
-                static_cast<LoggerType*>(this)->flush();
-            });
-        }
-        return static_cast<LoggerType*>(this)->isRunning();
-    }
-    using Base::flush;
-
-    protected:
-    LoggerBase() = default;
-
-    StreamType _ostream;
-};
-
-struct LogEvent{
-    const LoggerTimePoint time;
-    const unsigned char lvl;
-    const std::string msg;
-    const std::thread::id tid;
-    const uint64_t pid;
-    const std::string file="";
-    const unsigned int line=0;
-};
-
-template <typename LT>
-class DebugLogger : public LoggerBase<LogEvent, LT, std::vector<std::ostream*>>{
-    using StreamType = std::vector<std::ostream*>;
-    using LoggerType = LT;
-    using Base = LoggerBase<LogEvent, LoggerType, StreamType>;
-public:
-
-    template<typename... ST>
-    DebugLogger(ST&... streams) : _ostream(nb::RefPackToPtrVec<std::ostream, ST...>(streams...).vec) {}
-
-    ~DebugLogger() { static_cast<LoggerType*>(this)->stop(); }
-
-    template<typename U>
-    void log(
-        U val,
-        std::string file="",
-        unsigned int line=0
-    ) { static_cast<LoggerType*>(this)->write_message(val, 0x00, file, line); }
-
-    template<typename U>
-    void warn(
-        U val,
-        uint8_t lvl=0x01,
-        std::string file="",
-        unsigned int line=0
-    ) { static_cast<LoggerType*>(this)->write_message(val, lvl, file, line); }
-
-    void error(
-        const ErrorBase& val,
-        std::string file="",
-        unsigned int line=0
-    ) {
-        static_cast<LoggerType*>(this)->write_message(val, 0xFF, file, line);
-        static_cast<LoggerType*>(this)->flush();
-    }
-
-    protected:
-    std::vector<std::ostream*> _ostream;
-    void write_message(
-        std::string msg,
-        uint8_t lvl=0x00,
-        std::string file="",
-        unsigned int line=0
-    ) {
-        static_cast<LoggerType*>(this)->push(LogEvent{
-            std::chrono::system_clock::now(),
-            lvl,
-            msg,
-            std::this_thread::get_id(),
-            GetPID(),
-            file,
-            line
-        });
-    }
-
-    template <size_t N>
-    void write_message(
-        char const(&msg) [N],
-        uint8_t lvl=0x00,
-        std::string file="",
-        unsigned int line=0
-    ) {
-        static_cast<LoggerType*>(this)->write_message(std::string(msg), lvl, file, line);
-    }
-
-    void write_message(
-        const ErrorBase& err,
-        uint8_t lvl=0x00,
-        std::string file="",
-        unsigned int line=0
-    ) {
-        static_cast<LoggerType*>(this)->write_message(err.what(), lvl, file, line);
-    }
-
-};
-
-class DefaultDebugLogger : public DebugLogger<DefaultDebugLogger> {
-    using LoggerType = DefaultDebugLogger;
-    using Base = DebugLogger<DefaultDebugLogger>;
-    
-    template <typename... Ts>
-    struct LogRow;
-
-    public:
-    using Base::Base;
-
-    ~DefaultDebugLogger() { stop(); }
-
-    friend class BufferedDataProcessor<LogEvent, ThreadsafeQueue<LogEvent>, DefaultDebugLogger>;
-
-    template <typename STR, typename... Ts>
-    friend STR& operator<<(STR&, const DefaultDebugLogger::LogRow<Ts...>&);
-
-protected:
-    using Base::_ostream;
-
-    bool process(const LogEvent& msg);
-};  
-
-extern const bool LOGGER_RUNNING;
-
-#ifndef _NB_NO_LOGGER
-extern DefaultDebugLogger logger;
-#endif // _NB_NO_LOGGER
-
-// Taking Charge of Adult ADHD by Russell Barkley
-
-} // namespace nb
-
-#endif // _NB_LOGGER

engine/NBCore/NBCoreConfig.cmake.in

@@ -0,0 +1,2 @@
+@PACKAGE_INIT@
+include("${CMAKE_CURRENT_LIST_DIR}/NBCoreTargets.cmake")

engine/NBCore/include/NBCore/DataSink.hpp

@@ -0,0 +1,184 @@
+#pragma once
+#ifndef _NB_DATASINK
+#define _NB_DATASINK
+
+#include <atomic>
+#include <thread>
+#include <utility>
+
+#include <NBCore/ThreadSafeQueue.hpp>
+
+namespace nb {
+
+template<typename DataType>
+class DataSink {
+    public:
+    DataSink(const DataSink&) = delete;
+    DataSink(DataSink&&) = delete;
+    DataSink& operator=(const DataSink&) = delete;
+
+    virtual bool isRunning() const noexcept {
+        std::atomic_thread_fence(std::memory_order_acquire);
+        return _running.load(std::memory_order_acquire);
+    }
+    virtual bool stop() noexcept = 0;
+    virtual bool run() = 0;
+    virtual bool in(const DataType&) = 0;
+    
+    protected:
+    DataSink() {
+        _running.store(false, std::memory_order_release);
+    }
+
+    std::atomic<bool> _running;
+};
+
+template<typename DataType, typename SinkTypes=DataSink<DataType>>
+class MultiSink : public DataSink<DataType> {
+    protected:
+    using Base = DataSink<DataType>;
+    using SinkPtr = std::shared_ptr<SinkTypes>;
+    using Base::_running;
+    std::vector<SinkPtr> _sinks;
+
+    public:
+    MultiSink(std::vector<SinkPtr> sinks={}) : _sinks(sinks) {}
+    virtual void addSink(SinkPtr sink) {
+        _sinks.push_back(sink);
+    }
+    virtual std::vector<SinkPtr>& getSinks() { return _sinks; }
+    bool isRunning() const noexcept override {
+        return Base::isRunning();
+    }
+    bool stop() noexcept override {
+        _running.store(false, std::memory_order_release);
+        for (auto& sink : _sinks) {
+            sink->stop();
+        }
+        return isRunning();
+    }
+    bool run() override {
+        _running.store(true, std::memory_order_release);
+        for (auto& sink : _sinks) {
+            sink->run();
+        }
+        return isRunning();
+    }
+    bool in(const DataType& data) override {
+        if (isRunning()) {
+            bool success = true;
+            for (auto& sink : _sinks) {
+                success &= sink->in(data);
+            }
+            return success;
+        }
+        return false;
+    }
+};
+
+template<typename DataType, typename BufferType, typename ProcessorType>
+class BufferedDataProcessor : public DataSink<DataType> {
+    private:
+    ProcessorType* const type_ptr = static_cast<ProcessorType*>(this);
+
+    protected:
+    using Base = DataSink<DataType>;
+    using Base::_running;
+    BufferType _buffer;
+    virtual unsigned int count() const {
+        return type_ptr->count();
+    }
+    virtual bool pop(std::shared_ptr<DataType> ret) {
+        return type_ptr->pop(ret);
+    }
+    virtual void flush() {
+        type_ptr->flush();
+    }
+    virtual void clear() {
+        type_ptr->clear();
+    }
+    virtual bool process(const DataType& val) = 0;
+
+    public:
+    using Base::Base;
+    virtual bool stop() noexcept override { return type_ptr->stop(); }
+    virtual bool run() override { return type_ptr->run(); }
+    virtual bool in(const DataType& val) override { return type_ptr->in(val); }
+
+};
+
+template<typename DataType, typename ProcessorType>
+class MultithreadedDataProcessor 
+: public BufferedDataProcessor<DataType, ThreadsafeQueue<DataType>, ProcessorType> {
+    private:
+    ProcessorType* const type_ptr = static_cast<ProcessorType*>(this);
+    std::mutex _pause;
+
+    protected:
+    using Base = BufferedDataProcessor<DataType, ThreadsafeQueue<DataType>, ProcessorType>;
+    using Base::Base;
+    using Base::process;
+    using Base::_running;
+    std::shared_ptr<std::thread> _runningThread;
+    virtual unsigned int count() const override {
+        return type_ptr->_buffer.size();
+    }
+    virtual bool pop(std::shared_ptr<DataType> ret=nullptr) override {
+        type_ptr->_buffer.pop(ret);
+        return this->process(*ret);
+    }
+    virtual bool popBlock(std::shared_ptr<DataType> ret=nullptr) {
+        ret = type_ptr->_buffer.popBlock();
+        return this->process(*ret);
+    }
+    virtual void flush() override {
+        while(type_ptr->count()) {
+            type_ptr->pop();
+        }
+    }
+    virtual void clear() override {
+        type_ptr->_buffer.empty();
+    }
+    virtual std::unique_lock<std::mutex> pause() {
+        return std::move(std::unique_lock<std::mutex>(_pause));
+    }
+
+    public:
+    using Base::isRunning;
+    virtual ~MultithreadedDataProcessor() { type_ptr->stop(); }
+
+    bool run() override {
+        if (!type_ptr->isRunning()) {
+            _running.store(true, std::memory_order_release);
+            _runningThread = std::make_shared<std::thread>([&]{
+                while(type_ptr->isRunning()) {
+                    std::lock_guard<std::mutex> lock(_pause);
+                    type_ptr->flush();
+                }
+                type_ptr->flush();
+                type_ptr->stop();
+            });
+        }
+        return type_ptr->isRunning();
+    }
+    bool stop() noexcept override {
+        if (type_ptr->isRunning()) {
+            _running.store(false, std::memory_order_release);
+            if (_runningThread) {
+                _runningThread->join();
+                _runningThread = nullptr;
+            }
+            type_ptr->flush();
+        }
+        return !type_ptr->isRunning();
+    }
+    bool in(const DataType& val) override {
+        type_ptr->_buffer.push(val);
+        return type_ptr->isRunning();
+    }
+
+};
+
+
+} // namespace nb
+#endif // _NB_DATASINK

engine/NBCore/include/NBCore/Errors.hpp

@@ -0,0 +1,65 @@
+#pragma once
+#ifndef _NB_ERROR
+#define _NB_ERROR
+
+#include <NBCore/ErrorsImpl.hpp>
+#include <NBCore/Logger.hpp>
+
+namespace nb {
+
+#ifdef _NB_AUTOLOG
+    #ifndef LOG_W_CODE_LOC
+        #define LOG_W_CODE_LOC(file, line, args...) nb::logger.msg(args, file, line)
+    #endif // LOG_W_CODE_LOC
+    #ifndef WARN_W_CODE_LOC
+        #define WARN_W_CODE_LOC(file, line, args...) nb::logger.warn(args, file, line)
+    #endif // WARN_W_CODE_LOC
+    #ifndef ERROR_W_CODE_LOC
+        #define ERROR_W_CODE_LOC(file, line, args...) nb::logger.error(args, file, line)
+    #endif // ERROR_W_CODE_LOC
+    #ifdef _NB_CODE_ERROR_LOCATIONS
+        #ifndef LOG
+            #define LOG(arg) LOG_W_CODE_LOC(__FILE__, __LINE__, arg)
+        #endif // LOG
+        #ifndef WARN
+            #define WARN(args...) WARN_W_CODE_LOC(__FILE__, __LINE__, args)
+        #endif // WARN
+        #ifndef ERROR
+            #define ERROR(arg) ERROR_W_CODE_LOC(__FILE__, __LINE__, arg)
+        #endif // ERROR
+    #else
+        #ifndef LOG
+            #define LOG(args) nb::logger.msg(args)
+        #endif // LOG
+        #ifndef WARN
+            #define WARN(args...) nb::logger.warn(args)
+        #endif // WARN
+        #ifndef ERROR
+            #define ERROR(args) nb::logger.error(args)
+        #endif // ERROR
+    #endif // _NB_CODE_ERROR_LOCATIONS
+    #ifndef THROW_W_CODE_LOC
+        #define THROW_W_CODE_LOC(file, line, args...) ERROR_W_CODE_LOC(file, line, args); throw args
+    #endif // THROW_W_CODE_LOC
+#else
+    #ifndef LOG
+        #define LOG(args)
+    #endif // LOG
+    #ifndef WARN
+        #define WARN(args...)
+    #endif // WARN
+    #ifndef ERROR
+        #define ERROR(args)
+    #endif // ERROR    
+#endif // _NB_AUTOLOG
+
+#ifndef THROW
+    #ifdef _NB_AUTOLOG
+        #define THROW(args...) THROW_W_CODE_LOC(__FILE__, __LINE__, args)
+    #else
+        #define THROW(args...) throw args
+    #endif // _NB_AUTOLOG
+#endif // THROW
+} // namespace nb
+
+#endif // _NB_ERROR

engine/NBCore/include/NBCore/ErrorsImpl.hpp

@@ -6,17 +6,13 @@
 #include <memory>
 #include <string>
 #include <type_traits>
-#include <unordered_map>
 
-#include "StringUtils.hpp"
+#include <NBCore/StringUtils.hpp>
-#include "TypeTraits.hpp"
+#include <NBCore/Utils.hpp>
 
 namespace nb {
 
-typedef std::unordered_map<unsigned int, std::string> ErrorCodeMap;
+using ErrorCodeMap = ConstantMap<unsigned int, std::string>;
-
-template <class ErrorType=NoneType>
-class Error;
 
 class ErrorBase {
     protected:
@@ -32,11 +28,11 @@ class ErrorBase {
     virtual std::string what() const noexcept {
         std::string ret = msg;
         if (trace) {
-            std::string trace_msg = msg;
+            std::string trace_msg = trace->what();
-            ret += nb::NEWLINE + indent_strblock(
+            ret += NEWLINE + indent_strblock(
                 trace_msg,
-                nb::TABOVER,
+                TABOVER,
-                nb::TABOVER+"Trace: "
+                TABOVER+"Trace: "
             );
         }
         return ret;
@@ -48,15 +44,15 @@ class ErrorBase {
         std::string msg_,
         std::string type_,
         std::shared_ptr<ErrorBase> trace_
-) noexcept :
+    ) noexcept :
         code(code_),
         msg(msg_),
         type(type_),
         trace{trace_}
-{}
+    {}
 };
 
-template <class ErrorType>
+template <class ErrorType=NoneType>
 class Error : public ErrorBase {
     private:
     void inline check_asserts() {
@@ -73,16 +69,15 @@ class Error : public ErrorBase {
         );
     }
     
-    protected:
+    public:
     using ErrorBase::ErrorBase;
 
-    public:
     Error(
         unsigned int code_,
         const ErrorBase& trace_
     ) noexcept : ErrorBase(
         code_, 
-        ErrorType::ErrorMessages.at(code_),
+        ErrorType::ErrorMessages[code_],
         ErrorType::type,
         std::make_shared<ErrorBase>(trace_)
     ) { check_asserts(); }
@@ -91,7 +86,7 @@ class Error : public ErrorBase {
         std::string msg_,
         const ErrorBase& trace_
     ) noexcept : ErrorBase(
-        0, 
+        ErrorType::Codes::UNDEFINED, 
         msg_,
         ErrorType::type,
         std::make_shared<ErrorBase>(trace_)
@@ -99,13 +94,13 @@ class Error : public ErrorBase {
 
     Error(unsigned int code_) noexcept : ErrorBase(
         code_, 
-        ErrorType::ErrorMessages.at(code_),
+        ErrorType::ErrorMessages[code_],
         ErrorType::type,
         nullptr
     ) { check_asserts(); }
 
     Error(std::string msg_) noexcept : ErrorBase(
-        0, 
+        ErrorType::Codes::UNDEFINED, 
         msg_,
         ErrorType::type,
         nullptr
@@ -117,14 +112,14 @@ class Error : public ErrorBase {
         const ErrorBase& trace_
     ) noexcept : ErrorBase(
         code_,
-        ErrorType::ErrorMessages.at(code_) + " (" + note_ + ")",
+        ErrorType::ErrorMessages[code_] + " (" + note_ + ")",
         ErrorType::type,
         std::make_shared<ErrorBase>(trace_)
     ) { check_asserts(); }
 
     Error(unsigned int code_, const std::string& note_) noexcept : ErrorBase(
         code_,
-        ErrorType::ErrorMessages.at(code_) + " (" + note_ + ")",
+        ErrorType::ErrorMessages[code_] + " (" + note_ + ")",
         ErrorType::type,
         nullptr
     ) { check_asserts(); }
@@ -136,40 +131,41 @@ class Error : public ErrorBase {
     using ErrorBase::type;
 };
 
-
 template<>
 class Error<NoneType> : public Error<Error<NoneType>> {
+    protected:
     using Base = Error<Error<NoneType>>;
     
     public:
+    using Base::what;
+    using Base::code;
+    using Base::trace;
     using Base::Base;
+    enum Codes : unsigned int {
+        STANDARD, UNDEFINED, OUT_OF_RANGE, VALUE_ERROR, OVERWRITE_ERROR
+    };
+    inline static const std::string type = "nb::Error";
+    inline static const ErrorCodeMap ErrorMessages = {
+        {STANDARD, "std::exception"},
+        {UNDEFINED, "Error"},
+        {OUT_OF_RANGE, "Out-of-range error"},
+        {VALUE_ERROR, "Invalid value"},
+        {OVERWRITE_ERROR, "Attempting to overwrite managed data"}
+
+    };
 
     Error(unsigned int code_=1) noexcept : Base(code_) {}
-
     Error(const std::exception& err) : Base(
-        Codes::STANDARD,
+        STANDARD,
         std::string(err.what()),
         "std::exception",
         nullptr
     ) {}
-
-    // fix
-    Error(std::string msg_) noexcept : Base(
-        Codes::UNDEFINED, 
-        msg_
-    ) {}
-
-    enum Codes : unsigned int {
-        STANDARD, UNDEFINED
-    };
-
-    using Base::what;
-    using Base::code;
-    using Base::msg;
-    using Base::trace;
-    static const std::string type;
-    static const ErrorCodeMap ErrorMessages;
 };
+
+template<typename... Args>
+Error(Args...) -> Error<NoneType>;
+
 } // namespace nb
 
 #endif // _NB_ERRORS_IMPL

engine/NBCore/include/NBCore/Logger.hpp

@@ -0,0 +1,250 @@
+#pragma once
+#ifndef _NB_LOGGER
+#define _NB_LOGGER
+
+#include <chrono>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include <NBCore/DataSink.hpp>
+#include <NBCore/ErrorsImpl.hpp>
+#include <NBCore/Printer.hpp>
+#include <NBCore/Processes.hpp>
+#include <NBCore/ThreadSafeQueue.hpp>
+#include <NBCore/TypeTraits.hpp>
+
+namespace nb {
+
+class ErrorBase;
+
+typedef std::chrono::time_point<
+    std::chrono::system_clock,
+    std::chrono::nanoseconds
+> LoggerTimePoint;
+
+typedef std::string (*LogProcessFunction)(const LoggerTimePoint&, const std::string&);
+typedef std::unordered_map<uint8_t, LogProcessFunction> LogProcessFunctionMap;
+
+template<typename LogType, typename Logger>
+class LoggerBase : public MultithreadedDataProcessor<LogType, Logger>{
+    private:
+    Logger* const type_ptr = static_cast<LoggerType*>(this);
+
+    protected:
+    using LoggerType = Logger;
+    using Base = MultithreadedDataProcessor<LogType, LoggerType>;
+    using SinkType = DataSink<LogType>;
+    using Base::process;
+    std::shared_ptr<SinkType> _logsink;
+    LoggerBase(std::shared_ptr<SinkType> sink) : _logsink(sink) {}
+
+    public:
+    using Base::flush;
+    bool run() override {
+        _logsink->run();
+        return Base::run();
+    }
+    using Base::pause;
+    bool stop() noexcept override {
+        auto ret = Base::stop();
+        _logsink->stop();
+        return ret;
+    }
+
+};
+
+struct LogEvent{
+    const LoggerTimePoint time;
+    const unsigned char lvl;
+    const std::string msg;
+    const std::thread::id tid;
+    const uint64_t pid;
+    const std::string file="";
+    const unsigned int line=0;
+};
+
+class LogEventHandler : public DataSink<LogEvent> {
+    protected:
+    using Base = DataSink<LogEvent>;
+    using Base::_running;
+    std::atomic<uint8_t> _logLevel;
+
+    public:
+    using Base::isRunning;
+    LogEventHandler(uint8_t logging_level=0x01);
+    virtual uint8_t logLevel(uint8_t);
+    virtual uint8_t logLevel() const;
+    bool stop() noexcept override;
+    bool run() override;
+};
+
+template <typename LT>
+class DebugLogger : public LoggerBase<LogEvent, LT>{
+    private:
+    LT* const type_ptr = static_cast<LT*>(this);
+
+    protected:
+    using LoggerType = LT;
+    using Base = LoggerBase<LogEvent, LoggerType>;
+    using SinkType = LogEventHandler;
+    using SinkPtr = std::shared_ptr<SinkType>;
+    using Distributor = MultiSink<LogEvent, LogEventHandler>;
+    using Base::_logsink;
+    using Base::process;
+    std::atomic<uint8_t> _loglvl;
+    virtual void write_message(
+        std::string msg,
+        uint8_t lvl=0x00,
+        std::string file="",
+        unsigned int line=0
+    ) {
+        type_ptr->in(LogEvent{
+            std::chrono::system_clock::now(),
+            lvl,
+            msg,
+            std::this_thread::get_id(),
+            GetPID(),
+            file,
+            line
+        });
+    }
+    template <size_t N>
+    void write_message(
+        char const(&msg) [N],
+        uint8_t lvl=0x00,
+        std::string file="",
+        unsigned int line=0
+    ) {
+        this->write_message(std::string(msg), lvl, file, line);
+    }
+    void write_message(
+        const ErrorBase& err,
+        uint8_t lvl=0x00,
+        std::string file="",
+        unsigned int line=0
+    ) {
+        this->write_message(err.what(), lvl, file, line);
+    }
+    template<typename U>
+    std::enable_if_t<std::is_integral_v<U>, void> write_message(
+        const U& val,
+        uint8_t lvl=0x00,
+        std::string file="",
+        unsigned int line=0
+    ) {
+        this->write_message(std::to_string(val), lvl, file, line);
+    }
+
+    public:
+    DebugLogger(std::vector<SinkPtr> sinks={}) : Base(
+        std::static_pointer_cast<DataSink<LogEvent>>(std::make_shared<Distributor>())
+    ) {
+        for (auto sink : sinks) {
+            addLogHandler(sink);
+        }
+    }
+    ~DebugLogger() { static_cast<LoggerType*>(this)->stop(); }
+    void addLogHandler(SinkPtr sink) {
+        auto multsink = std::static_pointer_cast<Distributor>(_logsink);
+        multsink->addSink(sink);
+    }
+    uint8_t minimalLogLevel() const {
+        return _loglvl.load(std::memory_order_acquire);
+    }
+    uint8_t minimalLogLevel(uint8_t level) {
+        _loglvl.store(level, std::memory_order_release);
+        auto multsink = std::static_pointer_cast<Distributor>(_logsink);
+        for (auto& sink : multsink->getSinks()) {
+            if (sink->logLevel() < level) {
+                sink->logLevel(level);
+            }
+        }
+        return minimalLogLevel();
+    }
+
+    template<typename U>
+    void msg(
+        U val,
+        std::string file="",
+        unsigned int line=0
+    ) { this->write_message(val, 0x00, file, line); }
+
+    template<typename U>
+    void warn(
+        U val,
+        uint8_t lvl=0x01,
+        std::string file="",
+        unsigned int line=0
+    ) { this->write_message(val, lvl, file, line); }
+
+    void error(
+        const ErrorBase& val,
+        std::string file="",
+        unsigned int line=0
+    ) {
+        this->write_message(val, 0xFF, file, line);
+        auto lock = this->pause();
+        this->flush();
+    }
+
+    void error(
+        const std::string& val,
+        std::string file="",
+        unsigned int line=0
+    ) {
+        this->write_message(Error<>(val), 0xFF, file, line);
+        auto lock = this->pause();
+        this->flush();
+    }
+};
+
+class DefaultTerminalLogEventPrinter : public LogEventHandler {
+    protected:
+    using Base = LogEventHandler;
+    using Base::_running;
+
+    public:
+    using Base::isRunning;
+    using Base::logLevel;
+    using Base::stop;
+    using Base::run;
+    using Base::Base;
+    bool in(const LogEvent&) override;
+};
+
+class DefaultDebugLogger : public DebugLogger<DefaultDebugLogger> {
+    protected:
+    using LoggerType = DefaultDebugLogger;
+    using Base = DebugLogger<DefaultDebugLogger>;
+    using MultiLogSink = MultiSink<LogEvent>;
+    using SinkPtr = std::shared_ptr<LogEventHandler>;
+    using Base::_logsink;
+    using Base::write_message;
+    virtual bool process(const LogEvent& msg) override;
+        
+    public:
+    using Base::Base;
+    using Base::msg;
+    using Base::warn;
+    using Base::error;
+    using Base::addLogHandler;
+    using Base::minimalLogLevel;
+    DefaultDebugLogger(std::vector<SinkPtr> sinks={}) : Base(sinks) {}
+    ~DefaultDebugLogger() { stop(); }
+
+    friend class BufferedDataProcessor<LogEvent, ThreadsafeQueue<LogEvent>, DefaultDebugLogger>;
+};  
+
+extern const bool LOGGER_RUNNING;
+
+extern const bool LOGGER_RUNNING;
+#ifdef _NB_AUTOLOG
+extern DefaultDebugLogger logger;
+#endif // _NB_AUTOLOG
+
+// Taking Charge of Adult ADHD by Russell Barkley
+
+} // namespace nb
+
+#endif // _NB_LOGGER

engine/NBCore/include/NBCore/Printer.hpp

@@ -0,0 +1,52 @@
+#pragma once
+#ifndef _NB_PRINTER
+#define _NB_PRINTER
+
+#include <condition_variable>
+#include <iostream>
+#include <memory>
+#include <mutex>
+
+namespace nb {
+
+template<typename STREAM, typename PrinterType>
+class Printer {
+    private:
+    PrinterType* const type_ptr = static_cast<PrinterType*>(this);
+
+    protected:
+    STREAM& _stream;
+    Printer(STREAM* const stream_) : _stream(stream_) {}
+
+    public:
+    template<typename T>
+    PrinterType& operator<<(const T& val_) {
+        (*type_ptr) << val_;
+        return type_ptr;
+    }
+
+};
+
+class Terminal : public Printer<decltype(std::cout), Terminal> {
+    private:
+    Terminal* const type_ptr = static_cast<Terminal*>(this);
+    using MutexLock = std::lock_guard<std::mutex>;
+
+    protected:
+    using Base = Printer<decltype(std::cout), Terminal>;
+    using Base::_stream;
+    std::mutex _mutex;
+
+    public:
+    using Base::Base;
+
+    template<typename T>
+    Terminal& operator<<(const T& val_) {
+        MutexLock lock(_mutex);
+        _stream << val_;
+        return *type_ptr;
+    }
+};
+
+} // namespace nb
+#endif // _NB_PRINTER

engine/NBCore/include/NBCore/StringUtils.hpp

@@ -2,43 +2,24 @@
 #ifndef _NB_STRING_UTILS
 #define _NB_STRING_UTILS
 
-#include <iostream>
 #include <string>
 #include <string_view>
 
-#include "TypeTraits.hpp"
+#include <NBCore/TypeTraits.hpp>
 
 namespace nb {
 
 #ifdef _NB_TARGET_WINDOWS
-    const std::string NEWLINE = "\n";
+    inline static const std::string NEWLINE = "\n";
-    const std::wstring WNEWLINE = L"\n";
+    inline static const std::wstring WNEWLINE = L"\n";
 #endif // _NB_TARGET_WINDOWS
 #ifdef _NB_TARGET_LINUX
-    const std::string NEWLINE = "\n";
+    inline const std::string NEWLINE = "\n";
-    const std::wstring WNEWLINE = L"\n";
+    inline const std::wstring WNEWLINE = L"\n";
 #endif // _NB_TARGET_LINUX
 
 const std::string TABOVER = "   ";
 
-// std::wstring str_to_wstr(std::string in);
-
-// std::string wstr_to_str(std::wstring in);
-
-template <typename Stream, typename... Args>
-void stream(const Stream& s, Args&&... args);
-
-template <typename Stream, typename... Args>
-void stream(const Stream& s, Args&&... args) {
-    (s << ... << args);
-}
-
-template<typename... Args>
-void term(Args&&... args) { stream(std::cout, args..., nb::NEWLINE); }
-
-template<typename... Args>
-void wterm(Args&&... args) { stream(std::wcout, args..., nb::WNEWLINE); }
-
 template <typename T = char>
 std::basic_string<T> find_and_replace(
     ExplicitType_t<std::basic_string<T>> original,

engine/NBCore/include/NBCore/TypeTraits.hpp

@@ -33,6 +33,9 @@ namespace detail {
 
 struct NoneType{};
 
+template<typename T, unsigned int Arg>
+using Const_t = std::integral_constant<T, Arg>;
+
 template <
     template <class...> class Op,
     class... Args
@@ -87,6 +90,15 @@ 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) {}
@@ -109,6 +121,41 @@ ForEach(std::tuple<Pack...>& tup, Func f, const Args& arg) {
     ForEach<N+1, Func, Args, Pack...>(tup, f, arg);
 }
 
+template<typename T, typename... Pack>
+struct Find;
+
+template<typename T, typename U, typename... Pack>
+struct Find<T, U, Pack...> {
+    protected:
+    using here = Find<T, U>;
+    static constexpr unsigned int downstream = std::conditional_t<
+        here::value,
+        Const_t<unsigned int, 0>,
+        Find<T, Pack...>
+    >::value;
+
+    public:
+    static constexpr unsigned int value = std::conditional_t<
+        here::value,
+        Const_t<unsigned int, 1>,
+        std::conditional_t<
+            downstream,
+            Const_t<unsigned int, 1+downstream>,
+            Const_t<unsigned int, 0>
+        >
+    >::value;
+};
+
+template<typename T, typename U>
+struct Find<T, U> {
+    public:
+    static constexpr unsigned int value = std::conditional_t<
+        std::is_base_of<T, U>::value,
+        std::integral_constant<unsigned int, 1>,
+        std::integral_constant<unsigned int, 0>
+    >::value;
+};
+
 template <typename T, typename Pack1, typename... Pack>
 struct RefPackToPtrVec {
     RefPackToPtrVec(std::vector<T*> _vec, Pack1& p1, Pack&... packs)

engine/NBCore/include/NBCore/Utils.hpp

@@ -2,13 +2,27 @@
 #ifndef _NB_CORE_TYPES
 #define _NB_CORE_TYPES
 
-#include <mutex>
+#include <exception>
+#include <memory>
+#include <unordered_map>
 #include <vector>
 
-#include "Errors.hpp"
+// #include <NBCore/Errors.hpp>
 
 namespace nb {
 
+template<typename A, typename B>
+class ConstantMap : public std::unordered_map<A, B> {
+    using Base = std::unordered_map<A, B>;
+
+    public:
+    using Base::Base;
+    using Base::at;
+    const B& operator[](const A& key) const {
+        return at(key);
+    }
+};
+
 template<typename T>
 using SharedVector = std::vector<std::shared_ptr<T>>;
 
@@ -17,7 +31,7 @@ using RValueVector = std::vector<T&&>;
 
 using ByteVector = std::vector<uint8_t>;
 
-class ObjectManagerError : public Error<ObjectManagerError> {
+/* class ObjectManagerError : public Error<ObjectManagerError> {
     using Base = Error<ObjectManagerError>;
 
     public:
@@ -29,7 +43,7 @@ class ObjectManagerError : public Error<ObjectManagerError> {
 
     static const std::string type;
     static const ErrorCodeMap ErrorMessages;
-};
+}; */
 
 template<typename T>
 ByteVector vectorToBytes(const std::vector<T>& vec) {
@@ -54,7 +68,10 @@ ByteVector concatVectorBytes(const std::vector<T>& vec1, const std::vector<S>& v
 template<typename T>
 std::vector<T> bytesToVector(const ByteVector& vec) {
     if (vec.size() % sizeof(T) != 0) {
-        THROW(std::runtime_error("Data size does not align to std::vector<" + std::string(typeid(T).name()) + ">."));
+/*         THROW(Error<NoneType>(
+            std::runtime_error("Data size does not align to std::vector<" + std::string(typeid(T).name()) + ">.")
+        )); */
+        throw "byyyyeeee";
     }
     unsigned int num_elmts = vec.size() / sizeof(T);
     std::vector<T> ret(num_elmts);
@@ -63,7 +80,7 @@ std::vector<T> bytesToVector(const ByteVector& vec) {
     return ret;
 }
 
-template <typename T>
+/* template <typename T>
 class ThreadsafeObjectLock;
 
 template <typename T>
@@ -112,7 +129,7 @@ class ThreadsafeObjectLock {
         _manager->_mutex.lock();
     }
     ThreadsafeObject<T>* const _manager;
-};
+}; */
 
 } // namespace nb
 #endif // _NB_CORE_TYPES

engine/NBCore/src/ErrorsImpl.cpp

@@ -1,16 +1,11 @@
-#include "ErrorsImpl.hpp"
+#include <NBCore/ErrorsImpl.hpp>
 
 namespace nb {
 
-const std::string Error<>::type =  "nb::Error";
-const ErrorCodeMap Error<>::ErrorMessages = {
-    {Error::Codes::STANDARD, "std::exception"},
-    {Error::Codes::UNDEFINED, "Error"}
-};
-
 //ErrorBase::
-
 ErrorBase::ErrorBase(const std::exception& exception_) noexcept 
-: ErrorBase(Error<NoneType>(exception_)) {}
+: ErrorBase(Error(exception_)) {}
+
+} // namespace nb
+
 
-}

engine/NBCore/src/Logger.cpp

@@ -1,38 +1,82 @@
 #include <iostream>
+#include <sstream>
 
-#include "Logger.hpp"
+#include <NBCore/Logger.hpp>
-#include "StringUtils.hpp"
+#include <NBCore/StringUtils.hpp>
 
 namespace nb {
 
-#ifndef _NB_NO_LOGGER
+static bool RUN_LOGGER(nb::DefaultDebugLogger& logger_) {
-nb::DefaultDebugLogger logger(std::cout);
+    logger_.run();
-#endif // _NB_NO_LOGGER
+    return logger_.isRunning();
+}
 
-bool nb::DefaultDebugLogger::process(const LogEvent& msg) {
+#ifdef _NB_AUTOLOG
+DefaultDebugLogger logger({std::static_pointer_cast<LogEventHandler>(
+    std::make_shared<DefaultTerminalLogEventPrinter>(0x0)
+)});
+const bool LOGGER_RUNNING = RUN_LOGGER(logger);
+#else
+const bool LOGGER_RUNNING = false;
+#endif // _NB_AUTOLOG
+
+// class LogEventHandler
+
+LogEventHandler::LogEventHandler(uint8_t logging_level) {
+    _logLevel.store(logging_level, std::memory_order_release);
+}
+
+bool LogEventHandler::stop() noexcept {
+    _running.store(false, std::memory_order_release);
+    return isRunning();
+}
+
+bool LogEventHandler::run() {
+    _running.store(true, std::memory_order_release);
+    return isRunning();
+}
+
+uint8_t LogEventHandler::logLevel(uint8_t val) {
+    _logLevel.store(val, std::memory_order_release);
+    return logLevel();
+} 
+uint8_t LogEventHandler::logLevel() const {
+    return _logLevel.load();
+}
+
+// class DefaultTerminalLogEventPrinter
+
+bool DefaultTerminalLogEventPrinter::in(const LogEvent& msg) {
+    if (!isRunning()) {
+        return false;
+    }
+    if (msg.lvl < logLevel()) {
+        return false;
+    }
     constexpr size_t level_field_width = 5;
     constexpr size_t msg_prompt_length = level_field_width+7;
-    for (const auto os : this->_ostream) {
+    std::stringstream formatted_stream;
-        *os << "[";
+    formatted_stream << "[";
-        os->width(level_field_width);
+    formatted_stream.width(level_field_width);
-        *os << std::to_string(msg.lvl) << "] :: ";
+    formatted_stream << std::to_string(msg.lvl) << "] :: ";
     std::string fileloc="";
     if (!msg.file.empty()) {
         fileloc += "(" + msg.file + ":" + std::to_string(msg.line) + ") - ";
     }
-        *os << indent_strblock(
+    formatted_stream << indent_strblock(
         fileloc + msg.msg,
         std::string(20 - msg_prompt_length, ' '),
         ""
     ) << nb::NEWLINE;
-    }
+    std::string formatted_string = formatted_stream.str();
+    std::cout << formatted_string << std::flush;
     return true;
 }
 
-static bool RUN_LOGGER(nb::DefaultDebugLogger& log) {
+// class DefaultDebugLogger
-    return log.run();
+
+bool DefaultDebugLogger::process(const LogEvent& msg) {
+    return _logsink->in(msg);
 }
 
-const bool LOGGER_RUNNING = RUN_LOGGER(logger);
-
 } // namespace nb

engine/NBCore/src/Processes.cpp

@@ -6,7 +6,7 @@
 #include <unistd.h>
 #endif // _NB_TARGET_LINUX
 
-#include "Processes.hpp"
+#include <NBCore/Processes.hpp>
 
 namespace nb {
 

engine/NBCore/src/StringUtils.cpp

@@ -1,4 +1,4 @@
-#include "StringUtils.hpp"
+#include <NBCore/StringUtils.hpp>
 
 /* std::string nb::wstr_to_str(std::wstring in) {
     std::size_t wstrlen = in.length();

engine/NBCore/src/Utils.cpp

@@ -1,8 +1,8 @@
-#include "Utils.hpp"
+#include <NBCore/Utils.hpp>
 
 namespace nb {
 
-using ObjectManagerCodes = ObjectManagerError::Codes;
+/* using ObjectManagerCodes = ObjectManagerError::Codes;
 const std::string ObjectManagerError::type = "nb::ObjectManagerError";
 const ErrorCodeMap ObjectManagerError::ErrorMessages({
     {ObjectManagerCodes::UNDEFINED, "Error"},
@@ -22,6 +22,6 @@ const ErrorCodeMap ObjectManagerError::ErrorMessages({
         ObjectManagerCodes::BAD_THREAD,
         "Attempting operation from a bad thread"
     }
-});
+}); */
 
 }; // namespace nb

engine/NBCore/tests/testErrors.cpp

@@ -1,10 +1,10 @@
 #define CODE_ERROR_LOCATIONS
 
 #include <gtest/gtest.h>
-
-#include "Errors.hpp"
 #include <string>
 
+#include <NBCore/Errors.hpp>
+
 using namespace nb;
 
 class TestError : public Error<TestError> {

engine/NBCore/tests/testLogger.cpp

@@ -1,7 +1,8 @@
+#define _NB_AUTOLOG
 #include <exception>
 
-#include "Errors.hpp"
+#include <NBCore/Errors.hpp>
-#include "Logger.hpp"
+#include <NBCore/Logger.hpp>
 
 class TestError : public nb::Error<TestError> {
     using Base = Error<TestError>;
@@ -29,17 +30,19 @@ const nb::ErrorCodeMap TestError::ErrorMessages{
 };
 
 int main() {
-    nb::logger.log("Whoop!");
+    while(!nb::LOGGER_RUNNING) {}
+    nb::logger.minimalLogLevel(0x0);
+    nb::logger.msg("Whoop!");
     try {
         THROW(TestError(0, TestError(1, TestError(2, TestError(3, TestError(2))))));
     } catch (TestError e){
-        nb::logger.log("nb::Error was thrown!");
+        nb::logger.msg("nb::Error was thrown!");
     }
 
     try {
         THROW(std::exception());
     } catch (std::exception e){
-        nb::logger.log("std::exception was thrown!");
+        nb::logger.msg("std::exception was thrown!");
     }
     ERROR("hello there!");
     return 0;

engine/NBCore/tests/testProcesses.cpp

@@ -1,7 +1,7 @@
 #define CODE_ERROR_LOCATIONS
 
 #include <gtest/gtest.h>
-#include "Processes.hpp"
+#include <NBCore/Processes.hpp>
 #include <Windows.h>
 
 TEST(ProcessesTest, GetPID) {

engine/NBCore/tests/testUtils.cpp

@@ -3,8 +3,8 @@
 #include <gtest/gtest.h>
 
 #include <string>
-#include "TypeTraits.hpp"
+#include <NBCore/TypeTraits.hpp>
-#include "StringUtils.hpp"
+#include <NBCore/StringUtils.hpp>
 
 namespace nb {
 

engine/NBEvents/src/Events.cpp

@@ -1,4 +1,4 @@
-#include "Events.hpp"
+#include <NBCore/Events.hpp>
 
 namespace NB {
 

engine/NBGraphics/Buffers.hpp

@@ -4,238 +4,362 @@
 
 #include "GLLoad.hpp"
 
-#include <memory>
 #include <string>
+#include <vector>
 
 #include <NBCore/Errors.hpp>
-#include <NBCore/Logger.hpp>
+#include <NBCore/Types.hpp>
-#include <NBCore/Utils.hpp>
-
-#include "OGLObjects.hpp"
 
 namespace nb {
     
-extern const std::unordered_map<GLenum, std::string> BufferTypes;
+typedef std::vector<unsigned char> RawVec;
 
-class BufferError : public Error<BufferError> {
+static uint8_t GLSLTypeSize(GLenum type) {
-    protected:
+    switch(type) {
-    using Base = Error<BufferError>;
+    case GL_SHORT:
+    case GL_UNSIGNED_SHORT:
+    case GL_HALF_FLOAT:
+        return 2;
+        break;
+    case GL_INT:
+    case GL_UNSIGNED_INT:
+    case GL_FLOAT:
+        return 4;
+        break;
+    case GL_DOUBLE:
+        return 8;
+        break;
+    default:
+        return 1;
+        break;
+    }
+}
+
+struct VertexAttributePointer {
+    GLuint buffer = 0;
+    int32_t offset = 0;
+    GLsizei stride = -1;
+    GLuint divisor = 0;
+};
+
+struct VertexAttribute {
+    GLint GLSLSize;
+    GLenum GLSLType;
+    GLboolean GLSLNormalization;
+    VertexAttributePointer ptr;
+};
+
+static bool isIndexInVertexAttribute(int i, const VertexAttribute& va) {
+    if ((i -= va.ptr.offset) < 0) { return false; }
+    return (i%va.ptr.stride) < GLSLTypeSize(va.GLSLType) * va.GLSLSize;
+}
+
+typedef std::vector<VertexAttribute> VertexAttributeList;
+
+template<typename T>
+RawVec vectorToRaw(const std::vector<T>& vec) {
+    unsigned int num_bytes = vec.size() * sizeof(T);
+    RawVec ret(num_bytes);
+    memcpy(ret.data(), vec.data(), num_bytes);
+    return ret;
+}
+
+template<typename T, typename S>
+RawVec concatVectorsToRaw(const std::vector<T>& vec1, const std::vector<S>& vec2) {
+    RawVec vec1_raw = vectorToRaw<T>(vec1);
+    RawVec vec2_raw = vectorToRaw<S>(vec2);
+    unsigned int vec1_raw_size = vec1_raw.size();
+    unsigned int vec2_raw_size = vec2_raw.size();
+    RawVec ret(vec1_raw_size + vec2_raw_size);
+    memcpy(ret.data(), vec1_raw.data(), vec1_raw_size);
+    memcpy(ret.data() + vec1_raw_size, vec2_raw.data(), vec2_raw_size);
+    return ret;
+}
+
+template<typename T>
+std::vector<T> rawToVector(const RawVec& vec) {
+    if (vec.size() % sizeof(T) != 0) {
+        throw std::runtime_error("Data size does not align to std::vector<" + std::string(typeid(T).name()) + ">.");
+    }
+    unsigned int num_elmts = vec.size() / sizeof(T);
+    std::vector<T> ret(num_elmts);
+    memcpy(ret.data(), vec.data(), vec.size());
+
+    return ret;
+}
+
+class BufferError : public std::runtime_error {
+public:
+    const bool error;
+    BufferError(const std::string& msg, const std::string& file="", int line=-1) 
+        : std::runtime_error(NB::formatDebugString(msg, file, line)), error(true) {}
+    BufferError(bool isError=true) : std::runtime_error(""), error(isError) {}
+};
+
+
+template <typename ObjectType>
+class OpenGLObject {
+public:
+    OpenGLObject(OpenGLObject&&) = default;
+    OpenGLObject& operator=(OpenGLObject&&) = default;
+    ~OpenGLObject() { remove(); }
+    
+    virtual void bind() const = 0;
+    virtual void unbind() const = 0;
+    virtual bool isInitialized() const = 0;
+    GLuint id() const { return _id; }
+
+protected:
+    OpenGLObject() = default;
+    OpenGLObject(const OpenGLObject&) = delete;
+    OpenGLObject& operator=(const OpenGLObject&) = delete;
+
+    virtual void remove() const = 0;
+
+    GLuint _id;
+};
+
+class VAO : public virtual OpenGLObject<VAO> {
+public:
+    using Base = OpenGLObject<VAO>;
     using Base::Base;
 
-    public:
+    VAO() { glGenVertexArrays(1, &_id); }
-    enum Codes : unsigned int {
-        UNDEFINED,
-        DATA_OVERFLOW,
-        INVALID_BUFFER,
-        HANDLE_OVERWRITE,
-    };
-    static const std::string type;
-    static const ErrorCodeMap ErrorMessages;
-};
 
-template <typename BufferType>
+    void bind() const { glBindVertexArray(_id); }
-class Buffer : public OpenGLObject {
+    void unbind() const { glBindVertexArray(0); }
-    using Codes = BufferError::Codes;
 
-    public:
-    using OpenGLObject::OpenGLObject;
-    Buffer() = default;
-    Buffer(Buffer&& other) {
-        *this = std::move(other);
-    }
-    Buffer& operator=(Buffer&& rhs) {
-        auto targ_name = BufferTypes.at(Target);
-        if (Target != rhs.Target) {
-            THROW(BufferError(
-                Codes::INVALID_BUFFER,
-                "w/ ("+targ_name+") := ("+BufferTypes.at(rhs.Target)+")"
-            ));
-        }
-        //nb::logger.log(std::to_string(_id) + ":=" + std::to_string(rhs._id));
-        if (_id) {
-            THROW(BufferError(
-                Codes::HANDLE_OVERWRITE,
-                "w/ BufferType = " + targ_name
-            ));
-        }
-        _id = rhs._id;
-        _usage = rhs._usage;
-        _size = rhs._size;
-
-        rhs._id = 0;
-        rhs._usage = GL_STATIC_DRAW;
-        rhs._size = 0;
-        return *this;
-    }
-
-    virtual void bind() const override {
-        if (_id) {
-            glBindBuffer(Target, _id);
-        } else {
-            THROW(BufferError(
-                Codes::INVALID_BUFFER,
-                "w/ BufferType " + BufferTypes.at(Target)
-            ));
-        }
-    }
-    virtual void unbind() const override { glBindBuffer(Target, 0); }
-    virtual GLenum usage() const { return _usage; }
-    virtual GLenum usage(GLenum usage_) {
-        _usage = usage_;
-        data(data(), _usage);
-        return _usage;
-    }
-    virtual size_t size() const { return _size; }
-    virtual ByteVector data() const {
-        bind();
-        ByteVector ret(_size);
-        glGetBufferSubData(Target, 0, _size, ret.data());
-        return ret;
-    }
-    virtual void data(
-        const void* data_,
-        GLsizei size_,
-        GLenum usage_=GL_STATIC_DRAW
-    ) {
-        declare();
-        bind();
-        glBufferData(Target, size_, data_, usage_);
-        _size = size_;
-        _usage = usage_;
-    }
-    virtual void data(const ByteVector& data_, GLenum usage_=GL_STATIC_DRAW) {
-        data(data_.data(), data_.size(), usage_);
-
-    }
-    virtual void subdata(void* data_, GLsizeiptr size_, GLintptr offset_=0) {
-        bind();
-        if (offset_+size_ <= _size) {
-            THROW(BufferError(BufferError::Codes::DATA_OVERFLOW));
-        }
-        glBufferSubData(Target, offset_, size_, data_);
-    }
-    virtual void subdata(ByteVector& data_, GLintptr offset_=0) {
-        bind();
-        size_t size_ = data_.size();
-        if (offset_+size_ <= _size) {
-            THROW(BufferError(BufferError::Codes::DATA_OVERFLOW));
-        }
-        glBufferSubData(Target, offset_, data_.size(), data_.data());
-    }
-    // virtual void clear() const { glClearBufferData(Target, ) }
-    static const GLenum Target;
-
-    protected:
-    using OpenGLObject::_id;
-    GLenum _usage = GL_STATIC_DRAW;
-    size_t _size;
-    virtual GLuint declare() override {
-        if (!_id) {
-            glGenBuffers(1, &_id);
-        }
-        return _id;
-    } 
-    virtual void remove() override {
-        if (_id) {
-            glDeleteBuffers(1, &_id);
-            _id = 0;
-        }
-    }
-
-};
-
-template<typename BufferType>
-const GLenum Buffer<BufferType>::Target = BufferType::Target;
-
-template <typename BufferType>
-class ImmutableBuffer : public virtual Buffer<BufferType> {
-    public:
-    using Base = Buffer<BufferType>;
-    using Base::Target;
-    using Base::bind;
-
-    ImmutableBuffer() = default;
-    ImmutableBuffer(size_t size_, GLenum usage_ = GL_STATIC_DRAW, GLbitfield flags_=0x0) : size(size_), Base::usage(usage_) {
-        glBufferStorage(Target, size, nullptr, flags_);
-    }
-
-    std::weak_ptr<void> map(GLbitfield access_) {
-        if (_map && _mapAccess != access_) { unmap(); }
-        _mapAccess = access_;
-        if (!_map) {
-            bind();
-            glMapBuffer(Target, _mapAccess);
-        }
-        return _map;
-    }
-    void unmap() {
-        bind();
-        glUnmapBuffer(Target);
-        _map.reset();
-    }
-    
-    const size_t size;
 
 protected:
     using Base::_id;
-    std::shared_ptr<void> _map = nullptr;
+    const 
-    GLbitfield _mapAccess = 0;
+
+    void remove() { glDeleteVertexArrays(1, &_id); }
 
 };
 
-template<bool Immutable=false>
+template <typename BufferType>
-class ArrayBuffer : public Buffer<ArrayBuffer<false>> {
+class Buffer : public virtual OpenGLObject<Buffer<BufferType>> {
-    using Base = Buffer<ArrayBuffer<false>>;
+public:
-    using BufferType = Base;
+    using Base = OpenGLObject<Buffer>;
-
-    public:
     using Base::Base;
-    using Base::data;
-    ArrayBuffer(const ByteVector&, GLenum usage_=GL_STATIC_DRAW);
     
-    static const GLenum Target = GL_ARRAY_BUFFER;
+    Buffer(GLenum usage_ = GL_STATIC_DRAW) : usage(usage_) { glGenBuffers(1,  &_id); }
 
-    protected:
+    void bind() const { glBindBuffer(GLTarget, _id); }
-    using Base::_usage;
+    void unbind() const { glBindBuffer(GLTarget, 0); }
-};
+    void data(void* data_, size_t size) const { glBufferData(GLTarget, size, data_, usage); }
-
+    void data(nb::ByteVector& data_) const { glBufferData(GLTarget, data_.size(), data_.data(), usage); }
-template <>
+    void invalidate() const { glInvalidateBufferData(_id); }
-class ArrayBuffer<true> 
-: public virtual ArrayBuffer<false>, public virtual ImmutableBuffer<ArrayBuffer<true>> {
-    using Base = ArrayBuffer<false>;
-    using BufferType = ImmutableBuffer<ArrayBuffer<true>>;
-    using BufferType::BufferType;
 
 
-    public:
+    const GLenum GLTarget = BufferType::GLTarget;
-    using Base::Target;
+    GLenum usage;
+
+protected:
+    using Base::_id;
+    void remove() { glDeleteBuffers(1, &_id); }
 
 };
 
-template<bool Immutable=false>
+class VertexBuffer : public virtual Buffer<VertexBuffer> {
-class ElementBuffer : public Buffer<ElementBuffer<false>> {
+public:
-    using Base = Buffer<ElementBuffer<false>>;
-    using BufferType = Base;
 
-    public:
+    static const GLenum GLTarget = GL_ARRAY_BUFFER;
-    using Base::Base;
+protected:
-    static const GLenum Target = GL_ELEMENT_ARRAY_BUFFER;
-
-    protected:
 
 };
 
-template <>
+class ElementBuffer : public virtual Buffer<ElementBuffer> {
-class ElementBuffer<true> 
+public:
-: public virtual ElementBuffer<false>, public virtual ImmutableBuffer<ElementBuffer<true>> {
-    using Base = ElementBuffer<false>;
-    using BufferType = ImmutableBuffer<ElementBuffer<true>>;
 
-    public:
+    static const GLenum GLTarget = GL_ELEMENT_ARRAY_BUFFER;
-    using BufferType::BufferType;
+
-    using Base::Target;
+protected:
 
 };
 
+/*
+class Buffer : public OpenGLObject {
+public:
+    Buffer(
+        GLenum buffer_type,
+        GLenum usage=GL_STATIC_DRAW
+    ) : _type(buffer_type), _usage(usage) {
+            glGenBuffers(1, &_id);
+    }
+    Buffer(
+        const RawVec& init_data,
+        GLenum buffer_type,
+        GLenum usage=GL_STATIC_DRAW
+    ) : _type{buffer_type}, _usage{usage} { data(init_data); }
+    Buffer(
+        unsigned int size,
+        GLenum buffer_type,
+        GLenum usage=GL_STATIC_DRAW
+    ) : Buffer(RawVec(size), buffer_type, usage) {}
+
+    Buffer(Buffer&& rhs) { *this = std::move(rhs); }
+    Buffer& operator=(Buffer&& rhs) {
+        remove();
+        _usage = rhs._usage;
+        _id = rhs._id;
+        rhs._id = 0;
+        return *this;
+    }
+
+    GLenum usage() const { return _usage; }
+    unsigned int id() const { return _id; }
+    GLuint size() const { return _size; }
+    bool isInitialized() const override { return _id && glIsBuffer(_id) && bool(_size); }
+    RawVec data() const {
+        RawVec ret(_size);
+        bind();
+        glGetBufferSubData(_type, 0, _size, ret.data());
+        return ret;
+    }
+    void bind() const override { glBindBuffer(_type, _id); }
+    void unbind() const override { glBindBuffer(_type, 0); }
+
+    GLenum usage(GLenum usage) {
+        _usage=usage;
+        data(data());
+        return _usage;
+    }
+    void data(const RawVec& set_data) {
+        if (!glfwGetCurrentContext()) {
+            THROW_BUFFER_ERROR("No OpenGL context.");
+        }
+        bind();
+        glBufferData(_type, set_data.size(), set_data.data(), _usage);
+        _size = set_data.size();
+    }
+    void data(const RawVec& newData, unsigned int offset) {
+        if (newData.size()+offset > _size) {
+            THROW_BUFFER_ERROR("Attempting to overflow buffer of capacity " + std::to_string(_size) + ".");
+        }
+        bind();
+        glBufferSubData(_type, offset, newData.size(), newData.data());
+    }
+    void data(void* src, unsigned int offset, unsigned int size) {
+        if (size+offset > _size) {
+            THROW_BUFFER_ERROR("Attempting to overflow buffer of capacity " + std::to_string(_size) + ".");
+        }
+        bind();
+        glBufferSubData(_type, offset, size, src);
+    }
+
+protected:
+    virtual void remove() const override {
+        unbind();
+        if (_id) { glDeleteBuffers(1, &_id); }
+    }
+
+    using OpenGLObject::_id;
+    GLenum _type;
+    GLenum _usage;
+    unsigned int _size = 0;
+};
+
+
+class Texture : public OpenGLObject {
+public:
+    Texture(GLenum tar=GL_TEXTURE_2D) : _target(tar) { glGenTextures(1, &_id); }
+
+    Texture(Texture&& rhs) { *this=std::move(rhs); }
+    Texture& operator=(Texture&& rhs) {
+        _target = rhs._target;
+        _id = rhs._id;
+        rhs._id = 0;
+        return *this;
+    }
+
+    void bind() const override { glBindTexture(_target, _id); }
+    void unbind() const override { glBindTexture(_target, 0); }
+    bool isInitialized() const override { return _id && glIsTexture(_id); }
+
+protected:
+    using OpenGLObject::_id;
+    GLenum _target;
+};
+
+class Framebuffer : public OpenGLObject {
+public:
+
+    Framebuffer(GLenum tar=GL_FRAMEBUFFER) : _target(tar) { glGenFramebuffers(1, &_id); }
+
+    Framebuffer(Framebuffer&& rhs) { *this=std::move(rhs); }
+    Framebuffer& operator=(Framebuffer&& rhs) {
+        remove();
+        _target = rhs._target;
+        _id = rhs._id;
+        rhs._id = 0;
+        return *this;
+    }
+
+    void bind() const override { glBindFramebuffer(_target, _id); }
+    void unbind() const override { glBindFramebuffer(_target, 0); }
+    bool isInitialized() const override { return _id && glIsFramebuffer(_id); }
+    GLenum status() const {
+        bind();
+        return glCheckFramebufferStatus(_target);
+    }
+
+
+protected:
+    virtual void remove() const override {
+        unbind();
+        if (_id) { glDeleteFramebuffers(1, &_id); }
+    }
+    using OpenGLObject::_id;
+    GLenum _target;
+};
+
+class Renderbuffer : public OpenGLObject {
+public:
+    Renderbuffer(unsigned int x, unsigned int y, GLenum format=GL_RGBA32F, unsigned int multi=0) : Renderbuffer() {
+        storage(x, y, format, multi);
+    }
+    Renderbuffer() { glGenRenderbuffers(1, &_id); }
+
+
+    Renderbuffer(Renderbuffer&& rhs) { *this = std::move(rhs); }
+    Renderbuffer& operator=(Renderbuffer&& rhs) {
+        _format = rhs._format;
+        _id = rhs._id;
+        rhs._id = 0;
+        return *this;
+    }
+
+    virtual void bind() const override { glBindRenderbuffer(GL_RENDERBUFFER, _id); }
+    virtual void unbind() const override { glBindRenderbuffer(GL_RENDERBUFFER, _id); }
+    virtual bool isInitialized() const override { return _id && glIsRenderbuffer(_id); }
+
+    void storage(unsigned int x, unsigned int y, GLenum format=GL_RGBA32F, unsigned int multi=0) {
+        _sizex = x;
+        _sizey = y;
+        _format = format;
+        _multisample = multi;
+        bind();
+        glRenderbufferStorageMultisample(GL_RENDERBUFFER, _multisample, _format, _sizex, _sizey);
+    }
+
+
+protected:
+    virtual void remove() const override {
+        unbind();
+        if (_id) { glDeleteRenderbuffers(1, &_id); }
+    }
+
+    using OpenGLObject::_id;
+    GLenum _format;
+    unsigned int _sizex{0};
+    unsigned int _sizey{0};
+    unsigned int _multisample{0};
+
+};
+
+*/
+
 } // namespace NB
 #endif // _NB_BUFFER

engine/NBGraphics/CMakeLists.txt

@@ -1,3 +1,5 @@
+include_directories(./.)
+
 find_package(OpenGL)
 add_subdirectory(${GLFW_PATH} ${GLFW_PATH}/build)
 
@@ -8,12 +10,8 @@ set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
 set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
 
 toAbsolutePath(NB_GRAPHICS_SOURCE
-    ./src/Buffers.cpp
-    ./src/OGLObjects.cpp
-    ./src/ProgramPipeline.cpp
-    ./src/Textures.cpp
-    ./src/VertexArray.cpp
     ./src/Window.cpp
+    ./src/Buffers.cpp
 )
 
 toAbsolutePath(NB_GRAPHICS_INCLUDE
@@ -21,10 +19,8 @@ toAbsolutePath(NB_GRAPHICS_INCLUDE
     ./Camera.hpp
     ./Draw.hpp
     ./GLLoad.hpp
-    ./OGLObjects.hpp
+    ./shader.hpp
-    ./ProgramPipeline.hpp
+    ./VAOManager.hpp
-    ./Textures.hpp
-    ./VertexArray.hpp
     ./Window.hpp
 )
 
@@ -35,11 +31,4 @@ add_library(NBGraphics
     ${NB_GRAPHICS_SOURCE}
     ${GLAD_PATH}/src/glad.c
 )
-target_link_libraries(NBGraphics glfw)
+target_link_libraries(NBGraphics glfw3)
-
-target_include_directories(NBGraphics PUBLIC ./.)
-
-if (NB_BUILD_TESTS)
-    add_subdirectory(./tests)
-endif()
-

engine/NBGraphics/Camera.hpp

@@ -2,14 +2,13 @@
 #ifndef _NB_CAMERA
 #define _NB_CAMERA
 
-#include "GLLoad.hpp"
+#include <GLLoad.h>
-
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_inverse.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
 
-namespace nb {
+namespace NB {
 
 class Camera {
 public:

engine/NBGraphics/GLLoad.hpp

@@ -5,4 +5,31 @@
 #include <glad/glad.h>
 #include <GLFW/glfw3.h>
 
+#include <iostream>
+#include <string>
+
+namespace NB {
+
+static unsigned int __NB_GL_DEBUG_ERROR_CODE__;
+
+static std::string formatDebugString(const std::string& msg, const std::string& file="", int line=-1) {
+    std::string ret = "";
+    if (file != "") {
+        ret += "In file " + file;
+        if (line >= 0) {
+            ret += " at line " + std::to_string(line);
+        }
+        ret += ":\n\t";
+    }
+    return ret + msg;
+}
+
+}
+
+#define NB_GL_DEBUG_THROW(cmd, when) while(NB::__NB_GL_DEBUG_ERROR_CODE__=glGetError()){\
+    std::cout << "[GL ERROR]: " << NB::__NB_GL_DEBUG_ERROR_CODE__;\
+    std::cout << " " << when << " " << cmd << "\n";\
+} 
+#define NB_GL_DEBUG(cmd) NB_GL_DEBUG_THROW(#cmd, "before"); cmd; NB_GL_DEBUG_THROW(#cmd, "after");
+
 #endif

engine/NBGraphics/OGLObjects.hpp

@@ -1,45 +0,0 @@
-#pragma once
-#ifndef _NB_OGL_OBJECTS
-#define _NB_OGL_OBJECTS
-
-#include "GLLoad.hpp"
-
-#include <NBCore/Errors.hpp>
-
-namespace nb {
-
-class OGLError : public Error<OGLError> {
-    using Base = Error<OGLError>;
-    
-    public:
-    using Base::Base;
-
-    enum Codes : unsigned int {
-        UNDEFINED, HANGING_OBJECT
-    };
-
-    static const std::string type;
-    static const ErrorCodeMap ErrorMessages;
-};
-
-class OpenGLObject {
-    public:
-    OpenGLObject(const OpenGLObject&) = delete;
-    OpenGLObject& operator=(const OpenGLObject&) = delete;
-    virtual ~OpenGLObject() {};
-    
-    virtual void bind() const = 0;
-    virtual void unbind() const = 0;
-    GLuint id() const { return _id; }
-    
-    protected:
-    OpenGLObject() = default;
-    
-    virtual GLuint declare() = 0;
-    virtual void remove() = 0;
-
-    GLuint _id = 0;
-};
-
-} // namespace nb
-#endif // _NB_OGL_OBJECTS

engine/NBGraphics/ProgramPipeline.hpp

@@ -1,123 +0,0 @@
-#pragma once
-#ifndef _NB_SHADER
-#define _NB_SHADER
-
-#include "GLLoad.hpp"
-
-#include <string>
-
-#include <NBCore/Errors.hpp>
-#include <NBCore/Utils.hpp>
-
-#include "OGLObjects.hpp"
-
-namespace nb {
-
-class ShaderError : public Error<ShaderError> {
-    using Base = Error<ShaderError>;
-
-    public:
-    using Base::Base;
-
-    enum Codes : unsigned int {
-        UNDEFINED
-    };
-
-    static const std::string type;
-    static const ErrorCodeMap ErrorMessages;
-};
-
-class ProgramError : public Error<ProgramError> {
-    using Base = Error<ProgramError>;
-
-    public:
-    using Base::Base;
-
-    enum Codes : unsigned int {
-        UNDEFINED, LINKING_ERROR
-    };
-
-    static const std::string type;
-    static const ErrorCodeMap ErrorMessages;
-};
-
-enum OpenGLProfiles {
-    Core,
-    Compatibility,
-    ES
-};
-
-class Shader : public OpenGLObject {
-    using Base = OpenGLObject;
-    
-    public:
-    using Base::Base;
-    using Base::id;
-    Shader(GLenum, const std::string&);
-    Shader(Shader&&);
-    Shader& operator=(Shader&&) = delete;
-    ~Shader() { remove(); }
-    operator bool();
-    virtual void bind() const override { /* TODO: Some warning of some kind perhaps*/ }
-    virtual void unbind() const override { /* TODO: Some warning of some kind perhaps*/ }
-    GLint status(GLenum) const;
-    std::string log() const;
-    const GLenum target;
-    friend Base;
-
-    protected:
-    using Base::_id;
-    GLint _success;
-    virtual GLuint declare() override {
-        if (!_id) {
-            _id = _id = glCreateShader(target);
-        }
-        return _id;
-    }
-
-    virtual void remove() override {
-        if (_id) {
-            glDeleteShader(_id);
-        }
-    }
-
-};
-
-class Program : public OpenGLObject {
-    using Base = OpenGLObject;
-    
-    public:
-    using Base::Base;
-    using Base::id;
-    Program(SharedVector<Shader>);
-    Program(Program&&);
-    Program& operator=(Program&&) = delete;
-    operator bool();
-    ~Program() { remove(); }
-    virtual void bind() const override {
-        glUseProgram(_id);
-    }
-    virtual void unbind() const override { /* TODO: Some warning of some kind perhaps*/ }
-    GLint status(GLenum) const;
-    std::string log() const;
-    friend Base;
-
-    protected:
-    using Base::_id;
-    GLint _success;
-    virtual GLuint declare() override {
-        if (!_id) {
-            _id = glCreateProgram();
-        }
-        return _id;
-    } 
-    virtual void remove() override {
-        if (_id) {
-            glDeleteProgram(_id);
-        }
-    }
-
-};
-
-}
-#endif

engine/NBGraphics/Textures.hpp

@@ -1,61 +0,0 @@
-#pragma once
-#ifndef _NB_TEXTURES
-#define _NB_TEXTURES
-
-#include "Buffers.hpp"
-#include "OGLObjects.hpp"
-
-namespace nb {
-
-template<bool Immutable=false>
-class TextureBuffer : public virtual Buffer<TextureBuffer<false>> {
-    using Base = Buffer<TextureBuffer<false>>;
-    using BufferType = Base;
-
-    public:
-    using Base::Base;
-    static const GLenum Target = GL_TEXTURE_BUFFER;
-
-    protected:
-
-};
-
-template <>
-class TextureBuffer<true> 
-: public virtual TextureBuffer<false>, public virtual ImmutableBuffer<TextureBuffer<true>> {
-    using Base = TextureBuffer<false>;
-    using BufferType = ImmutableBuffer<TextureBuffer<true>>;
-    
-    public:
-    using BufferType::BufferType;
-    using Base::Target;
-};
-
-class Texture : public OpenGLObject {
-    using Base = OpenGLObject;
-public:
-    using Base::Base;
-    using Base::id;
-
-    Texture(GLenum);
-
-    virtual void bind() const override { glBindTexture(target, _id); }
-    virtual void unbind() const override { glBindTexture(target, 0); }
-
-    const GLenum target;
-
-    friend Base;
-
-    protected:
-    using Base::_id;
-
-    virtual void remove() override {
-        if (_id) {
-            glDeleteTextures(0, &_id);
-        }
-    }
-
-};
-
-} // namespace nb
-#endif // _NB_TEXTURES

engine/NBGraphics/VAOManager.hpp

@@ -0,0 +1,75 @@
+#pragma once
+#ifndef _NB_VAO_MANAGER
+#define _NB_VAO_MANAGER
+
+#include <GLLoad.h>
+
+#include <exception>
+#include <memory>
+#include <vector>
+
+#include "Buffers.h"
+
+#define THROW_VAO_ERROR(msg) throw VAOError(msg, __FILE__, __LINE__);
+
+namespace NB {
+
+class VAOError : public std::runtime_error {
+public:
+    const bool error;
+    VAOError(const std::string& msg, const std::string& file="", int line=-1) 
+        : std::runtime_error(NB::formatDebugString(msg, file, line)), error(true) {}
+    VAOError(bool isError=true) : std::runtime_error(""), error(isError) {}
+};
+
+class VAOManager : public OpenGLObject {
+public:
+    typedef std::shared_ptr<Buffer> BufferManagerPointer;
+    //typedef BufferManager BufferManagerPointer;
+
+    VAOManager();
+    VAOManager(
+        std::vector<BufferManagerPointer>,
+        BufferManagerPointer elmt_buf = nullptr,
+        const VertexAttributeList& vert_attrs = {}
+    );
+    VAOManager(
+        BufferManagerPointer vert_bufs,
+        BufferManagerPointer elmt_buf = nullptr,
+        const VertexAttributeList& vert_attrs = {}
+    ) : VAOManager(std::vector<BufferManagerPointer>(1, vert_bufs), elmt_buf, vert_attrs) {}
+
+    VAOManager(VAOManager&& rhs);
+    VAOManager& operator=(VAOManager&& rhs);
+
+    VertexAttributeList getLayout() const;
+    GLuint id() const;
+    unsigned int vertSize(GLuint) const;
+    std::vector<BufferManagerPointer> getVertexBuffers() const;
+    bool isInitialized() const override;
+    RawVec attributeData(unsigned int);
+
+    RawVec attributeData(unsigned int, const RawVec&);
+    void bind() const;
+    void unbind() const;
+    void addVBO(BufferManagerPointer);
+    void changeEBO(BufferManagerPointer);
+    VertexAttributeList addVertexAttributes(const VertexAttributeList&);
+    VertexAttributeList addVertexAttributes(VertexAttribute);
+    VertexAttributeList generate();
+    VertexAttributeList generate(VertexAttributeList);
+    VertexAttributeList changeLayout(unsigned int, VertexAttributePointer);
+
+    VAOError checkValid(const VertexAttributeList&);
+
+private:
+    void remove() const override;
+
+    using OpenGLObject::_id;
+    std::map<GLuint, BufferManagerPointer> _vert_buffers;
+    BufferManagerPointer _elmt_buffer = nullptr;
+    VertexAttributeList _vert_attrs;
+};
+
+} // namespace NB
+#endif // _NB_VAO_MANAGER

engine/NBGraphics/VertexArray.hpp

@@ -1,177 +0,0 @@
-#pragma once
-#ifndef _NB_VERTEX_ARRAY
-#define _NB_VERTEX_ARRAY
-
-#include "GLLoad.hpp"
-
-#include <NBCore/Errors.hpp>
-
-#include "Buffers.hpp"
-#include "OGLObjects.hpp"
-
-
-namespace nb {
-
-static uint8_t GLSLTypeSize(GLenum type) {
-    switch(type) {
-    case GL_SHORT:
-    case GL_UNSIGNED_SHORT:
-    case GL_HALF_FLOAT:
-        return 2;
-        break;
-    case GL_INT:
-    case GL_UNSIGNED_INT:
-    case GL_FLOAT:
-        return 4;
-        break;
-    case GL_DOUBLE:
-        return 8;
-        break;
-    default:
-        return 1;
-        break;
-    }
-}
-
-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;
-}
-
-typedef std::vector<VertexAttribute> VertexAttributeList;
-typedef std::vector<VertexAttributePointer> VertexAttributePointerList;
-
-class VAOError : public Error<VAOError> {
-    using Base = Error<VAOError>;
-    
-    public:
-    using Base::Base;
-    
-    enum Codes : unsigned int {
-        UNDEFINED, INVALID_ATTRIBUTE, INVALID_VAO
-    };
-
-    static const std::string type;
-    static const ErrorCodeMap ErrorMessages;
-};
-
-class VAO : public OpenGLObject {
-    using Base = OpenGLObject;
-    using Codes = VAOError::Codes;
-
-    public:
-    using Base::Base;
-    VAO() = default;
-    VAO(const VertexAttributePointerList&);
-    VAO(VAO&&);
-
-    VAO& operator=(VAO&&);
-
-    virtual void bind() const override {
-        if(_id) {
-            glBindVertexArray(_id);
-        } else {
-            THROW(VAOError(Codes::INVALID_VAO));
-        }
-    }
-    virtual void unbind() const override { glBindVertexArray(0); }
-
-    VertexAttributePointerList attributes() const;
-    VertexAttributePointerList attributes(const VertexAttributePointerList&);
-    VertexAttributePointer attr(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();
-            glDeleteVertexArrays(1, &_id);
-            _id = 0;
-        }
-    }
-    virtual GLuint declare() override {
-        if (!_id) {
-            glGenVertexArrays(1, &_id);
-        }
-        return _id;
-    }
-
-};
-
-using VBO = ArrayBuffer<false>;
-using VertBufVec = SharedVector<VBO>;
-using EBO = ElementBuffer<false>;
-
-struct VertexData {
-    std::shared_ptr<VBO> vbo;
-    VertexAttributeList attrs;
-};
-
-using VertexDataVec = std::vector<VertexData>;
-
-class VertexGroup {
-    public:
-    VertexGroup(VertexGroup&&);
-    VertexGroup& operator=(VertexGroup&&);
-    
-    VertexGroup(const VertexData&);
-    VertexGroup(const VertexDataVec&);
-    VertexGroup(const ByteVector&, const VertexAttributeList&);
-
-    void bind() const {
-        _ebo->bind();
-        _vao->bind();
-    }
-    void unbind() const {
-        _vao->unbind();
-        _ebo->unbind();
-    }
-
-    VertexDataVec getBuffers();
-    VertexData getBuffers(size_t);
-    size_t setBuffers(const VertexDataVec&);
-    size_t addBuffer(const VertexData&);
-    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();
-
-    protected:
-    VertexDataVec _vertex_data;
-    std::shared_ptr<EBO> _ebo;
-    std::shared_ptr<VAO> _vao;
-};
-
-} // namespace nb
-#endif // _NB_VERTEX_ARRAY

engine/NBGraphics/Window.hpp

@@ -4,42 +4,22 @@
 
 #include "GLLoad.hpp"
 
+#include <atomic>
 #include <array>
 #include <map>
 #include <stdexcept>
 #include <string>
 
-#include <NBCore/Errors.hpp>
-#include <NBCore/Utils.hpp>
-
 namespace nb {
 
-class OpenGLError : public Error<OpenGLError> {
+class GLError : public std::runtime_error {
-    using Base = Error<OpenGLError>;
+public:
-
+    GLError(const std::string&);
-    public:
-    using Base::Base;
-
-    enum Codes : unsigned int {
-        UNDEFINED, INIT_FAILED, GLFW_INTIALIZED, GLAD_FAILED
-    };
-
-    static const std::string type;
-    static const ErrorCodeMap ErrorMessages;
 };
 
-class WindowError : public Error<WindowError> {
+class WindowError : public std::runtime_error {
-    using Base = Error<WindowError>;
+public:
-
+    WindowError(const std::string&);
-    public:
-    using Base::Base;
-
-    enum Codes : unsigned int {
-        UNDEFINED, INITIALIZED_WINDOW, NO_GLFW, INIT_FAILED
-    };
-
-    static const std::string type;
-    static const ErrorCodeMap ErrorMessages;
 };
 
 class Window {

engine/NBGraphics/shader.hpp

@@ -0,0 +1,193 @@
+#pragma once
+#ifndef _NB_SHADER
+#define _NB_SHADER
+
+#include <GLLoad.h>
+
+#include <cctype>
+#include <cstring>
+#include <exception>
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <regex>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+// #define _PREPROC_FUNC_PARAMS_ (const ShaderPreprocessor&, ShaderUnit&, unsigned int, const std::string&, std::vector<uint8_t>&)
+
+namespace NB {
+
+class ShaderPreprocessorError : public std::runtime_error {
+public:
+    enum Codes : unsigned char {
+        NONE,
+        FILE_NOT_FOUND,
+        BUILTIN_NOT_FOUND,
+        CUSTOM,
+        UNDEFINED
+    };
+
+    const Codes code;
+
+    ShaderPreprocessorError(const std::string&, const std::string& file="", int line=-1);
+    ShaderPreprocessorError(Codes, const std::string& arg="", const std::string& file="", int line=-1);
+
+protected:
+    static std::string errorCodeParser(Codes, const std::string& arg="");
+};
+
+class ShaderError : public std::runtime_error {
+public:
+    ShaderError(const std::string&, const char* shad=nullptr, const std::string& file="", int line=-1);
+
+protected:
+    std::string formatString(const std::string&, const char* shad=nullptr, const std::string& file="", int line=-1);
+};
+
+struct File {
+    // typedef std::tuple<std::string, std::string, std::string> FilePath;
+    struct FilePath {
+        std::string dir;
+        std::string basename;
+        std::string ext;
+    };
+    FilePath path;
+    std::stringstream src;
+    std::map<unsigned int, std::shared_ptr<File>> include_map;
+
+    File() {}
+    File(const File& rhs) { *this = rhs; }
+
+    File& operator=(const File& rhs) {
+        path = rhs.path;
+        src.str("");
+        src << rhs.src.rdbuf();
+        include_map = rhs.include_map;
+        return *this;
+    }
+};
+
+// File::FilePath get_file_path(std::string);
+
+class ShaderPreprocessor;
+
+enum OpenGLProfiles {
+    Core,
+    Compatibility,
+    ES
+};
+
+struct ShaderUnit {
+    GLenum type = 0x0;
+    File file;
+    std::string preprocSource;
+    std::map<std::string, std::string> defines;
+    short vMajor=0, vMinor=0;
+    OpenGLProfiles profile = Core;
+};
+
+class ShaderPreprocessor;
+
+class ShaderProgram {
+    friend ShaderPreprocessor;
+public:
+    ShaderProgram() {}
+    ShaderProgram(const ShaderProgram& rhs) = delete;
+    ShaderProgram(ShaderProgram&& rhs);
+
+    ~ShaderProgram();
+
+    ShaderProgram& operator=(const ShaderProgram& rhs) = delete;
+    ShaderProgram& operator=(ShaderProgram&& rhs);
+
+    std::vector<ShaderUnit> getShaders() const;
+    ShaderUnit getShaders(unsigned int) const;
+    void use() const;
+    unsigned int id() const;
+
+    void setBool(const std::string& name, bool value) const;
+    void setInt(const std::string& name, int value) const;
+    void setUnsigned(const std::string& name, int value) const;
+    void setFloat(const std::string& name, float value) const;
+    void setMat4(const std::string& name, glm::mat4& value) const;
+
+    static ShaderProgram CreateShaderProgram(std::vector<ShaderUnit>&);
+
+private:
+    ShaderProgram(std::vector<ShaderUnit>& shaders) : _shader_units(shaders){}
+    
+    std::vector<ShaderUnit> _shader_units;
+    unsigned int _id;
+};
+
+class ShaderPreprocessor {
+public:
+    typedef ShaderPreprocessorError::Codes Codes;
+
+    enum TokenType {
+        TK,
+        DR,
+        WS,
+        NL,
+        LC,
+        BC
+    };
+    static std::string TokenName(const TokenType&);
+
+    std::map<std::string, GLenum> AcceptedExtensions = {
+        {".frag", GL_FRAGMENT_SHADER},
+        {".fs", GL_FRAGMENT_SHADER},
+        {".vert", GL_VERTEX_SHADER},
+        {".vs", GL_VERTEX_SHADER},
+        {".tess", 0x0},
+        {".geom", GL_GEOMETRY_SHADER},
+        {".comp", 0x0},
+        {".shad", 0x0},
+        {".glsl", 0x0}
+    };
+    std::map<std::string, OpenGLProfiles> AcceptedProfiles {
+        {"core", Core},
+        {"compatibility", Compatibility},
+        {"es", ES}
+    };
+    std::vector<std::string> Directories;
+    std::map<std::string, std::string> BuiltIns;
+
+    ShaderPreprocessor();
+    
+    
+    File load(const std::string, bool builtin_first=false) const;
+    ShaderUnit& preprocess(const std::string&, ShaderUnit&) const;
+    ShaderUnit preprocess(File, GLenum shader_type=0x0) const;
+    ShaderUnit preprocess(const std::string&, GLenum shader_type=0x0) const;
+    ShaderProgram ReloadFromFile(const ShaderProgram& rhs) const;
+    ShaderProgram CreateShaderProgram(std::vector<std::string>) const;
+
+private:
+    typedef std::pair<TokenType, std::string> Token;
+    typedef std::vector<std::string> StringVec; 
+
+    inline bool directive_dispatch(ShaderUnit&, const std::string&) const;
+    inline std::vector<Token> tokenize(const std::string&) const;
+
+    inline bool preprocessor_include(ShaderUnit&, const StringVec&, const std::string&) const;
+    inline bool preprocessor_version(ShaderUnit&, const StringVec&, const std::string&) const;
+    inline bool preprocessor_define(ShaderUnit&, const StringVec&, const std::string&) const;
+    // inline bool preprocessor_uniform(ShaderUnit&, const std::string&, const std::string&) const;
+
+    File loadFromBase(const std::string, const std::string base="") const;
+    File loadFromDirectories(const std::string) const;
+    File loadFromBuiltIn(const std::string) const;
+    File load_BuiltInFirst(const std::string) const;
+    File load_FilesFirst(const std::string) const;
+};
+
+}
+#endif

engine/NBGraphics/src/Buffers.cpp

@@ -2,25 +2,4 @@
 
 namespace nb {
 
-const std::unordered_map<GLenum, std::string> BufferTypes({
-    {GL_ARRAY_BUFFER, "GL_ARRAY_BUFFER"},
-    {GL_ELEMENT_ARRAY_BUFFER, "GL_ELEMENT_BUFFER"}
-});
-
-using BufferErrorCodes = BufferError::Codes;
-const std::string BufferError::type = "nb::BufferError";
-const ErrorCodeMap BufferError::ErrorMessages = {
-    { BufferErrorCodes::UNDEFINED, "Error" },
-    { BufferErrorCodes::DATA_OVERFLOW, "Attempting buffer overflow" },
-    { BufferErrorCodes::INVALID_BUFFER, "Attempting operation on invalid buffer" },
-    { BufferErrorCodes::HANDLE_OVERWRITE, "Attempting to overwrite active buffer"}
-
-};
-
-template<>
-ArrayBuffer<false>::ArrayBuffer(const ByteVector& data_, GLenum usage_) 
-: BufferType() {
-    data(data_, usage_);
-}
-
 }

engine/NBGraphics/src/Camera.cpp

@@ -1,6 +1,5 @@
-#include "Camera.hpp"
+#include "Camera.h"
-
+namespace NB {
-namespace nb {
 
 // Camera class
 Camera::Camera(const Vec3& pos, const Vec3& tar, const Vec3& up) {

engine/NBGraphics/src/OGLObjects.cpp

@@ -1,11 +0,0 @@
-#include "OGLObjects.hpp"
-
-namespace nb {
-
-const std::string OGLError::type = "nb::OGLError";
-const ErrorCodeMap OGLError::ErrorMessages = {
-    { OGLError::Codes::UNDEFINED, "Error" },
-    {OGLError::Codes::HANGING_OBJECT, "Attempting to leave a hanging OpenGL object"}
-};
-
-} // namespace nb

engine/NBGraphics/src/ProgramPipeline.cpp

@@ -1,75 +0,0 @@
-#include "ProgramPipeline.hpp"
-
-namespace nb{
-
-using ShaderErrCodes = ShaderError::Codes;
-const std::string ShaderError::type = "nb::ShaderError";
-const ErrorCodeMap ShaderError::ErrorMessages = {
-    {ShaderErrCodes::UNDEFINED, "Error"}
-};
-
-using ProgramErrCodes = ProgramError::Codes;
-const std::string ProgramError::type = "nb::ProgramError";
-const ErrorCodeMap ProgramError::ErrorMessages = {
-    {ProgramErrCodes::UNDEFINED, "Error"},
-    {ProgramErrCodes::LINKING_ERROR, "Linker error"}
-};
-
-Shader::Shader(GLenum target_, const std::string& source_) : target(target_) {
-    declare();
-    _success = status(GL_COMPILE_STATUS);
-}
-
-Shader::Shader(Shader&& cpy) : target(cpy.target) {
-    _id = cpy._id;
-}
-
-Shader::operator bool() { return _success; }
-
-GLint Shader::status(GLenum parameter) const {
-    GLint param = 0;
-    glGetShaderiv(_id, parameter, &param);
-    return param;
-}
-
-std::string Shader::log() const {
-    GLint logsize = status(GL_INFO_LOG_LENGTH);
-    char* log_ = new char[logsize];
-    glGetShaderInfoLog(_id, logsize, NULL, log_);
-    std::string ret(log_, logsize);
-    delete[] log_;
-    return ret; 
-}
-
-Program::Program(SharedVector<Shader> shaders_) {
-    declare();
-    for (auto shad_ptr : shaders_) {
-        glAttachShader(_id, shad_ptr->id());
-    }
-    glLinkProgram(_id);
-    _success = status(GL_LINK_STATUS);
-    if (!_success) {
-        WARN(log(), 0x01);
-    }
-}
-
-Program::operator bool() { return _success; }
-
-GLint Program::status(GLenum parameter) const {
-    GLint param = 0;
-    glGetProgramiv(_id, parameter, &param);
-    return param;
-}
-
-std::string Program::log() const {
-    GLint logsize = status(GL_INFO_LOG_LENGTH);
-    char* log_ = new char[logsize];
-    glGetProgramInfoLog(_id, logsize, NULL, log_);
-    std::string ret(log_, logsize);
-    delete[] log_;
-    return ret; 
-}
-
-
-
-}

engine/NBGraphics/src/Textures.cpp

@@ -1,10 +0,0 @@
-#include "Textures.hpp"
-
-namespace nb{
-
-Texture::Texture(GLenum target_) : target(target_) {
-    glGenTextures(1, &_id);
-}
-
-
-} // namespace nb

engine/NBGraphics/src/VAOManager.cpp

@@ -0,0 +1,225 @@
+#include "VAOManager.hpp"
+
+namespace NB {
+
+using BufferManagerPointer = std::shared_ptr<Buffer>;
+
+VAOManager::VAOManager() { glGenVertexArrays(1, &_id); }
+
+VAOManager::VAOManager(
+        std::vector<BufferManagerPointer> vert_bufs,
+        BufferManagerPointer elmt_buf,
+        const VertexAttributeList& vert_attrs
+) : VAOManager() {
+    _elmt_buffer = elmt_buf;
+    for (BufferManagerPointer vb : vert_bufs) {
+        _vert_buffers[vb->id()] = vb;
+    }
+    if (vert_attrs.size()!=0) {
+        generate(vert_attrs);
+    }
+}
+
+VAOManager::VAOManager(VAOManager&& rhs) { *this = std::move(rhs); }
+
+VAOManager& VAOManager::operator=(VAOManager&& rhs) {
+    remove();
+    _vert_buffers = rhs._vert_buffers;
+    _elmt_buffer = rhs._elmt_buffer;
+    _vert_attrs = rhs._vert_attrs;
+    return *this;
+}
+
+VertexAttributeList VAOManager::getLayout() const { return _vert_attrs; }
+
+GLuint VAOManager::id() const { return _id; }
+
+bool VAOManager::isInitialized() const {
+    return _id && glIsVertexArray(_id);
+}
+
+void VAOManager::remove() const {
+    bind();
+    for (int i{0}; i < _vert_attrs.size(); ++i) {
+        glDisableVertexAttribArray(i);
+    }
+    unbind();
+    glDisableVertexAttribArray(_id);
+}
+
+unsigned int VAOManager::vertSize(GLuint id) const {
+    unsigned int size = 0; 
+    for (const VertexAttribute& va : _vert_attrs) {
+        if (va.ptr.buffer == id) {
+            size += va.GLSLSize * GLSLTypeSize(va.GLSLType);
+        }
+    }
+    return size;
+}
+
+std::vector<BufferManagerPointer> VAOManager::getVertexBuffers() const {
+    std::vector<BufferManagerPointer> ret;
+    for (const auto& i : _vert_buffers) {
+        ret.emplace_back(i.second);
+    }
+    return ret;
+}
+
+RawVec VAOManager::attributeData(unsigned int i) {
+    if (i <= _vert_attrs.size()) {
+        throw std::out_of_range("No vertex attribute exists for specified index");
+    }
+    VertexAttribute attr = _vert_attrs[i];
+    BufferManagerPointer buffer = _vert_buffers[attr.ptr.buffer]; 
+    RawVec data = buffer->data();
+    unsigned int attr_size = attr.GLSLSize*GLSLTypeSize(attr.GLSLType);
+    RawVec ret((buffer->size()-attr.ptr.offset-attr_size)*attr_size/attr.ptr.stride);
+    int data_size = data.size();
+    for (int i{0}; i < data_size; ++i) {
+        if (isIndexInVertexAttribute(i, attr)) {
+            ret[i] = data[i];
+        }
+    }
+    return ret;
+}
+
+RawVec VAOManager::attributeData(unsigned int i, const RawVec& new_data) {
+    if (i >= _vert_attrs.size()) {
+        throw std::out_of_range("No vertex attribute exists for specified index.");
+    }
+    VertexAttribute attr = _vert_attrs[i];
+    BufferManagerPointer buffer = _vert_buffers[attr.ptr.buffer]; 
+    unsigned int attr_size = attr.GLSLSize*GLSLTypeSize(attr.GLSLType);
+    unsigned int offset = attr.ptr.offset;
+    unsigned int num_verts = buffer->size() / vertSize(buffer->id());
+    if (num_verts*attr_size != new_data.size()) {
+        // WHY HERE????
+        THROW_VAO_ERROR(
+            "Input data size of " + std::to_string(new_data.size()) 
+            + " does not match data size for requested vertex attribute of total size " + std::to_string(num_verts*attr_size)
+            + "."
+        );
+    }
+    uint64_t pos = uint64_t(new_data.data());
+    for (int i{0}; i<num_verts; i++) {
+        buffer->data((void*)(pos+i*attr_size), offset+i*attr.ptr.stride, attr_size);
+    }
+    return RawVec(new_data);
+}
+
+void VAOManager::bind() const {
+    glBindVertexArray(_id); 
+    if (_elmt_buffer) { _elmt_buffer->bind(); }
+}
+
+void VAOManager::unbind() const {
+    glBindVertexArray(0);
+    if (_elmt_buffer) { _elmt_buffer->unbind(); }
+}
+
+void VAOManager::addVBO(BufferManagerPointer vert_buf) {
+    GLuint vert_id = vert_buf->id();
+    if (_vert_buffers.find(vert_id) == _vert_buffers.end()) {
+        _vert_buffers[vert_buf->id()] = vert_buf;
+    } else {
+        THROW_VAO_ERROR("Attempting to add identical VBO id of " + std::to_string(vert_id) + ".");
+    }
+}
+
+void VAOManager::changeEBO(BufferManagerPointer ebo) {
+    _elmt_buffer = ebo;
+}
+
+VertexAttributeList VAOManager::addVertexAttributes(const VertexAttributeList& vert_attrs) { 
+    VertexAttributeList curr_vas = _vert_attrs;
+    curr_vas.insert(curr_vas.end(), vert_attrs.begin(), vert_attrs.end());
+    try {
+        throw checkValid(curr_vas);
+    } catch (VAOError vaoe) {
+        if (vaoe.error) {
+            THROW_VAO_ERROR(vaoe.what());
+        }
+    }
+    _vert_attrs = curr_vas;
+    generate();
+    return _vert_attrs;
+}
+
+VertexAttributeList VAOManager::addVertexAttributes(VertexAttribute vert_attr) {
+    return addVertexAttributes({vert_attr});
+}
+
+VertexAttributeList VAOManager::generate() {
+    bind();
+    unsigned int num_attrs = _vert_attrs.size();
+    VertexAttribute* va;
+    for (int i = 0; i < num_attrs; ++i) {
+        va = &(_vert_attrs[i]);
+        _vert_buffers[va->ptr.buffer]->bind();
+        glVertexAttribPointer(
+            i,
+            va->GLSLSize,
+            va->GLSLType,
+            va->GLSLNormalization,
+            va->ptr.stride,
+            (void*)va->ptr.offset
+        );
+        glVertexAttribDivisor(i, va->ptr.divisor);
+        glEnableVertexAttribArray(i);
+    }
+    if (_elmt_buffer != nullptr) {
+        _elmt_buffer->bind();
+    }
+    unbind();
+    return _vert_attrs;
+}
+
+VertexAttributeList VAOManager::generate(VertexAttributeList vert_attrs) {
+    try {
+        throw checkValid(vert_attrs);
+    } catch (VAOError vaoe) {
+        if (vaoe.error) {
+            THROW_VAO_ERROR(vaoe.what());
+        }
+    }
+    _vert_attrs.swap(vert_attrs);
+    return generate();
+}
+
+VertexAttributeList VAOManager::changeLayout(unsigned int i, VertexAttributePointer vap) {
+    _vert_attrs[i].ptr = vap;
+    bind();
+    const VertexAttribute* va = &(_vert_attrs[i]);
+    glDisableVertexAttribArray(i);
+    _vert_buffers[va->ptr.buffer]->bind();
+    glVertexAttribPointer(
+        _id,
+        va->GLSLSize,
+        va->GLSLType,
+        va->GLSLNormalization,
+        va->ptr.stride,
+        (void*)va->ptr.offset
+    );
+    glVertexAttribDivisor(i, va->ptr.divisor);
+    glEnableVertexAttribArray(i);
+    unbind();
+    return _vert_attrs;
+}
+
+VAOError VAOManager::checkValid(const VertexAttributeList& vert_attrs) {
+    GLuint va_id;
+    unsigned int num_attrs = vert_attrs.size();
+    for (int i = 0; i < num_attrs; ++i) {
+        va_id = vert_attrs[i].ptr.buffer;
+        if (_vert_buffers.find(va_id) == _vert_buffers.cend()) {
+            return VAOError("Attempting to point to unknown VBO of id " + std::to_string(va_id) + 
+            " at Vertex Attribute " + std::to_string(i) + ".");
+        }
+        if (vert_attrs[i].ptr.stride<0) {
+            return VAOError("Invalid stride value at Vertex Attribute " + std::to_string(i) + ".");
+        }
+    }
+    return VAOError(false);
+}
+
+} // namespace NB

engine/NBGraphics/src/VertexArray.cpp

@@ -1,231 +0,0 @@
-#include "VertexArray.hpp"
-
-namespace nb {
-
-using VAOErrorCodes = VAOError::Codes;
-const std::string VAOError::type = "nb::VAOError";
-const ErrorCodeMap VAOError::ErrorMessages = {
-    { VAOErrorCodes::UNDEFINED, "Error" },
-    { VAOErrorCodes::INVALID_ATTRIBUTE, "Targeting invalid attribute"},
-    { VAOErrorCodes::INVALID_VAO, "Targeting invalid VAO" }
-};
-
-VAO::VAO(const VertexAttributePointerList& attr_ptrs) {
-    attributes(attr_ptrs);
-}
-
-VAO::VAO(VAO&& other) {
-    *this = std::move(other);
-}
-
-VAO& VAO::operator=(VAO&& rhs) {
-    _id = rhs._id;
-    _attrs = rhs._attrs;
-
-    rhs._id = 0;
-    rhs._attrs = {};
-
-    return *this;
-}
-
-VertexAttributePointerList VAO::attributes() const {
-    return _attrs;
-}
-
-VertexAttributePointerList VAO::attributes(const VertexAttributePointerList& attrs_) {
-    declare();
-    disable();
-    _attrs = attrs_;
-    bind();
-    for (auto attr_ptr : attrs_) {
-        glBindBuffer(GL_ARRAY_BUFFER, attr_ptr.buffer);
-        GLuint idx = attr_ptr.index; 
-        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
-        );
-        glEnableVertexAttribArray(idx);
-    }
-    unbind();
-    return _attrs;
-}
-
-VertexAttributePointer VAO::attr(GLuint idx) const {
-    for (auto attr_ptr : _attrs) {
-        if (idx == attr_ptr.index) {
-            return attr_ptr;
-        }
-    }
-    THROW(VAOError(Codes::INVALID_ATTRIBUTE));
-}
-
-void VAO::enable() const {
-    if (_id) {
-        bind();
-        for(auto attr_ptr : _attrs) {
-            glEnableVertexAttribArray(attr_ptr.index);
-        }
-        unbind();
-    }
-}
-
-void VAO::enable(GLuint idx) const {
-    if(_id) {
-        bind();
-        glEnableVertexAttribArray(attr(idx).index); 
-        unbind();
-    }
-}
-
-void VAO::disable() const {
-    if(_id) {
-        bind();
-        for(auto attr_ptr : _attrs) {
-            glDisableVertexAttribArray(attr_ptr.index); 
-        }
-        unbind();
-    }
-}
-
-void VAO::disable(GLuint idx) const {
-    if(_id) {
-        bind();
-        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;
-}
-
-VertexGroup::VertexGroup(const VertexDataVec& vertex_data_) 
-: _vao(std::make_shared<VAO>()), _ebo(std::make_shared<EBO>()) {
-    setBuffers(vertex_data_);
-}
-
-VertexGroup::VertexGroup(const VertexData& vertex_data_) 
-: VertexGroup(VertexDataVec({vertex_data_})) {}
-
-VertexGroup::VertexGroup(
-    const ByteVector& data_,
-    const VertexAttributeList& attrs_
-) : VertexGroup({std::make_shared<VBO>(data_), attrs_}) {}
-
-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 (auto attr : data.attrs) {
-        attrs.emplace_back(
-            VertexAttributePointer{attr, data.vbo->id(),idx}
-        );
-        idx++;
-    }
-    _vao->attributes(attrs);
-    return _vertex_data.size();
-}
-
-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 (auto data : _vertex_data) {
-        for (auto attr : data.attrs) {
-            attr_ptrs.emplace_back(
-                VertexAttributePointer{attr, data.vbo->id(), idx}
-            );
-            idx++;
-        }
-    }
-    _vao->attributes(attr_ptrs);
-    return _vertex_data.size();
-}
-
-VertexData VertexGroup::dropBuffer(size_t idx) {
-    if (idx >= _vertex_data.size()) {
-        THROW(BufferError(BufferError::Codes::INVALID_BUFFER));
-    }
-    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(); }
-
-} // namespace nb

engine/NBGraphics/src/Window.cpp

@@ -16,23 +16,9 @@ static std::map<int, int> defailt_window_hints = {
 #endif
 };
 
-using OpenGLErrorCodes = OpenGLError::Codes;
+GLError::GLError(const std::string& msg) : std::runtime_error(msg) {}
-const std::string OpenGLError::type = "nb::OpenGLError";
-const ErrorCodeMap OpenGLError::ErrorMessages = {
-    {OpenGLErrorCodes::UNDEFINED, "Error"},
-    {OpenGLErrorCodes::INIT_FAILED, "GLFW initialization failed"},
-    {OpenGLErrorCodes::GLFW_INTIALIZED, "GLFW has already been initialized"},
-    {OpenGLErrorCodes::GLAD_FAILED, "GLAD initialization failed"}
-};
 
-using WindowErrorCodes = WindowError::Codes;
+WindowError::WindowError(const std::string &msg) : std::runtime_error(msg) {}
-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"}
-};
 
 int Window::getGLFWHint(int hint_key) {
     if (GLFWHints.find(hint_key) == GLFWHints.end()) {
@@ -44,7 +30,7 @@ int Window::getGLFWHint(int hint_key) {
 
 int Window::setGLFWHint(int hint_key, int hint_val) {
     if (Window::_glfw_init) {
-        THROW(OpenGLError(OpenGLErrorCodes::GLFW_INTIALIZED));
+        throw GLError("Cannot set GLFW hint after window is initialized.");
     } else {
         GLFWHints[hint_key] = hint_val;
     }
@@ -74,7 +60,7 @@ Window::Window(const uint16_t x, const uint16_t y, const char* initName, GLFWmon
             Window::_glfw_init = true;
         } else {            
             if (Window::StrictInitialization) {
-                THROW(OpenGLError(OpenGLErrorCodes::INIT_FAILED));
+                throw GLError("Failed to load GLFW with glfwInit()="+std::to_string(glfwResponse)+".");
             }
         }
     }
@@ -117,7 +103,7 @@ int Window::getWindowHint(int hint_key) const {
 
 int Window::setWindowHint(int hint_key, int hint_val) {
     if (_init) {
-        THROW(WindowError(WindowErrorCodes::INITIALIZED_WINDOW));
+        throw WindowError("Cannot set window hint after window is initialized.");
     } else {
         windowHints[hint_key] = hint_val;
     }
@@ -126,7 +112,7 @@ int Window::setWindowHint(int hint_key, int hint_val) {
 
 int Window::init() {
     if (!_glfw_init) {
-        THROW(WindowError(WindowErrorCodes::NO_GLFW));
+        throw GLError("GLFW has not been initialized.");
     }
     for (const auto& hint : windowHints) {
         glfwWindowHint(hint.first, hint.second);
@@ -137,7 +123,7 @@ int Window::init() {
         Window::WindowContexts.erase(window);
         if (Window::WindowContexts.size()==0 && Window::_glfw_init) { glfwTerminate(); }
         if (Window::StrictInitialization) {
-            THROW(WindowError(WindowErrorCodes::INIT_FAILED));
+            throw WindowError("Could not create window in glfwCreateWindow().");
         }
     }
     glfwMakeContextCurrent(window);
@@ -147,7 +133,10 @@ int Window::init() {
     if (!gladResponse) {
         Window::checkKillGLFW();
         if (Window::StrictInitialization) {
-            THROW(OpenGLError(OpenGLErrorCodes::GLAD_FAILED));
+            throw GLError("Failed to load GLAD with \
+                gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)="+\
+                std::to_string(gladResponse)+"."
+            );
         }
     }
 

engine/NBGraphics/src/shader.cpp

@@ -0,0 +1,742 @@
+#include "Shader.h"
+
+// #define _PREPROC_FUNC_PARAM_NAMES_ (const ShaderPreprocessor& proc, ShaderUnit& shad, unsigned int linenum, const std::string& line, std::vector<uint8_t>& params)
+
+namespace NB{
+
+File::FilePath get_file_path(std::string name) {
+    const std::vector<char> allowed_special_chars = {
+        '.', '!', '#', '$', '%', '&', '\'', '(', ')', '+', ',', '-', ';', '=', '@', '[', ']', '^', '_', '`', '~' 
+    };
+    std::vector<std::string> path = {""};
+    for (const char c : name) {
+        if (c == '/' || c == '\\') {
+            path.push_back("");
+        } else if (std::isalnum(c)) {
+            path.back() += c;
+        } else {
+            bool spec_char_found = false;
+            for (const char sc : allowed_special_chars) {
+                if (c == sc) {
+                    path.back() += c;
+                    spec_char_found = true;
+                    break;
+                }
+            }
+            if (!spec_char_found) {
+                throw std::runtime_error("'" + name + "' is not valid filepath.");
+            }
+        }
+    }
+    File::FilePath ret;
+    for (const auto& tk : path) {
+        if (tk == path.back()) {
+            size_t period = tk.find(".");
+            if (period == std::string::npos) {
+                ret.basename = tk;
+                ret.ext = "";
+            } else {
+                ret.basename = tk.substr(0, period);
+                ret.ext = tk.substr(period);
+            }
+        } else {
+            ret.dir += tk + "/";
+        }
+    }
+    return ret;
+}
+
+// ShaderPreprocessorError class
+ShaderPreprocessorError::ShaderPreprocessorError(
+    const std::string& msg,
+    const std::string& file,
+    int line
+) : code(Codes::UNDEFINED), std::runtime_error(formatDebugString(msg, file, line)) {}
+
+ShaderPreprocessorError::ShaderPreprocessorError(
+    Codes err_code,
+    const std::string& arg,
+    const std::string& file,
+    int line
+) : code(err_code), std::runtime_error(formatDebugString(errorCodeParser(err_code, arg), file, line)) {}
+
+std::string ShaderPreprocessorError::errorCodeParser(Codes err_code, const std::string& arg) {
+    switch(err_code) {
+        case Codes::FILE_NOT_FOUND:
+            return "File '" + arg + "' not found.";
+        case Codes::BUILTIN_NOT_FOUND:
+            return "Built-in '" + arg + "' not found.";
+        case Codes::CUSTOM:
+        case Codes::UNDEFINED:
+            return arg;
+        case Codes::NONE:
+        default:
+            return "";
+    }
+}
+
+// ShaderError class
+ShaderError::ShaderError(
+    const std::string& msg,
+    const char* shad,
+    const std::string& file,
+    int line
+) : std::runtime_error(formatString(msg, shad, file, line)) {}
+
+std::string ShaderError::formatString(
+    const std::string& msg,
+    const char* shad,
+    const std::string& file,
+    int line
+) {
+    std::stringstream ret;
+    if (file != "") {
+        ret << "In file " << file;
+        if (line >= 0) {
+            ret << " at line " << line;
+        }
+        ret << ":\n\t";
+    }
+    ret << msg;
+    if (shad != nullptr) {
+        ret << " with shader error: " << shad;
+    }
+    return ret.str();
+}
+
+// ShaderPreprocessor class
+std::string ShaderPreprocessor::TokenName(const ShaderPreprocessor::TokenType& x) {
+    switch(x) {
+        case TK:
+            return "Token";
+            break;
+        case DR:
+            return "Directive";
+            break;
+        case WS:
+            return "Whitespace";
+            break;
+        case NL:
+            return "NewLine";
+            break;
+        case LC:
+            return "LineComment";
+            break;
+        case BC:
+            return "BlockComment";
+            break;
+        default:
+            return "Unrecognized";
+            break;
+    }
+}
+
+ShaderPreprocessor::ShaderPreprocessor() {}
+
+File ShaderPreprocessor::loadFromBase(const std::string path, const std::string base) const {
+    File ret;
+    std::ifstream filestream;
+    filestream.open(base + path);
+    if (filestream.is_open()) {
+        ret.path = get_file_path(base + path);
+        ret.src << filestream.rdbuf();
+        return ret;
+    }
+    filestream.close();
+    std::string ext;
+    for (const auto& kv : AcceptedExtensions) {
+        ext = kv.first;
+        filestream.open(base + path + ext);
+        if (filestream.is_open()) {
+            ret.path = get_file_path(base + path + ext);
+            ret.src << filestream.rdbuf();
+            return ret;
+        }
+        filestream.close();
+    }
+    throw ShaderPreprocessorError(Codes::FILE_NOT_FOUND, base + path);
+}
+
+File ShaderPreprocessor::loadFromDirectories(const std::string name) const {
+    File ret;
+    std::ifstream fstream;
+    for (const std::string& path : Directories) {
+        fstream.open(path + name);
+        if (fstream.is_open()) {
+            ret.path = get_file_path(path + name);
+            ret.src << fstream.rdbuf();
+            return ret;
+        }
+        fstream.close();
+    }
+    throw ShaderPreprocessorError(Codes::FILE_NOT_FOUND, name);
+}
+
+File ShaderPreprocessor::load(const std::string path, bool builtin_first) const {
+    if(builtin_first) {
+        return load_BuiltInFirst(path);
+    }
+    return load_FilesFirst(path);
+}
+
+File ShaderPreprocessor::loadFromBuiltIn(const std::string name) const {
+    File ret;
+    //std::stringstream ret;
+    decltype(BuiltIns)::const_iterator builtin_it = BuiltIns.find(name);
+    if (builtin_it != BuiltIns.end()) {
+        ret.path = File::FilePath{"builtin:", name, ""};
+        ret.src << builtin_it->second;
+        return ret;
+    }
+    throw ShaderPreprocessorError(Codes::BUILTIN_NOT_FOUND, name);
+}
+
+File ShaderPreprocessor::load_FilesFirst(const std::string path) const {
+    try {
+        return loadFromBase(path);
+    } catch (ShaderPreprocessorError e) {
+        if (e.code == Codes::FILE_NOT_FOUND) {
+            try {
+                return loadFromDirectories(path);
+            } catch (ShaderPreprocessorError f) {
+                if (f.code == Codes::FILE_NOT_FOUND) {
+                    try {
+                        return loadFromBuiltIn(path);
+                    } catch(ShaderPreprocessorError g) {
+                        if (g.code == Codes::BUILTIN_NOT_FOUND) {
+                            throw ShaderPreprocessorError(Codes::FILE_NOT_FOUND, path);
+                        } else { throw g; }
+                    }
+                } else { throw f; }
+            }
+        } else { throw e; }
+    }
+}
+
+File ShaderPreprocessor::load_BuiltInFirst(const std::string path) const {
+    try {
+        return loadFromBuiltIn(path);
+    } catch (ShaderPreprocessorError f) {
+        if (f.code == Codes::BUILTIN_NOT_FOUND) {
+            try {
+                return loadFromDirectories(path);
+            } catch (ShaderPreprocessorError e) {
+                if (e.code == Codes::FILE_NOT_FOUND) {
+                    return loadFromBase(path);
+                } else {
+                    throw e;
+                }
+            }
+        } else {
+            throw f;
+        }
+    }
+    
+}
+
+std::vector<ShaderPreprocessor::Token> ShaderPreprocessor::tokenize(const std::string& code) const {
+    enum State {
+        FSlash,
+        WhiteSpace,
+        LineComment,
+        BlockComment,
+        BlockCommentEndStar,
+        Directive,
+        Token
+    };
+    
+    std::vector<ShaderPreprocessor::Token> tks;
+    
+    std::string token = "";
+    State state = WhiteSpace;
+    for(char c : code) {
+        if (c==13) {
+            continue;
+        }
+        switch(state) {
+            case WhiteSpace:
+                if (c=='/') {
+                    if (token != "") { tks.push_back({WS, token}); }
+                    token = c;
+                    state = FSlash;
+                } else if (c=='#') {
+                    if (token != "") { tks.push_back({WS, token}); }
+                    token = c;
+                    state = Directive;
+                } else if (c=='\n') {
+                    if (token != "") { tks.push_back({WS, token}); }
+                    tks.push_back({NL, "\n"});
+                    token = "";
+                    state = WhiteSpace;
+                } else if (std::isblank(c)) {
+                    token += c;
+                } else {
+                    if (token != "") { tks.push_back({WS, token}); }
+                    token = c;
+                    state = Token;
+                }
+                break;
+            case FSlash:
+                if (c=='/') {
+                    token += c;
+                    state = LineComment;
+                } else if (c=='*') {
+                    token += c;
+                    state = BlockComment;
+                } else if (c=='\n') {
+                    tks.push_back({TK, token});
+                    tks.push_back({NL, "\n"});
+                    token = "";
+                    state = WhiteSpace;
+                } else if (std::isblank(c)) {
+                    tks.push_back({TK, token});
+                    token = c;
+                }else {
+                    token += c;
+                    state = Token;
+                }
+                break;
+            case LineComment:
+                if (c=='\n') {
+                    tks.push_back({LC, token});
+                    tks.push_back({NL, "\n"});
+                    token = "";
+                    state = WhiteSpace;
+                } else {
+                    token += c;
+                }
+                break;
+            case BlockComment:
+                token += c;
+                if (c=='*') {
+                    state = BlockCommentEndStar;
+                }
+                break;
+            case BlockCommentEndStar:
+                token += c;
+                if (c=='/') {
+                    tks.push_back({BC, token});
+                    token = "";
+                    state = WhiteSpace;
+                } else {
+                    state = BlockComment;
+                }
+                break;
+            case Directive:
+                if (c=='\n') {
+                    tks.push_back({DR, token});
+                    tks.push_back({NL, "\n"});
+                    token = "";
+                    state = WhiteSpace;
+                } else if (c=='/') {
+                    tks.push_back({DR, token});
+                    token = c;
+                    state = FSlash;
+                } else {
+                    token += c;
+                }
+                break;
+            case Token:
+                if (c=='\n') {
+                    tks.push_back({TK, token});
+                    tks.push_back({NL, "\n"});
+                    token = "";
+                    state = WhiteSpace;
+                } else if (std::isblank(c)) {
+                    tks.push_back({TK, token});
+                    token = c;
+                    state = WhiteSpace;
+                } else if (c=='/') {
+                    tks.push_back({TK, token});
+                    token = c;
+                    state = FSlash;
+                }else {
+                    token += c;
+                }
+                break;
+            default:
+                break;
+        }
+        
+    }
+
+    switch(state) {
+        case WhiteSpace:
+            if (token != "") { tks.push_back({WS, token}); }
+        case FSlash:
+            tks.push_back({TK, token});
+            break;
+        case LineComment:
+            tks.push_back({LC, token});
+            break;
+        case BlockComment:
+        case BlockCommentEndStar:
+            tks.push_back({BC, token});
+            break;
+        case Directive:
+            tks.push_back({DR, token});
+            break;
+        case Token:
+            tks.push_back({TK, token});
+            break;
+        default:
+            break;
+    }
+
+    return tks;
+}
+
+ShaderUnit& ShaderPreprocessor::preprocess(const std::string& code, ShaderUnit& shad) const {
+    typedef ShaderPreprocessor::Token Token;
+    std::vector<Token> tks = tokenize(code);
+    
+    for (int i{0}; i < tks.size(); ++i) {
+        switch(tks[i].first) {
+            case DR:
+                directive_dispatch(shad, tks[i].second);
+                break;
+            case TK:
+            case NL:
+            case LC:
+            case BC:
+            case WS:
+            default:
+                shad.preprocSource += tks[i].second;
+                break;
+        }
+    }
+    
+    if (shad.vMajor == 0 && shad.vMinor == 0) {
+        shad.vMajor = 1;
+        shad.vMinor = 10;
+    }
+    return shad;
+}
+
+ShaderUnit ShaderPreprocessor::preprocess(File file, GLenum shader_type) const {
+    ShaderUnit ret;
+    ret.file = file;
+    if (shader_type) {
+        ret.type = shader_type;
+    } else {
+        decltype(AcceptedExtensions.begin()) find_type = AcceptedExtensions.find(file.path.ext);
+        if (find_type != AcceptedExtensions.end()) {
+            ret.type = find_type->second;
+        }
+    }
+    preprocess(file.src.str(), ret);
+    return ret;
+}
+
+ShaderUnit ShaderPreprocessor::preprocess(const std::string& code, GLenum shader_type) const {
+    File local;
+    local.path = File::FilePath{"live:", "live", ".shad"};
+    return preprocess(local, shader_type);
+}
+
+ShaderProgram ShaderPreprocessor::CreateShaderProgram(std::vector<std::string> shads) const {
+    std::vector<ShaderUnit> _shader_units;
+    for (const auto& name : shads) {
+        _shader_units.push_back(preprocess(load(name)));
+    }
+    return ShaderProgram::CreateShaderProgram(_shader_units);
+}
+
+ShaderProgram ShaderPreprocessor::ReloadFromFile(const ShaderProgram& rhs) const {
+    std::vector<std::string> shader_names;
+    shader_names.reserve(rhs._shader_units.size());
+    std::string filename;
+    for (const ShaderUnit& shad : rhs._shader_units) {
+        filename = shad.file.path.dir + shad.file.path.basename + shad.file.path.ext;
+        shader_names.emplace_back(filename);
+    }
+    return CreateShaderProgram(shader_names);
+}
+
+bool ShaderPreprocessor::directive_dispatch(ShaderUnit& shad, const std::string& line) const {
+    StringVec dir_tks = {""};
+    for (char c : line) {
+        if (std::isblank(c)) {
+            if (dir_tks.back() != "") {
+                dir_tks.push_back("");
+            }
+        } else {
+            dir_tks.back() += c;
+        }
+    }
+    if (!dir_tks.size()) { return false; }
+
+    if (dir_tks[0][0] != '#') { return false; }
+
+    if (dir_tks[0] == "#define") {
+        return preprocessor_define(shad, dir_tks, line);
+    } else if (dir_tks[0] == "#version") {
+        return preprocessor_version(shad, dir_tks, line);
+    } else if (dir_tks[0] == "#include") {
+        return preprocessor_include(shad, dir_tks, line);
+    }
+    return false;
+}
+
+typedef std::vector<std::string> StringVec;
+
+bool ShaderPreprocessor::preprocessor_include(
+    ShaderUnit& shad,
+    const StringVec& tokens,
+    const std::string& line
+) const
+{
+    try {
+        if (tokens[0] != "#include") { return false; }
+    } catch (std::out_of_range e) {
+        return false;
+    }
+    std::string path = "";
+    for (const auto& tk : tokens) {
+        if (tk != tokens.front()) {
+            path += tk;
+        }
+    }
+    // Add file-inclusion base + 
+    // Do path cleanup + 
+    // Restructure preprocessing data flow
+    std::string filename = path.substr(1, path.size()-2);
+    try {
+        if (path[0] == '"' && path.back() == '"') {
+            preprocess(load(filename).src.str(), shad);
+            return true;
+        } else if (path[0] == '<' && path.back() == '>') {
+            preprocess(load(filename, true).src.str(), shad);
+            return true;
+        }
+    } catch (ShaderPreprocessorError e) {
+        if (e.code == Codes::FILE_NOT_FOUND) {
+            std::cout << "COULD NOT FIND " << filename << ".\n";
+        } else {
+            throw e;
+        }
+    }
+    return false;
+}
+
+bool ShaderPreprocessor::preprocessor_define(ShaderUnit& shad, const StringVec& tokens, const std::string& line) const {
+    shad.preprocSource += line;
+    try {
+        if (tokens[0] != "#define") { return false; }
+        try {
+            shad.defines[tokens[1]] = tokens[2];
+        } catch (std::length_error& f) {
+            shad.defines[tokens[1]] = "";
+        }
+        return true;
+    } catch (std::out_of_range& e) {
+        return false;
+    }
+}
+
+bool ShaderPreprocessor::preprocessor_version(ShaderUnit& shad, const StringVec& tokens, const std::string& line) const {
+    shad.preprocSource += line;
+    std::cout << "Shader version: ";
+    try {
+        if (tokens[0] != "#version") { return false; }
+        if (tokens[1].size() == 3) {
+            short vMajor = tokens[1][0]-'0';
+            short vMinorA = tokens[1][1]-'0';
+            short vMinorB = tokens[1][2]-'0';
+            if (vMajor > 10 || vMinorA > 10 || vMinorB > 10) {
+                return false;
+            }
+            shad.vMajor = vMajor;
+            shad.vMinor = vMinorA*10 + vMinorB;
+            shad.profile = AcceptedProfiles.at(tokens[2]);
+            std::cout << shad.vMajor << "." << shad.vMinor << "\n";
+            return true;
+        } else {
+            return false;
+        }
+    } catch (std::out_of_range& e) {
+        return false;
+    }
+}
+
+
+/* bool ShaderPreprocessor::preprocessor_uniform(
+    ShaderUnit& shad,
+    const std::string& type,
+    const std::string& name
+) const {
+    std::string type_str = "";
+    unsigned int type_str_len = 0;
+    for (const char& c : type) {
+        if (type_str_len) {
+            if (std::isdigit(c)) {
+                type_str += c;
+                continue;
+            } else if (c=='[') {
+                type_str += '_';
+            }else if (c == ']' || std::isblank(c)){
+                continue;
+            } else {
+                return false;
+            }
+        } else {
+            if (std::isalnum(c)) {
+                type_str += c;
+                continue;
+            } else if (c == '[') {
+                type_str_len = type_str.length();
+                type_str += '_';
+                continue;
+            } else {
+                return false;
+            }
+        }
+    }
+    std::string name_str = "";
+    unsigned int name_str_len = 0;
+    for (const char& c : name) {
+        if (c == ';') {
+            break;
+        }
+        if (name_str_len) {
+            if (std::isdigit(c)) {
+                type_str.insert(type_str_len, 1, c);
+                type_str_len++;
+                continue;
+            } else if (c=='[') {
+                type_str.insert(type_str_len, "_");
+                type_str_len++;
+                continue;
+            }else if (c == ']' || std::isblank(c)){
+                continue;
+            } else {
+                return false;
+            }
+        } else {
+            if (std::isalnum(c)) {
+                name_str += c;
+                continue;
+            } else if ( c == '[') {
+                name_str_len = name_str.length();
+                type_str.insert(type_str_len, "_");
+                type_str_len++;
+                continue;
+            } else {
+                return false;
+            }
+        }
+    }
+    shad.uniforms.push_back(UniformHandle{
+        name_str,
+        type_str,
+        0x0,
+        0x0
+    });
+    return true;
+} */
+
+
+// ShaderProgram
+
+ShaderProgram::ShaderProgram(ShaderProgram&& rhs) {
+    _shader_units = rhs._shader_units;
+    _id = rhs._id;
+    rhs._id = 0;
+}
+
+ShaderProgram::~ShaderProgram() {
+    glDeleteProgram(_id);
+}
+
+ShaderProgram& ShaderProgram::operator=(ShaderProgram&& rhs) {
+    _shader_units = rhs._shader_units;
+    _id = rhs._id;
+    rhs._id = 0;
+    return *this;
+}
+
+
+ShaderProgram ShaderProgram::CreateShaderProgram(std::vector<ShaderUnit>& shaders) {
+    int success;
+    ShaderProgram ret(shaders);
+    char infoLog[512];
+    unsigned int shad_id;
+    std::vector<unsigned int> shad_ids;
+    shad_ids.reserve(shaders.size());
+    for (auto& shad : ret._shader_units) {
+        const char* source = shad.preprocSource.data();
+        shad_id = glCreateShader(shad.type);
+        shad_ids.emplace_back(shad_id);
+        glShaderSource(shad_id, 1, &source, NULL);
+        glCompileShader(shad_id);
+        glGetShaderiv(shad_id, GL_COMPILE_STATUS, &success);
+        if (!success) {
+            glGetShaderInfoLog(shad_id, 512, NULL, infoLog);
+            File::FilePath& fp = shad.file.path;
+            std::string filename = fp.dir + fp.basename + fp.ext;
+            // std::cout << "Could not compile '" + filename + "': " << infoLog << "\n";
+            // return *ret;
+            throw ShaderError("Could not compile '" + filename + "'.", infoLog);
+        }
+    }
+    
+    ret._id = glCreateProgram();
+    for(auto& id : shad_ids) {
+        glAttachShader(ret._id, id);
+    }
+    glLinkProgram(ret._id);
+    glGetProgramiv(ret._id, GL_LINK_STATUS, &success);
+    if (!success) {
+        glGetProgramInfoLog(ret._id, 512, NULL, infoLog);
+        throw ShaderError("Could not link shader program.", infoLog);
+    }
+    for (auto& id : shad_ids) {
+        glDeleteShader(id);
+    }
+    return ret;
+}
+
+unsigned int ShaderProgram::id() const { return _id; }
+
+void ShaderProgram::use() const {
+    glUseProgram(_id);
+}
+
+std::vector<ShaderUnit> ShaderProgram::getShaders() const {
+    return _shader_units;
+}
+
+ShaderUnit ShaderProgram::getShaders(unsigned int idx) const {
+    return _shader_units[idx];
+}
+
+void ShaderProgram::setBool(const std::string& name, bool value) const {
+    glUniform1i(glGetUniformLocation(_id, name.c_str()), (int)value);
+}
+
+void ShaderProgram::setInt(const std::string& name, int value) const {
+    glUniform1i(glGetUniformLocation(_id, name.c_str()), (int)value);
+}
+
+void ShaderProgram::setFloat(const std::string& name, float value) const {
+    glUniform1f(glGetUniformLocation(_id, name.c_str()), (int)value);
+}
+
+void ShaderProgram::setMat4(const std::string& name, glm::mat4& value) const {
+    glUniformMatrix4fv(glGetUniformLocation(_id, name.c_str()), 1, GL_FALSE, glm::value_ptr(value));
+} 
+
+/* // Shader class
+Shader::Shader() { _id = 0x0; }
+
+Shader::Shader(const Shader& cpy_shader) { _id = cpy_shader._id; }
+
+Shader& Shader::operator=(const Shader& cpy_shader) { _id = cpy_shader._id; return *this; }
+
+void Shader::use() const{
+    glUseProgram(_id);
+}
+
+*/
+
+}

engine/NBGraphics/tests/CMakeLists.txt

@@ -1,14 +0,0 @@
-cmake_minimum_required(VERSION 3.26.0)
-
-if (NB_BUILD_TESTS)
-    enable_testing()
-    include(GoogleTest)
-    add_executable(TestWindow
-        ./TestWindow.cpp
-    )
-    target_link_libraries(TestWindow
-        NBCore
-        NBGraphics
-    )
-
-endif()

engine/NBGraphics/tests/TestWindow.cpp

@@ -1,62 +0,0 @@
-#include "GLLoad.hpp"
-#include "ProgramPipeline.hpp"
-#include "VertexArray.hpp"
-#include "Window.hpp"
-
-int main() {
-    nb::logger.log("Howdy!");
-    nb::Window window(200, 200, "Hello!");
-    window.setWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-    window.setWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
-    window.init();
-
-    nb::logger.log("Goob");
-
-    auto vert = std::make_shared<nb::Shader>(
-        GL_VERTEX_SHADER,
-        "#version 330 core\n"
-        "layout (location = 0) in vec2 aPos;\n"
-        "void main()\n"
-        "{\n"
-        "   gl_Position = vec4(aPos.x, aPos.y, 0.0, 1.0);\n"
-        "}\0"
-    );
-
-    LOG("Vertex Shader: " + vert->log());
-
-    auto frag = std::make_shared<nb::Shader>(
-        GL_FRAGMENT_SHADER,
-        "#version 330 core\n"
-        "out vec4 FragColor;\n"
-        "void main()\n"
-        "{\n"
-        "   FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
-        "}\n\0"
-    );
-
-    LOG("Fragment shader: " + frag->log());
-
-    nb::ByteVector data = nb::vectorToBytes<float>({
-       -0.5, -0.5, 0.5, -0.5, 0.0, 0.5 
-    });
-
-    nb::Program prog({vert, frag});
-    prog.bind();
-
-    nb::VertexGroup tri(data, {
-        nb::VertexAttribute{
-            2,
-            GL_FLOAT,
-            false,
-            {0, 8}
-        }
-    });
-    tri.bind();
-
-    GLFWwindow* window_ptr = window.getWindow();
-    while(!glfwWindowShouldClose(window_ptr)) {
-        glDrawArrays(GL_TRIANGLES, 0, 3);
-    }    
-
-    return 0;
-}