Merge pull request #40 from orange-cpp/u/orange/inverted-matrix

U/orange/inverted matrix

.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/uml.iml" filepath="$PROJECT_DIR$/.idea/uml.iml" />
-    </modules>
-  </component>
-</project>

.idea/uml.iml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module classpath="CMake" type="CPP_MODULE" version="4" />

.idea/vcs.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-    <mapping directory="$PROJECT_DIR$/extlibs/googletest" vcs="Git" />
-  </component>
-</project>

CREDITS.md

@@ -0,0 +1,11 @@
+# OMATH CREDITS
+
+Thanks to everyone who made this possible, including:
+
+- Saikari aka luadebug for VCPKG port.
+
+And a big hand to everyone else who has contributed over the past!
+
+THANKS! <3
+
+    -- Orange++ <orange-cpp@yandex.ru>

include/omath/mat.hpp

@@ -253,21 +253,24 @@ namespace omath
 
             if constexpr (Rows == 2)
                 return At(0, 0) * At(1, 1) - At(0, 1) * At(1, 0);
-            else
+
+            if constexpr (Rows > 2)
             {
                 Type det = 0;
-                for (size_t i = 0; i < Columns; ++i)
+                for (size_t column = 0; column < Columns; ++column)
                 {
-                    const Type cofactor = (i % 2 == 0 ? 1 : -1) * At(0, i) * Minor(0, i).Determinant();
+                    const Type cofactor = At(0, column) * AlgComplement(0, column);
                     det += cofactor;
                 }
                 return det;
             }
+            std::unreachable();
         }
 
         [[nodiscard]]
-        constexpr Mat<Rows - 1, Columns - 1, Type, StoreType> Minor(const size_t row, const size_t column) const
+        constexpr Mat<Rows - 1, Columns - 1, Type, StoreType> Strip(const size_t row, const size_t column) const
         {
+            static_assert(Rows-1 > 0 && Columns-1 > 0);
             Mat<Rows - 1, Columns - 1, Type, StoreType> result;
             for (size_t i = 0, m = 0; i < Rows; ++i)
             {
@@ -285,6 +288,19 @@ namespace omath
             return result;
         }
 
+        [[nodiscard]]
+        constexpr Type Minor(const size_t row, const size_t column) const
+        {
+            return Strip(row, column).Determinant();
+        }
+
+        [[nodiscard]]
+        constexpr Type AlgComplement(const size_t row, const size_t column) const
+        {
+            const auto minor = Minor(row, column);
+            return (row + column + 2) % 2 == 0 ? minor: -minor;
+        }
+
         [[nodiscard]]
         constexpr const std::array<Type, Rows * Columns>& RawArray() const
         {
@@ -294,7 +310,7 @@ namespace omath
         [[nodiscard]]
         constexpr std::array<Type, Rows * Columns>& RawArray()
         {
-            return const_cast<std::array<Type, Rows * Columns>>(std::as_const(*this).RawArray());
+            return m_data;
         }
 
         [[nodiscard]]
@@ -343,6 +359,25 @@ namespace omath
             };
         }
 
+        [[nodiscard]]
+        constexpr std::optional<Mat> Inverted() const
+        {
+            const auto det = Determinant();
+
+            if (det == 0)
+                return std::nullopt;
+
+            const auto transposed = 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 /= det;
+
+            return {result};
+        }
     private:
         std::array<Type, Rows * Columns> m_data;
     };

include/omath/projection/camera.hpp

@@ -62,31 +62,37 @@ namespace omath::projection
         void SetFieldOfView(const FieldOfView& fov)
         {
             m_fieldOfView = fov;
+            m_viewProjectionMatrix = std::nullopt;
         }
 
         void SetNearPlane(const float near)
         {
             m_nearPlaneDistance = near;
+            m_viewProjectionMatrix = std::nullopt;
         }
 
         void SetFarPlane(const float far)
         {
             m_farPlaneDistance = far;
+            m_viewProjectionMatrix = std::nullopt;
         }
 
         void SetViewAngles(const ViewAnglesType& viewAngles)
         {
             m_viewAngles = viewAngles;
+            m_viewProjectionMatrix = std::nullopt;
         }
 
         void SetOrigin(const Vector3<float>& origin)
         {
             m_origin = origin;
+            m_viewProjectionMatrix = std::nullopt;
         }
 
         void SetViewPort(const ViewPort& viewPort)
         {
             m_viewPort = viewPort;
+            m_viewProjectionMatrix = std::nullopt;
         }
 
         [[nodiscard]] const FieldOfView& GetFieldOfView() const

source/engines/opengl_engine/formulas.cpp

@@ -32,9 +32,9 @@ namespace omath::opengl_engine
     }
     Mat4x4 RotationMatrix(const ViewAngles& angles)
     {
-        return MatRotationAxisZ<float, MatStoreType::COLUMN_MAJOR>(angles.roll) *
+        return MatRotationAxisX<float, MatStoreType::COLUMN_MAJOR>(-angles.pitch) *
                MatRotationAxisY<float, MatStoreType::COLUMN_MAJOR>(-angles.yaw) *
-               MatRotationAxisX<float, MatStoreType::COLUMN_MAJOR>(-angles.pitch);
+               MatRotationAxisZ<float, MatStoreType::COLUMN_MAJOR>(angles.roll);
     }
     Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
                                            const float far)

source/engines/unity_engine/formulas.cpp

@@ -32,9 +32,9 @@ namespace omath::unity_engine
     }
     Mat4x4 RotationMatrix(const ViewAngles& angles)
     {
-        return MatRotationAxisZ(angles.roll) *
-               MatRotationAxisY(angles.yaw) *
-               MatRotationAxisX(angles.pitch);
+        return MatRotationAxisX<float, MatStoreType::ROW_MAJOR>(angles.pitch) *
+               MatRotationAxisY<float, MatStoreType::ROW_MAJOR>(angles.yaw) *
+               MatRotationAxisZ<float, MatStoreType::ROW_MAJOR>(angles.roll);
     }
     Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
                                            const float far)

tests/general/unit_test_mat.cpp

@@ -180,10 +180,10 @@ TEST(UnitTestMatStandalone, Determinant_3x3)
 }
 
 // Test Minor for 3x3 matrix
-TEST(UnitTestMatStandalone, Minor_3x3)
+TEST(UnitTestMatStandalone, Strip_3x3)
 {
     constexpr Mat<3, 3> m{{3, 0, 2}, {2, 0, -2}, {0, 1, 1}};
-    auto minor = m.Minor(0, 0);
+    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);
@@ -206,3 +206,11 @@ TEST(UnitTestMatStandalone, Transpose_NonSquare)
     EXPECT_FLOAT_EQ(transposed.At(1, 1), 5.0f);
     EXPECT_FLOAT_EQ(transposed.At(2, 1), 6.0f);
 }
+
+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());
+}