MeshShapeGenerator.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "VectorTypes.h"
#include "IntVectorTypes.h"
#include "IndexTypes.h"
 
namespace UE
{
namespace Geometry
{
 
class /*GEOMETRYCORE_API*/ FMeshShapeGenerator
{
public:
    TArray<FVector3d> Vertices;
    
    TArray<FVector2f> UVs;
    TArray<int> UVParentVertex;
 
    TArray<FVector3f> Normals;
    TArray<int> NormalParentVertex;
 
    TArray<FIndex3i> Triangles;
    TArray<FIndex3i> TriangleUVs;
    TArray<FIndex3i> TriangleNormals;
    TArray<int> TrianglePolygonIDs;
 
 
public:
    bool bReverseOrientation = false;
 
    virtual ~FMeshShapeGenerator()
    {
    }
 
 
    virtual FMeshShapeGenerator& Generate() = 0;
 
    bool HasAttributes() const
    {
        return UVs.Num() > 0 || Normals.Num() > 0;
    }
 
    // Reset UV and normal-related on a generator, leaving vertices and triangles alone
    // @param bResetPolygonIDs Whether to also reset polygon IDs
    void ResetAttributes(bool bResetPolygonIDs = false)
    {
        UVs.Reset();
        UVParentVertex.Reset();
        Normals.Reset();
        NormalParentVertex.Reset();
        TriangleUVs.Reset();
        TriangleNormals.Reset();
        if (bResetPolygonIDs)
        {
            TrianglePolygonIDs.Reset();
        }
    }
 
    void Reset()
    {
        Vertices.Reset();
        UVs.Reset();
        UVParentVertex.Reset();
        Normals.Reset();
        NormalParentVertex.Reset();
        Triangles.Reset();
        TriangleUVs.Reset();
        TriangleNormals.Reset();
        TrianglePolygonIDs.Reset();
    }
 
 
    void SetBufferSizes(int NumVertices, int NumTriangles, int NumUVs, int NumNormals)
    {
        if (NumVertices > 0)
        {
            Vertices.SetNum(NumVertices);
        }
        if (NumTriangles > 0)
        {
            Triangles.SetNum(NumTriangles);
            TriangleUVs.SetNum(NumTriangles);
            TriangleNormals.SetNum(NumTriangles);
            TrianglePolygonIDs.SetNum(NumTriangles);
        }
        if (NumUVs > 0)
        {
            UVs.SetNum(NumUVs);
            UVParentVertex.SetNum(NumUVs);
        }
        if (NumNormals > 0)
        {
            Normals.SetNum(NumNormals);
            NormalParentVertex.SetNum(NumNormals);
        }
    }
    void ExtendBufferSizes(int AddVertices, int AddTriangles, int AddUVs, int AddNormals)
    {
        if (AddVertices > 0)
        {
            int NumVertices = Vertices.Num() + AddVertices;
            Vertices.SetNum(NumVertices);
        }
        if (AddTriangles > 0)
        {
            int NumTriangles = Triangles.Num() + AddTriangles;
            Triangles.SetNum(NumTriangles);
            TriangleUVs.SetNum(NumTriangles);
            TriangleNormals.SetNum(NumTriangles);
            TrianglePolygonIDs.SetNum(NumTriangles);
        }
        if (AddUVs > 0)
        {
            int NumUVs = UVs.Num() + AddUVs;
            UVs.SetNum(NumUVs);
            UVParentVertex.SetNum(NumUVs);
        }
        if (AddNormals > 0)
        {
            int NumNormals = Normals.Num() + AddNormals;
            Normals.SetNum(NumNormals);
            NormalParentVertex.SetNum(NumNormals);
        }
    }
 
 
    inline void SetVertex(int Index, const FVector3d& Position)
    {
        Vertices[Index] = Position;
    }
    inline int AppendVertex(const FVector3d& Position)
    {
        Vertices.Add(Position);
        return Vertices.Num()-1;
    }
 
    inline void SetUV(int Index, const FVector2f& UV, int ParentVertex)
    {
        UVs[Index] = UV;
        UVParentVertex[Index] = ParentVertex;
    }
    inline int AppendUV(const FVector2f& UV, int ParentVertex)
    {
        UVs.Add(UV);
        UVParentVertex.Add(ParentVertex);
        return UVs.Num() - 1;
    }
 
    inline void SetNormal(int Index, const FVector3f& Normal, int ParentVertex)
    {
        Normals[Index] = Normal;
        NormalParentVertex[Index] = ParentVertex;
    }
    inline int AppendNormal(const FVector3f& Normal, int ParentVertex)
    {
        Normals.Add(Normal);
        NormalParentVertex.Add(ParentVertex);
        return Normals.Num() - 1;
    }
 
 
    inline void SetTriangle(int Index, const FIndex3i& Tri)
    {
        Triangles[Index] = bReverseOrientation ? FIndex3i(Tri.C, Tri.B, Tri.A) : Tri;
    }
    inline void SetTriangle(int Index, int A, int B, int C)
    {
        Triangles[Index] = bReverseOrientation ? FIndex3i(C, B, A) : FIndex3i(A, B, C);
    }
    inline void SetTriangle(int Index, int A, int B, int C, bool bClockwiseOverride)
    {
        Triangles[Index] = (bReverseOrientation != bClockwiseOverride) ? FIndex3i(C, B, A) : FIndex3i(A, B, C);
    }
 
    
    inline int AppendTriangle(int A, int B, int C)
    {
        Triangles.Add( bReverseOrientation ? FIndex3i(C, B, A) : FIndex3i(A, B, C) );
        TriangleUVs.SetNum(Triangles.Num());
        TriangleNormals.SetNum(Triangles.Num());
        TrianglePolygonIDs.SetNum(Triangles.Num());
        return Triangles.Num() - 1;
    }
 
 
    inline void SetTriangleUVs(int Index, const FIndex3i& Tri)
    {
        TriangleUVs[Index] = bReverseOrientation ? FIndex3i(Tri.C, Tri.B, Tri.A) : Tri;
    }
    inline void SetTriangleUVs(int Index, int A, int B, int C)
    {
        TriangleUVs[Index] = bReverseOrientation ? FIndex3i(C, B, A) : FIndex3i(A, B, C);
    }
    inline void SetTriangleUVs(int Index, int A, int B, int C, bool bClockwiseOverride)
    {
        TriangleUVs[Index] = (bReverseOrientation != bClockwiseOverride) ? FIndex3i(C, B, A) : FIndex3i(A, B, C);
    }
 
 
    inline void SetTriangleNormals(int Index, const FIndex3i& Tri)
    {
        TriangleNormals[Index] = bReverseOrientation ? FIndex3i(Tri.C, Tri.B, Tri.A) : Tri;
    }
    inline void SetTriangleNormals(int Index, int A, int B, int C)
    {
        TriangleNormals[Index] = bReverseOrientation ? FIndex3i(C, B, A) : FIndex3i(A, B, C);
    }
    inline void SetTriangleNormals(int Index, int A, int B, int C, bool bClockwiseOverride)
    {
        TriangleNormals[Index] = (bReverseOrientation != bClockwiseOverride) ? FIndex3i(C, B, A) : FIndex3i(A, B, C);
    }
 
    inline void SetTrianglePolygon(int Index, int PolygonID)
    {
        TrianglePolygonIDs[Index] = PolygonID;
    }
 
    inline void SetTriangleWithMatchedUVNormal(int Index, int A, int B, int C)
    {
        SetTriangle(Index, A, B, C);
        SetTriangleNormals(Index, A, B, C);
        SetTriangleUVs(Index, A, B, C);
    }
 
 
    static FVector3d BilinearInterp(const FVector3d &v00, const FVector3d &v10, const FVector3d &v11, const FVector3d &v01, double tx, double ty)
    {
        FVector3d a = Lerp(v00, v01, ty);
        FVector3d b = Lerp(v10, v11, ty);
        return Lerp(a, b, tx);
    }
 
    static FVector2d BilinearInterp(const FVector2d &v00, const FVector2d &v10, const FVector2d &v11, const FVector2d &v01, double tx, double ty)
    {
        FVector2d a = Lerp(v00, v01, ty);
        FVector2d b = Lerp(v10, v11, ty);
        return Lerp(a, b, tx);
    }
 
    static FVector2f BilinearInterp(const FVector2f &v00, const FVector2f &v10, const FVector2f &v11, const FVector2f &v01, float tx, float ty)
    {
        FVector2f a = Lerp(v00, v01, ty);
        FVector2f b = Lerp(v10, v11, ty);
        return Lerp(a, b, tx);
    }
 
 
    static FVector3i LinearInterp(const FVector3i &a, const FVector3i &b, double t)
    {
        FVector3d c = Lerp((FVector3d)a, (FVector3d)b, t);
        return FVector3i((int)round(c.X), (int)round(c.Y), (int)round(c.Z));
    }
 
};
 
} // end namespace UE::Geometry
} // end namespace UE