naifb/NBEngine
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Added NDArray, did some light header and CMake restructuring

Browse Source
This commit is contained in:
NaifBanana
2026-10-30 02:19:05 -05:00
parent 97aed4e5ca
commit de7d435ccb
13 changed files with 287 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+1
View File
@@ -8,3 +8,4 @@ CMakeCache.txt
docs/*
!docs/CMake*
!docs/Doxyfile.in
CMakeLists.txt
+3 -3
View File
@@ -56,15 +56,15 @@ cmake_dependent_option(NBENGINE_INSTALL
)
if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
message(STATUS "Building for Windows")
message(STATUS "Targeting Windows")
set(NB_TARGET_WINDOWS ON)
elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
message(STATUS "Building for Linux")
message(STATUS "Targeting Linux")
set(NB_TARGET_LINUX ON)
endif()
if(NB_BUILD_TESTS)
message(STATUS "Building tests")
message(STATUS "Targeting tests")
enable_testing()
include(FetchContent)
FetchContent_Declare(
engine/CMakeLists.txt
+15 -28
View File
@@ -1,30 +1,17 @@
add_subdirectory(./NBCore)
set(NBENGINE_MODULES
NBCore
NBGraphics
NBData
)
get_target_property(NBCORE_INTERFACE_INCLUDES NBCore INTERFACE_INCLUDE_DIRECTORIES)
include_directories(${NBCORE_INTERFACE_INCLUDES})
set(NB_INCLUDE_FILES "")
set(NB_SOURCE_FILES "")
foreach(module ${NBENGINE_MODULES})
add_subdirectory("./${module}")
get_target_property(MODULE_INCLUDES ${module} INTERFACE_INCLUDE_DIRECTORIES)
list(APPEND NB_INCLUDE_FILES ${MODULE_INCLUDES})
list(APPEND NB_SOURCE_FILES ${MODULE_INCLUDES})
endforeach()
set(NB_INCLUDE_FILES ${NB_INCLUDE_FILES} PARENT_SCOPE)
set(NB_SOURCE_FILES ${NB_SOURCE_FILES} PARENT_SCOPE)
#add_subdirectory(./NBEvents)
add_subdirectory(./NBGraphics)
add_subdirectory(./NBData)
if (NB_CORE_SOURCE OR NB_EVENTS_SOURCE OR NB_GRAPHICS_SOURCE OR NB_DATA_SOURCE)
set(NB_SOURCE_FILES "")
list(APPEND NB_SOURCE_FILES
${NB_CORE_SOURCE}
${NB_GRAPHICS_SOURCE}
${NB_EVENTS_SOURCE}
${NB_DATA_SOURCE}
)
set(NB_SOURCE_FILES ${NB_SOURCE_FILES} PARENT_SCOPE)
endif()
if (NB_CORE_INCLUDE OR NB_EVENTS_INCLUDE OR NB_GRAPHICS_INCLUDE OR NB_DATA_INCLUDE)
set(NB_INCLUDE_FILES "")
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
+10 -13
View File
@@ -8,17 +8,10 @@ set(CMAKE_CXX_EXTENSIONS OFF)
include(GNUInstallDirs)
include(CMakePackageConfigHelpers)
toAbsolutePath(NB_CORE_SOURCE
./src/ErrorsImpl.cpp
./src/Logger.cpp
./src/Processes.cpp
./src/StringUtils.cpp
./src/TypeTraits.cpp
./src/Utils.cpp
)
toAbsolutePath(NB_CORE_INCLUDE
./include/NBCore/Arrays.hpp
./include/NBCore/CoreTypes.hpp
./include/NBCore/DataSink.hpp
./include/NBCore/DataTypes.hpp
./include/NBCore/Errors.hpp
./include/NBCore/ErrorsImpl.hpp
./include/NBCore/Logger.hpp
@@ -31,10 +24,14 @@ toAbsolutePath(NB_CORE_INCLUDE
./include/NBCore/Utils.hpp
)
set(NB_CORE_SOURCE ${NB_CORE_SOURCE} PARENT_SCOPE)
set(NB_CORE_INCLUDE ${NB_CORE_INCLUDE} PARENT_SCOPE)
add_library(NBCore ${NB_CORE_SOURCE})
add_library(NBCore
./src/ErrorsImpl.cpp
./src/Logger.cpp
./src/Processes.cpp
./src/StringUtils.cpp
./src/TypeTraits.cpp
./src/Utils.cpp
)
add_library(NBEngine::Core ALIAS NBCore)
target_include_directories(NBCore
PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
engine/NBCore/include/NBCore/Arrays.hpp
+135
View File
@@ -0,0 +1,135 @@
#pragma once
#ifndef _NB_DATA_TYPES
#define _NB_DATA_TYPES
#include <algorithm>
#include <array>
#include <cstring>
#include <NBCore/Errors.hpp>
namespace nb {
/*!
* @brief A multidimensional array template class
*
* */
template<typename T, unsigned int N>
class NDArray {
public:
using Coordinate = std::array<unsigned int, N>;
private:
template<unsigned int M>
static Coordinate ProjectDimensions(const std::array<unsigned int, M>& dims) {
Coordinate p;
unsigned int i=0;
if constexpr (M > N) {
std::for_each(dims.begin(), dims.end(), [&](unsigned int x){
if (i < N) {
p[i] = x;
} else {
if (x != 1) {
THROW(Error(Error<>::VALUE_ERROR,
"Higher dimensions must have a size of 1"
));
}
}
i++;
});
} else if constexpr (M < N) {
p.fill(1);
std::for_each(dims.begin(), dims.end(), [&](unsigned int x) {p[i] = x; i++;});
} else { p = dims; }
return p;
}
protected:
T* _data;
static unsigned int CalculateTotalSize(const std::array<unsigned int, N>& dims) {
unsigned int ret = 1;
std::for_each(dims.begin(), dims.end(), [&](unsigned int n){
ret *= n;
});
return ret;
}
public:
template<typename U, unsigned int M>
friend class NDArray;
static NDArray&& MemoryToNDArray(const Coordinate& dimensions_, T* data_) {
auto ret = NDArray(dimensions_);
ret._data = data_;
return std::move(ret);
}
const Coordinate dimensions;
const unsigned int totalSize;
NDArray(const Coordinate& dimensions_, T* data_=nullptr) :
dimensions(dimensions_),
totalSize(CalculateTotalSize(dimensions_))
{
if (data_) { data(data_); }
}
NDArray(NDArray&& arr) :
dimensions(arr.dimensions),
totalSize(arr.totalSize),
_data(std::move(arr._data)) {}
NDArray(const NDArray& arr)=delete;
template<unsigned int M>
NDArray(NDArray<T, M>&& arr) :
dimensions(ProjectDimensions<M>(arr.dimensions)),
totalSize(arr.totalSize),
_data(std::move(arr._data)){}
NDArray& operator=(const NDArray& arr) = delete;
NDArray& operator=(NDArray&& arr) = delete;
~NDArray() {
if (_data) { delete[] _data; }
};
unsigned int coordinateToIndex(const Coordinate& coord) const {
unsigned int blockSize = 1;
unsigned int ret = 0;
for (auto i = 0; i < dimensions.size(); ++i) {
ret += coord[i] * blockSize;
blockSize *= dimensions[i];
}
return ret;
}
inline NDArray& copy() const {
return NDArray(dimensions, _data);
}
inline const T& at(const Coordinate& coord) const {
return operator[](coord);
}
inline const T* data() const { return _data; }
inline const T& operator[](const Coordinate& coord) const {
return _data[coordinateToIndex(coord)];
}
inline T& at(const Coordinate& coord) {
return _data[coordinateToIndex(coord)];
}
inline T* data(const T* data_) {
if (!_data) { _data = new T[totalSize]; }
std::memcpy(_data, data_, totalSize * sizeof(T));
return _data;
}
inline T& operator[](const Coordinate& coord) {
return _data[coordinateToIndex(coord)];
}
}; // class NDArray<type, int>
} // namespace nb
#endif // _NB_DATA_TYPES
engine/NBCore/include/NBCore/CoreTypes.hpp
+37
View File
@@ -0,0 +1,37 @@
#pragma once
#ifndef _NB_CORE_TYPES
#define _NB_CORE_TYPES
#include <memory>
#include <unordered_map>
#include <vector>
namespace nb {
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>;
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);
}
};
enum TypeCodes {
UINT8, UINT16, UINT32, UINT64, INT8, INT16, INT32, INT64,
FLOAT16, FLOAT32, DOUBLE64, BOOL, NONE
};
}; // namespace nb
#endif // _NB_NB_CORE_TYPES
engine/NBCore/include/NBCore/DataTypes.hpp
-71
View File
@@ -1,71 +0,0 @@
#pragma once
#include <cstring>
#ifndef _NB_DATA_TYPES
#define _NB_DATA_TYPES
#include <algorithm>
#include <array>
#include <memory>
namespace nb {
template<typename T, unsigned int N>
class NDArray {
protected:
std::unique_ptr<T[]> _data;
static unsigned int calculateTotalSize(const std::array<unsigned int, N>& dims) {
unsigned int ret = 1;
std::for_each(dims.begin(), dims.end(), [&](unsigned int n){
ret *= n;
});
return ret;
}
public:
const std::array<unsigned int, N> dimensions;
const unsigned int totalSize;
static constexpr unsigned int NumberDimensions = N;
NDArray(
const std::array<unsigned int, N>& dimensions_,
T* data_=nullptr
) :
dimensions(dimensions_),
totalSize(calculateTotalSize(dimensions_))
{
if (data_) { data(data_); }
}
NDArray(
const std::array<unsigned int, N>& dimensions_,
const T* data_
) : NDArray(dimensions_) { data(data_); }
unsigned int coordinateToIndex(const std::array<T, N>& coord) const {
unsigned int blockSize = 1;
unsigned int ret = 0;
for (auto i = 0; i < dimensions.size(); ++i) {
ret += coord[i] * blockSize;
blockSize *= dimensions[i];
}
return ret;
}
inline const T& at(const std::array<T, N>& coord) const {
return _data[coordinateToIndex(coord)];
}
inline std::shared_ptr<T> data() const { return _data; }
inline T& at(const std::array<T, N>& coord) {
return _data[coordinateToIndex(coord)];
}
inline T* data(const T* data_) {
_data = std::make_unique<T[]>(totalSize);
std::memcpy(_data.get(), data_, totalSize * sizeof(T));
return _data.get();
}
}; // namespace nb
}
#endif // _NB_DATA_TYPES
engine/NBCore/include/NBCore/ErrorsImpl.hpp
+1 -1
View File
@@ -8,7 +8,7 @@
#include <type_traits>
#include <NBCore/StringUtils.hpp>
#include <NBCore/Utils.hpp>
#include <NBCore/CoreTypes.hpp>
namespace nb {
engine/NBCore/include/NBCore/TypeTraits.hpp
+2 -5
View File
@@ -5,6 +5,8 @@
#include <type_traits>
#include <utility>
#include <NBCore/CoreTypes.hpp>
namespace nb {
namespace detail {
@@ -33,11 +35,6 @@ namespace detail {
template<typename K, typename V>
std::pair<K, V> KeyVal(K key, V val) { return std::pair(key, val); }
enum TypeCodes {
UINT8, UINT16, UINT32, UINT64, INT8, INT16, INT32, INT64,
FLOAT16, FLOAT32, DOUBLE64, BOOL, NONE
};
template<typename T>
static constexpr TypeCodes GetTypeEnum = NONE;
engine/NBCore/include/NBCore/Utils.hpp
+5 -27
View File
@@ -2,34 +2,13 @@
#ifndef _NB_UTILTIES
#define _NB_UTILTIES
#include <memory>
#include <unordered_map>
#include <vector>
// #include <NBCore/Errors.hpp>
#include <NBCore/CoreTypes.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>>;
template<typename T>
using RValueVector = std::vector<T&&>;
using ByteVector = std::vector<uint8_t>;
/* class ObjectManagerError : public Error<ObjectManagerError> {
using Base = Error<ObjectManagerError>;
@@ -67,11 +46,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(
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());
engine/NBCore/tests/CMakeLists.txt
+1
View File
@@ -3,6 +3,7 @@ cmake_minimum_required(VERSION 3.26.0)
enable_testing()
include(GoogleTest)
add_executable(TestCore
./testArrays.cpp
./testErrors.cpp
#./testProcesses.cpp
./testUtils.cpp
engine/NBCore/tests/testArrays.cpp
+73
View File
@@ -0,0 +1,73 @@
#define CODE_ERROR_LOCATIONS
#include <gtest/gtest.h>
#include <NBCore/Arrays.hpp>
template<unsigned int N>
using Coord = typename nb::NDArray<uint8_t, N>::Coordinate;
template<typename A, typename B>
void ASSERT_ARRAY_EQ(A a, B b) {
unsigned int n = a.size();
for (int i = 0; i < n; ++i) {
ASSERT_EQ(a[i], b[i]);
}
}
TEST(TestNDArray, TestBasic) {
float* data_f = new float[9] {0,1,2,3,4,5,6,7,8};
nb::NDArray<float, 2> arr({3, 3}, data_f);
Coord<2> x{1,1};
ASSERT_ARRAY_EQ(arr.dimensions, Coord<2>{3,3});
ASSERT_FLOAT_EQ(data_f[4], arr.at(x));
arr.at(x) = 0.5;
ASSERT_FLOAT_EQ(0.5, arr.at(x));
delete[] data_f;
Coord<3> y{1,0,1};
unsigned int* data_ui = new unsigned int[8] {0,1,2,3,4,5,6,7};
nb::NDArray<unsigned int, 3> arr3d({2,2,2}, data_ui);
ASSERT_ARRAY_EQ(arr3d.dimensions, Coord<3>{2,2,2});
ASSERT_EQ(data_ui[5], arr3d.at(y));
arr3d[{0,1,1}] = 23;
ASSERT_EQ(23, arr3d.at({0,1,1}));
delete[] data_ui;
nb::NDArray<uint8_t, 4> arr4d({4,4,4,4});
arr4d[{0,1,2,3}] = 57;
ASSERT_ARRAY_EQ(arr4d.dimensions, Coord<4>{4,4,4,4});
ASSERT_EQ(57, arr4d.at({0,1,2,3}));
}
TEST(TestNDArray, TestMove) {
unsigned int data_ui[8] = {0,1,2,3,4,5,6,7};
nb::NDArray<unsigned int, 2> arr_1({4, 2}, data_ui);
nb::NDArray<unsigned int, 2> arr_2(std::move(arr_1));
Coord<2> x{2, 1};
ASSERT_EQ(arr_1.data(), nullptr);
ASSERT_ARRAY_EQ(arr_1.dimensions, arr_2.dimensions);
ASSERT_EQ(arr_2.at(x), 6);
}
TEST(TestNDArray, TestConversion) {
nb::NDArray<unsigned int, 2> arr1({3,3});
nb::NDArray<unsigned int, 3> arr2(std::move(arr1));
ASSERT_EQ(arr1.data(), nullptr);
ASSERT_ARRAY_EQ(arr2.dimensions, Coord<3>{3,3,1});
nb::NDArray<unsigned int, 2> arr3(std::move(arr2));
ASSERT_EQ(arr2.data(), nullptr);
ASSERT_ARRAY_EQ(arr3.dimensions, Coord<2>{3,3});
}
TEST(TestNDArray, TestFromMemory) {
auto data = new float[9]{1,2,3,4,5,6,7,8,9};
auto arr1 = nb::NDArray<float, 2>::MemoryToNDArray({3,3}, data);
ASSERT_EQ(arr1.data(), data);
ASSERT_FLOAT_EQ(arr1.at({1,2}), data[5]);
auto data2 = new float[9]{9,8,7,6,5,4,3,2,1};
arr1.data(data2);
ASSERT_EQ(arr1.data(), data);
ASSERT_FLOAT_EQ(arr1.at({3,0}), data2[6]);
delete[] data2;
}
engine/NBCore/tests/testUtils.cpp
+2 -20
View File
@@ -3,9 +3,9 @@
#include <gtest/gtest.h>
#include <string>
#include <NBCore/DataTypes.hpp>
#include <NBCore/TypeTraits.hpp>
#include <NBCore/StringUtils.hpp>
#include <NBCore/TypeTraits.hpp>
#include <NBCore/Utils.hpp>
namespace nb {
@@ -107,22 +107,4 @@ TEST(UtilsTest, TestIsDetected) {
ASSERT_TRUE(ret);
}
TEST(DataTypesTests, TestNDArray) {
float* data_f = new float[9] {0,1,2,3,4,5,6,7,8};
nb::NDArray<float, 2> arr({3, 3}, data_f);
ASSERT_FLOAT_EQ(data_f[4], arr.at({1,1}));
arr.at({1,1}) = 0.5;
ASSERT_FLOAT_EQ(0.5, arr.at({1,1}));
delete[] data_f;
unsigned int* data_ui = new unsigned int[8] {0,1,2,3,4,5,6,7};
nb::NDArray<unsigned int, 3> arr3d({2,2,2}, data_ui);
ASSERT_EQ(data_ui[5], arr3d.at({1,0,1}));
arr3d.at({0,1,1}) = 23;
ASSERT_EQ(23, arr3d.at({0,1,1}));
delete[] data_ui;
}
} // namespace nb