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 #42 from orange-cpp/feature/new-codestyle

Browse Source 
Feature/new codestyle
This commit is contained in:
Orange++
2025-05-03 20:59:06 +03:00
committed by GitHub
parent b06fd00673 dd738f365d
commit 31d3359507
70 changed files with 1326 additions and 1375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
.clang-format
View File

@@ -1,62 +1,64 @@
# Generated from CLion C/C++ Code Style settings
---
Language: Cpp
# Generated by CLion for Stroustrup
# The Stroustrup style, named after Bjarne Stroustrup, the creator of C++, is similar to the K&R style but differs
# in its treatment of the class definitions and the placement of braces in certain contexts. The opening brace is
# placed on the same line as the control statement, and the closing brace is on its own line.
BasedOnStyle: LLVM
AccessModifierOffset: -4
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignOperands: true
AlignConsecutiveAssignments: None
AlignConsecutiveBitFields: None
AlignConsecutiveDeclarations: None
AlignConsecutiveMacros: AcrossEmptyLinesAndComments
AlignTrailingComments: false
AllowShortBlocksOnASingleLine: false
AllowShortBlocksOnASingleLine: Never
AllowShortFunctionsOnASingleLine: None
AlwaysBreakTemplateDeclarations: Yes
BraceWrapping:
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
BreakTemplateDeclarations: Leave
BreakBeforeBraces: Custom
BraceWrapping:
AfterCaseLabel: true
AfterClass: true
AfterControlStatement: true
AfterEnum: true
AfterFunction: true
AfterControlStatement: true
SplitEmptyFunction: true
AfterEnum: true
AfterNamespace: true
AfterStruct: true
AfterUnion: true
AfterExternBlock: true
BeforeCatch: false
BeforeElse: false
BeforeCatch: true
BeforeElse: true
BeforeLambdaBody: true
BeforeWhile: false
IndentBraces: false
SplitEmptyFunction: true
BeforeWhile: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBraces: Custom
BreakConstructorInitializers: AfterColon
BreakConstructorInitializersBeforeComma: false
BreakBeforeBinaryOperators: All
BreakBeforeConceptDeclarations: false
ColumnLimit: 120
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ContinuationIndentWidth: 8
IncludeCategories:
- Regex: '^<.*'
Priority: 1
- Regex: '^".*'
Priority: 2
- Regex: '.*'
Priority: 3
IncludeIsMainRegex: '([-_](test|unittest))?$'
IndentCaseLabels: true
IncludeBlocks: Merge
IndentExternBlock: Indent
IndentRequiresClause: false
IndentWidth: 4
InsertNewlineAtEOF: true
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 2
ContinuationIndentWidth: 8
KeepEmptyLinesAtTheStartOfBlocks: false
NamespaceIndentation: All
PointerAlignment: Left
SpaceAfterCStyleCast: true
SortUsingDeclarations: true
SpaceAfterTemplateKeyword: false
SpaceBeforeCtorInitializerColon: false
SpaceBeforeParens: Custom
SpaceBeforeParensOptions:
AfterControlStatements: true
AfterFunctionDeclarationName: false
AfterFunctionDefinitionName: false
AfterForeachMacros: true
AfterIfMacros: true
AfterOverloadedOperator: false
BeforeNonEmptyParentheses: false
SpaceBeforeRangeBasedForLoopColon: false
SpaceInEmptyParentheses: false
SpacesInAngles: false
SpacesInConditionalStatement: false
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
TabWidth: 4
...
SpacesInConditionalStatement: false
SpacesInContainerLiterals: false
SpacesInParentheses: false

4
include/omath/3d_primitives/box.hpp
View File

@@ -11,7 +11,7 @@
namespace omath::primitives
{
[[nodiscard]]
std::array<Triangle<Vector3<float>>, 12> CreateBox(const Vector3<float>& top, const Vector3<float>& bottom,
const Vector3<float>& dirForward, const Vector3<float>& dirRight,
std::array<Triangle<Vector3<float>>, 12> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
const Vector3<float>& dir_forward, const Vector3<float>& dir_right,
float ratio = 4.f);
}

48
include/omath/angle.hpp
View File

@@ -3,10 +3,9 @@
//
#pragma once
#include "omath/angles.hpp"
#include <algorithm>
#include <utility>
#include "omath/angles.hpp"
namespace omath
{
@@ -17,14 +16,14 @@ namespace omath
};
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 Angle
{
Type m_angle;
constexpr explicit Angle(const Type& degrees)
{
if constexpr (flags == AngleFlags::Normalized)
m_angle = angles::WrapAngle(degrees, min, max);
m_angle = angles::wrap_angle(degrees, min, max);
else if constexpr (flags == AngleFlags::Clamped)
m_angle = std::clamp(degrees, min, max);
@@ -37,17 +36,17 @@ namespace omath
public:
[[nodiscard]]
constexpr static Angle FromDegrees(const Type& degrees)
constexpr static Angle from_degrees(const Type& degrees)
{
return Angle{degrees};
}
constexpr Angle() : m_angle(0)
constexpr Angle(): m_angle(0)
{
}
[[nodiscard]]
constexpr static Angle FromRadians(const Type& degrees)
constexpr static Angle from_radians(const Type& degrees)
{
return Angle{angles::RadiansToDegrees<Type>(degrees)};
return Angle{angles::radians_to_degrees<Type>(degrees)};
}
[[nodiscard]]
@@ -57,51 +56,51 @@ namespace omath
}
[[nodiscard]]
constexpr Type AsDegrees() const
constexpr Type as_degrees() const
{
return m_angle;
}
[[nodiscard]]
constexpr Type AsRadians() const
constexpr Type as_radians() const
{
return angles::DegreesToRadians(m_angle);
return angles::degrees_to_radians(m_angle);
}
[[nodiscard]]
Type Sin() const
Type sin() const
{
return std::sin(AsRadians());
return std::sin(as_radians());
}
[[nodiscard]]
Type Cos() const
Type cos() const
{
return std::cos(AsRadians());
return std::cos(as_radians());
}
[[nodiscard]]
Type Tan() const
Type tan() const
{
return std::tan(AsRadians());
return std::tan(as_radians());
}
[[nodiscard]]
Type Atan() const
Type atan() const
{
return std::atan(AsRadians());
return std::atan(as_radians());
}
[[nodiscard]]
Type Cot() const
Type cot() const
{
return Cos() / Sin();
return cos() / sin();
}
constexpr Angle& operator+=(const Angle& other)
{
if constexpr (flags == AngleFlags::Normalized)
m_angle = angles::WrapAngle(m_angle + other.m_angle, min, max);
m_angle = angles::wrap_angle(m_angle + other.m_angle, min, max);
else if constexpr (flags == AngleFlags::Clamped)
m_angle = std::clamp(m_angle + other.m_angle, min, max);
@@ -115,7 +114,8 @@ namespace omath
}
[[nodiscard]]
constexpr std::partial_ordering operator<=>(const Angle& other) const = default;
constexpr std::partial_ordering operator<=>(const Angle& other) const
= default;
constexpr Angle& operator-=(const Angle& other)
{
@@ -126,7 +126,7 @@ namespace omath
constexpr Angle& operator+(const Angle& other)
{
if constexpr (flags == AngleFlags::Normalized)
return {angles::WrapAngle(m_angle + other.m_angle, min, max)};
return {angles::wrap_angle(m_angle + other.m_angle, min, max)};
else if constexpr (flags == AngleFlags::Clamped)
return {std::clamp(m_angle + other.m_angle, min, max)};

51
include/omath/angles.hpp
View File

@@ -10,54 +10,55 @@ namespace omath::angles
{
template<class Type>
requires std::is_floating_point_v<Type>
[[nodiscard]] constexpr Type RadiansToDegrees(const Type& radians)
[[nodiscard]] constexpr Type radians_to_degrees(const Type& radians)
{
return radians * (Type(180) / std::numbers::pi_v<Type>);
return radians * (static_cast<Type>(180) / std::numbers::pi_v<Type>);
}
template<class Type>
requires std::is_floating_point_v<Type>
[[nodiscard]] constexpr Type DegreesToRadians(const Type& degrees)
[[nodiscard]] constexpr Type degrees_to_radians(const Type& degrees)
{
return degrees * (std::numbers::pi_v<Type> / Type(180));
}
template<class type>
requires std::is_floating_point_v<type>
[[nodiscard]] type HorizontalFovToVertical(const type& horFov, const type& aspect)
{
const auto fovRad = DegreesToRadians(horFov);
const auto vertFov = type(2) * std::atan(std::tan(fovRad / type(2)) / aspect);
return RadiansToDegrees(vertFov);
return degrees * (std::numbers::pi_v<Type> / static_cast<Type>(180));
}
template<class Type>
requires std::is_floating_point_v<Type>
[[nodiscard]] Type VerticalFovToHorizontal(const Type& vertFov, const Type& aspect)
[[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect)
{
const auto fovRad = DegreesToRadians(vertFov);
const auto fov_rad = degrees_to_radians(horizontal_fov);
const auto horFov = Type(2) * std::atan(std::tan(fovRad / Type(2)) * aspect);
const auto vert_fov = static_cast<Type>(2) * std::atan(std::tan(fov_rad / static_cast<Type>(2)) / aspect);
return RadiansToDegrees(horFov);
return radians_to_degrees(vert_fov);
}
template<class Type>
requires std::is_floating_point_v<Type>
[[nodiscard]] Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect)
{
const auto fov_as_radians = degrees_to_radians(vertical_fov);
const auto horizontal_fov
= static_cast<Type>(2) * std::atan(std::tan(fov_as_radians / static_cast<Type>(2)) * aspect);
return radians_to_degrees(horizontal_fov);
}
template<class Type>
requires std::is_arithmetic_v<Type>
[[nodiscard]] Type WrapAngle(const Type& angle, const Type& min, const Type& max)
[[nodiscard]] Type wrap_angle(const Type& angle, const Type& min, const Type& max)
{
if (angle <= max && angle >= min)
return angle;
const Type range = max - min;
Type wrappedAngle = std::fmod(angle - min, range);
Type wrapped_angle = std::fmod(angle - min, range);
if (wrappedAngle < 0)
wrappedAngle += range;
if (wrapped_angle < 0)
wrapped_angle += range;
return wrappedAngle + min;
return wrapped_angle + min;
}
}
} // namespace omath::angles

15
include/omath/collision/line_tracer.hpp
View File

@@ -14,25 +14,24 @@ namespace omath::collision
Vector3<float> start;
Vector3<float> end;
bool infinite_length = false;
[[nodiscard]]
Vector3<float> DirectionVector() const;
[[nodiscard]]
Vector3<float> DirectionVectorNormalized() const;
Vector3<float> direction_vector() const;
[[nodiscard]]
Vector3<float> direction_vector_normalized() const;
};
class LineTracer
{
public:
LineTracer() = delete;
[[nodiscard]]
static bool CanTraceLine(const Ray& ray, const Triangle<Vector3<float>>& triangle);
static bool can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle);
// Realization of Möller–Trumbore intersection algorithm
// https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
[[nodiscard]]
static Vector3<float> GetRayHitPoint(const Ray& ray, const Triangle<Vector3<float>>& triangle);
static Vector3<float> get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle);
};
}
} // namespace omath::collision

115
include/omath/color.hpp
View File

@@ -4,95 +4,93 @@
#pragma once
#include <cstdint>
#include "omath/vector3.hpp"
#include "omath/vector4.hpp"
#include <cstdint>
#ifdef max
#undef max
#endif
#ifdef min
#undef min
#endif
namespace omath
{
struct HSV
struct Hsv
{
float hue{};
float saturation{};
float value{};
};
class Color final : public Vector4<float>
{
public:
constexpr Color(const float r, const float g, const float b, const float a) : Vector4(r, g, b, a)
constexpr Color(const float r, const float g, const float b, const float a): Vector4(r, g, b, a)
{
Clamp(0.f, 1.f);
clamp(0.f, 1.f);
}
constexpr explicit Color() = default;
[[nodiscard]]
constexpr static Color FromRGBA(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a)
constexpr static Color from_rgba(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a)
{
return Color{Vector4(r, g, b, a) / 255.f};
}
[[nodiscard]]
constexpr static Color FromHSV(float hue, const float saturation, const float value)
constexpr static Color from_hsv(float hue, const float saturation, const float value)
{
float r{}, g{}, b{};
hue = std::clamp(hue, 0.f, 1.f);
const int i = static_cast<int>(hue * 6.f);
const float f = hue * 6 - i;
const float f = hue * 6.f - static_cast<float>(i);
const float p = value * (1 - saturation);
const float q = value * (1 - f * saturation);
const float t = value * (1 - (1 - f) * saturation);
switch (i % 6)
{
case 0:
r = value, g = t, b = p;
break;
case 1:
r = q, g = value, b = p;
break;
case 2:
r = p, g = value, b = t;
break;
case 3:
r = p, g = q, b = value;
break;
case 4:
r = t, g = p, b = value;
break;
case 5:
r = value, g = p, b = q;
break;
case 0:
r = value, g = t, b = p;
break;
case 1:
r = q, g = value, b = p;
break;
case 2:
r = p, g = value, b = t;
break;
case 3:
r = p, g = q, b = value;
break;
case 4:
r = t, g = p, b = value;
break;
case 5:
r = value, g = p, b = q;
break;
default:
return {0.f, 0.f, 0.f, 0.f};
default:
return {0.f, 0.f, 0.f, 0.f};
}
return {r, g, b, 1.f};
}
[[nodiscard]]
constexpr static Color FromHSV(const HSV& hsv)
constexpr static Color from_hsv(const Hsv& hsv)
{
return FromHSV(hsv.hue, hsv.saturation, hsv.value);
return from_hsv(hsv.hue, hsv.saturation, hsv.value);
}
[[nodiscard]]
constexpr HSV ToHSV() const
constexpr Hsv to_hsv() const
{
HSV hsvData;
Hsv hsv_data;
const float& red = x;
const float& green = y;
@@ -102,70 +100,69 @@ namespace omath
const float min = std::min({red, green, blue});
const float delta = max - min;
if (delta == 0.f)
hsvData.hue = 0.f;
hsv_data.hue = 0.f;
else if (max == red)
hsvData.hue = 60.f * (std::fmodf(((green - blue) / delta), 6.f));
hsv_data.hue = 60.f * (std::fmodf(((green - blue) / delta), 6.f));
else if (max == green)
hsvData.hue = 60.f * (((blue - red) / delta) + 2.f);
hsv_data.hue = 60.f * (((blue - red) / delta) + 2.f);
else if (max == blue)
hsvData.hue = 60.f * (((red - green) / delta) + 4.f);
hsv_data.hue = 60.f * (((red - green) / delta) + 4.f);
if (hsvData.hue < 0.f)
hsvData.hue += 360.f;
if (hsv_data.hue < 0.f)
hsv_data.hue += 360.f;
hsvData.hue /= 360.f;
hsvData.saturation = max == 0.f ? 0.f : delta / max;
hsvData.value = max;
hsv_data.hue /= 360.f;
hsv_data.saturation = max == 0.f ? 0.f : delta / max;
hsv_data.value = max;
return hsvData;
return hsv_data;
}
constexpr explicit Color(const Vector4& vec) : Vector4(vec)
constexpr explicit Color(const Vector4& vec): Vector4(vec)
{
Clamp(0.f, 1.f);
clamp(0.f, 1.f);
}
constexpr void SetHue(const float hue)
constexpr void set_hue(const float hue)
{
auto hsv = ToHSV();
auto hsv = to_hsv();
hsv.hue = hue;
*this = FromHSV(hsv);
*this = from_hsv(hsv);
}
constexpr void SetSaturation(const float saturation)
constexpr void set_saturation(const float saturation)
{
auto hsv = ToHSV();
auto hsv = to_hsv();
hsv.saturation = saturation;
*this = FromHSV(hsv);
*this = from_hsv(hsv);
}
constexpr void SetValue(const float value)
constexpr void set_value(const float value)
{
auto hsv = ToHSV();
auto hsv = to_hsv();
hsv.value = value;
*this = FromHSV(hsv);
*this = from_hsv(hsv);
}
[[nodiscard]]
constexpr Color Blend(const Color& other, float ratio) const
constexpr Color blend(const Color& other, float ratio) const
{
ratio = std::clamp(ratio, 0.f, 1.f);
return Color(*this * (1.f - ratio) + other * ratio);
}
[[nodiscard]] static constexpr Color Red()
[[nodiscard]] static constexpr Color red()
{
return {1.f, 0.f, 0.f, 1.f};
}
[[nodiscard]] static constexpr Color Green()
[[nodiscard]] static constexpr Color green()
{
return {0.f, 1.f, 0.f, 1.f};
}
[[nodiscard]] static constexpr Color Blue()
[[nodiscard]] static constexpr Color blue()
{
return {0.f, 0.f, 1.f, 1.f};
}

13
include/omath/engines/iw_engine/camera.hpp
View File

@@ -8,14 +8,15 @@
namespace omath::iw_engine
{
class Camera final : public projection::Camera<Mat4x4, ViewAngles>
class Camera final : public projection::Camera<Mat4X4, ViewAngles>
{
public:
Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
void LookAt(const Vector3<float>& target) override;
void look_at(const Vector3<float>& target) override;
protected:
[[nodiscard]] Mat4x4 CalcViewMatrix() const override;
[[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
[[nodiscard]] Mat4X4 calc_view_matrix() const override;
[[nodiscard]] Mat4X4 calc_projection_matrix() const override;
};
}
} // namespace omath::iw_engine

18
include/omath/engines/iw_engine/constants.hpp
View File

@@ -3,23 +3,23 @@
//
#pragma once
#include <omath/vector3.hpp>
#include <omath/mat.hpp>
#include <omath/angle.hpp>
#include <omath/mat.hpp>
#include <omath/vector3.hpp>
#include <omath/view_angles.hpp>
namespace omath::iw_engine
{
constexpr Vector3<float> kAbsUp = {0, 0, 1};
constexpr Vector3<float> kAbsRight = {0, -1, 0};
constexpr Vector3<float> kAbsForward = {1, 0, 0};
constexpr Vector3<float> k_abs_up = {0, 0, 1};
constexpr Vector3<float> k_abs_right = {0, -1, 0};
constexpr Vector3<float> k_abs_forward = {1, 0, 0};
using Mat4x4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
using Mat3x3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
using Mat1x3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
using Mat4X4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
using Mat3X3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
using Mat1X3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
using PitchAngle = Angle<float, -89.f, 89.f, AngleFlags::Clamped>;
using YawAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
}
} // namespace omath::iw_engine

12
include/omath/engines/iw_engine/formulas.hpp
View File

@@ -8,19 +8,19 @@
namespace omath::iw_engine
{
[[nodiscard]]
Vector3<float> ForwardVector(const ViewAngles& angles);
Vector3<float> forward_vector(const ViewAngles& angles);
[[nodiscard]]
Vector3<float> RightVector(const ViewAngles& angles);
Vector3<float> right_vector(const ViewAngles& angles);
[[nodiscard]]
Vector3<float> UpVector(const ViewAngles& angles);
Vector3<float> up_vector(const ViewAngles& angles);
[[nodiscard]]
Mat4x4 RotationMatrix(const ViewAngles& angles);
Mat4X4 rotation_matrix(const ViewAngles& angles);
[[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
[[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
[[nodiscard]]
Mat4x4 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
} // namespace omath::iw_engine

12
include/omath/engines/opengl_engine/camera.hpp
View File

@@ -7,13 +7,13 @@
namespace omath::opengl_engine
{
class Camera final : public projection::Camera<Mat4x4, ViewAngles>
class Camera final : public projection::Camera<Mat4X4, ViewAngles>
{
public:
Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
void LookAt(const Vector3<float>& target) override;
[[nodiscard]] Mat4x4 CalcViewMatrix() const override;
[[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
void look_at(const Vector3<float>& target) override;
[[nodiscard]] Mat4X4 calc_view_matrix() const override;
[[nodiscard]] Mat4X4 calc_projection_matrix() const override;
};
}
} // namespace omath::opengl_engine

15
include/omath/engines/opengl_engine/constants.hpp
View File

@@ -10,17 +10,16 @@
namespace omath::opengl_engine
{
constexpr Vector3<float> kAbsUp = {0, 1, 0};
constexpr Vector3<float> kAbsRight = {1, 0, 0};
constexpr Vector3<float> kAbsForward = {0, 0, -1};
constexpr Vector3<float> k_abs_up = {0, 1, 0};
constexpr Vector3<float> k_abs_right = {1, 0, 0};
constexpr Vector3<float> k_abs_forward = {0, 0, -1};
using Mat4x4 = Mat<4, 4, float, MatStoreType::COLUMN_MAJOR>;
using Mat3x3 = Mat<4, 4, float, MatStoreType::COLUMN_MAJOR>;
using Mat1x3 = Mat<1, 3, float, MatStoreType::COLUMN_MAJOR>;
using Mat4X4 = Mat<4, 4, float, MatStoreType::COLUMN_MAJOR>;
using Mat3X3 = Mat<4, 4, float, MatStoreType::COLUMN_MAJOR>;
using Mat1X3 = Mat<1, 3, float, MatStoreType::COLUMN_MAJOR>;
using PitchAngle = Angle<float, -90.f, 90.f, AngleFlags::Clamped>;
using YawAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
}
} // namespace omath::opengl_engine

12
include/omath/engines/opengl_engine/formulas.hpp
View File

@@ -8,19 +8,19 @@
namespace omath::opengl_engine
{
[[nodiscard]]
Vector3<float> ForwardVector(const ViewAngles& angles);
Vector3<float> forward_vector(const ViewAngles& angles);
[[nodiscard]]
Vector3<float> RightVector(const ViewAngles& angles);
Vector3<float> right_vector(const ViewAngles& angles);
[[nodiscard]]
Vector3<float> UpVector(const ViewAngles& angles);
Vector3<float> up_vector(const ViewAngles& angles);
[[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
[[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
[[nodiscard]]
Mat4x4 RotationMatrix(const ViewAngles& angles);
Mat4X4 rotation_matrix(const ViewAngles& angles);
[[nodiscard]]
Mat4x4 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
} // namespace omath::opengl_engine

13
include/omath/engines/source_engine/camera.hpp
View File

@@ -7,14 +7,15 @@
namespace omath::source_engine
{
class Camera final : public projection::Camera<Mat4x4, ViewAngles>
class Camera final : public projection::Camera<Mat4X4, ViewAngles>
{
public:
Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
void LookAt(const Vector3<float>& target) override;
void look_at(const Vector3<float>& target) override;
protected:
[[nodiscard]] Mat4x4 CalcViewMatrix() const override;
[[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
[[nodiscard]] Mat4X4 calc_view_matrix() const override;
[[nodiscard]] Mat4X4 calc_projection_matrix() const override;
};
}
} // namespace omath::source_engine

18
include/omath/engines/source_engine/constants.hpp
View File

@@ -3,23 +3,23 @@
//
#pragma once
#include <omath/vector3.hpp>
#include <omath/mat.hpp>
#include <omath/angle.hpp>
#include <omath/mat.hpp>
#include <omath/vector3.hpp>
#include <omath/view_angles.hpp>
namespace omath::source_engine
{
constexpr Vector3<float> kAbsUp = {0, 0, 1};
constexpr Vector3<float> kAbsRight = {0, -1, 0};
constexpr Vector3<float> kAbsForward = {1, 0, 0};
constexpr Vector3<float> k_abs_up = {0, 0, 1};
constexpr Vector3<float> k_abs_right = {0, -1, 0};
constexpr Vector3<float> k_abs_forward = {1, 0, 0};
using Mat4x4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
using Mat3x3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
using Mat1x3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
using Mat4X4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
using Mat3X3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
using Mat1X3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
using PitchAngle = Angle<float, -89.f, 89.f, AngleFlags::Clamped>;
using YawAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
} // namespace omath::source
} // namespace omath::source_engine

14
include/omath/engines/source_engine/formulas.hpp
View File

@@ -7,19 +7,19 @@
namespace omath::source_engine
{
[[nodiscard]]
Vector3<float> ForwardVector(const ViewAngles& angles);
Vector3<float> forward_vector(const ViewAngles& angles);
[[nodiscard]]
Mat4x4 RotationMatrix(const ViewAngles& angles);
Mat4X4 rotation_matrix(const ViewAngles& angles);
[[nodiscard]]
Vector3<float> RightVector(const ViewAngles& angles);
Vector3<float> right_vector(const ViewAngles& angles);
[[nodiscard]]
Vector3<float> UpVector(const ViewAngles& angles);
Vector3<float> up_vector(const ViewAngles& angles);
[[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
[[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
[[nodiscard]]
Mat4x4 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
} // namespace omath::source
Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
} // namespace omath::source_engine

13
include/omath/engines/unity_engine/camera.hpp
View File

@@ -8,14 +8,15 @@
namespace omath::unity_engine
{
class Camera final : public projection::Camera<Mat4x4, ViewAngles>
class Camera final : public projection::Camera<Mat4X4, ViewAngles>
{
public:
Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
void LookAt(const Vector3<float>& target) override;
void look_at(const Vector3<float>& target) override;
protected:
[[nodiscard]] Mat4x4 CalcViewMatrix() const override;
[[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
[[nodiscard]] Mat4X4 calc_view_matrix() const override;
[[nodiscard]] Mat4X4 calc_projection_matrix() const override;
};
}
} // namespace omath::unity_engine

18
include/omath/engines/unity_engine/constants.hpp
View File

@@ -4,23 +4,23 @@
#pragma once
#include <omath/vector3.hpp>
#include <omath/mat.hpp>
#include <omath/angle.hpp>
#include <omath/mat.hpp>
#include <omath/vector3.hpp>
#include <omath/view_angles.hpp>
namespace omath::unity_engine
{
constexpr Vector3<float> kAbsUp = {0, 1, 0};
constexpr Vector3<float> kAbsRight = {1, 0, 0};
constexpr Vector3<float> kAbsForward = {0, 0, 1};
constexpr Vector3<float> k_abs_up = {0, 1, 0};
constexpr Vector3<float> k_abs_right = {1, 0, 0};
constexpr Vector3<float> k_abs_forward = {0, 0, 1};
using Mat4x4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
using Mat3x3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
using Mat1x3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
using Mat4X4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
using Mat3X3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
using Mat1X3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
using PitchAngle = Angle<float, -90.f, 90.f, AngleFlags::Clamped>;
using YawAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
} // namespace omath::source
} // namespace omath::unity_engine

14
include/omath/engines/unity_engine/formulas.hpp
View File

@@ -8,19 +8,19 @@
namespace omath::unity_engine
{
[[nodiscard]]
Vector3<float> ForwardVector(const ViewAngles& angles);
Vector3<float> forward_vector(const ViewAngles& angles);
[[nodiscard]]
Vector3<float> RightVector(const ViewAngles& angles);
Vector3<float> right_vector(const ViewAngles& angles);
[[nodiscard]]
Vector3<float> UpVector(const ViewAngles& angles);
Vector3<float> up_vector(const ViewAngles& angles);
[[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
[[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
[[nodiscard]]
Mat4x4 RotationMatrix(const ViewAngles& angles);
Mat4X4 rotation_matrix(const ViewAngles& angles);
[[nodiscard]]
Mat4x4 CalcPerspectiveProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
} // namespace omath::source
Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
} // namespace omath::unity_engine

192
include/omath/mat.hpp
View File

@@ -2,21 +2,19 @@
// Created by vlad on 9/29/2024.
//
#pragma once
#include "omath/vector3.hpp"
#include <algorithm>
#include <array>
#include <iomanip>
#include <numeric>
#include <sstream>
#include <stdexcept>
#include <utility>
#include "omath/vector3.hpp"
#include <numeric>
#ifdef near
#undef near
#endif
#ifdef far
#undef far
#endif
@@ -34,25 +32,22 @@ namespace omath
COLUMN_MAJOR
};
template<typename M1, typename M2>
concept MatTemplateEqual =
(M1::rows == M2::rows) && (M1::columns == M2::columns) &&
std::is_same_v<typename M1::value_type, typename M2::value_type> &&
(M1::store_type == M2::store_type);
template<typename M1, typename M2> concept MatTemplateEqual
= (M1::rows == M2::rows) && (M1::columns == M2::columns)
&& std::is_same_v<typename M1::value_type, typename M2::value_type> && (M1::store_type == M2::store_type);
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 Mat final
{
public:
constexpr Mat() noexcept
{
Clear();
clear();
}
[[nodiscard]]
constexpr static MatStoreType GetStoreOrdering() noexcept
constexpr static MatStoreType get_store_ordering() noexcept
{
return StoreType;
}
@@ -61,24 +56,24 @@ namespace omath
if (rows.size() != Rows)
throw std::invalid_argument("Initializer list rows size does not match template parameter Rows");
auto rowIt = rows.begin();
for (size_t i = 0; i < Rows; ++i, ++rowIt)
auto row_it = rows.begin();
for (size_t i = 0; i < Rows; ++i, ++row_it)
{
if (rowIt->size() != Columns)
if (row_it->size() != Columns)
throw std::invalid_argument(
"All rows must have the same number of columns as template parameter Columns");
auto colIt = rowIt->begin();
for (size_t j = 0; j < Columns; ++j, ++colIt)
auto col_it = row_it->begin();
for (size_t j = 0; j < Columns; ++j, ++col_it)
{
At(i, j) = std::move(*colIt);
at(i, j) = std::move(*col_it);
}
}
}
constexpr explicit Mat(const Type* rawData)
constexpr explicit Mat(const Type* raw_data)
{
std::copy_n(rawData, Rows * Columns, m_data.begin());
std::copy_n(raw_data, Rows * Columns, m_data.begin());
}
constexpr Mat(const Mat& other) noexcept
@@ -89,13 +84,13 @@ namespace omath
[[nodiscard]]
constexpr Type& operator[](const size_t row, const size_t col)
{
return At(row, col);
return at(row, col);
}
[[nodiscard]]
constexpr Type& operator[](const size_t row, const size_t col) const
{
return At(row, col);
return at(row, col);
}
constexpr Mat(Mat&& other) noexcept
@@ -104,35 +99,35 @@ namespace omath
}
[[nodiscard]]
static constexpr size_t RowCount() noexcept
static constexpr size_t row_count() noexcept
{
return Rows;
}
[[nodiscard]]
static constexpr size_t ColumnsCount() noexcept
static constexpr size_t columns_count() noexcept
{
return Columns;
}
[[nodiscard]]
static consteval MatSize Size() noexcept
static consteval MatSize size() noexcept
{
return {Rows, Columns};
}
[[nodiscard]]
constexpr const Type& At(const size_t rowIndex, const size_t columnIndex) const
constexpr const Type& at(const size_t row_index, const size_t column_index) const
{
#if !defined(NDEBUG) && defined(OMATH_SUPRESS_SAFETY_CHECKS)
if (rowIndex >= Rows || columnIndex >= Columns)
if (row_index >= Rows || column_index >= Columns)
throw std::out_of_range("Index out of range");
#endif
if constexpr (StoreType == MatStoreType::ROW_MAJOR)
return m_data[rowIndex * Columns + columnIndex];
return m_data[row_index * Columns + column_index];
else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
return m_data[rowIndex + columnIndex * Rows];
return m_data[row_index + column_index * Rows];
else
{
@@ -141,30 +136,29 @@ namespace omath
}
}
[[nodiscard]] constexpr Type& At(const size_t rowIndex, const size_t columnIndex)
[[nodiscard]] constexpr Type& at(const size_t row_index, const size_t column_index)
{
return const_cast<Type&>(std::as_const(*this).At(rowIndex, columnIndex));
return const_cast<Type&>(std::as_const(*this).at(row_index, column_index));
}
[[nodiscard]]
constexpr Type Sum() const noexcept
constexpr Type sum() const noexcept
{
return std::accumulate(m_data.begin(), m_data.end(), Type(0));
return std::accumulate(m_data.begin(), m_data.end(), static_cast<Type>(0));
}
constexpr void Clear() noexcept
constexpr void clear() noexcept
{
Set(0);
set(static_cast<Type>(0));
}
constexpr void Set(const Type& value) noexcept
constexpr void set(const Type& value) noexcept
{
std::ranges::fill(m_data, value);
}
// Operator overloading for multiplication with another Mat
template<size_t OtherColumns>
[[nodiscard]]
template<size_t OtherColumns> [[nodiscard]]
constexpr Mat<Rows, OtherColumns, Type, StoreType>
operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const
{
@@ -175,20 +169,19 @@ namespace omath
{
Type sum = 0;
for (size_t k = 0; k < Columns; ++k)
sum += At(i, k) * other.At(k, j);
result.At(i, j) = sum;
sum += at(i, k) * other.at(k, j);
result.at(i, j) = sum;
}
return result;
}
constexpr Mat& operator*=(const Type& f) noexcept
{
std::ranges::for_each(m_data, [&f](auto& val) {val *= f;});
std::ranges::for_each(m_data, [&f](auto& val) { val *= f; });
return *this;
}
template<size_t OtherColumns>
constexpr Mat<Rows, OtherColumns, Type, StoreType>
template<size_t OtherColumns> constexpr Mat<Rows, OtherColumns, Type, StoreType>
operator*=(const Mat<Columns, OtherColumns, Type, StoreType>& other)
{
return *this = *this * other;
@@ -204,7 +197,7 @@ namespace omath
constexpr Mat& operator/=(const Type& value) noexcept
{
std::ranges::for_each(m_data, [&value](auto& val) {val /= value;});
std::ranges::for_each(m_data, [&value](auto& val) { val /= value; });
return *this;
}
@@ -233,33 +226,33 @@ namespace omath
}
[[nodiscard]]
constexpr Mat<Columns, Rows, Type, StoreType> Transposed() const noexcept
constexpr Mat<Columns, Rows, Type, StoreType> transposed() const noexcept
{
Mat<Columns, Rows, Type, StoreType> transposed;
for (size_t i = 0; i < Rows; ++i)
for (size_t j = 0; j < Columns; ++j)
transposed.At(j, i) = At(i, j);
transposed.at(j, i) = at(i, j);
return transposed;
}
[[nodiscard]]
constexpr Type Determinant() const
constexpr Type determinant() const
{
static_assert(Rows == Columns, "Determinant is only defined for square matrices.");
if constexpr (Rows == 1)
return At(0, 0);
return at(0, 0);
if constexpr (Rows == 2)
return At(0, 0) * At(1, 1) - At(0, 1) * At(1, 0);
return at(0, 0) * at(1, 1) - at(0, 1) * at(1, 0);
if constexpr (Rows > 2)
{
Type det = 0;
for (size_t column = 0; column < Columns; ++column)
{
const Type cofactor = At(0, column) * AlgComplement(0, column);
const Type cofactor = at(0, column) * alg_complement(0, column);
det += cofactor;
}
return det;
@@ -268,9 +261,9 @@ namespace omath
}
[[nodiscard]]
constexpr Mat<Rows - 1, Columns - 1, Type, StoreType> Strip(const size_t row, const size_t column) const
constexpr Mat<Rows - 1, Columns - 1, Type, StoreType> strip(const size_t row, const size_t column) const
{
static_assert(Rows-1 > 0 && Columns-1 > 0);
static_assert(Rows - 1 > 0 && Columns - 1 > 0);
Mat<Rows - 1, Columns - 1, Type, StoreType> result;
for (size_t i = 0, m = 0; i < Rows; ++i)
{
@@ -280,7 +273,7 @@ namespace omath
{
if (j == column)
continue;
result.At(m, n) = At(i, j);
result.at(m, n) = at(i, j);
++n;
}
++m;
@@ -289,32 +282,32 @@ namespace omath
}
[[nodiscard]]
constexpr Type Minor(const size_t row, const size_t column) const
constexpr Type minor(const size_t row, const size_t column) const
{
return Strip(row, column).Determinant();
return strip(row, column).determinant();
}
[[nodiscard]]
constexpr Type AlgComplement(const size_t row, const size_t column) const
constexpr Type alg_complement(const size_t row, const size_t column) const
{
const auto minor = Minor(row, column);
return (row + column + 2) % 2 == 0 ? minor: -minor;
const auto minor_value = minor(row, column);
return (row + column + 2) % 2 == 0 ? minor_value : -minor_value;
}
[[nodiscard]]
constexpr const std::array<Type, Rows * Columns>& RawArray() const
constexpr const std::array<Type, Rows * Columns>& raw_array() const
{
return m_data;
}
[[nodiscard]]
constexpr std::array<Type, Rows * Columns>& RawArray()
constexpr std::array<Type, Rows * Columns>& raw_array()
{
return m_data;
}
[[nodiscard]]
std::string ToString() const noexcept
std::string to_string() const noexcept
{
std::ostringstream oss;
oss << "[[";
@@ -326,7 +319,7 @@ namespace omath
for (size_t j = 0; j < Columns; ++j)
{
oss << std::setw(9) << std::fixed << std::setprecision(3) << At(i, j);
oss << std::setw(9) << std::fixed << std::setprecision(3) << at(i, j);
if (j != Columns - 1)
oss << ", ";
}
@@ -349,56 +342,55 @@ namespace omath
// Static methods that return fixed-size matrices
[[nodiscard]]
constexpr static Mat<4, 4> ToScreenMat(const Type& screenWidth, const Type& screenHeight) noexcept
constexpr static Mat<4, 4> to_screen_mat(const Type& screen_width, const Type& screen_height) noexcept
{
return {
{screenWidth / 2, 0, 0, 0},
{0, -screenHeight / 2, 0, 0},
{screen_width / 2, 0, 0, 0},
{0, -screen_height / 2, 0, 0},
{0, 0, 1, 0},
{screenWidth / 2, screenHeight / 2, 0, 1},
{screen_width / 2, screen_height / 2, 0, 1},
};
}
[[nodiscard]]
constexpr std::optional<Mat> Inverted() const
constexpr std::optional<Mat> inverted() const
{
const auto det = Determinant();
const auto det = determinant();
if (det == 0)
return std::nullopt;
const auto transposed = Transposed();
const auto transposed_mat = transposed();
Mat result;
for (std::size_t row = 0; row < Rows; row++)
for (std::size_t column = 0; column < Rows; column++)
result.At(row, column) = transposed.AlgComplement(row, column);
result.at(row, column) = transposed_mat.alg_complement(row, column);
result /= det;
return {result};
}
private:
std::array<Type, Rows * Columns> m_data;
};
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
[[nodiscard]]
constexpr static Mat<1, 4, Type, St> MatRowFromVector(const Vector3<Type>& vector) noexcept
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard]]
constexpr static Mat<1, 4, Type, St> mat_row_from_vector(const Vector3<Type>& vector) noexcept
{
return {{vector.x, vector.y, vector.z, 1}};
}
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
[[nodiscard]]
constexpr static Mat<4, 1, Type, St> MatColumnFromVector(const Vector3<Type>& vector) noexcept
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard]]
constexpr static Mat<4, 1, Type, St> mat_column_from_vector(const Vector3<Type>& vector) noexcept
{
return {{vector.x}, {vector.y}, {vector.z}, {1}};
}
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
[[nodiscard]]
constexpr Mat<4, 4, Type, St> MatTranslation(const Vector3<Type>& diff) noexcept
constexpr Mat<4, 4, Type, St> mat_translation(const Vector3<Type>& diff) noexcept
{
return
{
@@ -411,38 +403,38 @@ namespace omath
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
[[nodiscard]]
Mat<4, 4, Type, St> MatRotationAxisX(const Angle& angle) noexcept
Mat<4, 4, Type, St> mat_rotation_axis_x(const Angle& angle) noexcept
{
return
{
{1, 0, 0, 0},
{0, angle.Cos(), -angle.Sin(), 0},
{0, angle.Sin(), angle.Cos(), 0},
{0, angle.cos(), -angle.sin(), 0},
{0, angle.sin(), angle.cos(), 0},
{0, 0, 0, 1}
};
}
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
[[nodiscard]]
Mat<4, 4, Type, St> MatRotationAxisY(const Angle& angle) noexcept
Mat<4, 4, Type, St> mat_rotation_axis_y(const Angle& angle) noexcept
{
return
{
{angle.Cos(), 0, angle.Sin(), 0},
{angle.cos(), 0, angle.sin(), 0},
{0 , 1, 0, 0},
{-angle.Sin(), 0, angle.Cos(), 0},
{-angle.sin(), 0, angle.cos(), 0},
{0 , 0, 0, 1}
};
}
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
[[nodiscard]]
Mat<4, 4, Type, St> MatRotationAxisZ(const Angle& angle) noexcept
Mat<4, 4, Type, St> mat_rotation_axis_z(const Angle& angle) noexcept
{
return
{
{angle.Cos(), -angle.Sin(), 0, 0},
{angle.Sin(), angle.Cos(), 0, 0},
{angle.cos(), -angle.sin(), 0, 0},
{angle.sin(), angle.cos(), 0, 0},
{ 0, 0, 1, 0},
{ 0, 0, 0, 1},
};
@@ -450,8 +442,8 @@ namespace omath
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
[[nodiscard]]
static Mat<4, 4, Type, St> MatCameraView(const Vector3<Type>& forward, const Vector3<Type>& right,
const Vector3<Type>& up, const Vector3<Type>& cameraOrigin) noexcept
static Mat<4, 4, Type, St> mat_camera_view(const Vector3<Type>& forward, const Vector3<Type>& right,
const Vector3<Type>& up, const Vector3<Type>& camera_origin) noexcept
{
return Mat<4, 4, Type, St>
{
@@ -460,31 +452,31 @@ namespace omath
{forward.x, forward.y, forward.z, 0},
{0, 0, 0, 1},
} * MatTranslation<Type, St>(-cameraOrigin);
} * mat_translation<Type, St>(-camera_origin);
}
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
[[nodiscard]]
Mat<4, 4, Type, St> MatPerspectiveLeftHanded(const float fieldOfView, const float aspectRatio, const float near,
const float far) noexcept
Mat<4, 4, Type, St> mat_perspective_left_handed(const float field_of_view, const float aspect_ratio,
const float near, const float far) noexcept
{
const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f);
const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
return {{1.f / (aspectRatio * fovHalfTan), 0.f, 0.f, 0.f},
{0.f, 1.f / fovHalfTan, 0.f, 0.f},
return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
{0.f, 1.f / fov_half_tan, 0.f, 0.f},
{0.f, 0.f, (far + near) / (far - near), -(2.f * near * far) / (far - near)},
{0.f, 0.f, 1.f, 0.f}};
}
template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
[[nodiscard]]
Mat<4, 4, Type, St> MatPerspectiveRightHanded(const float fieldOfView, const float aspectRatio, const float near,
const float far) noexcept
Mat<4, 4, Type, St> mat_perspective_right_handed(const float field_of_view, const float aspect_ratio,
const float near, const float far) noexcept
{
const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f);
const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
return {{1.f / (aspectRatio * fovHalfTan), 0.f, 0.f, 0.f},
{0.f, 1.f / fovHalfTan, 0.f, 0.f},
return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
{0.f, 1.f / fov_half_tan, 0.f, 0.f},
{0.f, 0.f, -(far + near) / (far - near), -(2.f * near * far) / (far - near)},
{0.f, 0.f, -1.f, 0.f}};
}

46
include/omath/matrix.hpp
View File

@@ -1,8 +1,8 @@
#pragma once
#include "omath/vector3.hpp"
#include <initializer_list>
#include <memory>
#include <string>
#include "omath/vector3.hpp"
namespace omath
{
@@ -16,51 +16,51 @@ namespace omath
Matrix(const std::initializer_list<std::initializer_list<float>>& rows);
[[nodiscard]]
static Matrix ToScreenMatrix(float screenWidth, float screenHeight);
static Matrix to_screen_matrix(float screen_width, float screen_height);
[[nodiscard]]
static Matrix TranslationMatrix(const Vector3<float>& diff);
static Matrix translation_matrix(const Vector3<float>& diff);
[[nodiscard]]
static Matrix OrientationMatrix(const Vector3<float>& forward, const Vector3<float>& right, const Vector3<float>& up);
static Matrix orientation_matrix(const Vector3<float>& forward, const Vector3<float>& right,
const Vector3<float>& up);
[[nodiscard]]
static Matrix ProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);
static Matrix projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
Matrix(const Matrix& other);
Matrix(size_t rows, size_t columns, const float* pRaw);
Matrix(size_t rows, size_t columns, const float* raw_data);
Matrix(Matrix&& other) noexcept;
[[nodiscard]]
size_t RowCount() const noexcept;
size_t row_count() const noexcept;
[[nodiscard]]
float& operator[](size_t row, size_t column);
[[nodiscard]]
size_t ColumnsCount() const noexcept;
size_t columns_count() const noexcept;
[[nodiscard]]
std::pair<size_t, size_t> Size() const noexcept;
std::pair<size_t, size_t> size() const noexcept;
[[nodiscard]]
float& At(size_t iRow, size_t iCol);
float& at(size_t row, size_t col);
[[nodiscard]]
float Sum();
float sum();
void SetDataFromRaw(const float* pRawMatrix);
void set_data_from_raw(const float* raw_matrix);
[[nodiscard]]
Matrix Transpose() const;
Matrix transpose() const;
void Set(float val);
void set(float val);
[[nodiscard]]
const float& At(size_t iRow, size_t iCol) const;
const float& at(size_t row, size_t col) const;
Matrix operator*(const Matrix& other) const;
@@ -72,22 +72,22 @@ namespace omath
Matrix& operator/=(float f);
void Clear();
void clear();
[[nodiscard]]
Matrix Strip(size_t row, size_t column) const;
Matrix strip(size_t row, size_t column) const;
[[nodiscard]]
float Minor(size_t i, size_t j) const;
float minor(size_t i, size_t j) const;
[[nodiscard]]
float AlgComplement(size_t i, size_t j) const;
float alg_complement(size_t i, size_t j) const;
[[nodiscard]]
float Determinant() const;
float determinant() const;
[[nodiscard]]
const float* Raw() const;
const float* raw() const;
Matrix& operator=(const Matrix& other);
@@ -96,7 +96,7 @@ namespace omath
Matrix operator/(float f) const;
[[nodiscard]]
std::string ToString() const;
std::string to_string() const;
~Matrix();

14
include/omath/pathfinding/a_star.hpp
View File

@@ -3,9 +3,9 @@
//
#pragma once
#include <vector>
#include "omath/pathfinding/navigation_mesh.hpp"
#include "omath/vector3.hpp"
#include <vector>
namespace omath::pathfinding
{
@@ -14,17 +14,17 @@ namespace omath::pathfinding
{
public:
[[nodiscard]]
static std::vector<Vector3<float>> FindPath(const Vector3<float>& start, const Vector3<float>& end,
const NavigationMesh& navMesh);
static std::vector<Vector3<float>> find_path(const Vector3<float>& start, const Vector3<float>& end,
const NavigationMesh& nav_mesh);
private:
[[nodiscard]]
static std::vector<Vector3<float>>
ReconstructFinalPath(const std::unordered_map<Vector3<float>, PathNode>& closedList,
const Vector3<float>& current);
reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
const Vector3<float>& current);
[[nodiscard]]
static auto GetPerfectNode(const std::unordered_map<Vector3<float>, PathNode>& openList,
const Vector3<float>& endVertex);
static auto get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
const Vector3<float>& end_vertex);
};
} // namespace omath::pathfinding

14
include/omath/pathfinding/navigation_mesh.hpp
View File

@@ -4,10 +4,10 @@
#pragma once
#include "omath/vector3.hpp"
#include <expected>
#include <string>
#include <vector>
#include "omath/vector3.hpp"
namespace omath::pathfinding
{
@@ -21,18 +21,18 @@ namespace omath::pathfinding
{
public:
[[nodiscard]]
std::expected<Vector3<float>, std::string> GetClosestVertex(const Vector3<float>& point) const;
std::expected<Vector3<float>, std::string> get_closest_vertex(const Vector3<float>& point) const;
[[nodiscard]]
const std::vector<Vector3<float>>& GetNeighbors(const Vector3<float>& vertex) const;
const std::vector<Vector3<float>>& get_neighbors(const Vector3<float>& vertex) const;
[[nodiscard]]
bool Empty() const;
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);
void deserialize(const std::vector<uint8_t>& raw);
std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_verTextMap;
std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_vertex_map;
};
} // namespace omath::pathfinding

5
include/omath/projectile_prediction/proj_pred_engine.hpp
View File

@@ -6,15 +6,14 @@
#include "omath/projectile_prediction/target.hpp"
#include "omath/vector3.hpp"
namespace omath::projectile_prediction
{
class ProjPredEngine
{
public:
[[nodiscard]]
virtual std::optional<Vector3<float>> MaybeCalculateAimPoint(const Projectile& projectile,
const Target& target) const = 0;
virtual std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
const Target& target) const = 0;
virtual ~ProjPredEngine() = default;
};
} // namespace omath::projectile_prediction

24
include/omath/projectile_prediction/proj_pred_engine_avx2.hpp
View File

@@ -6,21 +6,23 @@
namespace omath::projectile_prediction
{
class ProjPredEngineAVX2 final : public ProjPredEngine
class ProjPredEngineAvx2 final : public ProjPredEngine
{
public:
[[nodiscard]] std::optional<Vector3<float>> MaybeCalculateAimPoint(const Projectile& projectile,
const Target& target) const override;
[[nodiscard]] std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
const Target& target) const override;
ProjPredEngineAVX2(float gravityConstant, float simulationTimeStep, float maximumSimulationTime);
~ProjPredEngineAVX2() override = default;
ProjPredEngineAvx2(float gravity_constant, float simulation_time_step, float maximum_simulation_time);
~ProjPredEngineAvx2() override = default;
private:
[[nodiscard]] static std::optional<float> CalculatePitch(const Vector3<float>& projOrigin, const Vector3<float>& targetPos,
float bulletGravity, float v0, float time);
const float m_gravityConstant;
const float m_simulationTimeStep;
const float m_maximumSimulationTime;
[[nodiscard]] static std::optional<float> calculate_pitch(const Vector3<float>& proj_origin,
const Vector3<float>& target_pos,
float bullet_gravity, float v0, float time);
// We use [[maybe_unused]] here since AVX2 is not available for ARM and ARM64 CPU
[[maybe_unused]] const float m_gravity_constant;
[[maybe_unused]] const float m_simulation_time_step;
[[maybe_unused]] const float m_maximum_simulation_time;
};
} // namespace omath::projectile_prediction

28
include/omath/projectile_prediction/proj_pred_engine_legacy.hpp
View File

@@ -4,38 +4,36 @@
#pragma once
#include <optional>
#include "omath/projectile_prediction/proj_pred_engine.hpp"
#include "omath/projectile_prediction/projectile.hpp"
#include "omath/projectile_prediction/target.hpp"
#include "omath/vector3.hpp"
#include <optional>
namespace omath::projectile_prediction
{
class ProjPredEngineLegacy final : public ProjPredEngine
{
public:
explicit ProjPredEngineLegacy(float gravityConstant, float simulationTimeStep, float maximumSimulationTime,
float distanceTolerance);
explicit ProjPredEngineLegacy(float gravity_constant, float simulation_time_step, float maximum_simulation_time,
float distance_tolerance);
[[nodiscard]]
std::optional<Vector3<float>> MaybeCalculateAimPoint(const Projectile& projectile,
const Target& target) const override;
std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
const Target& target) const override;
private:
const float m_gravityConstant;
const float m_simulationTimeStep;
const float m_maximumSimulationTime;
const float m_distanceTolerance;
const float m_gravity_constant;
const float m_simulation_time_step;
const float m_maximum_simulation_time;
const float m_distance_tolerance;
[[nodiscard]]
std::optional<float> MaybeCalculateProjectileLaunchPitchAngle(const Projectile& projectile,
const Vector3<float>& targetPosition) const;
std::optional<float> maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile,
const Vector3<float>& target_position) const;
[[nodiscard]]
bool IsProjectileReachedTarget(const Vector3<float>& targetPosition, const Projectile& projectile, float pitch,
float time) const;
bool is_projectile_reached_target(const Vector3<float>& target_position, const Projectile& projectile,
float pitch, float time) const;
};
} // namespace omath::projectile_prediction

9
include/omath/projectile_prediction/projectile.hpp
View File

@@ -10,12 +10,11 @@ namespace omath::projectile_prediction
class Projectile final
{
public:
[[nodiscard]]
Vector3<float> PredictPosition(float pitch, float yaw, float time, float gravity) const;
Vector3<float> predict_position(float pitch, float yaw, float time, float gravity) const;
Vector3<float> m_origin;
float m_launchSpeed{};
float m_gravityScale{};
float m_launch_speed{};
float m_gravity_scale{};
};
}
} // namespace omath::projectile_prediction

9
include/omath/projectile_prediction/target.hpp
View File

@@ -10,13 +10,12 @@ namespace omath::projectile_prediction
class Target final
{
public:
[[nodiscard]]
constexpr Vector3<float> PredictPosition(const float time, const float gravity) const
constexpr Vector3<float> predict_position(const float time, const float gravity) const
{
auto predicted = m_origin + m_velocity * time;
if (m_isAirborne)
if (m_is_airborne)
predicted.z -= gravity * std::pow(time, 2.f) * 0.5f;
return predicted;
@@ -24,6 +23,6 @@ namespace omath::projectile_prediction
Vector3<float> m_origin;
Vector3<float> m_velocity;
bool m_isAirborne{};
bool m_is_airborne{};
};
}
} // namespace omath::projectile_prediction

139
include/omath/projection/camera.hpp
View File

@@ -4,12 +4,12 @@
#pragma once
#include "omath/projection/error_codes.hpp"
#include <expected>
#include <omath/angle.hpp>
#include <omath/mat.hpp>
#include <omath/vector3.hpp>
#include <type_traits>
#include "omath/projection/error_codes.hpp"
namespace omath::projection
{
@@ -19,163 +19,156 @@ namespace omath::projection
float m_width;
float m_height;
[[nodiscard]] constexpr float AspectRatio() const
[[nodiscard]] constexpr float aspect_ratio() const
{
return m_width / m_height;
}
};
using FieldOfView = Angle<float, 0.f, 180.f, AngleFlags::Clamped>;
template<class Mat4x4Type, class ViewAnglesType>
template<class Mat4X4Type, class ViewAnglesType>
class Camera
{
public:
virtual ~Camera() = default;
Camera(const Vector3<float>& position, const ViewAnglesType& viewAngles, const ViewPort& viewPort,
const FieldOfView& fov, const float near, const float far) :
m_viewPort(viewPort), m_fieldOfView(fov), m_farPlaneDistance(far), m_nearPlaneDistance(near),
m_viewAngles(viewAngles), m_origin(position)
Camera(const Vector3<float>& position, const ViewAnglesType& view_angles, const ViewPort& view_port,
const FieldOfView& fov, const float near, const float far)
: m_view_port(view_port), m_field_of_view(fov), m_far_plane_distance(far), m_near_plane_distance(near),
m_view_angles(view_angles), m_origin(position)
{
}
protected:
virtual void LookAt(const Vector3<float>& target) = 0;
virtual void look_at(const Vector3<float>& target) = 0;
[[nodiscard]] virtual Mat4x4Type CalcViewMatrix() const = 0;
[[nodiscard]] virtual Mat4X4Type calc_view_matrix() const = 0;
[[nodiscard]] virtual Mat4x4Type CalcProjectionMatrix() const = 0;
[[nodiscard]] virtual Mat4X4Type calc_projection_matrix() const = 0;
[[nodiscard]] Mat4x4Type CalcViewProjectionMatrix() const
[[nodiscard]] Mat4X4Type calc_view_projection_matrix() const
{
return CalcProjectionMatrix() * CalcViewMatrix();
return calc_projection_matrix() * calc_view_matrix();
}
public:
[[nodiscard]] const Mat4x4Type& GetViewProjectionMatrix() const
[[nodiscard]] const Mat4X4Type& get_view_projection_matrix() const
{
if (!m_viewProjectionMatrix.has_value())
m_viewProjectionMatrix = CalcViewProjectionMatrix();
if (!m_view_projection_matrix.has_value())
m_view_projection_matrix = calc_view_projection_matrix();
return m_viewProjectionMatrix.value();
return m_view_projection_matrix.value();
}
void SetFieldOfView(const FieldOfView& fov)
void set_field_of_view(const FieldOfView& fov)
{
m_fieldOfView = fov;
m_viewProjectionMatrix = std::nullopt;
m_field_of_view = fov;
m_view_projection_matrix = std::nullopt;
}
void SetNearPlane(const float near)
void set_near_plane(const float near)
{
m_nearPlaneDistance = near;
m_viewProjectionMatrix = std::nullopt;
m_near_plane_distance = near;
m_view_projection_matrix = std::nullopt;
}
void SetFarPlane(const float far)
void set_far_plane(const float far)
{
m_farPlaneDistance = far;
m_viewProjectionMatrix = std::nullopt;
m_far_plane_distance = far;
m_view_projection_matrix = std::nullopt;
}
void SetViewAngles(const ViewAnglesType& viewAngles)
void set_view_angles(const ViewAnglesType& view_angles)
{
m_viewAngles = viewAngles;
m_viewProjectionMatrix = std::nullopt;
m_view_angles = view_angles;
m_view_projection_matrix = std::nullopt;
}
void SetOrigin(const Vector3<float>& origin)
void set_origin(const Vector3<float>& origin)
{
m_origin = origin;
m_viewProjectionMatrix = std::nullopt;
m_view_projection_matrix = std::nullopt;
}
void SetViewPort(const ViewPort& viewPort)
void set_view_port(const ViewPort& view_port)
{
m_viewPort = viewPort;
m_viewProjectionMatrix = std::nullopt;
m_view_port = view_port;
m_view_projection_matrix = std::nullopt;
}
[[nodiscard]] const FieldOfView& GetFieldOfView() const
[[nodiscard]] const FieldOfView& get_field_of_view() const
{
return m_fieldOfView;
return m_field_of_view;
}
[[nodiscard]] const float& GetNearPlane() const
[[nodiscard]] const float& get_near_plane() const
{
return m_nearPlaneDistance;
return m_near_plane_distance;
}
[[nodiscard]] const float& GetFarPlane() const
[[nodiscard]] const float& get_far_plane() const
{
return m_farPlaneDistance;
return m_far_plane_distance;
}
[[nodiscard]] const ViewAnglesType& GetViewAngles() const
[[nodiscard]] const ViewAnglesType& get_view_angles() const
{
return m_viewAngles;
return m_view_angles;
}
[[nodiscard]] const Vector3<float>& GetOrigin() const
[[nodiscard]] const Vector3<float>& get_origin() const
{
return m_origin;
}
[[nodiscard]] std::expected<Vector3<float>, Error> WorldToScreen(const Vector3<float>& worldPosition) const
[[nodiscard]] std::expected<Vector3<float>, Error> world_to_screen(const Vector3<float>& world_position) const
{
auto normalizedCords = WorldToViewPort(worldPosition);
auto normalized_cords = world_to_view_port(world_position);
if (!normalizedCords.has_value())
return std::unexpected{normalizedCords.error()};
if (!normalized_cords.has_value())
return std::unexpected{normalized_cords.error()};
return NdcToScreenPosition(*normalizedCords);
return ndc_to_screen_position(*normalized_cords);
}
[[nodiscard]] std::expected<Vector3<float>, Error> WorldToViewPort(const Vector3<float>& worldPosition) const
[[nodiscard]] std::expected<Vector3<float>, Error>
world_to_view_port(const Vector3<float>& world_position) const
{
auto projected = GetViewProjectionMatrix() *
MatColumnFromVector<float, Mat4x4Type::GetStoreOrdering()>(worldPosition);
auto projected = get_view_projection_matrix()
* mat_column_from_vector<float, Mat4X4Type::get_store_ordering()>(world_position);
if (projected.At(3, 0) == 0.0f)
if (projected.at(3, 0) == 0.0f)
return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
projected /= projected.At(3, 0);
projected /= projected.at(3, 0);
if (IsNdcOutOfBounds(projected))
if (is_ndc_out_of_bounds(projected))
return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
return Vector3<float>{projected.At(0, 0), projected.At(1, 0), projected.At(2, 0)};
return Vector3<float>{projected.at(0, 0), projected.at(1, 0), projected.at(2, 0)};
}
protected:
ViewPort m_viewPort{};
Angle<float, 0.f, 180.f, AngleFlags::Clamped> m_fieldOfView;
ViewPort m_view_port{};
Angle<float, 0.f, 180.f, AngleFlags::Clamped> m_field_of_view;
mutable std::optional<Mat4x4Type> m_viewProjectionMatrix;
mutable std::optional<Mat4X4Type> m_view_projection_matrix;
float m_farPlaneDistance;
float m_nearPlaneDistance;
float m_far_plane_distance;
float m_near_plane_distance;
ViewAnglesType m_viewAngles;
ViewAnglesType m_view_angles;
Vector3<float> m_origin;
private:
template<class Type>
[[nodiscard]]
constexpr static bool IsNdcOutOfBounds(const Type& ndc)
template<class Type> [[nodiscard]]
constexpr static bool is_ndc_out_of_bounds(const Type& ndc)
{
return std::ranges::any_of(ndc.RawArray(), [](const auto& val) { return val < -1 || val > 1; });
return std::ranges::any_of(ndc.raw_array(), [](const auto& val) { return val < -1 || val > 1; });
}
[[nodiscard]] Vector3<float> NdcToScreenPosition(const Vector3<float>& ndc) const
[[nodiscard]] Vector3<float> ndc_to_screen_position(const Vector3<float>& ndc) const
{
return
{
(ndc.x + 1.f) / 2.f * m_viewPort.m_width,
(1.f - ndc.y) / 2.f * m_viewPort.m_height,
ndc.z
};
return {(ndc.x + 1.f) / 2.f * m_view_port.m_width, (1.f - ndc.y) / 2.f * m_view_port.m_height, ndc.z};
}
};
} // namespace omath::projection

1
include/omath/projection/error_codes.hpp
View File

@@ -5,7 +5,6 @@
#pragma once
#include <cstdint>
namespace omath::projection
{
enum class Error : uint16_t

54
include/omath/triangle.hpp
View File

@@ -6,15 +6,14 @@
namespace omath
{
/*
|\
| \
a | \ hypot
| \
-----
b
*/
/*
|\
| \
a | \ hypot
| \
-----
b
*/
template<class Vector>
class Triangle final
@@ -31,52 +30,53 @@ namespace omath
Vector3<float> m_vertex3;
[[nodiscard]]
constexpr Vector3<float> CalculateNormal() const
constexpr Vector3<float> calculate_normal() const
{
const auto b = SideBVector();
const auto a = SideAVector();
return b.Cross(a).Normalized();
const auto b = side_b_vector();
const auto a = side_a_vector();
return b.cross(a).normalized();
}
[[nodiscard]]
float SideALength() const
float side_a_length() const
{
return m_vertex1.DistTo(m_vertex2);
return m_vertex1.distance_to(m_vertex2);
}
[[nodiscard]]
float SideBLength() const
float side_b_length() const
{
return m_vertex3.DistTo(m_vertex2);
return m_vertex3.distance_to(m_vertex2);
}
[[nodiscard]]
constexpr Vector3<float> SideAVector() const
constexpr Vector3<float> side_a_vector() const
{
return m_vertex1 - m_vertex2;
}
[[nodiscard]]
constexpr float Hypot() const
constexpr float hypot() const
{
return m_vertex1.DistTo(m_vertex3);
return m_vertex1.distance_to(m_vertex3);
}
[[nodiscard]]
constexpr bool IsRectangular() const
constexpr bool is_rectangular() const
{
const auto sideA = SideALength();
const auto sideB = SideBLength();
const auto hypot = Hypot();
const auto side_a = side_a_length();
const auto side_b = side_b_length();
const auto hypot_value = hypot();
return std::abs(sideA*sideA + sideB*sideB - hypot*hypot) <= 0.0001f;
return std::abs(side_a * side_a + side_b * side_b - hypot_value * hypot_value) <= 0.0001f;
}
[[nodiscard]]
constexpr Vector3<float> SideBVector() const
constexpr Vector3<float> side_b_vector() const
{
return m_vertex3 - m_vertex2;
}
[[nodiscard]]
constexpr Vector3<float> MidPoint() const
constexpr Vector3<float> mid_point() const
{
return (m_vertex1 + m_vertex2 + m_vertex3) / 3;
}

33
include/omath/vector2.hpp
View File

@@ -10,12 +10,11 @@
#include <imgui.h>
#endif
namespace omath
{
template<class Type>
requires std::is_arithmetic_v<Type>
requires std::is_arithmetic_v<Type>
class Vector2
{
public:
@@ -25,7 +24,7 @@ namespace omath
// Constructors
constexpr Vector2() = default;
constexpr Vector2(const Type& x, const Type& y) : x(x), y(y)
constexpr Vector2(const Type& x, const Type& y): x(x), y(y)
{
}
@@ -108,30 +107,30 @@ namespace omath
}
// Basic vector operations
[[nodiscard]] Type DistTo(const Vector2& vOther) const
[[nodiscard]] Type distance_to(const Vector2& other) const
{
return std::sqrt(DistToSqr(vOther));
return std::sqrt(distance_to_sqr(other));
}
[[nodiscard]] constexpr Type DistToSqr(const Vector2& vOther) const
[[nodiscard]] constexpr Type distance_to_sqr(const Vector2& other) const
{
return (x - vOther.x) * (x - vOther.x) + (y - vOther.y) * (y - vOther.y);
return (x - other.x) * (x - other.x) + (y - other.y) * (y - other.y);
}
[[nodiscard]] constexpr Type Dot(const Vector2& vOther) const
[[nodiscard]] constexpr Type dot(const Vector2& other) const
{
return x * vOther.x + y * vOther.y;
return x * other.x + y * other.y;
}
#ifndef _MSC_VER
[[nodiscard]] constexpr Type Length() const
[[nodiscard]] constexpr Type length() const
{
return std::hypot(this->x, this->y);
}
[[nodiscard]] constexpr Vector2 Normalized() const
[[nodiscard]] constexpr Vector2 normalized() const
{
const Type len = Length();
const Type len = length();
return len > 0.f ? *this / len : *this;
}
#else
@@ -146,12 +145,12 @@ namespace omath
return len > 0.f ? *this / len : *this;
}
#endif
[[nodiscard]] constexpr Type LengthSqr() const
[[nodiscard]] constexpr Type length_sqr() const
{
return x * x + y * y;
}
constexpr Vector2& Abs()
constexpr Vector2& abs()
{
// FIXME: Replace with std::abs, if it will become constexprable
x = x < 0 ? -x : x;
@@ -186,20 +185,20 @@ namespace omath
}
// Sum of elements
[[nodiscard]] constexpr Type Sum() const
[[nodiscard]] constexpr Type sum() const
{
return x + y;
}
[[nodiscard]]
constexpr std::tuple<Type, Type> AsTuple() const
constexpr std::tuple<Type, Type> as_tuple() const
{
return std::make_tuple(x, y);
}
#ifdef OMATH_IMGUI_INTEGRATION
[[nodiscard]]
ImVec2 ToImVec2() const
ImVec2 to_im_vec2() const
{
return {static_cast<float>(this->x), static_cast<float>(this->y)};
}

110
include/omath/vector3.hpp
View File

@@ -4,11 +4,11 @@
#pragma once
#include "omath/angle.hpp"
#include "omath/vector2.hpp"
#include <cstdint>
#include <expected>
#include <functional>
#include "omath/angle.hpp"
#include "omath/vector2.hpp"
namespace omath
{
@@ -18,13 +18,16 @@ namespace omath
IMPOSSIBLE_BETWEEN_ANGLE,
};
template<class Type> requires std::is_arithmetic_v<Type>
template<class Type>
requires std::is_arithmetic_v<Type>
class Vector3 : public Vector2<Type>
{
public:
Type z = static_cast<Type>(0);
constexpr Vector3(const Type& x, const Type& y, const Type& z) : Vector2<Type>(x, y), z(z) { }
constexpr Vector3() : Vector2<Type>() {};
constexpr Vector3(const Type& x, const Type& y, const Type& z): Vector2<Type>(x, y), z(z)
{
}
constexpr Vector3(): Vector2<Type>() {};
[[nodiscard]] constexpr bool operator==(const Vector3& src) const
{
@@ -100,72 +103,71 @@ namespace omath
return *this;
}
constexpr Vector3& Abs()
constexpr Vector3& abs()
{
Vector2<Type>::Abs();
Vector2<Type>::abs();
z = z < 0.f ? -z : z;
return *this;
}
[[nodiscard]] constexpr Type DistToSqr(const Vector3& vOther) const
[[nodiscard]] constexpr Type distance_to_sqr(const Vector3& other) const
{
return (*this - vOther).LengthSqr();
return (*this - other).length_sqr();
}
[[nodiscard]] constexpr Type Dot(const Vector3& vOther) const
[[nodiscard]] constexpr Type dot(const Vector3& other) const
{
return Vector2<Type>::Dot(vOther) + z * vOther.z;
return Vector2<Type>::dot(other) + z * other.z;
}
#ifndef _MSC_VER
[[nodiscard]] constexpr Type Length() const
[[nodiscard]] constexpr Type length() const
{
return std::hypot(this->x, this->y, z);
}
[[nodiscard]] constexpr Type Length2D() const
[[nodiscard]] constexpr Type length_2d() const
{
return Vector2<Type>::Length();
return Vector2<Type>::length();
}
[[nodiscard]] Type DistTo(const Vector3& vOther) const
[[nodiscard]] Type distance_to(const Vector3& other) const
{
return (*this - vOther).Length();
return (*this - other).length();
}
[[nodiscard]] constexpr Vector3 Normalized() const
[[nodiscard]] constexpr Vector3 normalized() const
{
const Type length = this->Length();
const Type length_value = this->length();
return length != 0 ? *this / length : *this;
return length_value != 0 ? *this / length_value : *this;
}
#else
[[nodiscard]] Type Length() const
[[nodiscard]] Type length() const
{
return std::hypot(this->x, this->y, z);
}
[[nodiscard]] Vector3 Normalized() const
[[nodiscard]] Vector3 normalized() const
{
const Type length = this->Length();
return length != 0 ? *this / length : *this;
}
[[nodiscard]] Type Length2D() const
[[nodiscard]] Type length_2d() const
{
return Vector2<Type>::Length();
}
[[nodiscard]] Type DistTo(const Vector3& vOther) const
[[nodiscard]] Type distance_to(const Vector3& vOther) const
{
return (*this - vOther).Length();
}
#endif
[[nodiscard]] constexpr Type LengthSqr() const
[[nodiscard]] constexpr Type length_sqr() const
{
return Vector2<Type>::LengthSqr() + z * z;
return Vector2<Type>::length_sqr() + z * z;
}
[[nodiscard]] constexpr Vector3 operator-() const
@@ -203,79 +205,69 @@ namespace omath
return {this->x / v.x, this->y / v.y, z / v.z};
}
[[nodiscard]] constexpr Vector3 Cross(const Vector3 &v) const
[[nodiscard]] constexpr Vector3 cross(const Vector3& v) const
{
return
{
this->y * v.z - z * v.y,
z * v.x - this->x * v.z,
this->x * v.y - this->y * v.x
};
return {this->y * v.z - z * v.y, z * v.x - this->x * v.z, this->x * v.y - this->y * v.x};
}
[[nodiscard]] constexpr Type Sum() const
[[nodiscard]] constexpr Type sum() const
{
return Sum2D() + z;
return sum_2d() + z;
}
[[nodiscard]] std::expected<Angle<float, 0.f, 180.f, AngleFlags::Clamped>, Vector3Error>
AngleBetween(const Vector3& other) const
angle_between(const Vector3& other) const
{
const auto bottom = Length() * other.Length();
const auto bottom = length() * other.length();
if (bottom == 0.f)
return std::unexpected(Vector3Error::IMPOSSIBLE_BETWEEN_ANGLE);
return Angle<float, 0.f, 180.f, AngleFlags::Clamped>::FromRadians(std::acos(Dot(other) / bottom));
return Angle<float, 0.f, 180.f, AngleFlags::Clamped>::from_radians(std::acos(dot(other) / bottom));
}
[[nodiscard]] bool IsPerpendicular(const Vector3& other) const
[[nodiscard]] bool is_perpendicular(const Vector3& other) const
{
if (const auto angle = AngleBetween(other))
return angle->AsDegrees() == 90.f;
if (const auto angle = angle_between(other))
return angle->as_degrees() == 90.f;
return false;
}
[[nodiscard]] constexpr Type Sum2D() const
[[nodiscard]] constexpr Type sum_2d() const
{
return Vector2<Type>::Sum();
return Vector2<Type>::sum();
}
[[nodiscard]] constexpr std::tuple<Type, Type, Type> AsTuple() const
[[nodiscard]] constexpr std::tuple<Type, Type, Type> as_tuple() const
{
return std::make_tuple(this->x, this->y, z);
}
[[nodiscard]] Vector3 ViewAngleTo(const Vector3 &other) const
[[nodiscard]] Vector3 view_angle_to(const Vector3& other) const
{
const float distance = DistTo(other);
const float distance = distance_to(other);
const auto delta = other - *this;
return
{
angles::RadiansToDegrees(std::asin(delta.z / distance)),
angles::RadiansToDegrees(std::atan2(delta.y, delta.x)),
0
};
return {angles::radians_to_degrees(std::asin(delta.z / distance)),
angles::radians_to_degrees(std::atan2(delta.y, delta.x)), 0};
}
};
}
} // namespace omath
// ReSharper disable once CppRedundantNamespaceDefinition
namespace std
{
template<>
struct hash<omath::Vector3<float>>
template<> struct hash<omath::Vector3<float>>
{
std::size_t operator()(const omath::Vector3<float>& vec) const noexcept
{
std::size_t hash = 0;
constexpr std::hash<float> hasher;
hash ^= hasher(vec.x) + 0x9e3779b9 + (hash<<6) + (hash>>2);
hash ^= hasher(vec.y) + 0x9e3779b9 + (hash<<6) + (hash>>2);
hash ^= hasher(vec.z) + 0x9e3779b9 + (hash<<6) + (hash>>2);
hash ^= hasher(vec.x) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
hash ^= hasher(vec.y) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
hash ^= hasher(vec.z) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
return hash;
}
};
}
} // namespace std

46
include/omath/vector4.hpp
View File

@@ -6,17 +6,18 @@
#include <algorithm>
#include <omath/vector3.hpp>
namespace omath
{
template <class Type>
template<class Type>
class Vector4 : public Vector3<Type>
{
public:
Type w;
constexpr Vector4(const Type& x, const Type& y, const Type& z, const Type& w) : Vector3<Type>(x, y, z), w(w) {}
constexpr Vector4() : Vector3<Type>(), w(0) {};
constexpr Vector4(const Type& x, const Type& y, const Type& z, const Type& w): Vector3<Type>(x, y, z), w(w)
{
}
constexpr Vector4(): Vector3<Type>(), w(0) {};
[[nodiscard]]
constexpr bool operator==(const Vector4& src) const
@@ -77,29 +78,29 @@ namespace omath
return *this;
}
[[nodiscard]] constexpr Type LengthSqr() const
[[nodiscard]] constexpr Type length_sqr() const
{
return Vector3<Type>::LengthSqr() + w * w;
return Vector3<Type>::length_sqr() + w * w;
}
[[nodiscard]] constexpr Type Dot(const Vector4& vOther) const
[[nodiscard]] constexpr Type dot(const Vector4& other) const
{
return Vector3<Type>::Dot(vOther) + w * vOther.w;
return Vector3<Type>::dot(other) + w * other.w;
}
[[nodiscard]] Vector3<Type> Length() const
[[nodiscard]] Vector3<Type> length() const
{
return std::sqrt(LengthSqr());
return std::sqrt(length_sqr());
}
constexpr Vector4& Abs()
constexpr Vector4& abs()
{
Vector3<Type>::Abs();
Vector3<Type>::abs();
w = w < 0.f ? -w : w;
return *this;
}
constexpr Vector4& Clamp(const Type& min, const Type& max)
constexpr Vector4& clamp(const Type& min, const Type& max)
{
this->x = std::clamp(this->x, min, max);
this->y = std::clamp(this->y, min, max);
@@ -151,23 +152,22 @@ namespace omath
}
[[nodiscard]]
constexpr Type Sum() const
constexpr Type sum() const
{
return Vector3<Type>::Sum() + w;
return Vector3<Type>::sum() + w;
}
#ifdef OMATH_IMGUI_INTEGRATION
[[nodiscard]]
ImVec4 ToImVec4() const
ImVec4 to_im_vec4() const
{
return
{
static_cast<float>(this->x),
static_cast<float>(this->y),
static_cast<float>(this->z),
static_cast<float>(w),
return {
static_cast<float>(this->x),
static_cast<float>(this->y),
static_cast<float>(this->z),
static_cast<float>(w),
};
}
#endif
};
}
} // namespace omath

2
include/omath/view_angles.hpp
View File

@@ -12,4 +12,4 @@ namespace omath
YawType yaw;
RollType roll;
};
}
} // namespace omath

30
source/3d_primitives/box.cpp
View File

@@ -3,27 +3,25 @@
//
#include "omath/3d_primitives/box.hpp"
namespace omath::primitives
{
std::array<Triangle<Vector3<float>>, 12> CreateBox(const Vector3<float>& top, const Vector3<float>& bottom,
const Vector3<float>& dirForward,
const Vector3<float>& dirRight,
const float ratio)
std::array<Triangle<Vector3<float>>, 12> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
const Vector3<float>& dir_forward,
const Vector3<float>& dir_right, const float ratio)
{
const auto height = top.DistTo(bottom);
const auto sideSize = height / ratio;
const auto height = top.distance_to(bottom);
const auto side_size = height / ratio;
// corner layout (0‑3 bottom, 4‑7 top)
std::array<Vector3<float>, 8> p;
p[0] = bottom + (dirForward + dirRight) * sideSize; // front‑right‑bottom
p[1] = bottom + (dirForward - dirRight) * sideSize; // front‑left‑bottom
p[2] = bottom + (-dirForward + dirRight) * sideSize; // back‑right‑bottom
p[3] = bottom + (-dirForward - dirRight) * sideSize; // back‑left‑bottom
p[4] = top + (dirForward + dirRight) * sideSize; // front‑right‑top
p[5] = top + (dirForward - dirRight) * sideSize; // front‑left‑top
p[6] = top + (-dirForward + dirRight) * sideSize; // back‑right‑top
p[7] = top + (-dirForward - dirRight) * sideSize; // back‑left‑top
p[0] = bottom + (dir_forward + dir_right) * side_size; // front‑right‑bottom
p[1] = bottom + (dir_forward - dir_right) * side_size; // front‑left‑bottom
p[2] = bottom + (-dir_forward + dir_right) * side_size; // back‑right‑bottom
p[3] = bottom + (-dir_forward - dir_right) * side_size; // back‑left‑bottom
p[4] = top + (dir_forward + dir_right) * side_size; // front‑right‑top
p[5] = top + (dir_forward - dir_right) * side_size; // front‑left‑top
p[6] = top + (-dir_forward + dir_right) * side_size; // back‑right‑top
p[7] = top + (-dir_forward - dir_right) * side_size; // back‑left‑top
std::array<Triangle<Vector3<float>>, 12> poly;
@@ -53,4 +51,4 @@ namespace omath::primitives
return poly;
}
}
} // namespace omath::primitives

52
source/collision/line_tracer.cpp
View File

@@ -5,63 +5,59 @@
namespace omath::collision
{
bool LineTracer::CanTraceLine(const Ray& ray, const Triangle<Vector3<float>>& triangle)
bool LineTracer::can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle)
{
return GetRayHitPoint(ray, triangle) == ray.end;
return get_ray_hit_point(ray, triangle) == ray.end;
}
Vector3<float> Ray::DirectionVector() const
Vector3<float> Ray::direction_vector() const
{
return end - start;
}
Vector3<float> Ray::DirectionVectorNormalized() const
Vector3<float> Ray::direction_vector_normalized() const
{
return DirectionVector().Normalized();
return direction_vector().normalized();
}
Vector3<float> LineTracer::GetRayHitPoint(const Ray& ray, const Triangle<Vector3<float>>& triangle)
Vector3<float> LineTracer::get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle)
{
constexpr float kEpsilon = std::numeric_limits<float>::epsilon();
constexpr float k_epsilon = std::numeric_limits<float>::epsilon();
const auto sideA = triangle.SideAVector();
const auto sideB = triangle.SideBVector();
const auto side_a = triangle.side_a_vector();
const auto side_b = triangle.side_b_vector();
const auto ray_dir = ray.direction_vector();
const auto rayDir = ray.DirectionVector();
const auto p = ray_dir.cross(side_b);
const auto det = side_a.dot(p);
const auto p = rayDir.Cross(sideB);
const auto det = sideA.Dot(p);
if (std::abs(det) < kEpsilon)
if (std::abs(det) < k_epsilon)
return ray.end;
const auto invDet = 1.0f / det;
const auto inv_det = 1.0f / det;
const auto t = ray.start - triangle.m_vertex2;
const auto u = t.Dot(p) * invDet;
const auto u = t.dot(p) * inv_det;
if ((u < 0 && std::abs(u) > kEpsilon) || (u > 1 && std::abs(u - 1) > kEpsilon))
if ((u < 0 && std::abs(u) > k_epsilon) || (u > 1 && std::abs(u - 1) > k_epsilon))
return ray.end;
const auto q = t.Cross(sideA);
const auto v = rayDir.Dot(q) * invDet;
const auto q = t.cross(side_a);
// ReSharper disable once CppTooWideScopeInitStatement
const auto v = ray_dir.dot(q) * inv_det;
if ((v < 0 && std::abs(v) > kEpsilon) || (u + v > 1 && std::abs(u + v - 1) > kEpsilon))
if ((v < 0 && std::abs(v) > k_epsilon) || (u + v > 1 && std::abs(u + v - 1) > k_epsilon))
return ray.end;
const auto tHit = sideB.Dot(q) * invDet;
const auto t_hit = side_b.dot(q) * inv_det;
if (ray.infinite_length)
{
if (tHit <= kEpsilon)
if (t_hit <= k_epsilon)
return ray.end;
}
else if (tHit <= kEpsilon || tHit > 1.0f - kEpsilon)
else if (t_hit <= k_epsilon || t_hit > 1.0f - k_epsilon)
return ray.end;
return ray.start + rayDir * tHit;
return ray.start + ray_dir * t_hit;
}
} // namespace omath::collision

1
source/color.cpp
View File

@@ -6,7 +6,6 @@
#include <algorithm>
#include <cmath>
namespace omath
{

29
source/engines/iw_engine/camera.cpp
View File

@@ -7,28 +7,27 @@
namespace omath::iw_engine
{
Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, const float near, const float far) :
projection::Camera<Mat4x4, ViewAngles>(position, viewAngles, viewPort, fov, near, far)
Camera::Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, const float near, const float far)
: projection::Camera<Mat4X4, ViewAngles>(position, view_angles, view_port, fov, near, far)
{
}
void Camera::LookAt([[maybe_unused]] const Vector3<float>& target)
void Camera::look_at([[maybe_unused]] const Vector3<float>& target)
{
const float distance = m_origin.DistTo(target);
const float distance = m_origin.distance_to(target);
const auto delta = target - m_origin;
m_viewAngles.pitch = PitchAngle::FromRadians(std::asin(delta.z / distance));
m_viewAngles.yaw = -YawAngle::FromRadians(std::atan2(delta.y, delta.x));
m_viewAngles.roll = RollAngle::FromRadians(0.f);
m_view_angles.pitch = PitchAngle::from_radians(std::asin(delta.z / distance));
m_view_angles.yaw = -YawAngle::from_radians(std::atan2(delta.y, delta.x));
m_view_angles.roll = RollAngle::from_radians(0.f);
}
Mat4x4 Camera::CalcViewMatrix() const
Mat4X4 Camera::calc_view_matrix() const
{
return iw_engine::CalcViewMatrix(m_viewAngles, m_origin);
return iw_engine::calc_view_matrix(m_view_angles, m_origin);
}
Mat4x4 Camera::CalcProjectionMatrix() const
Mat4X4 Camera::calc_projection_matrix() const
{
return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
m_farPlaneDistance);
return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
m_near_plane_distance, m_far_plane_distance);
}
} // namespace omath::openg
} // namespace omath::iw_engine

39
source/engines/iw_engine/formulas.cpp
View File

@@ -3,50 +3,49 @@
//
#include "omath/engines/iw_engine/formulas.hpp"
namespace omath::iw_engine
{
Vector3<float> ForwardVector(const ViewAngles& angles)
Vector3<float> forward_vector(const ViewAngles& angles)
{
const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsForward);
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Vector3<float> RightVector(const ViewAngles& angles)
Vector3<float> right_vector(const ViewAngles& angles)
{
const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsRight);
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Vector3<float> UpVector(const ViewAngles& angles)
Vector3<float> up_vector(const ViewAngles& angles)
{
const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsUp);
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Mat4x4 RotationMatrix(const ViewAngles& angles)
Mat4X4 rotation_matrix(const ViewAngles& angles)
{
return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll);
return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
}
Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
{
return MatCameraView(ForwardVector(angles), RightVector(angles), UpVector(angles), cam_origin);
return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin);
}
Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
const float far)
Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
const float far)
{
// NOTE: Need magic number to fix fov calculation, since IW engine inherit Quake proj matrix calculation
constexpr auto kMultiplyFactor = 0.75f;
constexpr auto k_multiply_factor = 0.75f;
const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f) * kMultiplyFactor;
const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f) * k_multiply_factor;
return {
{1.f / (aspectRatio * fovHalfTan), 0, 0, 0},
{0, 1.f / (fovHalfTan), 0, 0},
{1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
{0, 1.f / (fov_half_tan), 0, 0},
{0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
{0, 0, 1, 0},
};

30
source/engines/opengl_engine/camera.cpp
View File

@@ -4,32 +4,30 @@
#include "omath/engines/opengl_engine/camera.hpp"
#include "omath/engines/opengl_engine/formulas.hpp"
namespace omath::opengl_engine
{
Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, const float near, const float far) :
projection::Camera<Mat4x4, ViewAngles>(position, viewAngles, viewPort, fov, near, far)
Camera::Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, const float near, const float far)
: projection::Camera<Mat4X4, ViewAngles>(position, view_angles, view_port, fov, near, far)
{
}
void Camera::LookAt([[maybe_unused]] const Vector3<float>& target)
void Camera::look_at([[maybe_unused]] const Vector3<float>& target)
{
const float distance = m_origin.DistTo(target);
const float distance = m_origin.distance_to(target);
const auto delta = target - m_origin;
m_viewAngles.pitch = PitchAngle::FromRadians(std::asin(delta.z / distance));
m_viewAngles.yaw = -YawAngle::FromRadians(std::atan2(delta.y, delta.x));
m_viewAngles.roll = RollAngle::FromRadians(0.f);
m_view_angles.pitch = PitchAngle::from_radians(std::asin(delta.z / distance));
m_view_angles.yaw = -YawAngle::from_radians(std::atan2(delta.y, delta.x));
m_view_angles.roll = RollAngle::from_radians(0.f);
}
Mat4x4 Camera::CalcViewMatrix() const
Mat4X4 Camera::calc_view_matrix() const
{
return opengl_engine::CalcViewMatrix(m_viewAngles, m_origin);
return opengl_engine::calc_view_matrix(m_view_angles, m_origin);
}
Mat4x4 Camera::CalcProjectionMatrix() const
Mat4X4 Camera::calc_projection_matrix() const
{
return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
m_farPlaneDistance);
return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
m_near_plane_distance, m_far_plane_distance);
}
} // namespace omath::opengl
} // namespace omath::opengl_engine

45
source/engines/opengl_engine/formulas.cpp
View File

@@ -3,47 +3,48 @@
//
#include "omath/engines/opengl_engine/formulas.hpp"
namespace omath::opengl_engine
{
Vector3<float> ForwardVector(const ViewAngles& angles)
Vector3<float> forward_vector(const ViewAngles& angles)
{
const auto vec = RotationMatrix(angles) * MatColumnFromVector<float, MatStoreType::COLUMN_MAJOR>(kAbsForward);
const auto vec
= rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_forward);
return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Vector3<float> RightVector(const ViewAngles& angles)
Vector3<float> right_vector(const ViewAngles& angles)
{
const auto vec = RotationMatrix(angles) * MatColumnFromVector<float, MatStoreType::COLUMN_MAJOR>(kAbsRight);
const auto vec
= rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_right);
return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Vector3<float> UpVector(const ViewAngles& angles)
Vector3<float> up_vector(const ViewAngles& angles)
{
const auto vec = RotationMatrix(angles) * MatColumnFromVector<float, MatStoreType::COLUMN_MAJOR>(kAbsUp);
const auto vec = rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_up);
return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
{
return MatCameraView<float, MatStoreType::COLUMN_MAJOR>(-ForwardVector(angles), RightVector(angles),
UpVector(angles), cam_origin);
return mat_camera_view<float, MatStoreType::COLUMN_MAJOR>(-forward_vector(angles), right_vector(angles),
up_vector(angles), cam_origin);
}
Mat4x4 RotationMatrix(const ViewAngles& angles)
Mat4X4 rotation_matrix(const ViewAngles& angles)
{
return MatRotationAxisX<float, MatStoreType::COLUMN_MAJOR>(-angles.pitch) *
MatRotationAxisY<float, MatStoreType::COLUMN_MAJOR>(-angles.yaw) *
MatRotationAxisZ<float, MatStoreType::COLUMN_MAJOR>(angles.roll);
return mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(-angles.pitch)
* mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(-angles.yaw)
* mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll);
}
Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
const float far)
Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
const float far)
{
const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f);
const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
return {
{1.f / (aspectRatio * fovHalfTan), 0, 0, 0},
{0, 1.f / (fovHalfTan), 0, 0},
{1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
{0, 1.f / (fov_half_tan), 0, 0},
{0, 0, -(far + near) / (far - near), -(2.f * far * near) / (far - near)},
{0, 0, -1, 0},
};

30
source/engines/source_engine/camera.cpp
View File

@@ -4,34 +4,32 @@
#include "omath/engines/source_engine/camera.hpp"
#include "omath/engines/source_engine/formulas.hpp"
namespace omath::source_engine
{
Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
const projection::FieldOfView& fov, const float near, const float far) :
projection::Camera<Mat4x4, ViewAngles>(position, viewAngles, viewPort, fov, near, far)
Camera::Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
const projection::FieldOfView& fov, const float near, const float far)
: projection::Camera<Mat4X4, ViewAngles>(position, view_angles, view_port, fov, near, far)
{
}
void Camera::LookAt(const Vector3<float>& target)
void Camera::look_at(const Vector3<float>& target)
{
const float distance = m_origin.DistTo(target);
const float distance = m_origin.distance_to(target);
const auto delta = target - m_origin;
m_viewAngles.pitch = PitchAngle::FromRadians(std::asin(delta.z / distance));
m_viewAngles.yaw = -YawAngle::FromRadians(std::atan2(delta.y, delta.x));
m_viewAngles.roll = RollAngle::FromRadians(0.f);
m_view_angles.pitch = PitchAngle::from_radians(std::asin(delta.z / distance));
m_view_angles.yaw = -YawAngle::from_radians(std::atan2(delta.y, delta.x));
m_view_angles.roll = RollAngle::from_radians(0.f);
}
Mat4x4 Camera::CalcViewMatrix() const
Mat4X4 Camera::calc_view_matrix() const
{
return source_engine::CalcViewMatrix(m_viewAngles, m_origin);
return source_engine::calc_view_matrix(m_view_angles, m_origin);
}
Mat4x4 Camera::CalcProjectionMatrix() const
Mat4X4 Camera::calc_projection_matrix() const
{
return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
m_farPlaneDistance);
return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
m_near_plane_distance, m_far_plane_distance);
}
} // namespace omath::source
} // namespace omath::source_engine

39
source/engines/source_engine/formulas.cpp
View File

@@ -3,50 +3,49 @@
//
#include <omath/engines/source_engine/formulas.hpp>
namespace omath::source_engine
{
Vector3<float> ForwardVector(const ViewAngles& angles)
Vector3<float> forward_vector(const ViewAngles& angles)
{
const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsForward);
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Mat4x4 RotationMatrix(const ViewAngles& angles)
Mat4X4 rotation_matrix(const ViewAngles& angles)
{
return MatRotationAxisZ(angles.yaw) * MatRotationAxisY(angles.pitch) * MatRotationAxisX(angles.roll);
return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
}
Vector3<float> RightVector(const ViewAngles& angles)
Vector3<float> right_vector(const ViewAngles& angles)
{
const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsRight);
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Vector3<float> UpVector(const ViewAngles& angles)
Vector3<float> up_vector(const ViewAngles& angles)
{
const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsUp);
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
{
return MatCameraView(ForwardVector(angles), RightVector(angles), UpVector(angles), cam_origin);
return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin);
}
Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
const float far)
Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
const float far)
{
// NOTE: Need magic number to fix fov calculation, since source inherit Quake proj matrix calculation
constexpr auto kMultiplyFactor = 0.75f;
constexpr auto k_multiply_factor = 0.75f;
const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f) * kMultiplyFactor;
const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f) * k_multiply_factor;
return {
{1.f / (aspectRatio * fovHalfTan), 0, 0, 0},
{0, 1.f / (fovHalfTan), 0, 0},
{1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
{0, 1.f / (fov_half_tan), 0, 0},
{0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
{0, 0, 1, 0},
};

19
source/engines/unity_engine/camera.cpp
View File

@@ -4,25 +4,24 @@
#include <omath/engines/unity_engine/camera.hpp>
#include <omath/engines/unity_engine/formulas.hpp>
namespace omath::unity_engine
{
Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
const projection::FieldOfView& fov, const float near, const float far) :
projection::Camera<Mat4x4, ViewAngles>(position, viewAngles, viewPort, fov, near, far)
Camera::Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
const projection::FieldOfView& fov, const float near, const float far)
: projection::Camera<Mat4X4, ViewAngles>(position, view_angles, view_port, fov, near, far)
{
}
void Camera::LookAt([[maybe_unused]] const Vector3<float>& target)
void Camera::look_at([[maybe_unused]] const Vector3<float>& target)
{
throw std::runtime_error("Not implemented");
}
Mat4x4 Camera::CalcViewMatrix() const
Mat4X4 Camera::calc_view_matrix() const
{
return unity_engine::CalcViewMatrix(m_viewAngles, m_origin);
return unity_engine::calc_view_matrix(m_view_angles, m_origin);
}
Mat4x4 Camera::CalcProjectionMatrix() const
Mat4X4 Camera::calc_projection_matrix() const
{
return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
m_farPlaneDistance);
return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
m_near_plane_distance, m_far_plane_distance);
}
} // namespace omath::unity_engine

44
source/engines/unity_engine/formulas.cpp
View File

@@ -3,47 +3,45 @@
//
#include "omath/engines/unity_engine/formulas.hpp"
namespace omath::unity_engine
{
Vector3<float> ForwardVector(const ViewAngles& angles)
Vector3<float> forward_vector(const ViewAngles& angles)
{
const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsForward);
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Vector3<float> RightVector(const ViewAngles& angles)
Vector3<float> right_vector(const ViewAngles& angles)
{
const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsRight);
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Vector3<float> UpVector(const ViewAngles& angles)
Vector3<float> up_vector(const ViewAngles& angles)
{
const auto vec = RotationMatrix(angles) * MatColumnFromVector(kAbsUp);
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
{
return MatCameraView<float, MatStoreType::ROW_MAJOR>(ForwardVector(angles), -RightVector(angles),
UpVector(angles), cam_origin);
return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), -right_vector(angles),
up_vector(angles), cam_origin);
}
Mat4x4 RotationMatrix(const ViewAngles& angles)
Mat4X4 rotation_matrix(const ViewAngles& angles)
{
return MatRotationAxisX<float, MatStoreType::ROW_MAJOR>(angles.pitch) *
MatRotationAxisY<float, MatStoreType::ROW_MAJOR>(angles.yaw) *
MatRotationAxisZ<float, MatStoreType::ROW_MAJOR>(angles.roll);
return mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch)
* mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
* mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll);
}
Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
const float far)
Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
const float far)
{
const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f);
const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
return {
{1.f / (aspectRatio * fovHalfTan), 0, 0, 0},
{0, 1.f / (fovHalfTan), 0, 0},
{1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
{0, 1.f / (fov_half_tan), 0, 0},
{0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
{0, 0, -1.f, 0},
};

140
source/matrix.cpp
View File

@@ -1,14 +1,11 @@
#include "omath/matrix.hpp"
#include "omath/angles.hpp"
#include "omath/vector3.hpp"
#include <complex>
#include <format>
#include <stdexcept>
#include <utility>
namespace omath
{
Matrix::Matrix(const size_t rows, const size_t columns)
@@ -21,7 +18,7 @@ namespace omath
m_data = std::make_unique<float[]>(m_rows * m_columns);
Set(0.f);
set(0.f);
}
Matrix::Matrix(const std::initializer_list<std::initializer_list<float>>& rows)
@@ -29,7 +26,6 @@ namespace omath
m_rows = rows.size();
m_columns = rows.begin()->size();
for (const auto& row: rows)
if (row.size() != m_columns)
throw std::invalid_argument("All rows must have the same number of columns.");
@@ -41,7 +37,7 @@ namespace omath
{
size_t j = 0;
for (const auto& value: row)
At(i, j++) = value;
at(i, j++) = value;
++i;
}
}
@@ -55,29 +51,28 @@ namespace omath
for (size_t i = 0; i < m_rows; ++i)
for (size_t j = 0; j < m_columns; ++j)
At(i, j) = other.At(i, j);
at(i, j) = other.at(i, j);
}
Matrix::Matrix(const size_t rows, const size_t columns, const float* pRaw)
Matrix::Matrix(const size_t rows, const size_t columns, const float* raw_data)
{
m_rows = rows;
m_columns = columns;
m_data = std::make_unique<float[]>(m_rows * m_columns);
for (size_t i = 0; i < rows * columns; ++i)
At(i / rows, i % columns) = pRaw[i];
at(i / rows, i % columns) = raw_data[i];
}
size_t Matrix::RowCount() const noexcept
size_t Matrix::row_count() const noexcept
{
return m_rows;
}
float& Matrix::operator[](const size_t row, const size_t column)
{
return At(row, column);
return at(row, column);
}
Matrix::Matrix(Matrix&& other) noexcept
@@ -92,35 +87,35 @@ namespace omath
other.m_data = nullptr;
}
size_t Matrix::ColumnsCount() const noexcept
size_t Matrix::columns_count() const noexcept
{
return m_columns;
}
std::pair<size_t, size_t> Matrix::Size() const noexcept
std::pair<size_t, size_t> Matrix::size() const noexcept
{
return {RowCount(), ColumnsCount()};
return {row_count(), columns_count()};
}
float& Matrix::At(const size_t iRow, const size_t iCol)
float& Matrix::at(const size_t row, const size_t col)
{
return const_cast<float&>(std::as_const(*this).At(iRow, iCol));
return const_cast<float&>(std::as_const(*this).at(row, col));
}
float Matrix::Sum()
float Matrix::sum()
{
float sum = 0;
for (size_t i = 0; i < RowCount(); i++)
for (size_t j = 0; j < ColumnsCount(); j++)
sum += At(i, j);
for (size_t i = 0; i < row_count(); i++)
for (size_t j = 0; j < columns_count(); j++)
sum += at(i, j);
return sum;
}
const float& Matrix::At(const size_t iRow, const size_t iCol) const
const float& Matrix::at(const size_t row, const size_t col) const
{
return m_data[iRow * m_columns + iCol];
return m_data[row * m_columns + col];
}
Matrix Matrix::operator*(const Matrix& other) const
@@ -128,15 +123,14 @@ namespace omath
if (m_columns != other.m_rows)
throw std::runtime_error("n != m");
auto outMat = Matrix(m_rows, other.m_columns);
auto out_mat = Matrix(m_rows, other.m_columns);
for (size_t d = 0; d < m_rows; ++d)
for (size_t i = 0; i < other.m_columns; ++i)
for (size_t j = 0; j < other.m_rows; ++j)
outMat.At(d, i) += At(d, j) * other.At(j, i);
out_mat.at(d, i) += at(d, j) * other.at(j, i);
return outMat;
return out_mat;
}
Matrix& Matrix::operator*=(const Matrix& other)
@@ -150,22 +144,22 @@ namespace omath
auto out = *this;
for (size_t i = 0; i < m_rows; ++i)
for (size_t j = 0; j < m_columns; ++j)
out.At(i, j) *= f;
out.at(i, j) *= f;
return out;
}
Matrix& Matrix::operator*=(const float f)
{
for (size_t i = 0; i < RowCount(); i++)
for (size_t j = 0; j < ColumnsCount(); j++)
At(i, j) *= f;
for (size_t i = 0; i < row_count(); i++)
for (size_t j = 0; j < columns_count(); j++)
at(i, j) *= f;
return *this;
}
void Matrix::Clear()
void Matrix::clear()
{
Set(0.f);
set(0.f);
}
Matrix& Matrix::operator=(const Matrix& other)
@@ -175,7 +169,7 @@ namespace omath
for (size_t i = 0; i < m_rows; ++i)
for (size_t j = 0; j < m_columns; ++j)
At(i, j) = other.At(i, j);
at(i, j) = other.at(i, j);
return *this;
}
@@ -199,7 +193,7 @@ namespace omath
{
for (size_t i = 0; i < m_rows; ++i)
for (size_t j = 0; j < m_columns; ++j)
At(i, j) /= f;
at(i, j) /= f;
return *this;
}
@@ -209,12 +203,12 @@ namespace omath
auto out = *this;
for (size_t i = 0; i < m_rows; ++i)
for (size_t j = 0; j < m_columns; ++j)
out.At(i, j) /= f;
out.at(i, j) /= f;
return out;
}
std::string Matrix::ToString() const
std::string Matrix::to_string() const
{
std::string str;
@@ -222,7 +216,7 @@ namespace omath
{
for (size_t j = 0; j < m_columns; ++j)
{
str += std::format("{:.1f}", At(i, j));
str += std::format("{:.1f}", at(i, j));
if (j == m_columns - 1)
str += '\n';
@@ -233,89 +227,89 @@ namespace omath
return str;
}
float Matrix::Determinant() const
float Matrix::determinant() const // NOLINT(*-no-recursion)
{
if (m_rows + m_columns == 2)
return At(0, 0);
return at(0, 0);
if (m_rows == 2 and m_columns == 2)
return At(0, 0) * At(1, 1) - At(0, 1) * At(1, 0);
return at(0, 0) * at(1, 1) - at(0, 1) * at(1, 0);
float fDet = 0;
float det = 0;
for (size_t i = 0; i < m_columns; i++)
fDet += AlgComplement(0, i) * At(0, i);
det += alg_complement(0, i) * at(0, i);
return fDet;
return det;
}
float Matrix::AlgComplement(const size_t i, const size_t j) const
float Matrix::alg_complement(const size_t i, const size_t j) const // NOLINT(*-no-recursion)
{
const auto tmp = Minor(i, j);
const auto tmp = minor(i, j);
return ((i + j + 2) % 2 == 0) ? tmp : -tmp;
}
Matrix Matrix::Transpose() const
Matrix Matrix::transpose() const
{
Matrix transposed = {m_columns, m_rows};
for (size_t i = 0; i < m_rows; ++i)
for (size_t j = 0; j < m_columns; ++j)
transposed.At(j, i) = At(i, j);
transposed.at(j, i) = at(i, j);
return transposed;
}
Matrix::~Matrix() = default;
void Matrix::Set(const float val)
void Matrix::set(const float val)
{
for (size_t i = 0; i < m_rows; ++i)
for (size_t j = 0; j < m_columns; ++j)
At(i, j) = val;
at(i, j) = val;
}
Matrix Matrix::Strip(const size_t row, const size_t column) const
Matrix Matrix::strip(const size_t row, const size_t column) const
{
Matrix stripped = {m_rows - 1, m_columns - 1};
size_t iStripRowIndex = 0;
size_t strip_row_index = 0;
for (size_t i = 0; i < m_rows; i++)
{
if (i == row)
continue;
size_t iStripColumnIndex = 0;
size_t strip_column_index = 0;
for (size_t j = 0; j < m_columns; ++j)
{
if (j == column)
continue;
stripped.At(iStripRowIndex, iStripColumnIndex) = At(i, j);
iStripColumnIndex++;
stripped.at(strip_row_index, strip_column_index) = at(i, j);
strip_column_index++;
}
iStripRowIndex++;
strip_row_index++;
}
return stripped;
}
float Matrix::Minor(const size_t i, const size_t j) const
float Matrix::minor(const size_t i, const size_t j) const // NOLINT(*-no-recursion)
{
return Strip(i, j).Determinant();
return strip(i, j).determinant();
}
Matrix Matrix::ToScreenMatrix(const float screenWidth, const float screenHeight)
Matrix Matrix::to_screen_matrix(const float screen_width, const float screen_height)
{
return {
{screenWidth / 2.f, 0.f, 0.f, 0.f},
{0.f, -screenHeight / 2.f, 0.f, 0.f},
{screen_width / 2.f, 0.f, 0.f, 0.f},
{0.f, -screen_height / 2.f, 0.f, 0.f},
{0.f, 0.f, 1.f, 0.f},
{screenWidth / 2.f, screenHeight / 2.f, 0.f, 1.f},
{screen_width / 2.f, screen_height / 2.f, 0.f, 1.f},
};
}
Matrix Matrix::TranslationMatrix(const Vector3<float>& diff)
Matrix Matrix::translation_matrix(const Vector3<float>& diff)
{
return {
{1.f, 0.f, 0.f, 0.f},
@@ -325,7 +319,8 @@ namespace omath
};
}
Matrix Matrix::OrientationMatrix(const Vector3<float>& forward, const Vector3<float>& right, const Vector3<float>& up)
Matrix Matrix::orientation_matrix(const Vector3<float>& forward, const Vector3<float>& right,
const Vector3<float>& up)
{
return {
{right.x, up.x, forward.x, 0.f},
@@ -335,25 +330,26 @@ namespace omath
};
}
Matrix Matrix::ProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near, const float far)
Matrix Matrix::projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
const float far)
{
const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f);
const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
return {{1.f / (aspectRatio * fovHalfTan), 0.f, 0.f, 0.f},
{0.f, 1.f / fovHalfTan, 0.f, 0.f},
return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
{0.f, 1.f / fov_half_tan, 0.f, 0.f},
{0.f, 0.f, (far + near) / (far - near), 2.f * near * far / (far - near)},
{0.f, 0.f, -1.f, 0.f}};
}
const float* Matrix::Raw() const
const float* Matrix::raw() const
{
return m_data.get();
}
void Matrix::SetDataFromRaw(const float* pRawMatrix)
void Matrix::set_data_from_raw(const float* raw_matrix)
{
for (size_t i = 0; i < m_columns * m_rows; ++i)
At(i / m_rows, i % m_columns) = pRawMatrix[i];
at(i / m_rows, i % m_columns) = raw_matrix[i];
}
Matrix::Matrix()

87
source/pathfinding/a_star.cpp
View File

@@ -2,96 +2,95 @@
// Created by Vlad on 28.07.2024.
//
#include "omath/pathfinding/a_star.hpp"
#include <algorithm>
#include <optional>
#include <unordered_map>
#include <unordered_set>
namespace omath::pathfinding
{
struct PathNode final
{
std::optional<Vector3<float>> cameFrom;
float gCost = 0.f;
std::optional<Vector3<float>> came_from;
float g_cost = 0.f;
};
std::vector<Vector3<float>> Astar::ReconstructFinalPath(const std::unordered_map<Vector3<float>, PathNode>& closedList,
const Vector3<float>& current)
std::vector<Vector3<float>>
Astar::reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
const Vector3<float>& current)
{
std::vector<Vector3<float>> path;
std::optional currentOpt = current;
std::optional current_opt = current;
while (currentOpt)
while (current_opt)
{
path.push_back(*currentOpt);
path.push_back(*current_opt);
auto it = closedList.find(*currentOpt);
auto it = closed_list.find(*current_opt);
if (it == closedList.end())
if (it == closed_list.end())
break;
currentOpt = it->second.cameFrom;
current_opt = it->second.came_from;
}
std::ranges::reverse(path);
return path;
}
auto Astar::GetPerfectNode(const std::unordered_map<Vector3<float>, PathNode>& openList, const Vector3<float>& endVertex)
auto Astar::get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
const Vector3<float>& end_vertex)
{
return std::ranges::min_element(openList,
[&endVertex](const auto& a, const auto& b)
return std::ranges::min_element(open_list,
[&end_vertex](const auto& a, const auto& b)
{
const float fA = a.second.gCost + a.first.DistTo(endVertex);
const float fB = b.second.gCost + b.first.DistTo(endVertex);
return fA < fB;
const float fa = a.second.g_cost + a.first.distance_to(end_vertex);
const float fb = b.second.g_cost + b.first.distance_to(end_vertex);
return fa < fb;
});
}
std::vector<Vector3<float>> Astar::FindPath(const Vector3<float>& start, const Vector3<float>& end, const NavigationMesh& navMesh)
std::vector<Vector3<float>> Astar::find_path(const Vector3<float>& start, const Vector3<float>& end,
const NavigationMesh& nav_mesh)
{
std::unordered_map<Vector3<float>, PathNode> closedList;
std::unordered_map<Vector3<float>, PathNode> openList;
std::unordered_map<Vector3<float>, PathNode> closed_list;
std::unordered_map<Vector3<float>, PathNode> open_list;
auto maybeStartVertex = navMesh.GetClosestVertex(start);
auto maybeEndVertex = navMesh.GetClosestVertex(end);
auto maybe_start_vertex = nav_mesh.get_closest_vertex(start);
auto maybe_end_vertex = nav_mesh.get_closest_vertex(end);
if (!maybeStartVertex || !maybeEndVertex)
if (!maybe_start_vertex || !maybe_end_vertex)
return {};
const auto startVertex = maybeStartVertex.value();
const auto endVertex = maybeEndVertex.value();
const auto start_vertex = maybe_start_vertex.value();
const auto end_vertex = maybe_end_vertex.value();
open_list.emplace(start_vertex, PathNode{std::nullopt, 0.f});
openList.emplace(startVertex, PathNode{std::nullopt, 0.f});
while (!openList.empty())
while (!open_list.empty())
{
auto currentIt = GetPerfectNode(openList, endVertex);
auto current_it = get_perfect_node(open_list, end_vertex);
const auto current = currentIt->first;
const auto currentNode = currentIt->second;
const auto current = current_it->first;
const auto current_node = current_it->second;
if (current == endVertex)
return ReconstructFinalPath(closedList, current);
if (current == end_vertex)
return reconstruct_final_path(closed_list, current);
closed_list.emplace(current, current_node);
open_list.erase(current_it);
closedList.emplace(current, currentNode);
openList.erase(currentIt);
for (const auto& neighbor: navMesh.GetNeighbors(current))
for (const auto& neighbor: nav_mesh.get_neighbors(current))
{
if (closedList.contains(neighbor))
if (closed_list.contains(neighbor))
continue;
const float tentativeGCost = currentNode.gCost + neighbor.DistTo(current);
const float tentative_g_cost = current_node.g_cost + neighbor.distance_to(current);
const auto openIt = openList.find(neighbor);
// ReSharper disable once CppTooWideScopeInitStatement
const auto open_it = open_list.find(neighbor);
if (openIt == openList.end() || tentativeGCost < openIt->second.gCost)
openList[neighbor] = PathNode{current, tentativeGCost};
if (open_it == open_list.end() || tentative_g_cost < open_it->second.g_cost)
open_list[neighbor] = PathNode{current, tentative_g_cost};
}
}

65
source/pathfinding/navigation_mesh.cpp
View File

@@ -2,94 +2,89 @@
// Created by Vlad on 28.07.2024.
//
#include "omath/pathfinding/navigation_mesh.hpp"
#include <algorithm>
#include <stdexcept>
namespace omath::pathfinding
{
std::expected<Vector3<float>, std::string> NavigationMesh::GetClosestVertex(const Vector3<float> &point) const
std::expected<Vector3<float>, std::string> NavigationMesh::get_closest_vertex(const Vector3<float>& point) const
{
const auto res = std::ranges::min_element(m_verTextMap,
[&point](const auto& a, const auto& b)
{
return a.first.DistTo(point) < b.first.DistTo(point);
});
const auto res = std::ranges::min_element(m_vertex_map, [&point](const auto& a, const auto& b)
{ return a.first.distance_to(point) < b.first.distance_to(point); });
if (res == m_verTextMap.cend())
if (res == m_vertex_map.cend())
return std::unexpected("Failed to get clossest point");
return res->first;
}
const std::vector<Vector3<float>>& NavigationMesh::GetNeighbors(const Vector3<float> &vertex) const
const std::vector<Vector3<float>>& NavigationMesh::get_neighbors(const Vector3<float>& vertex) const
{
return m_verTextMap.at(vertex);
return m_vertex_map.at(vertex);
}
bool NavigationMesh::Empty() const
bool NavigationMesh::empty() const
{
return m_verTextMap.empty();
return m_vertex_map.empty();
}
std::vector<uint8_t> NavigationMesh::Serialize() const
std::vector<uint8_t> NavigationMesh::serialize() const
{
auto dumpToVector =[]<typename T>(const T& t, std::vector<uint8_t>& vec){
auto dump_to_vector = []<typename T>(const T& t, std::vector<uint8_t>& vec)
{
for (size_t i = 0; i < sizeof(t); i++)
vec.push_back(*(reinterpret_cast<const uint8_t*>(&t)+i));
vec.push_back(*(reinterpret_cast<const uint8_t*>(&t) + i));
};
std::vector<uint8_t> raw;
for (const auto& [vertex, neighbors] : m_verTextMap)
for (const auto& [vertex, neighbors]: m_vertex_map)
{
const auto neighborsCount = neighbors.size();
const auto neighbors_count = neighbors.size();
dumpToVector(vertex, raw);
dumpToVector(neighborsCount, raw);
dump_to_vector(vertex, raw);
dump_to_vector(neighbors_count, raw);
for (const auto& neighbor : neighbors)
dumpToVector(neighbor, raw);
for (const auto& neighbor: neighbors)
dump_to_vector(neighbor, raw);
}
return raw;
}
void NavigationMesh::Deserialize(const std::vector<uint8_t> &raw)
void NavigationMesh::deserialize(const std::vector<uint8_t>& raw)
{
auto loadFromVector = [](const std::vector<uint8_t>& vec, size_t& offset, auto& value)
auto load_from_vector = [](const std::vector<uint8_t>& vec, size_t& offset, auto& value)
{
if (offset + sizeof(value) > vec.size())
{
throw std::runtime_error("Deserialize: Invalid input data size.");
}
std::copy_n(vec.data() + offset, sizeof(value), (uint8_t*)&value);
std::copy_n(vec.data() + offset, sizeof(value), reinterpret_cast<uint8_t*>(&value));
offset += sizeof(value);
};
m_verTextMap.clear();
m_vertex_map.clear();
size_t offset = 0;
while (offset < raw.size())
{
Vector3<float> vertex;
loadFromVector(raw, offset, vertex);
load_from_vector(raw, offset, vertex);
uint16_t neighborsCount;
loadFromVector(raw, offset, neighborsCount);
uint16_t neighbors_count;
load_from_vector(raw, offset, neighbors_count);
std::vector<Vector3<float>> neighbors;
neighbors.reserve(neighborsCount);
neighbors.reserve(neighbors_count);
for (size_t i = 0; i < neighborsCount; ++i)
for (size_t i = 0; i < neighbors_count; ++i)
{
Vector3<float> neighbor;
loadFromVector(raw, offset, neighbor);
load_from_vector(raw, offset, neighbor);
neighbors.push_back(neighbor);
}
m_verTextMap.emplace(vertex, std::move(neighbors));
m_vertex_map.emplace(vertex, std::move(neighbors));
}
}
}
} // namespace omath::pathfinding

1
source/projectile_prediction/proj_pred_engine.cpp
View File

@@ -3,7 +3,6 @@
//
#include "omath/projectile_prediction/proj_pred_engine.hpp"
namespace omath::projectile_prediction
{

48
source/projectile_prediction/proj_pred_engine_avx2.cpp
View File

@@ -14,8 +14,8 @@
namespace omath::projectile_prediction
{
std::optional<Vector3<float>>
ProjPredEngineAVX2::MaybeCalculateAimPoint([[maybe_unused]] const Projectile& projectile,
[[maybe_unused]] const Target& target) const
ProjPredEngineAvx2::maybe_calculate_aim_point([[maybe_unused]] const Projectile& projectile,
[[maybe_unused]] const Target& target) const
{
#if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
const float bulletGravity = m_gravityConstant * projectile.m_gravityScale;
@@ -28,16 +28,16 @@ namespace omath::projectile_prediction
for (; currentTime <= m_maximumSimulationTime; currentTime += m_simulationTimeStep * SIMD_FACTOR)
{
const __m256 times =
_mm256_setr_ps(currentTime, currentTime + m_simulationTimeStep,
currentTime + m_simulationTimeStep * 2, currentTime + m_simulationTimeStep * 3,
currentTime + m_simulationTimeStep * 4, currentTime + m_simulationTimeStep * 5,
currentTime + m_simulationTimeStep * 6, currentTime + m_simulationTimeStep * 7);
const __m256 times
= _mm256_setr_ps(currentTime, currentTime + m_simulationTimeStep,
currentTime + m_simulationTimeStep * 2, currentTime + m_simulationTimeStep * 3,
currentTime + m_simulationTimeStep * 4, currentTime + m_simulationTimeStep * 5,
currentTime + m_simulationTimeStep * 6, currentTime + m_simulationTimeStep * 7);
const __m256 targetX =
_mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.x), times, _mm256_set1_ps(target.m_origin.x));
const __m256 targetY =
_mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.y), times, _mm256_set1_ps(target.m_origin.y));
const __m256 targetX
= _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.x), times, _mm256_set1_ps(target.m_origin.x));
const __m256 targetY
= _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.y), times, _mm256_set1_ps(target.m_origin.y));
const __m256 timesSq = _mm256_mul_ps(times, times);
const __m256 targetZ = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.z), times,
_mm256_fnmadd_ps(_mm256_set1_ps(0.5f * m_gravityConstant), timesSq,
@@ -112,25 +112,32 @@ namespace omath::projectile_prediction
}
return std::nullopt;
#else
throw std::runtime_error(
std::format("{} AVX2 feature is not enabled!", std::source_location::current().function_name()));
#endif
}
ProjPredEngineAVX2::ProjPredEngineAVX2(const float gravityConstant, const float simulationTimeStep,
const float maximumSimulationTime) :
m_gravityConstant(gravityConstant), m_simulationTimeStep(simulationTimeStep),
m_maximumSimulationTime(maximumSimulationTime)
ProjPredEngineAvx2::ProjPredEngineAvx2(const float gravity_constant, const float simulation_time_step,
const float maximum_simulation_time)
: m_gravity_constant(gravity_constant), m_simulation_time_step(simulation_time_step),
m_maximum_simulation_time(maximum_simulation_time)
{
}
std::optional<float> ProjPredEngineAVX2::CalculatePitch(const Vector3<float>& projOrigin,
const Vector3<float>& targetPos, const float bulletGravity,
const float v0, const float time)
std::optional<float> ProjPredEngineAvx2::calculate_pitch([[maybe_unused]] const Vector3<float>& proj_origin,
[[maybe_unused]] const Vector3<float>& target_pos,
[[maybe_unused]] const float bullet_gravity,
[[maybe_unused]] const float v0,
[[maybe_unused]] const float time)
{
#if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
if (time <= 0.0f)
return std::nullopt;
const Vector3 delta = targetPos - projOrigin;
const Vector3 delta = target_pos - proj_origin;
const float dSqr = delta.x * delta.x + delta.y * delta.y;
const float h = delta.z;
const float term = h + 0.5f * bulletGravity * time * time;
const float term = h + 0.5f * bullet_gravity * time * time;
const float requiredV0Sqr = (dSqr + term * term) / (time * time);
const float v0Sqr = v0 * v0;
@@ -140,7 +147,6 @@ namespace omath::projectile_prediction
if (dSqr == 0.0f)
return term >= 0.0f ? 90.0f : -90.0f;
const float d = std::sqrt(dSqr);
const float tanTheta = term / d;
return angles::RadiansToDegrees(std::atan(tanTheta));

62
source/projectile_prediction/proj_pred_engine_legacy.cpp
View File

@@ -4,65 +4,67 @@
namespace omath::projectile_prediction
{
ProjPredEngineLegacy::ProjPredEngineLegacy(const float gravityConstant, const float simulationTimeStep,
const float maximumSimulationTime, const float distanceTolerance) :
m_gravityConstant(gravityConstant), m_simulationTimeStep(simulationTimeStep),
m_maximumSimulationTime(maximumSimulationTime), m_distanceTolerance(distanceTolerance)
ProjPredEngineLegacy::ProjPredEngineLegacy(const float gravity_constant, const float simulation_time_step,
const float maximum_simulation_time, const float distance_tolerance)
: m_gravity_constant(gravity_constant), m_simulation_time_step(simulation_time_step),
m_maximum_simulation_time(maximum_simulation_time), m_distance_tolerance(distance_tolerance)
{
}
std::optional<Vector3<float>> ProjPredEngineLegacy::MaybeCalculateAimPoint(const Projectile& projectile,
const Target& target) const
std::optional<Vector3<float>> ProjPredEngineLegacy::maybe_calculate_aim_point(const Projectile& projectile,
const Target& target) const
{
for (float time = 0.f; time < m_maximumSimulationTime; time += m_simulationTimeStep)
for (float time = 0.f; time < m_maximum_simulation_time; time += m_simulation_time_step)
{
const auto predictedTargetPosition = target.PredictPosition(time, m_gravityConstant);
const auto predicted_target_position = target.predict_position(time, m_gravity_constant);
const auto projectilePitch = MaybeCalculateProjectileLaunchPitchAngle(projectile, predictedTargetPosition);
const auto projectile_pitch
= maybe_calculate_projectile_launch_pitch_angle(projectile, predicted_target_position);
if (!projectilePitch.has_value()) [[unlikely]]
if (!projectile_pitch.has_value()) [[unlikely]]
continue;
if (!IsProjectileReachedTarget(predictedTargetPosition, projectile, projectilePitch.value(), time))
if (!is_projectile_reached_target(predicted_target_position, projectile, projectile_pitch.value(), time))
continue;
const auto delta2d = (predictedTargetPosition - projectile.m_origin).Length2D();
const auto height = delta2d * std::tan(angles::DegreesToRadians(projectilePitch.value()));
const auto delta2d = (predicted_target_position - projectile.m_origin).length_2d();
const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
return Vector3(predictedTargetPosition.x, predictedTargetPosition.y, projectile.m_origin.z + height);
return Vector3(predicted_target_position.x, predicted_target_position.y, projectile.m_origin.z + height);
}
return std::nullopt;
}
std::optional<float>
ProjPredEngineLegacy::MaybeCalculateProjectileLaunchPitchAngle(const Projectile& projectile,
const Vector3<float>& targetPosition) const
ProjPredEngineLegacy::maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile,
const Vector3<float>& target_position) const
{
const auto bulletGravity = m_gravityConstant * projectile.m_gravityScale;
const auto delta = targetPosition - projectile.m_origin;
const auto bullet_gravity = m_gravity_constant * projectile.m_gravity_scale;
const auto delta = target_position - projectile.m_origin;
const auto distance2d = delta.Length2D();
const auto distance2dSqr = distance2d * distance2d;
const auto launchSpeedSqr = projectile.m_launchSpeed * projectile.m_launchSpeed;
const auto distance2d = delta.length_2d();
const auto distance2d_sqr = distance2d * distance2d;
const auto launch_speed_sqr = projectile.m_launch_speed * projectile.m_launch_speed;
float root = launchSpeedSqr * launchSpeedSqr -
bulletGravity * (bulletGravity * distance2dSqr + 2.0f * delta.z * launchSpeedSqr);
float root = launch_speed_sqr * launch_speed_sqr
- bullet_gravity * (bullet_gravity * distance2d_sqr + 2.0f * delta.z * launch_speed_sqr);
if (root < 0.0f) [[unlikely]]
return std::nullopt;
root = std::sqrt(root);
const float angle = std::atan((launchSpeedSqr - root) / (bulletGravity * distance2d));
const float angle = std::atan((launch_speed_sqr - root) / (bullet_gravity * distance2d));
return angles::RadiansToDegrees(angle);
return angles::radians_to_degrees(angle);
}
bool ProjPredEngineLegacy::IsProjectileReachedTarget(const Vector3<float>& targetPosition, const Projectile& projectile,
const float pitch, const float time) const
bool ProjPredEngineLegacy::is_projectile_reached_target(const Vector3<float>& target_position,
const Projectile& projectile, const float pitch,
const float time) const
{
const auto yaw = projectile.m_origin.ViewAngleTo(targetPosition).y;
const auto projectilePosition = projectile.PredictPosition(pitch, yaw, time, m_gravityConstant);
const auto yaw = projectile.m_origin.view_angle_to(target_position).y;
const auto projectile_position = projectile.predict_position(pitch, yaw, time, m_gravity_constant);
return projectilePosition.DistTo(targetPosition) <= m_distanceTolerance;
return projectile_position.distance_to(target_position) <= m_distance_tolerance;
}
} // namespace omath::projectile_prediction

19
source/projectile_prediction/projectile.cpp
View File

@@ -3,19 +3,20 @@
//
#include "omath/projectile_prediction/projectile.hpp"
#include <omath/engines/source_engine/formulas.hpp>
namespace omath::projectile_prediction
{
Vector3<float> Projectile::PredictPosition(const float pitch, const float yaw, const float time, const float gravity) const
Vector3<float> Projectile::predict_position(const float pitch, const float yaw, const float time,
const float gravity) const
{
auto currentPos = m_origin + source_engine::ForwardVector({source_engine::PitchAngle::FromDegrees(-pitch),
source_engine::YawAngle::FromDegrees(yaw),
source_engine::RollAngle::FromDegrees(0)}) *
m_launchSpeed * time;
currentPos.z -= (gravity * m_gravityScale) * (time * time) * 0.5f;
auto current_pos = m_origin
+ source_engine::forward_vector({source_engine::PitchAngle::from_degrees(-pitch),
source_engine::YawAngle::from_degrees(yaw),
source_engine::RollAngle::from_degrees(0)})
* m_launch_speed * time;
current_pos.z -= (gravity * m_gravity_scale) * (time * time) * 0.5f;
return currentPos;
return current_pos;
}
} // namespace omath::prediction
} // namespace omath::projectile_prediction

1
source/projectile_prediction/target.cpp
View File

@@ -4,7 +4,6 @@
#include "omath/projectile_prediction/projectile.hpp"
namespace omath::prediction
{

1
source/projection/camera.cpp
View File

@@ -3,7 +3,6 @@
//
#include "omath/projection/camera.hpp"
namespace omath::projection
{
}

60
tests/engines/unit_test_iw_engine.cpp
View File

@@ -9,69 +9,69 @@
TEST(UnitTestIwEngine, ForwardVector)
{
const auto forward = omath::iw_engine::ForwardVector({});
const auto forward = omath::iw_engine::forward_vector({});
EXPECT_EQ(forward, omath::iw_engine::kAbsForward);
EXPECT_EQ(forward, omath::iw_engine::k_abs_forward);
}
TEST(UnitTestIwEngine, RightVector)
{
const auto right = omath::iw_engine::RightVector({});
const auto right = omath::iw_engine::right_vector({});
EXPECT_EQ(right, omath::iw_engine::kAbsRight);
EXPECT_EQ(right, omath::iw_engine::k_abs_right);
}
TEST(UnitTestIwEngine, UpVector)
{
const auto up = omath::iw_engine::UpVector({});
EXPECT_EQ(up, omath::iw_engine::kAbsUp);
const auto up = omath::iw_engine::up_vector({});
EXPECT_EQ(up, omath::iw_engine::k_abs_up);
}
TEST(UnitTestIwEngine, ForwardVectorRotationYaw)
{
omath::iw_engine::ViewAngles angles;
angles.yaw = omath::iw_engine::YawAngle::FromDegrees(-90.f);
angles.yaw = omath::iw_engine::YawAngle::from_degrees(-90.f);
const auto forward = omath::iw_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::iw_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::iw_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::iw_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::iw_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::iw_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::iw_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::iw_engine::k_abs_right.z, 0.00001f);
}
TEST(UnitTestIwEngine, ForwardVectorRotationPitch)
{
omath::iw_engine::ViewAngles angles;
angles.pitch = omath::iw_engine::PitchAngle::FromDegrees(-89.f);
angles.pitch = omath::iw_engine::PitchAngle::from_degrees(-89.f);
const auto forward = omath::iw_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::iw_engine::kAbsUp.x, 0.02f);
EXPECT_NEAR(forward.y, omath::iw_engine::kAbsUp.y, 0.01f);
EXPECT_NEAR(forward.z, omath::iw_engine::kAbsUp.z, 0.01f);
const auto forward = omath::iw_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::iw_engine::k_abs_up.x, 0.02f);
EXPECT_NEAR(forward.y, omath::iw_engine::k_abs_up.y, 0.01f);
EXPECT_NEAR(forward.z, omath::iw_engine::k_abs_up.z, 0.01f);
}
TEST(UnitTestIwEngine, ForwardVectorRotationRoll)
{
omath::iw_engine::ViewAngles angles;
angles.roll = omath::iw_engine::RollAngle::FromDegrees(90.f);
angles.roll = omath::iw_engine::RollAngle::from_degrees(90.f);
const auto forward = omath::iw_engine::UpVector(angles);
EXPECT_NEAR(forward.x, omath::iw_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::iw_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::iw_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::iw_engine::up_vector(angles);
EXPECT_NEAR(forward.x, omath::iw_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::iw_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::iw_engine::k_abs_right.z, 0.00001f);
}
TEST(UnitTestIwEngine, ProjectTargetMovedFromCamera)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
const auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
for (float distance = 0.02f; distance < 1000.f; distance += 0.01f)
{
const auto projected = cam.WorldToScreen({distance, 0, 0});
const auto projected = cam.world_to_screen({distance, 0, 0});
EXPECT_TRUE(projected.has_value());
@@ -85,21 +85,21 @@ TEST(UnitTestIwEngine, ProjectTargetMovedFromCamera)
TEST(UnitTestIwEngine, CameraSetAndGetFov)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 90.f);
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}
TEST(UnitTestIwEngine, CameraSetAndGetOrigin)
{
auto cam = omath::iw_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}

60
tests/engines/unit_test_open_gl.cpp
View File

@@ -9,32 +9,32 @@
TEST(UnitTestOpenGL, ForwardVector)
{
const auto forward = omath::opengl_engine::ForwardVector({});
EXPECT_EQ(forward, omath::opengl_engine::kAbsForward);
const auto forward = omath::opengl_engine::forward_vector({});
EXPECT_EQ(forward, omath::opengl_engine::k_abs_forward);
}
TEST(UnitTestOpenGL, RightVector)
{
const auto right = omath::opengl_engine::RightVector({});
EXPECT_EQ(right, omath::opengl_engine::kAbsRight);
const auto right = omath::opengl_engine::right_vector({});
EXPECT_EQ(right, omath::opengl_engine::k_abs_right);
}
TEST(UnitTestOpenGL, UpVector)
{
const auto up = omath::opengl_engine::UpVector({});
EXPECT_EQ(up, omath::opengl_engine::kAbsUp);
const auto up = omath::opengl_engine::up_vector({});
EXPECT_EQ(up, omath::opengl_engine::k_abs_up);
}
TEST(UnitTestOpenGL, ForwardVectorRotationYaw)
{
omath::opengl_engine::ViewAngles angles;
angles.yaw = omath::opengl_engine::YawAngle::FromDegrees(90.f);
angles.yaw = omath::opengl_engine::YawAngle::from_degrees(90.f);
const auto forward = omath::opengl_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::opengl_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::opengl_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::opengl_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::opengl_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::opengl_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::opengl_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::opengl_engine::k_abs_right.z, 0.00001f);
}
@@ -43,35 +43,35 @@ TEST(UnitTestOpenGL, ForwardVectorRotationPitch)
{
omath::opengl_engine::ViewAngles angles;
angles.pitch = omath::opengl_engine::PitchAngle::FromDegrees(-90.f);
angles.pitch = omath::opengl_engine::PitchAngle::from_degrees(-90.f);
const auto forward = omath::opengl_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::opengl_engine::kAbsUp.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::opengl_engine::kAbsUp.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::opengl_engine::kAbsUp.z, 0.00001f);
const auto forward = omath::opengl_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::opengl_engine::k_abs_up.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::opengl_engine::k_abs_up.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::opengl_engine::k_abs_up.z, 0.00001f);
}
TEST(UnitTestOpenGL, ForwardVectorRotationRoll)
{
omath::opengl_engine::ViewAngles angles;
angles.roll = omath::opengl_engine::RollAngle::FromDegrees(-90.f);
angles.roll = omath::opengl_engine::RollAngle::from_degrees(-90.f);
const auto forward = omath::opengl_engine::UpVector(angles);
EXPECT_NEAR(forward.x, omath::opengl_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::opengl_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::opengl_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::opengl_engine::up_vector(angles);
EXPECT_NEAR(forward.x, omath::opengl_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::opengl_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::opengl_engine::k_abs_right.z, 0.00001f);
}
TEST(UnitTestOpenGL, ProjectTargetMovedFromCamera)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
const auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
for (float distance = -10.f; distance > -1000.f; distance -= 0.01f)
{
const auto projected = cam.WorldToScreen({0, 0, distance});
const auto projected = cam.world_to_screen({0, 0, distance});
EXPECT_TRUE(projected.has_value());
@@ -85,21 +85,21 @@ TEST(UnitTestOpenGL, ProjectTargetMovedFromCamera)
TEST(UnitTestOpenGL, CameraSetAndGetFov)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 90.f);
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}
TEST(UnitTestOpenGL, CameraSetAndGetOrigin)
{
auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}

64
tests/engines/unit_test_source_engine.cpp
View File

@@ -9,69 +9,69 @@
TEST(UnitTestSourceEngine, ForwardVector)
{
const auto forward = omath::source_engine::ForwardVector({});
const auto forward = omath::source_engine::forward_vector({});
EXPECT_EQ(forward, omath::source_engine::kAbsForward);
EXPECT_EQ(forward, omath::source_engine::k_abs_forward);
}
TEST(UnitTestSourceEngine, RightVector)
{
const auto right = omath::source_engine::RightVector({});
const auto right = omath::source_engine::right_vector({});
EXPECT_EQ(right, omath::source_engine::kAbsRight);
EXPECT_EQ(right, omath::source_engine::k_abs_right);
}
TEST(UnitTestSourceEngine, UpVector)
{
const auto up = omath::source_engine::UpVector({});
EXPECT_EQ(up, omath::source_engine::kAbsUp);
const auto up = omath::source_engine::up_vector({});
EXPECT_EQ(up, omath::source_engine::k_abs_up);
}
TEST(UnitTestSourceEngine, ForwardVectorRotationYaw)
{
omath::source_engine::ViewAngles angles;
angles.yaw = omath::source_engine::YawAngle::FromDegrees(-90.f);
angles.yaw = omath::source_engine::YawAngle::from_degrees(-90.f);
const auto forward = omath::source_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::source_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::source_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::source_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::source_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::source_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::source_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::source_engine::k_abs_right.z, 0.00001f);
}
TEST(UnitTestSourceEngine, ForwardVectorRotationPitch)
{
omath::source_engine::ViewAngles angles;
angles.pitch = omath::source_engine::PitchAngle::FromDegrees(-89.f);
angles.pitch = omath::source_engine::PitchAngle::from_degrees(-89.f);
const auto forward = omath::source_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::source_engine::kAbsUp.x, 0.02f);
EXPECT_NEAR(forward.y, omath::source_engine::kAbsUp.y, 0.01f);
EXPECT_NEAR(forward.z, omath::source_engine::kAbsUp.z, 0.01f);
const auto forward = omath::source_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::source_engine::k_abs_up.x, 0.02f);
EXPECT_NEAR(forward.y, omath::source_engine::k_abs_up.y, 0.01f);
EXPECT_NEAR(forward.z, omath::source_engine::k_abs_up.z, 0.01f);
}
TEST(UnitTestSourceEngine, ForwardVectorRotationRoll)
{
omath::source_engine::ViewAngles angles;
angles.roll = omath::source_engine::RollAngle::FromDegrees(90.f);
angles.roll = omath::source_engine::RollAngle::from_degrees(90.f);
const auto forward = omath::source_engine::UpVector(angles);
EXPECT_NEAR(forward.x, omath::source_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::source_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::source_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::source_engine::up_vector(angles);
EXPECT_NEAR(forward.x, omath::source_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::source_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::source_engine::k_abs_right.z, 0.00001f);
}
TEST(UnitTestSourceEngine, ProjectTargetMovedFromCamera)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
const auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
for (float distance = 0.02f; distance < 1000.f; distance += 0.01f)
{
const auto projected = cam.WorldToScreen({distance, 0, 0});
const auto projected = cam.world_to_screen({distance, 0, 0});
EXPECT_TRUE(projected.has_value());
@@ -85,13 +85,13 @@ TEST(UnitTestSourceEngine, ProjectTargetMovedFromCamera)
TEST(UnitTestSourceEngine, ProjectTargetMovedUp)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
const auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
auto prev = 1080.f;
for (float distance = 0.0f; distance < 10.f; distance += 1.f)
{
const auto projected = cam.WorldToScreen({100.f, 0, distance});
const auto projected = cam.world_to_screen({100.f, 0, distance});
EXPECT_TRUE(projected.has_value());
if (!projected.has_value())
@@ -105,21 +105,21 @@ TEST(UnitTestSourceEngine, ProjectTargetMovedUp)
TEST(UnitTestSourceEngine, CameraSetAndGetFov)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 90.f);
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}
TEST(UnitTestSourceEngine, CameraSetAndGetOrigin)
{
auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}

64
tests/engines/unit_test_unity_engine.cpp
View File

@@ -9,69 +9,69 @@
TEST(UnitTestUnityEngine, ForwardVector)
{
const auto forward = omath::unity_engine::ForwardVector({});
const auto forward = omath::unity_engine::forward_vector({});
EXPECT_EQ(forward, omath::unity_engine::kAbsForward);
EXPECT_EQ(forward, omath::unity_engine::k_abs_forward);
}
TEST(UnitTestUnityEngine, ForwardVectorRotationYaw)
{
omath::unity_engine::ViewAngles angles;
angles.yaw = omath::unity_engine::YawAngle::FromDegrees(90.f);
angles.yaw = omath::unity_engine::YawAngle::from_degrees(90.f);
const auto forward = omath::unity_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::unity_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::unity_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::unity_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::unity_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::unity_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::unity_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::unity_engine::k_abs_right.z, 0.00001f);
}
TEST(UnitTestUnityEngine, ForwardVectorRotationPitch)
{
omath::unity_engine::ViewAngles angles;
angles.pitch = omath::unity_engine::PitchAngle::FromDegrees(-90.f);
angles.pitch = omath::unity_engine::PitchAngle::from_degrees(-90.f);
const auto forward = omath::unity_engine::ForwardVector(angles);
EXPECT_NEAR(forward.x, omath::unity_engine::kAbsUp.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::unity_engine::kAbsUp.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::unity_engine::kAbsUp.z, 0.00001f);
const auto forward = omath::unity_engine::forward_vector(angles);
EXPECT_NEAR(forward.x, omath::unity_engine::k_abs_up.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::unity_engine::k_abs_up.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::unity_engine::k_abs_up.z, 0.00001f);
}
TEST(UnitTestUnityEngine, ForwardVectorRotationRoll)
{
omath::unity_engine::ViewAngles angles;
angles.roll = omath::unity_engine::RollAngle::FromDegrees(-90.f);
angles.roll = omath::unity_engine::RollAngle::from_degrees(-90.f);
const auto forward = omath::unity_engine::UpVector(angles);
EXPECT_NEAR(forward.x, omath::unity_engine::kAbsRight.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::unity_engine::kAbsRight.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::unity_engine::kAbsRight.z, 0.00001f);
const auto forward = omath::unity_engine::up_vector(angles);
EXPECT_NEAR(forward.x, omath::unity_engine::k_abs_right.x, 0.00001f);
EXPECT_NEAR(forward.y, omath::unity_engine::k_abs_right.y, 0.00001f);
EXPECT_NEAR(forward.z, omath::unity_engine::k_abs_right.z, 0.00001f);
}
TEST(UnitTestUnityEngine, RightVector)
{
const auto right = omath::unity_engine::RightVector({});
const auto right = omath::unity_engine::right_vector({});
EXPECT_EQ(right, omath::unity_engine::kAbsRight);
EXPECT_EQ(right, omath::unity_engine::k_abs_right);
}
TEST(UnitTestUnityEngine, UpVector)
{
const auto up = omath::unity_engine::UpVector({});
EXPECT_EQ(up, omath::unity_engine::kAbsUp);
const auto up = omath::unity_engine::up_vector({});
EXPECT_EQ(up, omath::unity_engine::k_abs_up);
}
TEST(UnitTestUnityEngine, ProjectTargetMovedFromCamera)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(60.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
const auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.01f, 1000.f);
for (float distance = 0.02f; distance < 100.f; distance += 0.01f)
{
const auto projected = cam.WorldToScreen({0, 0, distance});
const auto projected = cam.world_to_screen({0, 0, distance});
EXPECT_TRUE(projected.has_value());
@@ -84,30 +84,30 @@ TEST(UnitTestUnityEngine, ProjectTargetMovedFromCamera)
}
TEST(UnitTestUnityEngine, Project)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(60.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
const auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.03f, 1000.f);
const auto proj = cam.WorldToScreen({5.f, 3, 10.f});
const auto proj = cam.world_to_screen({5.f, 3, 10.f});
std::println("{} {}", proj->x, proj->y);
}
TEST(UnitTestUnityEngine, CameraSetAndGetFov)
{
constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 90.f);
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}
TEST(UnitTestUnityEngine, CameraSetAndGetOrigin)
{
auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
}

13
tests/general/unit_test_a_star.cpp
View File

@@ -4,14 +4,13 @@
#include <gtest/gtest.h>
#include <omath/pathfinding/a_star.hpp>
TEST(UnitTestAstar, FindingRightPath)
TEST(unit_test_a_star, finding_right_path)
{
omath::pathfinding::NavigationMesh mesh;
mesh.m_verTextMap[{0.f, 0.f, 0.f}] = {{0.f, 1.f, 0.f}};
mesh.m_verTextMap[{0.f, 1.f, 0.f}] = {{0.f, 2.f, 0.f}};
mesh.m_verTextMap[{0.f, 2.f, 0.f}] = {{0.f, 3.f, 0.f}};
mesh.m_verTextMap[{0.f, 3.f, 0.f}] = {};
std::ignore = omath::pathfinding::Astar::FindPath({}, {0.f, 3.f, 0.f}, mesh);
mesh.m_vertex_map[{0.f, 0.f, 0.f}] = {{0.f, 1.f, 0.f}};
mesh.m_vertex_map[{0.f, 1.f, 0.f}] = {{0.f, 2.f, 0.f}};
mesh.m_vertex_map[{0.f, 2.f, 0.f}] = {{0.f, 3.f, 0.f}};
mesh.m_vertex_map[{0.f, 3.f, 0.f}] = {};
std::ignore = omath::pathfinding::Astar::find_path({}, {0.f, 3.f, 0.f}, mesh);
}

24
tests/general/unit_test_angles.cpp
View File

@@ -4,46 +4,46 @@
#include <gtest/gtest.h>
#include <omath/angles.hpp>
TEST(UnitTestAngles, RadiansToDeg)
TEST(unit_test_angles, radians_to_deg)
{
constexpr float rad = 67;
EXPECT_NEAR(omath::angles::RadiansToDegrees(rad), 3838.82f, 0.01f);
EXPECT_NEAR(omath::angles::radians_to_degrees(rad), 3838.82f, 0.01f);
}
TEST(UnitTestAngles, DegreesToRadians)
TEST(unit_test_angles, degrees_to_radians)
{
constexpr float degree = 90;
EXPECT_NEAR(omath::angles::DegreesToRadians(degree), 1.5708f, 0.01f);
EXPECT_NEAR(omath::angles::degrees_to_radians(degree), 1.5708f, 0.01f);
}
TEST(UnitTestAngles, HorizontalFovToVerical)
TEST(unit_test_angles, horizontal_fov_to_verical)
{
constexpr float hFov = 90;
constexpr float aspectRation = 16.0f / 9.0f;
const auto verticalFov = omath::angles::HorizontalFovToVertical(hFov, aspectRation);
const auto verticalFov = omath::angles::horizontal_fov_to_vertical(hFov, aspectRation);
EXPECT_NEAR(verticalFov, 58.71f, 0.01f);
}
TEST(UnitTestAngles, VerticalToHorizontal)
TEST(unit_test_angles, vertical_to_horizontal)
{
constexpr float vFov = 58.71;
constexpr float aspectRation = 16.0f / 9.0f;
const auto horizontalFov = omath::angles::VerticalFovToHorizontal(vFov, aspectRation);
const auto horizontalFov = omath::angles::vertical_fov_to_horizontal(vFov, aspectRation);
EXPECT_NEAR(horizontalFov, 89.99f, 0.01f);
}
TEST(UnitTestAngles, WrapAngle)
TEST(unit_test_angles, wrap_angle)
{
const float wrapped = omath::angles::WrapAngle(361.f, 0.f, 360.f);
const float wrapped = omath::angles::wrap_angle(361.f, 0.f, 360.f);
EXPECT_NEAR(wrapped, 1.f, 0.01f);
}
TEST(UnitTestAngles, WrapAngleNegativeRange)
TEST(unit_test_angles, wrap_angle_negative_range)
{
const float wrapped = omath::angles::WrapAngle(-90.f, 0.f, 360.f);
const float wrapped = omath::angles::wrap_angle(-90.f, 0.f, 360.f);
EXPECT_NEAR(wrapped, 270.f, 0.01f);
}

20
tests/general/unit_test_color.cpp
View File

@@ -15,8 +15,8 @@ protected:
void SetUp() override
{
color1 = Color::Red();
color2 = Color::Green();
color1 = Color::red();
color2 = Color::green();
}
};
@@ -43,7 +43,7 @@ TEST_F(UnitTestColor, Constructor_Vector4)
// Test static methods for color creation
TEST_F(UnitTestColor, FromRGBA)
{
constexpr Color color = Color::FromRGBA(128, 64, 32, 255);
constexpr Color color = Color::from_rgba(128, 64, 32, 255);
EXPECT_FLOAT_EQ(color.x, 128.0f / 255.0f);
EXPECT_FLOAT_EQ(color.y, 64.0f / 255.0f);
EXPECT_FLOAT_EQ(color.z, 32.0f / 255.0f);
@@ -52,7 +52,7 @@ TEST_F(UnitTestColor, FromRGBA)
TEST_F(UnitTestColor, FromHSV)
{
constexpr Color color = Color::FromHSV(0.0f, 1.0f, 1.0f); // Red in HSV
constexpr Color color = Color::from_hsv(0.0f, 1.0f, 1.0f); // Red in HSV
EXPECT_FLOAT_EQ(color.x, 1.0f);
EXPECT_FLOAT_EQ(color.y, 0.0f);
EXPECT_FLOAT_EQ(color.z, 0.0f);
@@ -62,7 +62,7 @@ TEST_F(UnitTestColor, FromHSV)
// Test HSV conversion
TEST_F(UnitTestColor, ToHSV)
{
HSV hsv = color1.ToHSV(); // Red color
Hsv hsv = color1.to_hsv(); // Red color
EXPECT_FLOAT_EQ(hsv.hue, 0.0f);
EXPECT_FLOAT_EQ(hsv.saturation, 1.0f);
EXPECT_FLOAT_EQ(hsv.value, 1.0f);
@@ -71,7 +71,7 @@ TEST_F(UnitTestColor, ToHSV)
// Test color blending
TEST_F(UnitTestColor, Blend)
{
Color blended = color1.Blend(color2, 0.5f);
Color blended = color1.blend(color2, 0.5f);
EXPECT_FLOAT_EQ(blended.x, 0.5f);
EXPECT_FLOAT_EQ(blended.y, 0.5f);
EXPECT_FLOAT_EQ(blended.z, 0.0f);
@@ -81,9 +81,9 @@ TEST_F(UnitTestColor, Blend)
// Test predefined colors
TEST_F(UnitTestColor, PredefinedColors)
{
constexpr Color red = Color::Red();
constexpr Color green = Color::Green();
constexpr Color blue = Color::Blue();
constexpr Color red = Color::red();
constexpr Color green = Color::green();
constexpr Color blue = Color::blue();
EXPECT_FLOAT_EQ(red.x, 1.0f);
EXPECT_FLOAT_EQ(red.y, 0.0f);
@@ -106,7 +106,7 @@ TEST_F(UnitTestColor, BlendVector3)
{
constexpr Color v1(1.0f, 0.0f, 0.0f, 1.f); // Red
constexpr Color v2(0.0f, 1.0f, 0.0f, 1.f); // Green
constexpr Color blended = v1.Blend(v2, 0.5f);
constexpr Color blended = v1.blend(v2, 0.5f);
EXPECT_FLOAT_EQ(blended.x, 0.5f);
EXPECT_FLOAT_EQ(blended.y, 0.5f);
EXPECT_FLOAT_EQ(blended.z, 0.0f);

11
tests/general/unit_test_line_trace.cpp
View File

@@ -59,7 +59,7 @@ namespace
TEST_P(CanTraceLineParam, VariousRays)
{
const auto& p = GetParam();
EXPECT_EQ(LineTracer::CanTraceLine(p.ray, triangle), p.expected_clear);
EXPECT_EQ(LineTracer::can_trace_line(p.ray, triangle), p.expected_clear);
}
INSTANTIATE_TEST_SUITE_P(
@@ -84,7 +84,7 @@ namespace
constexpr Ray ray{{0.3f, 0.3f, -1.f}, {0.3f, 0.3f, 1.f}};
constexpr Vec3 expected{0.3f, 0.3f, 0.f};
const Vec3 hit = LineTracer::GetRayHitPoint(ray, triangle);
const Vec3 hit = LineTracer::get_ray_hit_point(ray, triangle);
ASSERT_FALSE(VecEqual(hit, ray.end));
EXPECT_TRUE(VecEqual(hit, expected));
}
@@ -99,7 +99,7 @@ namespace
{1001.f, 1000.f, 1000.f},
{1000.f, 1001.f, 1000.f}};
EXPECT_TRUE(LineTracer::CanTraceLine(short_ray, distant));
EXPECT_TRUE(LineTracer::can_trace_line(short_ray, distant));
}
TEST(LineTracerTraceRayEdge, CantHit)
@@ -108,14 +108,13 @@ namespace
constexpr Ray ray{{}, {1.0, 0, 0}, false};
EXPECT_TRUE(omath::collision::LineTracer::CanTraceLine(ray, triangle));
EXPECT_TRUE(omath::collision::LineTracer::can_trace_line(ray, triangle));
}
TEST(LineTracerTraceRayEdge, CanHit)
{
constexpr omath::Triangle<Vector3<float>> triangle{{2, 0, 0}, {2, 2, 0}, {2, 2, 2}};
constexpr Ray ray{{}, {2.1, 0, 0}, false};
auto endPoint = omath::collision::LineTracer::GetRayHitPoint(ray, triangle);
EXPECT_FALSE(omath::collision::LineTracer::CanTraceLine(ray, triangle));
EXPECT_FALSE(omath::collision::LineTracer::can_trace_line(ray, triangle));
}
} // namespace

140
tests/general/unit_test_mat.cpp
View File

@@ -22,22 +22,22 @@ protected:
TEST_F(UnitTestMat, Constructor_Default)
{
Mat<3, 3> m;
EXPECT_EQ(m.RowCount(), 3);
EXPECT_EQ(m.ColumnsCount(), 3);
EXPECT_EQ(m.row_count(), 3);
EXPECT_EQ(m.columns_count(), 3);
for (size_t i = 0; i < 3; ++i)
for (size_t j = 0; j < 3; ++j)
EXPECT_FLOAT_EQ(m.At(i, j), 0.0f);
EXPECT_FLOAT_EQ(m.at(i, j), 0.0f);
}
TEST_F(UnitTestMat, Constructor_InitializerList)
{
constexpr Mat<2, 2> m{{1.0f, 2.0f}, {3.0f, 4.0f}};
EXPECT_EQ(m.RowCount(), 2);
EXPECT_EQ(m.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m.At(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m.At(0, 1), 2.0f);
EXPECT_FLOAT_EQ(m.At(1, 0), 3.0f);
EXPECT_FLOAT_EQ(m.At(1, 1), 4.0f);
EXPECT_EQ(m.row_count(), 2);
EXPECT_EQ(m.columns_count(), 2);
EXPECT_FLOAT_EQ(m.at(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m.at(0, 1), 2.0f);
EXPECT_FLOAT_EQ(m.at(1, 0), 3.0f);
EXPECT_FLOAT_EQ(m.at(1, 1), 4.0f);
}
TEST_F(UnitTestMat, Operator_SquareBrackets)
@@ -51,19 +51,19 @@ TEST_F(UnitTestMat, Operator_SquareBrackets)
TEST_F(UnitTestMat, Constructor_Copy)
{
Mat<2, 2> m3 = m2;
EXPECT_EQ(m3.RowCount(), m2.RowCount());
EXPECT_EQ(m3.ColumnsCount(), m2.ColumnsCount());
EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
EXPECT_FLOAT_EQ(m3.At(1, 1), m2.At(1, 1));
EXPECT_EQ(m3.row_count(), m2.row_count());
EXPECT_EQ(m3.columns_count(), m2.columns_count());
EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
EXPECT_FLOAT_EQ(m3.at(1, 1), m2.at(1, 1));
}
TEST_F(UnitTestMat, Constructor_Move)
{
Mat<2, 2> m3 = std::move(m2);
EXPECT_EQ(m3.RowCount(), 2);
EXPECT_EQ(m3.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m3.At(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 4.0f);
EXPECT_EQ(m3.row_count(), 2);
EXPECT_EQ(m3.columns_count(), 2);
EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 4.0f);
// m2 is in a valid but unspecified state after move
}
@@ -71,61 +71,61 @@ TEST_F(UnitTestMat, Constructor_Move)
TEST_F(UnitTestMat, Operator_Multiplication_Matrix)
{
Mat<2, 2> m3 = m2 * m2;
EXPECT_EQ(m3.RowCount(), 2);
EXPECT_EQ(m3.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m3.At(0, 0), 7.0f);
EXPECT_FLOAT_EQ(m3.At(0, 1), 10.0f);
EXPECT_FLOAT_EQ(m3.At(1, 0), 15.0f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 22.0f);
EXPECT_EQ(m3.row_count(), 2);
EXPECT_EQ(m3.columns_count(), 2);
EXPECT_FLOAT_EQ(m3.at(0, 0), 7.0f);
EXPECT_FLOAT_EQ(m3.at(0, 1), 10.0f);
EXPECT_FLOAT_EQ(m3.at(1, 0), 15.0f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 22.0f);
}
TEST_F(UnitTestMat, Operator_Multiplication_Scalar)
{
Mat<2, 2> m3 = m2 * 2.0f;
EXPECT_FLOAT_EQ(m3.At(0, 0), 2.0f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 8.0f);
EXPECT_FLOAT_EQ(m3.at(0, 0), 2.0f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 8.0f);
}
TEST_F(UnitTestMat, Operator_Division_Scalar)
{
Mat<2, 2> m3 = m2 / 2.0f;
EXPECT_FLOAT_EQ(m3.At(0, 0), 0.5f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 2.0f);
EXPECT_FLOAT_EQ(m3.at(0, 0), 0.5f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 2.0f);
}
// Test matrix functions
TEST_F(UnitTestMat, Transpose)
{
Mat<2, 2> m3 = m2.Transposed();
EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
EXPECT_FLOAT_EQ(m3.At(0, 1), m2.At(1, 0));
EXPECT_FLOAT_EQ(m3.At(1, 0), m2.At(0, 1));
EXPECT_FLOAT_EQ(m3.At(1, 1), m2.At(1, 1));
Mat<2, 2> m3 = m2.transposed();
EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
EXPECT_FLOAT_EQ(m3.at(0, 1), m2.at(1, 0));
EXPECT_FLOAT_EQ(m3.at(1, 0), m2.at(0, 1));
EXPECT_FLOAT_EQ(m3.at(1, 1), m2.at(1, 1));
}
TEST_F(UnitTestMat, Determinant)
{
const float det = m2.Determinant();
const float det = m2.determinant();
EXPECT_FLOAT_EQ(det, -2.0f);
}
TEST_F(UnitTestMat, Sum)
{
const float sum = m2.Sum();
const float sum = m2.sum();
EXPECT_FLOAT_EQ(sum, 10.0f);
}
TEST_F(UnitTestMat, Clear)
{
m2.Clear();
for (size_t i = 0; i < m2.RowCount(); ++i)
for (size_t j = 0; j < m2.ColumnsCount(); ++j)
EXPECT_FLOAT_EQ(m2.At(i, j), 0.0f);
m2.clear();
for (size_t i = 0; i < m2.row_count(); ++i)
for (size_t j = 0; j < m2.columns_count(); ++j)
EXPECT_FLOAT_EQ(m2.at(i, j), 0.0f);
}
TEST_F(UnitTestMat, ToString)
{
const std::string str = m2.ToString();
const std::string str = m2.to_string();
EXPECT_FALSE(str.empty());
EXPECT_EQ(str, "[[ 1.000, 2.000]\n [ 3.000, 4.000]]");
}
@@ -135,31 +135,31 @@ TEST_F(UnitTestMat, AssignmentOperator_Copy)
{
Mat<2, 2> m3;
m3 = m2;
EXPECT_EQ(m3.RowCount(), m2.RowCount());
EXPECT_EQ(m3.ColumnsCount(), m2.ColumnsCount());
EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
EXPECT_EQ(m3.row_count(), m2.row_count());
EXPECT_EQ(m3.columns_count(), m2.columns_count());
EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
}
TEST_F(UnitTestMat, AssignmentOperator_Move)
{
Mat<2, 2> m3;
m3 = std::move(m2);
EXPECT_EQ(m3.RowCount(), 2);
EXPECT_EQ(m3.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m3.At(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 4.0f);
EXPECT_EQ(m3.row_count(), 2);
EXPECT_EQ(m3.columns_count(), 2);
EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 4.0f);
// m2 is in a valid but unspecified state after move
}
// Test static methods
TEST_F(UnitTestMat, StaticMethod_ToScreenMat)
{
Mat<4, 4> screenMat = Mat<4, 4>::ToScreenMat(800.0f, 600.0f);
EXPECT_FLOAT_EQ(screenMat.At(0, 0), 400.0f);
EXPECT_FLOAT_EQ(screenMat.At(1, 1), -300.0f);
EXPECT_FLOAT_EQ(screenMat.At(3, 0), 400.0f);
EXPECT_FLOAT_EQ(screenMat.At(3, 1), 300.0f);
EXPECT_FLOAT_EQ(screenMat.At(3, 3), 1.0f);
Mat<4, 4> screenMat = Mat<4, 4>::to_screen_mat(800.0f, 600.0f);
EXPECT_FLOAT_EQ(screenMat.at(0, 0), 400.0f);
EXPECT_FLOAT_EQ(screenMat.at(1, 1), -300.0f);
EXPECT_FLOAT_EQ(screenMat.at(3, 0), 400.0f);
EXPECT_FLOAT_EQ(screenMat.at(3, 1), 300.0f);
EXPECT_FLOAT_EQ(screenMat.at(3, 3), 1.0f);
}
@@ -175,7 +175,7 @@ TEST_F(UnitTestMat, Method_At_OutOfRange)
// Test Determinant for 3x3 matrix
TEST(UnitTestMatStandalone, Determinant_3x3)
{
constexpr auto det = Mat<3, 3>{{6, 1, 1}, {4, -2, 5}, {2, 8, 7}}.Determinant();
constexpr auto det = Mat<3, 3>{{6, 1, 1}, {4, -2, 5}, {2, 8, 7}}.determinant();
EXPECT_FLOAT_EQ(det, -306.0f);
}
@@ -183,28 +183,28 @@ TEST(UnitTestMatStandalone, Determinant_3x3)
TEST(UnitTestMatStandalone, Strip_3x3)
{
constexpr Mat<3, 3> m{{3, 0, 2}, {2, 0, -2}, {0, 1, 1}};
auto minor = m.Strip(0, 0);
EXPECT_EQ(minor.RowCount(), 2);
EXPECT_EQ(minor.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(minor.At(0, 0), 0.0f);
EXPECT_FLOAT_EQ(minor.At(0, 1), -2.0f);
EXPECT_FLOAT_EQ(minor.At(1, 0), 1.0f);
EXPECT_FLOAT_EQ(minor.At(1, 1), 1.0f);
auto minor = m.strip(0, 0);
EXPECT_EQ(minor.row_count(), 2);
EXPECT_EQ(minor.columns_count(), 2);
EXPECT_FLOAT_EQ(minor.at(0, 0), 0.0f);
EXPECT_FLOAT_EQ(minor.at(0, 1), -2.0f);
EXPECT_FLOAT_EQ(minor.at(1, 0), 1.0f);
EXPECT_FLOAT_EQ(minor.at(1, 1), 1.0f);
}
// Test Transpose for non-square matrix
TEST(UnitTestMatStandalone, Transpose_NonSquare)
{
constexpr Mat<2, 3> m{{1.0f, 2.0f, 3.0f}, {4.0f, 5.0f, 6.0f}};
auto transposed = m.Transposed();
EXPECT_EQ(transposed.RowCount(), 3);
EXPECT_EQ(transposed.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(transposed.At(0, 0), 1.0f);
EXPECT_FLOAT_EQ(transposed.At(1, 0), 2.0f);
EXPECT_FLOAT_EQ(transposed.At(2, 0), 3.0f);
EXPECT_FLOAT_EQ(transposed.At(0, 1), 4.0f);
EXPECT_FLOAT_EQ(transposed.At(1, 1), 5.0f);
EXPECT_FLOAT_EQ(transposed.At(2, 1), 6.0f);
auto transposed = m.transposed();
EXPECT_EQ(transposed.row_count(), 3);
EXPECT_EQ(transposed.columns_count(), 2);
EXPECT_FLOAT_EQ(transposed.at(0, 0), 1.0f);
EXPECT_FLOAT_EQ(transposed.at(1, 0), 2.0f);
EXPECT_FLOAT_EQ(transposed.at(2, 0), 3.0f);
EXPECT_FLOAT_EQ(transposed.at(0, 1), 4.0f);
EXPECT_FLOAT_EQ(transposed.at(1, 1), 5.0f);
EXPECT_FLOAT_EQ(transposed.at(2, 1), 6.0f);
}
TEST(UnitTestMatStandalone, Enverse)
@@ -212,5 +212,5 @@ TEST(UnitTestMatStandalone, Enverse)
constexpr Mat<2, 2> m{{1.0f, 3.0f}, {2.0f, 5.0f}};
constexpr Mat<2,2> mv{{-5.0f, 3.0f}, {2.0f, -1.0f}};
EXPECT_EQ(mv, m.Inverted());
EXPECT_EQ(mv, m.inverted());
}

102
tests/general/unit_test_matrix.cpp
View File

@@ -25,8 +25,8 @@ protected:
TEST_F(UnitTestMatrix, Constructor_Size)
{
const Matrix m(3, 3);
EXPECT_EQ(m.RowCount(), 3);
EXPECT_EQ(m.ColumnsCount(), 3);
EXPECT_EQ(m.row_count(), 3);
EXPECT_EQ(m.columns_count(), 3);
}
TEST_F(UnitTestMatrix, Operator_SquareBrackets)
@@ -41,120 +41,120 @@ TEST_F(UnitTestMatrix, Operator_SquareBrackets)
TEST_F(UnitTestMatrix, Constructor_InitializerList)
{
Matrix m{{1.0f, 2.0f}, {3.0f, 4.0f}};
EXPECT_EQ(m.RowCount(), 2);
EXPECT_EQ(m.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m.At(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m.At(1, 1), 4.0f);
EXPECT_EQ(m.row_count(), 2);
EXPECT_EQ(m.columns_count(), 2);
EXPECT_FLOAT_EQ(m.at(0, 0), 1.0f);
EXPECT_FLOAT_EQ(m.at(1, 1), 4.0f);
}
TEST_F(UnitTestMatrix, Constructor_Copy)
{
Matrix m3 = m2;
EXPECT_EQ(m3.RowCount(), m2.RowCount());
EXPECT_EQ(m3.ColumnsCount(), m2.ColumnsCount());
EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
EXPECT_EQ(m3.row_count(), m2.row_count());
EXPECT_EQ(m3.columns_count(), m2.columns_count());
EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
}
TEST_F(UnitTestMatrix, Constructor_Move)
{
Matrix m3 = std::move(m2);
EXPECT_EQ(m3.RowCount(), 2);
EXPECT_EQ(m3.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m3.At(0, 0), 1.0f);
EXPECT_EQ(m2.RowCount(), 0); // m2 should be empty after the move
EXPECT_EQ(m2.ColumnsCount(), 0);
EXPECT_EQ(m3.row_count(), 2);
EXPECT_EQ(m3.columns_count(), 2);
EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
EXPECT_EQ(m2.row_count(), 0); // m2 should be empty after the move
EXPECT_EQ(m2.columns_count(), 0);
}
// Test matrix operations
TEST_F(UnitTestMatrix, Operator_Multiplication_Matrix)
{
Matrix m3 = m2 * m2;
EXPECT_EQ(m3.RowCount(), 2);
EXPECT_EQ(m3.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m3.At(0, 0), 7.0f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 22.0f);
EXPECT_EQ(m3.row_count(), 2);
EXPECT_EQ(m3.columns_count(), 2);
EXPECT_FLOAT_EQ(m3.at(0, 0), 7.0f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 22.0f);
}
TEST_F(UnitTestMatrix, Operator_Multiplication_Scalar)
{
Matrix m3 = m2 * 2.0f;
EXPECT_FLOAT_EQ(m3.At(0, 0), 2.0f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 8.0f);
EXPECT_FLOAT_EQ(m3.at(0, 0), 2.0f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 8.0f);
}
TEST_F(UnitTestMatrix, Operator_Division_Scalar)
{
Matrix m3 = m2 / 2.0f;
EXPECT_FLOAT_EQ(m3.At(0, 0), 0.5f);
EXPECT_FLOAT_EQ(m3.At(1, 1), 2.0f);
EXPECT_FLOAT_EQ(m3.at(0, 0), 0.5f);
EXPECT_FLOAT_EQ(m3.at(1, 1), 2.0f);
}
// Test matrix functions
TEST_F(UnitTestMatrix, Transpose)
{
Matrix m3 = m2.Transpose();
EXPECT_FLOAT_EQ(m3.At(0, 1), 3.0f);
EXPECT_FLOAT_EQ(m3.At(1, 0), 2.0f);
Matrix m3 = m2.transpose();
EXPECT_FLOAT_EQ(m3.at(0, 1), 3.0f);
EXPECT_FLOAT_EQ(m3.at(1, 0), 2.0f);
}
TEST_F(UnitTestMatrix, Determinant)
{
const float det = m2.Determinant();
const float det = m2.determinant();
EXPECT_FLOAT_EQ(det, -2.0f);
}
TEST_F(UnitTestMatrix, Minor)
{
const float minor = m2.Minor(0, 0);
const float minor = m2.minor(0, 0);
EXPECT_FLOAT_EQ(minor, 4.0f);
}
TEST_F(UnitTestMatrix, AlgComplement)
{
const float algComp = m2.AlgComplement(0, 0);
const float algComp = m2.alg_complement(0, 0);
EXPECT_FLOAT_EQ(algComp, 4.0f);
}
TEST_F(UnitTestMatrix, Strip)
{
Matrix m3 = m2.Strip(0, 0);
EXPECT_EQ(m3.RowCount(), 1);
EXPECT_EQ(m3.ColumnsCount(), 1);
EXPECT_FLOAT_EQ(m3.At(0, 0), 4.0f);
Matrix m3 = m2.strip(0, 0);
EXPECT_EQ(m3.row_count(), 1);
EXPECT_EQ(m3.columns_count(), 1);
EXPECT_FLOAT_EQ(m3.at(0, 0), 4.0f);
}
TEST_F(UnitTestMatrix, ProjectionMatrix)
{
const Matrix proj = Matrix::ProjectionMatrix(45.0f, 1.33f, 0.1f, 100.0f);
EXPECT_EQ(proj.RowCount(), 4);
EXPECT_EQ(proj.ColumnsCount(), 4);
const Matrix proj = Matrix::projection_matrix(45.0f, 1.33f, 0.1f, 100.0f);
EXPECT_EQ(proj.row_count(), 4);
EXPECT_EQ(proj.columns_count(), 4);
// Further checks on projection matrix elements could be added
}
// Test other member functions
TEST_F(UnitTestMatrix, Set)
{
m1.Set(3.0f);
EXPECT_FLOAT_EQ(m1.At(0, 0), 3.0f);
EXPECT_FLOAT_EQ(m1.At(1, 1), 3.0f);
m1.set(3.0f);
EXPECT_FLOAT_EQ(m1.at(0, 0), 3.0f);
EXPECT_FLOAT_EQ(m1.at(1, 1), 3.0f);
}
TEST_F(UnitTestMatrix, Sum)
{
const float sum = m2.Sum();
const float sum = m2.sum();
EXPECT_FLOAT_EQ(sum, 10.0f);
}
TEST_F(UnitTestMatrix, Clear)
{
m2.Clear();
EXPECT_FLOAT_EQ(m2.At(0, 0), 0.0f);
EXPECT_FLOAT_EQ(m2.At(1, 1), 0.0f);
m2.clear();
EXPECT_FLOAT_EQ(m2.at(0, 0), 0.0f);
EXPECT_FLOAT_EQ(m2.at(1, 1), 0.0f);
}
TEST_F(UnitTestMatrix, ToString)
{
const std::string str = m2.ToString();
const std::string str = m2.to_string();
EXPECT_FALSE(str.empty());
}
@@ -163,18 +163,18 @@ TEST_F(UnitTestMatrix, AssignmentOperator_Copy)
{
Matrix m3(2, 2);
m3 = m2;
EXPECT_EQ(m3.RowCount(), m2.RowCount());
EXPECT_EQ(m3.ColumnsCount(), m2.ColumnsCount());
EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
EXPECT_EQ(m3.row_count(), m2.row_count());
EXPECT_EQ(m3.columns_count(), m2.columns_count());
EXPECT_FLOAT_EQ(m3.at(0, 0), m2.at(0, 0));
}
TEST_F(UnitTestMatrix, AssignmentOperator_Move)
{
Matrix m3(2, 2);
m3 = std::move(m2);
EXPECT_EQ(m3.RowCount(), 2);
EXPECT_EQ(m3.ColumnsCount(), 2);
EXPECT_FLOAT_EQ(m3.At(0, 0), 1.0f);
EXPECT_EQ(m2.RowCount(), 0); // m2 should be empty after the move
EXPECT_EQ(m2.ColumnsCount(), 0);
EXPECT_EQ(m3.row_count(), 2);
EXPECT_EQ(m3.columns_count(), 2);
EXPECT_FLOAT_EQ(m3.at(0, 0), 1.0f);
EXPECT_EQ(m2.row_count(), 0); // m2 should be empty after the move
EXPECT_EQ(m2.columns_count(), 0);
}

8
tests/general/unit_test_prediction.cpp
View File

@@ -4,13 +4,13 @@
TEST(UnitTestPrediction, PredictionTest)
{
constexpr omath::projectile_prediction::Target target{
.m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_isAirborne = false};
.m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
constexpr omath::projectile_prediction::Projectile proj = {
.m_origin = {3, 2, 1}, .m_launchSpeed = 5000, .m_gravityScale = 0.4};
.m_origin = {3, 2, 1}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
const auto viewPoint =
omath::projectile_prediction::ProjPredEngineLegacy(400, 1.f / 1000.f, 50, 5.f).MaybeCalculateAimPoint(proj, target);
omath::projectile_prediction::ProjPredEngineLegacy(400, 1.f / 1000.f, 50, 5.f).maybe_calculate_aim_point(proj, target);
const auto [pitch, yaw, _] = proj.m_origin.ViewAngleTo(viewPoint.value()).AsTuple();
const auto [pitch, yaw, _] = proj.m_origin.view_angle_to(viewPoint.value()).as_tuple();
EXPECT_NEAR(42.547142, pitch, 0.01f);
EXPECT_NEAR(-1.181189, yaw, 0.01f);

4
tests/general/unit_test_projection.cpp
View File

@@ -9,9 +9,9 @@
TEST(UnitTestProjection, Projection)
{
const auto x = omath::Angle<float, 0.f, 180.f, omath::AngleFlags::Clamped>::FromDegrees(90.f);
const auto x = omath::Angle<float, 0.f, 180.f, omath::AngleFlags::Clamped>::from_degrees(90.f);
auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, x, 0.01f, 1000.f);
const auto projected = cam.WorldToScreen({1000, 0, 50});
const auto projected = cam.world_to_screen({1000, 0, 50});
std::print("{} {} {}", projected->x, projected->y, projected->z);
}

26
tests/general/unit_test_triangle.cpp
View File

@@ -68,14 +68,14 @@ TEST_F(UnitTestTriangle, Constructor)
TEST_F(UnitTestTriangle, CalculateNormal)
{
// For t1, the normal should point in the +Z direction (0, 0, 1) or (0, 0, -1)
const Vector3 normal_t1 = t1.CalculateNormal();
const Vector3 normal_t1 = t1.calculate_normal();
// Check if it's normalized and pointed along Z (sign can differ, so use absolute check)
EXPECT_NEAR(std::fabs(normal_t1.z), 1.0f, 1e-5f);
EXPECT_NEAR(normal_t1.Length(), 1.0f, 1e-5f);
EXPECT_NEAR(normal_t1.length(), 1.0f, 1e-5f);
// For t3, we expect the normal to be along +Z as well
const Vector3 normal_t3 = t3.CalculateNormal();
const Vector3 normal_t3 = t3.calculate_normal();
EXPECT_NEAR(std::fabs(normal_t3.z), 1.0f, 1e-5f);
}
@@ -83,29 +83,29 @@ TEST_F(UnitTestTriangle, CalculateNormal)
TEST_F(UnitTestTriangle, SideLengths)
{
// For t1 side lengths
EXPECT_FLOAT_EQ(t1.SideALength(), std::sqrt(1.0f)); // distance between (0,0,0) and (1,0,0)
EXPECT_FLOAT_EQ(t1.SideBLength(), std::sqrt(1.0f + 1.0f)); // distance between (4,5,6) & (7,8,9)... but we are testing t1, so let's be accurate:
EXPECT_FLOAT_EQ(t1.side_a_length(), std::sqrt(1.0f)); // distance between (0,0,0) and (1,0,0)
EXPECT_FLOAT_EQ(t1.side_b_length(), std::sqrt(1.0f + 1.0f)); // distance between (4,5,6) & (7,8,9)... but we are testing t1, so let's be accurate:
// Actually, for t1: vertex2=(1,0,0), vertex3=(0,1,0)
// Dist between (0,1,0) and (1,0,0) = sqrt((1-0)^2 + (0-1)^2) = sqrt(1 + 1) = sqrt(2)
EXPECT_FLOAT_EQ(t1.SideBLength(), std::sqrt(2.0f));
EXPECT_FLOAT_EQ(t1.side_b_length(), std::sqrt(2.0f));
// For t3, side a = distance between vertex1=(0,0,0) and vertex2=(2,0,0), which is 2
// side b = distance between vertex3=(0,2,0) and vertex2=(2,0,0), which is sqrt(2^2 + (-2)^2)= sqrt(8)= 2.828...
// We'll just check side a first:
EXPECT_FLOAT_EQ(t3.SideALength(), 2.0f);
EXPECT_FLOAT_EQ(t3.side_a_length(), 2.0f);
// Then side b:
EXPECT_FLOAT_EQ(t3.SideBLength(), std::sqrt(8.0f));
EXPECT_FLOAT_EQ(t3.side_b_length(), std::sqrt(8.0f));
}
// Test side vectors
TEST_F(UnitTestTriangle, SideVectors)
{
const Vector3 sideA_t1 = t1.SideAVector(); // m_vertex1 - m_vertex2
const Vector3 sideA_t1 = t1.side_a_vector(); // m_vertex1 - m_vertex2
EXPECT_FLOAT_EQ(sideA_t1.x, 0.0f - 1.0f);
EXPECT_FLOAT_EQ(sideA_t1.y, 0.0f - 0.0f);
EXPECT_FLOAT_EQ(sideA_t1.z, 0.0f - 0.0f);
const Vector3 sideB_t1 = t1.SideBVector(); // m_vertex3 - m_vertex2
const Vector3 sideB_t1 = t1.side_b_vector(); // m_vertex3 - m_vertex2
EXPECT_FLOAT_EQ(sideB_t1.x, 0.0f - 1.0f);
EXPECT_FLOAT_EQ(sideB_t1.y, 1.0f - 0.0f);
EXPECT_FLOAT_EQ(sideB_t1.z, 0.0f - 0.0f);
@@ -113,19 +113,19 @@ TEST_F(UnitTestTriangle, SideVectors)
TEST_F(UnitTestTriangle, IsRectangular)
{
EXPECT_TRUE(Triangle<Vector3<float>>({2,0,0}, {}, {0,2,0}).IsRectangular());
EXPECT_TRUE(Triangle<Vector3<float>>({2,0,0}, {}, {0,2,0}).is_rectangular());
}
// Test midpoint
TEST_F(UnitTestTriangle, MidPoint)
{
// For t1, midpoint of (0,0,0), (1,0,0), (0,1,0)
const Vector3 mid1 = t1.MidPoint();
const Vector3 mid1 = t1.mid_point();
EXPECT_FLOAT_EQ(mid1.x, (0.0f + 1.0f + 0.0f) / 3.0f);
EXPECT_FLOAT_EQ(mid1.y, (0.0f + 0.0f + 1.0f) / 3.0f);
EXPECT_FLOAT_EQ(mid1.z, 0.0f);
// For t2, midpoint of (1,2,3), (4,5,6), (7,8,9)
const Vector3 mid2 = t2.MidPoint();
const Vector3 mid2 = t2.mid_point();
EXPECT_FLOAT_EQ(mid2.x, (1.0f + 4.0f + 7.0f) / 3.0f);
EXPECT_FLOAT_EQ(mid2.y, (2.0f + 5.0f + 8.0f) / 3.0f);
EXPECT_FLOAT_EQ(mid2.z, (3.0f + 6.0f + 9.0f) / 3.0f);

46
tests/general/unit_test_vector2.cpp
View File

@@ -150,76 +150,76 @@ TEST_F(UnitTestVector2, SubtractionAssignmentOperator_Float)
// Test other member functions
TEST_F(UnitTestVector2, DistTo)
{
const float dist = v1.DistTo(v2);
const float dist = v1.distance_to(v2);
EXPECT_FLOAT_EQ(dist, std::sqrt(18.0f));
}
TEST_F(UnitTestVector2, DistTo_SamePoint)
{
const float dist = v1.DistTo(v1);
const float dist = v1.distance_to(v1);
EXPECT_FLOAT_EQ(dist, 0.0f);
}
TEST_F(UnitTestVector2, DistToSqr)
{
constexpr float distSqr = Vector2(1.0f, 2.0f).DistToSqr(Vector2(4.0f, 5.0f));
constexpr float distSqr = Vector2(1.0f, 2.0f).distance_to_sqr(Vector2(4.0f, 5.0f));
EXPECT_FLOAT_EQ(distSqr, 18.0f);
}
TEST_F(UnitTestVector2, DistToSqr_SamePoint)
{
constexpr float distSqr = Vector2(1.0f, 2.0f).DistToSqr(Vector2(1.0f, 2.0f));
constexpr float distSqr = Vector2(1.0f, 2.0f).distance_to_sqr(Vector2(1.0f, 2.0f));
EXPECT_FLOAT_EQ(distSqr, 0.0f);
}
TEST_F(UnitTestVector2, DotProduct)
{
constexpr float dot = Vector2(1.0f, 2.0f).Dot(Vector2(4.0f, 5.0f));
constexpr float dot = Vector2(1.0f, 2.0f).dot(Vector2(4.0f, 5.0f));
EXPECT_FLOAT_EQ(dot, 14.0f);
}
TEST_F(UnitTestVector2, DotProduct_PerpendicularVectors)
{
constexpr float dot = Vector2(1.0f, 0.0f).Dot(Vector2(0.0f, 1.0f));
constexpr float dot = Vector2(1.0f, 0.0f).dot(Vector2(0.0f, 1.0f));
EXPECT_FLOAT_EQ(dot, 0.0f);
}
TEST_F(UnitTestVector2, DotProduct_ParallelVectors)
{
constexpr float dot = Vector2(1.0f, 1.0f).Dot(Vector2(2.0f, 2.0f));
constexpr float dot = Vector2(1.0f, 1.0f).dot(Vector2(2.0f, 2.0f));
EXPECT_FLOAT_EQ(dot, 4.0f);
}
TEST_F(UnitTestVector2, Length)
{
const float length = v1.Length();
const float length = v1.length();
EXPECT_FLOAT_EQ(length, std::sqrt(5.0f));
}
TEST_F(UnitTestVector2, Length_ZeroVector)
{
constexpr Vector2 v_zero(0.0f, 0.0f);
const float length = v_zero.Length();
const float length = v_zero.length();
EXPECT_FLOAT_EQ(length, 0.0f);
}
TEST_F(UnitTestVector2, Length_LargeValues)
{
constexpr Vector2 v_large(FLT_MAX, FLT_MAX);
const float length = v_large.Length();
const float length = v_large.length();
EXPECT_TRUE(std::isinf(length));
}
TEST_F(UnitTestVector2, LengthSqr)
{
constexpr float lengthSqr = Vector2(1.0f, 2.0f).LengthSqr();
constexpr float lengthSqr = Vector2(1.0f, 2.0f).length_sqr();
EXPECT_FLOAT_EQ(lengthSqr, 5.0f);
}
TEST_F(UnitTestVector2, Abs)
{
Vector2 v3(-1.0f, -2.0f);
v3.Abs();
v3.abs();
EXPECT_FLOAT_EQ(v3.x, 1.0f);
EXPECT_FLOAT_EQ(v3.y, 2.0f);
}
@@ -227,7 +227,7 @@ TEST_F(UnitTestVector2, Abs)
TEST_F(UnitTestVector2, Abs_PositiveValues)
{
Vector2 v3(1.0f, 2.0f);
v3.Abs();
v3.abs();
EXPECT_FLOAT_EQ(v3.x, 1.0f);
EXPECT_FLOAT_EQ(v3.y, 2.0f);
}
@@ -235,26 +235,26 @@ TEST_F(UnitTestVector2, Abs_PositiveValues)
TEST_F(UnitTestVector2, Abs_ZeroValues)
{
Vector2 v3(0.0f, 0.0f);
v3.Abs();
v3.abs();
EXPECT_FLOAT_EQ(v3.x, 0.0f);
EXPECT_FLOAT_EQ(v3.y, 0.0f);
}
TEST_F(UnitTestVector2, Sum)
{
constexpr float sum = Vector2(1.0f, 2.0f).Sum();
constexpr float sum = Vector2(1.0f, 2.0f).sum();
EXPECT_FLOAT_EQ(sum, 3.0f);
}
TEST_F(UnitTestVector2, Sum_NegativeValues)
{
constexpr float sum = Vector2(-1.0f, -2.0f).Sum();
constexpr float sum = Vector2(-1.0f, -2.0f).sum();
EXPECT_FLOAT_EQ(sum, -3.0f);
}
TEST_F(UnitTestVector2, Normalized)
{
const Vector2 v3 = v1.Normalized();
const Vector2 v3 = v1.normalized();
EXPECT_NEAR(v3.x, 0.44721f, 0.0001f);
EXPECT_NEAR(v3.y, 0.89443f, 0.0001f);
}
@@ -262,7 +262,7 @@ TEST_F(UnitTestVector2, Normalized)
TEST_F(UnitTestVector2, Normalized_ZeroVector)
{
constexpr Vector2 v_zero(0.0f, 0.0f);
const Vector2 v_norm = v_zero.Normalized();
const Vector2 v_norm = v_zero.normalized();
EXPECT_FLOAT_EQ(v_norm.x, 0.0f);
EXPECT_FLOAT_EQ(v_norm.y, 0.0f);
}
@@ -270,7 +270,7 @@ TEST_F(UnitTestVector2, Normalized_ZeroVector)
// Test AsTuple method
TEST_F(UnitTestVector2, AsTuple)
{
const auto tuple = v1.AsTuple();
const auto tuple = v1.as_tuple();
EXPECT_FLOAT_EQ(std::get<0>(tuple), v1.x);
EXPECT_FLOAT_EQ(std::get<1>(tuple), v1.y);
}
@@ -347,7 +347,7 @@ TEST_F(UnitTestVector2, NegationOperator_ZeroVector)
}
// Static assertions (compile-time checks)
static_assert(Vector2(1.0f, 2.0f).LengthSqr() == 5.0f, "LengthSqr should be 5");
static_assert(Vector2(1.0f, 2.0f).Dot(Vector2(4.0f, 5.0f)) == 14.0f, "Dot product should be 14");
static_assert(Vector2(4.0f, 5.0f).DistToSqr(Vector2(1.0f, 2.0f)) == 18.0f, "DistToSqr should be 18");
static_assert(Vector2(-1.0f, -2.0f).Abs() == Vector2(1.0f, 2.0f), "Abs should convert negative values to positive");
static_assert(Vector2(1.0f, 2.0f).length_sqr() == 5.0f, "LengthSqr should be 5");
static_assert(Vector2(1.0f, 2.0f).dot(Vector2(4.0f, 5.0f)) == 14.0f, "Dot product should be 14");
static_assert(Vector2(4.0f, 5.0f).distance_to_sqr(Vector2(1.0f, 2.0f)) == 18.0f, "DistToSqr should be 18");
static_assert(Vector2(-1.0f, -2.0f).abs() == Vector2(1.0f, 2.0f), "Abs should convert negative values to positive");

54
tests/general/unit_test_vector3.cpp
View File

@@ -164,26 +164,26 @@ TEST_F(UnitTestVector3, NegationOperator)
// Test other member functions
TEST_F(UnitTestVector3, DistToSqr)
{
constexpr auto distSqr = Vector3(1.0f, 2.0f, 3.0f).DistToSqr(Vector3(4.0f, 5.0f, 6.0f));
constexpr auto distSqr = Vector3(1.0f, 2.0f, 3.0f).distance_to_sqr(Vector3(4.0f, 5.0f, 6.0f));
EXPECT_FLOAT_EQ(distSqr, 27.0f);
}
TEST_F(UnitTestVector3, DotProduct)
{
constexpr auto dot = Vector3(1.0f, 2.0f, 3.0f).Dot(Vector3(4.0f, 5.0f, 6.0f));
constexpr auto dot = Vector3(1.0f, 2.0f, 3.0f).dot(Vector3(4.0f, 5.0f, 6.0f));
EXPECT_FLOAT_EQ(dot, 32.0f);
}
TEST_F(UnitTestVector3, LengthSqr)
{
constexpr auto lengthSqr = Vector3(1.0f, 2.0f, 3.0f).LengthSqr();
constexpr auto lengthSqr = Vector3(1.0f, 2.0f, 3.0f).length_sqr();
EXPECT_FLOAT_EQ(lengthSqr, 14.0f);
}
TEST_F(UnitTestVector3, Abs)
{
auto v3 = Vector3(-1.0f, -2.0f, -3.0f);
v3.Abs();
v3.abs();
EXPECT_FLOAT_EQ(v3.x, 1.0f);
EXPECT_FLOAT_EQ(v3.y, 2.0f);
EXPECT_FLOAT_EQ(v3.z, 3.0f);
@@ -191,19 +191,19 @@ TEST_F(UnitTestVector3, Abs)
TEST_F(UnitTestVector3, Sum)
{
constexpr auto sum = Vector3(1.0f, 2.0f, 3.0f).Sum();
constexpr auto sum = Vector3(1.0f, 2.0f, 3.0f).sum();
EXPECT_FLOAT_EQ(sum, 6.0f);
}
TEST_F(UnitTestVector3, Sum2D)
{
constexpr auto sum2D = Vector3(1.0f, 2.0f, 3.0f).Sum2D();
constexpr auto sum2D = Vector3(1.0f, 2.0f, 3.0f).sum_2d();
EXPECT_FLOAT_EQ(sum2D, 3.0f);
}
TEST_F(UnitTestVector3, CrossProduct)
{
constexpr Vector3 v3 = Vector3(1.0f, 2.0f, 3.0f).Cross(Vector3(4.0f, 5.0f, 6.0f));
constexpr Vector3 v3 = Vector3(1.0f, 2.0f, 3.0f).cross(Vector3(4.0f, 5.0f, 6.0f));
EXPECT_FLOAT_EQ(v3.x, -3.0f);
EXPECT_FLOAT_EQ(v3.y, 6.0f);
EXPECT_FLOAT_EQ(v3.z, -3.0f);
@@ -298,41 +298,41 @@ TEST_F(UnitTestVector3, Division_WithNaN)
// Test Length, Length2D, and Normalized
TEST_F(UnitTestVector3, Length)
{
const float length = v1.Length();
const float length = v1.length();
EXPECT_FLOAT_EQ(length, std::sqrt(14.0f));
}
TEST_F(UnitTestVector3, Length_ZeroVector)
{
constexpr Vector3 v_zero(0.0f, 0.0f, 0.0f);
const float length = v_zero.Length();
const float length = v_zero.length();
EXPECT_FLOAT_EQ(length, 0.0f);
}
TEST_F(UnitTestVector3, Length_LargeValues)
{
constexpr Vector3 v_large(FLT_MAX, FLT_MAX, FLT_MAX);
const float length = v_large.Length();
const float length = v_large.length();
EXPECT_TRUE(std::isinf(length));
}
TEST_F(UnitTestVector3, Length2D)
{
const float length2D = v1.Length2D();
const float length2D = v1.length_2d();
EXPECT_FLOAT_EQ(length2D, std::sqrt(5.0f));
}
TEST_F(UnitTestVector3, Normalized)
{
const Vector3 v_norm = v1.Normalized();
const float length = v_norm.Length();
const Vector3 v_norm = v1.normalized();
const float length = v_norm.length();
EXPECT_NEAR(length, 1.0f, 0.0001f);
}
TEST_F(UnitTestVector3, Normalized_ZeroVector)
{
constexpr Vector3 v_zero(0.0f, 0.0f, 0.0f);
const Vector3 v_norm = v_zero.Normalized();
const Vector3 v_norm = v_zero.normalized();
EXPECT_FLOAT_EQ(v_norm.x, 0.0f);
EXPECT_FLOAT_EQ(v_norm.y, 0.0f);
EXPECT_FLOAT_EQ(v_norm.z, 0.0f);
@@ -343,7 +343,7 @@ TEST_F(UnitTestVector3, CrossProduct_ParallelVectors)
{
constexpr Vector3 v_a(1.0f, 2.0f, 3.0f);
constexpr Vector3 v_b = v_a * 2.0f; // Parallel to v_a
constexpr Vector3 cross = v_a.Cross(v_b);
constexpr Vector3 cross = v_a.cross(v_b);
EXPECT_FLOAT_EQ(cross.x, 0.0f);
EXPECT_FLOAT_EQ(cross.y, 0.0f);
EXPECT_FLOAT_EQ(cross.z, 0.0f);
@@ -353,7 +353,7 @@ TEST_F(UnitTestVector3, CrossProduct_OrthogonalVectors)
{
constexpr Vector3 v_a(1.0f, 0.0f, 0.0f);
constexpr Vector3 v_b(0.0f, 1.0f, 0.0f);
constexpr Vector3 cross = v_a.Cross(v_b);
constexpr Vector3 cross = v_a.cross(v_b);
EXPECT_FLOAT_EQ(cross.x, 0.0f);
EXPECT_FLOAT_EQ(cross.y, 0.0f);
EXPECT_FLOAT_EQ(cross.z, 1.0f);
@@ -381,7 +381,7 @@ TEST_F(UnitTestVector3, Subtraction_NegativeValues)
// Test AsTuple method
TEST_F(UnitTestVector3, AsTuple)
{
const auto tuple = v1.AsTuple();
const auto tuple = v1.as_tuple();
EXPECT_FLOAT_EQ(std::get<0>(tuple), v1.x);
EXPECT_FLOAT_EQ(std::get<1>(tuple), v1.y);
EXPECT_FLOAT_EQ(std::get<2>(tuple), v1.z);
@@ -390,20 +390,20 @@ TEST_F(UnitTestVector3, AsTuple)
// Test AsTuple method
TEST_F(UnitTestVector3, AngleBeatween)
{
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).AngleBetween({1, 0 ,0}).value().AsDegrees(), 90.0f);
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).AngleBetween({0.0f, 0.0f, 1.0f}).value().AsDegrees(), 0.0f);
EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).AngleBetween({0.0f, 0.0f, 1.0f}).has_value());
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).angle_between({1, 0 ,0}).value().as_degrees(), 90.0f);
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).angle_between({0.0f, 0.0f, 1.0f}).value().as_degrees(), 0.0f);
EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).angle_between({0.0f, 0.0f, 1.0f}).has_value());
}
TEST_F(UnitTestVector3, IsPerpendicular)
{
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).IsPerpendicular({1, 0 ,0}), true);
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).IsPerpendicular({0.0f, 0.0f, 1.0f}), false);
EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).IsPerpendicular({0.0f, 0.0f, 1.0f}));
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).is_perpendicular({1, 0 ,0}), true);
EXPECT_EQ(Vector3(0.0f, 0.0f, 1.0f).is_perpendicular({0.0f, 0.0f, 1.0f}), false);
EXPECT_FALSE(Vector3(0.0f, 0.0f, 0.0f).is_perpendicular({0.0f, 0.0f, 1.0f}));
}
// Static assertions (compile-time checks)
static_assert(Vector3(1.0f, 2.0f, 3.0f).LengthSqr() == 14.0f, "LengthSqr should be 14");
static_assert(Vector3(1.0f, 2.0f, 3.0f).Dot(Vector3(4.0f, 5.0f, 6.0f)) == 32.0f, "Dot product should be 32");
static_assert(Vector3(4.0f, 5.0f, 6.0f).DistToSqr(Vector3(1.0f, 2.0f, 3.0f)) == 27.0f, "DistToSqr should be 27");
static_assert(Vector3(-1.0f, -2.0f, -3.0f).Abs() == Vector3(1.0f, 2.0f, 3.0f), "Abs should convert negative values to positive");
static_assert(Vector3(1.0f, 2.0f, 3.0f).length_sqr() == 14.0f, "LengthSqr should be 14");
static_assert(Vector3(1.0f, 2.0f, 3.0f).dot(Vector3(4.0f, 5.0f, 6.0f)) == 32.0f, "Dot product should be 32");
static_assert(Vector3(4.0f, 5.0f, 6.0f).distance_to_sqr(Vector3(1.0f, 2.0f, 3.0f)) == 27.0f, "DistToSqr should be 27");
static_assert(Vector3(-1.0f, -2.0f, -3.0f).abs() == Vector3(1.0f, 2.0f, 3.0f), "Abs should convert negative values to positive");

10
tests/general/unit_test_vector4.cpp
View File

@@ -180,20 +180,20 @@ TEST_F(UnitTestVector4, NegationOperator)
// Test other member functions
TEST_F(UnitTestVector4, LengthSqr)
{
constexpr float lengthSqr = Vector4(1.0f, 2.0f, 3.0f, 4.0f).LengthSqr();
constexpr float lengthSqr = Vector4(1.0f, 2.0f, 3.0f, 4.0f).length_sqr();
EXPECT_FLOAT_EQ(lengthSqr, 30.0f);
}
TEST_F(UnitTestVector4, DotProduct)
{
constexpr float dot = Vector4(1.0f, 2.0f, 3.0f, 4.0f).Dot(Vector4(4.0f, 5.0f, 6.0f, 7.0f));
constexpr float dot = Vector4(1.0f, 2.0f, 3.0f, 4.0f).dot(Vector4(4.0f, 5.0f, 6.0f, 7.0f));
EXPECT_FLOAT_EQ(dot, 60.0f);
}
TEST_F(UnitTestVector4, Abs)
{
Vector4 v3 = Vector4(-1.0f, -2.0f, -3.0f, -4.0f);
v3.Abs();
v3.abs();
EXPECT_FLOAT_EQ(v3.x, 1.0f);
EXPECT_FLOAT_EQ(v3.y, 2.0f);
EXPECT_FLOAT_EQ(v3.z, 3.0f);
@@ -202,14 +202,14 @@ TEST_F(UnitTestVector4, Abs)
TEST_F(UnitTestVector4, Sum)
{
constexpr float sum = Vector4(1.0f, 2.0f, 3.0f, 4.0f).Sum();
constexpr float sum = Vector4(1.0f, 2.0f, 3.0f, 4.0f).sum();
EXPECT_FLOAT_EQ(sum, 10.0f);
}
TEST_F(UnitTestVector4, Clamp)
{
Vector4 v3 = Vector4(1.0f, 2.0f, 3.0f, 4.0f);
v3.Clamp(1.5f, 2.5f);
v3.clamp(1.5f, 2.5f);
EXPECT_FLOAT_EQ(v3.x, 1.5f);
EXPECT_FLOAT_EQ(v3.y, 2.0f);
EXPECT_FLOAT_EQ(v3.z, 2.5f);