Vec4.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/Float4.h>
#include <Jolt/Math/Swizzle.h>
#include <Jolt/Math/MathTypes.h>
 
JPH_NAMESPACE_BEGIN
 
class [[nodiscard]] alignas(JPH_VECTOR_ALIGNMENT) Vec4
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    // Underlying vector type
#if defined(JPH_USE_SSE)
    using Type = __m128;
#elif defined(JPH_USE_NEON)
    using Type = float32x4_t;
#else
    using Type = struct { float mData[4]; };
#endif

                                Vec4() = default; 
                                Vec4(const Vec4 &inRHS) = default;
    Vec4 &                      operator = (const Vec4 &inRHS) = default;
    explicit JPH_INLINE         Vec4(Vec3Arg inRHS);                            
    JPH_INLINE                  Vec4(Vec3Arg inRHS, float inW);
    JPH_INLINE                  Vec4(Type inRHS) : mValue(inRHS)                { }

    JPH_INLINE                  Vec4(float inX, float inY, float inZ, float inW);

    static JPH_INLINE Vec4      sZero();

    static JPH_INLINE Vec4      sOne();

    static JPH_INLINE Vec4      sNaN();

    static JPH_INLINE Vec4      sReplicate(float inV);

    static JPH_INLINE Vec4      sLoadFloat4(const Float4 *inV);

    static JPH_INLINE Vec4      sLoadFloat4Aligned(const Float4 *inV);

    template <const int Scale>
    static JPH_INLINE Vec4      sGatherFloat4(const float *inBase, UVec4Arg inOffsets);

    static JPH_INLINE Vec4      sMin(Vec4Arg inV1, Vec4Arg inV2);

    static JPH_INLINE Vec4      sMax(Vec4Arg inV1, Vec4Arg inV2);

    static JPH_INLINE Vec4      sClamp(Vec4Arg inV, Vec4Arg inMin, Vec4Arg inMax);

    static JPH_INLINE UVec4     sEquals(Vec4Arg inV1, Vec4Arg inV2);

    static JPH_INLINE UVec4     sLess(Vec4Arg inV1, Vec4Arg inV2);

    static JPH_INLINE UVec4     sLessOrEqual(Vec4Arg inV1, Vec4Arg inV2);

    static JPH_INLINE UVec4     sGreater(Vec4Arg inV1, Vec4Arg inV2);

    static JPH_INLINE UVec4     sGreaterOrEqual(Vec4Arg inV1, Vec4Arg inV2);

    static JPH_INLINE Vec4      sFusedMultiplyAdd(Vec4Arg inMul1, Vec4Arg inMul2, Vec4Arg inAdd);

    static JPH_INLINE Vec4      sSelect(Vec4Arg inNotSet, Vec4Arg inSet, UVec4Arg inControl);

    static JPH_INLINE Vec4      sOr(Vec4Arg inV1, Vec4Arg inV2);

    static JPH_INLINE Vec4      sXor(Vec4Arg inV1, Vec4Arg inV2);

    static JPH_INLINE Vec4      sAnd(Vec4Arg inV1, Vec4Arg inV2);

    static JPH_INLINE void      sSort4(Vec4 &ioValue, UVec4 &ioIndex);

    static JPH_INLINE void      sSort4Reverse(Vec4 &ioValue, UVec4 &ioIndex);

#if defined(JPH_USE_SSE)
    JPH_INLINE float            GetX() const                                    { return _mm_cvtss_f32(mValue); }
    JPH_INLINE float            GetY() const                                    { return mF32[1]; }
    JPH_INLINE float            GetZ() const                                    { return mF32[2]; }
    JPH_INLINE float            GetW() const                                    { return mF32[3]; }
#elif defined(JPH_USE_NEON)
    JPH_INLINE float            GetX() const                                    { return vgetq_lane_f32(mValue, 0); }
    JPH_INLINE float            GetY() const                                    { return vgetq_lane_f32(mValue, 1); }
    JPH_INLINE float            GetZ() const                                    { return vgetq_lane_f32(mValue, 2); }
    JPH_INLINE float            GetW() const                                    { return vgetq_lane_f32(mValue, 3); }
#else
    JPH_INLINE float            GetX() const                                    { return mF32[0]; }
    JPH_INLINE float            GetY() const                                    { return mF32[1]; }
    JPH_INLINE float            GetZ() const                                    { return mF32[2]; }
    JPH_INLINE float            GetW() const                                    { return mF32[3]; }
#endif

    JPH_INLINE void             SetX(float inX)                                 { mF32[0] = inX; }
    JPH_INLINE void             SetY(float inY)                                 { mF32[1] = inY; }
    JPH_INLINE void             SetZ(float inZ)                                 { mF32[2] = inZ; }
    JPH_INLINE void             SetW(float inW)                                 { mF32[3] = inW; }

    JPH_INLINE void             Set(float inX, float inY, float inZ, float inW) { *this = Vec4(inX, inY, inZ, inW); }

    JPH_INLINE float            operator [] (uint inCoordinate) const           { JPH_ASSERT(inCoordinate < 4); return mF32[inCoordinate]; }
    JPH_INLINE float &          operator [] (uint inCoordinate)                 { JPH_ASSERT(inCoordinate < 4); return mF32[inCoordinate]; }

    JPH_INLINE bool             operator == (Vec4Arg inV2) const;
    JPH_INLINE bool             operator != (Vec4Arg inV2) const            { return !(*this == inV2); }

    JPH_INLINE bool             IsClose(Vec4Arg inV2, float inMaxDistSq = 1.0e-12f) const;

    JPH_INLINE bool             IsNearZero(float inMaxDistSq = 1.0e-12f) const;

    JPH_INLINE bool             IsNormalized(float inTolerance = 1.0e-6f) const;

    JPH_INLINE bool             IsNaN() const;

    JPH_INLINE Vec4             operator * (Vec4Arg inV2) const;

    JPH_INLINE Vec4             operator * (float inV2) const;

    friend JPH_INLINE Vec4      operator * (float inV1, Vec4Arg inV2);

    JPH_INLINE Vec4             operator / (float inV2) const;

    JPH_INLINE Vec4 &           operator *= (float inV2);

    JPH_INLINE Vec4 &           operator *= (Vec4Arg inV2);

    JPH_INLINE Vec4 &           operator /= (float inV2);

    JPH_INLINE Vec4             operator + (Vec4Arg inV2) const;

    JPH_INLINE Vec4 &           operator += (Vec4Arg inV2);

    JPH_INLINE Vec4             operator - () const;

    JPH_INLINE Vec4             operator - (Vec4Arg inV2) const;

    JPH_INLINE Vec4 &           operator -= (Vec4Arg inV2);

    JPH_INLINE Vec4             operator / (Vec4Arg inV2) const;

    template<uint32 SwizzleX, uint32 SwizzleY, uint32 SwizzleZ, uint32 SwizzleW>
    JPH_INLINE Vec4             Swizzle() const;

    JPH_INLINE Vec4             SplatX() const;

    JPH_INLINE Vec4             SplatY() const;

    JPH_INLINE Vec4             SplatZ() const;

    JPH_INLINE Vec4             SplatW() const;

    JPH_INLINE Vec3             SplatX3() const;

    JPH_INLINE Vec3             SplatY3() const;

    JPH_INLINE Vec3             SplatZ3() const;

    JPH_INLINE Vec3             SplatW3() const;

    JPH_INLINE int              GetLowestComponentIndex() const;

    JPH_INLINE int              GetHighestComponentIndex() const;

    JPH_INLINE Vec4             Abs() const;

    JPH_INLINE Vec4             Reciprocal() const;

    JPH_INLINE Vec4             DotV(Vec4Arg inV2) const;

    JPH_INLINE float            Dot(Vec4Arg inV2) const;

    JPH_INLINE float            LengthSq() const;

    JPH_INLINE float            Length() const;

    JPH_INLINE Vec4             Normalized() const;

    JPH_INLINE void             StoreFloat4(Float4 *outV) const;

    JPH_INLINE UVec4            ToInt() const;

    JPH_INLINE UVec4            ReinterpretAsInt() const;

    JPH_INLINE int              GetSignBits() const;

    JPH_INLINE float            ReduceMin() const;

    JPH_INLINE float            ReduceMax() const;

    JPH_INLINE Vec4             Sqrt() const;

    JPH_INLINE Vec4             GetSign() const;

    template <int X, int Y, int Z, int W>
    JPH_INLINE Vec4             FlipSign() const;

    inline void                 SinCos(Vec4 &outSin, Vec4 &outCos) const;

    inline Vec4                 Tan() const;

    inline Vec4                 ASin() const;

    inline Vec4                 ACos() const;

    inline Vec4                 ATan() const;

    inline static Vec4          sATan2(Vec4Arg inY, Vec4Arg inX);

    JPH_INLINE uint32           CompressUnitVector() const;

    JPH_INLINE static Vec4      sDecompressUnitVector(uint32 inValue);

    friend ostream &            operator << (ostream &inStream, Vec4Arg inV)
    {
        inStream << inV.mF32[0] << ", " << inV.mF32[1] << ", " << inV.mF32[2] << ", " << inV.mF32[3];
        return inStream;
    }
 
    union
    {
        Type                    mValue;
        float                   mF32[4];
    };
};
 
static_assert(std::is_trivial<Vec4>(), "Is supposed to be a trivial type!");
 
JPH_NAMESPACE_END
 
#include "Vec4.inl"