Mat44.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Math/MathTypes.h>
 
JPH_NAMESPACE_BEGIN
 
class [[nodiscard]] alignas(JPH_VECTOR_ALIGNMENT) Mat44
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    // Underlying column type
    using Type = Vec4::Type;
 
    // Argument type
    using ArgType = Mat44Arg;
 
                                Mat44() = default; 
    JPH_INLINE                  Mat44(Vec4Arg inC1, Vec4Arg inC2, Vec4Arg inC3, Vec4Arg inC4);
    JPH_INLINE                  Mat44(Vec4Arg inC1, Vec4Arg inC2, Vec4Arg inC3, Vec3Arg inC4);
                                Mat44(const Mat44 &inM2) = default;
    Mat44 &                     operator = (const Mat44 &inM2) = default;
    JPH_INLINE                  Mat44(Type inC1, Type inC2, Type inC3, Type inC4);
 
    static JPH_INLINE Mat44     sZero();
 
    static JPH_INLINE Mat44     sIdentity();
 
    static JPH_INLINE Mat44     sNaN();
 
    static JPH_INLINE Mat44     sLoadFloat4x4(const Float4 *inV);
 
    static JPH_INLINE Mat44     sLoadFloat4x4Aligned(const Float4 *inV);
 
    static JPH_INLINE Mat44     sRotationX(float inX);
    static JPH_INLINE Mat44     sRotationY(float inY);
    static JPH_INLINE Mat44     sRotationZ(float inZ);
 
    static JPH_INLINE Mat44     sRotation(Vec3Arg inAxis, float inAngle);
 
    static JPH_INLINE Mat44     sRotation(QuatArg inQuat);
 
    static JPH_INLINE Mat44     sTranslation(Vec3Arg inV);
 
    static JPH_INLINE Mat44     sRotationTranslation(QuatArg inR, Vec3Arg inT);
 
    static JPH_INLINE Mat44     sInverseRotationTranslation(QuatArg inR, Vec3Arg inT);
 
    static JPH_INLINE Mat44     sScale(float inScale);
 
    static JPH_INLINE Mat44     sScale(Vec3Arg inV);
 
    static JPH_INLINE Mat44     sOuterProduct(Vec3Arg inV1, Vec3Arg inV2);
 
    static JPH_INLINE Mat44     sCrossProduct(Vec3Arg inV);
 
    static JPH_INLINE Mat44     sQuatLeftMultiply(QuatArg inQ);
 
    static JPH_INLINE Mat44     sQuatRightMultiply(QuatArg inQ);
 
    static JPH_INLINE Mat44     sLookAt(Vec3Arg inPos, Vec3Arg inTarget, Vec3Arg inUp);
 
    static JPH_INLINE Mat44     sPerspective(float inFovY, float inAspect, float inNear, float inFar);
 
    JPH_INLINE float            operator () (uint inRow, uint inColumn) const           { JPH_ASSERT(inRow < 4); JPH_ASSERT(inColumn < 4); return mCol[inColumn].mF32[inRow]; }
    JPH_INLINE float &          operator () (uint inRow, uint inColumn)                 { JPH_ASSERT(inRow < 4); JPH_ASSERT(inColumn < 4); return mCol[inColumn].mF32[inRow]; }
 
    JPH_INLINE bool             operator == (Mat44Arg inM2) const;
    JPH_INLINE bool             operator != (Mat44Arg inM2) const                       { return !(*this == inM2); }
 
    JPH_INLINE bool             IsClose(Mat44Arg inM2, float inMaxDistSq = 1.0e-12f) const;
 
    JPH_INLINE Mat44            operator * (Mat44Arg inM) const;
 
    JPH_INLINE Vec3             operator * (Vec3Arg inV) const;
    JPH_INLINE Vec4             operator * (Vec4Arg inV) const;
 
    JPH_INLINE Vec3             Multiply3x3(Vec3Arg inV) const;
 
    JPH_INLINE Vec3             Multiply3x3Transposed(Vec3Arg inV) const;
 
    JPH_INLINE Mat44            Multiply3x3(Mat44Arg inM) const;
 
    JPH_INLINE Mat44            Multiply3x3LeftTransposed(Mat44Arg inM) const;
 
    JPH_INLINE Mat44            Multiply3x3RightTransposed(Mat44Arg inM) const;
 
    JPH_INLINE Mat44            operator * (float inV) const;
    friend JPH_INLINE Mat44     operator * (float inV, Mat44Arg inM)                    { return inM * inV; }
 
    JPH_INLINE Mat44 &          operator *= (float inV);
 
    JPH_INLINE Mat44            operator + (Mat44Arg inM) const;
 
    JPH_INLINE Mat44            operator - () const;
 
    JPH_INLINE Mat44            operator - (Mat44Arg inM) const;
 
    JPH_INLINE Mat44 &          operator += (Mat44Arg inM);
 
    JPH_INLINE Vec3             GetAxisX() const                                        { return Vec3(mCol[0]); }
    JPH_INLINE void             SetAxisX(Vec3Arg inV)                                   { mCol[0] = Vec4(inV, 0.0f); }
    JPH_INLINE Vec3             GetAxisY() const                                        { return Vec3(mCol[1]); }
    JPH_INLINE void             SetAxisY(Vec3Arg inV)                                   { mCol[1] = Vec4(inV, 0.0f); }
    JPH_INLINE Vec3             GetAxisZ() const                                        { return Vec3(mCol[2]); }
    JPH_INLINE void             SetAxisZ(Vec3Arg inV)                                   { mCol[2] = Vec4(inV, 0.0f); }
    JPH_INLINE Vec3             GetTranslation() const                                  { return Vec3(mCol[3]); }
    JPH_INLINE void             SetTranslation(Vec3Arg inV)                             { mCol[3] = Vec4(inV, 1.0f); }
    JPH_INLINE Vec3             GetDiagonal3() const                                    { return Vec3(mCol[0][0], mCol[1][1], mCol[2][2]); }
    JPH_INLINE void             SetDiagonal3(Vec3Arg inV)                               { mCol[0][0] = inV.GetX(); mCol[1][1] = inV.GetY(); mCol[2][2] = inV.GetZ(); }
    JPH_INLINE Vec4             GetDiagonal4() const                                    { return Vec4(mCol[0][0], mCol[1][1], mCol[2][2], mCol[3][3]); }
    JPH_INLINE void             SetDiagonal4(Vec4Arg inV)                               { mCol[0][0] = inV.GetX(); mCol[1][1] = inV.GetY(); mCol[2][2] = inV.GetZ(); mCol[3][3] = inV.GetW(); }
    JPH_INLINE Vec3             GetColumn3(uint inCol) const                            { JPH_ASSERT(inCol < 4); return Vec3(mCol[inCol]); }
    JPH_INLINE void             SetColumn3(uint inCol, Vec3Arg inV)                     { JPH_ASSERT(inCol < 4); mCol[inCol] = Vec4(inV, inCol == 3? 1.0f : 0.0f); }
    JPH_INLINE Vec4             GetColumn4(uint inCol) const                            { JPH_ASSERT(inCol < 4); return mCol[inCol]; }
    JPH_INLINE void             SetColumn4(uint inCol, Vec4Arg inV)                     { JPH_ASSERT(inCol < 4); mCol[inCol] = inV; }
 
    JPH_INLINE void             StoreFloat4x4(Float4 *outV) const;
 
    JPH_INLINE Mat44            Transposed() const;
 
    JPH_INLINE Mat44            Transposed3x3() const;
 
    JPH_INLINE Mat44            Inversed() const;
 
    JPH_INLINE Mat44            InversedRotationTranslation() const;
 
    JPH_INLINE float            GetDeterminant3x3() const;
 
    JPH_INLINE Mat44            Adjointed3x3() const;
 
    JPH_INLINE Mat44            Inversed3x3() const;
 
    JPH_INLINE bool             SetInversed3x3(Mat44Arg inM);
 
    JPH_INLINE Mat44            GetRotation() const;
 
    JPH_INLINE Mat44            GetRotationSafe() const;
 
    JPH_INLINE void             SetRotation(Mat44Arg inRotation);
 
    JPH_INLINE Quat             GetQuaternion() const;
 
    JPH_INLINE Mat44            GetDirectionPreservingMatrix() const                    { return GetRotation().Inversed3x3().Transposed3x3(); }
 
    JPH_INLINE Mat44            PreTranslated(Vec3Arg inTranslation) const;
 
    JPH_INLINE Mat44            PostTranslated(Vec3Arg inTranslation) const;
 
    JPH_INLINE Mat44            PreScaled(Vec3Arg inScale) const;
 
    JPH_INLINE Mat44            PostScaled(Vec3Arg inScale) const;
 
    JPH_INLINE Mat44            Decompose(Vec3 &outScale) const;
 
#ifndef JPH_DOUBLE_PRECISION
    JPH_INLINE Mat44            ToMat44() const                                         { return *this; }
#endif // !JPH_DOUBLE_PRECISION
 
    friend ostream &            operator << (ostream &inStream, Mat44Arg inM)
    {
        inStream << inM.mCol[0] << ", " << inM.mCol[1] << ", " << inM.mCol[2] << ", " << inM.mCol[3];
        return inStream;
    }
 
private:
    Vec4                        mCol[4];                                                
};
 
static_assert(std::is_trivial<Mat44>(), "Is supposed to be a trivial type!");
 
JPH_NAMESPACE_END
 
#include "Mat44.inl"