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

fix

Browse Source
This commit is contained in:
さくらみこ
2024-12-17 12:08:18 +03:00
parent 58fb6a0304
commit fc164b339b
3 changed files with 78 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
include/omath/Mat.hpp
View File

@@ -25,18 +25,18 @@ namespace omath
template<size_t Rows = 0, size_t Columns = 0, class Type = float, MatStoreType StoreType = MatStoreType::ROW_MAJOR> template<size_t Rows = 0, size_t Columns = 0, class Type = float, MatStoreType StoreType = MatStoreType::ROW_MAJOR>
requires std::is_arithmetic_v<Type> requires std::is_arithmetic_v<Type>
class OMATH_API Mat final class Mat final
{ {
public: public:
constexpr Mat() OMATH_API constexpr Mat()
{ {
Clear(); Clear();
} }
constexpr static MatStoreType GetStoreOrdering() OMATH_API constexpr static MatStoreType GetStoreOrdering()
{ {
return StoreType; 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) 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,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()); 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; m_data = other.m_data;
} }
constexpr Mat(Mat&& other) noexcept OMATH_API constexpr Mat(Mat&& other) noexcept
{ {
m_data = std::move(other.m_data); m_data = std::move(other.m_data);
} }
[[nodiscard]] [[nodiscard]]
static constexpr size_t RowCount() noexcept OMATH_API static constexpr size_t RowCount() noexcept
{ {
return Rows; return Rows;
} }
[[nodiscard]] [[nodiscard]]
static constexpr size_t ColumnsCount() noexcept OMATH_API static constexpr size_t ColumnsCount() noexcept
{ {
return Columns; return Columns;
} }
[[nodiscard]] [[nodiscard]]
static consteval MatSize Size() noexcept OMATH_API static consteval MatSize Size() noexcept
{ {
return {Rows, Columns}; 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) if (rowIndex >= Rows || columnIndex >= Columns)
throw std::out_of_range("Index out of range"); 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)); return const_cast<Type&>(std::as_const(*this).At(rowIndex, columnIndex));
} }
[[nodiscard]] [[nodiscard]]
constexpr Type Sum() const noexcept OMATH_API 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)
@@ -123,12 +123,12 @@ namespace omath
return sum; return sum;
} }
constexpr void Clear() noexcept OMATH_API constexpr void Clear() noexcept
{ {
Set(0); Set(0);
} }
constexpr void Set(const Type& value) noexcept OMATH_API constexpr void Set(const Type& value) noexcept
{ {
std::ranges::fill(m_data, value); std::ranges::fill(m_data, value);
} }
@@ -136,7 +136,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>
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; Mat<Rows, OtherColumns, Type, StoreType> result;
@@ -151,7 +151,7 @@ namespace omath
return result; 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 i = 0; i < Rows; ++i)
for (size_t j = 0; j < Columns; ++j) for (size_t j = 0; j < Columns; ++j)
@@ -161,19 +161,19 @@ namespace omath
template<size_t OtherColumns> template<size_t OtherColumns>
constexpr Mat<Rows, OtherColumns, Type, StoreType> 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; 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); Mat result(*this);
result *= f; result *= f;
return result; 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 i = 0; i < Rows; ++i)
for (size_t j = 0; j < Columns; ++j) for (size_t j = 0; j < Columns; ++j)
@@ -181,14 +181,14 @@ namespace omath
return *this; return *this;
} }
constexpr Mat operator/(const Type& f) const noexcept OMATH_API constexpr Mat operator/(const Type& f) const noexcept
{ {
Mat result(*this); Mat result(*this);
result /= f; result /= f;
return result; return result;
} }
constexpr Mat& operator=(const Mat& other) noexcept OMATH_API constexpr Mat& operator=(const Mat& other) noexcept
{ {
if (this == &other) if (this == &other)
return *this; return *this;
@@ -198,7 +198,7 @@ namespace omath
return *this; return *this;
} }
constexpr Mat& operator=(Mat&& other) noexcept OMATH_API constexpr Mat& operator=(Mat&& other) noexcept
{ {
if (this == &other) if (this == &other)
return *this; return *this;
@@ -211,7 +211,7 @@ namespace omath
} }
[[nodiscard]] [[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; Mat<Columns, Rows, Type, StoreType> transposed;
for (size_t i = 0; i < Rows; ++i) for (size_t i = 0; i < Rows; ++i)
@@ -222,7 +222,7 @@ namespace omath
} }
[[nodiscard]] [[nodiscard]]
constexpr Type Determinant() const OMATH_API 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.");
@@ -244,7 +244,7 @@ namespace omath
} }
[[nodiscard]] [[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; 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)
@@ -264,19 +264,19 @@ namespace omath
} }
[[nodiscard]] [[nodiscard]]
constexpr const std::array<Type, Rows * Columns>& RawArray() const OMATH_API constexpr const std::array<Type, Rows * Columns>& RawArray() const
{ {
return m_data; return m_data;
} }
[[nodiscard]] [[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()); return const_cast<std::array<Type, Rows * Columns>>(std::as_const(*this).RawArray());
} }
[[nodiscard]] [[nodiscard]]
std::string ToString() const noexcept OMATH_API 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)
@@ -293,20 +293,20 @@ namespace omath
} }
[[nodiscard]] [[nodiscard]]
bool operator==(const Mat& mat) const OMATH_API bool operator==(const Mat& mat) const
{ {
return m_data == mat.m_data; return m_data == mat.m_data;
} }
[[nodiscard]] [[nodiscard]]
bool operator!=(const Mat& mat) const OMATH_API 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]]
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 { return {
{screenWidth / 2, 0, 0, 0}, {screenWidth / 2, 0, 0, 0},
@@ -336,7 +336,7 @@ namespace omath
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
[[nodiscard]] [[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 return
{ {
@@ -349,7 +349,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]]
Mat<4, 4, Type, St> MatRotationAxisX(const Angle& angle) noexcept OMATH_API Mat<4, 4, Type, St> MatRotationAxisX(const Angle& angle) noexcept
{ {
return return
{ {
@@ -362,7 +362,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]]
Mat<4, 4, Type, St> MatRotationAxisY(const Angle& angle) noexcept OMATH_API Mat<4, 4, Type, St> MatRotationAxisY(const Angle& angle) noexcept
{ {
return return
{ {
@@ -375,7 +375,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]]
Mat<4, 4, Type, St> MatRotationAxisZ(const Angle& angle) noexcept OMATH_API Mat<4, 4, Type, St> MatRotationAxisZ(const Angle& angle) noexcept
{ {
return return
{ {
@@ -403,7 +403,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]]
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); return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll);
} }

72
include/omath/Matrix.hpp
View File

@@ -8,94 +8,94 @@ namespace omath
{ {
class Vector3; class Vector3;
class OMATH_API Matrix final class Matrix final
{ {
public: public:
Matrix(); OMATH_API Matrix();
Matrix(size_t rows, size_t columns); 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]] [[nodiscard]]
static Matrix ToScreenMatrix(float screenWidth, float screenHeight); OMATH_API static Matrix ToScreenMatrix(float screenWidth, float screenHeight);
[[nodiscard]] [[nodiscard]]
static Matrix TranslationMatrix(const Vector3& diff); OMATH_API static Matrix TranslationMatrix(const Vector3& diff);
[[nodiscard]] [[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]] [[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]] [[nodiscard]]
size_t RowCount() const noexcept; OMATH_API size_t RowCount() const noexcept;
[[nodiscard]] [[nodiscard]]
size_t ColumnsCount() const noexcept; OMATH_API size_t ColumnsCount() const noexcept;
[[nodiscard]] [[nodiscard]]
std::pair<size_t, size_t> Size() const noexcept; OMATH_API std::pair<size_t, size_t> Size() const noexcept;
[[nodiscard]] [[nodiscard]]
float& At(size_t iRow, size_t iCol); OMATH_API float& At(size_t iRow, size_t iCol);
[[nodiscard]] [[nodiscard]]
float Sum(); OMATH_API float Sum();
void SetDataFromRaw(const float* pRawMatrix); OMATH_API void SetDataFromRaw(const float* pRawMatrix);
[[nodiscard]] [[nodiscard]]
Matrix Transpose() const; OMATH_API Matrix Transpose() const;
void Set(float val); OMATH_API void Set(float val);
[[nodiscard]] [[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]] [[nodiscard]]
Matrix Strip(size_t row, size_t column) const; OMATH_API Matrix Strip(size_t row, size_t column) const;
[[nodiscard]] [[nodiscard]]
float Minor(size_t i, size_t j) const; OMATH_API float Minor(size_t i, size_t j) const;
[[nodiscard]] [[nodiscard]]
float AlgComplement(size_t i, size_t j) const; OMATH_API float AlgComplement(size_t i, size_t j) const;
[[nodiscard]] [[nodiscard]]
float Determinant() const; OMATH_API float Determinant() const;
[[nodiscard]] [[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]] [[nodiscard]]
std::string ToString() const; OMATH_API std::string ToString() const;
~Matrix(); OMATH_API ~Matrix();
private: private:
size_t m_rows; size_t m_rows;

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

@@ -18,21 +18,21 @@ namespace omath::pathfinding
}; };
class OMATH_API NavigationMesh final class NavigationMesh final
{ {
public: public:
[[nodiscard]] [[nodiscard]]
std::expected<Vector3, std::string> GetClosestVertex(const Vector3& point) const; OMATH_API std::expected<Vector3, std::string> GetClosestVertex(const Vector3& point) const;
[[nodiscard]] [[nodiscard]]
const std::vector<Vector3>& GetNeighbors(const Vector3& vertex) const; OMATH_API const std::vector<Vector3>& GetNeighbors(const Vector3& vertex) const;
[[nodiscard]] [[nodiscard]]
bool Empty() const; OMATH_API bool Empty() const;
[[nodiscard]] std::vector<uint8_t> Serialize() 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; std::unordered_map<Vector3, std::vector<Vector3>> m_verTextMap;
}; };