@bloomengine/engine 0.3.3 → 0.4.1

package/native/third_party/JoltPhysics/Jolt/Math/DMat44.inl

@@ -1,310 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Math/DVec3.h>
-
-JPH_NAMESPACE_BEGIN
-
-DMat44::DMat44(Vec4Arg inC1, Vec4Arg inC2, Vec4Arg inC3, DVec3Arg inC4) :
-	mCol { inC1, inC2, inC3 },
-	mCol3(inC4)
-{
-}
-
-DMat44::DMat44(Type inC1, Type inC2, Type inC3, DTypeArg inC4) :
-	mCol { inC1, inC2, inC3 },
-	mCol3(inC4)
-{
-}
-
-DMat44::DMat44(Mat44Arg inM) :
-	mCol { inM.GetColumn4(0), inM.GetColumn4(1), inM.GetColumn4(2) },
-	mCol3(inM.GetTranslation())
-{
-}
-
-DMat44::DMat44(Mat44Arg inRot, DVec3Arg inT) :
-	mCol { inRot.GetColumn4(0), inRot.GetColumn4(1), inRot.GetColumn4(2) },
-	mCol3(inT)
-{
-}
-
-DMat44 DMat44::sZero()
-{
-	return DMat44(Vec4::sZero(), Vec4::sZero(), Vec4::sZero(), DVec3::sZero());
-}
-
-DMat44 DMat44::sIdentity()
-{
-	return DMat44(Vec4(1, 0, 0, 0), Vec4(0, 1, 0, 0), Vec4(0, 0, 1, 0), DVec3::sZero());
-}
-
-DMat44 DMat44::sInverseRotationTranslation(QuatArg inR, DVec3Arg inT)
-{
-	Mat44 m = Mat44::sRotation(inR.Conjugated());
-	DMat44 dm(m, DVec3::sZero());
-	dm.SetTranslation(-dm.Multiply3x3(inT));
-	return dm;
-}
-
-bool DMat44::operator == (DMat44Arg inM2) const
-{
-	return mCol[0] == inM2.mCol[0]
-		&& mCol[1] == inM2.mCol[1]
-		&& mCol[2] == inM2.mCol[2]
-		&& mCol3 == inM2.mCol3;
-}
-
-bool DMat44::IsClose(DMat44Arg inM2, float inMaxDistSq) const
-{
-	for (int i = 0; i < 3; ++i)
-		if (!mCol[i].IsClose(inM2.mCol[i], inMaxDistSq))
-			return false;
-	return mCol3.IsClose(inM2.mCol3, double(inMaxDistSq));
-}
-
-DVec3 DMat44::operator * (Vec3Arg inV) const
-{
-#if defined(JPH_USE_AVX)
-	__m128 t = _mm_mul_ps(mCol[0].mValue, _mm_shuffle_ps(inV.mValue, inV.mValue, _MM_SHUFFLE(0, 0, 0, 0)));
-	t = _mm_add_ps(t, _mm_mul_ps(mCol[1].mValue, _mm_shuffle_ps(inV.mValue, inV.mValue, _MM_SHUFFLE(1, 1, 1, 1))));
-	t = _mm_add_ps(t, _mm_mul_ps(mCol[2].mValue, _mm_shuffle_ps(inV.mValue, inV.mValue, _MM_SHUFFLE(2, 2, 2, 2))));
-	return DVec3::sFixW(_mm256_add_pd(mCol3.mValue, _mm256_cvtps_pd(t)));
-#elif defined(JPH_USE_SSE)
-	__m128 t = _mm_mul_ps(mCol[0].mValue, _mm_shuffle_ps(inV.mValue, inV.mValue, _MM_SHUFFLE(0, 0, 0, 0)));
-	t = _mm_add_ps(t, _mm_mul_ps(mCol[1].mValue, _mm_shuffle_ps(inV.mValue, inV.mValue, _MM_SHUFFLE(1, 1, 1, 1))));
-	t = _mm_add_ps(t, _mm_mul_ps(mCol[2].mValue, _mm_shuffle_ps(inV.mValue, inV.mValue, _MM_SHUFFLE(2, 2, 2, 2))));
-	__m128d low = _mm_add_pd(mCol3.mValue.mLow, _mm_cvtps_pd(t));
-	__m128d high = _mm_add_pd(mCol3.mValue.mHigh, _mm_cvtps_pd(_mm_shuffle_ps(t, t, _MM_SHUFFLE(2, 2, 2, 2))));
-	return DVec3({ low, high });
-#elif defined(JPH_USE_NEON)
-	float32x4_t t = vmulq_f32(mCol[0].mValue, vdupq_laneq_f32(inV.mValue, 0));
-	t = vmlaq_f32(t, mCol[1].mValue, vdupq_laneq_f32(inV.mValue, 1));
-	t = vmlaq_f32(t, mCol[2].mValue, vdupq_laneq_f32(inV.mValue, 2));
-	float64x2_t low = vaddq_f64(mCol3.mValue.val[0], vcvt_f64_f32(vget_low_f32(t)));
-	float64x2_t high = vaddq_f64(mCol3.mValue.val[1], vcvt_high_f64_f32(t));
-	return DVec3::sFixW({ low, high });
-#else
-	return DVec3(
-		mCol3.mF64[0] + double(mCol[0].mF32[0] * inV.mF32[0] + mCol[1].mF32[0] * inV.mF32[1] + mCol[2].mF32[0] * inV.mF32[2]),
-		mCol3.mF64[1] + double(mCol[0].mF32[1] * inV.mF32[0] + mCol[1].mF32[1] * inV.mF32[1] + mCol[2].mF32[1] * inV.mF32[2]),
-		mCol3.mF64[2] + double(mCol[0].mF32[2] * inV.mF32[0] + mCol[1].mF32[2] * inV.mF32[1] + mCol[2].mF32[2] * inV.mF32[2]));
-#endif
-}
-
-DVec3 DMat44::operator * (DVec3Arg inV) const
-{
-#if defined(JPH_USE_AVX)
-	__m256d t = _mm256_add_pd(mCol3.mValue, _mm256_mul_pd(_mm256_cvtps_pd(mCol[0].mValue), _mm256_set1_pd(inV.mF64[0])));
-	t = _mm256_add_pd(t, _mm256_mul_pd(_mm256_cvtps_pd(mCol[1].mValue), _mm256_set1_pd(inV.mF64[1])));
-	t = _mm256_add_pd(t, _mm256_mul_pd(_mm256_cvtps_pd(mCol[2].mValue), _mm256_set1_pd(inV.mF64[2])));
-	return DVec3::sFixW(t);
-#elif defined(JPH_USE_SSE)
-	__m128d xxxx = _mm_set1_pd(inV.mF64[0]);
-	__m128d yyyy = _mm_set1_pd(inV.mF64[1]);
-	__m128d zzzz = _mm_set1_pd(inV.mF64[2]);
-	__m128 col0 = mCol[0].mValue;
-	__m128 col1 = mCol[1].mValue;
-	__m128 col2 = mCol[2].mValue;
-	__m128d t_low = _mm_add_pd(mCol3.mValue.mLow, _mm_mul_pd(_mm_cvtps_pd(col0), xxxx));
-	t_low = _mm_add_pd(t_low, _mm_mul_pd(_mm_cvtps_pd(col1), yyyy));
-	t_low = _mm_add_pd(t_low, _mm_mul_pd(_mm_cvtps_pd(col2), zzzz));
-	__m128d t_high = _mm_add_pd(mCol3.mValue.mHigh, _mm_mul_pd(_mm_cvtps_pd(_mm_shuffle_ps(col0, col0, _MM_SHUFFLE(2, 2, 2, 2))), xxxx));
-	t_high = _mm_add_pd(t_high, _mm_mul_pd(_mm_cvtps_pd(_mm_shuffle_ps(col1, col1, _MM_SHUFFLE(2, 2, 2, 2))), yyyy));
-	t_high = _mm_add_pd(t_high, _mm_mul_pd(_mm_cvtps_pd(_mm_shuffle_ps(col2, col2, _MM_SHUFFLE(2, 2, 2, 2))), zzzz));
-	return DVec3({ t_low, t_high });
-#elif defined(JPH_USE_NEON)
-	float64x2_t xxxx = vdupq_laneq_f64(inV.mValue.val[0], 0);
-	float64x2_t yyyy = vdupq_laneq_f64(inV.mValue.val[0], 1);
-	float64x2_t zzzz = vdupq_laneq_f64(inV.mValue.val[1], 0);
-	float32x4_t col0 = mCol[0].mValue;
-	float32x4_t col1 = mCol[1].mValue;
-	float32x4_t col2 = mCol[2].mValue;
-	float64x2_t t_low = vaddq_f64(mCol3.mValue.val[0], vmulq_f64(vcvt_f64_f32(vget_low_f32(col0)), xxxx));
-	t_low = vaddq_f64(t_low, vmulq_f64(vcvt_f64_f32(vget_low_f32(col1)), yyyy));
-	t_low = vaddq_f64(t_low, vmulq_f64(vcvt_f64_f32(vget_low_f32(col2)), zzzz));
-	float64x2_t t_high = vaddq_f64(mCol3.mValue.val[1], vmulq_f64(vcvt_high_f64_f32(col0), xxxx));
-	t_high = vaddq_f64(t_high, vmulq_f64(vcvt_high_f64_f32(col1), yyyy));
-	t_high = vaddq_f64(t_high, vmulq_f64(vcvt_high_f64_f32(col2), zzzz));
-	return DVec3::sFixW({ t_low, t_high });
-#else
-	return DVec3(
-		mCol3.mF64[0] + double(mCol[0].mF32[0]) * inV.mF64[0] + double(mCol[1].mF32[0]) * inV.mF64[1] + double(mCol[2].mF32[0]) * inV.mF64[2],
-		mCol3.mF64[1] + double(mCol[0].mF32[1]) * inV.mF64[0] + double(mCol[1].mF32[1]) * inV.mF64[1] + double(mCol[2].mF32[1]) * inV.mF64[2],
-		mCol3.mF64[2] + double(mCol[0].mF32[2]) * inV.mF64[0] + double(mCol[1].mF32[2]) * inV.mF64[1] + double(mCol[2].mF32[2]) * inV.mF64[2]);
-#endif
-}
-
-DVec3 DMat44::Multiply3x3(DVec3Arg inV) const
-{
-#if defined(JPH_USE_AVX)
-	__m256d t = _mm256_mul_pd(_mm256_cvtps_pd(mCol[0].mValue), _mm256_set1_pd(inV.mF64[0]));
-	t = _mm256_add_pd(t, _mm256_mul_pd(_mm256_cvtps_pd(mCol[1].mValue), _mm256_set1_pd(inV.mF64[1])));
-	t = _mm256_add_pd(t, _mm256_mul_pd(_mm256_cvtps_pd(mCol[2].mValue), _mm256_set1_pd(inV.mF64[2])));
-	return DVec3::sFixW(t);
-#elif defined(JPH_USE_SSE)
-	__m128d xxxx = _mm_set1_pd(inV.mF64[0]);
-	__m128d yyyy = _mm_set1_pd(inV.mF64[1]);
-	__m128d zzzz = _mm_set1_pd(inV.mF64[2]);
-	__m128 col0 = mCol[0].mValue;
-	__m128 col1 = mCol[1].mValue;
-	__m128 col2 = mCol[2].mValue;
-	__m128d t_low = _mm_mul_pd(_mm_cvtps_pd(col0), xxxx);
-	t_low = _mm_add_pd(t_low, _mm_mul_pd(_mm_cvtps_pd(col1), yyyy));
-	t_low = _mm_add_pd(t_low, _mm_mul_pd(_mm_cvtps_pd(col2), zzzz));
-	__m128d t_high = _mm_mul_pd(_mm_cvtps_pd(_mm_shuffle_ps(col0, col0, _MM_SHUFFLE(2, 2, 2, 2))), xxxx);
-	t_high = _mm_add_pd(t_high, _mm_mul_pd(_mm_cvtps_pd(_mm_shuffle_ps(col1, col1, _MM_SHUFFLE(2, 2, 2, 2))), yyyy));
-	t_high = _mm_add_pd(t_high, _mm_mul_pd(_mm_cvtps_pd(_mm_shuffle_ps(col2, col2, _MM_SHUFFLE(2, 2, 2, 2))), zzzz));
-	return DVec3({ t_low, t_high });
-#elif defined(JPH_USE_NEON)
-	float64x2_t xxxx = vdupq_laneq_f64(inV.mValue.val[0], 0);
-	float64x2_t yyyy = vdupq_laneq_f64(inV.mValue.val[0], 1);
-	float64x2_t zzzz = vdupq_laneq_f64(inV.mValue.val[1], 0);
-	float32x4_t col0 = mCol[0].mValue;
-	float32x4_t col1 = mCol[1].mValue;
-	float32x4_t col2 = mCol[2].mValue;
-	float64x2_t t_low = vmulq_f64(vcvt_f64_f32(vget_low_f32(col0)), xxxx);
-	t_low = vaddq_f64(t_low, vmulq_f64(vcvt_f64_f32(vget_low_f32(col1)), yyyy));
-	t_low = vaddq_f64(t_low, vmulq_f64(vcvt_f64_f32(vget_low_f32(col2)), zzzz));
-	float64x2_t t_high = vmulq_f64(vcvt_high_f64_f32(col0), xxxx);
-	t_high = vaddq_f64(t_high, vmulq_f64(vcvt_high_f64_f32(col1), yyyy));
-	t_high = vaddq_f64(t_high, vmulq_f64(vcvt_high_f64_f32(col2), zzzz));
-	return DVec3::sFixW({ t_low, t_high });
-#else
-	return DVec3(
-		double(mCol[0].mF32[0]) * inV.mF64[0] + double(mCol[1].mF32[0]) * inV.mF64[1] + double(mCol[2].mF32[0]) * inV.mF64[2],
-		double(mCol[0].mF32[1]) * inV.mF64[0] + double(mCol[1].mF32[1]) * inV.mF64[1] + double(mCol[2].mF32[1]) * inV.mF64[2],
-		double(mCol[0].mF32[2]) * inV.mF64[0] + double(mCol[1].mF32[2]) * inV.mF64[1] + double(mCol[2].mF32[2]) * inV.mF64[2]);
-#endif
-}
-
-DMat44 DMat44::operator * (Mat44Arg inM) const
-{
-	DMat44 result;
-
-	// Rotation part
-#if defined(JPH_USE_SSE)
-	for (int i = 0; i < 3; ++i)
-	{
-		__m128 c = inM.GetColumn4(i).mValue;
-		__m128 t = _mm_mul_ps(mCol[0].mValue, _mm_shuffle_ps(c, c, _MM_SHUFFLE(0, 0, 0, 0)));
-		t = _mm_add_ps(t, _mm_mul_ps(mCol[1].mValue, _mm_shuffle_ps(c, c, _MM_SHUFFLE(1, 1, 1, 1))));
-		t = _mm_add_ps(t, _mm_mul_ps(mCol[2].mValue, _mm_shuffle_ps(c, c, _MM_SHUFFLE(2, 2, 2, 2))));
-		result.mCol[i].mValue = t;
-	}
-#elif defined(JPH_USE_NEON)
-	for (int i = 0; i < 3; ++i)
-	{
-		Type c = inM.GetColumn4(i).mValue;
-		Type t = vmulq_f32(mCol[0].mValue, vdupq_laneq_f32(c, 0));
-		t = vmlaq_f32(t, mCol[1].mValue, vdupq_laneq_f32(c, 1));
-		t = vmlaq_f32(t, mCol[2].mValue, vdupq_laneq_f32(c, 2));
-		result.mCol[i].mValue = t;
-	}
-#else
-	for (int i = 0; i < 3; ++i)
-	{
-		Vec4 coli = inM.GetColumn4(i);
-		result.mCol[i] = mCol[0] * coli.mF32[0] + mCol[1] * coli.mF32[1] + mCol[2] * coli.mF32[2];
-	}
-#endif
-
-	// Translation part
-	result.mCol3 = *this * inM.GetTranslation();
-
-	return result;
-}
-
-DMat44 DMat44::operator * (DMat44Arg inM) const
-{
-	DMat44 result;
-
-	// Rotation part
-#if defined(JPH_USE_SSE)
-	for (int i = 0; i < 3; ++i)
-	{
-		__m128 c = inM.mCol[i].mValue;
-		__m128 t = _mm_mul_ps(mCol[0].mValue, _mm_shuffle_ps(c, c, _MM_SHUFFLE(0, 0, 0, 0)));
-		t = _mm_add_ps(t, _mm_mul_ps(mCol[1].mValue, _mm_shuffle_ps(c, c, _MM_SHUFFLE(1, 1, 1, 1))));
-		t = _mm_add_ps(t, _mm_mul_ps(mCol[2].mValue, _mm_shuffle_ps(c, c, _MM_SHUFFLE(2, 2, 2, 2))));
-		result.mCol[i].mValue = t;
-	}
-#elif defined(JPH_USE_NEON)
-	for (int i = 0; i < 3; ++i)
-	{
-		Type c = inM.GetColumn4(i).mValue;
-		Type t = vmulq_f32(mCol[0].mValue, vdupq_laneq_f32(c, 0));
-		t = vmlaq_f32(t, mCol[1].mValue, vdupq_laneq_f32(c, 1));
-		t = vmlaq_f32(t, mCol[2].mValue, vdupq_laneq_f32(c, 2));
-		result.mCol[i].mValue = t;
-	}
-#else
-	for (int i = 0; i < 3; ++i)
-	{
-		Vec4 coli = inM.mCol[i];
-		result.mCol[i] = mCol[0] * coli.mF32[0] + mCol[1] * coli.mF32[1] + mCol[2] * coli.mF32[2];
-	}
-#endif
-
-	// Translation part
-	result.mCol3 = *this * inM.GetTranslation();
-
-	return result;
-}
-
-void DMat44::SetRotation(Mat44Arg inRotation)
-{
-	mCol[0] = inRotation.GetColumn4(0);
-	mCol[1] = inRotation.GetColumn4(1);
-	mCol[2] = inRotation.GetColumn4(2);
-}
-
-DMat44 DMat44::PreScaled(Vec3Arg inScale) const
-{
-	return DMat44(inScale.GetX() * mCol[0], inScale.GetY() * mCol[1], inScale.GetZ() * mCol[2], mCol3);
-}
-
-DMat44 DMat44::PostScaled(Vec3Arg inScale) const
-{
-	Vec4 scale(inScale, 1);
-	return DMat44(scale * mCol[0], scale * mCol[1], scale * mCol[2], DVec3(scale) * mCol3);
-}
-
-DMat44 DMat44::PreTranslated(Vec3Arg inTranslation) const
-{
-	return DMat44(mCol[0], mCol[1], mCol[2], GetTranslation() + Multiply3x3(inTranslation));
-}
-
-DMat44 DMat44::PreTranslated(DVec3Arg inTranslation) const
-{
-	return DMat44(mCol[0], mCol[1], mCol[2], GetTranslation() + Multiply3x3(inTranslation));
-}
-
-DMat44 DMat44::PostTranslated(Vec3Arg inTranslation) const
-{
-	return DMat44(mCol[0], mCol[1], mCol[2], GetTranslation() + inTranslation);
-}
-
-DMat44 DMat44::PostTranslated(DVec3Arg inTranslation) const
-{
-	return DMat44(mCol[0], mCol[1], mCol[2], GetTranslation() + inTranslation);
-}
-
-DMat44 DMat44::Inversed() const
-{
-	DMat44 m(GetRotation().Inversed3x3());
-	m.mCol3 = -m.Multiply3x3(mCol3);
-	return m;
-}
-
-DMat44 DMat44::InversedRotationTranslation() const
-{
-	DMat44 m(GetRotation().Transposed3x3());
-	m.mCol3 = -m.Multiply3x3(mCol3);
-	return m;
-}
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Math/DVec3.h

@@ -1,291 +0,0 @@
-// 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
-
-/// 3 component vector of doubles (stored as 4 vectors).
-/// Note that we keep the 4th component the same as the 3rd component to avoid divisions by zero when JPH_FLOATING_POINT_EXCEPTIONS_ENABLED defined
-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;
-
-	/// Constructor
-								DVec3() = default; ///< Intentionally not initialized for performance reasons
-								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(); }
-
-	/// Create a vector from 3 components
-	JPH_INLINE					DVec3(double inX, double inY, double inZ);
-
-	/// Load 3 doubles from memory
-	explicit JPH_INLINE			DVec3(const Double3 &inV);
-
-	/// Vector with all zeros
-	static JPH_INLINE DVec3		sZero();
-
-	/// Vector with all ones
-	static JPH_INLINE DVec3		sOne();
-
-	/// Vectors with the principal axis
-	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); }
-
-	/// Replicate inV across all components
-	static JPH_INLINE DVec3		sReplicate(double inV);
-
-	/// Vector with all NaN's
-	static JPH_INLINE DVec3		sNaN();
-
-	/// Load 3 doubles from memory (reads 64 bits extra which it doesn't use)
-	static JPH_INLINE DVec3		sLoadDouble3Unsafe(const Double3 &inV);
-
-	/// Store 3 doubles to memory
-	JPH_INLINE void				StoreDouble3(Double3 *outV) const;
-
-	/// Convert to float vector 3 rounding to nearest
-	JPH_INLINE explicit			operator Vec3() const;
-
-	/// Prepare to convert to float vector 3 rounding towards zero (returns DVec3 that can be converted to a Vec3 to get the rounding)
-	JPH_INLINE DVec3			PrepareRoundToZero() const;
-
-	/// Prepare to convert to float vector 3 rounding towards positive/negative inf (returns DVec3 that can be converted to a Vec3 to get the rounding)
-	JPH_INLINE DVec3			PrepareRoundToInf() const;
-
-	/// Convert to float vector 3 rounding down
-	JPH_INLINE Vec3				ToVec3RoundDown() const;
-
-	/// Convert to float vector 3 rounding up
-	JPH_INLINE Vec3				ToVec3RoundUp() const;
-
-	/// Return the minimum value of each of the components
-	static JPH_INLINE DVec3		sMin(DVec3Arg inV1, DVec3Arg inV2);
-
-	/// Return the maximum of each of the components
-	static JPH_INLINE DVec3		sMax(DVec3Arg inV1, DVec3Arg inV2);
-
-	/// Clamp a vector between min and max (component wise)
-	static JPH_INLINE DVec3		sClamp(DVec3Arg inV, DVec3Arg inMin, DVec3Arg inMax);
-
-	/// Equals (component wise)
-	static JPH_INLINE DVec3		sEquals(DVec3Arg inV1, DVec3Arg inV2);
-
-	/// Less than (component wise)
-	static JPH_INLINE DVec3		sLess(DVec3Arg inV1, DVec3Arg inV2);
-
-	/// Less than or equal (component wise)
-	static JPH_INLINE DVec3		sLessOrEqual(DVec3Arg inV1, DVec3Arg inV2);
-
-	/// Greater than (component wise)
-	static JPH_INLINE DVec3		sGreater(DVec3Arg inV1, DVec3Arg inV2);
-
-	/// Greater than or equal (component wise)
-	static JPH_INLINE DVec3		sGreaterOrEqual(DVec3Arg inV1, DVec3Arg inV2);
-
-	/// Calculates inMul1 * inMul2 + inAdd
-	static JPH_INLINE DVec3		sFusedMultiplyAdd(DVec3Arg inMul1, DVec3Arg inMul2, DVec3Arg inAdd);
-
-	/// Component wise select, returns inNotSet when highest bit of inControl = 0 and inSet when highest bit of inControl = 1
-	static JPH_INLINE DVec3		sSelect(DVec3Arg inNotSet, DVec3Arg inSet, DVec3Arg inControl);
-
-	/// Logical or (component wise)
-	static JPH_INLINE DVec3		sOr(DVec3Arg inV1, DVec3Arg inV2);
-
-	/// Logical xor (component wise)
-	static JPH_INLINE DVec3		sXor(DVec3Arg inV1, DVec3Arg inV2);
-
-	/// Logical and (component wise)
-	static JPH_INLINE DVec3		sAnd(DVec3Arg inV1, DVec3Arg inV2);
-
-	/// Store if X is true in bit 0, Y in bit 1, Z in bit 2 and W in bit 3 (true is when highest bit of component is set)
-	JPH_INLINE int				GetTrues() const;
-
-	/// Test if any of the components are true (true is when highest bit of component is set)
-	JPH_INLINE bool				TestAnyTrue() const;
-
-	/// Test if all components are true (true is when highest bit of component is set)
-	JPH_INLINE bool				TestAllTrue() const;
-
-	/// Get individual components
-#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
-
-	/// Set individual components
-	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
-
-	/// Set all components
-	JPH_INLINE void				Set(double inX, double inY, double inZ)			{ *this = DVec3(inX, inY, inZ); }
-
-	/// Get double component by index
-	JPH_INLINE double			operator [] (uint inCoordinate) const			{ JPH_ASSERT(inCoordinate < 3); return mF64[inCoordinate]; }
-
-	/// Set double component by index
-	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
-
-	/// Comparison
-	JPH_INLINE bool				operator == (DVec3Arg inV2) const;
-	JPH_INLINE bool				operator != (DVec3Arg inV2) const				{ return !(*this == inV2); }
-
-	/// Test if two vectors are close
-	JPH_INLINE bool				IsClose(DVec3Arg inV2, double inMaxDistSq = 1.0e-24) const;
-
-	/// Test if vector is near zero
-	JPH_INLINE bool				IsNearZero(double inMaxDistSq = 1.0e-24) const;
-
-	/// Test if vector is normalized
-	JPH_INLINE bool				IsNormalized(double inTolerance = 1.0e-12) const;
-
-	/// Test if vector contains NaN elements
-	JPH_INLINE bool				IsNaN() const;
-
-	/// Multiply two double vectors (component wise)
-	JPH_INLINE DVec3			operator * (DVec3Arg inV2) const;
-
-	/// Multiply vector with double
-	JPH_INLINE DVec3			operator * (double inV2) const;
-
-	/// Multiply vector with double
-	friend JPH_INLINE DVec3		operator * (double inV1, DVec3Arg inV2);
-
-	/// Divide vector by double
-	JPH_INLINE DVec3			operator / (double inV2) const;
-
-	/// Multiply vector with double
-	JPH_INLINE DVec3 &			operator *= (double inV2);
-
-	/// Multiply vector with vector
-	JPH_INLINE DVec3 &			operator *= (DVec3Arg inV2);
-
-	/// Divide vector by double
-	JPH_INLINE DVec3 &			operator /= (double inV2);
-
-	/// Add two vectors (component wise)
-	JPH_INLINE DVec3			operator + (Vec3Arg inV2) const;
-
-	/// Add two double vectors (component wise)
-	JPH_INLINE DVec3			operator + (DVec3Arg inV2) const;
-
-	/// Add two vectors (component wise)
-	JPH_INLINE DVec3 &			operator += (Vec3Arg inV2);
-
-	/// Add two double vectors (component wise)
-	JPH_INLINE DVec3 &			operator += (DVec3Arg inV2);
-
-	/// Negate
-	JPH_INLINE DVec3			operator - () const;
-
-	/// Subtract two vectors (component wise)
-	JPH_INLINE DVec3			operator - (Vec3Arg inV2) const;
-
-	/// Subtract two double vectors (component wise)
-	JPH_INLINE DVec3			operator - (DVec3Arg inV2) const;
-
-	/// Subtract two vectors (component wise)
-	JPH_INLINE DVec3 &			operator -= (Vec3Arg inV2);
-
-	/// Subtract two vectors (component wise)
-	JPH_INLINE DVec3 &			operator -= (DVec3Arg inV2);
-
-	/// Divide (component wise)
-	JPH_INLINE DVec3			operator / (DVec3Arg inV2) const;
-
-	/// Return the absolute value of each of the components
-	JPH_INLINE DVec3			Abs() const;
-
-	/// Reciprocal vector (1 / value) for each of the components
-	JPH_INLINE DVec3			Reciprocal() const;
-
-	/// Cross product
-	JPH_INLINE DVec3			Cross(DVec3Arg inV2) const;
-
-	/// Dot product
-	JPH_INLINE double			Dot(DVec3Arg inV2) const;
-
-	/// Squared length of vector
-	JPH_INLINE double			LengthSq() const;
-
-	/// Length of vector
-	JPH_INLINE double			Length() const;
-
-	/// Normalize vector
-	JPH_INLINE DVec3			Normalized() const;
-
-	/// Component wise square root
-	JPH_INLINE DVec3			Sqrt() const;
-
-	/// Get vector that contains the sign of each element (returns 1 if positive, -1 if negative)
-	JPH_INLINE DVec3			GetSign() const;
-
-	/// To String
-	friend ostream &			operator << (ostream &inStream, DVec3Arg inV)
-	{
-		inStream << inV.mF64[0] << ", " << inV.mF64[1] << ", " << inV.mF64[2];
-		return inStream;
-	}
-
-	/// Internal helper function that checks that W is equal to Z, so e.g. dividing by it should not generate div by 0
-	JPH_INLINE void				CheckW() const;
-
-	/// Internal helper function that ensures that the Z component is replicated to the W component to prevent divisions by zero
-	static JPH_INLINE Type		sFixW(TypeArg inValue);
-
-	/// Representations of true and false for boolean operations
-	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"