Vec3.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/Core/StaticArray.h>
#include <Jolt/Math/Float3.h>
#include <Jolt/Math/Swizzle.h>
#include <Jolt/Math/MathTypes.h>
 
JPH_NAMESPACE_BEGIN

class [[nodiscard]] alignas(JPH_VECTOR_ALIGNMENT) Vec3
{
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 = Vec4::Type;
#endif
 
    // Argument type
    using ArgType = Vec3Arg;

                                Vec3() = default; 
                                Vec3(const Vec3 &inRHS) = default;
    Vec3 &                      operator = (const Vec3 &inRHS) = default;
    explicit JPH_INLINE         Vec3(Vec4Arg inRHS);
    JPH_INLINE                  Vec3(Type inRHS) : mValue(inRHS)                { CheckW(); }

    explicit JPH_INLINE         Vec3(const Float3 &inV);

    JPH_INLINE                  Vec3(float inX, float inY, float inZ);

    static JPH_INLINE Vec3      sZero();

    static JPH_INLINE Vec3      sOne();

    static JPH_INLINE Vec3      sNaN();

    static JPH_INLINE Vec3      sAxisX()                                        { return Vec3(1, 0, 0); }
    static JPH_INLINE Vec3      sAxisY()                                        { return Vec3(0, 1, 0); }
    static JPH_INLINE Vec3      sAxisZ()                                        { return Vec3(0, 0, 1); }

    static JPH_INLINE Vec3      sReplicate(float inV);

    static JPH_INLINE Vec3      sLoadFloat3Unsafe(const Float3 &inV);

    static JPH_INLINE Vec3      sMin(Vec3Arg inV1, Vec3Arg inV2);

    static JPH_INLINE Vec3      sMax(Vec3Arg inV1, Vec3Arg inV2);

    static JPH_INLINE Vec3      sClamp(Vec3Arg inV, Vec3Arg inMin, Vec3Arg inMax);

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

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

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

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

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

    static JPH_INLINE Vec3      sFusedMultiplyAdd(Vec3Arg inMul1, Vec3Arg inMul2, Vec3Arg inAdd);

    static JPH_INLINE Vec3      sSelect(Vec3Arg inNotSet, Vec3Arg inSet, UVec4Arg inControl);

    static JPH_INLINE Vec3      sOr(Vec3Arg inV1, Vec3Arg inV2);

    static JPH_INLINE Vec3      sXor(Vec3Arg inV1, Vec3Arg inV2);

    static JPH_INLINE Vec3      sAnd(Vec3Arg inV1, Vec3Arg inV2);

    static JPH_INLINE Vec3      sUnitSpherical(float inTheta, float inPhi);

    JPH_EXPORT static const StaticArray<Vec3, 1026> sUnitSphere;

    template <class Random>
    static inline Vec3          sRandom(Random &inRandom);

#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]; }
#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); }
#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]; }
#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] = mF32[3] = inZ; } // Assure Z and W are the same

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

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

    JPH_INLINE void             SetComponent(uint inCoordinate, float inValue)  { JPH_ASSERT(inCoordinate < 3); mF32[inCoordinate] = inValue; mValue = sFixW(mValue); } // Assure Z and W are the same

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

    JPH_INLINE bool             IsClose(Vec3Arg 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 Vec3             operator * (Vec3Arg inV2) const;

    JPH_INLINE Vec3             operator * (float inV2) const;

    friend JPH_INLINE Vec3      operator * (float inV1, Vec3Arg inV2);

    JPH_INLINE Vec3             operator / (float inV2) const;

    JPH_INLINE Vec3 &           operator *= (float inV2);

    JPH_INLINE Vec3 &           operator *= (Vec3Arg inV2);

    JPH_INLINE Vec3 &           operator /= (float inV2);

    JPH_INLINE Vec3             operator + (Vec3Arg inV2) const;

    JPH_INLINE Vec3 &           operator += (Vec3Arg inV2);

    JPH_INLINE Vec3             operator - () const;

    JPH_INLINE Vec3             operator - (Vec3Arg inV2) const;

    JPH_INLINE Vec3 &           operator -= (Vec3Arg inV2);

    JPH_INLINE Vec3             operator / (Vec3Arg inV2) const;

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

    JPH_INLINE Vec4             SplatX() const;

    JPH_INLINE Vec4             SplatY() const;

    JPH_INLINE Vec4             SplatZ() const;

    JPH_INLINE int              GetLowestComponentIndex() const;

    JPH_INLINE int              GetHighestComponentIndex() const;

    JPH_INLINE Vec3             Abs() const;

    JPH_INLINE Vec3             Reciprocal() const;

    JPH_INLINE static Vec3      sDifferenceOfProducts(Vec3Arg inA, Vec3Arg inB, Vec3Arg inC, Vec3Arg inD);

    JPH_INLINE Vec3             Cross(Vec3Arg inV2) const;

    JPH_INLINE Vec3             CrossPrecise(Vec3Arg inV2) const;

    JPH_INLINE Vec3             DotV(Vec3Arg inV2) const;

    JPH_INLINE Vec4             DotV4(Vec3Arg inV2) const;

    JPH_INLINE float            Dot(Vec3Arg inV2) const;

    JPH_INLINE float            LengthSq() const;

    JPH_INLINE float            Length() const;

    JPH_INLINE Vec3             Normalized() const;

    JPH_INLINE Vec3             NormalizedOr(Vec3Arg inZeroValue) const;

    JPH_INLINE void             StoreFloat3(Float3 *outV) const;

    JPH_INLINE UVec4            ToInt() const;

    JPH_INLINE UVec4            ReinterpretAsInt() const;

    JPH_INLINE float            ReduceMin() const;

    JPH_INLINE float            ReduceMax() const;

    JPH_INLINE float            ReduceSum() const;

    JPH_INLINE Vec3             Sqrt() const;

    JPH_INLINE Vec3             GetNormalizedPerpendicular() const;

    JPH_INLINE Vec3             GetSign() const;

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

    JPH_INLINE uint32           CompressUnitVector() const;

    JPH_INLINE static Vec3      sDecompressUnitVector(uint32 inValue);

    friend ostream &            operator << (ostream &inStream, Vec3Arg inV)
    {
        inStream << inV.mF32[0] << ", " << inV.mF32[1] << ", " << inV.mF32[2];
        return inStream;
    }

    JPH_INLINE void             CheckW() const;

    static JPH_INLINE Type      sFixW(Type inValue);
 
    union
    {
        Type                    mValue;
        float                   mF32[4];
    };
};
 
static_assert(std::is_trivially_default_constructible<Vec3>() && std::is_trivially_copyable<Vec3>(), "Is supposed to be a trivial type!");
 
JPH_NAMESPACE_END
 
#include "Vec3.inl"