Quat.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/Vec3.h>
#include <Jolt/Math/Vec4.h>
 
JPH_NAMESPACE_BEGIN
 
class [[nodiscard]] alignas(JPH_VECTOR_ALIGNMENT) Quat
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    inline                      Quat() = default; 
                                Quat(const Quat &inRHS) = default;
    Quat &                      operator = (const Quat &inRHS) = default;
    inline                      Quat(float inX, float inY, float inZ, float inW)                : mValue(inX, inY, inZ, inW) { }
    inline explicit             Quat(const Float4 &inV)                                         : mValue(Vec4::sLoadFloat4(&inV)) { }
    inline explicit             Quat(Vec4Arg inV)                                               : mValue(inV) { }
 
 
    inline bool                 operator == (QuatArg inRHS) const                               { return mValue == inRHS.mValue; }
 
    inline bool                 operator != (QuatArg inRHS) const                               { return mValue != inRHS.mValue; }
 
    inline bool                 IsClose(QuatArg inRHS, float inMaxDistSq = 1.0e-12f) const      { return mValue.IsClose(inRHS.mValue, inMaxDistSq); }
 
    inline bool                 IsNormalized(float inTolerance = 1.0e-5f) const                 { return mValue.IsNormalized(inTolerance); }
 
    inline bool                 IsNaN() const                                                   { return mValue.IsNaN(); }
 
 
    JPH_INLINE float            GetX() const                                                    { return mValue.GetX(); }
 
    JPH_INLINE float            GetY() const                                                    { return mValue.GetY(); }
 
    JPH_INLINE float            GetZ() const                                                    { return mValue.GetZ(); }
 
    JPH_INLINE float            GetW() const                                                    { return mValue.GetW(); }
 
    JPH_INLINE Vec3             GetXYZ() const                                                  { return Vec3(mValue); }
 
    JPH_INLINE Vec4             GetXYZW() const                                                 { return mValue; }
 
    JPH_INLINE void             SetX(float inX)                                                 { mValue.SetX(inX); }
    JPH_INLINE void             SetY(float inY)                                                 { mValue.SetY(inY); }
    JPH_INLINE void             SetZ(float inZ)                                                 { mValue.SetZ(inZ); }
    JPH_INLINE void             SetW(float inW)                                                 { mValue.SetW(inW); }
 
    JPH_INLINE void             Set(float inX, float inY, float inZ, float inW)                 { mValue.Set(inX, inY, inZ, inW); }
 
 
    JPH_INLINE static Quat      sZero()                                                         { return Quat(Vec4::sZero()); }
 
    JPH_INLINE static Quat      sIdentity()                                                     { return Quat(0, 0, 0, 1); }
 
 
    JPH_INLINE static Quat      sRotation(Vec3Arg inAxis, float inAngle);
 
    JPH_INLINE void             GetAxisAngle(Vec3 &outAxis, float &outAngle) const;
 
    JPH_INLINE static Quat      sFromTo(Vec3Arg inFrom, Vec3Arg inTo);
 
    template <class Random>
    inline static Quat          sRandom(Random &inRandom);
 
    inline static Quat          sEulerAngles(Vec3Arg inAngles);
 
    inline Vec3                 GetEulerAngles() const;
 
 
    JPH_INLINE float            LengthSq() const                                                { return mValue.LengthSq(); }
 
    JPH_INLINE float            Length() const                                                  { return mValue.Length(); }
 
    JPH_INLINE Quat             Normalized() const                                              { return Quat(mValue.Normalized()); }
 
 
    JPH_INLINE void             operator += (QuatArg inRHS)                                     { mValue += inRHS.mValue; }
    JPH_INLINE void             operator -= (QuatArg inRHS)                                     { mValue -= inRHS.mValue; }
    JPH_INLINE void             operator *= (float inValue)                                     { mValue *= inValue; }
    JPH_INLINE void             operator /= (float inValue)                                     { mValue /= inValue; }
    JPH_INLINE Quat             operator - () const                                             { return Quat(-mValue); }
    JPH_INLINE Quat             operator + (QuatArg inRHS) const                                { return Quat(mValue + inRHS.mValue); }
    JPH_INLINE Quat             operator - (QuatArg inRHS) const                                { return Quat(mValue - inRHS.mValue); }
    JPH_INLINE Quat             operator * (QuatArg inRHS) const;
    JPH_INLINE Quat             operator * (float inValue) const                                { return Quat(mValue * inValue); }
    inline friend Quat          operator * (float inValue, QuatArg inRHS)                       { return Quat(inRHS.mValue * inValue); }
    JPH_INLINE Quat             operator / (float inValue) const                                { return Quat(mValue / inValue); }
 
 
    JPH_INLINE Vec3             operator * (Vec3Arg inValue) const;
 
    static JPH_INLINE Quat      sMultiplyImaginary(Vec3Arg inLHS, QuatArg inRHS);
 
    JPH_INLINE Vec3             InverseRotate(Vec3Arg inValue) const;
 
    JPH_INLINE Vec3             RotateAxisX() const;
 
    JPH_INLINE Vec3             RotateAxisY() const;
 
    JPH_INLINE Vec3             RotateAxisZ() const;
 
    JPH_INLINE float            Dot(QuatArg inRHS) const                                        { return mValue.Dot(inRHS.mValue); }
 
    JPH_INLINE Quat             Conjugated() const                                              { return Quat(mValue.FlipSign<-1, -1, -1, 1>()); }
 
    JPH_INLINE Quat             Inversed() const                                                { return Conjugated() / Length(); }
 
    JPH_INLINE Quat             EnsureWPositive() const                                         { return Quat(Vec4::sXor(mValue, Vec4::sAnd(mValue.SplatW(), UVec4::sReplicate(0x80000000).ReinterpretAsFloat()))); }
 
    JPH_INLINE Quat             GetPerpendicular() const                                        { return Quat(mValue.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z>().FlipSign<1, -1, 1, -1>()); }
 
    JPH_INLINE float            GetRotationAngle(Vec3Arg inAxis) const                          { return GetW() == 0.0f? JPH_PI : 2.0f * ATan(GetXYZ().Dot(inAxis) / GetW()); }
 
    JPH_INLINE Quat             GetTwist(Vec3Arg inAxis) const;
 
    JPH_INLINE void             GetSwingTwist(Quat &outSwing, Quat &outTwist) const;
 
    JPH_INLINE Quat             LERP(QuatArg inDestination, float inFraction) const;
 
    JPH_INLINE Quat             SLERP(QuatArg inDestination, float inFraction) const;
 
    static JPH_INLINE Quat      sLoadFloat3Unsafe(const Float3 &inV);
 
    JPH_INLINE void             StoreFloat3(Float3 *outV) const;
 
    JPH_INLINE void             StoreFloat4(Float4 *outV) const;
 
    JPH_INLINE uint32           CompressUnitQuat() const                                        { return mValue.CompressUnitVector(); }
 
    JPH_INLINE static Quat      sDecompressUnitQuat(uint32 inValue)                             { return Quat(Vec4::sDecompressUnitVector(inValue)); }
 
    friend ostream &            operator << (ostream &inStream, QuatArg inQ)                    { inStream << inQ.mValue; return inStream; }
 
    Vec4                        mValue;
};
 
static_assert(std::is_trivial<Quat>(), "Is supposed to be a trivial type!");
 
JPH_NAMESPACE_END
 
#include "Quat.inl"