ClothingMeshUtils.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "SkeletalMeshTypes.h"
#include "Chaos/AABBTree.h"
 
DECLARE_LOG_CATEGORY_EXTERN(LogClothingMeshUtils, Log, All);
 
struct FClothPhysicalMeshData;
struct FPointWeightMap;
 
namespace ClothingMeshUtils
{
    struct FMeshToMeshFilterSet
    {
        TSet<int32> SourceTriangles;  // Set of triangle index in the source ClothMeshDesc
        TSet<int32> TargetVertices;  // Set of vertex index in the target ClothMeshDesc
    };
 
    class ClothMeshDesc
    {
    public:
        ClothMeshDesc(TConstArrayView<FVector3f> InPositions, TConstArrayView<FVector3f> InNormals, TConstArrayView<uint32> InIndices)
            : Positions(InPositions)
            , Normals(InNormals)
            , Indices(InIndices)
            , bHasValidBVH(false)
        {
        }
 
        ClothMeshDesc(TConstArrayView<FVector3f> InPositions, TConstArrayView<FVector3f> InNormals, TConstArrayView<FVector3f> InTangents, TConstArrayView<uint32> InIndices)
            : Positions(InPositions)
            , Normals(InNormals)
            , Tangents(InTangents)
            , Indices(InIndices)
            , bHasValidBVH(false)
        {
        }
 
        /* Construct a mesh descriptor with re-calculated (averaged) normals to match the simulation output. */
        ClothMeshDesc(TConstArrayView<FVector3f> InPositions, TConstArrayView<uint32> InIndices)
            : Positions(InPositions)
            , Indices(InIndices)
            , bHasValidBVH(false)
        {
            ComputeAveragedNormals();
            Normals = TConstArrayView<FVector3f>(AveragedNormals);
        }
 
        const TConstArrayView<FVector3f>& GetPositions() const { return Positions; }
        const TConstArrayView<FVector3f>& GetNormals() const { return Normals; }
        const TConstArrayView<FVector3f>& GetTangents() const { return Tangents; }
        const TConstArrayView<uint32>& GetIndices() const { return Indices; }
 
        bool HasValidMesh() const { return Positions.Num() == Normals.Num() && Indices.Num() % 3 == 0; }
 
        bool HasTangents() const { return Positions.Num() == Tangents.Num(); }
 
        bool HasAveragedNormals() const { return Normals.Num() == AveragedNormals.Num(); }
 
        CLOTHINGSYSTEMRUNTIMECOMMON_API float DistanceToTriangle(const FVector& Position, int32 TriangleBaseIndex) const;
 
        TArray<int32>& GetFilteredTriangles() const { return FilteredTriangles; }
 
        void GatherAllSourceTrianglesForTargetVertex(const TArray<FMeshToMeshFilterSet>& FilterSets, int32 TargetVertex) const;
 
        CLOTHINGSYSTEMRUNTIMECOMMON_API TArray<int32> FindCandidateTriangles(const FVector& InPoint, float InTolerance = KINDA_SMALL_NUMBER) const;
 
        CLOTHINGSYSTEMRUNTIMECOMMON_API TConstArrayView<float> GetMaxEdgeLengths() const;
 
    private:
        CLOTHINGSYSTEMRUNTIMECOMMON_API void ComputeAveragedNormals();
 
        struct FClothBvEntry;
 
        TConstArrayView<FVector3f> Positions;
        TConstArrayView<FVector3f> Normals;
        TConstArrayView<FVector3f> Tangents;
        TConstArrayView<uint32> Indices;
 
        TArray<FVector3f> AveragedNormals;
 
        mutable bool bHasValidBVH;
        mutable Chaos::TAABBTree<int32, Chaos::TAABBTreeLeafArray<int32, false>, false> BVH;
 
        mutable TArray<float> MaxEdgeLengths;
        mutable TArray<int32> FilteredTriangles;
    };
 
    void CLOTHINGSYSTEMRUNTIMECOMMON_API SkinPhysicsMesh(
        const TArray<int32>& BoneMap,  // UClothingAssetCommon::UsedBoneIndices
        const FClothPhysicalMeshData& InMesh, 
        const FTransform& PostTransform,  // Final transform to apply to component space positions and normals
        const FMatrix44f* InBoneMatrices, 
        const int32 InNumBoneMatrices, 
        TArray<FVector3f>& OutPositions, 
        TArray<FVector3f>& OutNormals);
 
    void CLOTHINGSYSTEMRUNTIMECOMMON_API GenerateMeshToMeshVertData(
        TArray<FMeshToMeshVertData>& OutMeshToMeshVertData,
        const ClothMeshDesc& TargetMesh,
        const ClothMeshDesc& SourceMesh,
        const FPointWeightMap* MaxDistances,
        bool bUseSmoothTransitions,
        bool bUseMultipleInfluences,
        float KernelMaxDistance,
        const TArray<FMeshToMeshFilterSet>& FilterSets = TArray<FMeshToMeshFilterSet>());
 
    void CLOTHINGSYSTEMRUNTIMECOMMON_API ComputeVertexContributions(
        TArray<FMeshToMeshVertData> &InOutSkinningData,
        const FPointWeightMap* const InMaxDistances,
        const bool bInSmoothTransition,
        const bool bInUseMultipleInfluences = false);
 
    FVector4f GetPointBaryAndDist(
        const FVector3f& A,
        const FVector3f& B,
        const FVector3f& C,
        const FVector3f& Point);
 
    FVector4f GetPointBaryAndDistWithNormals(
        const FVector3f& A,
        const FVector3f& B,
        const FVector3f& C,
        const FVector3f& NA,
        const FVector3f& NB,
        const FVector3f& NC,
        const FVector3f& Point);
 
    class FVertexParameterMapper
    {
    public:
        UE_NONCOPYABLE(FVertexParameterMapper)
 
        FVertexParameterMapper(TConstArrayView<FVector3f> InMesh0Positions,
            TConstArrayView<FVector3f> InMesh0Normals,
            TConstArrayView<FVector3f> InMesh1Positions,
            TConstArrayView<FVector3f> InMesh1Normals,
            TConstArrayView<uint32> InMesh1Indices)
            : Mesh0Positions(InMesh0Positions)
            , Mesh0Normals(InMesh0Normals)
            , Mesh1Positions(InMesh1Positions)
            , Mesh1Normals(InMesh1Normals)
            , Mesh1Indices(InMesh1Indices)
        {
        }
 
        template<typename T, typename Lambda>
        void Map(TConstArrayView<T>& SourceData, TArray<T>& DestData, const Lambda& Func)
        {
            // Enforce the interp func signature (returns T and takes a bary and 3 Ts)
            // If you hit this then either the return type isn't T or your arguments aren't convertible to T
            static_assert(std::is_same_v<T, typename TDecay<decltype(Func(DeclVal<FVector3f>(), DeclVal<T>(), DeclVal<T>(), DeclVal<T>()))>::Type>, "Invalid Lambda signature passed to Map");
 
            const int32 NumMesh0Positions = Mesh0Positions.Num();
            const int32 NumMesh0Normals = Mesh0Normals.Num();
 
            const int32 NumMesh1Positions = Mesh1Positions.Num();
            const int32 NumMesh1Normals = Mesh1Normals.Num();
            const int32 NumMesh1Indices = Mesh1Indices.Num();
 
            // Validate mesh data
            check(NumMesh0Positions == NumMesh0Normals);
            check(NumMesh1Positions == NumMesh1Normals);
            check(NumMesh1Indices % 3 == 0);
            check(SourceData.Num() == NumMesh1Positions);
 
            if(DestData.Num() != NumMesh0Positions)
            {
                DestData.Reset();
                DestData.AddUninitialized(NumMesh0Positions);
            }
 
            TArray<FVector4> EmbeddedPositions;
            TArray<int32> SourceIndices;
            GenerateEmbeddedPositions(EmbeddedPositions, SourceIndices);
 
            for(int32 DestVertIndex = 0 ; DestVertIndex < NumMesh0Positions ; ++DestVertIndex)
            {
                // Truncate the distance from the position data
                FVector Bary = EmbeddedPositions[DestVertIndex];
 
                const int32 SourceTriBaseIdx = DestVertIndex * 3;
                T A = SourceData[SourceIndices[SourceTriBaseIdx + 0]];
                T B = SourceData[SourceIndices[SourceTriBaseIdx + 1]];
                T C = SourceData[SourceIndices[SourceTriBaseIdx + 2]];
 
                T& DestVal = DestData[DestVertIndex];
 
                // If we're super close to a vertex just take it's value.
                // Otherwise call the provided interp lambda
                FVector DiffVec = FVector::OneVector - Bary;
                if(FMath::Abs(DiffVec.X) <= SMALL_NUMBER)
                {
                    DestVal = A;
                }
                else if(FMath::Abs(DiffVec.Y) <= SMALL_NUMBER)
                {
                    DestVal = B;
                }
                else if(FMath::Abs(DiffVec.Z) <= SMALL_NUMBER)
                {
                    DestVal = C;
                }
                else
                {
                    DestVal = Func((FVector3f)Bary, A, B, C);
                }
            }
        }
 
        CLOTHINGSYSTEMRUNTIMECOMMON_API void Map(TConstArrayView<float> Source, TArray<float>& Dest);
 
    private:
 
        CLOTHINGSYSTEMRUNTIMECOMMON_API void GenerateEmbeddedPositions(TArray<FVector4>& OutEmbeddedPositions, TArray<int32>& OutSourceIndices);
 
        TConstArrayView<FVector3f> Mesh0Positions;
        TConstArrayView<FVector3f> Mesh0Normals;
        TConstArrayView<FVector3f> Mesh1Positions;
        TConstArrayView<FVector3f> Mesh1Normals;
        TConstArrayView<uint32> Mesh1Indices;
    };
}