MeshNormals.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Port of geometry3Sharp MeshNormals
 
#pragma once
 
#include "Containers/Array.h"
#include "DynamicMesh3.h"
#include "DynamicMeshAttributeSet.h"
#include "Math/UnrealMathSSE.h"
#include "Math/Vector.h"
 
template <typename FuncType> class TFunctionRef;
 
namespace UE
{
namespace Geometry
{
 
 
class FMeshNormals
{
protected:
    const FDynamicMesh3* Mesh;
    TArray<FVector3d> Normals;
 
public:
    FMeshNormals()
    {
        Mesh = nullptr;
    }
 
    FMeshNormals(const FDynamicMesh3* Mesh)
    {
        SetMesh(Mesh);
    }
 
 
    void SetMesh(const FDynamicMesh3* MeshIn)
    {
        this->Mesh = MeshIn;
    }
 
    const TArray<FVector3d>& GetNormals() const { return Normals; }
 
    FVector3d& operator[](int i) { return Normals[i]; }
    const FVector3d& operator[](int i) const { return Normals[i]; }
 
 
    GEOMETRYCORE_API void SetCount(int Count, bool bClearToZero);
 
    void ComputeVertexNormals(bool bWeightByArea = true, bool bWeightByAngle = true)
    {
        Compute_FaceAvg(bWeightByArea, bWeightByAngle);
    }
 
    void ComputeTriangleNormals()
    {
        Compute_Triangle();
    }
 
    GEOMETRYCORE_API void SetDegenerateTriangleNormalsToNeighborNormal();
 
    void RecomputeOverlayNormals(const FDynamicMeshNormalOverlay* NormalOverlay, bool bWeightByArea = true, bool bWeightByAngle = true)
    {
        Compute_Overlay_FaceAvg(NormalOverlay, bWeightByArea, bWeightByAngle);
    }
 
 
    GEOMETRYCORE_API void CopyToVertexNormals(FDynamicMesh3* SetMesh, bool bInvert = false) const;
 
    GEOMETRYCORE_API void CopyToOverlay(FDynamicMeshNormalOverlay* NormalOverlay, bool bInvert = false) const;
 
 
    static GEOMETRYCORE_API void QuickComputeVertexNormals(FDynamicMesh3& Mesh, bool bInvert = false);
 
 
    static GEOMETRYCORE_API void SmoothVertexNormals(FDynamicMesh3& Mesh, int32 SmoothingRounds, double SmoothingAlpha);
 
 
    static GEOMETRYCORE_API void QuickComputeVertexNormalsForTriangles(FDynamicMesh3& Mesh, const TArray<int32>& Triangles, bool bWeightByArea = true, bool bWeightByAngle = true, bool bInvert = false);
 
 
    static GEOMETRYCORE_API FVector3d ComputeVertexNormal(const FDynamicMesh3& Mesh, int VertIdx, bool bWeightByArea = true, bool bWeightByAngle = true);
 
    static GEOMETRYCORE_API FVector3d ComputeVertexNormal(const FDynamicMesh3& Mesh, int32 VertIdx, TFunctionRef<bool(int32)> TriangleFilterFunc, bool bWeightByArea = true, bool bWeightByAngle = true);
 
 
    static GEOMETRYCORE_API FVector3d ComputeOverlayNormal(const FDynamicMesh3& Mesh, const FDynamicMeshNormalOverlay* NormalOverlay, int ElemIdx, bool bWeightByArea = true, bool bWeightByAngle = true);
 
    static GEOMETRYCORE_API void InitializeOverlayToPerVertexNormals(FDynamicMeshNormalOverlay* NormalOverlay, bool bUseMeshVertexNormalsIfAvailable = true);
 
 
    static GEOMETRYCORE_API void InitializeOverlayToPerTriangleNormals(FDynamicMeshNormalOverlay* NormalOverlay);
 
 
    static GEOMETRYCORE_API void InitializeOverlayTopologyFromOpeningAngle(const FDynamicMesh3* Mesh, FDynamicMeshNormalOverlay* NormalOverlay, 
        double AngleThresholdDeg);
 
    static GEOMETRYCORE_API void InitializeOverlayTopologyFromFaceGroups(const FDynamicMesh3* Mesh, FDynamicMeshNormalOverlay* NormalOverlay);
 
 
    static GEOMETRYCORE_API void InitializeMeshToPerTriangleNormals(FDynamicMesh3* Mesh);
 
 
    static GEOMETRYCORE_API void InitializeOverlayRegionToPerVertexNormals(FDynamicMeshNormalOverlay* NormalOverlay, const TArray<int32>& Triangles);
 
    static GEOMETRYCORE_API bool QuickRecomputeOverlayNormals(FDynamicMesh3& Mesh, bool bInvert = false, bool bWeightByArea = true, bool bWeightByAngle = true, bool bParallelCompute = true);
 
    static GEOMETRYCORE_API bool RecomputeOverlayTriNormals(FDynamicMesh3& Mesh, const TArray<int32>& Triangles, bool bWeightByArea = true, bool bWeightByAngle = true);
 
    static GEOMETRYCORE_API bool RecomputeOverlayElementNormals(FDynamicMesh3& Mesh, const TArray<int32>& ElementIDs, bool bWeightByArea = true, bool bWeightByAngle = true);
 
    static GEOMETRYCORE_API FVector3d GetVertexWeightsOnTriangle(const FDynamicMesh3* Mesh, int TriID, double TriArea, bool bWeightByArea, bool bWeightByAngle);
 
protected:
    GEOMETRYCORE_API void Compute_FaceAvg_AreaWeighted();
    GEOMETRYCORE_API void Compute_FaceAvg(bool bWeightByArea, bool bWeightByAngle);
 
    GEOMETRYCORE_API void Compute_Triangle();
 
    GEOMETRYCORE_API void Compute_Overlay_FaceAvg_AreaWeighted(const FDynamicMeshNormalOverlay* NormalOverlay);
    GEOMETRYCORE_API void Compute_Overlay_FaceAvg(const FDynamicMeshNormalOverlay* NormalOverlay, bool bWeightByArea, bool bWeightByAngle);
 
};
 
 
} // end namespace UE::Geometry
} // end namespace UE