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 #21 from orange-cpp/u/orange-cpp/dropped-shared-export

Browse Source 
U/orange cpp/dropped shared export
This commit is contained in:
Orange++
2024-12-23 13:52:55 +03:00
committed by GitHub
parent 30bc3f2c6d 9ad8ec755b
commit c3bfd12971
20 changed files with 95 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.idea/vcs.xml generated
View File

@@ -2,7 +2,6 @@
<project version="4"> <project version="4">
<component name="VcsDirectoryMappings"> <component name="VcsDirectoryMappings">
<mapping directory="" vcs="Git" /> <mapping directory="" vcs="Git" />
<mapping directory="$PROJECT_DIR$/extlibs/glm" vcs="Git" />
<mapping directory="$PROJECT_DIR$/extlibs/googletest" vcs="Git" /> <mapping directory="$PROJECT_DIR$/extlibs/googletest" vcs="Git" />
</component> </component>
</project> </project>

4
CMakeLists.txt
View File

@@ -21,10 +21,6 @@ endif()
target_compile_definitions(omath PUBLIC OMATH_EXPORT) 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(source)
if(OMATH_BUILD_TESTS) if(OMATH_BUILD_TESTS)

4
include/omath/Angle.hpp
View File

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

5
include/omath/Color.hpp
View File

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

77
include/omath/Mat.hpp
View File

@@ -8,11 +8,10 @@
#include <stdexcept> #include <stdexcept>
#include <utility> #include <utility>
#include "Vector3.hpp" #include "Vector3.hpp"
#include "omath/omath_export.hpp"
namespace omath namespace omath
{ {
struct OMATH_API MatSize struct MatSize
{ {
size_t rows, columns; size_t rows, columns;
}; };
@@ -28,15 +27,15 @@ namespace omath
class Mat final class Mat final
{ {
public: public:
OMATH_API constexpr Mat() constexpr Mat()
{ {
Clear(); Clear();
} }
OMATH_API constexpr static MatStoreType GetStoreOrdering() constexpr static MatStoreType GetStoreOrdering()
{ {
return StoreType; return StoreType;
} }
OMATH_API constexpr Mat(const std::initializer_list<std::initializer_list<Type>>& rows) constexpr Mat(const std::initializer_list<std::initializer_list<Type>>& rows)
{ {
if (rows.size() != Rows) if (rows.size() != Rows)
throw std::invalid_argument("Initializer list rows size does not match template parameter Rows"); throw std::invalid_argument("Initializer list rows size does not match template parameter Rows");
@@ -56,45 +55,45 @@ namespace omath
} }
} }
OMATH_API constexpr explicit Mat(const Type* rawData) constexpr explicit Mat(const Type* rawData)
{ {
std::copy_n(rawData, Rows * Columns, m_data.begin()); std::copy_n(rawData, Rows * Columns, m_data.begin());
} }
OMATH_API constexpr Mat(const Mat& other) noexcept constexpr Mat(const Mat& other) noexcept
{ {
m_data = other.m_data; m_data = other.m_data;
} }
OMATH_API constexpr Type& operator[](const size_t row, const size_t col) constexpr Type& operator[](const size_t row, const size_t col)
{ {
return At(row, col); return At(row, col);
} }
OMATH_API constexpr Mat(Mat&& other) noexcept constexpr Mat(Mat&& other) noexcept
{ {
m_data = std::move(other.m_data); m_data = std::move(other.m_data);
} }
[[nodiscard]] [[nodiscard]]
OMATH_API static constexpr size_t RowCount() noexcept static constexpr size_t RowCount() noexcept
{ {
return Rows; return Rows;
} }
[[nodiscard]] [[nodiscard]]
OMATH_API static constexpr size_t ColumnsCount() noexcept static constexpr size_t ColumnsCount() noexcept
{ {
return Columns; return Columns;
} }
[[nodiscard]] [[nodiscard]]
OMATH_API static consteval MatSize Size() noexcept static consteval MatSize Size() noexcept
{ {
return {Rows, Columns}; return {Rows, Columns};
} }
[[nodiscard]] OMATH_API constexpr const Type& At(const size_t rowIndex, const size_t columnIndex) const [[nodiscard]] constexpr const Type& At(const size_t rowIndex, const size_t columnIndex) const
{ {
if (rowIndex >= Rows || columnIndex >= Columns) if (rowIndex >= Rows || columnIndex >= Columns)
throw std::out_of_range("Index out of range"); throw std::out_of_range("Index out of range");
@@ -112,13 +111,13 @@ namespace omath
} }
} }
[[nodiscard]] OMATH_API constexpr Type& At(const size_t rowIndex, const size_t columnIndex) [[nodiscard]] constexpr Type& At(const size_t rowIndex, const size_t columnIndex)
{ {
return const_cast<Type&>(std::as_const(*this).At(rowIndex, columnIndex)); return const_cast<Type&>(std::as_const(*this).At(rowIndex, columnIndex));
} }
[[nodiscard]] [[nodiscard]]
OMATH_API constexpr Type Sum() const noexcept constexpr Type Sum() const noexcept
{ {
Type sum = 0; Type sum = 0;
for (size_t i = 0; i < Rows; ++i) for (size_t i = 0; i < Rows; ++i)
@@ -128,12 +127,12 @@ namespace omath
return sum; return sum;
} }
OMATH_API constexpr void Clear() noexcept constexpr void Clear() noexcept
{ {
Set(0); Set(0);
} }
OMATH_API constexpr void Set(const Type& value) noexcept constexpr void Set(const Type& value) noexcept
{ {
std::ranges::fill(m_data, value); std::ranges::fill(m_data, value);
} }
@@ -141,7 +140,7 @@ namespace omath
// Operator overloading for multiplication with another Mat // Operator overloading for multiplication with another Mat
template<size_t OtherColumns> template<size_t OtherColumns>
constexpr Mat<Rows, OtherColumns, Type, StoreType> constexpr Mat<Rows, OtherColumns, Type, StoreType>
OMATH_API operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const
{ {
Mat<Rows, OtherColumns, Type, StoreType> result; Mat<Rows, OtherColumns, Type, StoreType> result;
@@ -156,7 +155,7 @@ namespace omath
return result; return result;
} }
OMATH_API constexpr Mat& operator*=(const Type& f) noexcept constexpr Mat& operator*=(const Type& f) noexcept
{ {
for (size_t i = 0; i < Rows; ++i) for (size_t i = 0; i < Rows; ++i)
for (size_t j = 0; j < Columns; ++j) for (size_t j = 0; j < Columns; ++j)
@@ -166,19 +165,19 @@ namespace omath
template<size_t OtherColumns> template<size_t OtherColumns>
constexpr Mat<Rows, OtherColumns, Type, StoreType> constexpr Mat<Rows, OtherColumns, Type, StoreType>
OMATH_API operator*=(const Mat<Columns, OtherColumns, Type, StoreType>& other) operator*=(const Mat<Columns, OtherColumns, Type, StoreType>& other)
{ {
return *this = *this * other; return *this = *this * other;
} }
OMATH_API constexpr Mat operator*(const Type& f) const noexcept constexpr Mat operator*(const Type& f) const noexcept
{ {
Mat result(*this); Mat result(*this);
result *= f; result *= f;
return result; return result;
} }
OMATH_API constexpr Mat& operator/=(const Type& f) noexcept constexpr Mat& operator/=(const Type& f) noexcept
{ {
for (size_t i = 0; i < Rows; ++i) for (size_t i = 0; i < Rows; ++i)
for (size_t j = 0; j < Columns; ++j) for (size_t j = 0; j < Columns; ++j)
@@ -186,14 +185,14 @@ namespace omath
return *this; return *this;
} }
OMATH_API constexpr Mat operator/(const Type& f) const noexcept constexpr Mat operator/(const Type& f) const noexcept
{ {
Mat result(*this); Mat result(*this);
result /= f; result /= f;
return result; return result;
} }
OMATH_API constexpr Mat& operator=(const Mat& other) noexcept constexpr Mat& operator=(const Mat& other) noexcept
{ {
if (this == &other) if (this == &other)
return *this; return *this;
@@ -203,7 +202,7 @@ namespace omath
return *this; return *this;
} }
OMATH_API constexpr Mat& operator=(Mat&& other) noexcept constexpr Mat& operator=(Mat&& other) noexcept
{ {
if (this == &other) if (this == &other)
return *this; return *this;
@@ -216,7 +215,7 @@ namespace omath
} }
[[nodiscard]] [[nodiscard]]
OMATH_API constexpr Mat<Columns, Rows, Type, StoreType> Transposed() const noexcept constexpr Mat<Columns, Rows, Type, StoreType> Transposed() const noexcept
{ {
Mat<Columns, Rows, Type, StoreType> transposed; Mat<Columns, Rows, Type, StoreType> transposed;
for (size_t i = 0; i < Rows; ++i) for (size_t i = 0; i < Rows; ++i)
@@ -227,7 +226,7 @@ namespace omath
} }
[[nodiscard]] [[nodiscard]]
OMATH_API constexpr Type Determinant() const constexpr Type Determinant() const
{ {
static_assert(Rows == Columns, "Determinant is only defined for square matrices."); static_assert(Rows == Columns, "Determinant is only defined for square matrices.");
@@ -249,7 +248,7 @@ namespace omath
} }
[[nodiscard]] [[nodiscard]]
OMATH_API constexpr Mat<Rows - 1, Columns - 1, Type, StoreType> Minor(const size_t row, const size_t column) const 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; Mat<Rows - 1, Columns - 1, Type, StoreType> result;
for (size_t i = 0, m = 0; i < Rows; ++i) for (size_t i = 0, m = 0; i < Rows; ++i)
@@ -269,19 +268,19 @@ namespace omath
} }
[[nodiscard]] [[nodiscard]]
OMATH_API constexpr const std::array<Type, Rows * Columns>& RawArray() const constexpr const std::array<Type, Rows * Columns>& RawArray() const
{ {
return m_data; return m_data;
} }
[[nodiscard]] [[nodiscard]]
OMATH_API constexpr std::array<Type, Rows * Columns>& RawArray() constexpr std::array<Type, Rows * Columns>& RawArray()
{ {
return const_cast<std::array<Type, Rows * Columns>>(std::as_const(*this).RawArray()); return const_cast<std::array<Type, Rows * Columns>>(std::as_const(*this).RawArray());
} }
[[nodiscard]] [[nodiscard]]
OMATH_API std::string ToString() const noexcept std::string ToString() const noexcept
{ {
std::ostringstream oss; std::ostringstream oss;
for (size_t i = 0; i < Rows; ++i) for (size_t i = 0; i < Rows; ++i)
@@ -298,20 +297,20 @@ namespace omath
} }
[[nodiscard]] [[nodiscard]]
OMATH_API bool operator==(const Mat& mat) const bool operator==(const Mat& mat) const
{ {
return m_data == mat.m_data; return m_data == mat.m_data;
} }
[[nodiscard]] [[nodiscard]]
OMATH_API bool operator!=(const Mat& mat) const bool operator!=(const Mat& mat) const
{ {
return !operator==(mat); return !operator==(mat);
} }
// Static methods that return fixed-size matrices // Static methods that return fixed-size matrices
[[nodiscard]] [[nodiscard]]
OMATH_API constexpr static Mat<4, 4> ToScreenMat(const Type& screenWidth, const Type& screenHeight) noexcept constexpr static Mat<4, 4> ToScreenMat(const Type& screenWidth, const Type& screenHeight) noexcept
{ {
return { return {
{screenWidth / 2, 0, 0, 0}, {screenWidth / 2, 0, 0, 0},
@@ -341,7 +340,7 @@ namespace omath
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
[[nodiscard]] [[nodiscard]]
OMATH_API constexpr Mat<4, 4, Type, St> MatTranslation(const Vector3& diff) noexcept constexpr Mat<4, 4, Type, St> MatTranslation(const Vector3& diff) noexcept
{ {
return return
{ {
@@ -354,7 +353,7 @@ namespace omath
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle> template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
[[nodiscard]] [[nodiscard]]
OMATH_API Mat<4, 4, Type, St> MatRotationAxisX(const Angle& angle) noexcept Mat<4, 4, Type, St> MatRotationAxisX(const Angle& angle) noexcept
{ {
return return
{ {
@@ -367,7 +366,7 @@ namespace omath
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle> template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
[[nodiscard]] [[nodiscard]]
OMATH_API Mat<4, 4, Type, St> MatRotationAxisY(const Angle& angle) noexcept Mat<4, 4, Type, St> MatRotationAxisY(const Angle& angle) noexcept
{ {
return return
{ {
@@ -380,7 +379,7 @@ namespace omath
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle> template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
[[nodiscard]] [[nodiscard]]
OMATH_API Mat<4, 4, Type, St> MatRotationAxisZ(const Angle& angle) noexcept Mat<4, 4, Type, St> MatRotationAxisZ(const Angle& angle) noexcept
{ {
return return
{ {
@@ -408,7 +407,7 @@ namespace omath
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class ViewAngles> template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class ViewAngles>
[[nodiscard]] [[nodiscard]]
OMATH_API Mat<4, 4, Type, St> MatRotation(const ViewAngles& angles) noexcept Mat<4, 4, Type, St> MatRotation(const ViewAngles& angles) noexcept
{ {
return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll); return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll);
} }

73
include/omath/Matrix.hpp
View File

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

3
include/omath/Triangle3d.hpp
View File

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

3
include/omath/Vector2.hpp
View File

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

3
include/omath/Vector3.hpp
View File

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

3
include/omath/Vector4.hpp
View File

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

4
include/omath/ViewAngles.hpp
View File

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

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

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

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

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

24
include/omath/omath_export.hpp
View File

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

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

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

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

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

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

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

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

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

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

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

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

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