Error logging almost working!

CMakeLists.txt

@@ -7,10 +7,6 @@ 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 "")
@@ -32,42 +28,12 @@ if(CMAKE_BUILD_TYPE STREQUAL "Release")
     message(STATUS "Targeting Release build")
 elseif(CMAKE_BUILD_TYPE STREQUAL "Debug")
     message(STATUS "Targeting Debug build")
-    set(NB_DEBUG_BUILD ON)
+    set(NB_LOGGING 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)
@@ -89,6 +55,7 @@ if(NB_BUILD_TESTS)
         FetchContent_MakeAvailable(gtest)
     endif()
     set(GTEST_COLOR ON)
+    set(GLFW_BUILD_TESTS ON CACHE BOOL "" FORCE)
 endif()
 
 if (NB_LOGGING)
@@ -97,16 +64,19 @@ 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)
-endif()
-if(NB_TARGET_LINUX)
+elseif (NB_TARGET_LINUX)
     add_compile_definitions(_NB_TARGET_LINUX)
 endif()
 
-get_filename_component(NBENGINE_ROOT ${CMAKE_CURRENT_LIST_DIR} ABSOLUTE)
+# External Dep paths
+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 ${PROJECT_BINARY_DIR}/${CMAKE_BUILD_TYPE})
+add_subdirectory(./engine)
 
 # Toggle
 set(NB_REBUILD_DOCS)
@@ -114,24 +84,3 @@ 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

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

README.md

@@ -1,23 +1,21 @@
 # NBEngine
 
+My own GUI (and related stuff needed for GUI programs) engine. I suck at coding. Do not judge.
+
 ## Current Implemented Libraries
 
 These are subject to (hopefully) grow in size as more stuff gets added.
 
-* NBCore: Core/foundational functionality for all other subpackages to be built upon.
-    * Erroring and Logging
-    * Basic data structures and declarations
 * NBWindow: Creates and manages GLFW windows
 * NBEvents: Multithreading event manager. Very unstable. Sucks a lot.
 
 ## Dependencies and Foundations
 
-For Code:
+While the engine is intended to be a close-to-ground-up project, there's no point in reinventing the spokes that
+make up a wheel. This project utilizes and depends on (expected to change and grow):
 
 * GLFW
 * Glad
 
-For Repo:
-
-* gTest
-* doxygen
+Additionally, it's important to note that right now this project is on Windows only. I wanna work on this in Linux soon
+("soon" whatever that means. Maybe in like 5 years).

engine/CMakeLists.txt

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

engine/NBCore/CMakeLists.txt

@@ -1,86 +1,31 @@
-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/Errors.cpp
     ./src/Logger.cpp
     ./src/Processes.cpp
     ./src/StringUtils.cpp
     ./src/Utils.cpp
 )
+
 toAbsolutePath(NB_CORE_INCLUDE
-    ./include/NBCore/ANSITerm.hpp
-    ./include/NBCore/DataSink.hpp
-    ./include/NBCore/Errors.hpp
-    ./include/NBCore/ErrorsImpl.hpp
-    ./include/NBCore/Logger.hpp
-    ./include/NBCore/Printer.hpp
-    ./include/NBCore/Processes.hpp
-    ./include/NBCore/StringUtils.hpp
-    ./include/NBCore/ThreadsafeQueue.hpp
-    ./include/NBCore/Types.hpp
-    ./include/NBCore/TypeTraits.hpp
-    ./include/NBCore/Utils.hpp
+    ./ANSITerm.hpp
+    ./DataSink.hpp
+    ./Errors.hpp
+    ./Logger.hpp
+    ./Processes.hpp
+    ./StringUtils.hpp
+    ./ThreadsafeQueue.hpp
+    ./Types.hpp
+    ./TypeTraits.hpp
+    ./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 
-)
 
-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()
+target_include_directories(NBCore PUBLIC ./.)
 
 if (NB_BUILD_TESTS)
-    add_subdirectory(./tests )
+    add_subdirectory(./tests)
 endif()

engine/NBCore/DataSink.hpp

@@ -0,0 +1,134 @@
+#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 && (_runningThread!=nullptr);
+    }
+    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

@@ -0,0 +1,243 @@
+#pragma once
+#ifndef _NB_ERROR
+#define _NB_ERROR
+
+#include <exception>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include "TypeTraits.hpp"
+#include <unordered_map>
+#include "StringUtils.hpp"
+
+namespace nb {
+
+typedef std::unordered_map<unsigned int, const char*> ErrorCodeMap;
+
+template <typename T>
+using has_type = decltype(T::type);
+
+template<class ErrorType = NoneType>
+class ErrorBase;
+
+template<>
+class ErrorBase<NoneType> : public std::exception {
+public:
+    const unsigned int code;
+    const std::string msg;
+    const std::shared_ptr<const std::exception> trace;
+    const bool traceIsNBError;
+
+    virtual inline std::string str() const noexcept = 0;
+
+    virtual const char* what() const noexcept override final {
+        const std::string& ret = str();
+        return ret.c_str();
+    }
+
+protected:
+    template <
+        typename TraceType = std::exception,
+        std::enable_if_t<std::is_base_of_v<std::exception, TraceType>, bool> = true
+    >
+    ErrorBase(
+        const unsigned int& code_,
+        const std::string& msg_,
+        const std::shared_ptr<TraceType> trace_,
+        const unsigned int& line_,
+        std::string filename_
+    ) noexcept :
+        code(code_),
+        msg(msg_),
+        trace{std::dynamic_pointer_cast<std::exception>(trace_)},
+        traceIsNBError( trace_ ? is_detected<has_type, TraceType>::value : false)
+    {
+        static_assert(std::is_base_of<std::exception, TraceType>::value,
+            "`trace_` must be a pointer to a child object of std::exception."
+        );
+    }
+};
+
+template <class ErrorType>
+class ErrorBase : public ErrorBase<NoneType> {
+    using Base = ErrorBase<NoneType>;
+public:
+    ErrorBase(const ErrorBase&) = default;
+    ErrorBase& operator=(const ErrorBase&) = delete;
+
+    virtual inline std::string str() const noexcept override {
+        std::string ret = msg + nb::NEWLINE;
+        if (trace) {
+            const std::string tabover = "  ";
+            std::string trace_msg;
+            if (traceIsNBError) { 
+                trace_msg = std::static_pointer_cast<const ErrorBase>(trace)->str();
+                trace_msg = std::string(std::string_view(trace_msg).substr(
+                    0, trace_msg.length()-nb::NEWLINE.length()
+                ));
+            } else {
+                trace_msg = std::string(trace->what());
+            }
+            ret += indent_strblock(trace_msg, tabover, tabover+"Trace: ")+nb::NEWLINE;
+        }
+        return ret;
+    }
+
+    static const std::string type;
+    static const ErrorCodeMap ErrorMessages; 
+
+    using Base::code;
+    using Base::msg;
+    using Base::trace;
+    using Base::traceIsNBError;
+
+protected:
+    using Base::Base;
+
+    template <
+        typename TraceType = std::exception,
+        std::enable_if_t<std::is_base_of_v<std::exception, TraceType>, bool> = true
+    >
+    ErrorBase(
+        const unsigned int code_,
+        std::string msg_,
+        const TraceType* trace_=nullptr,
+        unsigned int line_=0,
+        std::string filename_=""
+    ) : Base(
+        code_,
+        msg_, 
+        trace_ ? std::make_shared<TraceType>(*trace_) : nullptr, 
+        line_, 
+        filename_
+    ) {
+        static_assert(std::is_same<const std::unordered_map<unsigned int, const char*>, decltype(ErrorType::ErrorMessages)>::value,
+            "const std::unordered_map<unsigned int, const char*> ErrorMessages must be "
+            "a class member."
+        );
+        static_assert(std::is_enum_v<typename ErrorType::Codes>, "enum Codes must be a class member.");
+        static_assert(std::is_same<std::underlying_type_t<typename ErrorType::Codes>, unsigned int>::value,
+            "enum Codes must be of underlying type unsigned int."
+        );
+        static_assert(std::is_same<const std::string, decltype(ErrorType::type)>::value,
+            "const std::string type must be a class member."
+        );
+    }
+
+    template <
+        typename TraceType,
+        std::enable_if_t<std::is_base_of_v<std::exception, TraceType>, bool> = true
+    >
+    ErrorBase(
+        const unsigned int& code_,
+        const TraceType& trace_,
+        unsigned int line_=0,
+        std::string filename_=""
+    ) noexcept : ErrorBase(
+        code_, 
+        ErrorType::ErrorMessages.at(code_),
+        &trace_,
+        line_,
+        filename_
+    ) {}
+
+    template <
+        typename TraceType,
+        std::enable_if_t<std::is_base_of_v<std::exception, TraceType>, bool> = true
+    >
+    ErrorBase(
+        const std::string& msg_,
+        const TraceType& trace_,
+        unsigned int line_=0,
+        std::string filename_=""
+    ) noexcept : ErrorBase(
+        0, 
+        msg_,
+        &trace_,
+        line_,
+        filename_
+    ) {}
+
+    ErrorBase(
+        const unsigned int& code_,
+        unsigned int line_=0,
+        std::string filename_=""
+    ) noexcept : ErrorBase(
+        code_, 
+        ErrorType::ErrorMessages.at(code_),
+        static_cast<std::exception*>(nullptr),
+        line_,
+        filename_
+    ) {}
+
+    ErrorBase(
+        const std::string& msg_,
+        unsigned int line_=0,
+        std::string filename_=""
+    ) noexcept : ErrorBase(
+        0, 
+        msg_,
+        static_cast<std::exception*>(nullptr),
+        line_,
+        filename_
+    ) {}
+};
+template <typename ErrorType>
+const std::string ErrorBase<ErrorType>::type = ErrorType::type;
+template <typename ErrorType>
+const ErrorCodeMap ErrorBase<ErrorType>::ErrorMessages = ErrorType::ErrorMessages;
+
+template <class ErrorType = NoneType>
+class Error;
+
+template<>
+class Error<NoneType>;
+
+template <class ErrorType>
+class Error : public ErrorBase<ErrorType> {
+    using Base = ErrorBase<ErrorType>;
+public:    
+    template <typename... Args>
+    Error(Args... args) : Base(args...) {}
+
+    using Base::str;
+    using Base::what;
+    using Base::code;
+    using Base::msg;
+    using Base::trace;
+    using Base::traceIsNBError;
+    using Base::type;
+    using Base::ErrorMessages;
+
+    friend ErrorBase<Error>;
+};
+
+template<>
+class Error<NoneType> : public ErrorBase<Error<NoneType>> {
+    using Base = ErrorBase<Error<NoneType>>;
+public:
+    using Base::Base;
+    Error() : Base(0) {}
+    
+    template <typename... Args>
+    Error(Args... args) : Base(args...) {}
+
+    enum Codes : unsigned int {
+        GENERAL, UNDEFINED, BADERRORCODE
+    };
+
+    using Base::str;
+    using Base::what;
+
+    using Base::code;
+    using Base::msg;
+    using Base::trace;
+    using Base::traceIsNBError;
+    static const std::string type;
+    static const ErrorCodeMap ErrorMessages;
+};
+
+} // namespace nb
+
+#endif // _NB_ERROR

engine/NBCore/Logger.hpp

@@ -0,0 +1,153 @@
+#pragma once
+#ifndef _NB_LOGGER
+#define _NB_LOGGER
+
+#include <chrono>
+#include <ostream>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "DataSink.hpp"
+#include "Processes.hpp"
+#include "ThreadSafeQueue.hpp"
+#include "TypeTraits.hpp"
+
+namespace nb {
+
+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 (!type_ptr->isRunning()) {
+            this->_running = true;
+            this->_runningThread = std::make_shared<std::thread>([&]{
+                while(type_ptr->isRunning()) {
+                    type_ptr->flush();
+                }
+                type_ptr->flush();
+            });
+        }
+        return type_ptr->isRunning();
+    }
+protected:
+    LoggerBase() = default;
+
+    StreamType _ostream;
+
+private:
+    LoggerType* type_ptr = static_cast<LoggerType*>(this);
+};
+
+struct LogEvent{
+    const LoggerTimePoint time;
+    const unsigned char lvl;
+    const std::string msg;
+    const std::thread::id tid;
+    const uint64_t pid;
+};
+
+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() { type_ptr->stop(); }
+
+    void log(const std::string& msg, const uint8_t& lvl=0x00) {
+        type_ptr->push(LogEvent{
+            std::chrono::system_clock::now(),
+            lvl,
+            msg,
+            std::this_thread::get_id(),
+            GetPID(),
+        });
+    }
+
+    template <size_t N>
+    void log(char const(&msg) [N], const uint8_t& lvl=0x00) {
+        type_ptr->log(std::string(msg), lvl);
+    }
+
+    void log(const std::exception& err, const uint8_t& lvl=0xFF) {
+        type_ptr->log(err.what(), lvl);
+    }
+
+    template<typename U>
+    void warn(const U& val, const uint8_t& lvl=0x01) { type_ptr->log(val, lvl); }
+
+    template<typename U>
+    void error(const U& val) { type_ptr->log(val, 0xFF); }
+
+protected:
+    std::vector<std::ostream*> _ostream;
+
+private:
+    LoggerType* type_ptr = static_cast<LoggerType*>(this);
+};
+
+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);
+};  
+
+#ifndef _NB_NO_LOGGER
+extern DefaultDebugLogger logger;
+#endif // _NB_NO_LOGGER
+
+// Taking Charge of Adult ADHD by Russell Barkley
+
+} // namespace nb
+
+#ifndef CONSTRUCT_ERROR
+    #ifdef _NB_CODE_ERROR_LOCATIONS
+        #define CONSTRUCT_ERROR(type, ...) type(# __VA_ARGS__, __LINE__, __FILE__)
+    #else
+        #define CONSTRUCT_ERROR(type, ...) type(__VA_ARGS__)
+    #endif // _NB_CODE_ERROR_LOCATIONS
+#endif // CONSTRUCT_ERROR
+
+#ifndef THROW
+    #ifdef _NB_AUTOLOG
+        #define THROW(type, ...) {auto x = CONSTRUCT_ERROR(type, ## __VA_ARGS__); nb::logger.error(x); throw x;}
+    #else
+        #define THROW(type, ...) throw CONSTRUCT_ERROR(type, __VA_ARGS__)
+    #endif // _NB_AUTOLOG
+#endif // THROW
+
+#endif // _NB_LOGGER

engine/NBCore/NBCoreConfig.cmake.in

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

engine/NBCore/Processes.hpp

@@ -7,8 +7,6 @@
 namespace nb {
 
 uint64_t GetPID();
-uint64_t getTID();
-
 
 } // namespace nb
 

engine/NBCore/StringUtils.hpp

@@ -0,0 +1,142 @@
+#pragma once
+#ifndef _NB_CORE_TYPES
+#define _NB_CORE_TYPES
+
+#include <iostream>
+#include <string>
+#include <type_traits>
+
+#include "TypeTraits.hpp"
+
+namespace nb {
+
+#ifdef _NB_TARGET_WINDOWS
+    const std::string NEWLINE = "\n";
+    const std::wstring WNEWLINE = L"\n";
+#endif // _NB_TARGET_WINDOWS
+#ifdef _NB_TARGET_LINUX
+    const std::string NEWLINE = "\n";
+    const std::wstring WNEWLINE = L"\n";
+#endif // _NB_TARGET_LINUX
+
+template <typename... T>
+using StringConvertible = ValidConversion<std::string, T...>;
+
+template <typename... T>
+using WStringConvertible = ValidConversion<std::wstring, T...>;
+
+template <typename... T>
+constexpr bool StringConvertible_v = StringConvertible<T...>::value;
+
+template <typename... T>
+constexpr bool WStringConvertible_v = WStringConvertible<T...>::value;
+
+template <typename... T>
+using StringConvertible_to = typename StringConvertible<T...>::to;
+
+template <typename... T>
+using WStringConvertible_to = typename WStringConvertible<T...>::to;
+
+template <typename... T>
+using StringConvertible_from = typename StringConvertible<T...>::from;
+
+template <typename... T>
+using WStringConvertible_from = typename WStringConvertible<T...>::from;
+
+template<typename T>
+std::enable_if_t<StringConvertible_v<T>, std::wstring> str_to_wstr(T in) {
+    std::string str(in);
+    std::wstring ret(str.begin(), str.end());
+    return ret;
+}
+
+template<typename T>
+std::enable_if_t<WStringConvertible_v<T>, std::string> wstr_to_str(T in) {
+    std::wstring wstr(in);
+    std::size_t wstrlen = wstr.length();
+    char* c_str= new char[wstrlen];
+    std::wcstombs(c_str, wstr.c_str(), wstrlen);
+    std::string ret(c_str, wstrlen);
+    delete[] c_str;
+    return ret;
+}
+
+template <typename Stream, typename... Args>
+void stream(Stream& s, Args&&... args);
+
+template <typename Stream, typename... Args>
+void stream(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 = std::string, typename A, typename B, typename C>
+ValidConversion_to<T, A, B, C> find_and_replace(
+    A original,
+    B find,
+    C replace
+) {
+    const T& find_t = T(find);
+    const T& replace_t = T(replace); 
+
+    T ret(original);
+
+    std::size_t find_len = find_t.length();
+    std::size_t replace_len = replace_t.length();
+    std::size_t currpos = 0;
+    while(true) {
+        currpos = ret.find(find_t, currpos);
+        if (currpos == T::npos) {
+            break;
+        }
+        ret = ret.erase(currpos, find_len);
+        ret = ret.insert(currpos, replace_t);
+        currpos += replace_len;
+    }
+    return ret;
+}
+
+template <typename A, typename B, typename C>
+StringConvertible_to<A, B, C> indent_strblock(
+    A block,
+    B prepend,
+    C topIndent
+) {
+    return std::string(topIndent) + find_and_replace<std::string>(
+        std::string(block),
+        nb::NEWLINE,
+        nb::NEWLINE + std::string(prepend)
+    );
+}
+
+template <typename A, typename B>
+StringConvertible_to<A, B> indent_strblock(
+    A block,
+    B prepend
+) {
+    return indent_strblock<A, B, B>(block, prepend, prepend);
+}
+
+/* template<typename T>
+T swap_endian(const T& val) {
+    T ret;
+    const int size = sizeof(T);
+    auto retLoc = static_cast<void*>(&ret);
+    auto valLoc = static_cast<const void*>(&val);
+
+    for (int i = 0; i < size; ++i) {
+        memcpy(retLoc+i, valLoc+(size-i-1), 1);
+    }
+    return ret;
+} */
+
+
+// using ByteVector = std::vector<uint8_t>;
+
+} // namespace nb
+#endif // _NB_CORE_TYPES

engine/NBCore/TypeTraits.hpp

@@ -33,9 +33,6 @@ 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
@@ -72,33 +69,6 @@ using ValidConversion_to = typename ValidConversion<Types...>::to;
 template<typename To, typename From>
 using ValidConversion_from = typename ValidConversion<To, From>::from;
 
-template <typename T>
-struct ExplicitType { using type=T; };
-
-template <typename T>
-using ExplicitType_t = typename ExplicitType<T>::type;
-
-template <typename T>
-T* NULLPTR = static_cast<T*>(nullptr);
-
-template <typename Func, typename T>
-struct RunAndOutput {
-    using type = T;
-    T value;
-    RunAndOutput(Func func, T val) : value(val) {
-        func();
-    }
-};
-
-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) {}
@@ -121,41 +91,6 @@ 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/Utils.hpp

@@ -0,0 +1,24 @@
+#pragma once
+#ifndef _NB_CORE_TYPES
+#define _NB_CORE_TYPES
+
+namespace nb {
+
+/* template<typename T>
+T swap_endian(const T& val) {
+    T ret;
+    const int size = sizeof(T);
+    auto retLoc = static_cast<void*>(&ret);
+    auto valLoc = static_cast<const void*>(&val);
+
+    for (int i = 0; i < size; ++i) {
+        memcpy(retLoc+i, valLoc+(size-i-1), 1);
+    }
+    return ret;
+} */
+
+
+// using ByteVector = std::vector<uint8_t>;
+
+} // namespace nb
+#endif // _NB_CORE_TYPES

engine/NBCore/include/NBCore/DataSink.hpp

@@ -1,184 +0,0 @@
-#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

@@ -1,65 +0,0 @@
-#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

@@ -1,171 +0,0 @@
-#pragma once
-#ifndef _NB_ERRORS_IMPL
-#define _NB_ERRORS_IMPL
-
-#include <exception>
-#include <memory>
-#include <string>
-#include <type_traits>
-
-#include <NBCore/StringUtils.hpp>
-#include <NBCore/Utils.hpp>
-
-namespace nb {
-
-using ErrorCodeMap = ConstantMap<unsigned int, std::string>;
-
-class ErrorBase {
-    protected:
-
-    public:
-    const unsigned int code;
-    const std::string msg;
-    const std::string type;
-    const std::shared_ptr<ErrorBase> trace;
-
-    ErrorBase(const ErrorBase&) = default;
-    ErrorBase(const std::exception&) noexcept;
-    virtual std::string what() const noexcept {
-        std::string ret = msg;
-        if (trace) {
-            std::string trace_msg = trace->what();
-            ret += NEWLINE + indent_strblock(
-                trace_msg,
-                TABOVER,
-                TABOVER+"Trace: "
-            );
-        }
-        return ret;
-    }
-    
-    protected:
-    ErrorBase(
-        unsigned int code_,
-        std::string msg_,
-        std::string type_,
-        std::shared_ptr<ErrorBase> trace_
-    ) noexcept :
-        code(code_),
-        msg(msg_),
-        type(type_),
-        trace{trace_}
-    {}
-};
-
-template <class ErrorType=NoneType>
-class Error : public ErrorBase {
-    private:
-    void inline check_asserts() {
-        static_assert(std::is_same<const ErrorCodeMap, decltype(ErrorType::ErrorMessages)>::value,
-            "const std::unordered_map<unsigned int, const char*> ErrorMessages must be "
-            "a class member."
-        );
-        static_assert(std::is_enum_v<typename ErrorType::Codes>, "enum Codes must be a class member.");
-        static_assert(std::is_same<std::underlying_type_t<typename ErrorType::Codes>, unsigned int>::value,
-            "enum Codes must be of underlying type unsigned int."
-        );
-        static_assert(std::is_same<const std::string, decltype(ErrorType::type)>::value,
-            "const std::string type must be a class member."
-        );
-    }
-    
-    public:
-    using ErrorBase::ErrorBase;
-
-    Error(
-        unsigned int code_,
-        const ErrorBase& trace_
-    ) noexcept : ErrorBase(
-        code_, 
-        ErrorType::ErrorMessages[code_],
-        ErrorType::type,
-        std::make_shared<ErrorBase>(trace_)
-    ) { check_asserts(); }
-
-    Error(
-        std::string msg_,
-        const ErrorBase& trace_
-    ) noexcept : ErrorBase(
-        ErrorType::Codes::UNDEFINED, 
-        msg_,
-        ErrorType::type,
-        std::make_shared<ErrorBase>(trace_)
-    ) { check_asserts(); }
-
-    Error(unsigned int code_) noexcept : ErrorBase(
-        code_, 
-        ErrorType::ErrorMessages[code_],
-        ErrorType::type,
-        nullptr
-    ) { check_asserts(); }
-
-    Error(std::string msg_) noexcept : ErrorBase(
-        ErrorType::Codes::UNDEFINED, 
-        msg_,
-        ErrorType::type,
-        nullptr
-    ) { check_asserts(); }
-
-    Error(
-        unsigned int code_,
-        const std::string& note_,
-        const ErrorBase& trace_
-    ) noexcept : ErrorBase(
-        code_,
-        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[code_] + " (" + note_ + ")",
-        ErrorType::type,
-        nullptr
-    ) { check_asserts(); }
-
-    using ErrorBase::what;
-    using ErrorBase::code;
-    using ErrorBase::msg;
-    using ErrorBase::trace;
-    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(
-        STANDARD,
-        std::string(err.what()),
-        "std::exception",
-        nullptr
-    ) {}
-};
-
-template<typename... Args>
-Error(Args...) -> Error<NoneType>;
-
-} // namespace nb
-
-#endif // _NB_ERRORS_IMPL

engine/NBCore/include/NBCore/Logger.hpp

@@ -1,250 +0,0 @@
-#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

@@ -1,52 +0,0 @@
-#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

@@ -1,60 +0,0 @@
-#pragma once
-#ifndef _NB_STRING_UTILS
-#define _NB_STRING_UTILS
-
-#include <string>
-#include <string_view>
-
-#include <NBCore/TypeTraits.hpp>
-
-namespace nb {
-
-#ifdef _NB_TARGET_WINDOWS
-    inline static const std::string NEWLINE = "\n";
-    inline static const std::wstring WNEWLINE = L"\n";
-#endif // _NB_TARGET_WINDOWS
-#ifdef _NB_TARGET_LINUX
-    inline const std::string NEWLINE = "\n";
-    inline const std::wstring WNEWLINE = L"\n";
-#endif // _NB_TARGET_LINUX
-
-const std::string TABOVER = "   ";
-
-template <typename T = char>
-std::basic_string<T> find_and_replace(
-    ExplicitType_t<std::basic_string<T>> original,
-    ExplicitType_t<std::basic_string_view<T>> find,
-    ExplicitType_t<std::basic_string_view<T>> replace
-) {
-    using StringType = std::basic_string<T>;
-
-    StringType ret(original);
-
-    std::size_t find_len = find.length();
-    std::size_t replace_len = replace.length();
-    std::size_t currpos = 0;
-    while(true) {
-        currpos = ret.find(find, currpos);
-        if (currpos == StringType::npos) {
-            break;
-        }
-        ret = ret.erase(currpos, find_len);
-        ret = ret.insert(currpos, replace);
-        currpos += replace_len;
-    }
-    return ret;
-}
-
-std::string indent_strblock(
-    std::string block,
-    std::string prepend,
-    std::string topIndent
-);
-
-std::string indent_strblock(
-    std::string block,
-    std::string prepend
-);
-
-} // namespace nb
-#endif // _NB_STRING_UTILS

engine/NBCore/include/NBCore/Utils.hpp

@@ -1,135 +0,0 @@
-#pragma once
-#ifndef _NB_CORE_TYPES
-#define _NB_CORE_TYPES
-
-#include <exception>
-#include <memory>
-#include <unordered_map>
-#include <vector>
-
-// #include <NBCore/Errors.hpp>
-
-namespace nb {
-
-template<typename A, typename B>
-class ConstantMap : public std::unordered_map<A, B> {
-    using Base = std::unordered_map<A, B>;
-
-    public:
-    using Base::Base;
-    using Base::at;
-    const B& operator[](const A& key) const {
-        return at(key);
-    }
-};
-
-template<typename T>
-using SharedVector = std::vector<std::shared_ptr<T>>;
-
-template<typename T>
-using RValueVector = std::vector<T&&>;
-
-using ByteVector = std::vector<uint8_t>;
-
-/* class ObjectManagerError : public Error<ObjectManagerError> {
-    using Base = Error<ObjectManagerError>;
-
-    public:
-    using Base::Base;
-
-    enum Codes : unsigned int {
-        UNDEFINED, NO_MANAGER, MANAGER_MISMATCH, LOCK_OVERFLOW, BAD_THREAD
-    };
-
-    static const std::string type;
-    static const ErrorCodeMap ErrorMessages;
-}; */
-
-template<typename T>
-ByteVector vectorToBytes(const std::vector<T>& vec) {
-    unsigned int num_bytes = vec.size() * sizeof(T);
-    ByteVector ret(num_bytes);
-    memcpy(ret.data(), vec.data(), num_bytes);
-    return ret;
-}
-
-template<typename T, typename S>
-ByteVector concatVectorBytes(const std::vector<T>& vec1, const std::vector<S>& vec2) {
-    ByteVector vec1_raw = vectorToBytes<T>(vec1);
-    ByteVector vec2_raw = vectorToBytes<S>(vec2);
-    unsigned int vec1_raw_size = vec1_raw.size();
-    unsigned int vec2_raw_size = vec2_raw.size();
-    ByteVector 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> bytesToVector(const ByteVector& vec) {
-    if (vec.size() % sizeof(T) != 0) {
-/*         THROW(Error<NoneType>(
-            std::runtime_error("Data size does not align to std::vector<" + std::string(typeid(T).name()) + ">.")
-        )); */
-        throw "byyyyeeee";
-    }
-    unsigned int num_elmts = vec.size() / sizeof(T);
-    std::vector<T> ret(num_elmts);
-    memcpy(ret.data(), vec.data(), vec.size());
-
-    return ret;
-}
-
-/* template <typename T>
-class ThreadsafeObjectLock;
-
-template <typename T>
-class ThreadsafeObject {
-    using Codes = ObjectManagerError::Codes;
-
-    public:
-    ThreadsafeObject(T&& obj) 
-    : _obj(std::make_shared<T>(obj)) {}
-
-    ThreadsafeObjectLock<T> lock() {
-        return ThreadsafeObjectLock<T>(this);
-    }
-
-    friend ThreadsafeObjectLock<T>;
-
-    protected:
-    std::shared_ptr<T> _obj;
-    mutable std::recursive_mutex _mutex;
-
-};
-
-template <typename T>
-class ThreadsafeObjectLock {
-    public:
-    ThreadsafeObjectLock(const ThreadsafeObjectLock&) = delete;
-    ThreadsafeObjectLock operator=(const ThreadsafeObjectLock&) = delete;
-    ~ThreadsafeObjectLock() {
-        _manager->_mutex.unlock();
-    }
-
-    T* operator->() {
-        return _manager->_obj.get(); 
-    }
-
-    friend ThreadsafeObject<T>;
-
-    protected:
-    ThreadsafeObjectLock(
-        ThreadsafeObject<T>* const manager_
-    ) : _manager(manager_) {
-        if (!_manager) {
-            using Codes = ObjectManagerError::Codes;
-            THROW(ObjectManagerError(Codes::NO_MANAGER));
-        }
-        _manager->_mutex.lock();
-    }
-    ThreadsafeObject<T>* const _manager;
-}; */
-
-} // namespace nb
-#endif // _NB_CORE_TYPES

engine/NBCore/src/Errors.cpp

@@ -0,0 +1,14 @@
+#include "Errors.hpp"
+#include "TypeTraits.hpp"
+
+namespace nb {
+
+const std::string Error<nb::NoneType>::type =  "nb::Error";
+
+const ErrorCodeMap Error<nb::NoneType>::ErrorMessages = {
+    {Error::Codes::GENERAL, "General std::exception."},
+    {Error::Codes::UNDEFINED, "Undefined / general error."},
+    {Error::Codes::BADERRORCODE, "Unrecognized error code."}
+};
+
+}

engine/NBCore/src/ErrorsImpl.cpp

@@ -1,11 +0,0 @@
-#include <NBCore/ErrorsImpl.hpp>
-
-namespace nb {
-
-//ErrorBase::
-ErrorBase::ErrorBase(const std::exception& exception_) noexcept 
-: ErrorBase(Error(exception_)) {}
-
-} // namespace nb
-
-

engine/NBCore/src/Logger.cpp

@@ -1,82 +1,31 @@
 #include <iostream>
-#include <sstream>
 
-#include <NBCore/Logger.hpp>
-#include <NBCore/StringUtils.hpp>
+#include "Logger.hpp"
+#include "StringUtils.hpp"
 
 namespace nb {
 
-static bool RUN_LOGGER(nb::DefaultDebugLogger& logger_) {
-    logger_.run();
-    return logger_.isRunning();
-}
+#ifndef _NB_NO_LOGGER
+nb::DefaultDebugLogger logger(std::cout);
+#endif // _NB_NO_LOGGER
 
-#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;
+bool nb::DefaultDebugLogger::process(const LogEvent& msg) {
+    for (const auto os : this->_ostream) {
+        *os << indent_strblock(
+            msg.msg,
+            std::string(10, ' '),
+            "[ "+std::to_string(msg.lvl)+" ] :  "
+        ) << nb::NEWLINE;
     }
-    if (msg.lvl < logLevel()) {
-        return false;
-    }
-    constexpr size_t level_field_width = 5;
-    constexpr size_t msg_prompt_length = level_field_width+7;
-    std::stringstream formatted_stream;
-    formatted_stream << "[";
-    formatted_stream.width(level_field_width);
-    formatted_stream << std::to_string(msg.lvl) << "] :: ";
-    std::string fileloc="";
-    if (!msg.file.empty()) {
-        fileloc += "(" + msg.file + ":" + std::to_string(msg.line) + ") - ";
-    }
-    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;
 }
 
-// class DefaultDebugLogger
-
-bool DefaultDebugLogger::process(const LogEvent& msg) {
-    return _logsink->in(msg);
+static bool RUN_LOGGER(nb::DefaultDebugLogger& log) {
+    return log.run();
 }
 
+
+
+static 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 <NBCore/Processes.hpp>
+#include "Processes.hpp"
 
 namespace nb {
 
@@ -15,15 +15,8 @@ uint64_t GetPID() {
     return GetCurrentProcessId();
 }
 #endif // _NB_TARGET_WINDOWS
+
 #ifdef _NB_TARGET_LINUX
 #endif // _NB_TARGET_LINUX
     
-#ifdef _NB_TARGET_WINDOWS
-uint64_t GetTID() {
-    return GetCurrentThreadId();
-}
-#endif // _NB_TARGET_WINDOWS
-#ifdef _NB_TARGET_LINUX
-#endif // _NB_TARGET_LINUX
-
 } // namespace nb

engine/NBCore/src/StringUtils.cpp

@@ -1,29 +1 @@
-#include <NBCore/StringUtils.hpp>
-
-/* std::string nb::wstr_to_str(std::wstring in) {
-    std::size_t wstrlen = in.length();
-    char* c_str= new char[wstrlen];
-    std::wcstombs(c_str, in.c_str(), wstrlen);
-    std::string ret(c_str, wstrlen);
-    delete[] c_str;
-    return ret;
-} */
-
-std::string nb::indent_strblock(
-    std::string block,
-    std::string prepend,
-    std::string topIndent
-) {
-    return topIndent + nb::find_and_replace(
-        block,
-        nb::NEWLINE,
-        nb::NEWLINE + prepend
-    );
-}
-
-std::string nb::indent_strblock(
-    std::string block,
-    std::string prepend
-) {
-    return nb::indent_strblock(block, prepend, prepend);
-}
+#include "StringUtils.hpp"

engine/NBCore/src/Utils.cpp

@@ -1,27 +1 @@
-#include <NBCore/Utils.hpp>
 
-namespace nb {
-
-/* using ObjectManagerCodes = ObjectManagerError::Codes;
-const std::string ObjectManagerError::type = "nb::ObjectManagerError";
-const ErrorCodeMap ObjectManagerError::ErrorMessages({
-    {ObjectManagerCodes::UNDEFINED, "Error"},
-    {
-        ObjectManagerCodes::NO_MANAGER,
-        "Attempting to create object lock without lock manager"
-    },
-    {
-        ObjectManagerCodes::MANAGER_MISMATCH,
-        "Attempting to delete object lock from mismatched lock manager"
-    },
-    {
-        ObjectManagerCodes::LOCK_OVERFLOW,
-        "Too many object locks allocated"
-    },
-    {
-        ObjectManagerCodes::BAD_THREAD,
-        "Attempting operation from a bad thread"
-    }
-}); */
-
-}; // namespace nb

engine/NBCore/tests/testErrors.cpp

@@ -1,9 +1,9 @@
 #define CODE_ERROR_LOCATIONS
 
 #include <gtest/gtest.h>
-#include <string>
 
-#include <NBCore/Errors.hpp>
+#include "Errors.hpp"
+#include <string>
 
 using namespace nb;
 
@@ -35,5 +35,5 @@ const ErrorCodeMap TestError::ErrorMessages{
 
 TEST(ErrorTest, Test) {
     auto err = TestError(0, TestError(1, TestError(2, TestError(3, TestError(2)))));
-    ASSERT_STREQ(err.what().c_str(), "Hey!\n   Trace: How\n      Trace: You\n         Trace: Doin\n            Trace: You");
+    ASSERT_STREQ(err.what(), "Hey!\n  Trace: How\n    Trace: You\n      Trace: Doin\n        Trace: You\n");
 }

engine/NBCore/tests/testLogger.cpp

@@ -1,49 +1,17 @@
-#define _NB_AUTOLOG
 #include <exception>
 
-#include <NBCore/Errors.hpp>
-#include <NBCore/Logger.hpp>
+#include "Errors.hpp"
+#include "Logger.hpp"
 
-class TestError : public nb::Error<TestError> {
-    using Base = Error<TestError>;
-public:    
-    using Base::Base;
-    using Base::what;
-    using Base::code;
-    using Base::msg;
-    using Base::trace;
 
-    enum Codes : unsigned int {
-        A, B, C, D
-    };
-
-    static const std::string type;
-    static const nb::ErrorCodeMap ErrorMessages;
-};
-
-const std::string TestError::type="TestError";
-const nb::ErrorCodeMap TestError::ErrorMessages{
-    {TestError::Codes::A, "Hey!"},
-    {TestError::Codes::B, "How"},
-    {TestError::Codes::C, "You"},
-    {TestError::Codes::D, "Doin"}
-};
 
 int main() {
-    while(!nb::LOGGER_RUNNING) {}
-    nb::logger.minimalLogLevel(0x0);
-    nb::logger.msg("Whoop!");
+    nb::logger.log("Whoop!");
     try {
-        THROW(TestError(0, TestError(1, TestError(2, TestError(3, TestError(2))))));
-    } catch (TestError e){
-        nb::logger.msg("nb::Error was thrown!");
+        THROW(nb::Error, "Hiii!");
+    } catch (nb::Error<nb::NoneType> e){
+        nb::logger.log("Winner winner chicken dinner!");
     }
 
-    try {
-        THROW(std::exception());
-    } catch (std::exception e){
-        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 <NBCore/Processes.hpp>
+#include "Processes.hpp"
 #include <Windows.h>
 
 TEST(ProcessesTest, GetPID) {

engine/NBCore/tests/testUtils.cpp

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

engine/NBData/CMakeLists.txt

@@ -1,70 +0,0 @@
-cmake_minimum_required(VERSION 3.10)
-project(NBData VERSION 0.1)
-
-include(GNUInstallDirs)
-include(CMakePackageConfigHelpers)
-
-toAbsolutePath(NB_DATA_SOURCE 
-    ./src/FFT.cpp
-)
-toAbsolutePath(NB_DATA_INCLUDE
-    ./include/NBData/FFT.hpp
-)
-
-set(NB_DATA_SOURCE ${NB_DATA_SOURCE} PARENT_SCOPE)
-set(NB_DATA_INCLUDE ${NB_DATA_INCLUDE} PARENT_SCOPE)
-
-add_library(NBData ${NB_DATA_SOURCE})
-add_library(NBEngine::Data ALIAS NBData)
-target_link_libraries(NBData
-    NBCore
-)
-target_include_directories(NBData
-    PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
-    PUBLIC "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
-)
-export(
-    TARGETS NBData
-    FILE "${CMAKE_BINARY_DIR}/cmake/NBDataTargets.cmake"
-    NAMESPACE NBEngine::
-)
-configure_package_config_file(
-    "NBDataConfig.cmake.in"
-    "${CMAKE_BINARY_DIR}/cmake/NBDataConfig.cmake"
-    INSTALL_DESTINATION "${CMAKE_INSTALL_PREFIX}/cmake"
-    PATH_VARS CMAKE_INSTALL_LIBDIR
-)
-write_basic_package_version_file(
-    "${CMAKE_BINARY_DIR}/cmake/NBDataConfigVersion.cmake"
-    COMPATIBILITY AnyNewerVersion 
-)
-
-if (NBENGINE_INSTALL)
-    message("Installing NBData to ${CMAKE_INSTALL_PREFIX}")
-    install(
-        TARGETS NBData
-        EXPORT NBDataTargets
-        LIBRARY DESTINATION lib
-        ARCHIVE DESTINATION lib
-        INCLUDES DESTINATION include
-    )
-    install(
-        DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/NBData"
-        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
-        FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp"
-    )
-    install(
-        EXPORT NBDataTargets
-        DESTINATION "${CMAKE_INSTALL_PREFIX}/cmake"
-        NAMESPACE NBEngine::
-    )
-    install(FILES
-        "${CMAKE_BINARY_DIR}/cmake/NBDataConfig.cmake"
-        "${CMAKE_BINARY_DIR}/cmake/NBDataConfigVersion.cmake"
-        DESTINATION "${CMAKE_INSTALL_PREFIX}/CMake"
-    )
-endif()
-
-if (NB_BUILD_TESTS)
-    add_subdirectory(./tests )
-endif()

engine/NBData/NBDataConfig.cmake.in

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

engine/NBData/include/NBData/FFT.hpp

@@ -1,252 +0,0 @@
-#pragma once
-#ifndef _NB_DATA_FFT
-#define _NB_DATA_FFT
-
-#include <cmath>
-#include <complex>
-#include <unordered_map>
-#include <vector>
-
-#include <NBCore/Errors.hpp>
-
-#ifndef PI_VALUE
-    #define PI_VALUE 3.1415926535
-#endif
-
-/*! @file FFT.hpp */
-
-namespace nb {
-
-using namespace std::complex_literals;
-
-constexpr double operator""_pi(long double val) {
-    return val*PI_VALUE;
-}
-constexpr double operator""_pi(unsigned long long val) {
-    return val*PI_VALUE;
-}
-
-constexpr float operator""_pif(long double val) {
-    return val*PI_VALUE;
-}
-constexpr float operator""_pif(unsigned long long val) {
-    return val*PI_VALUE;
-}
-
-template<typename T>
-bool isPowerOf2(const T& x) {
-    bool ret = false;
-    unsigned int mask=1;
-    for (int i=0; i<(8*sizeof(std::declval<T>())); ++i) {ret ^= x&mask; mask<<=1;}
-    return ret;
-}
-
-/*!
-    @brief Calculates the complex-valued twiddle factor given the `phase`
-    @param phase A double representing the phase, or `(k*n)/N`, of a DFT,
-    in units of 2*Pi.
-    @return A std::complex<T> representing the complex twiddle factor of 
-    the DFT at that `phase`, calculated via `exp(-2*Pi*i*phase)`.
-
-    Calculates the complex-valued twiddle factor given the `phase` in units
-    of the ratio around the circle (i.e. in units of 2*Pi), calculated via
-    `exp(-2*Pi*i*phase)`. Note the minus sign, as this function is for the
-    *forward* DFT.
-*/
-template<typename T>
-std::complex<T> calculateTwiddleFactor(double phase) {
-    int sign = -1;
-    while(phase>0.5) { phase-=0.5; sign*=-1; }
-    return static_cast<std::complex<T>>(std::exp(2_pi*(sign)*(1i)*phase));
-}
-
-/*!
-    Stores the twiddle factors for Radix-2 DFT matrices for a given data type
-    (i.e. stores std::complex<T> values), which can be retrieved using `TwiddleFactor<T>::get`.
-*/
-template<typename T>
-class TwiddleFactors2 {
-    protected:
-    static std::unordered_map<unsigned int, std::complex<T>> factors;
-    
-    public:
-    /*!
-        @brief Retrieves the twiddle factor for a Radix-2 DFT
-        @param numerator The numerator (i.e. `k*n` of a DFT matrix) part of the phase
-        when defined in units of 2*Pi.
-        @param log2N The `log2(denominator)` (i.e. `/N` of a DFT matrix) part of the phase
-        when defined in units of 2*Pi.
-        @return A std::complex<T> for the value of the `numerator / (2^log2N)` twiddle factor
-    */
-    static std::complex<T> get(unsigned int numerator, unsigned int log2N);
-};
-
-template<typename T>
-std::complex<T>* fft2_impl(
-    const std::complex<T>* source,
-    std::complex<T>* dest,
-    unsigned int log2N,
-    unsigned int stride=1
-) {
-    constexpr std::complex<T> J(0, 1);
-    switch(log2N) {
-        case 0:
-            dest[0] = source[0];
-        break;
-
-        case 1:
-            dest[0] = source[0] + source[stride];
-            dest[1] = source[0] - source[stride];
-        break;
-
-        case 2:
-            dest[0] = source[0] + source[stride] + source[2*stride] + source[3*stride];
-            dest[1] = source[0] - J*source[stride] - source[2*stride] + J*source[3*stride];
-            dest[2] = source[0] - source[stride] + source[2*stride] - source[3*stride];
-            dest[3] = source[0] + J*source[stride] - source[2*stride] - J*source[3*stride];
-        break;
-
-        default:
-            const unsigned int halfway = 1<<(log2N-1);
-            fft2_impl(source, dest, log2N-1, 2*stride);
-            fft2_impl(&(source[stride]), &(dest[halfway]), log2N-1, 2*stride);
-            std::complex<T> twiddle;
-            std::complex<T> p, q;
-            for (unsigned int i=0; i < halfway; ++i) {
-                twiddle = TwiddleFactors2<T>::get(i, log2N);
-                p = dest[i];
-                q = dest[halfway+i]*twiddle;
-                dest[i] = p+q;
-                dest[halfway+i] = p-q;
-            }
-        break;
-    }
-    return dest;
-
-}
-
-template<typename T>
-std::complex<T>* dft_impl(
-    const std::complex<T>* source,
-    std::complex<T>* dest,
-    unsigned int N
-) {
-    for (int k=0; k < N; ++k) {
-        dest[k] = 0;
-        for (int n = 0; n < N; ++n) {
-            dest[k] += source[n] * calculateTwiddleFactor<T>(double(n*k)/double(N));
-        }
-    }
-    return dest;
-}
-
-/*!
-    @brief Computes the minimal Radix-2 DFT on a std::vector<std::complex<T>>
-    @param values A std::vector<std::complex<T>> representing the time domain values
-    @return A std::vector<std::complex<T>>, representing the minimal Radix-2 DFT of `values`
-
-    Computes the Radix-2 DFT on a std::vector<std::complex<T>>. If the input vector
-    `values` is not a power of 2, then the number of points in the DFT (and thus the
-    size of the returned frequency domain vector) is determined by 
-    `2^ceil(log2(values.size()))`
-*/
-template<typename T>
-std::vector<std::complex<T>> fft2(const std::vector<std::complex<T>>& values) {
-    const auto N = values.size();
-    unsigned int log2N=0;
-    while(1<<log2N < N) {log2N++;}
-    std::vector<std::complex<T>> temp(1<<log2N, 0);
-    std::vector<std::complex<T>> ret = temp;
-    for (int i=0; i < N; ++i) { temp[i] = values[i]; }
-    std::complex<T>* fft_results = fft2_impl(temp.data(), ret.data(), log2N);
-    return ret;
-}
-
-/*!
-    @brief Computes the minimal Radix-2 DFT on a `std::vector<T>`
-    @param values A std::vector<T> representing the time domain values with packed real and
-    imaginary parts
-    @return A `std::vector<T>`, representing the minimal Radix-2 DFT of `values` with packed
-    real and imaginary parts
-    @throw std::string Thrown when the size of the vector is not divisible by 2 (i.e. 
-    there are unmatched real/imaginary pairs).
-
-    Computes the Radix-2 DFT on a std::vector<std::complex<T>>. Equivalent to 
-    `fft2(const std::vector<std::complex<T>>)` if `values[2*i]` and `values[2*i+1]`
-    were mapped to the real and imaginary parts of the complex vector.
-*/
-template<typename T>
-std::vector<T> fft2(const std::vector<T>& values) {
-    if (values.size()&1) {
-        THROW(Error<>(Error<>::VALUE_ERROR,
-            "Vector must be of even length to represent complex values."
-        ));
-    }
-    std::complex<T> complex_input(values.data(), values.size()/2);
-    std::complex<T> complex_ret = fft2(complex_input);
-    return std::vector<T>(complex_ret.data(), complex_ret.size()*2);
-}
-
-/*!
-    @brief Computes the DFT on a std::vector<std::complex<T>>
-    @param values A std::vector<std::complex<T>> representing the time domain values
-    @return A std::vector<std::complex<T>> of the DFT of `values` in the frequency domain
-
-    Computes the DFT of the std::vector<std::complex<T>> `values`. Does so using the 
-    naive O(N^2) matrix-multiplication method.
-*/
-template<typename T>
-std::vector<std::complex<T>> dft(const std::vector<std::complex<T>>& x) {
-    std::vector<std::complex<T>> ret = x;
-    std::complex<T>* fft_results = dft_impl(x.data(), ret.data(), x.size());
-    return ret;
-}
-
-/*!
-    @brief Computes the DFT on a `std::vector<T>`
-    @param values A `std::vector<T>` representing the time domain values with packed real and
-    imaginary parts
-    @return A `std::vector<T>` of the DFT of `values` in the frequency domain with
-    packed real and imaginary parts
-    @throw std::string Thrown when the size of the vector is not divisible by 2 (i.e. 
-    there are unmatched real/imaginary pairs).
-
-    Computes the DFT on a `std::vector<T>`. Equivalent to 
-    `dft(const std::vector<std::complex<T>>)` if `values[2*i]` and `values[2*i+1]`
-    were mapped to the real and imaginary parts of the complex vector.
-*/
-template<typename T>
-std::vector<T> dft(const std::vector<T>& values) {
-    if (values.size()&1) {
-        THROW(Error<>(Error<>::VALUE_ERROR,
-            "Vector must be of even length to represent complex values."
-        ));
-    }
-    std::complex<T> complex_input(values.data(), values.size()/2);
-    std::complex<T> complex_ret = dft(complex_input);
-    return std::vector<T>(complex_ret.data(), complex_ret.size()*2);
-}
-
-template<typename T>
-std::unordered_map<unsigned int, std::complex<T>> TwiddleFactors2<T>::factors = {};
-
-template<typename T>
-std::complex<T> TwiddleFactors2<T>::get(unsigned int a, unsigned int log2N) {
-    while(a && !(a&1)) { a>>=1; log2N--; }
-    const unsigned int N = 1<<log2N;
-    const double phase = double(a)/double(N);
-    const unsigned int key = a*N;
-    try {
-        return factors.at(key);
-    } catch (const std::out_of_range& e) {
-        if (a > N>>1 ) {
-            return (factors[key] = std::conj(TwiddleFactors2<T>::get(N-a, log2N)));
-        } else {
-            return (factors[key] = calculateTwiddleFactor<T>(phase));
-        }
-    }
-}
-
-} // namespace n
-
-#endif // _NB_DATA_FFT

engine/NBData/src/FFT.cpp

@@ -1,6 +0,0 @@
-#include <NBCore/Errors.hpp>
-#include <NBData/FFT.hpp>
-
-namespace nb {
-
-} // namespace nb

engine/NBData/tests/CMakeLists.txt

@@ -1,22 +0,0 @@
-cmake_minimum_required(VERSION 3.26.0)
-
-if (NB_BUILD_TESTS)
-    enable_testing()
-    include(GoogleTest)
-
-    add_executable(TestData
-        ./testFFT.cpp
-    )
-    target_link_libraries(TestData
-        NBData
-        GTest::gtest_main
-    )
-    gtest_discover_tests(TestData)
-
-    add_executable(FFTSpeedTest
-        ./fftspeedtest.cpp
-    )
-    target_link_libraries(FFTSpeedTest
-        NBData
-    )
-endif()

engine/NBData/tests/fftspeedtest.cpp

@@ -1,5 +0,0 @@
-#include <NBData/FFT.hpp>
-
-int main() {
-    return 0;
-}

engine/NBData/tests/testComplex.cpp

@@ -1,27 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <NBData/ComplexNumbers.hpp>
-
-template<typename A, typename B>
-void COMPLEX_EQ(const nb::Complex<A>& a, const nb::Complex<B>& b) {
-    ASSERT_EQ(a.r, b.r);
-    ASSERT_EQ(a.i, b.i);
-}
-
-template<typename A, typename B>
-void COMPLEX_ALMOST_EQ(const nb::Complex<A>& a, const nb::Complex<B>& b) {
-    ASSERT_FLOAT_EQ(a.r, b.r);
-    ASSERT_FLOAT_EQ(a.i, b.i);
-}
-
-TEST(ComplexNumberTests, TestConstruction) {
-    COMPLEX_ALMOST_EQ(nb::Complex(), nb::Complex(0,0));
-    COMPLEX_ALMOST_EQ(nb::Complex(5.0), nb::Complex(5, 0));
-    COMPLEX_ALMOST_EQ(1.5_j, nb::Complex(0.0, 1.5));
-}
-
-TEST(ComplexNumberTests, TestAdd) {
-    auto x = nb::Complex(1.0) - nb::Complex(2.0, 1.0);
-    ASSERT_FLOAT_EQ(x.r, -1);
-    ASSERT_FLOAT_EQ(x.i, -1);
-}

engine/NBData/tests/testFFT.cpp

@@ -1,68 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <NBData/FFT.hpp>
-
-using namespace nb;
-
-template<typename A, typename B>
-void COMPLEX_EQ(const std::complex<A>& a, const std::complex<B>& b) {
-    ASSERT_EQ(a.real(), b.real());
-    ASSERT_EQ(a.imag(), b.imag());
-}
-
-template<typename A, typename B>
-void COMPLEX_FLOAT_EQ(
-    const std::complex<A>& a,
-    const std::complex<B>& b,
-    const long double epsilon=0
-) {
-    if (epsilon) {
-        ASSERT_NEAR(a.real(), b.real(), epsilon);
-        ASSERT_NEAR(a.imag(), b.imag(), epsilon);
-    } else {
-        ASSERT_FLOAT_EQ(a.real(), b.real());
-        ASSERT_FLOAT_EQ(a.imag(), b.imag());
-    }
-}
-
-template<typename A, typename B>
-void COMPLEX_EQ_VEC(
-    const std::vector<std::complex<A>>& a,
-    const std::vector<std::complex<A>>& b
-) {
-    if (a.size() != b.size()) { FAIL(); }
-    for (int i = 0; i < a.size(); ++i) {
-        COMPLEX_EQ(a[i], b[i]);
-    }
-}
-
-template<typename A, typename B>
-void COMPLEX_FLOAT_EQ_VEC(
-    const std::vector<std::complex<A>>& a,
-    const std::vector<std::complex<B>>& b,
-    const long double epsilon
-) {
-    if (a.size() != b.size()) { FAIL(); }
-    for (int i = 0; i < a.size(); ++i) {
-        COMPLEX_FLOAT_EQ(a[i], b[i], epsilon);
-    }
-}
-
-TEST(FFTTest, TestFFT) {
-    std::vector<std::vector<std::complex<double>>> input = {
-        {1.0, 0.5, 0},
-        {1,1,1,1,1,1,1,1},
-
-    };
-    std::vector<std::vector<std::complex<double>>> expected = {
-        {1.5,1.f-0.5if,0.5,1.f+0.5if},
-        {8, 0, 0, 0, 0, 0, 0, 0}
-    };
-    for (int i = 0; i < input.size(); ++i) {
-        COMPLEX_FLOAT_EQ_VEC(
-            nb::fft2(input[i]),
-            expected[i],
-             1e-10
-        );
-    }
-}

engine/NBEvents/src/Events.cpp

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