GeomTools.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
 
class UStaticMesh;
 
struct FUtilEdge3D
{
    FVector3f V0;
    FVector3f V1;
};
 
struct FUtilEdge2D
{
    FVector2D V0;
    FVector2D V1;
};
 
struct FUtilVertex2D
{
    FVector2D Pos;
    FColor Color;
    FVector2D UV;
    bool bInteriorEdge;
 
    FUtilVertex2D() {}
 
    FUtilVertex2D(const FVector2D& InPos) 
        : Pos(InPos), Color(255,255,255,255), UV(0.f, 0.f), bInteriorEdge(false)
    {}
 
    FUtilVertex2D(const FVector2D& InPos, const FColor& InColor) 
        : Pos(InPos), Color(InColor), UV(0.f, 0.f), bInteriorEdge(false)
    {}
};
 
struct FUtilPoly2D
{
    TArray<FUtilVertex2D> Verts;
};
 
struct FUtilPoly2DSet
{
    TArray<FUtilPoly2D> Polys;
    FMatrix PolyToWorld;
};
 
struct FUtilTri2D
{
    FUtilVertex2D Verts[3];
};
 
struct FClipSMVertex
{
    FVector3f Pos;
    FVector3f TangentX;
    FVector3f TangentY;
    FVector3f TangentZ;
    FVector2D UVs[8];
    FColor Color;
};
 
struct FClipSMFace
{
    int32 MaterialIndex;
    uint32 SmoothingMask;
    int32 NumUVs;
    bool bOverrideTangentBasis;
 
    FVector FaceNormal;
 
    FMatrix TangentXGradient;
    FMatrix TangentYGradient;
    FMatrix TangentZGradient;
    FMatrix UVGradient[8];
    FMatrix ColorGradient;
 
    void CopyFace(const FClipSMFace& OtherFace)
    {
        FMemory::Memcpy(this,&OtherFace,sizeof(FClipSMFace));
    }
};
 
struct FClipSMTriangle : FClipSMFace
{
    FClipSMVertex Vertices[3];
 
    ENGINE_API void ComputeGradientsAndNormal();
 
    FClipSMTriangle(int32 Init)
    {
        FMemory::Memzero(this, sizeof(FClipSMTriangle));
    }
};
 
struct FClipSMPolygon : FClipSMFace
{
    TArray<FClipSMVertex> Vertices;
 
    FClipSMPolygon(int32 Init)
    {
        FMemory::Memzero(this, sizeof(FClipSMPolygon));
    }
};
 
namespace FGeomTools
{
    ENGINE_API void GetClippableStaticMeshTriangles(TArray<FClipSMTriangle>& OutClippableTriangles, const UStaticMesh* StaticMesh);
 
    ENGINE_API void ClipMeshWithPlane(TArray<FClipSMTriangle>& OutTris, TArray<FUtilEdge3D>& OutClipEdges, const TArray<FClipSMTriangle>& InTriangles, const FPlane& Plane);
 
    ENGINE_API void ProjectEdges(TArray<FUtilEdge2D>& Out2DEdges, FMatrix& ToWorld, const TArray<FUtilEdge3D>& In3DEdges, const FPlane& InPlane);
 
    ENGINE_API void Buid2DPolysFromEdges(TArray<FUtilPoly2D>& OutPolys, const TArray<FUtilEdge2D>& InEdges, const FColor& VertColor);
 
    ENGINE_API bool TriangulatePoly(TArray<FClipSMTriangle>& OutTris, const FClipSMPolygon& InPoly, bool bKeepColinearVertices = false);
 
    ENGINE_API FClipSMPolygon Transform2DPolygonToSMPolygon(const FUtilPoly2D& InTri, const FMatrix& InMatrix);
 
    ENGINE_API void GeneratePlanarFitPolyUVs(FUtilPoly2D& Polygon);
 
    ENGINE_API void GeneratePlanarTilingPolyUVs(FUtilPoly2D& Polygon, float TileSize);
 
    ENGINE_API void RemoveRedundantTriangles(TArray<FClipSMTriangle>& Tris);
 
    ENGINE_API void Split2DPolysWithPlane(FUtilPoly2DSet& PolySet, const FPlane& Plane, const FColor& ExteriorVertColor, const FColor& InteriorVertColor);
 
    ENGINE_API bool VectorsOnSameSide(const FVector3f& Vec, const FVector3f& A, const FVector3f& B, const float SameSideDotProductEpsilon = 0.0f );
 
    ENGINE_API bool PointInTriangle(const FVector3f& A, const FVector3f& B, const FVector3f& C, const FVector3f& P, const float InsideTriangleDotProductEpsilon = 0.0f);
 
};
 
 
class FGeomTools2D
{
public:
    // Corrects the polygon winding to match bNegativeWinding
    // Ie. If the vertex order doesn't match the winding, it is reversed
    // Returns empty array of points if num points < 3
    static ENGINE_API void CorrectPolygonWinding(TArray<FVector2D>& OutVertices, const TArray<FVector2D>& Vertices, const bool bNegativeWinding);
 
    // Returns true if the points forming a polygon have CCW winding
    // Returns true if the polygon isn't valid
    static ENGINE_API bool IsPolygonWindingCCW(const TArray<FVector2D>& Points);
    static ENGINE_API bool IsPolygonWindingCCW(const TArray<FIntPoint>& Points);
 
    // Checks that these polygons can be successfully triangulated  
    static ENGINE_API bool ArePolygonsValid(const TArray<TArray<FVector2D>>& Polygons);
 
    // Merge additive and subtractive polygons, split them up into additive polygons
    // Assumes all polygons and overlapping polygons are valid, and the windings match the setting on the polygon
    static ENGINE_API TArray<TArray<FVector2D>> ReducePolygons(const TArray<TArray<FVector2D>>& Polygons, const TArray<bool>& PolygonNegativeWinding);
 
    // Triangulate a polygon. Check notes in implementation
    static ENGINE_API bool TriangulatePoly(TArray<FVector2D>& OutTris, const TArray<FVector2D>& PolygonVertices, bool bKeepColinearVertices = false);
 
    // 2D version of RemoveRedundantTriangles from GeomTools
    static ENGINE_API void RemoveRedundantTriangles(TArray<FVector2D>& OutTriangles, const TArray<FVector2D>& InTriangles);
 
    // Generate convex shapes
    static ENGINE_API void GenerateConvexPolygonsFromTriangles(TArray<TArray<FVector2D>>& OutPolygons, const TArray<FVector2D>& InTriangles);
 
    // Generate convex hull from points
    static ENGINE_API void GenerateConvexHullFromPoints(TArray<FVector2D>& OutConvexHull, TArray<FVector2D>& Points);
 
    // Returns true if TestPoint is inside the polygon defined by PolygonPoints
    static ENGINE_API bool IsPointInPolygon(const FVector2D& TestPoint, const TArray<FVector2D>& PolygonPoints);
};