@bloomengine/engine 0.4.0 → 0.4.1

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

@@ -1,941 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/HashCombine.h>
-
-// Create a std::hash/JPH::Hash for DVec3
-JPH_MAKE_HASHABLE(JPH::DVec3, t.GetX(), t.GetY(), t.GetZ())
-
-JPH_NAMESPACE_BEGIN
-
-DVec3::DVec3(Vec3Arg inRHS)
-{
-#if defined(JPH_USE_AVX)
-	mValue = _mm256_cvtps_pd(inRHS.mValue);
-#elif defined(JPH_USE_SSE)
-	mValue.mLow = _mm_cvtps_pd(inRHS.mValue);
-	mValue.mHigh = _mm_cvtps_pd(_mm_shuffle_ps(inRHS.mValue, inRHS.mValue, _MM_SHUFFLE(2, 2, 2, 2)));
-#elif defined(JPH_USE_NEON)
-	mValue.val[0] = vcvt_f64_f32(vget_low_f32(inRHS.mValue));
-	mValue.val[1] = vcvt_high_f64_f32(inRHS.mValue);
-#else
-	mF64[0] = (double)inRHS.GetX();
-	mF64[1] = (double)inRHS.GetY();
-	mF64[2] = (double)inRHS.GetZ();
-	#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-		mF64[3] = mF64[2];
-	#endif
-#endif
-}
-
-DVec3::DVec3(Vec4Arg inRHS) :
-	DVec3(Vec3(inRHS))
-{
-}
-
-DVec3::DVec3(double inX, double inY, double inZ)
-{
-#if defined(JPH_USE_AVX)
-	mValue = _mm256_set_pd(inZ, inZ, inY, inX); // Assure Z and W are the same
-#elif defined(JPH_USE_SSE)
-	mValue.mLow = _mm_set_pd(inY, inX);
-	mValue.mHigh = _mm_set1_pd(inZ);
-#elif defined(JPH_USE_NEON)
-	mValue.val[0] = vcombine_f64(vcreate_f64(BitCast<uint64>(inX)), vcreate_f64(BitCast<uint64>(inY)));
-	mValue.val[1] = vdupq_n_f64(inZ);
-#else
-	mF64[0] = inX;
-	mF64[1] = inY;
-	mF64[2] = inZ;
-	#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-		mF64[3] = mF64[2];
-	#endif
-#endif
-}
-
-DVec3::DVec3(const Double3 &inV)
-{
-#if defined(JPH_USE_AVX)
-	Type x = _mm256_castpd128_pd256(_mm_load_sd(&inV.x));
-	Type y = _mm256_castpd128_pd256(_mm_load_sd(&inV.y));
-	Type z = _mm256_broadcast_sd(&inV.z);
-	Type xy = _mm256_unpacklo_pd(x, y);
-	mValue = _mm256_blend_pd(xy, z, 0b1100); // Assure Z and W are the same
-#elif defined(JPH_USE_SSE)
-	mValue.mLow = _mm_loadu_pd(&inV.x);
-	mValue.mHigh = _mm_set1_pd(inV.z);
-#elif defined(JPH_USE_NEON)
-	mValue.val[0] = vld1q_f64(&inV.x);
-	mValue.val[1] = vdupq_n_f64(inV.z);
-#else
-	mF64[0] = inV.x;
-	mF64[1] = inV.y;
-	mF64[2] = inV.z;
-	#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-		mF64[3] = mF64[2];
-	#endif
-#endif
-}
-
-void DVec3::CheckW() const
-{
-#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-	// Avoid asserts when both components are NaN
-	JPH_ASSERT(reinterpret_cast<const uint64 *>(mF64)[2] == reinterpret_cast<const uint64 *>(mF64)[3]);
-#endif // JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-}
-
-/// Internal helper function that ensures that the Z component is replicated to the W component to prevent divisions by zero
-DVec3::Type DVec3::sFixW(TypeArg inValue)
-{
-#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-	#if defined(JPH_USE_AVX)
-		return _mm256_shuffle_pd(inValue, inValue, 2);
-	#elif defined(JPH_USE_SSE)
-		Type value;
-		value.mLow = inValue.mLow;
-		value.mHigh = _mm_shuffle_pd(inValue.mHigh, inValue.mHigh, 0);
-		return value;
-	#elif defined(JPH_USE_NEON)
-		Type value;
-		value.val[0] = inValue.val[0];
-		value.val[1] = vdupq_laneq_f64(inValue.val[1], 0);
-		return value;
-	#else
-		Type value;
-		value.mData[0] = inValue.mData[0];
-		value.mData[1] = inValue.mData[1];
-		value.mData[2] = inValue.mData[2];
-		value.mData[3] = inValue.mData[2];
-		return value;
-	#endif
-#else
-	return inValue;
-#endif // JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-}
-
-DVec3 DVec3::sZero()
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_setzero_pd();
-#elif defined(JPH_USE_SSE)
-	__m128d zero = _mm_setzero_pd();
-	return DVec3({ zero, zero });
-#elif defined(JPH_USE_NEON)
-	float64x2_t zero = vdupq_n_f64(0.0);
-	return DVec3({ zero, zero });
-#else
-	return DVec3(0, 0, 0);
-#endif
-}
-
-DVec3 DVec3::sReplicate(double inV)
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_set1_pd(inV);
-#elif defined(JPH_USE_SSE)
-	__m128d value = _mm_set1_pd(inV);
-	return DVec3({ value, value });
-#elif defined(JPH_USE_NEON)
-	float64x2_t value = vdupq_n_f64(inV);
-	return DVec3({ value, value });
-#else
-	return DVec3(inV, inV, inV);
-#endif
-}
-
-DVec3 DVec3::sOne()
-{
-	return sReplicate(1.0);
-}
-
-DVec3 DVec3::sNaN()
-{
-	return sReplicate(numeric_limits<double>::quiet_NaN());
-}
-
-DVec3 DVec3::sLoadDouble3Unsafe(const Double3 &inV)
-{
-#if defined(JPH_USE_AVX)
-	Type v = _mm256_loadu_pd(&inV.x);
-#elif defined(JPH_USE_SSE)
-	Type v;
-	v.mLow = _mm_loadu_pd(&inV.x);
-	v.mHigh = _mm_set1_pd(inV.z);
-#elif defined(JPH_USE_NEON)
-	Type v = vld1q_f64_x2(&inV.x);
-#else
-	Type v = { inV.x, inV.y, inV.z };
-#endif
-	return sFixW(v);
-}
-
-void DVec3::StoreDouble3(Double3 *outV) const
-{
-	outV->x = mF64[0];
-	outV->y = mF64[1];
-	outV->z = mF64[2];
-}
-
-DVec3::operator Vec3() const
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_cvtpd_ps(mValue);
-#elif defined(JPH_USE_SSE)
-	__m128 low = _mm_cvtpd_ps(mValue.mLow);
-	__m128 high = _mm_cvtpd_ps(mValue.mHigh);
-	return _mm_shuffle_ps(low, high, _MM_SHUFFLE(1, 0, 1, 0));
-#elif defined(JPH_USE_NEON)
-	return vcvt_high_f32_f64(vcvtx_f32_f64(mValue.val[0]), mValue.val[1]);
-#else
-	return Vec3((float)GetX(), (float)GetY(), (float)GetZ());
-#endif
-}
-
-DVec3 DVec3::sMin(DVec3Arg inV1, DVec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_min_pd(inV1.mValue, inV2.mValue);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_min_pd(inV1.mValue.mLow, inV2.mValue.mLow), _mm_min_pd(inV1.mValue.mHigh, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vminq_f64(inV1.mValue.val[0], inV2.mValue.val[0]), vminq_f64(inV1.mValue.val[1], inV2.mValue.val[1]) });
-#else
-	return DVec3(min(inV1.mF64[0], inV2.mF64[0]),
-				 min(inV1.mF64[1], inV2.mF64[1]),
-				 min(inV1.mF64[2], inV2.mF64[2]));
-#endif
-}
-
-DVec3 DVec3::sMax(DVec3Arg inV1, DVec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_max_pd(inV1.mValue, inV2.mValue);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_max_pd(inV1.mValue.mLow, inV2.mValue.mLow), _mm_max_pd(inV1.mValue.mHigh, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vmaxq_f64(inV1.mValue.val[0], inV2.mValue.val[0]), vmaxq_f64(inV1.mValue.val[1], inV2.mValue.val[1]) });
-#else
-	return DVec3(max(inV1.mF64[0], inV2.mF64[0]),
-				 max(inV1.mF64[1], inV2.mF64[1]),
-				 max(inV1.mF64[2], inV2.mF64[2]));
-#endif
-}
-
-DVec3 DVec3::sClamp(DVec3Arg inV, DVec3Arg inMin, DVec3Arg inMax)
-{
-	return sMax(sMin(inV, inMax), inMin);
-}
-
-DVec3 DVec3::sEquals(DVec3Arg inV1, DVec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_cmp_pd(inV1.mValue, inV2.mValue, _CMP_EQ_OQ);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_cmpeq_pd(inV1.mValue.mLow, inV2.mValue.mLow), _mm_cmpeq_pd(inV1.mValue.mHigh, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vreinterpretq_f64_u64(vceqq_f64(inV1.mValue.val[0], inV2.mValue.val[0])), vreinterpretq_f64_u64(vceqq_f64(inV1.mValue.val[1], inV2.mValue.val[1])) });
-#else
-	return DVec3(inV1.mF64[0] == inV2.mF64[0]? cTrue : cFalse,
-				 inV1.mF64[1] == inV2.mF64[1]? cTrue : cFalse,
-				 inV1.mF64[2] == inV2.mF64[2]? cTrue : cFalse);
-#endif
-}
-
-DVec3 DVec3::sLess(DVec3Arg inV1, DVec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_cmp_pd(inV1.mValue, inV2.mValue, _CMP_LT_OQ);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_cmplt_pd(inV1.mValue.mLow, inV2.mValue.mLow), _mm_cmplt_pd(inV1.mValue.mHigh, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vreinterpretq_f64_u64(vcltq_f64(inV1.mValue.val[0], inV2.mValue.val[0])), vreinterpretq_f64_u64(vcltq_f64(inV1.mValue.val[1], inV2.mValue.val[1])) });
-#else
-	return DVec3(inV1.mF64[0] < inV2.mF64[0]? cTrue : cFalse,
-				 inV1.mF64[1] < inV2.mF64[1]? cTrue : cFalse,
-				 inV1.mF64[2] < inV2.mF64[2]? cTrue : cFalse);
-#endif
-}
-
-DVec3 DVec3::sLessOrEqual(DVec3Arg inV1, DVec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_cmp_pd(inV1.mValue, inV2.mValue, _CMP_LE_OQ);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_cmple_pd(inV1.mValue.mLow, inV2.mValue.mLow), _mm_cmple_pd(inV1.mValue.mHigh, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vreinterpretq_f64_u64(vcleq_f64(inV1.mValue.val[0], inV2.mValue.val[0])), vreinterpretq_f64_u64(vcleq_f64(inV1.mValue.val[1], inV2.mValue.val[1])) });
-#else
-	return DVec3(inV1.mF64[0] <= inV2.mF64[0]? cTrue : cFalse,
-				 inV1.mF64[1] <= inV2.mF64[1]? cTrue : cFalse,
-				 inV1.mF64[2] <= inV2.mF64[2]? cTrue : cFalse);
-#endif
-}
-
-DVec3 DVec3::sGreater(DVec3Arg inV1, DVec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_cmp_pd(inV1.mValue, inV2.mValue, _CMP_GT_OQ);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_cmpgt_pd(inV1.mValue.mLow, inV2.mValue.mLow), _mm_cmpgt_pd(inV1.mValue.mHigh, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vreinterpretq_f64_u64(vcgtq_f64(inV1.mValue.val[0], inV2.mValue.val[0])), vreinterpretq_f64_u64(vcgtq_f64(inV1.mValue.val[1], inV2.mValue.val[1])) });
-#else
-	return DVec3(inV1.mF64[0] > inV2.mF64[0]? cTrue : cFalse,
-				 inV1.mF64[1] > inV2.mF64[1]? cTrue : cFalse,
-				 inV1.mF64[2] > inV2.mF64[2]? cTrue : cFalse);
-#endif
-}
-
-DVec3 DVec3::sGreaterOrEqual(DVec3Arg inV1, DVec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_cmp_pd(inV1.mValue, inV2.mValue, _CMP_GE_OQ);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_cmpge_pd(inV1.mValue.mLow, inV2.mValue.mLow), _mm_cmpge_pd(inV1.mValue.mHigh, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vreinterpretq_f64_u64(vcgeq_f64(inV1.mValue.val[0], inV2.mValue.val[0])), vreinterpretq_f64_u64(vcgeq_f64(inV1.mValue.val[1], inV2.mValue.val[1])) });
-#else
-	return DVec3(inV1.mF64[0] >= inV2.mF64[0]? cTrue : cFalse,
-				 inV1.mF64[1] >= inV2.mF64[1]? cTrue : cFalse,
-				 inV1.mF64[2] >= inV2.mF64[2]? cTrue : cFalse);
-#endif
-}
-
-DVec3 DVec3::sFusedMultiplyAdd(DVec3Arg inMul1, DVec3Arg inMul2, DVec3Arg inAdd)
-{
-#if defined(JPH_USE_AVX)
-	#ifdef JPH_USE_FMADD
-		return _mm256_fmadd_pd(inMul1.mValue, inMul2.mValue, inAdd.mValue);
-	#else
-		return _mm256_add_pd(_mm256_mul_pd(inMul1.mValue, inMul2.mValue), inAdd.mValue);
-	#endif
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vmlaq_f64(inAdd.mValue.val[0], inMul1.mValue.val[0], inMul2.mValue.val[0]), vmlaq_f64(inAdd.mValue.val[1], inMul1.mValue.val[1], inMul2.mValue.val[1]) });
-#else
-	return inMul1 * inMul2 + inAdd;
-#endif
-}
-
-DVec3 DVec3::sSelect(DVec3Arg inNotSet, DVec3Arg inSet, DVec3Arg inControl)
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_blendv_pd(inNotSet.mValue, inSet.mValue, inControl.mValue);
-#elif defined(JPH_USE_SSE4_1)
-	Type v = { _mm_blendv_pd(inNotSet.mValue.mLow, inSet.mValue.mLow, inControl.mValue.mLow), _mm_blendv_pd(inNotSet.mValue.mHigh, inSet.mValue.mHigh, inControl.mValue.mHigh) };
-	return sFixW(v);
-#elif defined(JPH_USE_NEON)
-	Type v = { vbslq_f64(vreinterpretq_u64_s64(vshrq_n_s64(vreinterpretq_s64_f64(inControl.mValue.val[0]), 63)), inSet.mValue.val[0], inNotSet.mValue.val[0]),
-			   vbslq_f64(vreinterpretq_u64_s64(vshrq_n_s64(vreinterpretq_s64_f64(inControl.mValue.val[1]), 63)), inSet.mValue.val[1], inNotSet.mValue.val[1]) };
-	return sFixW(v);
-#else
-	DVec3 result;
-	for (int i = 0; i < 3; i++)
-		result.mF64[i] = (BitCast<uint64>(inControl.mF64[i]) & (uint64(1) << 63))? inSet.mF64[i] : inNotSet.mF64[i];
-#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-	result.mF64[3] = result.mF64[2];
-#endif // JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-	return result;
-#endif
-}
-
-DVec3 DVec3::sOr(DVec3Arg inV1, DVec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_or_pd(inV1.mValue, inV2.mValue);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_or_pd(inV1.mValue.mLow, inV2.mValue.mLow), _mm_or_pd(inV1.mValue.mHigh, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vreinterpretq_f64_u64(vorrq_u64(vreinterpretq_u64_f64(inV1.mValue.val[0]), vreinterpretq_u64_f64(inV2.mValue.val[0]))),
-				   vreinterpretq_f64_u64(vorrq_u64(vreinterpretq_u64_f64(inV1.mValue.val[1]), vreinterpretq_u64_f64(inV2.mValue.val[1]))) });
-#else
-	return DVec3(BitCast<double>(BitCast<uint64>(inV1.mF64[0]) | BitCast<uint64>(inV2.mF64[0])),
-				 BitCast<double>(BitCast<uint64>(inV1.mF64[1]) | BitCast<uint64>(inV2.mF64[1])),
-				 BitCast<double>(BitCast<uint64>(inV1.mF64[2]) | BitCast<uint64>(inV2.mF64[2])));
-#endif
-}
-
-DVec3 DVec3::sXor(DVec3Arg inV1, DVec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_xor_pd(inV1.mValue, inV2.mValue);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_xor_pd(inV1.mValue.mLow, inV2.mValue.mLow), _mm_xor_pd(inV1.mValue.mHigh, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(inV1.mValue.val[0]), vreinterpretq_u64_f64(inV2.mValue.val[0]))),
-				   vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(inV1.mValue.val[1]), vreinterpretq_u64_f64(inV2.mValue.val[1]))) });
-#else
-	return DVec3(BitCast<double>(BitCast<uint64>(inV1.mF64[0]) ^ BitCast<uint64>(inV2.mF64[0])),
-				 BitCast<double>(BitCast<uint64>(inV1.mF64[1]) ^ BitCast<uint64>(inV2.mF64[1])),
-				 BitCast<double>(BitCast<uint64>(inV1.mF64[2]) ^ BitCast<uint64>(inV2.mF64[2])));
-#endif
-}
-
-DVec3 DVec3::sAnd(DVec3Arg inV1, DVec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_and_pd(inV1.mValue, inV2.mValue);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_and_pd(inV1.mValue.mLow, inV2.mValue.mLow), _mm_and_pd(inV1.mValue.mHigh, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(inV1.mValue.val[0]), vreinterpretq_u64_f64(inV2.mValue.val[0]))),
-				   vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(inV1.mValue.val[1]), vreinterpretq_u64_f64(inV2.mValue.val[1]))) });
-#else
-	return DVec3(BitCast<double>(BitCast<uint64>(inV1.mF64[0]) & BitCast<uint64>(inV2.mF64[0])),
-				 BitCast<double>(BitCast<uint64>(inV1.mF64[1]) & BitCast<uint64>(inV2.mF64[1])),
-				 BitCast<double>(BitCast<uint64>(inV1.mF64[2]) & BitCast<uint64>(inV2.mF64[2])));
-#endif
-}
-
-int DVec3::GetTrues() const
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_movemask_pd(mValue) & 0x7;
-#elif defined(JPH_USE_SSE)
-	return (_mm_movemask_pd(mValue.mLow) + (_mm_movemask_pd(mValue.mHigh) << 2)) & 0x7;
-#else
-	return int((BitCast<uint64>(mF64[0]) >> 63) | ((BitCast<uint64>(mF64[1]) >> 63) << 1) | ((BitCast<uint64>(mF64[2]) >> 63) << 2));
-#endif
-}
-
-bool DVec3::TestAnyTrue() const
-{
-	return GetTrues() != 0;
-}
-
-bool DVec3::TestAllTrue() const
-{
-	return GetTrues() == 0x7;
-}
-
-bool DVec3::operator == (DVec3Arg inV2) const
-{
-	return sEquals(*this, inV2).TestAllTrue();
-}
-
-bool DVec3::IsClose(DVec3Arg inV2, double inMaxDistSq) const
-{
-	return (inV2 - *this).LengthSq() <= inMaxDistSq;
-}
-
-bool DVec3::IsNearZero(double inMaxDistSq) const
-{
-	return LengthSq() <= inMaxDistSq;
-}
-
-DVec3 DVec3::operator * (DVec3Arg inV2) const
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_mul_pd(mValue, inV2.mValue);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_mul_pd(mValue.mLow, inV2.mValue.mLow), _mm_mul_pd(mValue.mHigh, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vmulq_f64(mValue.val[0], inV2.mValue.val[0]), vmulq_f64(mValue.val[1], inV2.mValue.val[1]) });
-#else
-	return DVec3(mF64[0] * inV2.mF64[0], mF64[1] * inV2.mF64[1], mF64[2] * inV2.mF64[2]);
-#endif
-}
-
-DVec3 DVec3::operator * (double inV2) const
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_mul_pd(mValue, _mm256_set1_pd(inV2));
-#elif defined(JPH_USE_SSE)
-	__m128d v = _mm_set1_pd(inV2);
-	return DVec3({ _mm_mul_pd(mValue.mLow, v), _mm_mul_pd(mValue.mHigh, v) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vmulq_n_f64(mValue.val[0], inV2), vmulq_n_f64(mValue.val[1], inV2) });
-#else
-	return DVec3(mF64[0] * inV2, mF64[1] * inV2, mF64[2] * inV2);
-#endif
-}
-
-DVec3 operator * (double inV1, DVec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_mul_pd(_mm256_set1_pd(inV1), inV2.mValue);
-#elif defined(JPH_USE_SSE)
-	__m128d v = _mm_set1_pd(inV1);
-	return DVec3({ _mm_mul_pd(v, inV2.mValue.mLow), _mm_mul_pd(v, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vmulq_n_f64(inV2.mValue.val[0], inV1), vmulq_n_f64(inV2.mValue.val[1], inV1) });
-#else
-	return DVec3(inV1 * inV2.mF64[0], inV1 * inV2.mF64[1], inV1 * inV2.mF64[2]);
-#endif
-}
-
-DVec3 DVec3::operator / (double inV2) const
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_div_pd(mValue, _mm256_set1_pd(inV2));
-#elif defined(JPH_USE_SSE)
-	__m128d v = _mm_set1_pd(inV2);
-	return DVec3({ _mm_div_pd(mValue.mLow, v), _mm_div_pd(mValue.mHigh, v) });
-#elif defined(JPH_USE_NEON)
-	float64x2_t v = vdupq_n_f64(inV2);
-	return DVec3({ vdivq_f64(mValue.val[0], v), vdivq_f64(mValue.val[1], v) });
-#else
-	return DVec3(mF64[0] / inV2, mF64[1] / inV2, mF64[2] / inV2);
-#endif
-}
-
-DVec3 &DVec3::operator *= (double inV2)
-{
-#if defined(JPH_USE_AVX)
-	mValue = _mm256_mul_pd(mValue, _mm256_set1_pd(inV2));
-#elif defined(JPH_USE_SSE)
-	__m128d v = _mm_set1_pd(inV2);
-	mValue.mLow = _mm_mul_pd(mValue.mLow, v);
-	mValue.mHigh = _mm_mul_pd(mValue.mHigh, v);
-#elif defined(JPH_USE_NEON)
-	mValue.val[0] = vmulq_n_f64(mValue.val[0], inV2);
-	mValue.val[1] = vmulq_n_f64(mValue.val[1], inV2);
-#else
-	for (int i = 0; i < 3; ++i)
-		mF64[i] *= inV2;
-	#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-		mF64[3] = mF64[2];
-	#endif
-#endif
-	return *this;
-}
-
-DVec3 &DVec3::operator *= (DVec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	mValue = _mm256_mul_pd(mValue, inV2.mValue);
-#elif defined(JPH_USE_SSE)
-	mValue.mLow = _mm_mul_pd(mValue.mLow, inV2.mValue.mLow);
-	mValue.mHigh = _mm_mul_pd(mValue.mHigh, inV2.mValue.mHigh);
-#elif defined(JPH_USE_NEON)
-	mValue.val[0] = vmulq_f64(mValue.val[0], inV2.mValue.val[0]);
-	mValue.val[1] = vmulq_f64(mValue.val[1], inV2.mValue.val[1]);
-#else
-	for (int i = 0; i < 3; ++i)
-		mF64[i] *= inV2.mF64[i];
-	#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-		mF64[3] = mF64[2];
-	#endif
-#endif
-	return *this;
-}
-
-DVec3 &DVec3::operator /= (double inV2)
-{
-#if defined(JPH_USE_AVX)
-	mValue = _mm256_div_pd(mValue, _mm256_set1_pd(inV2));
-#elif defined(JPH_USE_SSE)
-	__m128d v = _mm_set1_pd(inV2);
-	mValue.mLow = _mm_div_pd(mValue.mLow, v);
-	mValue.mHigh = _mm_div_pd(mValue.mHigh, v);
-#elif defined(JPH_USE_NEON)
-	float64x2_t v = vdupq_n_f64(inV2);
-	mValue.val[0] = vdivq_f64(mValue.val[0], v);
-	mValue.val[1] = vdivq_f64(mValue.val[1], v);
-#else
-	for (int i = 0; i < 3; ++i)
-		mF64[i] /= inV2;
-	#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-		mF64[3] = mF64[2];
-	#endif
-#endif
-	return *this;
-}
-
-DVec3 DVec3::operator + (Vec3Arg inV2) const
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_add_pd(mValue, _mm256_cvtps_pd(inV2.mValue));
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_add_pd(mValue.mLow, _mm_cvtps_pd(inV2.mValue)), _mm_add_pd(mValue.mHigh, _mm_cvtps_pd(_mm_shuffle_ps(inV2.mValue, inV2.mValue, _MM_SHUFFLE(2, 2, 2, 2)))) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vaddq_f64(mValue.val[0], vcvt_f64_f32(vget_low_f32(inV2.mValue))), vaddq_f64(mValue.val[1], vcvt_high_f64_f32(inV2.mValue)) });
-#else
-	return DVec3(mF64[0] + inV2.mF32[0], mF64[1] + inV2.mF32[1], mF64[2] + inV2.mF32[2]);
-#endif
-}
-
-DVec3 DVec3::operator + (DVec3Arg inV2) const
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_add_pd(mValue, inV2.mValue);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_add_pd(mValue.mLow, inV2.mValue.mLow), _mm_add_pd(mValue.mHigh, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vaddq_f64(mValue.val[0], inV2.mValue.val[0]), vaddq_f64(mValue.val[1], inV2.mValue.val[1]) });
-#else
-	return DVec3(mF64[0] + inV2.mF64[0], mF64[1] + inV2.mF64[1], mF64[2] + inV2.mF64[2]);
-#endif
-}
-
-DVec3 &DVec3::operator += (Vec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	mValue = _mm256_add_pd(mValue, _mm256_cvtps_pd(inV2.mValue));
-#elif defined(JPH_USE_SSE)
-	mValue.mLow = _mm_add_pd(mValue.mLow, _mm_cvtps_pd(inV2.mValue));
-	mValue.mHigh = _mm_add_pd(mValue.mHigh, _mm_cvtps_pd(_mm_shuffle_ps(inV2.mValue, inV2.mValue, _MM_SHUFFLE(2, 2, 2, 2))));
-#elif defined(JPH_USE_NEON)
-	mValue.val[0] = vaddq_f64(mValue.val[0], vcvt_f64_f32(vget_low_f32(inV2.mValue)));
-	mValue.val[1] = vaddq_f64(mValue.val[1], vcvt_high_f64_f32(inV2.mValue));
-#else
-	for (int i = 0; i < 3; ++i)
-		mF64[i] += inV2.mF32[i];
-	#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-		mF64[3] = mF64[2];
-	#endif
-#endif
-	return *this;
-}
-
-DVec3 &DVec3::operator += (DVec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	mValue = _mm256_add_pd(mValue, inV2.mValue);
-#elif defined(JPH_USE_SSE)
-	mValue.mLow = _mm_add_pd(mValue.mLow, inV2.mValue.mLow);
-	mValue.mHigh = _mm_add_pd(mValue.mHigh, inV2.mValue.mHigh);
-#elif defined(JPH_USE_NEON)
-	mValue.val[0] = vaddq_f64(mValue.val[0], inV2.mValue.val[0]);
-	mValue.val[1] = vaddq_f64(mValue.val[1], inV2.mValue.val[1]);
-#else
-	for (int i = 0; i < 3; ++i)
-		mF64[i] += inV2.mF64[i];
-	#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-		mF64[3] = mF64[2];
-	#endif
-#endif
-	return *this;
-}
-
-DVec3 DVec3::operator - () const
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_sub_pd(_mm256_setzero_pd(), mValue);
-#elif defined(JPH_USE_SSE)
-	__m128d zero = _mm_setzero_pd();
-	return DVec3({ _mm_sub_pd(zero, mValue.mLow), _mm_sub_pd(zero, mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	#ifdef JPH_CROSS_PLATFORM_DETERMINISTIC
-		float64x2_t zero = vdupq_n_f64(0);
-		return DVec3({ vsubq_f64(zero, mValue.val[0]), vsubq_f64(zero, mValue.val[1]) });
-	#else
-		return DVec3({ vnegq_f64(mValue.val[0]), vnegq_f64(mValue.val[1]) });
-	#endif
-#else
-	#ifdef JPH_CROSS_PLATFORM_DETERMINISTIC
-		return DVec3(0.0 - mF64[0], 0.0 - mF64[1], 0.0 - mF64[2]);
-	#else
-		return DVec3(-mF64[0], -mF64[1], -mF64[2]);
-	#endif
-#endif
-}
-
-DVec3 DVec3::operator - (Vec3Arg inV2) const
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_sub_pd(mValue, _mm256_cvtps_pd(inV2.mValue));
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_sub_pd(mValue.mLow, _mm_cvtps_pd(inV2.mValue)), _mm_sub_pd(mValue.mHigh, _mm_cvtps_pd(_mm_shuffle_ps(inV2.mValue, inV2.mValue, _MM_SHUFFLE(2, 2, 2, 2)))) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vsubq_f64(mValue.val[0], vcvt_f64_f32(vget_low_f32(inV2.mValue))), vsubq_f64(mValue.val[1], vcvt_high_f64_f32(inV2.mValue)) });
-#else
-	return DVec3(mF64[0] - inV2.mF32[0], mF64[1] - inV2.mF32[1], mF64[2] - inV2.mF32[2]);
-#endif
-}
-
-DVec3 DVec3::operator - (DVec3Arg inV2) const
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_sub_pd(mValue, inV2.mValue);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_sub_pd(mValue.mLow, inV2.mValue.mLow), _mm_sub_pd(mValue.mHigh, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vsubq_f64(mValue.val[0], inV2.mValue.val[0]), vsubq_f64(mValue.val[1], inV2.mValue.val[1]) });
-#else
-	return DVec3(mF64[0] - inV2.mF64[0], mF64[1] - inV2.mF64[1], mF64[2] - inV2.mF64[2]);
-#endif
-}
-
-DVec3 &DVec3::operator -= (Vec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	mValue = _mm256_sub_pd(mValue, _mm256_cvtps_pd(inV2.mValue));
-#elif defined(JPH_USE_SSE)
-	mValue.mLow = _mm_sub_pd(mValue.mLow, _mm_cvtps_pd(inV2.mValue));
-	mValue.mHigh = _mm_sub_pd(mValue.mHigh, _mm_cvtps_pd(_mm_shuffle_ps(inV2.mValue, inV2.mValue, _MM_SHUFFLE(2, 2, 2, 2))));
-#elif defined(JPH_USE_NEON)
-	mValue.val[0] = vsubq_f64(mValue.val[0], vcvt_f64_f32(vget_low_f32(inV2.mValue)));
-	mValue.val[1] = vsubq_f64(mValue.val[1], vcvt_high_f64_f32(inV2.mValue));
-#else
-	for (int i = 0; i < 3; ++i)
-		mF64[i] -= inV2.mF32[i];
-	#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-		mF64[3] = mF64[2];
-	#endif
-#endif
-	return *this;
-}
-
-DVec3 &DVec3::operator -= (DVec3Arg inV2)
-{
-#if defined(JPH_USE_AVX)
-	mValue = _mm256_sub_pd(mValue, inV2.mValue);
-#elif defined(JPH_USE_SSE)
-	mValue.mLow = _mm_sub_pd(mValue.mLow, inV2.mValue.mLow);
-	mValue.mHigh = _mm_sub_pd(mValue.mHigh, inV2.mValue.mHigh);
-#elif defined(JPH_USE_NEON)
-	mValue.val[0] = vsubq_f64(mValue.val[0], inV2.mValue.val[0]);
-	mValue.val[1] = vsubq_f64(mValue.val[1], inV2.mValue.val[1]);
-#else
-	for (int i = 0; i < 3; ++i)
-		mF64[i] -= inV2.mF64[i];
-	#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-		mF64[3] = mF64[2];
-	#endif
-#endif
-	return *this;
-}
-
-DVec3 DVec3::operator / (DVec3Arg inV2) const
-{
-	inV2.CheckW();
-#if defined(JPH_USE_AVX)
-	return _mm256_div_pd(mValue, inV2.mValue);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_div_pd(mValue.mLow, inV2.mValue.mLow), _mm_div_pd(mValue.mHigh, inV2.mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vdivq_f64(mValue.val[0], inV2.mValue.val[0]), vdivq_f64(mValue.val[1], inV2.mValue.val[1]) });
-#else
-	return DVec3(mF64[0] / inV2.mF64[0], mF64[1] / inV2.mF64[1], mF64[2] / inV2.mF64[2]);
-#endif
-}
-
-DVec3 DVec3::Abs() const
-{
-#if defined(JPH_USE_AVX512)
-	return _mm256_range_pd(mValue, mValue, 0b1000);
-#elif defined(JPH_USE_AVX)
-	return _mm256_max_pd(_mm256_sub_pd(_mm256_setzero_pd(), mValue), mValue);
-#elif defined(JPH_USE_SSE)
-	__m128d zero = _mm_setzero_pd();
-	return DVec3({ _mm_max_pd(_mm_sub_pd(zero, mValue.mLow), mValue.mLow), _mm_max_pd(_mm_sub_pd(zero, mValue.mHigh), mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vabsq_f64(mValue.val[0]), vabsq_f64(mValue.val[1]) });
-#else
-	return DVec3(abs(mF64[0]), abs(mF64[1]), abs(mF64[2]));
-#endif
-}
-
-DVec3 DVec3::Reciprocal() const
-{
-	return sOne() / mValue;
-}
-
-DVec3 DVec3::Cross(DVec3Arg inV2) const
-{
-#if defined(JPH_USE_AVX2)
-	__m256d t1 = _mm256_permute4x64_pd(inV2.mValue, _MM_SHUFFLE(0, 0, 2, 1)); // Assure Z and W are the same
-	t1 = _mm256_mul_pd(t1, mValue);
-	__m256d t2 = _mm256_permute4x64_pd(mValue, _MM_SHUFFLE(0, 0, 2, 1)); // Assure Z and W are the same
-	t2 = _mm256_mul_pd(t2, inV2.mValue);
-	__m256d t3 = _mm256_sub_pd(t1, t2);
-	return _mm256_permute4x64_pd(t3, _MM_SHUFFLE(0, 0, 2, 1)); // Assure Z and W are the same
-#else
-	return DVec3(mF64[1] * inV2.mF64[2] - mF64[2] * inV2.mF64[1],
-				 mF64[2] * inV2.mF64[0] - mF64[0] * inV2.mF64[2],
-				 mF64[0] * inV2.mF64[1] - mF64[1] * inV2.mF64[0]);
-#endif
-}
-
-double DVec3::Dot(DVec3Arg inV2) const
-{
-#if defined(JPH_USE_AVX)
-	__m256d mul = _mm256_mul_pd(mValue, inV2.mValue);
-	__m128d xy = _mm256_castpd256_pd128(mul);
-	__m128d yx = _mm_shuffle_pd(xy, xy, 1);
-	__m128d sum = _mm_add_pd(xy, yx);
-	__m128d zw = _mm256_extractf128_pd(mul, 1);
-	sum = _mm_add_pd(sum, zw);
-	return _mm_cvtsd_f64(sum);
-#elif defined(JPH_USE_SSE)
-	__m128d xy = _mm_mul_pd(mValue.mLow, inV2.mValue.mLow);
-	__m128d yx = _mm_shuffle_pd(xy, xy, 1);
-	__m128d sum = _mm_add_pd(xy, yx);
-	__m128d z = _mm_mul_sd(mValue.mHigh, inV2.mValue.mHigh);
-	sum = _mm_add_pd(sum, z);
-	return _mm_cvtsd_f64(sum);
-#elif defined(JPH_USE_NEON)
-	float64x2_t mul_low = vmulq_f64(mValue.val[0], inV2.mValue.val[0]);
-	float64x2_t mul_high = vmulq_f64(mValue.val[1], inV2.mValue.val[1]);
-	return vaddvq_f64(mul_low) + vgetq_lane_f64(mul_high, 0);
-#else
-	double dot = 0.0;
-	for (int i = 0; i < 3; i++)
-		dot += mF64[i] * inV2.mF64[i];
-	return dot;
-#endif
-}
-
-double DVec3::LengthSq() const
-{
-	return Dot(*this);
-}
-
-DVec3 DVec3::Sqrt() const
-{
-#if defined(JPH_USE_AVX)
-	return _mm256_sqrt_pd(mValue);
-#elif defined(JPH_USE_SSE)
-	return DVec3({ _mm_sqrt_pd(mValue.mLow), _mm_sqrt_pd(mValue.mHigh) });
-#elif defined(JPH_USE_NEON)
-	return DVec3({ vsqrtq_f64(mValue.val[0]), vsqrtq_f64(mValue.val[1]) });
-#else
-	return DVec3(sqrt(mF64[0]), sqrt(mF64[1]), sqrt(mF64[2]));
-#endif
-}
-
-double DVec3::Length() const
-{
-	return sqrt(Dot(*this));
-}
-
-DVec3 DVec3::Normalized() const
-{
-	return *this / Length();
-}
-
-bool DVec3::IsNormalized(double inTolerance) const
-{
-	return abs(LengthSq() - 1.0) <= inTolerance;
-}
-
-bool DVec3::IsNaN() const
-{
-#if defined(JPH_USE_AVX512)
-	return (_mm256_fpclass_pd_mask(mValue, 0b10000001) & 0x7) != 0;
-#elif defined(JPH_USE_AVX)
-	return (_mm256_movemask_pd(_mm256_cmp_pd(mValue, mValue, _CMP_UNORD_Q)) & 0x7) != 0;
-#elif defined(JPH_USE_SSE)
-	return ((_mm_movemask_pd(_mm_cmpunord_pd(mValue.mLow, mValue.mLow)) + (_mm_movemask_pd(_mm_cmpunord_pd(mValue.mHigh, mValue.mHigh)) << 2)) & 0x7) != 0;
-#else
-	return isnan(mF64[0]) || isnan(mF64[1]) || isnan(mF64[2]);
-#endif
-}
-
-DVec3 DVec3::GetSign() const
-{
-#if defined(JPH_USE_AVX512)
-	return _mm256_fixupimm_pd(mValue, mValue, _mm256_set1_epi32(0xA9A90A00), 0);
-#elif defined(JPH_USE_AVX)
-	__m256d minus_one = _mm256_set1_pd(-1.0);
-	__m256d one = _mm256_set1_pd(1.0);
-	return _mm256_or_pd(_mm256_and_pd(mValue, minus_one), one);
-#elif defined(JPH_USE_SSE)
-	__m128d minus_one = _mm_set1_pd(-1.0);
-	__m128d one = _mm_set1_pd(1.0);
-	return DVec3({ _mm_or_pd(_mm_and_pd(mValue.mLow, minus_one), one), _mm_or_pd(_mm_and_pd(mValue.mHigh, minus_one), one) });
-#elif defined(JPH_USE_NEON)
-	uint64x2_t minus_one = vreinterpretq_u64_f64(vdupq_n_f64(-1.0f));
-	uint64x2_t one = vreinterpretq_u64_f64(vdupq_n_f64(1.0f));
-	return DVec3({ vreinterpretq_f64_u64(vorrq_u64(vandq_u64(vreinterpretq_u64_f64(mValue.val[0]), minus_one), one)),
-				   vreinterpretq_f64_u64(vorrq_u64(vandq_u64(vreinterpretq_u64_f64(mValue.val[1]), minus_one), one)) });
-#else
-	return DVec3(std::signbit(mF64[0])? -1.0 : 1.0,
-				 std::signbit(mF64[1])? -1.0 : 1.0,
-				 std::signbit(mF64[2])? -1.0 : 1.0);
-#endif
-}
-
-DVec3 DVec3::PrepareRoundToZero() const
-{
-	// Float has 23 bit mantissa, double 52 bit mantissa => we lose 29 bits when converting from double to float
-	constexpr uint64 cDoubleToFloatMantissaLoss = (1U << 29) - 1;
-
-#if defined(JPH_USE_AVX)
-	return _mm256_and_pd(mValue, _mm256_castsi256_pd(_mm256_set1_epi64x(int64_t(~cDoubleToFloatMantissaLoss))));
-#elif defined(JPH_USE_SSE)
-	__m128d mask = _mm_castsi128_pd(_mm_set1_epi64x(int64_t(~cDoubleToFloatMantissaLoss)));
-	return DVec3({ _mm_and_pd(mValue.mLow, mask), _mm_and_pd(mValue.mHigh, mask) });
-#elif defined(JPH_USE_NEON)
-	uint64x2_t mask = vdupq_n_u64(~cDoubleToFloatMantissaLoss);
-	return DVec3({ vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(mValue.val[0]), mask)),
-				   vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(mValue.val[1]), mask)) });
-#else
-	double x = BitCast<double>(BitCast<uint64>(mF64[0]) & ~cDoubleToFloatMantissaLoss);
-	double y = BitCast<double>(BitCast<uint64>(mF64[1]) & ~cDoubleToFloatMantissaLoss);
-	double z = BitCast<double>(BitCast<uint64>(mF64[2]) & ~cDoubleToFloatMantissaLoss);
-
-	return DVec3(x, y, z);
-#endif
-}
-
-DVec3 DVec3::PrepareRoundToInf() const
-{
-	// Float has 23 bit mantissa, double 52 bit mantissa => we lose 29 bits when converting from double to float
-	constexpr uint64 cDoubleToFloatMantissaLoss = (1U << 29) - 1;
-
-#if defined(JPH_USE_AVX512)
-	__m256i mantissa_loss = _mm256_set1_epi64x(cDoubleToFloatMantissaLoss);
-	__mmask8 is_zero = _mm256_testn_epi64_mask(_mm256_castpd_si256(mValue), mantissa_loss);
-	__m256d value_or_mantissa_loss = _mm256_or_pd(mValue, _mm256_castsi256_pd(mantissa_loss));
-	return _mm256_mask_blend_pd(is_zero, value_or_mantissa_loss, mValue);
-#elif defined(JPH_USE_AVX)
-	__m256i mantissa_loss = _mm256_set1_epi64x(cDoubleToFloatMantissaLoss);
-	__m256d value_and_mantissa_loss = _mm256_and_pd(mValue, _mm256_castsi256_pd(mantissa_loss));
-	__m256d is_zero = _mm256_cmp_pd(value_and_mantissa_loss, _mm256_setzero_pd(), _CMP_EQ_OQ);
-	__m256d value_or_mantissa_loss = _mm256_or_pd(mValue, _mm256_castsi256_pd(mantissa_loss));
-	return _mm256_blendv_pd(value_or_mantissa_loss, mValue, is_zero);
-#elif defined(JPH_USE_SSE4_1)
-	__m128i mantissa_loss = _mm_set1_epi64x(cDoubleToFloatMantissaLoss);
-	__m128d zero = _mm_setzero_pd();
-	__m128d value_and_mantissa_loss_low = _mm_and_pd(mValue.mLow, _mm_castsi128_pd(mantissa_loss));
-	__m128d is_zero_low = _mm_cmpeq_pd(value_and_mantissa_loss_low, zero);
-	__m128d value_or_mantissa_loss_low = _mm_or_pd(mValue.mLow, _mm_castsi128_pd(mantissa_loss));
-	__m128d value_and_mantissa_loss_high = _mm_and_pd(mValue.mHigh, _mm_castsi128_pd(mantissa_loss));
-	__m128d is_zero_high = _mm_cmpeq_pd(value_and_mantissa_loss_high, zero);
-	__m128d value_or_mantissa_loss_high = _mm_or_pd(mValue.mHigh, _mm_castsi128_pd(mantissa_loss));
-	return DVec3({ _mm_blendv_pd(value_or_mantissa_loss_low, mValue.mLow, is_zero_low), _mm_blendv_pd(value_or_mantissa_loss_high, mValue.mHigh, is_zero_high) });
-#elif defined(JPH_USE_NEON)
-	uint64x2_t mantissa_loss = vdupq_n_u64(cDoubleToFloatMantissaLoss);
-	float64x2_t zero = vdupq_n_f64(0.0);
-	float64x2_t value_and_mantissa_loss_low = vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(mValue.val[0]), mantissa_loss));
-	uint64x2_t is_zero_low = vceqq_f64(value_and_mantissa_loss_low, zero);
-	float64x2_t value_or_mantissa_loss_low = vreinterpretq_f64_u64(vorrq_u64(vreinterpretq_u64_f64(mValue.val[0]), mantissa_loss));
-	float64x2_t value_and_mantissa_loss_high = vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(mValue.val[1]), mantissa_loss));
-	float64x2_t value_low = vbslq_f64(is_zero_low, mValue.val[0], value_or_mantissa_loss_low);
-	uint64x2_t is_zero_high = vceqq_f64(value_and_mantissa_loss_high, zero);
-	float64x2_t value_or_mantissa_loss_high = vreinterpretq_f64_u64(vorrq_u64(vreinterpretq_u64_f64(mValue.val[1]), mantissa_loss));
-	float64x2_t value_high = vbslq_f64(is_zero_high, mValue.val[1], value_or_mantissa_loss_high);
-	return DVec3({ value_low, value_high });
-#else
-	uint64 ux = BitCast<uint64>(mF64[0]);
-	uint64 uy = BitCast<uint64>(mF64[1]);
-	uint64 uz = BitCast<uint64>(mF64[2]);
-
-	double x = BitCast<double>((ux & cDoubleToFloatMantissaLoss) == 0? ux : (ux | cDoubleToFloatMantissaLoss));
-	double y = BitCast<double>((uy & cDoubleToFloatMantissaLoss) == 0? uy : (uy | cDoubleToFloatMantissaLoss));
-	double z = BitCast<double>((uz & cDoubleToFloatMantissaLoss) == 0? uz : (uz | cDoubleToFloatMantissaLoss));
-
-	return DVec3(x, y, z);
-#endif
-}
-
-Vec3 DVec3::ToVec3RoundDown() const
-{
-	DVec3 to_zero = PrepareRoundToZero();
-	DVec3 to_inf = PrepareRoundToInf();
-	return Vec3(DVec3::sSelect(to_zero, to_inf, DVec3::sLess(*this, DVec3::sZero())));
-}
-
-Vec3 DVec3::ToVec3RoundUp() const
-{
-	DVec3 to_zero = PrepareRoundToZero();
-	DVec3 to_inf = PrepareRoundToInf();
-	return Vec3(DVec3::sSelect(to_inf, to_zero, DVec3::sLess(*this, DVec3::sZero())));
-}
-
-JPH_NAMESPACE_END