Initial NBData, added FFT

CMakeLists.txt

@@ -9,6 +9,7 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 
 include(GNUInstallDirs)
 include(CMakePackageConfigHelpers)
+include(CMakeDependentOption)
 
 function(toAbsolutePath SETVAR PATHS)
     set(PATHS ${PATHS} ${ARGN})
@@ -31,13 +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_BUILD_TESTS ON)
-    set(NB_BUILD_DOCS ON)
-    set(NBENGINE_INSTALL ON)
+    set(NB_DEBUG_BUILD 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)
@@ -67,15 +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()
 
-get_filename_component(NBENGINE_ROOT ./ ABSOLUTE)
+get_filename_component(NBENGINE_ROOT ${CMAKE_CURRENT_LIST_DIR} ABSOLUTE)
 
-add_subdirectory(./engine)
+add_subdirectory(./engine ${PROJECT_BINARY_DIR}/${CMAKE_BUILD_TYPE})
 
 # Toggle
 set(NB_REBUILD_DOCS)
@@ -84,22 +115,23 @@ 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)
-    include(CMakePackageConfigHelpers)
-    configure_package_config_file(
-        "NBEngineConfig.cmake.in"
-        "NBEngineConfig.cmake"
-        INSTALL_DESTINATION ${CMAKE_INSTALL_PREFIX}/cmake
-        PATH_VARS CMAKE_INSTALL_LIBDIR
-    )
-    write_basic_package_version_file(
-        "${CMAKE_CURRENT_BINARY_DIR}/NBEngineConfigVersion.cmake"
-        COMPATIBILITY AnyNewerVersion 
-    )
     install(FILES
-        "${CMAKE_CURRENT_BINARY_DIR}/NBEngineConfig.cmake"
-        "${CMAKE_CURRENT_BINARY_DIR}/NBEngineConfigVersion.cmake"
+        "${PROJECT_BINARY_DIR}/cmake/NBEngineConfig.cmake"
+        "${PROJECT_BINARY_DIR}/cmake/NBEngineConfigVersion.cmake"
         DESTINATION "${CMAKE_INSTALL_PREFIX}/cmake"
     )
 endif()

README.md

@@ -4,6 +4,9 @@
 
 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.
 

engine/CMakeLists.txt

@@ -3,17 +3,28 @@ 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)
+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)
+if (NB_CORE_INCLUDE OR NB_EVENTS_INCLUDE OR NB_GRAPHICS_INCLUDE OR NB_DATA_INCLUDE)
     set(NB_INCLUDE_FILES "")
-    list(APPEND NB_INCLUDE_FILES ${NB_CORE_INCLUDE} ${NB_GRAPHICS_INCLUDE} ${NB_EVENTS_INCLUDE})
+    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,6 +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
@@ -14,6 +21,7 @@ toAbsolutePath(NB_CORE_INCLUDE
     ./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
@@ -28,45 +36,51 @@ 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:${PROJECT_SOURCE_DIR}/include>"
+    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}")
-    include(GNUInstallDirs)
-    include(CMakePackageConfigHelpers)
     install(
         TARGETS NBCore
         EXPORT NBCoreTargets
+        LIBRARY DESTINATION lib
+        ARCHIVE DESTINATION lib
+        INCLUDES DESTINATION include
     )
     install(
-        DIRECTORY "${PROJECT_SOURCE_DIR}/include/NBCore"
+        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
+        DESTINATION "${CMAKE_INSTALL_PREFIX}/cmake"
         NAMESPACE NBEngine::
     )
-    configure_package_config_file(
-        "NBCoreConfig.cmake.in"
-        "NBCoreConfig.cmake"
-        INSTALL_DESTINATION ${CMAKE_INSTALL_PREFIX}/cmake
-        PATH_VARS CMAKE_INSTALL_LIBDIR
-    )
-    write_basic_package_version_file(
-        "${CMAKE_CURRENT_BINARY_DIR}/NBCoreConfigVersion.cmake"
-        COMPATIBILITY AnyNewerVersion 
-    )
     install(FILES
-        "${CMAKE_CURRENT_BINARY_DIR}/NBCoreConfig.cmake"
-        "${CMAKE_CURRENT_BINARY_DIR}/NBCoreConfigVersion.cmake"
-        DESTINATION "${CMAKE_INSTALL_PREFIX}/cmake"
+        "${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/include/NBCore/DataSink.hpp

@@ -4,6 +4,7 @@
 
 #include <atomic>
 #include <thread>
+#include <utility>
 
 #include <NBCore/ThreadSafeQueue.hpp>
 
@@ -11,121 +12,170 @@ namespace nb {
 
 template<typename DataType>
 class DataSink {
-public:
+    public:
     DataSink(const DataSink&) = delete;
     DataSink(DataSink&&) = delete;
     DataSink& operator=(const DataSink&) = delete;
 
     virtual bool isRunning() const noexcept {
-        return _running;
+        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() = default;
+    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> {
-    using Base = DataSink<DataType>;
-public:
-    using Base::Base;
+    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); }
 
-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(); }
+    private:
+    ProcessorType* const type_ptr = static_cast<ProcessorType*>(this);
+    std::mutex _pause;
 
-    bool isRunning() const noexcept override {
-        return this->_running;
+    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()) {
-            this->_running = true;
+            _running.store(true, std::memory_order_release);
             _runningThread = std::make_shared<std::thread>([&]{
                 while(type_ptr->isRunning()) {
-                    flush();
+                    std::lock_guard<std::mutex> lock(_pause);
+                    type_ptr->flush();
                 }
+                type_ptr->flush();
+                type_ptr->stop();
             });
         }
-        return this->isRunning();
+        return type_ptr->isRunning();
     }
     bool stop() noexcept override {
         if (type_ptr->isRunning()) {
-            this->_running = false;
-            _runningThread->join();
-            _runningThread = nullptr;
+            _running.store(false, std::memory_order_release);
+            if (_runningThread) {
+                _runningThread->join();
+                _runningThread = nullptr;
+            }
+            type_ptr->flush();
         }
         return !type_ptr->isRunning();
     }
-
-    protected:
-    using Base::Base;
-
-    unsigned int count() const {
-        return this->_buffer.size();
+    bool in(const DataType& val) override {
+        type_ptr->_buffer.push(val);
+        return type_ptr->isRunning();
     }
-    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);
 
 };
 

engine/NBCore/include/NBCore/Errors.hpp

@@ -8,35 +8,57 @@
 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(args...) nb::logger.log(args, __FILE__, __LINE__)
+            #define LOG(arg) LOG_W_CODE_LOC(__FILE__, __LINE__, arg)
         #endif // LOG
         #ifndef WARN
-            #define WARN(args...) nb::logger.warn(args, __FILE__, __LINE__)
+            #define WARN(args...) WARN_W_CODE_LOC(__FILE__, __LINE__, args)
         #endif // WARN
         #ifndef ERROR
-            #define ERROR(args...) nb::logger.error(args, __FILE__, __LINE__)
+            #define ERROR(arg) ERROR_W_CODE_LOC(__FILE__, __LINE__, arg)
         #endif // ERROR
     #else
         #ifndef LOG
-            #define LOG(args...) nb::logger.log(args)
+            #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)
+            #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...) ERROR(args); nb::logger.stop(); throw args
+        #define THROW(args...) THROW_W_CODE_LOC(__FILE__, __LINE__, args)
     #else
         #define THROW(args...) throw args
-    #endif // _NB_CODE_ERROR_LOCATIONS
+    #endif // _NB_AUTOLOG
 #endif // THROW
 } // namespace nb
 

engine/NBCore/include/NBCore/ErrorsImpl.hpp

@@ -6,13 +6,13 @@
 #include <memory>
 #include <string>
 #include <type_traits>
-#include <unordered_map>
 
 #include <NBCore/StringUtils.hpp>
+#include <NBCore/Utils.hpp>
 
 namespace nb {
 
-typedef std::unordered_map<unsigned int, std::string> ErrorCodeMap;
+using ErrorCodeMap = ConstantMap<unsigned int, std::string>;
 
 class ErrorBase {
     protected:
@@ -25,11 +25,10 @@ class ErrorBase {
 
     ErrorBase(const ErrorBase&) = default;
     ErrorBase(const std::exception&) noexcept;
-    ErrorBase(const std::string&) noexcept;
     virtual std::string what() const noexcept {
         std::string ret = msg;
         if (trace) {
-            std::string trace_msg = msg;
+            std::string trace_msg = trace->what();
             ret += NEWLINE + indent_strblock(
                 trace_msg,
                 TABOVER,
@@ -41,16 +40,16 @@ class ErrorBase {
     
     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_}
-{}
+        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>
@@ -69,17 +68,16 @@ class Error : public ErrorBase {
             "const std::string type must be a class member."
         );
     }
-
-    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(); }
@@ -88,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_)
@@ -96,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
@@ -114,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(); }
@@ -142,14 +140,18 @@ class Error<NoneType> : public Error<Error<NoneType>> {
     using Base::what;
     using Base::code;
     using Base::trace;
+    using Base::Base;
     enum Codes : unsigned int {
-        STANDARD, UNDEFINED, INDEX_ERROR
+        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"},
-        {INDEX_ERROR, "Indexing 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_) {}
@@ -159,13 +161,6 @@ class Error<NoneType> : public Error<Error<NoneType>> {
         "std::exception",
         nullptr
     ) {}
-
-    Error(const std::string& msg_) noexcept : Base(
-        Codes::UNDEFINED, 
-        msg_,
-        type,
-        nullptr
-    ) {}
 };
 
 template<typename... Args>

engine/NBCore/include/NBCore/Logger.hpp

@@ -3,13 +3,13 @@
 #define _NB_LOGGER
 
 #include <chrono>
-#include <ostream>
 #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>
@@ -26,32 +26,32 @@ typedef std::chrono::time_point<
 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;
+template<typename LogType, typename Logger>
+class LoggerBase : public MultithreadedDataProcessor<LogType, Logger>{
+    private:
+    Logger* const type_ptr = static_cast<LoggerType*>(this);
 
     protected:
-    LoggerBase() = default;
+    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;
+    }
 
-    StreamType _ostream;
 };
 
 struct LogEvent{
@@ -64,59 +64,42 @@ struct LogEvent{
     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, 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();
-    }
-    void error(
-        const std::string& val,
-        std::string file="",
-        unsigned int line=0
-    ) {
-        static_cast<LoggerType*>(this)->write_message(Error(val), 0xFF, file, line);
-        static_cast<LoggerType*>(this)->flush();
-    }
+class DebugLogger : public LoggerBase<LogEvent, LT>{
+    private:
+    LT* const type_ptr = static_cast<LT*>(this);
 
     protected:
-    std::vector<std::ostream*> _ostream;
-    void write_message(
+    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
     ) {
-        static_cast<LoggerType*>(this)->push(LogEvent{
+        type_ptr->in(LogEvent{
             std::chrono::system_clock::now(),
             lvl,
             msg,
@@ -126,7 +109,6 @@ public:
             line
         });
     }
-
     template <size_t N>
     void write_message(
         char const(&msg) [N],
@@ -134,18 +116,16 @@ public:
         std::string file="",
         unsigned int line=0
     ) {
-        static_cast<LoggerType*>(this)->write_message(std::string(msg), lvl, file, line);
+        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);
+        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,
@@ -153,38 +133,115 @@ public:
         std::string file="",
         unsigned int line=0
     ) {
-        static_cast<LoggerType*>(this)->write_message(std::to_string(val), lvl, file, line);
+        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 DefaultDebugLogger : public DebugLogger<DefaultDebugLogger> {
-    using LoggerType = DefaultDebugLogger;
-    using Base = DebugLogger<DefaultDebugLogger>;
-    
-    template <typename... Ts>
-    struct LogRow;
+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>;
-
-    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 const bool LOGGER_RUNNING;
+#ifdef _NB_AUTOLOG
 extern DefaultDebugLogger logger;
-#endif // _NB_NO_LOGGER
+#endif // _NB_AUTOLOG
 
 // Taking Charge of Adult ADHD by Russell Barkley
 

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,7 +2,6 @@
 #ifndef _NB_STRING_UTILS
 #define _NB_STRING_UTILS
 
-#include <iostream>
 #include <string>
 #include <string_view>
 
@@ -21,24 +20,6 @@ namespace nb {
 
 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..., 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

@@ -90,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) {}

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 <NBCore/Errors.hpp>
+// #include <NBCore/Errors.hpp>
 
 namespace nb {
 
+template<typename A, typename B>
+class ConstantMap : public std::unordered_map<A, B> {
+    using Base = std::unordered_map<A, B>;
+
+    public:
+    using Base::Base;
+    using Base::at;
+    const B& operator[](const A& key) const {
+        return at(key);
+    }
+};
+
 template<typename T>
 using SharedVector = std::vector<std::shared_ptr<T>>;
 
@@ -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,9 +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(Error<NoneType>(
+/*         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);
@@ -65,7 +80,7 @@ std::vector<T> bytesToVector(const ByteVector& vec) {
     return ret;
 }
 
-template <typename T>
+/* template <typename T>
 class ThreadsafeObjectLock;
 
 template <typename T>
@@ -114,7 +129,7 @@ class ThreadsafeObjectLock {
         _manager->_mutex.lock();
     }
     ThreadsafeObject<T>* const _manager;
-};
+}; */
 
 } // namespace nb
 #endif // _NB_CORE_TYPES

engine/NBCore/src/Logger.cpp

@@ -1,38 +1,82 @@
 #include <iostream>
+#include <sstream>
 
 #include <NBCore/Logger.hpp>
 #include <NBCore/StringUtils.hpp>
 
 namespace nb {
 
-#ifndef _NB_NO_LOGGER
-nb::DefaultDebugLogger logger(std::cout);
-#endif // _NB_NO_LOGGER
+static bool RUN_LOGGER(nb::DefaultDebugLogger& logger_) {
+    logger_.run();
+    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) {
-        *os << "[";
-        os->width(level_field_width);
-        *os << std::to_string(msg.lvl) << "] :: ";
-        std::string fileloc="";
-        if (!msg.file.empty()) {
-            fileloc += "(" + msg.file + ":" + std::to_string(msg.line) + ") - ";
-        }
-        *os << indent_strblock(
-            fileloc + msg.msg,
-            std::string(20 - msg_prompt_length, ' '),
-            ""
-        ) << nb::NEWLINE;
+    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;
 }
 
-static bool RUN_LOGGER(nb::DefaultDebugLogger& log) {
-    return log.run();
+// class DefaultDebugLogger
+
+bool DefaultDebugLogger::process(const LogEvent& msg) {
+    return _logsink->in(msg);
 }
 
-const bool LOGGER_RUNNING = RUN_LOGGER(logger);
-
 } // namespace nb

engine/NBCore/src/Utils.cpp

@@ -2,7 +2,7 @@
 
 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/testLogger.cpp

@@ -1,3 +1,4 @@
+#define _NB_AUTOLOG
 #include <exception>
 
 #include <NBCore/Errors.hpp>
@@ -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/NBData/CMakeLists.txt

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

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

engine/NBData/include/NBData/FFT.hpp

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

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

engine/NBData/tests/CMakeLists.txt

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

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

engine/NBData/tests/testComplex.cpp

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

@@ -0,0 +1,68 @@
+#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
+        );
+    }
+}