CollectionTetrahedralBindingsFacade.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
#include "Containers/UnrealString.h"
#include "Containers/Array.h"
#include "GeometryCollection/ManagedArrayCollection.h"
#include "GeometryCollection/ManagedArrayAccessor.h"
 
namespace GeometryCollection::Facades
{
    class FleshDeformerImpl
    {
    public:
        FleshDeformerImpl()
        {}
 
        static CHAOS_API Chaos::PMatrix<float, 3, 3> GetTangentBasis(const FVector3f& TangentZ);
        static CHAOS_API Chaos::PMatrix<float, 3, 3> GetOrthogonalBasisVectors(const FVector3f& PtA, const FVector3f& PtB, const FVector3f& PtC);
 
        static CHAOS_API FVector3f GetRotatedOffsetVector(const FVector3f& Offset, const FVector3f& RestPtA, const FVector3f& RestPtB, const FVector3f& RestPtC, const FVector3f& CurrPtA, const FVector3f& CurrPtB, const FVector3f& CurrPtC);
        static CHAOS_API FVector3f GetRotatedOffsetVector(const FIntVector4& Parents, const FVector3f& Offset, const TManagedArray<FVector3f>& RestVertices, const TArray<Chaos::TVector<Chaos::FRealSingle, 3>>& CurrVertices);
 
        static CHAOS_API FVector3f GetEmbeddedPosition(
            const int32 SurfaceIndex,
            const TManagedArrayAccessor<FIntVector4>* ParentsArray,
            const TManagedArrayAccessor<FVector4f>* WeightsArray,
            const TManagedArrayAccessor<FVector3f>* OffsetArray,
            const TManagedArray<FVector3f>& RestVertices,
            const TArray<Chaos::TVector<Chaos::FRealSingle, 3>>& CurrVertices);
    };
 
    class FTetrahedralBindings
    {
    public:
        // groups
        static CHAOS_API const FName MeshBindingsGroupName;
 
        //
        // Attributes
        //
 
        static CHAOS_API const FName MeshIdAttributeName;
 
        static CHAOS_API const FName ParentsAttributeName;
        static CHAOS_API const FName WeightsAttributeName;
        static CHAOS_API const FName OffsetsAttributeName;
        static CHAOS_API const FName MaskAttributeName;
 
        // Dependency
        static const FName TetrahedralGroupDependency;
 
        CHAOS_API FTetrahedralBindings(FManagedArrayCollection& InSelf);
        CHAOS_API FTetrahedralBindings(const FManagedArrayCollection& InSelf);
        CHAOS_API virtual ~FTetrahedralBindings();
 
        CHAOS_API void DefineSchema();
 
        bool IsConst() const { return MeshIdAttribute.IsConst(); }
 
        CHAOS_API bool IsValid() const;
 
        static CHAOS_API FName GenerateMeshGroupName(const int32 TetMeshIdx, const FName& MeshId, const int32 LOD);
 
        CHAOS_API int32 GetTetMeshIndex(const FName& MeshId, const int32 LOD) const;
 
        CHAOS_API bool ContainsBindingsGroup(const int32 TetMeshIdx, const FName& MeshId, const int32 LOD) const;
        CHAOS_API bool ContainsBindingsGroup(const FName& GroupName) const;
 
        CHAOS_API void AddBindingsGroup(const int32 TetMeshIdx, const FName& MeshId, const int32 LOD);
        CHAOS_API void AddBindingsGroup(const FName& GroupName);
        
        CHAOS_API bool ReadBindingsGroup(const int32 TetMeshIdx, const FName& MeshId, const int32 LOD);
        CHAOS_API bool ReadBindingsGroup(const FName& GroupName);
 
        CHAOS_API void RemoveBindingsGroup(const int32 TetMeshIdx, const FName& MeshId, const int32 LOD);
        CHAOS_API void RemoveBindingsGroup(const FName& GroupName);
 
        CHAOS_API void SetBindingsData(const TArray<FIntVector4>& ParentsIn, const TArray<FVector4f>& WeightsIn, const TArray<FVector3f>& OffsetsIn, const TArray<float>& MaskIn);
        void SetBindingsData(const TArray<FIntVector4>& ParentsIn, const TArray<FVector4f>& WeightsIn, const TArray<FVector3f>& OffsetsIn)
        {
            TArray<float> MaskTmp; MaskTmp.SetNum(ParentsIn.Num());
            for (int32 i = 0; i < ParentsIn.Num(); i++)
            {
                MaskTmp[i] = 1.0;
            }
            SetBindingsData(ParentsIn, WeightsIn, OffsetsIn, MaskTmp);
        }
 
        const TManagedArrayAccessor<FIntVector4>* GetParentsRO() const { return Parents.Get(); }
              TManagedArrayAccessor<FIntVector4>* GetParents() { check(!IsConst()); return Parents.Get(); }
        const TManagedArrayAccessor<FVector4f>* GetWeightsRO() const { return Weights.Get(); }
              TManagedArrayAccessor<FVector4f>* GetWeights() { check(!IsConst()); return Weights.Get(); }
        const TManagedArrayAccessor<FVector3f>* GetOffsetsRO() const { return Offsets.Get(); }
              TManagedArrayAccessor<FVector3f>* GetOffsets() { check(!IsConst());  return Offsets.Get(); }
        const TManagedArrayAccessor<float>* GetMaskRO() const { return Masks.Get(); }
              TManagedArrayAccessor<float>* GetMask() { check(!IsConst()); return Masks.Get(); }
 
        class Evaluator
        {
        public:
            Evaluator(
                const TManagedArrayAccessor<FIntVector4>* Parents, 
                const TManagedArrayAccessor<FVector4f>* Weights, 
                const TManagedArrayAccessor<FVector3f>* Offsets,
                const TManagedArray<FVector3f>* RestVertices)
                : MinIndexValue(TNumericLimits<int32>::Max())
                , MaxIndexValue(INDEX_NONE)
                , ParentsArray(Parents)
                , WeightsArray(Weights)
                , OffsetsArray(Offsets)
                , RestVerticesArray(RestVertices)
            {}
 
            bool IsValid() const
            { 
                return ParentsArray && WeightsArray && OffsetsArray && 
                    (ParentsArray->Get().Num()==WeightsArray->Get().Num() && ParentsArray->Get().Num()==OffsetsArray->Get().Num()) &&
                    (RestVerticesArray->IsValidIndex(MinIndex()) && RestVerticesArray->IsValidIndex(MaxIndex())); 
            }
            int32 NumVertices() const { return ParentsArray->Num(); }
            int32 MinIndex() const
            {
                if (MinIndexValue == TNumericLimits<int32>::Max())
                {
                    for (const FIntVector4& Tet : ParentsArray->Get())
                    {
                        const int32 IndexEnd = Tet[3] == INDEX_NONE ? 3 : 4;
                        for (int32 LocalIdx = 0; LocalIdx < IndexEnd; ++LocalIdx)
                        {
                            MinIndexValue = FMath::Min(MinIndexValue, Tet[LocalIdx]);
                        }
                    }
                }
                return MinIndexValue;
            }
            int32 MinIndexPosition() const
            {
                MinIndexValue = TNumericLimits<int32>::Max();
                int32 OutMinIndexPosition = INDEX_NONE;
                for (int32 TetIdx = 0; TetIdx < ParentsArray->Get().Num(); ++TetIdx)
                {
                    const FIntVector4& Tet = ParentsArray->Get()[TetIdx];
                    const int32 IndexEnd = Tet[3] == INDEX_NONE ? 3 : 4;
                    for (int32 LocalIdx = 0; LocalIdx < IndexEnd; ++LocalIdx)
                    {
                        if (Tet[LocalIdx] < MinIndexValue)
                        {
                            MinIndexValue = FMath::Min(MinIndexValue, Tet[LocalIdx]);
                            OutMinIndexPosition = TetIdx;
                        }
                    }
                }
                return OutMinIndexPosition;
            }
            int32 MaxIndex() const
            {
                if (MaxIndexValue == INDEX_NONE)
                {
                    for (const FIntVector4& Tet : ParentsArray->Get())
                    {
                        const int32 IndexEnd = Tet[3] == INDEX_NONE ? 3 : 4;
                        for (int32 LocalIdx = 0; LocalIdx < IndexEnd; ++LocalIdx)
                        {
                            MaxIndexValue = FMath::Max(MaxIndexValue, Tet[LocalIdx]);
                        }
                    }
                }
                return MaxIndexValue;
            }
            FVector3f GetEmbeddedPosition(const int32 Index, const TArray<Chaos::TVector<Chaos::FRealSingle, 3>>& CurrVertices) const
            {
                return FleshDeformerImpl::GetEmbeddedPosition(Index, ParentsArray, WeightsArray, OffsetsArray, *RestVerticesArray, CurrVertices);
            }
 
        private:
            mutable int32 MinIndexValue;
            mutable int32 MaxIndexValue;
            const TManagedArrayAccessor<FIntVector4>* ParentsArray;
            const TManagedArrayAccessor<FVector4f>* WeightsArray;
            const TManagedArrayAccessor<FVector3f>* OffsetsArray;
            const TManagedArray<FVector3f>* RestVerticesArray;
        };
 
        class MaskedEvaluator
        {
        public:
            MaskedEvaluator(
                const TManagedArrayAccessor<FIntVector4>* Parents, 
                const TManagedArrayAccessor<FVector4f>* Weights, 
                const TManagedArrayAccessor<FVector3f>* Offsets, 
                const TManagedArrayAccessor<float>* Masks,
                const TManagedArray<FVector3f>* RestVertices)
                : UnmaskedEval(Parents, Weights, Offsets, RestVertices)
                , ParentsArray(Parents)
                , MasksArray(Masks)
            {}
 
            bool IsValid() const { return UnmaskedEval.IsValid() && (ParentsArray->Get().Num() == MasksArray->Get().Num()); }
            int32 NumVertices() const { return UnmaskedEval.NumVertices(); }
            int32 MinIndex() const { return UnmaskedEval.MinIndex(); }
            int32 MaxIndex() const { return UnmaskedEval.MaxIndex(); }
            FVector3f GetEmbeddedPosition(const int32 Index, const FVector3f& RigPosition, const TArray<Chaos::TVector<Chaos::FRealSingle, 3>>& CurrVertices) const
            {
                const float Mask = MasksArray->Get()[Index];
                if (Mask < 1.0e-6)
                {
                    return RigPosition;
                }
                else if (Mask > 1.0 - 1.0e-6)
                {
                    return UnmaskedEval.GetEmbeddedPosition(Index, CurrVertices);
                }
                else
                {
                    FVector3f EmbeddedPos = UnmaskedEval.GetEmbeddedPosition(Index, CurrVertices);
                    return (1.0 - Mask) * RigPosition + Mask * EmbeddedPos;
                }
            }
        private:
            Evaluator UnmaskedEval;
            const TManagedArrayAccessor<FIntVector4>* ParentsArray;
            const TManagedArrayAccessor<float>* MasksArray;
        };
 
        TUniquePtr<Evaluator> InitEvaluator(const TManagedArray<FVector3f>* RestVertices) const
        {
            return TUniquePtr<Evaluator>(new Evaluator(Parents.Get(), Weights.Get(), Offsets.Get(), RestVertices));
        }
 
        TUniquePtr<MaskedEvaluator> InitMaskedEvaluator(const TManagedArray<FVector3f>* RestVertices) const
        { return TUniquePtr<MaskedEvaluator>(new MaskedEvaluator(Parents.Get(), Weights.Get(), Offsets.Get(), Masks.Get(), RestVertices)); }
 
    private:
        TManagedArrayAccessor<FString> MeshIdAttribute;
 
        TUniquePtr<TManagedArrayAccessor<FIntVector4>> Parents;
        TUniquePtr<TManagedArrayAccessor<FVector4f>> Weights;
        TUniquePtr<TManagedArrayAccessor<FVector3f>> Offsets;
        TUniquePtr<TManagedArrayAccessor<float>> Masks;
    };
 
}