MeshTangents.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "DynamicMesh3.h"
#include "DynamicMeshAttributeSet.h"
#include "Math/UnrealMathSSE.h"
#include "Math/Vector.h"
#include "Misc/AssertionMacros.h"
#include "VectorTypes.h"
 
 
namespace UE
{
namespace Geometry
{
 
using namespace UE::Math;
 
class FDynamicMeshTangents
{
public:
    const FDynamicMesh3* Mesh = nullptr;
    const FDynamicMeshNormalOverlay* Normals = nullptr;
    const FDynamicMeshNormalOverlay* Tangents = nullptr;
    const FDynamicMeshNormalOverlay* Bitangents = nullptr;
 
    GEOMETRYCORE_API FDynamicMeshTangents(const FDynamicMesh3* MeshIn);
 
    GEOMETRYCORE_API bool HasValidTangents(bool bCheckValues=false) const;
 
    GEOMETRYCORE_API void GetTangentFrame(int32 TriangleID, int32 TriVertexIndex, FVector3f& NormalOut, FVector3f& TangentOut, FVector3f& BitangentOut) const;
    GEOMETRYCORE_API void GetTangentVectors(int32 TriangleID, int32 TriVertexIndex, const FVector3f& Normal, FVector3f& TangentOut, FVector3f& BitangentOut) const;
    GEOMETRYCORE_API void GetTangentVectors(int32 TriangleID, int32 TriVertexIndex, FVector3f& TangentOut, FVector3f& BitangentOut) const;
};
 
 
struct FComputeTangentsOptions
{
    bool bAveraged = true;      
    bool bAngleWeighted = true;
};
 
 
template<typename RealType>
class TMeshTangents
{
protected:
    const FDynamicMesh3* Mesh;
    TArray<TVector<RealType>> Tangents;
    TArray<TVector<RealType>> Bitangents;
    TArray<int32> AllDegenerateTris;
 
public:
    TMeshTangents()
    {
        Mesh = nullptr;
    }
 
    TMeshTangents(const FDynamicMesh3* Mesh)
    {
        SetMesh(Mesh);
    }
 
    void SetMesh(const FDynamicMesh3* MeshIn)
    {
        this->Mesh = MeshIn;
    }
 
    const TArray<TVector<RealType>>& GetTangents() const { return Tangents; }
 
    const TArray<TVector<RealType>>& GetBitangents() const { return Bitangents; }
 
    const TArray<int32>& GetDegenerateTris() const { return AllDegenerateTris; }
 
    // Get the target mesh
    const FDynamicMesh3* GetMesh() const
    {
        return Mesh; 
    }
 
    //
    // Per-Triangle-Vertex Tangents
    // Number of Tangents is NumTriangles * 3
    //
 
    void InitializeTriVertexTangents(bool bClearToZero)
    {
        SetTangentCount(Mesh->MaxTriangleID() * 3, bClearToZero);
    }
 
    template<typename OtherRealType>
    void CopyTriVertexTangents(const TMeshTangents<OtherRealType>& OtherTangents);
 
    GEOMETRYCORE_API bool CopyTriVertexTangents(const FDynamicMesh3& SourceMesh);
 
 
    GEOMETRYCORE_API void ComputeTriVertexTangents(const FDynamicMeshNormalOverlay* NormalOverlay, const FDynamicMeshUVOverlay* UVOverlay, const FComputeTangentsOptions& Options);
 
    void GetPerTriangleTangent(int32 TriangleID, int32 TriVertIdx, UE::Math::TVector<RealType>& TangentOut, UE::Math::TVector<RealType>& BitangentOut) const
    {
        int32 k = TriangleID * 3 + TriVertIdx;
        TangentOut = Tangents[k];
        BitangentOut = Bitangents[k];
    }
 
 
    template<typename VectorType, typename OtherRealType>
    void GetPerTriangleTangent(int32 TriangleID, int32 TriVertIdx, VectorType& TangentOut, VectorType& BitangentOut) const
    {
        int32 k = TriangleID * 3 + TriVertIdx;
        TangentOut.X = (OtherRealType)Tangents[k].X;
        TangentOut.Y = (OtherRealType)Tangents[k].Y;
        TangentOut.Z = (OtherRealType)Tangents[k].Z;
        BitangentOut.X = (OtherRealType)Bitangents[k].X;
        BitangentOut.Y = (OtherRealType)Bitangents[k].Y;
        BitangentOut.Z = (OtherRealType)Bitangents[k].Z;
    }
 
 
    void GetInterpolatedTriangleTangent(int32 TriangleID, 
        const UE::Math::TVector<RealType>& BaryCoords,
        UE::Math::TVector<RealType>& TangentOut,
        UE::Math::TVector<RealType>& BitangentOut) const
    {
        int32 k = TriangleID * 3;
        if (k >= 0 && (k+2) < Tangents.Num())
        {
            TangentOut = Blend3(Tangents[k], Tangents[k+1], Tangents[k+2], BaryCoords.X, BaryCoords.Y, BaryCoords.Z);
            Normalize(TangentOut);
            BitangentOut = Blend3(Bitangents[k], Bitangents[k+1], Bitangents[k+2], BaryCoords.X, BaryCoords.Y, BaryCoords.Z);
            Normalize(BitangentOut);
        }
        else
        {
            TangentOut = TVector<RealType>::UnitX();
            BitangentOut = TVector<RealType>::UnitY();
        }
    }
 
 
    void SetPerTriangleTangent(int TriangleID, int TriVertIdx, const TVector<RealType>& Tangent, const TVector<RealType>& Bitangent)
    {
        int k = TriangleID * 3 + TriVertIdx;
        Tangents[k] = Tangent;
        Bitangents[k] = Bitangent;
    }
 
    template<typename OtherVectorType>
    inline void GetTriangleVertexTangentVectors(int32 TriangleID, int32 TriVertexIndex, OtherVectorType& TangentOut, OtherVectorType& BitangentOut) const
    {
        int k = TriangleID * 3 + TriVertexIndex;
        TangentOut = (OtherVectorType)Tangents[k];
        BitangentOut = (OtherVectorType)Bitangents[k];
    }
 
 
    //
    // Per-Triangle Tangents
    // Number of Tangents is NumTriangles
    //
 
    void InitializeTriangleTangents(bool bClearToZero)
    {
        SetTangentCount(Mesh->MaxTriangleID(), bClearToZero);
    }
 
    GEOMETRYCORE_API void ComputeTriangleTangents(const FDynamicMeshUVOverlay* UVOverlay, bool bOrthogonalize = true);
 
 
    GEOMETRYCORE_API bool CopyToOverlays(FDynamicMesh3& MeshToSet) const;
 
 
 
    static bool ComputeDefaultOverlayTangents(FDynamicMesh3& Mesh)
    {
        const FDynamicMeshAttributeSet* Attributes = Mesh.Attributes();
        if (!Attributes)
        {
            return false;
        }
        const FDynamicMeshUVOverlay* UVOverlay = Attributes->PrimaryUV();
        const FDynamicMeshNormalOverlay* NormalOverlay = Attributes->PrimaryNormals();
        if (UVOverlay && NormalOverlay)
        {
            TMeshTangents Tangents;
            Tangents.SetMesh(&Mesh);
            Tangents.ComputeTriVertexTangents(NormalOverlay, UVOverlay, FComputeTangentsOptions());
            Mesh.Attributes()->EnableTangents();
            return Tangents.CopyToOverlays(Mesh);
        }
        return false;
    }
 
protected:
    GEOMETRYCORE_API void SetTangentCount(int Count, bool bClearToZero);
 
    // calculate per-triangle tangents and then projected to overlay normals at each triangle-vertex
    void ComputeSeparatePerTriangleTangents(const FDynamicMeshNormalOverlay* NormalOverlay, const FDynamicMeshUVOverlay* UVOverlay, const FComputeTangentsOptions& Options);
 
    // Calculate MikkT-space-style tangents
    void ComputeMikkTStyleTangents(const FDynamicMeshNormalOverlay* NormalOverlay, const FDynamicMeshUVOverlay* UVOverlay, const FComputeTangentsOptions& Options);
};
 
typedef TMeshTangents<float> FMeshTangentsf;
typedef TMeshTangents<double> FMeshTangentsd;
 
 
 
 
template<typename RealType>
template<typename OtherRealType>
void TMeshTangents<RealType>::CopyTriVertexTangents(const TMeshTangents<OtherRealType>& OtherMeshTangents)
{
    const TArray<TVector<OtherRealType>>& OtherTangents = OtherMeshTangents.GetTangents();
    const TArray<TVector<OtherRealType>>& OtherBitangents = OtherMeshTangents.GetBitangents();
 
    int32 Num = OtherTangents.Num();
    check(Mesh->MaxTriangleID() * 3 == Num);
    InitializeTriVertexTangents(false);
    for (int32 k = 0; k < Num; ++k)
    {
        Tangents[k] = TVector<RealType>(OtherTangents[k]);
        Bitangents[k] = TVector<RealType>(OtherBitangents[k]);
    }
    AllDegenerateTris = OtherMeshTangents.GetDegenerateTris();
}
 
 
} // end namespace UE::Geometry
} // end namespace UE