SimdTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Chaos/Core.h"
#include "Chaos/VectorUtility.h"
#include "Math/VectorRegister.h"
 
namespace Chaos
{
    namespace Private
    {
        //
        // WIP: Not ready for public use. Keep in the Private namespace for now...
        // 
        // NOTE: Only TNumLanes == 4 is supported for now
        //
 
        static const int SimdAlignment = 16;
 
        template<int TNumLanes>
        struct TSimdSelector
        {
            alignas(SimdAlignment) float V[TNumLanes];
 
            FORCEINLINE void SetValue(const int LaneIndex, bool B)
            {
                reinterpret_cast<uint32*>(V)[LaneIndex] = B ? 0xFFFFFFFF : 0;
            }
 
            FORCEINLINE bool GetValue(const int LaneIndex) const
            {
                // Can't do float comparison because its a NaN for true
                return (reinterpret_cast<const uint32*>(V)[LaneIndex] != 0);
            }
 
            static TSimdSelector<TNumLanes> True();
            static TSimdSelector<TNumLanes> False();
        };
 
        template<typename T, int TNumLanes>
        struct TSimdValue
        {
            using ValueType = T;
            alignas(SimdAlignment) ValueType V[TNumLanes];
 
            FORCEINLINE void SetValue(const int32 LaneIndex, const ValueType F)
            {
                V[LaneIndex] = F;
            }
 
            FORCEINLINE ValueType GetValue(const int32 LaneIndex) const
            {
                return V[LaneIndex];
            }
 
            FORCEINLINE void SetValues(const ValueType F)
            {
                for (int32 LaneIndex = 0; LaneIndex < TNumLanes; ++LaneIndex)
                {
                    SetValue(LaneIndex, F);
                }
            }
        };
 
        template<int TNumLanes>
        struct TSimdInt32
        {
            alignas(SimdAlignment) int32 V[TNumLanes];
 
            FORCEINLINE TSimdInt32()
            {
            }
 
            FORCEINLINE void SetValue(const int32 LaneIndex, const int32 I)
            {
                V[LaneIndex] = I;
            }
 
            FORCEINLINE int32 GetValue(const int32 LaneIndex) const
            {
                return V[LaneIndex];
            }
 
            FORCEINLINE void SetValues(const int32 I)
            {
                *this = Make(I);
            }
 
            FORCEINLINE int32 GetMaxValue() const
            {
                int32 MaxValue = V[0];
                for (int32 LaneIndex = 1; LaneIndex < TNumLanes; ++LaneIndex)
                {
                    MaxValue = FMath::Max(MaxValue, V[LaneIndex]);
                }
                return MaxValue;
            }
 
            static TSimdInt32<TNumLanes> Make(const int32 I);
            static TSimdInt32<TNumLanes> Zero();
        };
 
        template<int TNumLanes>
        struct TSimdRealf
        {
            alignas(SimdAlignment) float V[TNumLanes];
 
            FORCEINLINE TSimdRealf()
            {
            }
 
            FORCEINLINE void SetValue(const int32 LaneIndex, const float F)
            {
                V[LaneIndex] = F;
            }
 
            FORCEINLINE float GetValue(const int32 LaneIndex) const
            {
                return V[LaneIndex];
            }
 
            FORCEINLINE void SetValues(const float F)
            {
                *this = Make(F);
            }
 
            static TSimdRealf Make(const float F);
            static TSimdRealf Zero();
            static TSimdRealf One();
        };
 
        template<int TNumLanes>
        struct TSimdVec3f
        {
            static_assert(TNumLanes == 4, "Other sizes not yet supported");
 
            alignas(SimdAlignment) float VX[TNumLanes];
            alignas(SimdAlignment) float VY[TNumLanes];
            alignas(SimdAlignment) float VZ[TNumLanes];
 
            FORCEINLINE TSimdVec3f()
            {
            }
 
            FORCEINLINE TSimdVec3f(const FVec3f& V)
            {
                SetValues(V);
            }
 
            FORCEINLINE void SetValue(const int32 LaneIndex, const FVec3f& V)
            {
                VX[LaneIndex] = V.X;
                VY[LaneIndex] = V.Y;
                VZ[LaneIndex] = V.Z;
            };
 
            FORCEINLINE FVec3f GetValue(const int32 LaneIndex) const
            {
                return FVec3f(VX[LaneIndex], VY[LaneIndex], VZ[LaneIndex]);
            }
 
            FORCEINLINE void SetValues(const FVec3f& V)
            {
                *this = Make(V);
            }
 
            FORCEINLINE static TSimdVec3f Make(const FVec3f& V)
            {
                TSimdVec3f Out;
                for (int32 LaneIndex = 0; LaneIndex < TNumLanes; ++LaneIndex)
                {
                    Out.SetValue(LaneIndex, V);
                }
                return Out;
            }
 
            FORCEINLINE static TSimdVec3f Make(const FVec3f& V0, const FVec3f& V1, const FVec3f& V2, const FVec3f& V3)
            {
                TSimdVec3f Out;
                if (TNumLanes == 4)
                {
                    Out.SetValue(0, V0);
                    Out.SetValue(1, V1);
                    Out.SetValue(2, V2);
                    Out.SetValue(3, V3);
 
                }
                return Out;
            }
        };
    }
}