Vec8.inl

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#include <Jolt/Math/UVec8.h>
 
JPH_NAMESPACE_BEGIN
 
Vec8::Vec8(Vec4Arg inLo, Vec4Arg inHi) :
    mValue(_mm256_insertf128_ps(_mm256_castps128_ps256(inLo.mValue), inHi.mValue, 1))
{       
}
    
Vec8 Vec8::sZero()
{
    return _mm256_setzero_ps();
}
 
Vec8 Vec8::sReplicate(float inV)
{
    return _mm256_set1_ps(inV);
}
 
Vec8 Vec8::sSplatX(Vec4Arg inV)
{
    return _mm256_set1_ps(inV.GetX());
}
 
Vec8 Vec8::sSplatY(Vec4Arg inV)
{
    return _mm256_set1_ps(inV.GetY());
}
 
Vec8 Vec8::sSplatZ(Vec4Arg inV)
{
    return _mm256_set1_ps(inV.GetZ());
}
 
Vec8 Vec8::sFusedMultiplyAdd(Vec8Arg inMul1, Vec8Arg inMul2, Vec8Arg inAdd)
{
#ifdef JPH_USE_FMADD
    return _mm256_fmadd_ps(inMul1.mValue, inMul2.mValue, inAdd.mValue);
#else
    return _mm256_add_ps(_mm256_mul_ps(inMul1.mValue, inMul2.mValue), inAdd.mValue);
#endif
}
 
Vec8 Vec8::sSelect(Vec8Arg inV1, Vec8Arg inV2, UVec8Arg inControl)
{
    return _mm256_blendv_ps(inV1.mValue, inV2.mValue, _mm256_castsi256_ps(inControl.mValue));
}
 
Vec8 Vec8::sMin(Vec8Arg inV1, Vec8Arg inV2)
{
    return _mm256_min_ps(inV1.mValue, inV2.mValue);
}
 
Vec8 Vec8::sMax(Vec8Arg inV1, Vec8Arg inV2)
{
    return _mm256_max_ps(inV1.mValue, inV2.mValue);
}
 
UVec8 Vec8::sLess(Vec8Arg inV1, Vec8Arg inV2)
{
    return _mm256_castps_si256(_mm256_cmp_ps(inV1.mValue, inV2.mValue, _CMP_LT_OQ));
}
 
UVec8 Vec8::sGreater(Vec8Arg inV1, Vec8Arg inV2)
{
    return _mm256_castps_si256(_mm256_cmp_ps(inV1.mValue, inV2.mValue, _CMP_GT_OQ));
}
 
Vec8 Vec8::sLoadFloat8(const float *inV)
{
    return _mm256_loadu_ps(inV);
}
 
Vec8 Vec8::sLoadFloat8Aligned(const float *inV)
{
    return _mm256_load_ps(inV);
}
 
Vec8 Vec8::operator * (Vec8Arg inV2) const
{
    return _mm256_mul_ps(mValue, inV2.mValue);
}
 
Vec8 Vec8::operator * (float inV2) const
{
    return _mm256_mul_ps(mValue, _mm256_set1_ps(inV2));
}
 
Vec8 Vec8::operator + (Vec8Arg inV2) const
{
    return _mm256_add_ps(mValue, inV2.mValue);
}
 
Vec8 Vec8::operator - (Vec8Arg inV2) const
{
    return _mm256_sub_ps(mValue, inV2.mValue);
}
 
Vec8 Vec8::operator / (Vec8Arg inV2) const
{
    return _mm256_div_ps(mValue, inV2.mValue);
}
 
Vec8 Vec8::Reciprocal() const
{
    return Vec8::sReplicate(1.0f) / mValue;
}
 
template<uint32 SwizzleX, uint32 SwizzleY, uint32 SwizzleZ, uint32 SwizzleW>
Vec8 Vec8::Swizzle() const
{
    static_assert(SwizzleX <= 3, "SwizzleX template parameter out of range");
    static_assert(SwizzleY <= 3, "SwizzleY template parameter out of range");
    static_assert(SwizzleZ <= 3, "SwizzleZ template parameter out of range");
    static_assert(SwizzleW <= 3, "SwizzleW template parameter out of range");
 
    return _mm256_shuffle_ps(mValue, mValue, _MM_SHUFFLE(SwizzleW, SwizzleZ, SwizzleY, SwizzleX));
}
 
Vec8 Vec8::Abs() const
{
#if defined(JPH_USE_AVX512)
    return _mm256_range_ps(mValue, mValue, 0b1000);
#else
    return _mm256_max_ps(_mm256_sub_ps(_mm256_setzero_ps(), mValue), mValue);
#endif
}
    
Vec4 Vec8::LowerVec4() const
{
    return _mm256_castps256_ps128(mValue);
}
 
Vec4 Vec8::UpperVec4() const
{
    return _mm256_extractf128_ps(mValue, 1);
}
 
float Vec8::ReduceMin() const
{
    return Vec4::sMin(LowerVec4(), UpperVec4()).ReduceMin();
}
 
JPH_NAMESPACE_END