StaticMeshOperations.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "CoreMinimal.h"
#include "Delegates/Delegate.h"
#include "Logging/LogMacros.h"
#include "Math/Transform.h"
#include "Math/UnrealMathSSE.h"
#include "Math/Vector.h"
#include "Math/Vector2D.h"
#include "MeshTypes.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/Optional.h"
#include "Misc/SecureHash.h"
 
class FName;
struct FMeshDescription;
struct FOverlappingCorners;
struct FPolygonGroupID;
struct FRawMesh;
struct FUVMapParameters;
 
enum class ELightmapUVVersion : int32;
 
typedef TMap<FPolygonGroupID, FPolygonGroupID> PolygonGroupMap;
 
DECLARE_LOG_CATEGORY_EXTERN(LogStaticMeshOperations, Log, All);
 
DECLARE_DELEGATE_ThreeParams(FAppendPolygonGroupsDelegate, const FMeshDescription& /*SourceMesh*/, FMeshDescription& /*TargetMesh*/, PolygonGroupMap& /*RemapPolygonGroup*/)
 
enum class EComputeNTBsFlags : uint32
{
    None = 0x00000000,  // No flags
    Normals = 0x00000001, //Force-recompute the normals and implicitly force the recomputing of tangents.
    Tangents = 0x00000002, //Force-recompute the tangents.
    UseMikkTSpace = 0x00000004, //Used when force-recomputing the tangents, use MikkTSpace.
    WeightedNTBs = 0x00000008, //Use weight surface area and angle when computing NTBs to proportionally distribute the vertex instance contribution to the normal/tangent/binormal in a smooth group.    i.e. Weight solve the cylinder problem
    BlendOverlappingNormals = 0x00000010,
    IgnoreDegenerateTriangles = 0x00000020,
};
ENUM_CLASS_FLAGS(EComputeNTBsFlags);
 
class FStaticMeshOperations
{
public:
    struct FAppendSettings
    {
        enum
        {
            MAX_NUM_UV_CHANNELS = 8,
        };
 
        FAppendPolygonGroupsDelegate PolygonGroupsDelegate;
        bool bMergeVertexColor = true;
        bool bMergeUVChannels[MAX_NUM_UV_CHANNELS] = {true};
        bool bMergeObjectName = false;
        FVector MergedAssetPivot = FVector::ZeroVector;
        TOptional<FTransform> MeshTransform; // Apply a transformation on source mesh (see MeshTransform)
    };
 
    static STATICMESHDESCRIPTION_API void ComputeTriangleTangentsAndNormals(FMeshDescription& MeshDescription, float ComparisonThreshold = 0.0f, const TCHAR* DebugName = nullptr);
 
    static STATICMESHDESCRIPTION_API void ComputeTangentsAndNormals(FMeshDescription& MeshDescription, EComputeNTBsFlags ComputeNTBsOptions);
 
    /*
     * Make sure all normals and tangents are valid. If not, recompute them.
     */
    static STATICMESHDESCRIPTION_API void RecomputeNormalsAndTangentsIfNeeded(FMeshDescription& MeshDescription, EComputeNTBsFlags ComputeNTBsOptions);
 
    static STATICMESHDESCRIPTION_API void ComputeMikktTangents(FMeshDescription& MeshDescription, bool bIgnoreDegenerateTriangles);
 
    static STATICMESHDESCRIPTION_API void DetermineEdgeHardnessesFromVertexInstanceNormals(FMeshDescription& MeshDescription, float Tolerance = UE_KINDA_SMALL_NUMBER);
 
    static STATICMESHDESCRIPTION_API void ConvertToRawMesh(const FMeshDescription& SourceMeshDescription, FRawMesh& DestinationRawMesh, const TMap<FName, int32>& MaterialMap);
 
    static STATICMESHDESCRIPTION_API void ConvertFromRawMesh(const FRawMesh& SourceRawMesh, FMeshDescription& DestinationMeshDescription, const TMap<int32, FName>& MaterialMap, bool bSkipNormalsAndTangents = false, const TCHAR* DebugName = nullptr);
 
    static STATICMESHDESCRIPTION_API void AppendMeshDescription(const FMeshDescription& SourceMesh, FMeshDescription& TargetMesh, const FAppendSettings& AppendSettings);
    static STATICMESHDESCRIPTION_API void AppendMeshDescriptions(const TArray<const FMeshDescription*>& SourceMeshes, FMeshDescription& TargetMesh, const FAppendSettings& AppendSettings);
 
    static STATICMESHDESCRIPTION_API void HasInvalidVertexInstanceNormalsOrTangents(const FMeshDescription& MeshDescription, bool& bHasInvalidNormals, bool& bHasInvalidTangents);
 
    UE_DEPRECATED(5.5, "Use HasInvalidVertexInstanceNormalsOrTangents")
    static void AreNormalsAndTangentsValid(const FMeshDescription& MeshDescription, bool& bHasInvalidNormals, bool& bHasInvalidTangents)
    {
        HasInvalidVertexInstanceNormalsOrTangents(MeshDescription, bHasInvalidNormals, bHasInvalidTangents);
    }
 
 
    static STATICMESHDESCRIPTION_API void FindOverlappingCorners(FOverlappingCorners& OverlappingCorners, const FMeshDescription& MeshDescription, float ComparisonThreshold);
 
    static STATICMESHDESCRIPTION_API int32 GetUVChartCount(FMeshDescription& MeshDescription, int32 SrcLightmapIndex, ELightmapUVVersion LightmapUVVersion, const FOverlappingCorners& OverlappingCorners);
 
    static STATICMESHDESCRIPTION_API bool CreateLightMapUVLayout(FMeshDescription& MeshDescription,
        int32 SrcLightmapIndex,
        int32 DstLightmapIndex,
        int32 MinLightmapResolution,
        ELightmapUVVersion LightmapUVVersion,
        const FOverlappingCorners& OverlappingCorners);
 
    UE_DEPRECATED(5.4, "Please use GenerateUV() instead.")
    static STATICMESHDESCRIPTION_API bool GenerateUniqueUVsForStaticMesh(const FMeshDescription& MeshDescription, int32 TextureResolution, bool bMergeIdenticalMaterials, TArray<FVector2D>& OutTexCoords);
        
    enum class EGenerateUVMethod
    {
        Default,
        Legacy,
        UVAtlas,
        XAtlas,     
        PatchBuilder
    };
 
    struct FGenerateUVOptions
    {
        // Expected texture resolution
        int32 TextureResolution = 512;
 
        // Wether to fold triangles sharing the same UVs & vertex colors in the generated UV mapping.
        bool bMergeTrianglesWithIdenticalAttributes = false;
 
        // Method to use when generating UVs
        EGenerateUVMethod UVMethod = EGenerateUVMethod::Default;
    };
 
    static STATICMESHDESCRIPTION_API bool GenerateUV(const FMeshDescription& MeshDescription, const FGenerateUVOptions& Options, TArray<FVector2D>& OutTexCoords);
 
    static STATICMESHDESCRIPTION_API bool AddUVChannel(FMeshDescription& MeshDescription);
 
    static STATICMESHDESCRIPTION_API bool InsertUVChannel(FMeshDescription& MeshDescription, int32 UVChannelIndex);
 
    static STATICMESHDESCRIPTION_API bool RemoveUVChannel(FMeshDescription& MeshDescription, int32 UVChannelIndex);
 
    static STATICMESHDESCRIPTION_API void GeneratePlanarUV(const FMeshDescription& MeshDescription, const FUVMapParameters& Params, TMap<FVertexInstanceID, FVector2D>& OutTexCoords);
 
    static STATICMESHDESCRIPTION_API void GenerateCylindricalUV(FMeshDescription& MeshDescription, const FUVMapParameters& Params, TMap<FVertexInstanceID, FVector2D>& OutTexCoords);
 
    static STATICMESHDESCRIPTION_API void GenerateBoxUV(const FMeshDescription& MeshDescription, const FUVMapParameters& Params, TMap<FVertexInstanceID, FVector2D>& OutTexCoords);
 
    //static void RemapPolygonGroups(FMeshDescription& MeshDescription, TMap<FPolygonGroupID, FPolygonGroupID>& Remap);
 
    /*
     * Move some polygon to a new PolygonGroup(section)
     * SectionIndex: The target section we want to assign the polygon. See bRemoveEmptyPolygonGroup to know how its used
     * TriangleIndexStart: The triangle index is compute as follow: foreach polygon {TriangleIndex += Polygon->NumberTriangles}
     * TriangleIndexEnd: The triangle index is compute as follow: foreach polygon {TriangleIndex += Polygon->NumberTriangles}
     * bRemoveEmptyPolygonGroup: If true, any polygonGroup that is empty after moving a polygon will be delete.
     *                           This parameter impact how SectionIndex is use
     *                           If param is true  : PolygonGroupTargetID.GetValue() do not necessary equal SectionIndex in case there is less sections then SectionIndex
     *                           If param is false : PolygonGroupTargetID.GetValue() equal SectionIndex, we will add all necessary missing PolygonGroupID (this can generate empty PolygonGroupID)
     */
    static STATICMESHDESCRIPTION_API void SwapPolygonPolygonGroup(FMeshDescription& MeshDescription, int32 SectionIndex, int32 TriangleIndexStart, int32 TriangleIndexEnd, bool bRemoveEmptyPolygonGroup);
 
    static STATICMESHDESCRIPTION_API void ConvertHardEdgesToSmoothGroup(const FMeshDescription& SourceMeshDescription, TArray<uint32>& FaceSmoothingMasks);
 
    static STATICMESHDESCRIPTION_API void ConvertSmoothGroupToHardEdges(const TArray<uint32>& FaceSmoothingMasks, FMeshDescription& DestinationMeshDescription);
 
    static STATICMESHDESCRIPTION_API bool HasVertexColor(const FMeshDescription& MeshDescription);
 
    static STATICMESHDESCRIPTION_API void BuildWeldedVertexIDRemap(const FMeshDescription& MeshDescription, const float WeldingThreshold, TMap<FVertexID, FVertexID>& OutVertexIDRemap);
 
    static STATICMESHDESCRIPTION_API FSHAHash ComputeSHAHash(const FMeshDescription& MeshDescription, bool bSkipTransientAttributes = false);
 
    static STATICMESHDESCRIPTION_API void FlipPolygons(FMeshDescription& MeshDescription);
 
    static STATICMESHDESCRIPTION_API void ApplyTransform(FMeshDescription& MeshDescription, const FTransform& Transform, bool bApplyCorrectNormalTransform = false);
    static STATICMESHDESCRIPTION_API void ApplyTransform(FMeshDescription& MeshDescription, const FMatrix& Transform, bool bApplyCorrectNormalTransform = false);
 
    static STATICMESHDESCRIPTION_API int32 GetUniqueVertexCount(const FMeshDescription& MeshDescription);
    static STATICMESHDESCRIPTION_API int32 GetUniqueVertexCount(const FMeshDescription& MeshDescription, const FOverlappingCorners& OverlappingCorners);
 
    static STATICMESHDESCRIPTION_API void ReorderMeshDescriptionPolygonGroups(const FMeshDescription& SourceMeshDescription
        , FMeshDescription& DestinationMeshDescription
        , TOptional<const FString> UnmatchMaterialNameWarning
        , TOptional<const FString> DestinationPolygonGroupCountDifferFromSource_Msg);
 
    static STATICMESHDESCRIPTION_API bool ValidateAndFixData(FMeshDescription& MeshDescription, const FString& DebugName);
 
    static STATICMESHDESCRIPTION_API float ComputeMeshArea(const FMeshDescription& InMeshDescription);
};