first commit of some basics

TSE_Math/src/Matrix4x4.hpp

@@ -0,0 +1,96 @@
+#pragma once
+
+#include "Vector3.hpp"
+#include "Vector4.hpp"
+#include "Quaternion.hpp"
+
+namespace TSE
+{
+    class Matrix4x4
+    {
+        public:
+        float m[4][4]; // Row Major Layout
+
+        /// @brief default Constructor. all values are 0
+        Matrix4x4();
+        /// @brief sets the diagonal to a custom value
+        /// @param d the value for the diagonal
+        Matrix4x4(float d);
+        /// @brief copy constructor
+        /// @param other the matrix to be copied
+        Matrix4x4(const Matrix4x4& other);
+
+        /// @brief checks if the matrix is an identity matrix aka the diagonal is set to 1, and everithing else is 0
+        /// @return is identity matrix
+        bool IsIdentityMatrix() const;
+        /// @brief chacks if the matrix ist valid aka the values are not NaN
+        /// @return is valid
+        bool IsValid() const;
+        /// @brief inverts the current matrix with the generic invertion method
+        void Invert();
+        /// @brief gets the conjuget of the current matrix
+        /// @return the conjuget
+        Matrix4x4 Conjucate() const;
+        /// @brief Gets the determinant of the matrix
+        /// @return the determinant
+        float Determinant() const;
+        /// @brief checks if the current matrix is an affine matrix aka a transformation matrix only translation, rotation, and scale set.
+        /// @return is affine
+        bool IsAffine() const;
+        /// @brief inverts an affine matrix. simply a faster inversion method for affine matrecies.
+        void InvertAffine();
+        /// @brief gets the pointer to the contents of this matrix.
+        /// @return the contens as row major
+        const float* ToArrayRowMajor() const;
+        /// @brief fills an array with the matrix contens as column major
+        /// @param out the array to be filled
+        void ToArrayColumnMajor(float out[16]) const;
+
+        /// @brief generates an identity matrix
+        /// @return identity matrix
+        static Matrix4x4 Identity();
+        /// @brief generates an orthographics projection matrix.
+        /// @param left the left clipping plane
+        /// @param right the right clipping plane
+        /// @param bottom the bottom clipping plane
+        /// @param top the top clipping plane
+        /// @param near the near clipping plane
+        /// @param far the far clipping plane
+        /// @return an orthoraphic projection matrix
+        static Matrix4x4 Orthographic(float left, float right, float bottom, float top, float near, float far);
+        /// @brief generates a perspectiv projection marix
+        /// @param fov the field of view in deg
+        /// @param aspectRatio the aspect ratio of the render target
+        /// @param near the near clipping plane
+        /// @param far the far clipping plane
+        /// @return a perspective projection matrix
+        static Matrix4x4 Perspective(float fov, float aspectRatio, float near, float far);
+        /// @brief generaties a translation matrix from a position
+        /// @param pos the position to use
+        /// @return the generated matrix
+        static Matrix4x4 ToTranslationMatrix(const Vector3& pos);
+        /// @brief generates a rotation matrix from a quaternion
+        /// @param rot the quaternion to use
+        /// @return the generated matrix
+        static Matrix4x4 ToRotationMatrix(const Quaternion& rot);
+        /// @brief generates a rotation matrix from an angle around the z axis (2D)
+        /// @param angle the angle to rotate about
+        /// @return the generated matrix
+        static Matrix4x4 ToRotationMatrixFromZAxisOnly(float angle);
+        /// @brief generates a scale matrix from a scale vector
+        /// @param scale the scale to use
+        /// @return the generated matrix
+        static Matrix4x4 ToScaleMatrix(const Vector3& scale);
+        /// @brief inverts a the given matrix, when possible it trys to use less calculations
+        /// @param mat the matrix to invert
+        /// @return the inverted matrix
+        static Matrix4x4 Invert(const Matrix4x4& mat);
+
+        Matrix4x4 operator*(const Matrix4x4& other) const;
+        Matrix4x4 operator*=(const Matrix4x4& other);
+        Matrix4x4 operator*(float scalar) const;
+        Matrix4x4 operator*=(float scalar);
+        Vector3 operator*(const Vector3& v) const;
+        Vector4 operator*(const Vector4& v) const;
+    };
+} // namespace TSE