diff --git a/.clang-format b/.clang-format index d074535..402faea 100644 --- a/.clang-format +++ b/.clang-format @@ -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 \ No newline at end of file diff --git a/include/omath/3d_primitives/box.hpp b/include/omath/3d_primitives/box.hpp index 0f18c40..23a5967 100644 --- a/include/omath/3d_primitives/box.hpp +++ b/include/omath/3d_primitives/box.hpp @@ -11,7 +11,7 @@ namespace omath::primitives { [[nodiscard]] - std::array>, 12> CreateBox(const Vector3& top, const Vector3& bottom, - const Vector3& dirForward, const Vector3& dirRight, + std::array>, 12> create_box(const Vector3& top, const Vector3& bottom, + const Vector3& dir_forward, const Vector3& dir_right, float ratio = 4.f); } diff --git a/include/omath/angle.hpp b/include/omath/angle.hpp index 11d36d9..61e75d0 100644 --- a/include/omath/angle.hpp +++ b/include/omath/angle.hpp @@ -3,10 +3,9 @@ // #pragma once +#include "omath/angles.hpp" #include #include -#include "omath/angles.hpp" - namespace omath { @@ -17,14 +16,14 @@ namespace omath }; template - requires std::is_arithmetic_v + requires std::is_arithmetic_v 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(degrees)}; + return Angle{angles::radians_to_degrees(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)}; diff --git a/include/omath/angles.hpp b/include/omath/angles.hpp index 11a69d4..cafacbb 100644 --- a/include/omath/angles.hpp +++ b/include/omath/angles.hpp @@ -10,54 +10,55 @@ namespace omath::angles { template requires std::is_floating_point_v - [[nodiscard]] constexpr Type RadiansToDegrees(const Type& radians) + [[nodiscard]] constexpr Type radians_to_degrees(const Type& radians) { - return radians * (Type(180) / std::numbers::pi_v); + return radians * (static_cast(180) / std::numbers::pi_v); } template requires std::is_floating_point_v - [[nodiscard]] constexpr Type DegreesToRadians(const Type& degrees) + [[nodiscard]] constexpr Type degrees_to_radians(const Type& degrees) { - return degrees * (std::numbers::pi_v / Type(180)); - } - - template - requires std::is_floating_point_v - [[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 / static_cast(180)); } template requires std::is_floating_point_v - [[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(2) * std::atan(std::tan(fov_rad / static_cast(2)) / aspect); - return RadiansToDegrees(horFov); + return radians_to_degrees(vert_fov); + } + + template + requires std::is_floating_point_v + [[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(2) * std::atan(std::tan(fov_as_radians / static_cast(2)) * aspect); + + return radians_to_degrees(horizontal_fov); } template requires std::is_arithmetic_v - [[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 diff --git a/include/omath/collision/line_tracer.hpp b/include/omath/collision/line_tracer.hpp index cd7a87a..6a655b0 100644 --- a/include/omath/collision/line_tracer.hpp +++ b/include/omath/collision/line_tracer.hpp @@ -14,25 +14,24 @@ namespace omath::collision Vector3 start; Vector3 end; bool infinite_length = false; - [[nodiscard]] - Vector3 DirectionVector() const; [[nodiscard]] - Vector3 DirectionVectorNormalized() const; + Vector3 direction_vector() const; + + [[nodiscard]] + Vector3 direction_vector_normalized() const; }; class LineTracer { public: LineTracer() = delete; - [[nodiscard]] - static bool CanTraceLine(const Ray& ray, const Triangle>& triangle); - + static bool can_trace_line(const Ray& ray, const Triangle>& triangle); // Realization of Möller–Trumbore intersection algorithm // https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm [[nodiscard]] - static Vector3 GetRayHitPoint(const Ray& ray, const Triangle>& triangle); + static Vector3 get_ray_hit_point(const Ray& ray, const Triangle>& triangle); }; -} +} // namespace omath::collision diff --git a/include/omath/color.hpp b/include/omath/color.hpp index 48a02df..e460059 100644 --- a/include/omath/color.hpp +++ b/include/omath/color.hpp @@ -4,95 +4,93 @@ #pragma once -#include #include "omath/vector3.hpp" #include "omath/vector4.hpp" +#include #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 { 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(hue * 6.f); - const float f = hue * 6 - i; + const float f = hue * 6.f - static_cast(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}; } diff --git a/include/omath/engines/iw_engine/camera.hpp b/include/omath/engines/iw_engine/camera.hpp index 844ff5d..ea59474 100644 --- a/include/omath/engines/iw_engine/camera.hpp +++ b/include/omath/engines/iw_engine/camera.hpp @@ -8,14 +8,15 @@ namespace omath::iw_engine { - class Camera final : public projection::Camera + class Camera final : public projection::Camera { public: - Camera(const Vector3& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort, + Camera(const Vector3& position, const ViewAngles& view_angles, const projection::ViewPort& view_port, const Angle& fov, float near, float far); - void LookAt(const Vector3& target) override; + void look_at(const Vector3& 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; }; -} \ No newline at end of file +} // namespace omath::iw_engine \ No newline at end of file diff --git a/include/omath/engines/iw_engine/constants.hpp b/include/omath/engines/iw_engine/constants.hpp index ff7d41d..48e29c1 100644 --- a/include/omath/engines/iw_engine/constants.hpp +++ b/include/omath/engines/iw_engine/constants.hpp @@ -3,23 +3,23 @@ // #pragma once -#include -#include #include +#include +#include #include namespace omath::iw_engine { - constexpr Vector3 kAbsUp = {0, 0, 1}; - constexpr Vector3 kAbsRight = {0, -1, 0}; - constexpr Vector3 kAbsForward = {1, 0, 0}; + constexpr Vector3 k_abs_up = {0, 0, 1}; + constexpr Vector3 k_abs_right = {0, -1, 0}; + constexpr Vector3 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; using YawAngle = Angle; using RollAngle = Angle; using ViewAngles = omath::ViewAngles; -} \ No newline at end of file +} // namespace omath::iw_engine \ No newline at end of file diff --git a/include/omath/engines/iw_engine/formulas.hpp b/include/omath/engines/iw_engine/formulas.hpp index 60d1fee..424621f 100644 --- a/include/omath/engines/iw_engine/formulas.hpp +++ b/include/omath/engines/iw_engine/formulas.hpp @@ -8,19 +8,19 @@ namespace omath::iw_engine { [[nodiscard]] - Vector3 ForwardVector(const ViewAngles& angles); + Vector3 forward_vector(const ViewAngles& angles); [[nodiscard]] - Vector3 RightVector(const ViewAngles& angles); + Vector3 right_vector(const ViewAngles& angles); [[nodiscard]] - Vector3 UpVector(const ViewAngles& angles); + Vector3 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& cam_origin); + [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& 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 diff --git a/include/omath/engines/opengl_engine/camera.hpp b/include/omath/engines/opengl_engine/camera.hpp index bfee7c4..605ee44 100644 --- a/include/omath/engines/opengl_engine/camera.hpp +++ b/include/omath/engines/opengl_engine/camera.hpp @@ -7,13 +7,13 @@ namespace omath::opengl_engine { - class Camera final : public projection::Camera + class Camera final : public projection::Camera { public: - Camera(const Vector3& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort, + Camera(const Vector3& position, const ViewAngles& view_angles, const projection::ViewPort& view_port, const Angle& fov, float near, float far); - void LookAt(const Vector3& target) override; - [[nodiscard]] Mat4x4 CalcViewMatrix() const override; - [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override; + void look_at(const Vector3& target) override; + [[nodiscard]] Mat4X4 calc_view_matrix() const override; + [[nodiscard]] Mat4X4 calc_projection_matrix() const override; }; -} \ No newline at end of file +} // namespace omath::opengl_engine \ No newline at end of file diff --git a/include/omath/engines/opengl_engine/constants.hpp b/include/omath/engines/opengl_engine/constants.hpp index 3e0a762..ff62f46 100644 --- a/include/omath/engines/opengl_engine/constants.hpp +++ b/include/omath/engines/opengl_engine/constants.hpp @@ -10,17 +10,16 @@ namespace omath::opengl_engine { - constexpr Vector3 kAbsUp = {0, 1, 0}; - constexpr Vector3 kAbsRight = {1, 0, 0}; - constexpr Vector3 kAbsForward = {0, 0, -1}; + constexpr Vector3 k_abs_up = {0, 1, 0}; + constexpr Vector3 k_abs_right = {1, 0, 0}; + constexpr Vector3 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; using YawAngle = Angle; using RollAngle = Angle; - using ViewAngles = omath::ViewAngles; -} \ No newline at end of file +} // namespace omath::opengl_engine \ No newline at end of file diff --git a/include/omath/engines/opengl_engine/formulas.hpp b/include/omath/engines/opengl_engine/formulas.hpp index 7f24ef6..dc6ae64 100644 --- a/include/omath/engines/opengl_engine/formulas.hpp +++ b/include/omath/engines/opengl_engine/formulas.hpp @@ -8,19 +8,19 @@ namespace omath::opengl_engine { [[nodiscard]] - Vector3 ForwardVector(const ViewAngles& angles); + Vector3 forward_vector(const ViewAngles& angles); [[nodiscard]] - Vector3 RightVector(const ViewAngles& angles); + Vector3 right_vector(const ViewAngles& angles); [[nodiscard]] - Vector3 UpVector(const ViewAngles& angles); + Vector3 up_vector(const ViewAngles& angles); - [[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3& cam_origin); + [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& 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 diff --git a/include/omath/engines/source_engine/camera.hpp b/include/omath/engines/source_engine/camera.hpp index baa11e3..0ea1112 100644 --- a/include/omath/engines/source_engine/camera.hpp +++ b/include/omath/engines/source_engine/camera.hpp @@ -7,14 +7,15 @@ namespace omath::source_engine { - class Camera final : public projection::Camera + class Camera final : public projection::Camera { public: - Camera(const Vector3& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort, + Camera(const Vector3& position, const ViewAngles& view_angles, const projection::ViewPort& view_port, const Angle& fov, float near, float far); - void LookAt(const Vector3& target) override; + void look_at(const Vector3& 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; }; -} \ No newline at end of file +} // namespace omath::source_engine \ No newline at end of file diff --git a/include/omath/engines/source_engine/constants.hpp b/include/omath/engines/source_engine/constants.hpp index 3c7e1df..e081df5 100644 --- a/include/omath/engines/source_engine/constants.hpp +++ b/include/omath/engines/source_engine/constants.hpp @@ -3,23 +3,23 @@ // #pragma once -#include -#include #include +#include +#include #include namespace omath::source_engine { - constexpr Vector3 kAbsUp = {0, 0, 1}; - constexpr Vector3 kAbsRight = {0, -1, 0}; - constexpr Vector3 kAbsForward = {1, 0, 0}; + constexpr Vector3 k_abs_up = {0, 0, 1}; + constexpr Vector3 k_abs_right = {0, -1, 0}; + constexpr Vector3 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; using YawAngle = Angle; using RollAngle = Angle; using ViewAngles = omath::ViewAngles; -} // namespace omath::source +} // namespace omath::source_engine diff --git a/include/omath/engines/source_engine/formulas.hpp b/include/omath/engines/source_engine/formulas.hpp index 450de1e..2b651e0 100644 --- a/include/omath/engines/source_engine/formulas.hpp +++ b/include/omath/engines/source_engine/formulas.hpp @@ -7,19 +7,19 @@ namespace omath::source_engine { [[nodiscard]] - Vector3 ForwardVector(const ViewAngles& angles); + Vector3 forward_vector(const ViewAngles& angles); [[nodiscard]] - Mat4x4 RotationMatrix(const ViewAngles& angles); + Mat4X4 rotation_matrix(const ViewAngles& angles); [[nodiscard]] - Vector3 RightVector(const ViewAngles& angles); + Vector3 right_vector(const ViewAngles& angles); [[nodiscard]] - Vector3 UpVector(const ViewAngles& angles); + Vector3 up_vector(const ViewAngles& angles); - [[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3& cam_origin); + [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& 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 diff --git a/include/omath/engines/unity_engine/camera.hpp b/include/omath/engines/unity_engine/camera.hpp index e3a7f4e..7a96757 100644 --- a/include/omath/engines/unity_engine/camera.hpp +++ b/include/omath/engines/unity_engine/camera.hpp @@ -8,14 +8,15 @@ namespace omath::unity_engine { - class Camera final : public projection::Camera + class Camera final : public projection::Camera { public: - Camera(const Vector3& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort, + Camera(const Vector3& position, const ViewAngles& view_angles, const projection::ViewPort& view_port, const Angle& fov, float near, float far); - void LookAt(const Vector3& target) override; + void look_at(const Vector3& 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; }; -} \ No newline at end of file +} // namespace omath::unity_engine \ No newline at end of file diff --git a/include/omath/engines/unity_engine/constants.hpp b/include/omath/engines/unity_engine/constants.hpp index 27ec9a3..d1308ef 100644 --- a/include/omath/engines/unity_engine/constants.hpp +++ b/include/omath/engines/unity_engine/constants.hpp @@ -4,23 +4,23 @@ #pragma once -#include -#include #include +#include +#include #include namespace omath::unity_engine { - constexpr Vector3 kAbsUp = {0, 1, 0}; - constexpr Vector3 kAbsRight = {1, 0, 0}; - constexpr Vector3 kAbsForward = {0, 0, 1}; + constexpr Vector3 k_abs_up = {0, 1, 0}; + constexpr Vector3 k_abs_right = {1, 0, 0}; + constexpr Vector3 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; using YawAngle = Angle; using RollAngle = Angle; using ViewAngles = omath::ViewAngles; -} // namespace omath::source +} // namespace omath::unity_engine diff --git a/include/omath/engines/unity_engine/formulas.hpp b/include/omath/engines/unity_engine/formulas.hpp index 8b36953..db691d5 100644 --- a/include/omath/engines/unity_engine/formulas.hpp +++ b/include/omath/engines/unity_engine/formulas.hpp @@ -8,19 +8,19 @@ namespace omath::unity_engine { [[nodiscard]] - Vector3 ForwardVector(const ViewAngles& angles); + Vector3 forward_vector(const ViewAngles& angles); [[nodiscard]] - Vector3 RightVector(const ViewAngles& angles); + Vector3 right_vector(const ViewAngles& angles); [[nodiscard]] - Vector3 UpVector(const ViewAngles& angles); + Vector3 up_vector(const ViewAngles& angles); - [[nodiscard]] Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3& cam_origin); + [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& 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 diff --git a/include/omath/mat.hpp b/include/omath/mat.hpp index c418702..8ebbd22 100644 --- a/include/omath/mat.hpp +++ b/include/omath/mat.hpp @@ -2,21 +2,19 @@ // Created by vlad on 9/29/2024. // #pragma once +#include "omath/vector3.hpp" #include #include #include +#include #include #include #include -#include "omath/vector3.hpp" -#include - #ifdef near #undef near #endif - #ifdef far #undef far #endif @@ -34,25 +32,22 @@ namespace omath COLUMN_MAJOR }; - - template - concept MatTemplateEqual = - (M1::rows == M2::rows) && (M1::columns == M2::columns) && - std::is_same_v && - (M1::store_type == M2::store_type); + template concept MatTemplateEqual + = (M1::rows == M2::rows) && (M1::columns == M2::columns) + && std::is_same_v && (M1::store_type == M2::store_type); template - requires std::is_arithmetic_v + requires std::is_arithmetic_v 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(std::as_const(*this).At(rowIndex, columnIndex)); + return const_cast(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(0)); } - constexpr void Clear() noexcept + constexpr void clear() noexcept { - Set(0); + set(static_cast(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 - [[nodiscard]] + template [[nodiscard]] constexpr Mat operator*(const Mat& 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 - constexpr Mat + template constexpr Mat operator*=(const Mat& 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 Transposed() const noexcept + constexpr Mat transposed() const noexcept { Mat 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 Strip(const size_t row, const size_t column) const + constexpr Mat 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 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& RawArray() const + constexpr const std::array& raw_array() const { return m_data; } [[nodiscard]] - constexpr std::array& RawArray() + constexpr std::array& 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 Inverted() const + constexpr std::optional 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 m_data; }; - template - [[nodiscard]] - constexpr static Mat<1, 4, Type, St> MatRowFromVector(const Vector3& vector) noexcept + template [[nodiscard]] + constexpr static Mat<1, 4, Type, St> mat_row_from_vector(const Vector3& vector) noexcept { return {{vector.x, vector.y, vector.z, 1}}; } - template - [[nodiscard]] - constexpr static Mat<4, 1, Type, St> MatColumnFromVector(const Vector3& vector) noexcept + template [[nodiscard]] + constexpr static Mat<4, 1, Type, St> mat_column_from_vector(const Vector3& vector) noexcept { return {{vector.x}, {vector.y}, {vector.z}, {1}}; } template [[nodiscard]] - constexpr Mat<4, 4, Type, St> MatTranslation(const Vector3& diff) noexcept + constexpr Mat<4, 4, Type, St> mat_translation(const Vector3& diff) noexcept { return { @@ -411,38 +403,38 @@ namespace omath template [[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 [[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 [[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 [[nodiscard]] - static Mat<4, 4, Type, St> MatCameraView(const Vector3& forward, const Vector3& right, - const Vector3& up, const Vector3& cameraOrigin) noexcept + static Mat<4, 4, Type, St> mat_camera_view(const Vector3& forward, const Vector3& right, + const Vector3& up, const Vector3& 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(-cameraOrigin); + } * mat_translation(-camera_origin); } template [[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 [[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}}; } diff --git a/include/omath/matrix.hpp b/include/omath/matrix.hpp index a8c19e4..1e2df87 100644 --- a/include/omath/matrix.hpp +++ b/include/omath/matrix.hpp @@ -1,8 +1,8 @@ #pragma once +#include "omath/vector3.hpp" #include #include #include -#include "omath/vector3.hpp" namespace omath { @@ -16,51 +16,51 @@ namespace omath Matrix(const std::initializer_list>& 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& diff); + static Matrix translation_matrix(const Vector3& diff); [[nodiscard]] - static Matrix OrientationMatrix(const Vector3& forward, const Vector3& right, const Vector3& up); + static Matrix orientation_matrix(const Vector3& forward, const Vector3& right, + const Vector3& 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() const noexcept; + std::pair 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(); diff --git a/include/omath/pathfinding/a_star.hpp b/include/omath/pathfinding/a_star.hpp index b2a315e..ba5041d 100644 --- a/include/omath/pathfinding/a_star.hpp +++ b/include/omath/pathfinding/a_star.hpp @@ -3,9 +3,9 @@ // #pragma once -#include #include "omath/pathfinding/navigation_mesh.hpp" #include "omath/vector3.hpp" +#include namespace omath::pathfinding { @@ -14,17 +14,17 @@ namespace omath::pathfinding { public: [[nodiscard]] - static std::vector> FindPath(const Vector3& start, const Vector3& end, - const NavigationMesh& navMesh); + static std::vector> find_path(const Vector3& start, const Vector3& end, + const NavigationMesh& nav_mesh); private: [[nodiscard]] static std::vector> - ReconstructFinalPath(const std::unordered_map, PathNode>& closedList, - const Vector3& current); + reconstruct_final_path(const std::unordered_map, PathNode>& closed_list, + const Vector3& current); [[nodiscard]] - static auto GetPerfectNode(const std::unordered_map, PathNode>& openList, - const Vector3& endVertex); + static auto get_perfect_node(const std::unordered_map, PathNode>& open_list, + const Vector3& end_vertex); }; } // namespace omath::pathfinding diff --git a/include/omath/pathfinding/navigation_mesh.hpp b/include/omath/pathfinding/navigation_mesh.hpp index ce763e9..e5ea0cb 100644 --- a/include/omath/pathfinding/navigation_mesh.hpp +++ b/include/omath/pathfinding/navigation_mesh.hpp @@ -4,10 +4,10 @@ #pragma once +#include "omath/vector3.hpp" #include #include #include -#include "omath/vector3.hpp" namespace omath::pathfinding { @@ -21,18 +21,18 @@ namespace omath::pathfinding { public: [[nodiscard]] - std::expected, std::string> GetClosestVertex(const Vector3& point) const; + std::expected, std::string> get_closest_vertex(const Vector3& point) const; [[nodiscard]] - const std::vector>& GetNeighbors(const Vector3& vertex) const; + const std::vector>& get_neighbors(const Vector3& vertex) const; [[nodiscard]] - bool Empty() const; + bool empty() const; - [[nodiscard]] std::vector Serialize() const; + [[nodiscard]] std::vector serialize() const; - void Deserialize(const std::vector& raw); + void deserialize(const std::vector& raw); - std::unordered_map, std::vector>> m_verTextMap; + std::unordered_map, std::vector>> m_vertex_map; }; } // namespace omath::pathfinding diff --git a/include/omath/projectile_prediction/proj_pred_engine.hpp b/include/omath/projectile_prediction/proj_pred_engine.hpp index d507dbe..e4be97e 100644 --- a/include/omath/projectile_prediction/proj_pred_engine.hpp +++ b/include/omath/projectile_prediction/proj_pred_engine.hpp @@ -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> MaybeCalculateAimPoint(const Projectile& projectile, - const Target& target) const = 0; + virtual std::optional> maybe_calculate_aim_point(const Projectile& projectile, + const Target& target) const = 0; virtual ~ProjPredEngine() = default; }; } // namespace omath::projectile_prediction diff --git a/include/omath/projectile_prediction/proj_pred_engine_avx2.hpp b/include/omath/projectile_prediction/proj_pred_engine_avx2.hpp index f4b925e..85e3fc5 100644 --- a/include/omath/projectile_prediction/proj_pred_engine_avx2.hpp +++ b/include/omath/projectile_prediction/proj_pred_engine_avx2.hpp @@ -6,21 +6,23 @@ namespace omath::projectile_prediction { - class ProjPredEngineAVX2 final : public ProjPredEngine + class ProjPredEngineAvx2 final : public ProjPredEngine { public: - [[nodiscard]] std::optional> MaybeCalculateAimPoint(const Projectile& projectile, - const Target& target) const override; + [[nodiscard]] std::optional> 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 CalculatePitch(const Vector3& projOrigin, const Vector3& targetPos, - float bulletGravity, float v0, float time); - const float m_gravityConstant; - const float m_simulationTimeStep; - const float m_maximumSimulationTime; + [[nodiscard]] static std::optional calculate_pitch(const Vector3& proj_origin, + const Vector3& 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 diff --git a/include/omath/projectile_prediction/proj_pred_engine_legacy.hpp b/include/omath/projectile_prediction/proj_pred_engine_legacy.hpp index 8eb5a5e..caa5cf5 100644 --- a/include/omath/projectile_prediction/proj_pred_engine_legacy.hpp +++ b/include/omath/projectile_prediction/proj_pred_engine_legacy.hpp @@ -4,38 +4,36 @@ #pragma once -#include #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 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> MaybeCalculateAimPoint(const Projectile& projectile, - const Target& target) const override; + std::optional> 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 MaybeCalculateProjectileLaunchPitchAngle(const Projectile& projectile, - const Vector3& targetPosition) const; - + std::optional maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile, + const Vector3& target_position) const; [[nodiscard]] - bool IsProjectileReachedTarget(const Vector3& targetPosition, const Projectile& projectile, float pitch, - float time) const; + bool is_projectile_reached_target(const Vector3& target_position, const Projectile& projectile, + float pitch, float time) const; }; } // namespace omath::projectile_prediction diff --git a/include/omath/projectile_prediction/projectile.hpp b/include/omath/projectile_prediction/projectile.hpp index b32b4af..d1188c5 100644 --- a/include/omath/projectile_prediction/projectile.hpp +++ b/include/omath/projectile_prediction/projectile.hpp @@ -10,12 +10,11 @@ namespace omath::projectile_prediction class Projectile final { public: - [[nodiscard]] - Vector3 PredictPosition(float pitch, float yaw, float time, float gravity) const; + Vector3 predict_position(float pitch, float yaw, float time, float gravity) const; Vector3 m_origin; - float m_launchSpeed{}; - float m_gravityScale{}; + float m_launch_speed{}; + float m_gravity_scale{}; }; -} \ No newline at end of file +} // namespace omath::projectile_prediction \ No newline at end of file diff --git a/include/omath/projectile_prediction/target.hpp b/include/omath/projectile_prediction/target.hpp index a780858..40e010c 100644 --- a/include/omath/projectile_prediction/target.hpp +++ b/include/omath/projectile_prediction/target.hpp @@ -10,13 +10,12 @@ namespace omath::projectile_prediction class Target final { public: - [[nodiscard]] - constexpr Vector3 PredictPosition(const float time, const float gravity) const + constexpr Vector3 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 m_origin; Vector3 m_velocity; - bool m_isAirborne{}; + bool m_is_airborne{}; }; -} \ No newline at end of file +} // namespace omath::projectile_prediction \ No newline at end of file diff --git a/include/omath/projection/camera.hpp b/include/omath/projection/camera.hpp index ca7b19d..93f956a 100644 --- a/include/omath/projection/camera.hpp +++ b/include/omath/projection/camera.hpp @@ -4,12 +4,12 @@ #pragma once +#include "omath/projection/error_codes.hpp" #include #include #include #include #include -#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; - template + template class Camera { public: virtual ~Camera() = default; - Camera(const Vector3& 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& 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& target) = 0; + virtual void look_at(const Vector3& 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& origin) + void set_origin(const Vector3& 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& GetOrigin() const + [[nodiscard]] const Vector3& get_origin() const { return m_origin; } - [[nodiscard]] std::expected, Error> WorldToScreen(const Vector3& worldPosition) const + [[nodiscard]] std::expected, Error> world_to_screen(const Vector3& 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, Error> WorldToViewPort(const Vector3& worldPosition) const + [[nodiscard]] std::expected, Error> + world_to_view_port(const Vector3& world_position) const { - auto projected = GetViewProjectionMatrix() * - MatColumnFromVector(worldPosition); + auto projected = get_view_projection_matrix() + * mat_column_from_vector(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{projected.At(0, 0), projected.At(1, 0), projected.At(2, 0)}; + return Vector3{projected.at(0, 0), projected.at(1, 0), projected.at(2, 0)}; } protected: - ViewPort m_viewPort{}; - Angle m_fieldOfView; + ViewPort m_view_port{}; + Angle m_field_of_view; - mutable std::optional m_viewProjectionMatrix; + mutable std::optional 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 m_origin; private: - template - [[nodiscard]] - constexpr static bool IsNdcOutOfBounds(const Type& ndc) + template [[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 NdcToScreenPosition(const Vector3& ndc) const + [[nodiscard]] Vector3 ndc_to_screen_position(const Vector3& 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 diff --git a/include/omath/projection/error_codes.hpp b/include/omath/projection/error_codes.hpp index 3c5d26c..ae29fc0 100644 --- a/include/omath/projection/error_codes.hpp +++ b/include/omath/projection/error_codes.hpp @@ -5,7 +5,6 @@ #pragma once #include - namespace omath::projection { enum class Error : uint16_t diff --git a/include/omath/triangle.hpp b/include/omath/triangle.hpp index 5c00601..b5e9822 100644 --- a/include/omath/triangle.hpp +++ b/include/omath/triangle.hpp @@ -6,15 +6,14 @@ namespace omath { - /* - |\ - | \ - a | \ hypot - | \ - ----- - b - */ - + /* + |\ + | \ + a | \ hypot + | \ + ----- + b + */ template class Triangle final @@ -31,52 +30,53 @@ namespace omath Vector3 m_vertex3; [[nodiscard]] - constexpr Vector3 CalculateNormal() const + constexpr Vector3 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 SideAVector() const + constexpr Vector3 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 SideBVector() const + constexpr Vector3 side_b_vector() const { return m_vertex3 - m_vertex2; } [[nodiscard]] - constexpr Vector3 MidPoint() const + constexpr Vector3 mid_point() const { return (m_vertex1 + m_vertex2 + m_vertex3) / 3; } diff --git a/include/omath/vector2.hpp b/include/omath/vector2.hpp index 5753f60..9a512a2 100644 --- a/include/omath/vector2.hpp +++ b/include/omath/vector2.hpp @@ -10,12 +10,11 @@ #include #endif - namespace omath { template - requires std::is_arithmetic_v + requires std::is_arithmetic_v 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 AsTuple() const + constexpr std::tuple 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(this->x), static_cast(this->y)}; } diff --git a/include/omath/vector3.hpp b/include/omath/vector3.hpp index 683e4f4..8f26609 100644 --- a/include/omath/vector3.hpp +++ b/include/omath/vector3.hpp @@ -4,11 +4,11 @@ #pragma once +#include "omath/angle.hpp" +#include "omath/vector2.hpp" #include #include #include -#include "omath/angle.hpp" -#include "omath/vector2.hpp" namespace omath { @@ -18,13 +18,16 @@ namespace omath IMPOSSIBLE_BETWEEN_ANGLE, }; - template requires std::is_arithmetic_v + template + requires std::is_arithmetic_v class Vector3 : public Vector2 { public: Type z = static_cast(0); - constexpr Vector3(const Type& x, const Type& y, const Type& z) : Vector2(x, y), z(z) { } - constexpr Vector3() : Vector2() {}; + constexpr Vector3(const Type& x, const Type& y, const Type& z): Vector2(x, y), z(z) + { + } + constexpr Vector3(): Vector2() {}; [[nodiscard]] constexpr bool operator==(const Vector3& src) const { @@ -100,72 +103,71 @@ namespace omath return *this; } - constexpr Vector3& Abs() + constexpr Vector3& abs() { - Vector2::Abs(); + Vector2::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::Dot(vOther) + z * vOther.z; + return Vector2::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::Length(); + return Vector2::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::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::LengthSqr() + z * z; + return Vector2::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, 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::FromRadians(std::acos(Dot(other) / bottom)); + return Angle::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::Sum(); + return Vector2::sum(); } - [[nodiscard]] constexpr std::tuple AsTuple() const + [[nodiscard]] constexpr std::tuple 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> + template<> struct hash> { std::size_t operator()(const omath::Vector3& vec) const noexcept { std::size_t hash = 0; constexpr std::hash 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 diff --git a/include/omath/vector4.hpp b/include/omath/vector4.hpp index e50528f..36e0c0a 100644 --- a/include/omath/vector4.hpp +++ b/include/omath/vector4.hpp @@ -6,17 +6,18 @@ #include #include - namespace omath { - template + template class Vector4 : public Vector3 { public: Type w; - constexpr Vector4(const Type& x, const Type& y, const Type& z, const Type& w) : Vector3(x, y, z), w(w) {} - constexpr Vector4() : Vector3(), w(0) {}; + constexpr Vector4(const Type& x, const Type& y, const Type& z, const Type& w): Vector3(x, y, z), w(w) + { + } + constexpr Vector4(): Vector3(), 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::LengthSqr() + w * w; + return Vector3::length_sqr() + w * w; } - [[nodiscard]] constexpr Type Dot(const Vector4& vOther) const + [[nodiscard]] constexpr Type dot(const Vector4& other) const { - return Vector3::Dot(vOther) + w * vOther.w; + return Vector3::dot(other) + w * other.w; } - [[nodiscard]] Vector3 Length() const + [[nodiscard]] Vector3 length() const { - return std::sqrt(LengthSqr()); + return std::sqrt(length_sqr()); } - constexpr Vector4& Abs() + constexpr Vector4& abs() { - Vector3::Abs(); + Vector3::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::Sum() + w; + return Vector3::sum() + w; } #ifdef OMATH_IMGUI_INTEGRATION [[nodiscard]] - ImVec4 ToImVec4() const + ImVec4 to_im_vec4() const { - return - { - static_cast(this->x), - static_cast(this->y), - static_cast(this->z), - static_cast(w), + return { + static_cast(this->x), + static_cast(this->y), + static_cast(this->z), + static_cast(w), }; } #endif }; -} +} // namespace omath diff --git a/include/omath/view_angles.hpp b/include/omath/view_angles.hpp index d744f6b..cd63640 100644 --- a/include/omath/view_angles.hpp +++ b/include/omath/view_angles.hpp @@ -12,4 +12,4 @@ namespace omath YawType yaw; RollType roll; }; -} +} // namespace omath diff --git a/source/3d_primitives/box.cpp b/source/3d_primitives/box.cpp index 0e45eaa..81da0bb 100644 --- a/source/3d_primitives/box.cpp +++ b/source/3d_primitives/box.cpp @@ -3,27 +3,25 @@ // #include "omath/3d_primitives/box.hpp" - namespace omath::primitives { - std::array>, 12> CreateBox(const Vector3& top, const Vector3& bottom, - const Vector3& dirForward, - const Vector3& dirRight, - const float ratio) + std::array>, 12> create_box(const Vector3& top, const Vector3& bottom, + const Vector3& dir_forward, + const Vector3& 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, 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>, 12> poly; @@ -53,4 +51,4 @@ namespace omath::primitives return poly; } -} +} // namespace omath::primitives diff --git a/source/collision/line_tracer.cpp b/source/collision/line_tracer.cpp index 5bf7837..e60c0de 100644 --- a/source/collision/line_tracer.cpp +++ b/source/collision/line_tracer.cpp @@ -5,63 +5,59 @@ namespace omath::collision { - bool LineTracer::CanTraceLine(const Ray& ray, const Triangle>& triangle) + bool LineTracer::can_trace_line(const Ray& ray, const Triangle>& triangle) { - return GetRayHitPoint(ray, triangle) == ray.end; + return get_ray_hit_point(ray, triangle) == ray.end; } - Vector3 Ray::DirectionVector() const + Vector3 Ray::direction_vector() const { return end - start; } - Vector3 Ray::DirectionVectorNormalized() const + Vector3 Ray::direction_vector_normalized() const { - return DirectionVector().Normalized(); + return direction_vector().normalized(); } - Vector3 LineTracer::GetRayHitPoint(const Ray& ray, const Triangle>& triangle) + Vector3 LineTracer::get_ray_hit_point(const Ray& ray, const Triangle>& triangle) { - constexpr float kEpsilon = std::numeric_limits::epsilon(); + constexpr float k_epsilon = std::numeric_limits::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 diff --git a/source/color.cpp b/source/color.cpp index 981ae73..090725c 100644 --- a/source/color.cpp +++ b/source/color.cpp @@ -6,7 +6,6 @@ #include #include - namespace omath { diff --git a/source/engines/iw_engine/camera.cpp b/source/engines/iw_engine/camera.cpp index 6261e08..77aaf20 100644 --- a/source/engines/iw_engine/camera.cpp +++ b/source/engines/iw_engine/camera.cpp @@ -7,28 +7,27 @@ namespace omath::iw_engine { - Camera::Camera(const Vector3& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort, - const Angle& fov, const float near, const float far) : - projection::Camera(position, viewAngles, viewPort, fov, near, far) + Camera::Camera(const Vector3& position, const ViewAngles& view_angles, const projection::ViewPort& view_port, + const Angle& fov, const float near, const float far) + : projection::Camera(position, view_angles, view_port, fov, near, far) { } - void Camera::LookAt([[maybe_unused]] const Vector3& target) + void Camera::look_at([[maybe_unused]] const Vector3& 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 \ No newline at end of file +} // namespace omath::iw_engine \ No newline at end of file diff --git a/source/engines/iw_engine/formulas.cpp b/source/engines/iw_engine/formulas.cpp index 0c293fe..37635dc 100644 --- a/source/engines/iw_engine/formulas.cpp +++ b/source/engines/iw_engine/formulas.cpp @@ -3,50 +3,49 @@ // #include "omath/engines/iw_engine/formulas.hpp" - namespace omath::iw_engine { - Vector3 ForwardVector(const ViewAngles& angles) + Vector3 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 RightVector(const ViewAngles& angles) + Vector3 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 UpVector(const ViewAngles& angles) + Vector3 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& cam_origin) + Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& 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}, }; diff --git a/source/engines/opengl_engine/camera.cpp b/source/engines/opengl_engine/camera.cpp index 07d4f50..4b69410 100644 --- a/source/engines/opengl_engine/camera.cpp +++ b/source/engines/opengl_engine/camera.cpp @@ -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& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort, - const Angle& fov, const float near, const float far) : - projection::Camera(position, viewAngles, viewPort, fov, near, far) + Camera::Camera(const Vector3& position, const ViewAngles& view_angles, const projection::ViewPort& view_port, + const Angle& fov, const float near, const float far) + : projection::Camera(position, view_angles, view_port, fov, near, far) { } - void Camera::LookAt([[maybe_unused]] const Vector3& target) + void Camera::look_at([[maybe_unused]] const Vector3& 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 diff --git a/source/engines/opengl_engine/formulas.cpp b/source/engines/opengl_engine/formulas.cpp index 316ed11..79868b5 100644 --- a/source/engines/opengl_engine/formulas.cpp +++ b/source/engines/opengl_engine/formulas.cpp @@ -3,47 +3,48 @@ // #include "omath/engines/opengl_engine/formulas.hpp" - namespace omath::opengl_engine { - Vector3 ForwardVector(const ViewAngles& angles) + Vector3 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 RightVector(const ViewAngles& angles) + Vector3 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 UpVector(const ViewAngles& angles) + Vector3 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& cam_origin) + Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& 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 RotationMatrix(const ViewAngles& angles) + Mat4X4 rotation_matrix(const ViewAngles& angles) { - return MatRotationAxisX(-angles.pitch) * - MatRotationAxisY(-angles.yaw) * - MatRotationAxisZ(angles.roll); + return mat_rotation_axis_x(-angles.pitch) + * mat_rotation_axis_y(-angles.yaw) + * mat_rotation_axis_z(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}, }; diff --git a/source/engines/source_engine/camera.cpp b/source/engines/source_engine/camera.cpp index 2906b55..3b550f5 100644 --- a/source/engines/source_engine/camera.cpp +++ b/source/engines/source_engine/camera.cpp @@ -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& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort, - const projection::FieldOfView& fov, const float near, const float far) : - projection::Camera(position, viewAngles, viewPort, fov, near, far) + Camera::Camera(const Vector3& position, const ViewAngles& view_angles, const projection::ViewPort& view_port, + const projection::FieldOfView& fov, const float near, const float far) + : projection::Camera(position, view_angles, view_port, fov, near, far) { } - void Camera::LookAt(const Vector3& target) + void Camera::look_at(const Vector3& 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 diff --git a/source/engines/source_engine/formulas.cpp b/source/engines/source_engine/formulas.cpp index 5dcca88..fe869e4 100644 --- a/source/engines/source_engine/formulas.cpp +++ b/source/engines/source_engine/formulas.cpp @@ -3,50 +3,49 @@ // #include - namespace omath::source_engine { - Vector3 ForwardVector(const ViewAngles& angles) + Vector3 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 RightVector(const ViewAngles& angles) + Vector3 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 UpVector(const ViewAngles& angles) + Vector3 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& cam_origin) + Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& 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}, }; diff --git a/source/engines/unity_engine/camera.cpp b/source/engines/unity_engine/camera.cpp index 5270f5a..f06304d 100644 --- a/source/engines/unity_engine/camera.cpp +++ b/source/engines/unity_engine/camera.cpp @@ -4,25 +4,24 @@ #include #include - namespace omath::unity_engine { - Camera::Camera(const Vector3& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort, - const projection::FieldOfView& fov, const float near, const float far) : - projection::Camera(position, viewAngles, viewPort, fov, near, far) + Camera::Camera(const Vector3& position, const ViewAngles& view_angles, const projection::ViewPort& view_port, + const projection::FieldOfView& fov, const float near, const float far) + : projection::Camera(position, view_angles, view_port, fov, near, far) { } - void Camera::LookAt([[maybe_unused]] const Vector3& target) + void Camera::look_at([[maybe_unused]] const Vector3& 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 diff --git a/source/engines/unity_engine/formulas.cpp b/source/engines/unity_engine/formulas.cpp index 4477253..ed6579f 100644 --- a/source/engines/unity_engine/formulas.cpp +++ b/source/engines/unity_engine/formulas.cpp @@ -3,47 +3,45 @@ // #include "omath/engines/unity_engine/formulas.hpp" - - namespace omath::unity_engine { - Vector3 ForwardVector(const ViewAngles& angles) + Vector3 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 RightVector(const ViewAngles& angles) + Vector3 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 UpVector(const ViewAngles& angles) + Vector3 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& cam_origin) + Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3& 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 RotationMatrix(const ViewAngles& angles) + Mat4X4 rotation_matrix(const ViewAngles& angles) { - return MatRotationAxisX(angles.pitch) * - MatRotationAxisY(angles.yaw) * - MatRotationAxisZ(angles.roll); + return mat_rotation_axis_x(angles.pitch) + * mat_rotation_axis_y(angles.yaw) + * mat_rotation_axis_z(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}, }; diff --git a/source/matrix.cpp b/source/matrix.cpp index 7782d56..428aaa8 100644 --- a/source/matrix.cpp +++ b/source/matrix.cpp @@ -1,14 +1,11 @@ #include "omath/matrix.hpp" #include "omath/angles.hpp" #include "omath/vector3.hpp" - - #include #include #include #include - namespace omath { Matrix::Matrix(const size_t rows, const size_t columns) @@ -21,7 +18,7 @@ namespace omath m_data = std::make_unique(m_rows * m_columns); - Set(0.f); + set(0.f); } Matrix::Matrix(const std::initializer_list>& 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(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 Matrix::Size() const noexcept + std::pair 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(std::as_const(*this).At(iRow, iCol)); + return const_cast(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& diff) + Matrix Matrix::translation_matrix(const Vector3& diff) { return { {1.f, 0.f, 0.f, 0.f}, @@ -325,7 +319,8 @@ namespace omath }; } - Matrix Matrix::OrientationMatrix(const Vector3& forward, const Vector3& right, const Vector3& up) + Matrix Matrix::orientation_matrix(const Vector3& forward, const Vector3& right, + const Vector3& 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() diff --git a/source/pathfinding/a_star.cpp b/source/pathfinding/a_star.cpp index aba160f..593c907 100644 --- a/source/pathfinding/a_star.cpp +++ b/source/pathfinding/a_star.cpp @@ -2,96 +2,95 @@ // Created by Vlad on 28.07.2024. // #include "omath/pathfinding/a_star.hpp" - #include #include #include #include - namespace omath::pathfinding { struct PathNode final { - std::optional> cameFrom; - float gCost = 0.f; + std::optional> came_from; + float g_cost = 0.f; }; - - std::vector> Astar::ReconstructFinalPath(const std::unordered_map, PathNode>& closedList, - const Vector3& current) + std::vector> + Astar::reconstruct_final_path(const std::unordered_map, PathNode>& closed_list, + const Vector3& current) { std::vector> 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, PathNode>& openList, const Vector3& endVertex) + auto Astar::get_perfect_node(const std::unordered_map, PathNode>& open_list, + const Vector3& 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> Astar::FindPath(const Vector3& start, const Vector3& end, const NavigationMesh& navMesh) + std::vector> Astar::find_path(const Vector3& start, const Vector3& end, + const NavigationMesh& nav_mesh) { - std::unordered_map, PathNode> closedList; - std::unordered_map, PathNode> openList; + std::unordered_map, PathNode> closed_list; + std::unordered_map, 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}; } } diff --git a/source/pathfinding/navigation_mesh.cpp b/source/pathfinding/navigation_mesh.cpp index 2f985ee..97c7dc1 100644 --- a/source/pathfinding/navigation_mesh.cpp +++ b/source/pathfinding/navigation_mesh.cpp @@ -2,94 +2,89 @@ // Created by Vlad on 28.07.2024. // #include "omath/pathfinding/navigation_mesh.hpp" - #include #include namespace omath::pathfinding { - std::expected, std::string> NavigationMesh::GetClosestVertex(const Vector3 &point) const + std::expected, std::string> NavigationMesh::get_closest_vertex(const Vector3& 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>& NavigationMesh::GetNeighbors(const Vector3 &vertex) const + const std::vector>& NavigationMesh::get_neighbors(const Vector3& 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 NavigationMesh::Serialize() const + std::vector NavigationMesh::serialize() const { - auto dumpToVector =[](const T& t, std::vector& vec){ + auto dump_to_vector = [](const T& t, std::vector& vec) + { for (size_t i = 0; i < sizeof(t); i++) - vec.push_back(*(reinterpret_cast(&t)+i)); + vec.push_back(*(reinterpret_cast(&t) + i)); }; std::vector 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 &raw) + void NavigationMesh::deserialize(const std::vector& raw) { - auto loadFromVector = [](const std::vector& vec, size_t& offset, auto& value) + auto load_from_vector = [](const std::vector& 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(&value)); offset += sizeof(value); }; - m_verTextMap.clear(); + m_vertex_map.clear(); size_t offset = 0; while (offset < raw.size()) { Vector3 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> 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 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 diff --git a/source/projectile_prediction/proj_pred_engine.cpp b/source/projectile_prediction/proj_pred_engine.cpp index e8e7f92..f122900 100644 --- a/source/projectile_prediction/proj_pred_engine.cpp +++ b/source/projectile_prediction/proj_pred_engine.cpp @@ -3,7 +3,6 @@ // #include "omath/projectile_prediction/proj_pred_engine.hpp" - namespace omath::projectile_prediction { diff --git a/source/projectile_prediction/proj_pred_engine_avx2.cpp b/source/projectile_prediction/proj_pred_engine_avx2.cpp index 055e060..9a26c43 100644 --- a/source/projectile_prediction/proj_pred_engine_avx2.cpp +++ b/source/projectile_prediction/proj_pred_engine_avx2.cpp @@ -14,8 +14,8 @@ namespace omath::projectile_prediction { std::optional> - 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 ProjPredEngineAVX2::CalculatePitch(const Vector3& projOrigin, - const Vector3& targetPos, const float bulletGravity, - const float v0, const float time) + std::optional ProjPredEngineAvx2::calculate_pitch([[maybe_unused]] const Vector3& proj_origin, + [[maybe_unused]] const Vector3& 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)); diff --git a/source/projectile_prediction/proj_pred_engine_legacy.cpp b/source/projectile_prediction/proj_pred_engine_legacy.cpp index 557fa2a..5d3c041 100644 --- a/source/projectile_prediction/proj_pred_engine_legacy.cpp +++ b/source/projectile_prediction/proj_pred_engine_legacy.cpp @@ -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> ProjPredEngineLegacy::MaybeCalculateAimPoint(const Projectile& projectile, - const Target& target) const + std::optional> 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 - ProjPredEngineLegacy::MaybeCalculateProjectileLaunchPitchAngle(const Projectile& projectile, - const Vector3& targetPosition) const + ProjPredEngineLegacy::maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile, + const Vector3& 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& targetPosition, const Projectile& projectile, - const float pitch, const float time) const + bool ProjPredEngineLegacy::is_projectile_reached_target(const Vector3& 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 diff --git a/source/projectile_prediction/projectile.cpp b/source/projectile_prediction/projectile.cpp index c003562..30202db 100644 --- a/source/projectile_prediction/projectile.cpp +++ b/source/projectile_prediction/projectile.cpp @@ -3,19 +3,20 @@ // #include "omath/projectile_prediction/projectile.hpp" - #include namespace omath::projectile_prediction { - Vector3 Projectile::PredictPosition(const float pitch, const float yaw, const float time, const float gravity) const + Vector3 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 diff --git a/source/projectile_prediction/target.cpp b/source/projectile_prediction/target.cpp index b0edda4..e704b29 100644 --- a/source/projectile_prediction/target.cpp +++ b/source/projectile_prediction/target.cpp @@ -4,7 +4,6 @@ #include "omath/projectile_prediction/projectile.hpp" - namespace omath::prediction { diff --git a/source/projection/camera.cpp b/source/projection/camera.cpp index e50b6eb..26d3d0d 100644 --- a/source/projection/camera.cpp +++ b/source/projection/camera.cpp @@ -3,7 +3,6 @@ // #include "omath/projection/camera.hpp" - namespace omath::projection { } diff --git a/tests/engines/unit_test_iw_engine.cpp b/tests/engines/unit_test_iw_engine.cpp index 86b7d0b..76133f5 100644 --- a/tests/engines/unit_test_iw_engine.cpp +++ b/tests/engines/unit_test_iw_engine.cpp @@ -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{}); - cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f)); + EXPECT_EQ(cam.get_origin(), omath::Vector3{}); + 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); } \ No newline at end of file diff --git a/tests/engines/unit_test_open_gl.cpp b/tests/engines/unit_test_open_gl.cpp index 170b306..1e9ddf8 100644 --- a/tests/engines/unit_test_open_gl.cpp +++ b/tests/engines/unit_test_open_gl.cpp @@ -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{}); - cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f)); + EXPECT_EQ(cam.get_origin(), omath::Vector3{}); + 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); } \ No newline at end of file diff --git a/tests/engines/unit_test_source_engine.cpp b/tests/engines/unit_test_source_engine.cpp index eebd58e..a0749f3 100644 --- a/tests/engines/unit_test_source_engine.cpp +++ b/tests/engines/unit_test_source_engine.cpp @@ -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{}); - cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f)); + EXPECT_EQ(cam.get_origin(), omath::Vector3{}); + 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); } \ No newline at end of file diff --git a/tests/engines/unit_test_unity_engine.cpp b/tests/engines/unit_test_unity_engine.cpp index b5a5e8e..932bed6 100644 --- a/tests/engines/unit_test_unity_engine.cpp +++ b/tests/engines/unit_test_unity_engine.cpp @@ -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{}); - cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f)); + EXPECT_EQ(cam.get_origin(), omath::Vector3{}); + 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); } \ No newline at end of file diff --git a/tests/general/unit_test_a_star.cpp b/tests/general/unit_test_a_star.cpp index e33f8c0..6c341c4 100644 --- a/tests/general/unit_test_a_star.cpp +++ b/tests/general/unit_test_a_star.cpp @@ -4,14 +4,13 @@ #include #include - -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); } \ No newline at end of file diff --git a/tests/general/unit_test_angles.cpp b/tests/general/unit_test_angles.cpp index adbabea..1883d78 100644 --- a/tests/general/unit_test_angles.cpp +++ b/tests/general/unit_test_angles.cpp @@ -4,46 +4,46 @@ #include #include -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); } \ No newline at end of file diff --git a/tests/general/unit_test_color.cpp b/tests/general/unit_test_color.cpp index 77aeaf3..5bfb39a 100644 --- a/tests/general/unit_test_color.cpp +++ b/tests/general/unit_test_color.cpp @@ -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); diff --git a/tests/general/unit_test_line_trace.cpp b/tests/general/unit_test_line_trace.cpp index 9472494..e47d2b7 100644 --- a/tests/general/unit_test_line_trace.cpp +++ b/tests/general/unit_test_line_trace.cpp @@ -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> 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 diff --git a/tests/general/unit_test_mat.cpp b/tests/general/unit_test_mat.cpp index 7fc25f6..c6162c7 100644 --- a/tests/general/unit_test_mat.cpp +++ b/tests/general/unit_test_mat.cpp @@ -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()); } diff --git a/tests/general/unit_test_matrix.cpp b/tests/general/unit_test_matrix.cpp index 0594ff4..ec56cbc 100644 --- a/tests/general/unit_test_matrix.cpp +++ b/tests/general/unit_test_matrix.cpp @@ -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); } \ No newline at end of file diff --git a/tests/general/unit_test_prediction.cpp b/tests/general/unit_test_prediction.cpp index 94e8ae4..6fb054a 100644 --- a/tests/general/unit_test_prediction.cpp +++ b/tests/general/unit_test_prediction.cpp @@ -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); diff --git a/tests/general/unit_test_projection.cpp b/tests/general/unit_test_projection.cpp index 6acc9d1..ac4892a 100644 --- a/tests/general/unit_test_projection.cpp +++ b/tests/general/unit_test_projection.cpp @@ -9,9 +9,9 @@ TEST(UnitTestProjection, Projection) { - const auto x = omath::Angle::FromDegrees(90.f); + const auto x = omath::Angle::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); } \ No newline at end of file diff --git a/tests/general/unit_test_triangle.cpp b/tests/general/unit_test_triangle.cpp index bf73b6e..28d8412 100644 --- a/tests/general/unit_test_triangle.cpp +++ b/tests/general/unit_test_triangle.cpp @@ -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>({2,0,0}, {}, {0,2,0}).IsRectangular()); + EXPECT_TRUE(Triangle>({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); diff --git a/tests/general/unit_test_vector2.cpp b/tests/general/unit_test_vector2.cpp index e4133d0..1896b15 100644 --- a/tests/general/unit_test_vector2.cpp +++ b/tests/general/unit_test_vector2.cpp @@ -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"); diff --git a/tests/general/unit_test_vector3.cpp b/tests/general/unit_test_vector3.cpp index e543bf4..9cf66ef 100644 --- a/tests/general/unit_test_vector3.cpp +++ b/tests/general/unit_test_vector3.cpp @@ -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"); diff --git a/tests/general/unit_test_vector4.cpp b/tests/general/unit_test_vector4.cpp index 0075216..dcdb7fe 100644 --- a/tests/general/unit_test_vector4.cpp +++ b/tests/general/unit_test_vector4.cpp @@ -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);