TransformSequence.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "TransformTypes.h"
 
namespace UE
{
namespace Geometry
{
 
using namespace UE::Math;
 
template<typename RealType>
class TTransformSequence3
{
protected:
    TArray<TTransformSRT3<RealType>, TInlineAllocator<2>> Transforms;
 
public:
 
    void Append(const TTransformSRT3<RealType>& Transform)
    {
        Transforms.Add(Transform);
    }
 
    void Append(const FTransform& Transform)
    {
        Transforms.Add( TTransformSRT3<RealType>(Transform) );
    }
 
    void Append(const TTransformSequence3<RealType>& SequenceToAppend)
    {
        for (const TTransformSRT3<RealType>& Transform : SequenceToAppend.Transforms)
        {
            Append(Transform);
        }
    }
 
    int32 Num() const { return Transforms.Num(); }
 
    const TArray<TTransformSRT3<RealType>,TInlineAllocator<2>>& GetTransforms() const { return Transforms; }
 
 
    bool HasNonUniformScale(RealType Tolerance = TMathUtil<RealType>::ZeroTolerance) const
    {
        for (const TTransformSRT3<RealType>& Transform : Transforms)
        {
            if (Transform.HasNonUniformScale(Tolerance))
            {
                return true;
            }
        }
        return false;
    }
 
 
    void AppendInverse(const FTransform& Transform, const RealType Tolerance = TMathUtil<RealType>::ZeroTolerance)
    {
        AppendInverse(TTransformSRT3<RealType>(Transform), Tolerance);
    }
 
    void AppendInverse(const TTransformSRT3<RealType>& Transform, const RealType Tolerance = TMathUtil<RealType>::ZeroTolerance)
    {
        if (Transform.CanRepresentInverse(Tolerance))
        {
            Append(Transform.InverseUnsafe(Tolerance));
        }
        else
        {
            TTransformSRT3<RealType> InvS = TTransformSRT3<RealType>::Identity();
            InvS.SetScale(TTransformSRT3<RealType>::GetSafeScaleReciprocal(Transform.GetScale3D(), Tolerance));
 
            TTransformSRT3<RealType> InvRT = Transform;
            InvRT.SetScale(TVector<RealType>::One());
            InvRT = InvRT.InverseUnsafe();
            Append(InvRT);
            Append(InvS);
        }
    }
 
    void AppendInverse(const TTransformSequence3<RealType>& SequenceToAppend, const RealType Tolerance = TMathUtil<RealType>::ZeroTolerance)
    {
        for (int32 Idx = Transforms.Num() - 1; Idx >= 0; --Idx)
        {
            AppendInverse(Transforms[Idx], Tolerance);
        }
    }
 
    // Create the inverse of a transform sequence. Note: Transforms with both non-uniform scale and rotation may be split into two transforms. Zeros in scale will be replaced with unit scales.
    TTransformSequence3<RealType> GetInverse(const RealType Tolerance = TMathUtil<RealType>::ZeroTolerance) const
    {
        TTransformSequence3<RealType> InverseTransformSeq;
        for (int32 Idx = Transforms.Num() - 1; Idx >= 0; --Idx)
        {
            InverseTransformSeq.AppendInverse(Transforms[Idx]);
        }
        return InverseTransformSeq;
    }
 
    TVector<RealType> GetAccumulatedScale() const
    {
        TVector<RealType> FinalScale = TVector<RealType>::One();
        for (const TTransformSRT3<RealType>& Transform : Transforms)
        {
            FinalScale = FinalScale * Transform.GetScale();
        }
        return FinalScale;
    }
 
    bool WillInvert() const
    {
        RealType Det = 1;
        for (const TTransformSRT3<RealType>& Transform : Transforms)
        {
            Det *= Transform.GetDeterminant();
        }
        return Det < 0;
    }
 
    void ClearScales()
    {
        for (TTransformSRT3<RealType>& Transform : Transforms)
        {
            Transform.SetScale(TVector<RealType>::One());
        }
    }
 
    TVector<RealType> TransformPosition(UE::Math::TVector<RealType> P) const
    {
        for (const TTransformSRT3<RealType>& Transform : Transforms)
        {
            P = Transform.TransformPosition(P);
        }
        return P;
    }
 
    TVector<RealType> InverseTransformPosition(UE::Math::TVector<RealType> P) const
    {
        int32 N = Transforms.Num();
        for (int32 k = N - 1; k >= 0; k--)
        {
            P = Transforms[k].InverseTransformPosition(P);
        }
        return P;
    }
 
    TVector<RealType> TransformVector(UE::Math::TVector<RealType> V) const
    {
        for (const TTransformSRT3<RealType>& Transform : Transforms)
        {
            V = Transform.TransformVector(V);
        }
        return V;
    }
 
 
    TVector<RealType> TransformNormal(UE::Math::TVector<RealType> Normal) const
    {
        for (const TTransformSRT3<RealType>& Transform : Transforms)
        {
            Normal = Transform.TransformNormal(Normal);
        }
        return Normal;
    }
 
    template<typename TransformsEquivalentFunc>
    bool IsEquivalent(const TTransformSequence3<RealType>& OtherSeq, TransformsEquivalentFunc TransformsTest) const
    {
        int32 N = Transforms.Num();
        if (N == OtherSeq.Transforms.Num())
        {
            bool bAllTransformsEqual = true;
            for (int32 k = 0; k < N && bAllTransformsEqual; ++k)
            {
                bAllTransformsEqual = bAllTransformsEqual && TransformsTest(Transforms[k], OtherSeq.Transforms[k]);
            }
            return bAllTransformsEqual;
        }
        return false;
    }
};
 
typedef TTransformSequence3<float> FTransformSequence3f;
typedef TTransformSequence3<double> FTransformSequence3d;
 
 
} // end namespace UE::Geometry
} // end namespace UE