ScalarRegister.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Math/UnrealMathUtility.h"
#include "Math/VectorRegister.h"
 
//Currently disabled because FBoneAtom became FTransform and we want to iterate quickly on it.
#ifndef ENABLE_VECTORIZED_TRANSFORM
#define ENABLE_VECTORIZED_TRANSFORM     PLATFORM_ENABLE_VECTORINTRINSICS
#endif
 
#if ENABLE_VECTORIZED_TRANSFORM
 
class ScalarRegister
{
public:
    using RegisterType = VectorRegister4Float;
 
    RegisterType Value;
 
    [[nodiscard]] UE_FORCEINLINE_HINT ScalarRegister();
 
    [[nodiscard]] UE_FORCEINLINE_HINT ScalarRegister(const ScalarRegister& VectorValue);
 
    [[nodiscard]] explicit UE_FORCEINLINE_HINT ScalarRegister(const float& ScalarValue);
 
    [[nodiscard]] explicit UE_FORCEINLINE_HINT ScalarRegister(RegisterType VectorValue);
 
    [[nodiscard]] UE_FORCEINLINE_HINT ScalarRegister operator*(const ScalarRegister& RHS) const;
 
    [[nodiscard]] UE_FORCEINLINE_HINT ScalarRegister operator+(const ScalarRegister& RHS) const;
 
    inline ScalarRegister& operator+=(const ScalarRegister& RHS);
 
    inline ScalarRegister& operator-=(const ScalarRegister& RHS);
 
    [[nodiscard]] UE_FORCEINLINE_HINT ScalarRegister operator-(const ScalarRegister& RHS) const;
 
    
    inline ScalarRegister& operator=(const ScalarRegister& RHS);
 
    inline ScalarRegister& operator=(const RegisterType& RHS);
 
    UE_FORCEINLINE_HINT operator RegisterType() const;
};
 
UE_FORCEINLINE_HINT ScalarRegister::ScalarRegister()
{
}
 
UE_FORCEINLINE_HINT ScalarRegister::ScalarRegister(const ScalarRegister& VectorValue)
{
    Value = VectorValue.Value;
}
 
UE_FORCEINLINE_HINT ScalarRegister::ScalarRegister(const float& ScalarValue)
{
    Value = VectorLoadFloat1(&ScalarValue);
}
 
UE_FORCEINLINE_HINT ScalarRegister::ScalarRegister(RegisterType VectorValue)
{
    Value = VectorValue;
}
 
UE_FORCEINLINE_HINT ScalarRegister ScalarRegister::operator*(const ScalarRegister& RHS) const
{
    return ScalarRegister(VectorMultiply(Value, RHS.Value));
}
 
UE_FORCEINLINE_HINT ScalarRegister ScalarRegister::operator+(const ScalarRegister& RHS) const
{
    return ScalarRegister(VectorAdd(Value, RHS.Value));
}
 
inline ScalarRegister& ScalarRegister::operator+=(const ScalarRegister& RHS)
{
    Value = VectorAdd(Value, RHS.Value);
    return *this;
}
 
inline ScalarRegister& ScalarRegister::operator-=(const ScalarRegister& RHS)
{
    Value = VectorSubtract(Value, RHS.Value);
    return *this;
}
 
UE_FORCEINLINE_HINT ScalarRegister ScalarRegister::operator-(const ScalarRegister& RHS) const
{
    return ScalarRegister(VectorSubtract(Value, RHS.Value));
}
 
    
inline ScalarRegister& ScalarRegister::operator=(const ScalarRegister& RHS)
{
    Value = RHS.Value;
    return *this;
}
 
inline ScalarRegister& ScalarRegister::operator=(const RegisterType& RHS)
{
    Value = RHS;
    return *this;
}
 
UE_FORCEINLINE_HINT ScalarRegister::operator RegisterType() const
{
    return Value;
}
 
#define ScalarOne (ScalarRegister)ScalarRegister(VectorOne())
#define ScalarZero (ScalarRegister)ScalarRegister(VectorZero())
 
/*----------------------------------------------------------------------------
    ScalarRegister specialization of templates.
----------------------------------------------------------------------------*/
 
UE_FORCEINLINE_HINT ScalarRegister ScalarMin(const ScalarRegister& A, const ScalarRegister& B)
{
    return ScalarRegister(VectorMin(A.Value, B.Value));
}
 
UE_FORCEINLINE_HINT ScalarRegister ScalarMax(const ScalarRegister& A, const ScalarRegister& B)
{
    return ScalarRegister(VectorMax(A.Value, B.Value));
}
 
// TCustomLerp for FMath::Lerp()
template<> struct TCustomLerp<ScalarRegister>
{
    constexpr static bool Value = true;
 
    // Specialization of Lerp template that works with scalar (float in vector) registers
    inline ScalarRegister Lerp(const ScalarRegister& A, const ScalarRegister& B, const ScalarRegister& Alpha)
    {
        const ScalarRegister::RegisterType Delta = VectorSubtract(B.Value, A.Value);
        return ScalarRegister(VectorMultiplyAdd(Alpha.Value, Delta, A.Value));
    }
};
 
UE_FORCEINLINE_HINT ScalarRegister ScalarReciprocal(const ScalarRegister& A)
{
    return ScalarRegister(VectorReciprocalAccurate(A.Value));
}
 
#define NonZeroAnimWeight(A) VectorAnyGreaterThan(A.Value, GlobalVectorConstants::AnimWeightThreshold)
 
 
#define NonOneAnimWeight(A) !VectorAnyGreaterThan(A.Value, VectorSubtract(VectorOne(), GlobalVectorConstants::AnimWeightThreshold))
 
#else
 
#define ScalarRegister float
 
#define ScalarOne 1.0f
#define ScalarZero 0.0f
 
#define ScalarMin Min
#define ScalarMax Max
 
#define ScalarReciprocal(A)  (1.0f / (A))
 
#define NonZeroAnimWeight(A) ((A) > ZERO_ANIMWEIGHT_THRESH)
#define NonOneAnimWeight(A) ((A) < 1.0f - ZERO_ANIMWEIGHT_THRESH)
 
#endif