DVec3.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/Double3.h>
 
JPH_NAMESPACE_BEGIN
 
class [[nodiscard]] alignas(JPH_DVECTOR_ALIGNMENT) DVec3
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    // Underlying vector type
#if defined(JPH_USE_AVX)
    using Type = __m256d;
    using TypeArg = __m256d;
#elif defined(JPH_USE_SSE)
    using Type = struct { __m128d mLow, mHigh; };
    using TypeArg = const Type &;
#elif defined(JPH_USE_NEON)
    using Type = float64x2x2_t;
    using TypeArg = const Type &;
#else
    using Type = struct { double mData[4]; };
    using TypeArg = const Type &;
#endif
 
    // Argument type
    using ArgType = DVec3Arg;
 
                                DVec3() = default; 
                                DVec3(const DVec3 &inRHS) = default;
    DVec3 &                     operator = (const DVec3 &inRHS) = default;
    JPH_INLINE explicit         DVec3(Vec3Arg inRHS);
    JPH_INLINE explicit         DVec3(Vec4Arg inRHS);
    JPH_INLINE                  DVec3(TypeArg inRHS) : mValue(inRHS)            { CheckW(); }
 
    JPH_INLINE                  DVec3(double inX, double inY, double inZ);
 
    explicit JPH_INLINE         DVec3(const Double3 &inV);
 
    static JPH_INLINE DVec3     sZero();
 
    static JPH_INLINE DVec3     sOne();
 
    static JPH_INLINE DVec3     sAxisX()                                        { return DVec3(1, 0, 0); }
    static JPH_INLINE DVec3     sAxisY()                                        { return DVec3(0, 1, 0); }
    static JPH_INLINE DVec3     sAxisZ()                                        { return DVec3(0, 0, 1); }
 
    static JPH_INLINE DVec3     sReplicate(double inV);
 
    static JPH_INLINE DVec3     sNaN();
 
    static JPH_INLINE DVec3     sLoadDouble3Unsafe(const Double3 &inV);
 
    JPH_INLINE void             StoreDouble3(Double3 *outV) const;
 
    JPH_INLINE explicit         operator Vec3() const;
 
    JPH_INLINE DVec3            PrepareRoundToZero() const;
 
    JPH_INLINE DVec3            PrepareRoundToInf() const;
 
    JPH_INLINE Vec3             ToVec3RoundDown() const;
 
    JPH_INLINE Vec3             ToVec3RoundUp() const;
 
    static JPH_INLINE DVec3     sMin(DVec3Arg inV1, DVec3Arg inV2);
 
    static JPH_INLINE DVec3     sMax(DVec3Arg inV1, DVec3Arg inV2);
 
    static JPH_INLINE DVec3     sClamp(DVec3Arg inV, DVec3Arg inMin, DVec3Arg inMax);
 
    static JPH_INLINE DVec3     sEquals(DVec3Arg inV1, DVec3Arg inV2);
 
    static JPH_INLINE DVec3     sLess(DVec3Arg inV1, DVec3Arg inV2);
 
    static JPH_INLINE DVec3     sLessOrEqual(DVec3Arg inV1, DVec3Arg inV2);
 
    static JPH_INLINE DVec3     sGreater(DVec3Arg inV1, DVec3Arg inV2);
 
    static JPH_INLINE DVec3     sGreaterOrEqual(DVec3Arg inV1, DVec3Arg inV2);
 
    static JPH_INLINE DVec3     sFusedMultiplyAdd(DVec3Arg inMul1, DVec3Arg inMul2, DVec3Arg inAdd);
 
    static JPH_INLINE DVec3     sSelect(DVec3Arg inNotSet, DVec3Arg inSet, DVec3Arg inControl);
 
    static JPH_INLINE DVec3     sOr(DVec3Arg inV1, DVec3Arg inV2);
 
    static JPH_INLINE DVec3     sXor(DVec3Arg inV1, DVec3Arg inV2);
 
    static JPH_INLINE DVec3     sAnd(DVec3Arg inV1, DVec3Arg inV2);
 
    JPH_INLINE int              GetTrues() const;
 
    JPH_INLINE bool             TestAnyTrue() const;
 
    JPH_INLINE bool             TestAllTrue() const;
 
#if defined(JPH_USE_AVX)
    JPH_INLINE double           GetX() const                                    { return _mm_cvtsd_f64(_mm256_castpd256_pd128(mValue)); }
    JPH_INLINE double           GetY() const                                    { return mF64[1]; }
    JPH_INLINE double           GetZ() const                                    { return mF64[2]; }
#elif defined(JPH_USE_SSE)
    JPH_INLINE double           GetX() const                                    { return _mm_cvtsd_f64(mValue.mLow); }
    JPH_INLINE double           GetY() const                                    { return mF64[1]; }
    JPH_INLINE double           GetZ() const                                    { return _mm_cvtsd_f64(mValue.mHigh); }
#elif defined(JPH_USE_NEON)
    JPH_INLINE double           GetX() const                                    { return vgetq_lane_f64(mValue.val[0], 0); }
    JPH_INLINE double           GetY() const                                    { return vgetq_lane_f64(mValue.val[0], 1); }
    JPH_INLINE double           GetZ() const                                    { return vgetq_lane_f64(mValue.val[1], 0); }
#else
    JPH_INLINE double           GetX() const                                    { return mF64[0]; }
    JPH_INLINE double           GetY() const                                    { return mF64[1]; }
    JPH_INLINE double           GetZ() const                                    { return mF64[2]; }
#endif
 
    JPH_INLINE void             SetX(double inX)                                { mF64[0] = inX; }
    JPH_INLINE void             SetY(double inY)                                { mF64[1] = inY; }
    JPH_INLINE void             SetZ(double inZ)                                { mF64[2] = mF64[3] = inZ; } // Assure Z and W are the same
 
    JPH_INLINE void             Set(double inX, double inY, double inZ)         { *this = DVec3(inX, inY, inZ); }
 
    JPH_INLINE double           operator [] (uint inCoordinate) const           { JPH_ASSERT(inCoordinate < 3); return mF64[inCoordinate]; }
 
    JPH_INLINE void             SetComponent(uint inCoordinate, double inValue) { JPH_ASSERT(inCoordinate < 3); mF64[inCoordinate] = inValue; mValue = sFixW(mValue); } // Assure Z and W are the same
 
    JPH_INLINE bool             operator == (DVec3Arg inV2) const;
    JPH_INLINE bool             operator != (DVec3Arg inV2) const               { return !(*this == inV2); }
 
    JPH_INLINE bool             IsClose(DVec3Arg inV2, double inMaxDistSq = 1.0e-24) const;
 
    JPH_INLINE bool             IsNearZero(double inMaxDistSq = 1.0e-24) const;
 
    JPH_INLINE bool             IsNormalized(double inTolerance = 1.0e-12) const;
 
    JPH_INLINE bool             IsNaN() const;
 
    JPH_INLINE DVec3            operator * (DVec3Arg inV2) const;
 
    JPH_INLINE DVec3            operator * (double inV2) const;
 
    friend JPH_INLINE DVec3     operator * (double inV1, DVec3Arg inV2);
 
    JPH_INLINE DVec3            operator / (double inV2) const;
 
    JPH_INLINE DVec3 &          operator *= (double inV2);
 
    JPH_INLINE DVec3 &          operator *= (DVec3Arg inV2);
 
    JPH_INLINE DVec3 &          operator /= (double inV2);
 
    JPH_INLINE DVec3            operator + (Vec3Arg inV2) const;
 
    JPH_INLINE DVec3            operator + (DVec3Arg inV2) const;
 
    JPH_INLINE DVec3 &          operator += (Vec3Arg inV2);
 
    JPH_INLINE DVec3 &          operator += (DVec3Arg inV2);
 
    JPH_INLINE DVec3            operator - () const;
 
    JPH_INLINE DVec3            operator - (Vec3Arg inV2) const;
 
    JPH_INLINE DVec3            operator - (DVec3Arg inV2) const;
 
    JPH_INLINE DVec3 &          operator -= (Vec3Arg inV2);
 
    JPH_INLINE DVec3 &          operator -= (DVec3Arg inV2);
 
    JPH_INLINE DVec3            operator / (DVec3Arg inV2) const;
 
    JPH_INLINE DVec3            Abs() const;
 
    JPH_INLINE DVec3            Reciprocal() const;
 
    JPH_INLINE DVec3            Cross(DVec3Arg inV2) const;
 
    JPH_INLINE double           Dot(DVec3Arg inV2) const;
 
    JPH_INLINE double           LengthSq() const;
 
    JPH_INLINE double           Length() const;
 
    JPH_INLINE DVec3            Normalized() const;
 
    JPH_INLINE DVec3            Sqrt() const;
 
    JPH_INLINE DVec3            GetSign() const;
 
    friend ostream &            operator << (ostream &inStream, DVec3Arg inV)
    {
        inStream << inV.mF64[0] << ", " << inV.mF64[1] << ", " << inV.mF64[2];
        return inStream;
    }
 
    JPH_INLINE void             CheckW() const;
 
    static JPH_INLINE Type      sFixW(TypeArg inValue);
 
    inline static const double  cTrue = BitCast<double>(~uint64(0));
    inline static const double  cFalse = 0.0;
 
    union
    {
        Type                    mValue;
        double                  mF64[4];
    };
};
 
static_assert(std::is_trivial<DVec3>(), "Is supposed to be a trivial type!");
 
JPH_NAMESPACE_END
 
#include "DVec3.inl"