UVec4.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/Vec4.h>
 
JPH_NAMESPACE_BEGIN
 
class [[nodiscard]] alignas(JPH_VECTOR_ALIGNMENT) UVec4
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    // Underlying vector type
#if defined(JPH_USE_SSE)
    using Type = __m128i;
#elif defined(JPH_USE_NEON)
    using Type = uint32x4_t;
#else
    using Type = struct { uint32 mData[4]; };
#endif
 
                                UVec4() = default; 
                                UVec4(const UVec4 &inRHS) = default;
    UVec4 &                     operator = (const UVec4 &inRHS) = default;
    JPH_INLINE                  UVec4(Type inRHS) : mValue(inRHS)                   { }
 
    JPH_INLINE                  UVec4(uint32 inX, uint32 inY, uint32 inZ, uint32 inW);
 
    JPH_INLINE bool             operator == (UVec4Arg inV2) const;
    JPH_INLINE bool             operator != (UVec4Arg inV2) const                   { return !(*this == inV2); }
 
    template<uint32 SwizzleX, uint32 SwizzleY, uint32 SwizzleZ, uint32 SwizzleW>
    JPH_INLINE UVec4            Swizzle() const;
 
    static JPH_INLINE UVec4     sZero();
 
    static JPH_INLINE UVec4     sReplicate(uint32 inV);
 
    static JPH_INLINE UVec4     sLoadInt(const uint32 *inV);
 
    static JPH_INLINE UVec4     sLoadInt4(const uint32 *inV);
 
    static JPH_INLINE UVec4     sLoadInt4Aligned(const uint32 *inV);
 
    template <const int Scale>
    static JPH_INLINE UVec4     sGatherInt4(const uint32 *inBase, UVec4Arg inOffsets);
 
    static JPH_INLINE UVec4     sMin(UVec4Arg inV1, UVec4Arg inV2);
 
    static JPH_INLINE UVec4     sMax(UVec4Arg inV1, UVec4Arg inV2);
 
    static JPH_INLINE UVec4     sEquals(UVec4Arg inV1, UVec4Arg inV2);
 
    static JPH_INLINE UVec4     sSelect(UVec4Arg inNotSet, UVec4Arg inSet, UVec4Arg inControl);
 
    static JPH_INLINE UVec4     sOr(UVec4Arg inV1, UVec4Arg inV2);
 
    static JPH_INLINE UVec4     sXor(UVec4Arg inV1, UVec4Arg inV2);
 
    static JPH_INLINE UVec4     sAnd(UVec4Arg inV1, UVec4Arg inV2);
 
    static JPH_INLINE UVec4     sNot(UVec4Arg inV1);
 
    static JPH_INLINE UVec4     sSort4True(UVec4Arg inValue, UVec4Arg inIndex);
 
#if defined(JPH_USE_SSE)
    JPH_INLINE uint32           GetX() const                                        { return uint32(_mm_cvtsi128_si32(mValue)); }
    JPH_INLINE uint32           GetY() const                                        { return mU32[1]; }
    JPH_INLINE uint32           GetZ() const                                        { return mU32[2]; }
    JPH_INLINE uint32           GetW() const                                        { return mU32[3]; }
#elif defined(JPH_USE_NEON)
    JPH_INLINE uint32           GetX() const                                        { return vgetq_lane_u32(mValue, 0); }
    JPH_INLINE uint32           GetY() const                                        { return vgetq_lane_u32(mValue, 1); }
    JPH_INLINE uint32           GetZ() const                                        { return vgetq_lane_u32(mValue, 2); }
    JPH_INLINE uint32           GetW() const                                        { return vgetq_lane_u32(mValue, 3); }
#else
    JPH_INLINE uint32           GetX() const                                        { return mU32[0]; }
    JPH_INLINE uint32           GetY() const                                        { return mU32[1]; }
    JPH_INLINE uint32           GetZ() const                                        { return mU32[2]; }
    JPH_INLINE uint32           GetW() const                                        { return mU32[3]; }
#endif
 
    JPH_INLINE void             SetX(uint32 inX)                                    { mU32[0] = inX; }
    JPH_INLINE void             SetY(uint32 inY)                                    { mU32[1] = inY; }
    JPH_INLINE void             SetZ(uint32 inZ)                                    { mU32[2] = inZ; }
    JPH_INLINE void             SetW(uint32 inW)                                    { mU32[3] = inW; }
 
    JPH_INLINE uint32           operator [] (uint inCoordinate) const               { JPH_ASSERT(inCoordinate < 4); return mU32[inCoordinate]; }
    JPH_INLINE uint32 &         operator [] (uint inCoordinate)                     { JPH_ASSERT(inCoordinate < 4); return mU32[inCoordinate]; }
 
    JPH_INLINE UVec4            operator * (UVec4Arg inV2) const;
 
    JPH_INLINE UVec4            operator + (UVec4Arg inV2);
 
    JPH_INLINE UVec4 &          operator += (UVec4Arg inV2);
 
    JPH_INLINE UVec4            SplatX() const;
 
    JPH_INLINE UVec4            SplatY() const;
 
    JPH_INLINE UVec4            SplatZ() const;
 
    JPH_INLINE UVec4            SplatW() const;
 
    JPH_INLINE Vec4             ToFloat() const;
 
    JPH_INLINE Vec4             ReinterpretAsFloat() const;
 
    JPH_INLINE void             StoreInt4(uint32 *outV) const;
 
    JPH_INLINE void             StoreInt4Aligned(uint32 *outV) const;
 
    JPH_INLINE bool             TestAnyTrue() const;
 
    JPH_INLINE bool             TestAnyXYZTrue() const;
 
    JPH_INLINE bool             TestAllTrue() const;
 
    JPH_INLINE bool             TestAllXYZTrue() const;
 
    JPH_INLINE int              CountTrues() const;
 
    JPH_INLINE int              GetTrues() const;
 
    template <const uint Count>
    JPH_INLINE UVec4            LogicalShiftLeft() const;
 
    template <const uint Count>
    JPH_INLINE UVec4            LogicalShiftRight() const;
 
    template <const uint Count>
    JPH_INLINE UVec4            ArithmeticShiftRight() const;
 
    JPH_INLINE UVec4            Expand4Uint16Lo() const;
 
    JPH_INLINE UVec4            Expand4Uint16Hi() const;
 
    JPH_INLINE UVec4            Expand4Byte0() const;
 
    JPH_INLINE UVec4            Expand4Byte4() const;
 
    JPH_INLINE UVec4            Expand4Byte8() const;
 
    JPH_INLINE UVec4            Expand4Byte12() const;
 
    JPH_INLINE UVec4            ShiftComponents4Minus(int inCount) const;
 
    friend ostream &            operator << (ostream &inStream, UVec4Arg inV)
    {
        inStream << inV.mU32[0] << ", " << inV.mU32[1] << ", " << inV.mU32[2] << ", " << inV.mU32[3];
        return inStream;
    }
 
    union
    {
        Type                    mValue;
        uint32                  mU32[4];
    };
};
 
static_assert(std::is_trivial<UVec4>(), "Is supposed to be a trivial type!");
 
JPH_NAMESPACE_END
 
#include "UVec4.inl"