admin/omath
1
0
Fork 0
mirror of https://github.com/orange-cpp/omath.git synced 2026-02-13 07:03:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #17 from luadebug/export

Browse Source 
Create Export for DLL (shared MSVC build)
This commit is contained in:
Orange++
2024-12-17 12:24:11 +03:00
committed by GitHub
parent c0efa35e8a fc164b339b
commit 5f8fc4058c
20 changed files with 144 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
CMakeLists.txt
View File

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.26)
project(omath VERSION 1.0.0)
include(CMakePackageConfigHelpers)
set(CMAKE_CXX_STANDARD 26)
@@ -19,10 +19,16 @@ else()
add_library(omath STATIC source/Vector3.cpp)
endif()
target_compile_definitions(omath PUBLIC OMATH_EXPORT)
if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
target_compile_options(omath PRIVATE /Zc:static_assert-)
endif()
add_subdirectory(source)
add_subdirectory(extlibs)
if(OMATH_BUILD_TESTS)
add_subdirectory(extlibs)
add_subdirectory(tests)
endif()
@@ -79,4 +85,4 @@ install(FILES
"${CMAKE_CURRENT_BINARY_DIR}/omathConfig.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/omathConfigVersion.cmake"
DESTINATION lib/cmake/omath
)
)

4
include/omath/Angle.hpp
View File

@@ -6,7 +6,7 @@
#include "omath/Angles.hpp"
#include <algorithm>
#include "omath/omath_export.hpp"
namespace omath
{
@@ -18,7 +18,7 @@ namespace omath
template<class Type = float, Type min = Type(0), Type max = Type(360), AngleFlags flags = AngleFlags::Normalized>
requires std::is_arithmetic_v<Type>
class Angle
class OMATH_API Angle
{
Type m_angle;
constexpr Angle(const Type& degrees)

1
include/omath/Angles.hpp
View File

@@ -6,7 +6,6 @@
#include <numbers>
#include <cmath>
namespace omath::angles
{
template<class Type>

6
include/omath/Color.hpp
View File

@@ -7,11 +7,11 @@
#include "omath/Vector3.hpp"
#include <cstdint>
#include "omath/Vector4.hpp"
#include "omath/omath_export.hpp"
namespace omath
{
struct HSV
struct OMATH_API HSV
{
float m_hue{};
float m_saturation{};
@@ -19,7 +19,7 @@ namespace omath
};
class Color final : public Vector4
class OMATH_API Color final : public Vector4
{
public:
constexpr Color(float r, float g, float b, float a) : Vector4(r,g,b,a)

76
include/omath/Mat.hpp
View File

@@ -8,11 +8,11 @@
#include <stdexcept>
#include <utility>
#include "Vector3.hpp"
#include "omath/omath_export.hpp"
namespace omath
{
struct MatSize
struct OMATH_API MatSize
{
size_t rows, columns;
};
@@ -28,15 +28,15 @@ namespace omath
class Mat final
{
public:
constexpr Mat()
OMATH_API constexpr Mat()
{
Clear();
}
constexpr static MatStoreType GetStoreOrdering()
OMATH_API constexpr static MatStoreType GetStoreOrdering()
{
return StoreType;
}
constexpr Mat(const std::initializer_list<std::initializer_list<Type>>& rows)
OMATH_API constexpr Mat(const std::initializer_list<std::initializer_list<Type>>& rows)
{
if (rows.size() != Rows)
throw std::invalid_argument("Initializer list rows size does not match template parameter Rows");
@@ -56,40 +56,40 @@ namespace omath
}
}
constexpr explicit Mat(const Type* rawData)
OMATH_API constexpr explicit Mat(const Type* rawData)
{
std::copy_n(rawData, Rows * Columns, m_data.begin());
}
constexpr Mat(const Mat& other) noexcept
OMATH_API constexpr Mat(const Mat& other) noexcept
{
m_data = other.m_data;
}
constexpr Mat(Mat&& other) noexcept
OMATH_API constexpr Mat(Mat&& other) noexcept
{
m_data = std::move(other.m_data);
}
[[nodiscard]]
static constexpr size_t RowCount() noexcept
OMATH_API static constexpr size_t RowCount() noexcept
{
return Rows;
}
[[nodiscard]]
static constexpr size_t ColumnsCount() noexcept
OMATH_API static constexpr size_t ColumnsCount() noexcept
{
return Columns;
}
[[nodiscard]]
static consteval MatSize Size() noexcept
OMATH_API static consteval MatSize Size() noexcept
{
return {Rows, Columns};
}
[[nodiscard]] constexpr const Type& At(const size_t rowIndex, const size_t columnIndex) const
[[nodiscard]] OMATH_API constexpr const Type& At(const size_t rowIndex, const size_t columnIndex) const
{
if (rowIndex >= Rows || columnIndex >= Columns)
throw std::out_of_range("Index out of range");
@@ -107,13 +107,13 @@ namespace omath
}
}
[[nodiscard]] constexpr Type& At(const size_t rowIndex, const size_t columnIndex)
[[nodiscard]] OMATH_API constexpr Type& At(const size_t rowIndex, const size_t columnIndex)
{
return const_cast<Type&>(std::as_const(*this).At(rowIndex, columnIndex));
}
[[nodiscard]]
constexpr Type Sum() const noexcept
OMATH_API constexpr Type Sum() const noexcept
{
Type sum = 0;
for (size_t i = 0; i < Rows; ++i)
@@ -123,12 +123,12 @@ namespace omath
return sum;
}
constexpr void Clear() noexcept
OMATH_API constexpr void Clear() noexcept
{
Set(0);
}
constexpr void Set(const Type& value) noexcept
OMATH_API constexpr void Set(const Type& value) noexcept
{
std::ranges::fill(m_data, value);
}
@@ -136,7 +136,7 @@ namespace omath
// Operator overloading for multiplication with another Mat
template<size_t OtherColumns>
constexpr Mat<Rows, OtherColumns, Type, StoreType>
operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const
OMATH_API operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const
{
Mat<Rows, OtherColumns, Type, StoreType> result;
@@ -151,7 +151,7 @@ namespace omath
return result;
}
constexpr Mat& operator*=(const Type& f) noexcept
OMATH_API constexpr Mat& operator*=(const Type& f) noexcept
{
for (size_t i = 0; i < Rows; ++i)
for (size_t j = 0; j < Columns; ++j)
@@ -161,19 +161,19 @@ namespace omath
template<size_t OtherColumns>
constexpr Mat<Rows, OtherColumns, Type, StoreType>
operator*=(const Mat<Columns, OtherColumns, Type, StoreType>& other)
OMATH_API operator*=(const Mat<Columns, OtherColumns, Type, StoreType>& other)
{
return *this = *this * other;
}
constexpr Mat operator*(const Type& f) const noexcept
OMATH_API constexpr Mat operator*(const Type& f) const noexcept
{
Mat result(*this);
result *= f;
return result;
}
constexpr Mat& operator/=(const Type& f) noexcept
OMATH_API constexpr Mat& operator/=(const Type& f) noexcept
{
for (size_t i = 0; i < Rows; ++i)
for (size_t j = 0; j < Columns; ++j)
@@ -181,14 +181,14 @@ namespace omath
return *this;
}
constexpr Mat operator/(const Type& f) const noexcept
OMATH_API constexpr Mat operator/(const Type& f) const noexcept
{
Mat result(*this);
result /= f;
return result;
}
constexpr Mat& operator=(const Mat& other) noexcept
OMATH_API constexpr Mat& operator=(const Mat& other) noexcept
{
if (this == &other)
return *this;
@@ -198,7 +198,7 @@ namespace omath
return *this;
}
constexpr Mat& operator=(Mat&& other) noexcept
OMATH_API constexpr Mat& operator=(Mat&& other) noexcept
{
if (this == &other)
return *this;
@@ -211,7 +211,7 @@ namespace omath
}
[[nodiscard]]
constexpr Mat<Columns, Rows, Type, StoreType> Transposed() const noexcept
OMATH_API constexpr Mat<Columns, Rows, Type, StoreType> Transposed() const noexcept
{
Mat<Columns, Rows, Type, StoreType> transposed;
for (size_t i = 0; i < Rows; ++i)
@@ -222,7 +222,7 @@ namespace omath
}
[[nodiscard]]
constexpr Type Determinant() const
OMATH_API constexpr Type Determinant() const
{
static_assert(Rows == Columns, "Determinant is only defined for square matrices.");
@@ -244,7 +244,7 @@ namespace omath
}
[[nodiscard]]
constexpr Mat<Rows - 1, Columns - 1, Type, StoreType> Minor(const size_t row, const size_t column) const
OMATH_API constexpr Mat<Rows - 1, Columns - 1, Type, StoreType> Minor(const size_t row, const size_t column) const
{
Mat<Rows - 1, Columns - 1, Type, StoreType> result;
for (size_t i = 0, m = 0; i < Rows; ++i)
@@ -264,19 +264,19 @@ namespace omath
}
[[nodiscard]]
constexpr const std::array<Type, Rows * Columns>& RawArray() const
OMATH_API constexpr const std::array<Type, Rows * Columns>& RawArray() const
{
return m_data;
}
[[nodiscard]]
constexpr std::array<Type, Rows * Columns>& RawArray()
OMATH_API constexpr std::array<Type, Rows * Columns>& RawArray()
{
return const_cast<std::array<Type, Rows * Columns>>(std::as_const(*this).RawArray());
}
[[nodiscard]]
std::string ToString() const noexcept
OMATH_API std::string ToString() const noexcept
{
std::ostringstream oss;
for (size_t i = 0; i < Rows; ++i)
@@ -293,20 +293,20 @@ namespace omath
}
[[nodiscard]]
bool operator==(const Mat& mat) const
OMATH_API bool operator==(const Mat& mat) const
{
return m_data == mat.m_data;
}
[[nodiscard]]
bool operator!=(const Mat& mat) const
OMATH_API bool operator!=(const Mat& mat) const
{
return !operator==(mat);
}
// Static methods that return fixed-size matrices
[[nodiscard]]
constexpr static Mat<4, 4> ToScreenMat(const Type& screenWidth, const Type& screenHeight) noexcept
OMATH_API constexpr static Mat<4, 4> ToScreenMat(const Type& screenWidth, const Type& screenHeight) noexcept
{
return {
{screenWidth / 2, 0, 0, 0},
@@ -336,7 +336,7 @@ namespace omath
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
[[nodiscard]]
constexpr Mat<4, 4, Type, St> MatTranslation(const Vector3& diff) noexcept
OMATH_API constexpr Mat<4, 4, Type, St> MatTranslation(const Vector3& diff) noexcept
{
return
{
@@ -349,7 +349,7 @@ namespace omath
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
[[nodiscard]]
Mat<4, 4, Type, St> MatRotationAxisX(const Angle& angle) noexcept
OMATH_API Mat<4, 4, Type, St> MatRotationAxisX(const Angle& angle) noexcept
{
return
{
@@ -362,7 +362,7 @@ namespace omath
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
[[nodiscard]]
Mat<4, 4, Type, St> MatRotationAxisY(const Angle& angle) noexcept
OMATH_API Mat<4, 4, Type, St> MatRotationAxisY(const Angle& angle) noexcept
{
return
{
@@ -375,7 +375,7 @@ namespace omath
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
[[nodiscard]]
Mat<4, 4, Type, St> MatRotationAxisZ(const Angle& angle) noexcept
OMATH_API Mat<4, 4, Type, St> MatRotationAxisZ(const Angle& angle) noexcept
{
return
{
@@ -403,7 +403,7 @@ namespace omath
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class ViewAngles>
[[nodiscard]]
Mat<4, 4, Type, St> MatRotation(const ViewAngles& angles) noexcept
OMATH_API Mat<4, 4, Type, St> MatRotation(const ViewAngles& angles) noexcept
{
return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll);
}

71
include/omath/Matrix.hpp
View File

@@ -2,6 +2,7 @@
#include <initializer_list>
#include <memory>
#include <string>
#include "omath/omath_export.hpp"
namespace omath
{
@@ -10,91 +11,91 @@ namespace omath
class Matrix final
{
public:
Matrix();
Matrix(size_t rows, size_t columns);
OMATH_API Matrix();
OMATH_API Matrix(size_t rows, size_t columns);
Matrix(const std::initializer_list<std::initializer_list<float>>& rows);
OMATH_API Matrix(const std::initializer_list<std::initializer_list<float>>& rows);
[[nodiscard]]
static Matrix ToScreenMatrix(float screenWidth, float screenHeight);
OMATH_API static Matrix ToScreenMatrix(float screenWidth, float screenHeight);
[[nodiscard]]
static Matrix TranslationMatrix(const Vector3& diff);
OMATH_API static Matrix TranslationMatrix(const Vector3& diff);
[[nodiscard]]
static Matrix OrientationMatrix(const Vector3& forward, const Vector3& right, const Vector3& up);
OMATH_API static Matrix OrientationMatrix(const Vector3& forward, const Vector3& right, const Vector3& up);
[[nodiscard]]
static Matrix ProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
OMATH_API static Matrix ProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
Matrix(const Matrix& other);
OMATH_API Matrix(const Matrix& other);
Matrix(size_t rows, size_t columns, const float* pRaw);
OMATH_API Matrix(size_t rows, size_t columns, const float* pRaw);
Matrix(Matrix&& other) noexcept;
OMATH_API Matrix(Matrix&& other) noexcept;
[[nodiscard]]
size_t RowCount() const noexcept;
OMATH_API size_t RowCount() const noexcept;
[[nodiscard]]
size_t ColumnsCount() const noexcept;
OMATH_API size_t ColumnsCount() const noexcept;
[[nodiscard]]
std::pair<size_t, size_t> Size() const noexcept;
OMATH_API std::pair<size_t, size_t> Size() const noexcept;
[[nodiscard]]
float& At(size_t iRow, size_t iCol);
OMATH_API float& At(size_t iRow, size_t iCol);
[[nodiscard]]
float Sum();
OMATH_API float Sum();
void SetDataFromRaw(const float* pRawMatrix);
OMATH_API void SetDataFromRaw(const float* pRawMatrix);
[[nodiscard]]
Matrix Transpose() const;
OMATH_API Matrix Transpose() const;
void Set(float val);
OMATH_API void Set(float val);
[[nodiscard]]
const float& At(size_t iRow, size_t iCol) const;
OMATH_API const float& At(size_t iRow, size_t iCol) const;
Matrix operator*(const Matrix& other) const;
OMATH_API Matrix operator*(const Matrix& other) const;
Matrix& operator*=(const Matrix& other);
OMATH_API Matrix& operator*=(const Matrix& other);
Matrix operator*(float f) const;
OMATH_API Matrix operator*(float f) const;
Matrix& operator*=(float f);
OMATH_API Matrix& operator*=(float f);
Matrix& operator/=(float f);
OMATH_API Matrix& operator/=(float f);
void Clear();
OMATH_API void Clear();
[[nodiscard]]
Matrix Strip(size_t row, size_t column) const;
OMATH_API Matrix Strip(size_t row, size_t column) const;
[[nodiscard]]
float Minor(size_t i, size_t j) const;
OMATH_API float Minor(size_t i, size_t j) const;
[[nodiscard]]
float AlgComplement(size_t i, size_t j) const;
OMATH_API float AlgComplement(size_t i, size_t j) const;
[[nodiscard]]
float Determinant() const;
OMATH_API float Determinant() const;
[[nodiscard]]
const float* Raw() const;
OMATH_API const float* Raw() const;
Matrix& operator=(const Matrix& other);
OMATH_API Matrix& operator=(const Matrix& other);
Matrix& operator=(Matrix&& other) noexcept;
OMATH_API Matrix& operator=(Matrix&& other) noexcept;
Matrix operator/(float f) const;
OMATH_API Matrix operator/(float f) const;
[[nodiscard]]
std::string ToString() const;
OMATH_API std::string ToString() const;
~Matrix();
OMATH_API ~Matrix();
private:
size_t m_rows;

3
include/omath/Triangle3d.hpp
View File

@@ -3,10 +3,11 @@
//
#pragma once
#include "omath/Vector3.hpp"
#include "omath/omath_export.hpp"
namespace omath
{
class Triangle3d final
class OMATH_API Triangle3d final
{
public:
Triangle3d(const Vector3& vertex1, const Vector3& vertex2, const Vector3& vertex3);

4
include/omath/Vector2.hpp
View File

@@ -5,11 +5,11 @@
#pragma once
#include <tuple>
#include <cmath>
#include "omath/omath_export.hpp"
namespace omath
{
class Vector2
class OMATH_API Vector2
{
public:
float x = 0.f;

4
include/omath/Vector3.hpp
View File

@@ -7,11 +7,11 @@
#include <cstdint>
#include <functional>
#include "omath/Vector2.hpp"
#include "omath/omath_export.hpp"
namespace omath
{
class Vector3 : public Vector2
class OMATH_API Vector3 : public Vector2
{
public:
float z = 0.f;

4
include/omath/Vector4.hpp
View File

@@ -5,11 +5,11 @@
#include <omath/Vector3.hpp>
#include <algorithm>
#include "omath/omath_export.hpp"
namespace omath
{
class Vector4 : public Vector3
class OMATH_API Vector4 : public Vector3
{
public:
float w;

4
include/omath/ViewAngles.hpp
View File

@@ -3,10 +3,12 @@
//
#pragma once
#include "omath/omath_export.hpp"
namespace omath
{
template<class PitchType, class YawType, class RollType>
struct ViewAngles
struct OMATH_API ViewAngles
{
PitchType pitch;
YawType yaw;

6
include/omath/collision/LineTracer.hpp
View File

@@ -5,11 +5,11 @@
#include "omath/Vector3.hpp"
#include "omath/Triangle3d.hpp"
#include "omath/omath_export.hpp"
namespace omath::collision
{
class Ray
class OMATH_API Ray
{
public:
Vector3 start;
@@ -21,7 +21,7 @@ namespace omath::collision
[[nodiscard]]
Vector3 DirectionVectorNormalized() const;
};
class LineTracer
class OMATH_API LineTracer
{
public:
LineTracer() = delete;

3
include/omath/engines/Source/Camera.hpp
View File

@@ -4,10 +4,11 @@
#pragma once
#include "Constants.h"
#include "omath/projection/Camera.hpp"
#include "omath/omath_export.hpp"
namespace omath::source
{
class Camera final : public projection::Camera<Mat4x4, ViewAngles>
class OMATH_API Camera final : public projection::Camera<Mat4x4, ViewAngles>
{
public:
Camera(const Vector3& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,

24
include/omath/omath_export.hpp Normal file
View File

@@ -0,0 +1,24 @@
#pragma once
/* Export prefix for functions */
#ifdef _MSC_VER
/* MSVC */
# define OMATH_API_EXPORT __declspec(dllexport)
#else
/* GCC/Clang */
# define OMATH_API_EXPORT __attribute__((visibility("default")))
#endif
/* Import prefix for functions */
#ifdef _MSC_VER
# define OMATH_API_IMPORT __declspec(dllimport)
#else
# define OMATH_API_IMPORT extern
#endif
/* Resolve import/export */
#ifdef OMATH_EXPORT
# define OMATH_API OMATH_API_EXPORT
#else
# define OMATH_API OMATH_API_IMPORT
#endif

4
include/omath/pathfinding/Astar.hpp
View File

@@ -6,11 +6,11 @@
#include <vector>
#include "NavigationMesh.hpp"
#include "omath/Vector3.hpp"
#include "omath/omath_export.hpp"
namespace omath::pathfinding
{
class Astar final
class OMATH_API Astar final
{
public:
[[nodiscard]]

10
include/omath/pathfinding/NavigationMesh.hpp
View File

@@ -8,7 +8,7 @@
#include <expected>
#include <vector>
#include <string>
#include "omath/omath_export.hpp"
namespace omath::pathfinding
{
@@ -23,16 +23,16 @@ namespace omath::pathfinding
public:
[[nodiscard]]
std::expected<Vector3, std::string> GetClosestVertex(const Vector3& point) const;
OMATH_API std::expected<Vector3, std::string> GetClosestVertex(const Vector3& point) const;
[[nodiscard]]
const std::vector<Vector3>& GetNeighbors(const Vector3& vertex) const;
OMATH_API const std::vector<Vector3>& GetNeighbors(const Vector3& vertex) const;
[[nodiscard]]
bool Empty() const;
OMATH_API bool Empty() const;
[[nodiscard]] std::vector<uint8_t> Serialize() const;
void Deserialize(const std::vector<uint8_t>& raw);
OMATH_API void Deserialize(const std::vector<uint8_t>& raw);
std::unordered_map<Vector3, std::vector<Vector3>> m_verTextMap;
};

4
include/omath/prediction/Engine.hpp
View File

@@ -8,11 +8,11 @@
#include "omath/Vector3.hpp"
#include "omath/prediction/Projectile.hpp"
#include "omath/prediction/Target.hpp"
#include "omath/omath_export.hpp"
namespace omath::prediction
{
class Engine final
class OMATH_API Engine final
{
public:
explicit Engine(float gravityConstant, float simulationTimeStep,

4
include/omath/prediction/Projectile.hpp
View File

@@ -4,11 +4,11 @@
#pragma once
#include "omath/Vector3.hpp"
#include "omath/omath_export.hpp"
namespace omath::prediction
{
class Projectile final
class OMATH_API Projectile final
{
public:

4
include/omath/prediction/Target.hpp
View File

@@ -4,11 +4,11 @@
#pragma once
#include "omath/Vector3.hpp"
#include "omath/omath_export.hpp"
namespace omath::prediction
{
class Target final
class OMATH_API Target final
{
public:

6
include/omath/projection/Camera.hpp
View File

@@ -10,11 +10,11 @@
#include "ErrorCodes.hpp"
#include <omath/Angle.hpp>
#include <type_traits>
#include "omath/omath_export.hpp"
namespace omath::projection
{
class ViewPort final
class OMATH_API ViewPort final
{
public:
float m_width;
@@ -28,7 +28,7 @@ namespace omath::projection
using FieldOfView = const Angle<float, 0.f, 180.f, AngleFlags::Clamped>;
template<class Mat4x4Type, class ViewAnglesType>
class Camera
class OMATH_API Camera
{
public: