CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

3855 lines
133 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "Operations/MeshBevel.h"
#include "GroupTopology.h"
#include "EdgeLoop.h"
#include "DynamicMesh/DynamicMeshChangeTracker.h"
#include "MeshWeights.h"
#include "CompGeom/PolygonTriangulation.h"
#include "DynamicMesh/MeshNormals.h"
#include "DynamicMesh/MeshIndexUtil.h"
#include "MeshRegionBoundaryLoops.h"
#include "MeshBoundaryLoops.h"
#include "Operations/PolyEditingEdgeUtil.h"
#include "Operations/PolyEditingUVUtil.h"
#include "Algo/Count.h"
#include "Algo/RemoveIf.h"
#include "Distance/DistLine3Line3.h"
#include "Operations/UniformTessellate.h"
#include "DynamicSubmesh3.h"
#include "Solvers/ConstrainedMeshSmoother.h"
#include "Solvers/ConstrainedMeshDeformer.h"
#include "Selections/MeshFaceSelection.h"
#include "Parameterization/DynamicMeshUVEditor.h"
#include "Polygon2.h"
#include "VectorUtil.h"
#include "Spatial/DenseGrid2.h"
using namespace UE::Geometry;
// Uncomment to enable various checks and ensures in the Bevel code.
// We cannot default-enable these checks even in Debug builds, because
// Bevel still frequently hits some of these cases, and those checks/ensures
// make it very difficult to debug a game using Bevel in Geometry Script (eg Lyra sample)
//#define ENABLE_MESH_BEVEL_DEBUG
#ifdef ENABLE_MESH_BEVEL_DEBUG
#define MESH_BEVEL_DEBUG_CHECK(Expr) checkSlow(Expr)
#define MESH_BEVEL_DEBUG_ENSURE(Expr) ensure(Expr)
#else
#define MESH_BEVEL_DEBUG_CHECK(Expr)
#define MESH_BEVEL_DEBUG_ENSURE(Expr) !!(Expr)
#endif
namespace UELocal
{
static void QuadsToTris(const FDynamicMesh3& Mesh, const TArray<FIndex2i>& Quads, TArray<int32>& TrisOut, bool bReset)
{
int32 N = Quads.Num();
if (bReset)
{
TrisOut.Reset();
TrisOut.Reserve(2 * N);
}
for (const FIndex2i& Quad : Quads)
{
if (Mesh.IsTriangle(Quad.A))
{
TrisOut.Add(Quad.A);
}
if (Mesh.IsTriangle(Quad.B))
{
TrisOut.Add(Quad.B);
}
}
};
}
void FMeshBevel::InitializeFromGroupTopology(const FDynamicMesh3& Mesh, const FGroupTopology& Topology)
{
ResultInfo = FGeometryResult(EGeometryResultType::InProgress);
// set up initial problem inputs
for (int32 TopoEdgeID = 0; TopoEdgeID < Topology.Edges.Num(); ++TopoEdgeID)
{
if (Topology.IsIsolatedLoop(TopoEdgeID))
{
FEdgeLoop NewLoop;
NewLoop.InitializeFromEdges(&Mesh, Topology.Edges[TopoEdgeID].Span.Edges);
AddBevelEdgeLoop(Mesh, NewLoop);
}
else
{
AddBevelGroupEdge(Mesh, Topology, TopoEdgeID);
}
if (ResultInfo.CheckAndSetCancelled(Progress))
{
return;
}
}
// precompute topological information necessary to apply bevel to vertices/edges/loops
BuildVertexSets(Mesh);
}
void FMeshBevel::InitializeFromGroupTopologyEdges(const FDynamicMesh3& Mesh, const FGroupTopology& Topology, const TArray<int32>& GroupEdges)
{
ResultInfo = FGeometryResult(EGeometryResultType::InProgress);
// set up initial problem inputs
for (int32 TopoEdgeID : GroupEdges)
{
if (Topology.IsIsolatedLoop(TopoEdgeID))
{
FEdgeLoop NewLoop;
NewLoop.InitializeFromEdges(&Mesh, Topology.Edges[TopoEdgeID].Span.Edges);
AddBevelEdgeLoop(Mesh, NewLoop);
}
else
{
AddBevelGroupEdge(Mesh, Topology, TopoEdgeID);
}
if (ResultInfo.CheckAndSetCancelled(Progress))
{
return;
}
}
// precompute topological information necessary to apply bevel to vertices/edges/loops
BuildVertexSets(Mesh);
}
void FMeshBevel::InitializeFromTriangleEdges(const FDynamicMesh3& Mesh, TConstArrayView<int32> TriangleEdges, TFunctionRef<bool(int32)> IsCornerVertex)
{
ResultInfo = FGeometryResult(EGeometryResultType::InProgress);
// VID to TriangleEdges Index map, used for walking chains/loops
TMultiMap<int32, int32> V2EIdx;
TArray<uint8> EdgeUsed;
EdgeUsed.SetNumZeroed(TriangleEdges.Num());
TSet<int32> AllEdgeVIDs;
for (int32 Idx = 0; Idx < TriangleEdges.Num(); ++Idx)
{
int32 EID = TriangleEdges[Idx];
if (Mesh.IsBoundaryEdge(EID))
{
// bevel doesn't support boundary edges; mark them as processed without adding them to the bevel data
EdgeUsed[Idx] = 1;
continue;
}
FIndex2i VIDs = Mesh.GetEdgeV(EID);
V2EIdx.Add(VIDs.A, Idx);
V2EIdx.Add(VIDs.B, Idx);
AllEdgeVIDs.Add(VIDs.A);
AllEdgeVIDs.Add(VIDs.B);
}
// edge chains, stored as [VID,EID] pairs and a EndChain or EndLoop as the EID at the end of each continguous chain or loop respectively
constexpr int32 EndChain = -1, EndLoop = -2;
TArray<TPair<int32,int32>> Chains;
auto ProcessEdgeIdx = [&EdgeUsed, &TriangleEdges, &Mesh, &IsCornerVertex, &V2EIdx, &Chains, EndChain, EndLoop](int32 VID, int32 EdgeIdx)
{
EdgeUsed[EdgeIdx] = 1;
int32 WalkEID = TriangleEdges[EdgeIdx];
Chains.Emplace(VID, WalkEID);
int32 StartVID = VID;
int32 WalkVID = VID;
int32 MaxIters = TriangleEdges.Num() + 2; // safety to prevent infinite loop
while (--MaxIters > 0)
{
FIndex2i EdgeV = Mesh.GetEdgeV(WalkEID);
// step WalkVID to next vertex
WalkVID = EdgeV[1 - EdgeV.IndexOf(WalkVID)];
// detect loops
if (WalkVID == StartVID)
{
Chains.Emplace(WalkVID, EndLoop);
break;
}
// stop chains at specified corner vertices
if (IsCornerVertex(WalkVID))
{
Chains.Emplace(WalkVID, EndChain);
break;
}
// non-loop case, look for a next edge
int32 WalkEIdx = -1;
int32 ECount = 0;
for (TMultiMap<int32, int32>::TConstKeyIterator It = V2EIdx.CreateConstKeyIterator(WalkVID); It; ++It)
{
ECount++;
if (EdgeUsed[It.Value()] != 0)
{
continue;
}
WalkEIdx = It.Value();
}
// if next vertex had valence != 2, it's the end of this chain
if (ECount != 2)
{
Chains.Emplace(WalkVID, EndChain);
break;
}
// walk to the next edge and mark it as processed
EdgeUsed[WalkEIdx] = 1;
WalkEID = TriangleEdges[WalkEIdx];
Chains.Emplace(WalkVID, WalkEID);
}
check(MaxIters > 0);
};
// Process all loops and chains that have at least one vertex on multiple selected edges
for (int32 VID : AllEdgeVIDs)
{
int32 NumEdges = V2EIdx.Num(VID);
if (IsCornerVertex(VID) || NumEdges != 2)
{
for (TMultiMap<int32, int32>::TConstKeyIterator It = V2EIdx.CreateConstKeyIterator(VID); It; ++It)
{
if (!EdgeUsed[It.Value()])
{
ProcessEdgeIdx(VID, It.Value());
}
}
}
}
// Process remaining (isolated) loops where all vertices had only two adjacent selected edges
for (int32 Idx = 0; Idx < EdgeUsed.Num(); ++Idx)
{
if (!EdgeUsed[Idx])
{
ProcessEdgeIdx(Mesh.GetEdgeV(TriangleEdges[Idx]).A, Idx);
}
}
// Add the edge chains and loops to the bevel data structures
TArray<int32> EdgeLoop, VertexLoop;
for (int32 ChainIdx = 0, ChainLen = 0; ChainIdx < Chains.Num(); ChainIdx += ChainLen + 1)
{
for (ChainLen = 0; ChainLen + ChainIdx < Chains.Num() && Chains[ChainIdx + ChainLen].Value >= 0; ++ChainLen)
{}
check(ChainLen > 0 && ChainIdx + ChainLen < Chains.Num());
bool bIsLoop = Chains[ChainIdx + ChainLen].Value == EndLoop;
if (bIsLoop)
{
EdgeLoop.Reset(ChainLen);
VertexLoop.Reset(ChainLen);
for (int32 Idx = ChainIdx; Idx < ChainIdx + ChainLen; ++Idx)
{
EdgeLoop.Add(Chains[Idx].Value);
VertexLoop.Add(Chains[Idx].Key);
}
// Note: Could initialize the bevel edge loop data directly rather than going via FEdgeLoop and avoid some copying
FEdgeLoop NewLoop;
NewLoop.Initialize(&Mesh, VertexLoop, EdgeLoop);
AddBevelEdgeLoop(Mesh, NewLoop);
}
else
{
FIndex2i CornerVIDs(Chains[ChainIdx].Key, Chains[ChainIdx + ChainLen].Key);
FBevelEdge Edge;
int32 NewBevelEdgeIndex = Edges.Num();
for (int32 ci = 0; ci < 2; ++ci)
{
int32 VertexID = CornerVIDs[ci];
Edge.bEndpointBoundaryFlag[ci] = Mesh.IsBoundaryVertex(VertexID);
int32 IncomingEdgeID = (ci == 0) ? Chains[ChainIdx].Value : Chains[ChainIdx + ChainLen - 1].Value;
int32 BevelVertexIndex = -1;
FBevelVertex* VertInfo = GetBevelVertexFromVertexID(VertexID, &BevelVertexIndex);
if (VertInfo == nullptr)
{
FBevelVertex NewVertex;
PRAGMA_DISABLE_DEPRECATION_WARNINGS
NewVertex.CornerID = INDEX_NONE;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
NewVertex.VertexID = VertexID;
BevelVertexIndex = Vertices.Num();
Vertices.Add(NewVertex);
VertexIDToIndexMap.Add(VertexID, BevelVertexIndex);
VertInfo = &Vertices[BevelVertexIndex];
}
VertInfo->IncomingBevelMeshEdges.Add(IncomingEdgeID);
PRAGMA_DISABLE_DEPRECATION_WARNINGS
VertInfo->IncomingBevelTopoEdges.Add(INDEX_NONE);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
VertInfo->IncomingBevelEdgeIndices.Add(NewBevelEdgeIndex);
Edge.BevelVertices[ci] = BevelVertexIndex;
}
Edge.MeshEdges.Reset(ChainLen);
for (int32 Idx = ChainIdx; Idx < ChainIdx + ChainLen; ++Idx)
{
Edge.MeshEdges.Add(Chains[Idx].Value);
}
Edge.MeshVertices.Reset(ChainLen + 1);
for (int32 Idx = ChainIdx; Idx < ChainIdx + ChainLen + 1; ++Idx)
{
Edge.MeshVertices.Add(Chains[Idx].Key);
}
PRAGMA_DISABLE_DEPRECATION_WARNINGS
Edge.GroupEdgeID = INDEX_NONE;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
Edge.MeshEdgeTris.Reserve(Edge.MeshEdges.Num());
for (int32 eid : Edge.MeshEdges)
{
Edge.MeshEdgeTris.Add(Mesh.GetEdgeT(eid));
}
Edge.InitialPositions.Reserve(Edge.MeshVertices.Num());
for (int32 vid : Edge.MeshVertices)
{
Edge.InitialPositions.Add(Mesh.GetVertex(vid));
}
Edge.EdgeIndex = NewBevelEdgeIndex;
Edges.Add(MoveTemp(Edge));
}
if (ResultInfo.CheckAndSetCancelled(Progress))
{
return;
}
}
// precompute topological information necessary to apply bevel to vertices/edges/loops
BuildVertexSets(Mesh);
}
bool FMeshBevel::InitializeFromGroupTopologyFaces(const FDynamicMesh3& Mesh, const FGroupTopology& Topology, const TArray<int32>& GroupFaces)
{
TSet<int32> GroupSelection;
GroupSelection.Append(GroupFaces);
bool bFoundAnythingToBevel = false;
for (int32 GroupID : GroupFaces)
{
const FGroupTopology::FGroup* Group = Topology.FindGroupByID(GroupID);
for (const FGroupTopology::FGroupBoundary& Boundary : Group->Boundaries)
{
for (int32 GroupEdgeID : Boundary.GroupEdges)
{
const FGroupTopology::FGroupEdge& GroupEdge = Topology.Edges[GroupEdgeID];
int32 OtherGroupID = GroupEdge.OtherGroupID(GroupID);
// Do not bevel edges where both sides are selected, or boundary edges
if (OtherGroupID == IndexConstants::InvalidID || GroupSelection.Contains(OtherGroupID))
{
continue;
}
if (Topology.IsIsolatedLoop(GroupEdgeID))
{
FEdgeLoop NewLoop;
NewLoop.InitializeFromEdges(&Mesh, Topology.Edges[GroupEdgeID].Span.Edges);
AddBevelEdgeLoop(Mesh, NewLoop);
bFoundAnythingToBevel = true;
}
else
{
AddBevelGroupEdge(Mesh, Topology, GroupEdgeID);
bFoundAnythingToBevel = true;
}
}
}
}
if (bFoundAnythingToBevel)
{
// precompute topological information necessary to apply bevel to vertices/edges/loops
BuildVertexSets(Mesh);
}
return bFoundAnythingToBevel;
}
bool FMeshBevel::InitializeFromTriangleSet(const FDynamicMesh3& Mesh, const TArray<int32>& Triangles)
{
ResultInfo = FGeometryResult(EGeometryResultType::InProgress);
FMeshRegionBoundaryLoops RegionLoops(&Mesh, Triangles, true);
if (RegionLoops.bFailed)
{
ResultInfo.SetFailed();
return false;
}
// cannot bevel a selection-bowtie vertex, so we have to check for those and fail here
TSet<int32> AllVertices;
for (const FEdgeLoop& Loop : RegionLoops.Loops)
{
for (int32 vid : Loop.Vertices)
{
if (AllVertices.Contains(vid))
{
return false;
}
AllVertices.Add(vid);
}
}
for (const FEdgeLoop& Loop : RegionLoops.Loops)
{
AddBevelEdgeLoop(Mesh, Loop);
}
// precompute topological information necessary to apply bevel to vertices/edges/loops
BuildVertexSets(Mesh);
return true;
}
void FMeshBevel::FixBowties(FDynamicMesh3& Mesh, FDynamicMeshChangeTracker* ChangeTracker)
{
TMultiMap<int32, int32> SplitMeshVIDs; // map from original VID to new VIDs for any bowtie vertices that were split
auto SplitBowtie = [this, &Mesh, &SplitMeshVIDs, &ChangeTracker](int32 VID, int32 EID) -> int32
{
FIndex2i EdgeV = Mesh.GetEdgeV(EID);
int32 SubIdx = EdgeV.IndexOf(VID);
check(SubIdx != INDEX_NONE);
int32 OtherVID = EdgeV[1 - SubIdx];
if (ChangeTracker)
{
ChangeTracker->SaveVertexOneRingTriangles(VID, true);
}
FDynamicMeshEditor Edit(&Mesh);
FDynamicMeshEditResult EditResult;
Edit.SplitBowties(VID, EditResult);
FIndex2i UpdatedEdgeV = Mesh.GetEdgeV(EID);
int32 OtherVIDSubIdx = UpdatedEdgeV.IndexOf(OtherVID);
check(OtherVIDSubIdx != INDEX_NONE);
int32 NewVID = UpdatedEdgeV[1 - OtherVIDSubIdx];
for (int32 AddedVID : EditResult.NewVertices)
{
SplitMeshVIDs.Add(VID, AddedVID);
}
return NewVID;
};
auto RemapVertexID = [this, &Mesh, &SplitMeshVIDs, &SplitBowtie](int32 OrigVID, int32 EID, int32& RemapVID) -> bool
{
bool bWasBowtie = SplitMeshVIDs.Contains(OrigVID);
RemapVID = OrigVID;
if (bWasBowtie)
{
FIndex2i EdgeV = Mesh.GetEdgeV(EID);
if (!EdgeV.Contains(OrigVID))
{
for (auto KeyIter = SplitMeshVIDs.CreateConstKeyIterator(OrigVID); KeyIter; ++KeyIter)
{
int32 NewVID = KeyIter.Value();
if (EdgeV.Contains(NewVID))
{
RemapVID = NewVID;
return true;
}
}
// the edge should always include one of the vertices that the bowtie was split in to
checkSlow(false);
}
return true;
}
else if (Mesh.IsBowtieVertex(OrigVID))
{
RemapVID = SplitBowtie(OrigVID, EID);
return true;
}
return false;
};
for (FBevelLoop& Loop : Loops)
{
checkSlow(Loop.MeshVertices.Num() == Loop.MeshEdges.Num());
for (int32 VertPathIdx = 0; VertPathIdx < Loop.MeshVertices.Num(); ++VertPathIdx)
{
int32 OrigVID = Loop.MeshVertices[VertPathIdx];
int32 EdgePathIdx = VertPathIdx;
int32 EID = Loop.MeshEdges[EdgePathIdx];
int32 RemapVID = OrigVID;
if (RemapVertexID(OrigVID, EID, RemapVID))
{
Loop.MeshVertices[VertPathIdx] = RemapVID;
}
}
}
int32 OrigNumVertices = Vertices.Num();
TSet<int32> BevelVerticesToRelink;
TMap<int32, int32> MeshVIDToBevelVertexIdx;
for (FBevelEdge& Edge : Edges)
{
checkSlow(Edge.MeshVertices.Num() == Edge.MeshEdges.Num() + 1);
for (int32 VertPathIdx = 0; VertPathIdx < Edge.MeshVertices.Num(); ++VertPathIdx)
{
int32 OrigVID = Edge.MeshVertices[VertPathIdx];
int32 EdgePathIdx = FMath::Min(VertPathIdx, Edge.MeshEdges.Num() - 1);
int32 EID = Edge.MeshEdges[EdgePathIdx];
int32 RemapVID = OrigVID;
if (RemapVertexID(OrigVID, EID, RemapVID))
{
Edge.MeshVertices[VertPathIdx] = RemapVID;
// if we're at an endpoint of the bevel edge, also update the bevel vertex, and make the edge point to the updated bevel vertex
if (VertPathIdx == 0 || VertPathIdx + 1 == Edge.MeshVertices.Num())
{
int32 BevelVertexSubIdx = VertPathIdx == 0 ? 0 : 1;
int32 BevelVertexIdx = Edge.BevelVertices[BevelVertexSubIdx];
VertexIDToIndexMap.Remove(OrigVID);
bool bWasAlreadyRelinked;
BevelVerticesToRelink.Add(BevelVertexIdx, &bWasAlreadyRelinked);
// after splitting bowties, recompute whether the split vertex is still a boundary vertex
Edge.bEndpointBoundaryFlag[BevelVertexSubIdx] = Mesh.IsBoundaryVertex(RemapVID);
if (!bWasAlreadyRelinked)
{
// First time encountering this bevel vertex; just remap it to the split vertex on the current edge
Vertices[BevelVertexIdx].VertexID = RemapVID;
MeshVIDToBevelVertexIdx.Add(RemapVID, BevelVertexIdx);
}
else
{
// We've encountered this bevel vertex before; use a previously-found mapping, or copy the vertex to create a new one
int32* FoundBevelVert = MeshVIDToBevelVertexIdx.Find(RemapVID);
int32 NewBevelVertIdx = INDEX_NONE;
if (FoundBevelVert)
{
NewBevelVertIdx = *FoundBevelVert;
}
else
{
// Add a copy of the existing bevel vertex
NewBevelVertIdx = Vertices.Add(FBevelVertex(Vertices[BevelVertexIdx]));
Vertices[NewBevelVertIdx].VertexID = RemapVID;
BevelVerticesToRelink.Add(NewBevelVertIdx);
MeshVIDToBevelVertexIdx.Add(RemapVID, NewBevelVertIdx);
}
Edge.BevelVertices[BevelVertexSubIdx] = NewBevelVertIdx;
}
}
}
}
}
// Fix up edge and triangle references on any relinked bevel vertices
for (int32 BevelVertexIdx : BevelVerticesToRelink)
{
FBevelVertex& Vertex = Vertices[BevelVertexIdx];
VertexIDToIndexMap.Add(Vertices[BevelVertexIdx].VertexID, BevelVertexIdx);
Vertex.VertexType = EBevelVertexType::Unknown; // reset type to unknown; will be set by InitVertexSet below
Vertex.IncomingBevelEdgeIndices.SetNum(
Algo::RemoveIf(Vertex.IncomingBevelEdgeIndices, [this, BevelVertexIdx](int32 BevelEdgeIdx)
{
return !Edges[BevelEdgeIdx].BevelVertices.Contains(BevelVertexIdx);
}));
int32 MeshVertexID = Vertex.VertexID;
Vertex.IncomingBevelMeshEdges.SetNum(
Algo::RemoveIf(Vertex.IncomingBevelMeshEdges, [this, MeshVertexID, &Mesh](int32 EdgeID)
{
return !Mesh.GetEdgeV(EdgeID).Contains(MeshVertexID);
}));
InitVertexSet(Mesh, Vertices[BevelVertexIdx]);
}
for (int32 BevelVertexIdx : BevelVerticesToRelink)
{
FBevelVertex& Vertex = Vertices[BevelVertexIdx];
FinalizeTerminatorVertex(Mesh, Vertex);
}
}
bool FMeshBevel::Apply(FDynamicMesh3& Mesh, FDynamicMeshChangeTracker* ChangeTracker)
{
FixBowties(Mesh, ChangeTracker);
// disconnect along bevel graph edges/vertices and save necessary info
UnlinkEdges(Mesh, ChangeTracker);
if (ResultInfo.CheckAndSetCancelled(Progress))
{
return false;
}
UnlinkLoops(Mesh, ChangeTracker);
if (ResultInfo.CheckAndSetCancelled(Progress))
{
return false;
}
UnlinkVertices(Mesh, ChangeTracker);
if (ResultInfo.CheckAndSetCancelled(Progress))
{
return false;
}
FixUpUnlinkedBevelEdges(Mesh);
if (ResultInfo.CheckAndSetCancelled(Progress))
{
return false;
}
// update vertex positions
DisplaceVertices(Mesh, InsetDistance);
if (ResultInfo.CheckAndSetCancelled(Progress))
{
return false;
}
// mesh the bevel corners and edges
if (NumSubdivisions <= 0)
{
CreateBevelMeshing(Mesh);
}
else
{
CreateBevelMeshing_Multi(Mesh);
}
if (ResultInfo.CheckAndSetCancelled(Progress))
{
return false;
}
// build output list of triangles so it can be re-used in operations below if useful
NewTriangles.Reset();
for (FBevelVertex& Vertex : Vertices)
{
NewTriangles.Append(Vertex.NewTriangles);
}
for (FBevelEdge& Edge : Edges)
{
UELocal::QuadsToTris(Mesh, Edge.StripQuads, NewTriangles, false);
}
for (FBevelLoop& Loop : Loops)
{
UELocal::QuadsToTris(Mesh, Loop.StripQuads, NewTriangles, false);
}
// compute normals
ComputeNormals(Mesh);
if (ResultInfo.CheckAndSetCancelled(Progress))
{
return false;
}
// compute UVs
ComputeUVs(Mesh);
if (ResultInfo.CheckAndSetCancelled(Progress))
{
return false;
}
ComputeMaterialIDs(Mesh);
if (ResultInfo.CheckAndSetCancelled(Progress))
{
return false;
}
// todo: compute other attribs
ResultInfo.SetSuccess(true, Progress);
return true;
}
FMeshBevel::FBevelVertex* FMeshBevel::GetBevelVertexFromVertexID(int32 VertexID, int32* IndexOut)
{
int32* FoundIndex = VertexIDToIndexMap.Find(VertexID);
if (FoundIndex == nullptr)
{
return nullptr;
}
if (IndexOut != nullptr)
{
*IndexOut = *FoundIndex;
}
return &Vertices[*FoundIndex];
}
void FMeshBevel::AddBevelGroupEdge(const FDynamicMesh3& Mesh, const FGroupTopology& Topology, int32 GroupEdgeID)
{
const TArray<int32>& MeshEdgeList = Topology.Edges[GroupEdgeID].Span.Edges;
// currently cannot handle boundary edges
if ( Algo::CountIf(MeshEdgeList, [&Mesh](int EdgeID) { return Mesh.IsBoundaryEdge(EdgeID); }) > 0 )
{
return;
}
FIndex2i EdgeCornerIDs = Topology.Edges[GroupEdgeID].EndpointCorners;
FBevelEdge Edge;
int32 NewBevelEdgeIndex = Edges.Num();
for (int32 ci = 0; ci < 2; ++ci)
{
int32 CornerID = EdgeCornerIDs[ci];
FGroupTopology::FCorner Corner = Topology.Corners[CornerID];
int32 VertexID = Corner.VertexID;
Edge.bEndpointBoundaryFlag[ci] = Mesh.IsBoundaryVertex(VertexID);
int32 IncomingEdgeID = (ci == 0) ? MeshEdgeList[0] : MeshEdgeList.Last();
int32 BevelVertexIndex = -1;
FBevelVertex* VertInfo = GetBevelVertexFromVertexID(VertexID, &BevelVertexIndex);
if (VertInfo == nullptr)
{
FBevelVertex NewVertex;
PRAGMA_DISABLE_DEPRECATION_WARNINGS
NewVertex.CornerID = CornerID;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
NewVertex.VertexID = VertexID;
BevelVertexIndex = Vertices.Num();
Vertices.Add(NewVertex);
VertexIDToIndexMap.Add(VertexID, BevelVertexIndex);
VertInfo = &Vertices[BevelVertexIndex];
}
VertInfo->IncomingBevelMeshEdges.Add(IncomingEdgeID);
PRAGMA_DISABLE_DEPRECATION_WARNINGS
VertInfo->IncomingBevelTopoEdges.Add(GroupEdgeID);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
VertInfo->IncomingBevelEdgeIndices.Add(NewBevelEdgeIndex);
Edge.BevelVertices[ci] = BevelVertexIndex;
}
Edge.MeshEdges.Append(MeshEdgeList);
Edge.MeshVertices.Append(Topology.Edges[GroupEdgeID].Span.Vertices);
PRAGMA_DISABLE_DEPRECATION_WARNINGS
Edge.GroupEdgeID = GroupEdgeID;
Edge.GroupIDs = Topology.Edges[GroupEdgeID].Groups;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
Edge.MeshEdgeTris.Reserve(Edge.MeshEdges.Num());
for (int32 eid : Edge.MeshEdges)
{
Edge.MeshEdgeTris.Add(Mesh.GetEdgeT(eid));
}
Edge.InitialPositions.Reserve(Edge.MeshVertices.Num());
for (int32 vid : Edge.MeshVertices)
{
Edge.InitialPositions.Add(Mesh.GetVertex(vid));
}
Edge.EdgeIndex = Edges.Num();
Edges.Add(MoveTemp(Edge));
}
void FMeshBevel::AddBevelEdgeLoop(const FDynamicMesh3& Mesh, const FEdgeLoop& MeshEdgeLoop)
{
// currently cannot handle boundary edges
if ( Algo::CountIf(MeshEdgeLoop.Edges, [&Mesh](int EdgeID) { return Mesh.IsBoundaryEdge(EdgeID); }) > 0 )
{
return;
}
FBevelLoop Loop;
Loop.MeshEdges = MeshEdgeLoop.Edges;
Loop.MeshVertices = MeshEdgeLoop.Vertices;
Loop.MeshEdgeTris.Reserve(Loop.MeshEdges.Num());
for (int32 eid : Loop.MeshEdges)
{
Loop.MeshEdgeTris.Add(Mesh.GetEdgeT(eid));
}
Loop.InitialPositions.Reserve(Loop.MeshVertices.Num());
for (int32 vid : Loop.MeshVertices)
{
Loop.InitialPositions.Add(Mesh.GetVertex(vid));
}
Loops.Add(Loop);
}
void FMeshBevel::InitVertexSet(const FDynamicMesh3& Mesh, FMeshBevel::FBevelVertex& Vertex)
{
// get sorted list of triangles around the vertex
TArray<int> GroupLengths;
TArray<bool> bGroupIsLoop;
EMeshResult Result = Mesh.GetVtxContiguousTriangles(Vertex.VertexID, Vertex.SortedTriangles, GroupLengths, bGroupIsLoop);
if (Result != EMeshResult::Ok || GroupLengths.Num() != 1 || Vertex.SortedTriangles.Num() < 2)
{
Vertex.VertexType = EBevelVertexType::Unknown;
return;
}
// GetVtxContiguousTriangles does not return triangles sorted in a consistent direction. This check will
// reverse the ordering such that it is consistently walking counter-clockwise around the vertex (I think...)
FIndex3i Tri0 = Mesh.GetTriangle(Vertex.SortedTriangles[0]).GetCycled(Vertex.VertexID);
FIndex3i Tri1 = Mesh.GetTriangle(Vertex.SortedTriangles[1]).GetCycled(Vertex.VertexID);
if (Tri0.C == Tri1.B)
{
Algo::Reverse(Vertex.SortedTriangles);
}
if (Mesh.IsBoundaryVertex(Vertex.VertexID))
{
Vertex.VertexType = EBevelVertexType::BoundaryVertex;
// TODO: we should have a BuildBoundaryVertex function here that correctly populates the
// Wedges for the boundary vertex. The currently BuildJunctionVertex will not be able to do
// this because it assumes it can just walk forward from any edge
return;
}
MESH_BEVEL_DEBUG_CHECK(Vertex.IncomingBevelMeshEdges.Num() != 0); // shouldn't ever happen
if (Vertex.IncomingBevelMeshEdges.Num() == 1)
{
BuildTerminatorVertex(Vertex, Mesh);
}
else
{
BuildJunctionVertex(Vertex, Mesh);
}
}
void FMeshBevel::FinalizeTerminatorVertex(const FDynamicMesh3& Mesh, FBevelVertex& Vertex)
{
if (Vertex.VertexType == EBevelVertexType::TerminatorVertex)
{
int32 OtherVertexID = Vertex.TerminatorInfo.B;
int32* OtherBevelVtxIdx = VertexIDToIndexMap.Find(OtherVertexID);
if (OtherBevelVtxIdx != nullptr)
{
// does other vertex have to be a terminator? or can this also happen w/ a junction?
FBevelVertex& OtherVertex = Vertices[*OtherBevelVtxIdx];
if (OtherVertex.VertexType == EBevelVertexType::TerminatorVertex)
{
// want to skip this if the ring-split edge is already a bevel edge
int32 MeshEdgeID = Mesh.FindEdge(Vertex.VertexID, OtherVertex.VertexID);
MESH_BEVEL_DEBUG_CHECK(MeshEdgeID >= 0);
if (Mesh.IsEdge(MeshEdgeID) &&
Vertex.TerminatorInfo.A == MeshEdgeID &&
OtherVertex.TerminatorInfo.A == MeshEdgeID && // do we need the other vertex to use the same edge here? (is this actually a hard constraint on that edge that we should be enforcing??)
Vertex.IncomingBevelMeshEdges.Contains(MeshEdgeID) == false)
{
Vertex.ConnectedBevelVertex = *OtherBevelVtxIdx;
}
}
}
}
}
void FMeshBevel::BuildVertexSets(const FDynamicMesh3& Mesh)
{
// can be parallel
for (FBevelVertex& Vertex : Vertices)
{
InitVertexSet(Mesh, Vertex);
if (ResultInfo.CheckAndSetCancelled(Progress))
{
return;
}
}
// At a 'Terminator' vertex we are going to split the one-ring and fill the bevel-side with a quad, which
// will usually leave a single-triangle hole. However if two Terminator vertices are directly connected
// via a non-bevel mesh edge, the two triangles will be connected, ie the hole is quad-shaped. It's easier
// to detect this case here /before/ we split the mesh up into disconnected parts...
for (FBevelVertex& Vertex : Vertices)
{
FinalizeTerminatorVertex(Mesh, Vertex);
}
}
void FMeshBevel::BuildJunctionVertex(FBevelVertex& Vertex, const FDynamicMesh3& Mesh)
{
//
// Now split up the single contiguous one-ring into "Wedges" created by the incoming split-edges
//
// find first split edge, and the triangle/index "after" that first split edge
int32 NT = Vertex.SortedTriangles.Num();
int32 StartTriIndex = -1;
for (int32 k = 0; k < NT; ++k)
{
if (FindSharedEdgeInTriangles(Mesh, Vertex.SortedTriangles[k], Vertex.SortedTriangles[(k + 1) % NT]) == Vertex.IncomingBevelMeshEdges[0])
{
StartTriIndex = (k + 1) % NT; // start at second tri, so that bevel-edge is first edge in wedge
break;
}
}
if (StartTriIndex == -1)
{
Vertex.VertexType = EBevelVertexType::Unknown;
return;
}
// now walk around the one-ring tris, accumulating into current Wedge until we hit another split-edge,
// at which point a new Wedge is spawned
int32 CurTriIndex = StartTriIndex;
FOneRingWedge CurWedge;
CurWedge.WedgeVertex = Vertex.VertexID;
CurWedge.Triangles.Add(Vertex.SortedTriangles[CurTriIndex]);
CurWedge.BorderEdges.A = Vertex.IncomingBevelMeshEdges[0];
for (int32 k = 0; k < NT; ++k)
{
int32 CurTri = Vertex.SortedTriangles[CurTriIndex % NT];
int32 NextTri = Vertex.SortedTriangles[(CurTriIndex + 1) % NT];
int32 SharedEdge = FindSharedEdgeInTriangles(Mesh, CurTri, NextTri);
MESH_BEVEL_DEBUG_CHECK(SharedEdge != -1);
if (Vertex.IncomingBevelMeshEdges.Contains(SharedEdge))
{
// if we found a bevel-edge, close the current wedge and start a new one
CurWedge.BorderEdges.B = SharedEdge;
Vertex.Wedges.Add(CurWedge);
CurWedge = FOneRingWedge();
CurWedge.WedgeVertex = Vertex.VertexID;
CurWedge.BorderEdges.A = SharedEdge;
}
CurWedge.Triangles.Add(NextTri);
CurTriIndex++;
}
// ?? is there a chance that we have a final open wedge here? we iterate one extra time so it shouldn't happen (or could we get an extra wedge then??)
for (FOneRingWedge& Wedge : Vertex.Wedges)
{
Wedge.BorderEdgeTriEdgeIndices.A = Mesh.GetTriEdges(Wedge.Triangles[0]).IndexOf(Wedge.BorderEdges.A);
Wedge.BorderEdgeTriEdgeIndices.B = Mesh.GetTriEdges(Wedge.Triangles.Last()).IndexOf(Wedge.BorderEdges.B);
}
if (Vertex.Wedges.Num() > 1)
{
Vertex.VertexType = EBevelVertexType::JunctionVertex;
}
else
{
Vertex.VertexType = EBevelVertexType::Unknown;
}
}
void FMeshBevel::BuildTerminatorVertex(FBevelVertex& Vertex, const FDynamicMesh3& Mesh)
{
Vertex.VertexType = EBevelVertexType::Unknown;
if (MESH_BEVEL_DEBUG_ENSURE(Vertex.IncomingBevelMeshEdges.Num() == 1) == false)
{
return;
}
int32 IncomingEdgeID = Vertex.IncomingBevelMeshEdges[0];
int32 NumTris = Vertex.SortedTriangles.Num();
// We have one edge coming into the vertex one ring, our main problem is to pick a second
// edge to split the one-ring with. There is no obvious right answer in many cases.
// "other" split edge that we pick
int32 RingSplitEdgeID = -1;
// NOTE: code below assumes we have polygroups on the mesh. In theory we could also support not having polygroups,
// by (eg) picking an arbitrary edge "furthest" from IncomingEdgeID in the exponential map
// Find the ordered set of triangles that are not in either of the groups connected to IncomingEdgeID. Eg imagine
// a cube corner, if we want to bevel IncomingEdgeID along one of the cube edges, we want to add the new edge
// in the "furthest" face (perpendicular to the edge)
FIndex2i IncomingEdgeT = Mesh.GetEdgeT(IncomingEdgeID);
FIndex2i IncomingEdgeGroups(Mesh.GetTriangleGroup(IncomingEdgeT.A), Mesh.GetTriangleGroup(IncomingEdgeT.B));
// Find the first index of Vertex.SortedTriangles that we want to remove.
// This should not be able to fail but if it does, we will just start at 0
// and maybe end up with some bevel failures below
int32 NumTriangles = Vertex.SortedTriangles.Num();
int32 StartIndex = 0;
for (int32 k = 0; k < NumTriangles; ++k)
{
int32 gid = Mesh.GetTriangleGroup(Vertex.SortedTriangles[k]);
if (IncomingEdgeGroups.Contains(gid))
{
StartIndex = k;
break;
}
}
TArray<int32> OtherGroupTris; // sorted wedge of triangles that are not in either of the groups connected to incoming edge
TArray<int32> OtherGroups; // list of group IDs encountered, in-order
for ( int32 k = 0; k < NumTriangles; ++k )
{
// Vertex.SortedTriangles was ordered, ie sequential triangles were connected, but if we filter
// out some triangles it may no longer be sequential in OtherGroupTris, leading to badness.
// But the two groups we are removing should be contiguous, so if we start there, then the
// remaining tris should be contiguous. StartIndex found above should give us that triangle.
int32 ShiftedIndex = (StartIndex + k) % NumTriangles;
int32 tid = Vertex.SortedTriangles[ShiftedIndex];
int32 gid = Mesh.GetTriangleGroup(tid);
if (IncomingEdgeGroups.Contains(gid) == false)
{
OtherGroupTris.Add(tid);
OtherGroups.AddUnique(gid);
}
}
int32 NumRemainingTris = OtherGroupTris.Num();
// Determine which edge to split at in the "other" group triangles. If we only have one group
// then we can try to pick the "middlest" edge. The worst case is when there is only one triangle,
// then we are picking a not-very-good edge no matter what (potentially we should do an edge split or
// face poke in that situation). If we have multiple groups then we probably want to pick one
// of the group-boundary edges inside the triangle-span, ideally the "middlest" but currently we
// are just picking one arbitrarily...
if (OtherGroups.Num() == 1)
{
Vertex.NewGroupID = OtherGroups[0];
if (OtherGroupTris.Num() == 1)
{
FIndex3i TriEdges = Mesh.GetTriEdges(OtherGroupTris[0]);
for (int32 j = 0; j < 3; ++j)
{
if (Mesh.GetEdgeV(TriEdges[j]).Contains(Vertex.VertexID))
{
RingSplitEdgeID = TriEdges[j];
break;
}
}
}
else if (OtherGroupTris.Num() == 2)
{
RingSplitEdgeID = FindSharedEdgeInTriangles(Mesh, OtherGroupTris[0], OtherGroupTris[1]);
}
else
{
// try using the 'middlest' triangle as the 'middlest' edge
// TODO: should compute opening angles here and pick the edge closest to the middle of the angular span!!
int32 j = OtherGroupTris.Num() / 2;
RingSplitEdgeID = FindSharedEdgeInTriangles(Mesh, OtherGroupTris[j], OtherGroupTris[j+1]);
// If the OtherGroupTris list ended up being not contiguous (see above for how that can happen), then
// it's possible that (j) and (j+1) are not connected and the share-edge search will fail. In that case
// we will just linear-search for two connected triangles. If this fails then this vertex will not be bevelled.
if (RingSplitEdgeID == -1)
{
for (int32 k = 0; k < NumRemainingTris; ++k)
{
RingSplitEdgeID = FindSharedEdgeInTriangles(Mesh, OtherGroupTris[k], OtherGroupTris[(k+1)%NumRemainingTris]);
if (RingSplitEdgeID != -1)
{
break;
}
}
}
}
}
else
{
// Search for two adjacent triangles in different groups that have a shared edge. This search
// may need to wrap around if we got unlucky in the triangle ordering in OtherGroupTris
for (int32 k = 0; k < OtherGroupTris.Num(); ++k)
{
int32 TriangleA = OtherGroupTris[k], TriangleB = OtherGroupTris[(k+1)%NumRemainingTris];
if (Mesh.GetTriangleGroup(TriangleA) != Mesh.GetTriangleGroup(TriangleB))
{
RingSplitEdgeID = FindSharedEdgeInTriangles(Mesh, TriangleA, TriangleB);
Vertex.NewGroupID = -1; // allocate a new group for this triangle, this is usually what one would want
break;
}
}
}
if (RingSplitEdgeID == -1)
{
return;
}
// save edgeid/vertexid for the 'terminator edge' that we will disconnect at
FIndex2i SplitEdgeV = Mesh.GetEdgeV(RingSplitEdgeID);
Vertex.TerminatorInfo = FIndex2i(RingSplitEdgeID, SplitEdgeV.OtherElement(Vertex.VertexID));
// split the terminator vertex into two wedges
TArray<int32> SplitTriSets[2];
if (SplitInteriorVertexTrianglesIntoSubsets(&Mesh, Vertex.VertexID, IncomingEdgeID, RingSplitEdgeID, SplitTriSets[0], SplitTriSets[1]) == false)
{
return;
}
// make the wedge list
Vertex.Wedges.SetNum(2);
Vertex.Wedges[0].WedgeVertex = Vertex.VertexID;
Vertex.Wedges[0].Triangles.Append(SplitTriSets[0]);
Vertex.Wedges[1].WedgeVertex = Vertex.VertexID;
Vertex.Wedges[1].Triangles.Append(SplitTriSets[1]);
// We need to know the two border edges of each wedge, because we will use this information
// in later stages. Note that this block is not specific to the TerminatorVertex case
for (FOneRingWedge& Wedge : Vertex.Wedges)
{
int32 NumWedgeTris = Wedge.Triangles.Num();
FIndex2i VtxEdges0 = IndexUtil::FindVertexEdgesInTriangle(Mesh, Wedge.Triangles[0], Vertex.VertexID);
if (NumWedgeTris == 1)
{
// If the wedge only has one tri, both edges are the border edges.
// Note that these are not sorted, ie B might not be the edge shared with the next Wedge.
// Currently this does not matter but it might in the future?
Wedge.BorderEdges.A = VtxEdges0.A;
Wedge.BorderEdges.B = VtxEdges0.B;
}
else
{
// the wedge-border-edge is *not* the edge connected to the next triangle in the wedge-triangle-list
Wedge.BorderEdges.A = ( Mesh.GetEdgeT(VtxEdges0.A).Contains(Wedge.Triangles[1]) ) ? VtxEdges0.B : VtxEdges0.A;
// final wedge-border-edge is the same case, with the last and second-last tris
FIndex2i VtxEdges1 = IndexUtil::FindVertexEdgesInTriangle(Mesh, Wedge.Triangles[NumWedgeTris-1], Vertex.VertexID);
Wedge.BorderEdges.B = ( Mesh.GetEdgeT(VtxEdges1.A).Contains(Wedge.Triangles[NumWedgeTris-2]) ) ? VtxEdges1.B : VtxEdges1.A;
}
// save the index of the border edge in it's triangle, so that when we disconnect the wedges later,
// we can find the new edge ID
Wedge.BorderEdgeTriEdgeIndices.A = Mesh.GetTriEdges(Wedge.Triangles[0]).IndexOf(Wedge.BorderEdges.A);
Wedge.BorderEdgeTriEdgeIndices.B = Mesh.GetTriEdges(Wedge.Triangles.Last()).IndexOf(Wedge.BorderEdges.B);
}
Vertex.VertexType = EBevelVertexType::TerminatorVertex;
}
void FMeshBevel::UnlinkEdges(FDynamicMesh3& Mesh, FDynamicMeshChangeTracker* ChangeTracker)
{
for (FBevelEdge& Edge : Edges)
{
UnlinkBevelEdgeInterior(Mesh, Edge, ChangeTracker);
}
}
namespace UELocal
{
// decomposition of a vertex one-ring into two connected triangle subsets
struct FVertexSplit
{
int32 VertexID;
bool bOK;
TArray<int32> TriSets[2];
};
// walk along a sequence of vertex-splits and make sure that the split triangle sets
// maintain consistent "sides" (see call in UnlinkBevelEdgeInterior for more details)
static void ReconcileTriangleSets(TArray<FVertexSplit>& SplitSequence)
{
int32 N = SplitSequence.Num();
TArray<int32> PrevTriSet0;
for (int32 k = 0; k < N; ++k)
{
if (PrevTriSet0.Num() == 0 && SplitSequence[k].TriSets[0].Num() > 0)
{
PrevTriSet0 = SplitSequence[k].TriSets[0];
}
else
{
bool bFoundInSet0 = false;
for (int32 tid : SplitSequence[k].TriSets[0])
{
if (PrevTriSet0.Contains(tid))
{
bFoundInSet0 = true;
break;
}
}
if (!bFoundInSet0)
{
Swap(SplitSequence[k].TriSets[0], SplitSequence[k].TriSets[1]);
}
PrevTriSet0 = SplitSequence[k].TriSets[0];
}
}
}
};
void FMeshBevel::UnlinkBevelEdgeInterior(
FDynamicMesh3& Mesh,
FBevelEdge& BevelEdge,
FDynamicMeshChangeTracker* ChangeTracker)
{
// figure out what sets of triangles to split each vertex into
int32 N = BevelEdge.MeshVertices.Num();
TArray<UELocal::FVertexSplit> SplitsToProcess;
SplitsToProcess.SetNum(N);
// precompute triangle sets for each vertex we want to split, by "cutting" the one ring into two halves based
// on edges - 2 edges for interior vertices, and 1 edge for a boundary vertex at the start/end of the edge-span
SplitsToProcess[0] = UELocal::FVertexSplit{ BevelEdge.MeshVertices[0], false };
if (BevelEdge.bEndpointBoundaryFlag[0])
{
SplitsToProcess[0].bOK = SplitBoundaryVertexTrianglesIntoSubsets(&Mesh, SplitsToProcess[0].VertexID, BevelEdge.MeshEdges[0],
SplitsToProcess[0].TriSets[0], SplitsToProcess[0].TriSets[1]);
}
for (int32 k = 1; k < N - 1; ++k)
{
SplitsToProcess[k].VertexID = BevelEdge.MeshVertices[k];
if (Mesh.IsBoundaryVertex(SplitsToProcess[k].VertexID))
{
SplitsToProcess[k].bOK = false;
}
else
{
SplitsToProcess[k].bOK = SplitInteriorVertexTrianglesIntoSubsets(&Mesh, SplitsToProcess[k].VertexID,
BevelEdge.MeshEdges[k-1], BevelEdge.MeshEdges[k], SplitsToProcess[k].TriSets[0], SplitsToProcess[k].TriSets[1]);
}
}
SplitsToProcess[N-1] = UELocal::FVertexSplit{ BevelEdge.MeshVertices[N - 1], false };
if (BevelEdge.bEndpointBoundaryFlag[1])
{
SplitsToProcess[N-1].bOK = SplitBoundaryVertexTrianglesIntoSubsets(&Mesh, SplitsToProcess[N-1].VertexID, BevelEdge.MeshEdges[N-2],
SplitsToProcess[N-1].TriSets[0], SplitsToProcess[N-1].TriSets[1]);
}
// SplitInteriorVertexTrianglesIntoSubsets does not consistently order its output sets, ie, if you imagine [Edge0,Edge1] as a path
// cutting through the one ring, the "side" that Set0 and Set1 end up is arbitrary, and depends on the ordering of edges in the triangles of Edge1.
// This might ideally be fixed in the future, but for the time being, all we need is consistency. So we walk from the start of the
// edge to the end, checking for overlap between each tri-one-ring-wedge. If Split[k].TriSet0 does not overlap with Split[k-1].TriSet0, then
// we want to swap TriSet0 and TriSet1 at Split[k].
UELocal::ReconcileTriangleSets(SplitsToProcess);
// apply vertex splits and accumulate new list
N = SplitsToProcess.Num();
for (int32 k = 0; k < N; ++k)
{
const UELocal::FVertexSplit& Split = SplitsToProcess[k];
if (ChangeTracker)
{
ChangeTracker->SaveVertexOneRingTriangles(Split.VertexID, true);
}
bool bDone = false;
if (Split.bOK)
{
FDynamicMesh3::FVertexSplitInfo SplitInfo;
EMeshResult Result = Mesh.SplitVertex(Split.VertexID, Split.TriSets[0], SplitInfo);
if (MESH_BEVEL_DEBUG_ENSURE(Result == EMeshResult::Ok))
{
BevelEdge.NewMeshVertices.Add(SplitInfo.NewVertex);
bDone = true;
}
}
if (!bDone)
{
BevelEdge.NewMeshVertices.Add(Split.VertexID);
}
}
// now build edge correspondences
N = BevelEdge.MeshVertices.Num();
MESH_BEVEL_DEBUG_CHECK(N == BevelEdge.NewMeshVertices.Num());
for (int32 k = 0; k < N-1; ++k)
{
int32 Edge0 = BevelEdge.MeshEdges[k];
int32 Edge1 = Mesh.FindEdge(BevelEdge.NewMeshVertices[k], BevelEdge.NewMeshVertices[k + 1]);
BevelEdge.NewMeshEdges.Add(Edge1);
MESH_BEVEL_DEBUG_CHECK(Edge1 >= 0);
if ( Mesh.IsEdge(Edge1) && Edge0 != Edge1 && MeshEdgePairs.Contains(Edge0) == false )
{
MeshEdgePairs.Add(Edge0, Edge1);
MeshEdgePairs.Add(Edge1, Edge0);
}
}
}
void FMeshBevel::UnlinkBevelLoop(FDynamicMesh3& Mesh, FBevelLoop& BevelLoop, FDynamicMeshChangeTracker* ChangeTracker)
{
int32 N = BevelLoop.MeshVertices.Num();
TArray<UELocal::FVertexSplit> SplitsToProcess;
SplitsToProcess.SetNum(N);
// precompute triangle sets for each vertex we want to split
for (int32 k = 0; k < N; ++k)
{
SplitsToProcess[k].VertexID = BevelLoop.MeshVertices[k];
if (Mesh.IsBoundaryVertex(SplitsToProcess[k].VertexID))
{
// cannot split boundary vertex
SplitsToProcess[k].bOK = false;
}
else
{
int32 PrevEdge = (k == 0) ? BevelLoop.MeshEdges.Last() : BevelLoop.MeshEdges[k-1];
int32 CurEdge = BevelLoop.MeshEdges[k];
SplitsToProcess[k].bOK = SplitInteriorVertexTrianglesIntoSubsets(&Mesh, SplitsToProcess[k].VertexID,
PrevEdge, CurEdge, SplitsToProcess[k].TriSets[0], SplitsToProcess[k].TriSets[1]);
}
}
// fix up triangle sets - see call in UnlinkBevelEdgeInterior() for more info
UELocal::ReconcileTriangleSets(SplitsToProcess);
// apply vertex splits and accumulate new list
N = SplitsToProcess.Num();
for (int32 k = 0; k < N; ++k)
{
const UELocal::FVertexSplit& Split = SplitsToProcess[k];
if (ChangeTracker)
{
ChangeTracker->SaveVertexOneRingTriangles(Split.VertexID, true);
}
bool bDone = false;
if (Split.bOK)
{
FDynamicMesh3::FVertexSplitInfo SplitInfo;
EMeshResult Result = Mesh.SplitVertex(Split.VertexID, Split.TriSets[1], SplitInfo);
if (MESH_BEVEL_DEBUG_ENSURE(Result == EMeshResult::Ok))
{
BevelLoop.NewMeshVertices.Add(SplitInfo.NewVertex);
bDone = true;
}
}
if (!bDone)
{
BevelLoop.NewMeshVertices.Add(Split.VertexID); // failed to split, so we have a shared vertex on both "sides"
}
}
// now build edge correspondences
N = BevelLoop.MeshVertices.Num();
MESH_BEVEL_DEBUG_CHECK(N == BevelLoop.NewMeshVertices.Num());
for (int32 k = 0; k < N; ++k)
{
int32 Edge0 = BevelLoop.MeshEdges[k];
int32 Edge1 = Mesh.FindEdge(BevelLoop.NewMeshVertices[k], BevelLoop.NewMeshVertices[(k + 1)%N]);
BevelLoop.NewMeshEdges.Add(Edge1);
MESH_BEVEL_DEBUG_CHECK(Edge1 >= 0);
if (Mesh.IsEdge(Edge1) && Edge0 != Edge1 && MeshEdgePairs.Contains(Edge0) == false )
{
MeshEdgePairs.Add(Edge0, Edge1);
MeshEdgePairs.Add(Edge1, Edge0);
}
}
}
void FMeshBevel::UnlinkLoops(FDynamicMesh3& Mesh, FDynamicMeshChangeTracker* ChangeTracker)
{
for (FBevelLoop& Loop : Loops)
{
UnlinkBevelLoop(Mesh, Loop, ChangeTracker);
}
}
void FMeshBevel::UnlinkVertices(FDynamicMesh3& Mesh, FDynamicMeshChangeTracker* ChangeTracker)
{
// TODO: currently have to do terminator vertices first because we do some of the
// determination inside the unlink code...
for (FBevelVertex& Vertex : Vertices)
{
if (Vertex.VertexType == EBevelVertexType::TerminatorVertex)
{
UnlinkTerminatorVertex(Mesh, Vertex, ChangeTracker);
}
}
for (FBevelVertex& Vertex : Vertices)
{
if (Vertex.VertexType == EBevelVertexType::JunctionVertex)
{
UnlinkJunctionVertex(Mesh, Vertex, ChangeTracker);
}
}
}
void FMeshBevel::UnlinkJunctionVertex(FDynamicMesh3& Mesh, FBevelVertex& Vertex, FDynamicMeshChangeTracker* ChangeTracker)
{
MESH_BEVEL_DEBUG_CHECK(Vertex.VertexType == EBevelVertexType::JunctionVertex);
if (ChangeTracker)
{
ChangeTracker->SaveVertexOneRingTriangles(Vertex.VertexID, true);
}
int32 NumWedges = Vertex.Wedges.Num();
MESH_BEVEL_DEBUG_CHECK(NumWedges > 1);
// Split triangles around vertex into separate tri-sets based on wedges.
// This will create a new vertex for each wedge.
for (int32 k = 1; k < NumWedges; ++k)
{
FOneRingWedge& Wedge = Vertex.Wedges[k];
FDynamicMesh3::FVertexSplitInfo SplitInfo;
EMeshResult Result = Mesh.SplitVertex(Vertex.VertexID, Wedge.Triangles, SplitInfo);
if (MESH_BEVEL_DEBUG_ENSURE(Result == EMeshResult::Ok))
{
Wedge.WedgeVertex = SplitInfo.NewVertex;
}
}
// update end start/end pairs for each wedge. If we created new edges above, this is
// the first time we will encounter them, so save in edge correspondence map
for (int32 k = 0; k < NumWedges; ++k)
{
FOneRingWedge& Wedge = Vertex.Wedges[k];
for (int32 j = 0; j < 2; ++j)
{
int32 OldWedgeEdgeID = Wedge.BorderEdges[j];
int32 OldWedgeEdgeIndex = Wedge.BorderEdgeTriEdgeIndices[j];
int32 TriangleID = (j == 0) ? Wedge.Triangles[0] : Wedge.Triangles.Last();
int32 CurWedgeEdgeID = Mesh.GetTriEdges(TriangleID)[OldWedgeEdgeIndex];
if (OldWedgeEdgeID != CurWedgeEdgeID)
{
if (MeshEdgePairs.Contains(OldWedgeEdgeID) == false)
{
MeshEdgePairs.Add(OldWedgeEdgeID, CurWedgeEdgeID);
MeshEdgePairs.Add(CurWedgeEdgeID, OldWedgeEdgeID);
}
Wedge.BorderEdges[j] = CurWedgeEdgeID;
}
}
}
}
void FMeshBevel::UnlinkTerminatorVertex(FDynamicMesh3& Mesh, FBevelVertex& BevelVertex, FDynamicMeshChangeTracker* ChangeTracker)
{
MESH_BEVEL_DEBUG_CHECK(BevelVertex.VertexType == EBevelVertexType::TerminatorVertex);
MESH_BEVEL_DEBUG_CHECK(BevelVertex.Wedges.Num() == 2);
if (ChangeTracker)
{
ChangeTracker->SaveVertexOneRingTriangles(BevelVertex.VertexID, true);
}
// split the vertex
FDynamicMesh3::FVertexSplitInfo SplitInfo;
EMeshResult Result = Mesh.SplitVertex(BevelVertex.VertexID, BevelVertex.Wedges[1].Triangles, SplitInfo);
if (MESH_BEVEL_DEBUG_ENSURE(Result == EMeshResult::Ok))
{
BevelVertex.Wedges[1].WedgeVertex = SplitInfo.NewVertex;
// update end start/end pairs for each wedge, and save in the edge correspondence map.
// Note that this is the same block as in UnlinkJunctionVertex
int32 NumWedges = BevelVertex.Wedges.Num();
for (int32 k = 0; k < NumWedges; ++k)
{
FOneRingWedge& Wedge = BevelVertex.Wedges[k];
for (int32 j = 0; j < 2; ++j)
{
int32 OldWedgeEdgeID = Wedge.BorderEdges[j];
int32 OldWedgeEdgeIndex = Wedge.BorderEdgeTriEdgeIndices[j];
int32 TriangleID = (j == 0) ? Wedge.Triangles[0] : Wedge.Triangles.Last();
int32 CurWedgeEdgeID = Mesh.GetTriEdges(TriangleID)[OldWedgeEdgeIndex];
if (OldWedgeEdgeID != CurWedgeEdgeID)
{
if (MeshEdgePairs.Contains(OldWedgeEdgeID) == false)
{
MeshEdgePairs.Add(OldWedgeEdgeID, CurWedgeEdgeID);
MeshEdgePairs.Add(CurWedgeEdgeID, OldWedgeEdgeID);
}
Wedge.BorderEdges[j] = CurWedgeEdgeID;
}
}
}
}
}
void FMeshBevel::FixUpUnlinkedBevelEdges(FDynamicMesh3& Mesh)
{
// Rewrite vertex IDs in BevelEdge vertex lists to correctly match the vertices in the new unlinked wedges.
// We did not know these new vertices in UnlinkBevelEdgeInterior() because we didn't unlink the vertices
// into wedges until afterwards.
for (FBevelEdge& Edge : Edges)
{
// In some cases, like single edges, Edge.NewMeshEdges is incorrect (mapped to itself); e.g., because we
// could not actually unlink the edge in UnlinkBevelEdgeInterior (if there were no interior vertices).
// Now that all vertices are unlinked, take one more pass through and fix the single-edge or self-mapped edges.
bool bSingleEdge = Edge.MeshEdges.Num() == 1;
bool bFailedEdgePairing = false;
for (int32 Idx = 0; Idx < Edge.MeshEdges.Num(); ++Idx)
{
bool bNewEdgeIsOld = Edge.MeshEdges[Idx] == Edge.NewMeshEdges[Idx];
if (!bSingleEdge && !bNewEdgeIsOld)
{
continue;
}
int32* FoundOtherEdge = MeshEdgePairs.Find(Edge.MeshEdges[Idx]);
MESH_BEVEL_DEBUG_CHECK(FoundOtherEdge != nullptr);
if (FoundOtherEdge != nullptr)
{
Edge.NewMeshEdges[Idx] = *FoundOtherEdge;
}
else
{
bFailedEdgePairing = true; // something went wrong, loop below will break things
break;
}
}
if (bFailedEdgePairing)
{
continue;
}
// process start and end vertices of the path
for (int32 j = 0; j < 2; ++j)
{
int32 vi = (j == 0) ? 0 : (Edge.MeshVertices.Num()-1);
int32 ei = (j == 0) ? 0 : (Edge.MeshEdges.Num()-1);
const FBevelVertex* BevelVertex = GetBevelVertexFromVertexID(Edge.MeshVertices[vi]);
int32& V0 = Edge.MeshVertices[vi];
int32& V1 = Edge.NewMeshVertices[vi];
int32 E0 = Edge.MeshEdges[ei], E1 = Edge.NewMeshEdges[ei];
bool bFoundV0 = false, bFoundV1 = false;
for (const FOneRingWedge& Wedge : BevelVertex->Wedges)
{
for (int32 tid : Wedge.Triangles)
{
FIndex3i TriEdges = Mesh.GetTriEdges(tid);
if (TriEdges.Contains(E0) && bFoundV0 == false)
{
MESH_BEVEL_DEBUG_CHECK( Mesh.GetEdgeV(E0).Contains(Wedge.WedgeVertex) );
V0 = Wedge.WedgeVertex;
bFoundV0 = true;
break;
}
else if (TriEdges.Contains(E1) && bFoundV1 == false)
{
MESH_BEVEL_DEBUG_CHECK( Mesh.GetEdgeV(E1).Contains(Wedge.WedgeVertex) );
V1 = Wedge.WedgeVertex;
bFoundV1 = true;
break;
}
}
}
}
}
}
void FMeshBevel::DisplaceVertices(FDynamicMesh3& Mesh, double Distance)
{
// fallback (very bad) technique to compute an inset vertex
auto GetDisplacedVertexPos = [Distance](const FDynamicMesh3& Mesh, int32 VertexID) -> FVector3d
{
FVector3d CurPos = Mesh.GetVertex(VertexID);
FVector3d Centroid = FMeshWeights::MeanValueCentroid(Mesh, VertexID);
return CurPos + Distance * Normalized(Centroid - CurPos);
};
// Basically want to inset any beveled edges inwards into the existing poly-faces.
// To do this we will solve using our standard inset technique, eg similar to FInsetMeshRegion,
// which involves computing 'inset lines' for each edge and then finding nearest-points between
// pairs of lines (which will be the intersection point if the face is planar).
// Need to keep track of the inset line sets for open paths because at the corner vertices we
// will need to combine data from multiple path-line-sets (possibly could do this more efficiently
// as we only ever need the first and last...but small in context)
struct FEdgePathInsetLines
{
TArray<FLine3d> InsetLines0;
TArray<FLine3d> InsetLines1;
};
TArray<FEdgePathInsetLines> AllInsetLines;
AllInsetLines.SetNum(Edges.Num());
// solve open paths
for ( int32 k = 0; k < Edges.Num(); ++k)
{
FBevelEdge& Edge = Edges[k];
UE::Geometry::ComputeInsetLineSegmentsFromEdges(Mesh, Edge.MeshEdges, InsetDistance, AllInsetLines[k].InsetLines0);
UE::Geometry::SolveInsetVertexPositionsFromInsetLines(Mesh, AllInsetLines[k].InsetLines0, Edge.MeshVertices, Edge.NewPositions0, false);
UE::Geometry::ComputeInsetLineSegmentsFromEdges(Mesh, Edge.NewMeshEdges, InsetDistance, AllInsetLines[k].InsetLines1);
UE::Geometry::SolveInsetVertexPositionsFromInsetLines(Mesh, AllInsetLines[k].InsetLines1, Edge.NewMeshVertices, Edge.NewPositions1, false);
}
// solve loops
for (FBevelLoop& Loop : Loops)
{
TArray<FLine3d> InsetLines;
UE::Geometry::ComputeInsetLineSegmentsFromEdges(Mesh, Loop.MeshEdges, InsetDistance, InsetLines);
UE::Geometry::SolveInsetVertexPositionsFromInsetLines(Mesh, InsetLines, Loop.MeshVertices, Loop.NewPositions0, true);
UE::Geometry::ComputeInsetLineSegmentsFromEdges(Mesh, Loop.NewMeshEdges, InsetDistance, InsetLines);
UE::Geometry::SolveInsetVertexPositionsFromInsetLines(Mesh, InsetLines, Loop.NewMeshVertices, Loop.NewPositions1, true);
}
// Now solve corners. For corners, we want to find the 1 or 2 inset-lines corresponding
// to the outgoing bevel-edges at each bevel-vertex-wedge.
for (FBevelVertex& Vertex : Vertices)
{
if (Vertex.VertexType == EBevelVertexType::Unknown)
{
continue;
}
int32 NumWedges = Vertex.Wedges.Num();
for (int32 k = 0; k < NumWedges; ++k)
{
FOneRingWedge& Wedge = Vertex.Wedges[k];
FVector3d CurPos = Mesh.GetVertex(Wedge.WedgeVertex);
// collect up set of inset lines relevant to this vertex
TArray<FLine3d> SolveLines;
for (int32 j : Vertex.IncomingBevelEdgeIndices)
{
if (Edges[j].MeshVertices[0] == Wedge.WedgeVertex)
{
SolveLines.Add(AllInsetLines[j].InsetLines0[0]);
}
else if (Edges[j].MeshVertices.Last() == Wedge.WedgeVertex)
{
SolveLines.Add(AllInsetLines[j].InsetLines0.Last());
}
else if (Edges[j].NewMeshVertices[0] == Wedge.WedgeVertex)
{
SolveLines.Add(AllInsetLines[j].InsetLines1[0]);
}
else if (Edges[j].NewMeshVertices.Last() == Wedge.WedgeVertex)
{
SolveLines.Add(AllInsetLines[j].InsetLines1.Last());
}
}
// todo: BoundaryVertex case never actually gets here because currently we do not initialize wedges of BoundaryVertex!
bool bIsSimpleBoundary = (Vertex.VertexType == EBevelVertexType::BoundaryVertex && SolveLines.Num() == 1);
if (Vertex.VertexType == EBevelVertexType::TerminatorVertex || bIsSimpleBoundary)
{
// TODO: this ensure has been sporadically hit in Lyra. Needs to be investigated.
//ensure(SolveLines.Num() == 1);
if (SolveLines.Num() == 1)
{
// This will be on the inset edge-line but possibly pulled away from the face the incoming terminating edge is 'hitting'
// It's fine on right-angles but you can see the problem on the front edge of a cube shaped like:
//
// *---*
// *-*
FVector3d InsetLinePosition = SolveLines[0].NearestPoint(CurPos);
Wedge.NewPosition = InsetLinePosition;
// What we ought to do is determine which group topology edges each wedge vertex should 'slide along'.
// However this is a bit complex to figure out and so for the shorter term we are just going to
// do a hack by finding the wedge-mesh-edge most aligned w/ the line inset edge.
// This will obviously fail if there are sliver triangles in the wedge that it can get confused by...
FVector3d BaseInsetDir = Normalized(InsetLinePosition - CurPos);
double MaxDot = -1;
FLine3d MaxDotEdgeLine;
Mesh.EnumerateVertexVertices(Wedge.WedgeVertex, [&](int32 othervid)
{
FLine3d EdgeLine = FLine3d::FromPoints(CurPos, Mesh.GetVertex(othervid));
double DirDot = EdgeLine.Direction.Dot(BaseInsetDir);
if (DirDot > MaxDot )
{
MaxDot = DirDot;
MaxDotEdgeLine = EdgeLine;
}
});
if (MaxDot > -1)
{
FDistLine3Line3d LineIntersection(SolveLines[0], MaxDotEdgeLine);
LineIntersection.Get();
Wedge.NewPosition = LineIntersection.Line2ClosestPoint;
}
Wedge.bHaveNewPosition = true;
}
}
else
{
MESH_BEVEL_DEBUG_CHECK(SolveLines.Num() >= 2);
if (SolveLines.Num() >= 2)
{
Wedge.NewPosition = UE::Geometry::SolveInsetVertexPositionFromLinePair(CurPos, SolveLines[0], SolveLines[1]);
Wedge.bHaveNewPosition = true;
}
}
}
}
auto SetDisplacedPositions = [&GetDisplacedVertexPos](FDynamicMesh3& Mesh, TArray<int32>& VerticesIn, TArray<FVector3d>& PositionsIn, int32 InsetStart, int32 InsetEnd)
{
int32 NumVertices = VerticesIn.Num();
if (PositionsIn.Num() == NumVertices)
{
int32 Stop = NumVertices - InsetEnd;
for (int32 k = InsetStart; k < Stop; ++k)
{
Mesh.SetVertex(VerticesIn[k], PositionsIn[k]);
}
}
};
// now bake in new positions
for (FBevelEdge& Edge : Edges)
{
SetDisplacedPositions(Mesh, Edge.MeshVertices, Edge.NewPositions0, Edge.bEndpointBoundaryFlag[0]?0:1, Edge.bEndpointBoundaryFlag[1]?0:1);
SetDisplacedPositions(Mesh, Edge.NewMeshVertices, Edge.NewPositions1, Edge.bEndpointBoundaryFlag[0]?0:1, Edge.bEndpointBoundaryFlag[1]?0:1);
}
for (FBevelLoop& Loop : Loops)
{
SetDisplacedPositions(Mesh, Loop.MeshVertices, Loop.NewPositions0, 0, 0);
SetDisplacedPositions(Mesh, Loop.NewMeshVertices, Loop.NewPositions1, 0, 0);
}
for (FBevelVertex& Vertex : Vertices)
{
for (FOneRingWedge& Wedge : Vertex.Wedges)
{
if (Wedge.bHaveNewPosition)
{
Mesh.SetVertex(Wedge.WedgeVertex, Wedge.NewPosition);
}
}
}
}
void FMeshBevel::AppendJunctionVertexPolygon(FDynamicMesh3& Mesh, FBevelVertex& Vertex)
{
MESH_BEVEL_DEBUG_CHECK(Vertex.VertexType == EBevelVertexType::JunctionVertex);
// UnlinkJunctionVertex() split the terminator vertex into N vertices, one for each
// (now disconnected) triangle-wedge. The wedges are ordered such that their wedge-vertices
// define a polygon with correct winding, so we can just mesh it and append the triangles
TArray<FVector3d> PolygonPoints;
for (FOneRingWedge& Wedge : Vertex.Wedges)
{
PolygonPoints.Add(Mesh.GetVertex(Wedge.WedgeVertex));
}
TArray<FIndex3i> Triangles;
PolygonTriangulation::TriangulateSimplePolygon<double>(PolygonPoints, Triangles);
Vertex.NewGroupID = Mesh.AllocateTriangleGroup();
for (FIndex3i Tri : Triangles)
{
int32 A = Vertex.Wedges[Tri.A].WedgeVertex;
int32 B = Vertex.Wedges[Tri.B].WedgeVertex;
int32 C = Vertex.Wedges[Tri.C].WedgeVertex;
int32 tid = Mesh.AppendTriangle(A, B, C, Vertex.NewGroupID);
if (Mesh.IsTriangle(tid))
{
Vertex.NewTriangles.Add(tid);
}
}
}
void FMeshBevel::AppendTerminatorVertexTriangle(FDynamicMesh3& Mesh, FBevelVertex& Vertex)
{
MESH_BEVEL_DEBUG_CHECK(Vertex.VertexType == EBevelVertexType::TerminatorVertex);
// UnlinkTerminatorVertex() opened up a triangle-shaped hole adjacent to the incoming edge quad-strip
// at the terminator vertex. The Wedges of the terminator vertex contain the vertex IDs of the two
// verts on the quad-strip edge. We need the third vertex. We stored [SplitEdge, FarVertexID] in
// .TerminatorInfo, however FarVertexID may have become a different vertex when we unlinked other
// vertices. So, we will try to use SplitEdge to find it.
// If this turns out to have problems, basically the QuadEdgeID is on the boundary of a 3-edge hole,
// and so it should be straightforward to find the two other boundary edges and that gives the vertex.
int32 RingSplitEdgeID = Vertex.TerminatorInfo.A;
if (Mesh.IsEdge(RingSplitEdgeID))
{
FIndex2i SplitEdgeV = Mesh.GetEdgeV(RingSplitEdgeID);
int32 FarVertexID = SplitEdgeV.OtherElement(Vertex.VertexID);
int32 QuadEdgeID = Mesh.FindEdge(Vertex.Wedges[0].WedgeVertex, Vertex.Wedges[1].WedgeVertex);
if (Mesh.IsEdge(QuadEdgeID))
{
FIndex2i QuadEdgeV = Mesh.GetOrientedBoundaryEdgeV(QuadEdgeID);
// should have computed this GroupID in initial setup
int32 UseGroupID = (Vertex.NewGroupID >= 0) ? Vertex.NewGroupID : Mesh.AllocateTriangleGroup();
int32 tid = Mesh.AppendTriangle(QuadEdgeV.B, QuadEdgeV.A, FarVertexID, UseGroupID);
if (Mesh.IsTriangle(tid))
{
Vertex.NewTriangles.Add(tid);
}
else
{
MESH_BEVEL_DEBUG_CHECK(false);
}
}
else
{
MESH_BEVEL_DEBUG_CHECK(false);
}
}
}
void FMeshBevel::AppendTerminatorVertexPairQuad(FDynamicMesh3& Mesh, FBevelVertex& Vertex0, FBevelVertex& Vertex1)
{
MESH_BEVEL_DEBUG_CHECK(Vertex0.VertexType == EBevelVertexType::TerminatorVertex);
MESH_BEVEL_DEBUG_CHECK(Vertex1.VertexType == EBevelVertexType::TerminatorVertex);
// This is a variant of AppendTerminatorVertexTriangle that handles the case where basically two
// Terminator Vertices are directly connected by a non-beveled mesh edge that was used as the ring-split-edge.
// Since both sides were opened, we have a quad-shaped hole instead of a triangle-shaped hole, with a quad-edge
// at each end. The quad can be filled directly, we just need to sort out ordering/etc
// does not seem like we need to do anything w/ the TerminatorInfo here, we can get everything from wedges
int32 QuadEdgeID0 = Mesh.FindEdge(Vertex0.Wedges[0].WedgeVertex, Vertex0.Wedges[1].WedgeVertex);
int32 QuadEdgeID1 = Mesh.FindEdge(Vertex1.Wedges[0].WedgeVertex, Vertex1.Wedges[1].WedgeVertex);
MESH_BEVEL_DEBUG_CHECK(Mesh.IsEdge(QuadEdgeID0) && Mesh.IsEdge(QuadEdgeID1));
FIndex2i QuadEdgeV0 = Mesh.GetOrientedBoundaryEdgeV(QuadEdgeID0);
FIndex2i QuadEdgeV1 = Mesh.GetOrientedBoundaryEdgeV(QuadEdgeID1);
// make sure that the two opposing/connecting edges exist
MESH_BEVEL_DEBUG_CHECK(
Mesh.FindEdge(QuadEdgeV0.A, QuadEdgeV1.B) != IndexConstants::InvalidID &&
Mesh.FindEdge(QuadEdgeV0.B, QuadEdgeV1.A) != IndexConstants::InvalidID);
// BIASED? should have computed this GroupID in initial setup
int32 UseGroupID = (Vertex0.NewGroupID >= 0) ? Vertex0.NewGroupID : Mesh.AllocateTriangleGroup();
// quad order is V0.B, V0.A, V1.B, V1.A
int32 tid0 = Mesh.AppendTriangle(QuadEdgeV0.B, QuadEdgeV0.A, QuadEdgeV1.B, UseGroupID);
MESH_BEVEL_DEBUG_CHECK(tid0 >= 0);
if (Mesh.IsTriangle(tid0))
{
Vertex0.NewTriangles.Add(tid0);
}
int32 tid1 = Mesh.AppendTriangle(QuadEdgeV0.B, QuadEdgeV1.B, QuadEdgeV1.A, UseGroupID);
MESH_BEVEL_DEBUG_CHECK(tid1 >= 0);
if (Mesh.IsTriangle(tid1))
{
Vertex1.NewTriangles.Add(tid1);
}
}
void FMeshBevel::AppendEdgeQuads(FDynamicMesh3& Mesh, FBevelEdge& Edge)
{
int32 NumEdges = Edge.MeshEdges.Num();
if (NumEdges != Edge.NewMeshEdges.Num())
{
return;
}
Edge.NewGroupID = Mesh.AllocateTriangleGroup();
// At this point each edge-span should be fully disconnected into a set of paired edges,
// so we can trivially join each edge pair with a quad.
for (int32 k = 0; k < NumEdges; ++k)
{
int32 EdgeID0 = Edge.MeshEdges[k];
int32 EdgeID1 = Edge.NewMeshEdges[k];
// in certain cases, like bevel topo-edges with a single mesh-edge, we would not
// have been able to construct the "other" mesh edge when processing the topo-edge
// (where .NewMeshEdges is computed), it would only have been created when processing the
// junction vertex. Currently we do not go back and update .NewMeshEdges in that case, but
// we do store the edge-pair-correspondence in the MeshEdgePairs map.
if (EdgeID0 == EdgeID1)
{
int32* FoundEdgeID1 = MeshEdgePairs.Find(EdgeID0);
if (FoundEdgeID1 != nullptr)
{
EdgeID1 = *FoundEdgeID1;
}
}
FIndex2i QuadTris(IndexConstants::InvalidID, IndexConstants::InvalidID);
if (EdgeID0 != EdgeID1 && Mesh.IsEdge(EdgeID1) )
{
FIndex2i EdgeV0 = Mesh.GetOrientedBoundaryEdgeV(EdgeID0);
FIndex2i EdgeV1 = Mesh.GetOrientedBoundaryEdgeV(EdgeID1);
if (EdgeV0.Contains(EdgeV1.A) || EdgeV0.Contains(EdgeV1.B))
{
// If we hit this case, it means that Edge0 and Edge1 are still connected at one end, and
// so cannot be connected by a Quad, they can only be connected by a single triangle.
// It is unclear how we end up in this situation, it does occur somewhat regularly in complex
// geometry scripts though (eg see UE-157531 for a potential repro).
int32 OtherV = EdgeV0.Contains(EdgeV1.A) ? EdgeV1.B : EdgeV1.A;
QuadTris.A = Mesh.AppendTriangle(EdgeV0.B, EdgeV0.A, OtherV, Edge.NewGroupID);
QuadTris.B = IndexConstants::InvalidID;
}
else
{
QuadTris.A = Mesh.AppendTriangle(EdgeV0.B, EdgeV0.A, EdgeV1.B, Edge.NewGroupID);
QuadTris.B = Mesh.AppendTriangle(EdgeV1.B, EdgeV1.A, EdgeV0.B, Edge.NewGroupID);
}
}
Edge.StripQuads.Add(QuadTris);
}
}
void FMeshBevel::AppendLoopQuads(FDynamicMesh3& Mesh, FBevelLoop& Loop)
{
int32 NumEdges = Loop.MeshEdges.Num();
if (NumEdges != Loop.NewMeshEdges.Num())
{
return;
}
auto GetGroupKey = [&Mesh, &Loop](int32 k)
{
FIndex2i EdgeTris = Loop.MeshEdgeTris[k];
int32 Group0 = Mesh.GetTriangleGroup(EdgeTris.A);
int32 Group1 = Mesh.IsTriangle(EdgeTris.B) ? Mesh.GetTriangleGroup(EdgeTris.B) : -1;
return FIndex2i(FMath::Max(Group0, Group1), FMath::Min(Group0, Group1));
};
TMap<FIndex2i, int> NewGroupIDs;
for (int32 k = 0; k < NumEdges; ++k)
{
FIndex2i GroupKey = GetGroupKey(k);
if (NewGroupIDs.Contains(GroupKey) == false)
{
NewGroupIDs.Add(GroupKey, Mesh.AllocateTriangleGroup());
Loop.NewGroupIDs.Add(NewGroupIDs[GroupKey]);
}
}
// At this point each edge-span should be fully disconnected into a set of paired edges,
// so we can trivially join each edge pair with a quad.
for (int32 k = 0; k < NumEdges; ++k)
{
int32 EdgeID0 = Loop.MeshEdges[k];
int32 EdgeID1 = Loop.NewMeshEdges[k];
// case that happens in AppendEdgeQuads() should never happen for loops...
FIndex2i QuadTris(IndexConstants::InvalidID, IndexConstants::InvalidID);
if (EdgeID0 != EdgeID1 && Mesh.IsEdge(EdgeID1))
{
FIndex2i GroupKey = GetGroupKey(k);
int32 NewGroupID = NewGroupIDs[GroupKey];
FIndex2i EdgeV0 = Mesh.GetOrientedBoundaryEdgeV(EdgeID0);
FIndex2i EdgeV1 = Mesh.GetOrientedBoundaryEdgeV(EdgeID1);
QuadTris.A = Mesh.AppendTriangle(EdgeV0.B, EdgeV0.A, EdgeV1.B, NewGroupID);
QuadTris.B = Mesh.AppendTriangle(EdgeV1.B, EdgeV1.A, EdgeV0.B, NewGroupID);
}
Loop.StripQuads.Add(QuadTris);
}
}
void FMeshBevel::CreateBevelMeshing(FDynamicMesh3& Mesh)
{
for (FBevelVertex& Vertex : Vertices)
{
if (Vertex.VertexType == EBevelVertexType::JunctionVertex)
{
if (Vertex.Wedges.Num() > 2)
{
AppendJunctionVertexPolygon(Mesh, Vertex);
}
}
}
for (FBevelEdge& Edge : Edges)
{
AppendEdgeQuads(Mesh, Edge);
}
for (FBevelLoop& Loop : Loops)
{
AppendLoopQuads(Mesh, Loop);
}
// easier to do terminators last so that we can use quad edge to orient the triangle
TSet<FIndex2i> HandledQuadVtxPairs;
for (FBevelVertex& Vertex : Vertices)
{
if (Vertex.VertexType == EBevelVertexType::TerminatorVertex)
{
if (Vertex.ConnectedBevelVertex >= 0)
{
FBevelVertex& OtherVertex = Vertices[Vertex.ConnectedBevelVertex];
FIndex2i VtxPair(Vertex.VertexID, OtherVertex.VertexID);
VtxPair.Sort();
if (HandledQuadVtxPairs.Contains(VtxPair) == false)
{
AppendTerminatorVertexPairQuad(Mesh, Vertex, OtherVertex);
HandledQuadVtxPairs.Add(VtxPair);
}
}
else
{
AppendTerminatorVertexTriangle(Mesh, Vertex);
}
}
}
}
void FMeshBevel::AppendEdgeQuads_Multi(FDynamicMesh3& Mesh, FBevelEdge& Edge)
{
int32 NumEdges = Edge.MeshEdges.Num();
if (NumEdges != Edge.NewMeshEdges.Num())
{
return;
}
Edge.NewGroupID = Mesh.AllocateTriangleGroup();
struct FEdgePair
{
FIndex2i EdgeV0;
FIndex2i EdgeV1;
};
TArray<FEdgePair> SequentialQuadEdges;
bool bFoundInvalidCase = false;
// At this point each edge-span should be fully disconnected into a set of paired edges,
// so we can trivially join each edge pair with a quad. (In the multi-case we will further
// subdivide this quad instead of adding it directly)
for (int32 k = 0; k < NumEdges && bFoundInvalidCase == false; ++k)
{
int32 EdgeID0 = Edge.MeshEdges[k];
int32 EdgeID1 = Edge.NewMeshEdges[k];
// in certain cases, like bevel topo-edges with a single mesh-edge, we would not
// have been able to construct the "other" mesh edge when processing the topo-edge
// (where .NewMeshEdges is computed), it would only have been created when processing the
// junction vertex. Currently we do not go back and update .NewMeshEdges in that case, but
// we do store the edge-pair-correspondence in the MeshEdgePairs map.
if (EdgeID0 == EdgeID1)
{
int32* FoundEdgeID1 = MeshEdgePairs.Find(EdgeID0);
if (FoundEdgeID1 != nullptr)
{
EdgeID1 = *FoundEdgeID1;
}
}
if (EdgeID0 != EdgeID1 && Mesh.IsEdge(EdgeID1))
{
FIndex2i EdgeV0 = Mesh.GetOrientedBoundaryEdgeV(EdgeID0);
FIndex2i EdgeV1 = Mesh.GetOrientedBoundaryEdgeV(EdgeID1);
if (EdgeV0.Contains(EdgeV1.A) || EdgeV0.Contains(EdgeV1.B))
{
// If we hit this case, it means that Edge0 and Edge1 are still connected at one end, and
// so cannot be connected by a Quad, they can only be connected by a single triangle.
// It is unclear how we end up in this situation, it does occur somewhat regularly in complex
// geometry scripts though (eg see UE-157531 for a potential repro).
// In this case we cannot add subdivisions currently, and will fall back to simpler geometry
bFoundInvalidCase = true;
}
else
{
SequentialQuadEdges.Add({ EdgeV0, EdgeV1 });
}
}
else
{
bFoundInvalidCase = true;
}
}
// if something went wrong above, fall back to adding a single quad to avoid holes/etc
// (it's possible that this path may still result in catastrophic failure...)
if (bFoundInvalidCase || SequentialQuadEdges.Num() != NumEdges)
{
AppendEdgeQuads(Mesh, Edge);
return;
}
// all the code below is going to generate the bevel edge geometry and populate this list of
// vertex-rows, which will be used to assemble the final FQuadGridPatch for the bevel edge-strip
int32 N = NumSubdivisions;
TArray<TArray<int32>> VertexSpans;
VertexSpans.SetNum(N + 2);
// this function appends a new column to the rows in VertexSpans, by generating new
// vertices on the interior of the edge between StartVID and EndVID
auto AppendNewVertColumn = [&Mesh, &VertexSpans, N](int32 StartVID, int32 EndVID)
{
FVector3d StartPos = Mesh.GetVertex(StartVID);
FVector3d EndPos = Mesh.GetVertex(EndVID);
VertexSpans[0].Add(StartVID);
for (int32 j = 0; j < N; ++j)
{
double T = (double)(j+1) / (double)(N + 1);
int32 NewVertID = Mesh.AppendVertex(Lerp(StartPos, EndPos, T));
VertexSpans[j+1].Add(NewVertID);
}
VertexSpans[N+1].Add(EndVID);
};
// this function appends a new column to the rows in VertexSpans by copying
// the column from an existing adjacent FQuadGridPatch. This happens if we are
// meshing a bevel-edge that is connected to another bevel-edge that was already
// generated, and the connecting bevel-vertex only has 2 bevel-edges (ie no polygon will be inserted)
auto AppendExistingVertColumn = [&VertexSpans, N](const FQuadGridPatch* AdjacentQuadPatch, int32 CornerVertexID) -> bool
{
int32 ColumnIdx = AdjacentQuadPatch->FindColumnIndex(CornerVertexID);
if (ColumnIdx >= 0)
{
TArray<int32> ColumnVerts;
AdjacentQuadPatch->GetVertexColumn(ColumnIdx, ColumnVerts);
// Our column should start w/ CornerVertexID, but it may be reversed due to different orientations when building the adjacent patch...
// (could that be fixed further upstream? possibly it should be!)
if (ColumnVerts.Last() == CornerVertexID)
{
Algo::Reverse(ColumnVerts);
}
for (int32 j = 0; j <= (N + 1); ++j)
{
VertexSpans[j].Add(ColumnVerts[j]);
}
return true;
}
return false;
};
// start and end vertex columns may already exist in some other FBevelEdge that has already been generated.
// In that case, instead of appending new vertices, we want to look up the existing vertices and stitch to them.
// This case only happens for BevelVertices connected to exactly 2 BevelEdges (<2 => Terminator, >2 => Polygon at vertex).
auto GetConnectedQuadStripRef = [this](int BevelVertexIdx, int CurBevelEdgeIdx)
{
if (BevelVertexIdx == -1) return (const FQuadGridPatch*)nullptr;
const FBevelVertex& Vtx = Vertices[BevelVertexIdx];
if (Vtx.VertexType != EBevelVertexType::JunctionVertex || Vtx.Wedges.Num() != 2) return (const FQuadGridPatch*)nullptr;
for (int EdgeIdx : Vtx.IncomingBevelEdgeIndices)
{
if (EdgeIdx != CurBevelEdgeIdx)
{
const FBevelEdge& OtherEdge = Edges[EdgeIdx];
if (OtherEdge.StripQuadPatch.IsEmpty() == false)
{
return (const FQuadGridPatch*)&OtherEdge.StripQuadPatch;
}
return (const FQuadGridPatch*)nullptr;
}
}
return (const FQuadGridPatch*)nullptr;
};
// Below code expects SequentialQuadEdges to be ordered s.t. for edges spanning
// vertices 0,1,2 the edges should be (1,0),(2,1) not (0,1),(1,2) ...
// We enforce this by reversing the array if needed
if (SequentialQuadEdges.Num() > 1 && SequentialQuadEdges[0].EdgeV0.B == SequentialQuadEdges[1].EdgeV0.A)
{
Algo::Reverse(SequentialQuadEdges);
}
// SequentialQuadEdges ordering may not be in agreement with the [BevelVertices.A, BevelVertices.B]
// ordering of the BevelEdge. If so, then the Prev/Next QuadGridPatch
// search below would return the Prev & Next flipped from where we need them, causing the later AppendExistingVertColumn
// to fail. The simplest fix for this here is to swap PrevQuadPatch/NextQuadPatch...
int OriginalPrevVtxID = (Edge.BevelVertices.A >= 0) ? Vertices[Edge.BevelVertices.A].VertexID : -1;
int OriginalNextVtxID = (Edge.BevelVertices.B >= 0) ? Vertices[Edge.BevelVertices.B].VertexID : -1;
FIndex2i EdgeStartQuadVerts(SequentialQuadEdges[0].EdgeV0.B, SequentialQuadEdges[0].EdgeV1.A);
FIndex2i EdgeEndQuadVerts(SequentialQuadEdges[NumEdges-1].EdgeV0.A, SequentialQuadEdges[NumEdges-1].EdgeV1.B);
FIndex2i BevelEdgeVerts(Edge.BevelVertices.A, Edge.BevelVertices.B);
if (EdgeStartQuadVerts.Contains(OriginalNextVtxID) || EdgeEndQuadVerts.Contains(OriginalPrevVtxID))
{
Swap(BevelEdgeVerts.A, BevelEdgeVerts.B);
}
// find quadgrid patches connected to start and end of current bevel edge, if the yexist
const FQuadGridPatch* PrevQuadPatch = GetConnectedQuadStripRef(BevelEdgeVerts.A, Edge.EdgeIndex);
const FQuadGridPatch* NextQuadPatch = GetConnectedQuadStripRef(BevelEdgeVerts.B, Edge.EdgeIndex);
// now add columns of vertices for each inital vertex along the bevel-edge (by iterating along mesh-edges)
for (int32 k = 0; k < NumEdges; ++k)
{
FIndex2i EdgeV0 = SequentialQuadEdges[k].EdgeV0;
FIndex2i EdgeV1 = SequentialQuadEdges[k].EdgeV1;
int32 QuadA = EdgeV0.B;
int32 QuadB = EdgeV0.A;
int32 QuadC = EdgeV1.B;
int32 QuadD = EdgeV1.A;
// for first and last edges, we have to add an extra row of vertices
if (k == 0)
{
if (PrevQuadPatch == nullptr || AppendExistingVertColumn(PrevQuadPatch, QuadA) == false)
{
AppendNewVertColumn(QuadA, QuadD);
}
}
if (k != NumEdges-1 || NextQuadPatch == nullptr || AppendExistingVertColumn(NextQuadPatch, QuadB) == false)
{
AppendNewVertColumn(QuadB, QuadC);
}
}
// now append the quads that connect up the vertices
TArray<TArray<FIndex2i>> QuadSpans;
QuadSpans.SetNum(N + 1);
int32 NumStrips = VertexSpans.Num() - 1;
for (int32 k = 0; k < NumEdges; ++k)
{
for ( int32 j = 0; j < NumStrips; ++j)
{
FIndex2i QuadTris(IndexConstants::InvalidID, IndexConstants::InvalidID);
QuadTris.A = Mesh.AppendTriangle(VertexSpans[j][k], VertexSpans[j][k+1], VertexSpans[j+1][k], Edge.NewGroupID);
QuadTris.B = Mesh.AppendTriangle(VertexSpans[j+1][k+1], VertexSpans[j+1][k], VertexSpans[j][k+1], Edge.NewGroupID);
QuadSpans[j].Add(QuadTris);
Edge.StripQuads.Add(QuadTris);
}
}
// finally save the quad-patch we generated in the FBevelEdge
Edge.StripQuadPatch.InitializeFromQuadPatch(Mesh, QuadSpans, VertexSpans);
}
void FMeshBevel::AppendLoopQuads_Multi(FDynamicMesh3& Mesh, FBevelLoop& Loop)
{
// As in other places, the Loop case is a simplified version of the Edge case, where
// many special cases do not have to be handled. See the comments in
// AppendEdgeQuads_Multi() for anything non-obvious below
int32 NumEdges = Loop.MeshEdges.Num();
if (NumEdges != Loop.NewMeshEdges.Num())
{
return;
}
auto GetGroupKey = [&Mesh, &Loop](int32 k)
{
FIndex2i EdgeTris = Loop.MeshEdgeTris[k];
int32 Group0 = Mesh.GetTriangleGroup(EdgeTris.A);
int32 Group1 = Mesh.IsTriangle(EdgeTris.B) ? Mesh.GetTriangleGroup(EdgeTris.B) : -1;
return FIndex2i(FMath::Max(Group0, Group1), FMath::Min(Group0, Group1));
};
TMap<FIndex2i, int> NewGroupIDs;
for (int32 k = 0; k < NumEdges; ++k)
{
FIndex2i GroupKey = GetGroupKey(k);
if (NewGroupIDs.Contains(GroupKey) == false)
{
NewGroupIDs.Add(GroupKey, Mesh.AllocateTriangleGroup());
Loop.NewGroupIDs.Add(NewGroupIDs[GroupKey]);
}
}
struct FEdgePair
{
FIndex2i EdgeV0;
FIndex2i EdgeV1;
};
TArray<FEdgePair> SequentialQuadEdges;
bool bFoundInvalidCase = false;
// At this point each edge-span should be fully disconnected into a set of paired edges,
// so we can trivially join each edge pair with a quad.
for (int32 k = 0; k < NumEdges && bFoundInvalidCase == false; ++k)
{
int32 EdgeID0 = Loop.MeshEdges[k];
int32 EdgeID1 = Loop.NewMeshEdges[k];
// case that happens in AppendEdgeQuads() should never happen for loops...
FIndex2i QuadTris(IndexConstants::InvalidID, IndexConstants::InvalidID);
if (EdgeID0 != EdgeID1 && Mesh.IsEdge(EdgeID1))
{
FIndex2i GroupKey = GetGroupKey(k);
int32 NewGroupID = NewGroupIDs[GroupKey];
FIndex2i EdgeV0 = Mesh.GetOrientedBoundaryEdgeV(EdgeID0);
FIndex2i EdgeV1 = Mesh.GetOrientedBoundaryEdgeV(EdgeID1);
SequentialQuadEdges.Add({ EdgeV0, EdgeV1 });
}
else
{
bFoundInvalidCase = true;
}
}
if (bFoundInvalidCase || SequentialQuadEdges.Num() != NumEdges)
{
AppendLoopQuads(Mesh, Loop);
return;
}
// Test the edge ordering -- i.e. for vertices 0,1,2, if bEdgeHasReverseOrder == true,
// edge vertices will be (0,1),(1,2); otherwise it will be (1,0),(2,1)
bool bEdgeHasReverseOrder = (SequentialQuadEdges.Num() > 1 && SequentialQuadEdges[0].EdgeV0.B == SequentialQuadEdges[1].EdgeV0.A);
int32 N = NumSubdivisions;
TArray<TArray<int32>> VertexSpans;
VertexSpans.SetNum(N + 2);
auto AppendVertColumn = [&Mesh, &VertexSpans, &N](int32 StartVID, int32 EndVID)
{
FVector3d StartPos = Mesh.GetVertex(StartVID);
FVector3d EndPos = Mesh.GetVertex(EndVID);
VertexSpans[0].Add(StartVID);
for (int32 j = 0; j < N; ++j)
{
double T = (double)(j + 1) / (double)(N + 1);
int32 NewVertID = Mesh.AppendVertex(Lerp(StartPos, EndPos, T));
VertexSpans[j + 1].Add(NewVertID);
}
VertexSpans[N + 1].Add(EndVID);
};
for (int32 k = 0; k < NumEdges; ++k)
{
FIndex2i EdgeV0 = SequentialQuadEdges[k].EdgeV0;
FIndex2i EdgeV1 = SequentialQuadEdges[k].EdgeV1;
if (bEdgeHasReverseOrder)
{
EdgeV0.Swap();
EdgeV1.Swap();
}
int32 QuadA = EdgeV0.B;
int32 QuadB = EdgeV0.A;
int32 QuadC = EdgeV1.B;
int32 QuadD = EdgeV1.A;
if (k == 0)
{
AppendVertColumn(QuadA, QuadD);
}
if (k != NumEdges - 1)
{
AppendVertColumn(QuadB, QuadC);
}
else
{
for (int32 j = 0; j <= (N+1); ++j)
{
int FirstColVal = VertexSpans[j][0];
VertexSpans[j].Add(FirstColVal);
}
}
}
TArray<TArray<FIndex2i>> QuadSpans;
QuadSpans.SetNum(N + 1);
// Offsets for flipping triangles in cases where the edges had the opposite ordering from our expectation
int32 SwapOffset0 = (int32)(bEdgeHasReverseOrder);
int32 SwapOffset1 = (int32)(!bEdgeHasReverseOrder);
int32 NumStrips = VertexSpans.Num() - 1;
for (int32 k = 0; k < NumEdges; ++k)
{
FIndex2i GroupKey = GetGroupKey(k);
int32 NewGroupID = NewGroupIDs[GroupKey];
for (int32 j = 0; j < NumStrips; ++j)
{
FIndex2i QuadTris(IndexConstants::InvalidID, IndexConstants::InvalidID);
QuadTris.A = Mesh.AppendTriangle(VertexSpans[j][k + SwapOffset0], VertexSpans[j][k + SwapOffset1], VertexSpans[j+1][k], NewGroupID);
QuadTris.B = Mesh.AppendTriangle(VertexSpans[j+1][k + SwapOffset1], VertexSpans[j+1][k + SwapOffset0], VertexSpans[j][k+1], NewGroupID);
QuadSpans[j].Add(QuadTris);
Loop.StripQuads.Add(QuadTris);
}
}
Loop.StripQuadPatch.InitializeFromQuadPatch(Mesh, QuadSpans, VertexSpans);
}
void FMeshBevel::AppendJunctionVertexPolygon_Multi(FDynamicMesh3& Mesh, FBevelVertex& Vertex)
{
// This function appends triangulations for junction vertices, ie where 3+ bevel-edges meet and
// so a polygonal face must be inserted. For a multi-segment bevel, we need to tessellate the
// polygon with interior vertices so that the interior vertices can be displaced later based
// on the bevel profile shape. And this is also where we will precompute certain information about
// the interior vertices, like (eg) barycentric coords of interior vertices, so that we can later
// deform them relative to the profile shapes on the boundary.
//
// This is probably the most complex part of doing the bevel, and there are special cases for
// valence-3 and valence-4, with lots of similar-but-slightly-different code.
MESH_BEVEL_DEBUG_CHECK(Vertex.VertexType == EBevelVertexType::JunctionVertex);
// TODO: all the setup here could be done in parallel, which might matter given that
// we are doing a tessellation, conformal unwrap, etc. Would need to cache temporary data.
// Junction vertices can never be directly connected so there should not be any order effects.
// UnlinkJunctionVertex() split the junction vertex into N vertices, one for each
// (now disconnected) triangle-wedge. The wedges are ordered such that their wedge-vertices
// define a polygon with correct winding. However in this case we have additional interior
// vertices along the polygon edges. So we need to construct a mesh for the junction vertex
// that has a compatible boundary and (in most cases) additional interior vertices, which
// is done in this function via a regular tessellation of the polygon
int32 NumEdgeVerts = 0; // this should be determined by NumSubdivisions but we will compute from actual mesh here
bool bAllEdgesHaveSameNumVerts = true; // current code only handles the case where all edges have same # of subdivisions.
// First step is to find the loop of vertices around the border of the junction vertex.
// Each incoming source-mesh edge became a "wedge", with start vertex A and end B, and
// then a quad-patch was appended connecting A to B. So we need to get the right "column"
// of the quad patch, which will give us the vertex span [A, ..., B]. These are accumulated
// in-wedge-sequence into PolygonPoints/Vertices. The start/end vertices A and B are accumulated
// in-order in the PolygonCorners/Indices/VIDs lists.
// (In both sets, the 'B' vertex is always skipped because it will be added as A in the next span)
TArray<FVector3d> PolygonPoints, PolygonCorners;
TArray<int32> PolygonVertices, PolygonCornerVIDs;
int32 NumWedges = Vertex.Wedges.Num();
for (int32 wi = 0; wi < NumWedges; ++wi)
{
FOneRingWedge& CurWedge = Vertex.Wedges[wi];
FOneRingWedge& NextWedge = Vertex.Wedges[(wi+1)%NumWedges];
int32 A = CurWedge.WedgeVertex;
int32 B = NextWedge.WedgeVertex;
// We don't know which Edge will contain the [A,B] vertices, and whether it is the 'start'
// or 'end' of the Edge. So currently just linear searching through all of them and checking
// each end. Maybe Vertex.IncomingBevelEdgeIndices would work here instead
TArray<int32> BevelEdgeQuadStripEndVertices;
bool bFound = false;
for (FBevelEdge& Span : Edges)
{
// this helper appends the vertex-column of an adjacent edge-quadstrip to the current vertex polygon loop
auto AppendStrip = [&](TArray<int32>& OrderedVertices)
{
PolygonCorners.Add(Mesh.GetVertex(OrderedVertices[0]));
PolygonCornerVIDs.Add(OrderedVertices[0]);
for (int32 j = 0; j < OrderedVertices.Num()-1; ++j)
{
int32 VertexID = OrderedVertices[j];
PolygonVertices.Add(VertexID);
PolygonPoints.Add(Mesh.GetVertex(VertexID));
}
if (NumEdgeVerts == 0)
{
NumEdgeVerts = OrderedVertices.Num();
}
else if (OrderedVertices.Num() != NumEdgeVerts)
{
bAllEdgesHaveSameNumVerts = false;
}
bFound = true;
};
if (Span.StripQuadPatch.VertexSpans.IsEmpty())
{
// The no-vertex-span case can happen for cases where the smooth bevel has failed and fallen back to non-smooth bevel
continue;
}
// try start and end columns, and handle case where vertex ordering might be reversed (should this be possible, because of consistent mesh winding??)
Span.StripQuadPatch.GetVertexColumn(0, BevelEdgeQuadStripEndVertices);
if (BevelEdgeQuadStripEndVertices[0] == A && BevelEdgeQuadStripEndVertices.Last() == B)
{
AppendStrip(BevelEdgeQuadStripEndVertices);
break;
}
if (BevelEdgeQuadStripEndVertices[0] == B && BevelEdgeQuadStripEndVertices.Last() == A)
{
Algo::Reverse(BevelEdgeQuadStripEndVertices);
AppendStrip(BevelEdgeQuadStripEndVertices);
break;
}
Span.StripQuadPatch.GetVertexColumn(Span.StripQuadPatch.NumVertexCols() - 1, BevelEdgeQuadStripEndVertices);
if (BevelEdgeQuadStripEndVertices[0] == A && BevelEdgeQuadStripEndVertices.Last() == B)
{
AppendStrip(BevelEdgeQuadStripEndVertices);
break;
}
if (BevelEdgeQuadStripEndVertices[0] == B && BevelEdgeQuadStripEndVertices.Last() == A)
{
Algo::Reverse(BevelEdgeQuadStripEndVertices);
AppendStrip(BevelEdgeQuadStripEndVertices);
break;
}
}
if (!bFound)
{
PolygonVertices.Add(CurWedge.WedgeVertex);
PolygonPoints.Add(Mesh.GetVertex(CurWedge.WedgeVertex));
bAllEdgesHaveSameNumVerts = false;
}
}
// code below won't work unless each edge has same vert count, in that case just triangulate the polygon (ie fail)
if (bAllEdgesHaveSameNumVerts == false || NumEdgeVerts == 0)
{
TArray<FIndex3i> Triangles;
PolygonTriangulation::TriangulateSimplePolygon<double>(PolygonPoints, Triangles);
Vertex.NewGroupID = Mesh.AllocateTriangleGroup();
for (FIndex3i Tri : Triangles)
{
int32 tid = Mesh.AppendTriangle(PolygonVertices[Tri.A], PolygonVertices[Tri.B], PolygonVertices[Tri.C], Vertex.NewGroupID);
if (Mesh.IsTriangle(tid))
{
Vertex.NewTriangles.Add(tid);
}
}
return;
}
// find centroid of polygon
FVector3d Centroid = FVector3d::Zero();
for (FVector3d Pos : PolygonPoints)
{
Centroid += Pos;
}
Centroid /= (double)PolygonPoints.Num();
// Now we have enough information to tessellate and fill the hole.
// Apologies for the convoluted code here. The general case was implemented
// first, and then the 3/4 special-cases were added. Probably they should
// be refactored out into 3 separate functions. Sorry! -rms
// Append corners of the polygon into a temporary mesh, and then triangles
// For the case of > 4 vertices, add the centroid and triangulate as a fan
FDynamicMesh3 TmpMesh;
int32 NCorners = PolygonCorners.Num();
for (int32 k = 0; k < NCorners; ++k)
{
int NewVID = TmpMesh.AppendVertex(PolygonCorners[k]);
ensure(NewVID == k);
}
if (NCorners == 3) // single triangle
{
TmpMesh.AppendTriangle(0, 1, 2);
}
else if (NCorners == 4) // quad
{
TmpMesh.AppendTriangle(0, 1, 2);
TmpMesh.AppendTriangle(2, 3, 0);
}
else // make triangle fan
{
int32 CentroidID = TmpMesh.AppendVertex(Centroid);
for (int32 i = 0; i < NCorners; ++i)
{
int NewTID = TmpMesh.AppendTriangle(i, ((i + 1) % NCorners), CentroidID);
}
}
// Ok, for the case of a triangle, we will use barycentric coordinates of the initial
// triangle rather than trying to do general polygon barycentrics. To avoid writing custom
// triangle-tess code here, FUniformTessellate is still used, but it doesn't return the barycentrics.
// So instead we store the 3 vertex-coordinate-functions in vertex colors and allow them to be lerp'd
if (NCorners == 3)
{
// note that this construction of TriTess will be the same for every valence-3 corner, and
// probably should be cached unless NumEdgeVerts changes...
FDynamicMesh3 TriTess;
TriTess = TmpMesh;
TriTess.SetVertex(0, FVector3d(1, 0, 0));
TriTess.SetVertex(1, FVector3d(0, 1, 0));
TriTess.SetVertex(2, FVector3d(0.5, 0.75, 0));
TriTess.EnableVertexColors(FVector3f::Zero());
TriTess.SetVertexColor(0, FVector3f(1, 0, 0));
TriTess.SetVertexColor(1, FVector3f(0, 1, 0));
TriTess.SetVertexColor(2, FVector3f(0, 0, 1));
FUniformTessellate Tesselator(&TriTess);
Tesselator.TessellationNum = NumEdgeVerts - 2;
bool bTesselateOK = Tesselator.Compute();
checkSlow(bTesselateOK);
// need mapping between the boundary of this tessellated mesh and the triangle-shaped polygon
// surrounding the hole in the original mesh. Derive this from the known correspondence
// between the first vertex in each
FMeshBoundaryLoops BoundaryLoops(&TriTess, true);
TArray<int32> TriLoopVerts = BoundaryLoops.Loops[0].Vertices;
int32 LoopN = TriLoopVerts.Num();
checkSlow(PolygonVertices[0] == PolygonCornerVIDs[0]);
checkSlow(PolygonVertices.Num() == LoopN);
int32 StartIndex = TriLoopVerts.IndexOfByKey(0); // index of first vertex in loop
TArray<int32> TriTessVertIDToPolygonIndexMap;
TriTessVertIDToPolygonIndexMap.SetNum(TriTess.MaxVertexID());
for (int32 k = 0; k < LoopN; ++k)
{
int32 LoopVertID = TriLoopVerts[(k + StartIndex) % LoopN];
TriTessVertIDToPolygonIndexMap[LoopVertID] = k;
}
FVector3d PosA = TmpMesh.GetVertex(0);
FVector3d PosB = TmpMesh.GetVertex(1);
FVector3d PosC = TmpMesh.GetVertex(2);
// for this special case we only store the 3 corners in the InteriorBorderLoop, this will be detected in
// the profile code and used correctly there
Vertex.InteriorVertices.Reserve(FMath::Max((NumEdgeVerts-1)*(NumEdgeVerts-1), 0)); // this is for quad so it's more than needed...
Vertex.InteriorBorderLoop = TArray<int32>({ PolygonCornerVIDs[0], PolygonCornerVIDs[1], PolygonCornerVIDs[2] });
TArray<int32> VertexMap;
VertexMap.SetNum(TriTess.MaxVertexID());
// Append the new interior vertices, boundary vertices already exist and are just updated in the map.
// For interior vertices the barycentric coords are stored in the BorderFrameWeights
for (int32 vid : TriTess.VertexIndicesItr())
{
if (TriTess.IsBoundaryVertex(vid))
{
int32 LoopIndex = TriTessVertIDToPolygonIndexMap[vid];
int32 ExistingVertID = PolygonVertices[LoopIndex];
VertexMap[vid] = ExistingVertID;
}
else
{
FVector3f BaryCoords = TriTess.GetVertexColor(vid);
BaryCoords /= (BaryCoords.X + BaryCoords.Y + BaryCoords.Z);
FVector3d InterpPos = BaryCoords.X * PosA + BaryCoords.Y * PosB + BaryCoords.Z * PosC;
int32 NewVID = Mesh.AppendVertex(InterpPos);
FBevelVertex_InteriorVertex& InteriorVertex = Vertex.InteriorVertices.Emplace_GetRef();
InteriorVertex.VertexID = NewVID;
InteriorVertex.BorderFrameWeight.Add(FVector3d(BaryCoords.X, BaryCoords.Y, BaryCoords.Z));
VertexMap[vid] = NewVID;
}
}
// finally append the triangles
TArray<FIndex3i> Triangles;
Vertex.NewGroupID = Mesh.AllocateTriangleGroup();
for (FIndex3i Triangle : TriTess.TrianglesItr())
{
// NOTE FLIP HERE! This is because outer loop is oriented for outside tris, so we need to flip
int T0 = Mesh.AppendTriangle(VertexMap[Triangle.A], VertexMap[Triangle.C], VertexMap[Triangle.B], Vertex.NewGroupID);
if (Mesh.IsTriangle(T0))
{
Vertex.NewTriangles.Add(T0);
}
}
// we are done the valnce=3 case, exit this function
return;
}
// For a quad, the tessellation is simple and is just done directly here
if (NCorners == 4)
{
FDenseGrid2i VertexGrid;
VertexGrid.Resize(NumEdgeVerts, NumEdgeVerts);
VertexGrid.AssignAll(-1);
// transfer vertex polygon into border of grid
int32 PolygonIdx = 0;
for (int32 xi = 0; xi < NumEdgeVerts; ++xi)
{
VertexGrid.At(xi,0) = PolygonVertices[PolygonIdx++];
}
for ( int32 yi = 1; yi < NumEdgeVerts-1; ++yi )
{
VertexGrid.At(NumEdgeVerts-1, yi) = PolygonVertices[PolygonIdx++];
}
for (int32 xi = NumEdgeVerts-1; xi >= 0; --xi)
{
VertexGrid.At(xi, NumEdgeVerts-1) = PolygonVertices[PolygonIdx++];
}
for (int32 yi = NumEdgeVerts - 2; yi >= 1; --yi)
{
VertexGrid.At(0, yi) = PolygonVertices[PolygonIdx++];
}
ensure(PolygonIdx == PolygonVertices.Num());
int c00 = VertexGrid.At(0, 0);
int c10 = VertexGrid.At(NumEdgeVerts-1, 0);
int c01 = VertexGrid.At(0, NumEdgeVerts-1);
int c11 = VertexGrid.At(NumEdgeVerts-1, NumEdgeVerts-1);
FVector3d V00 = Mesh.GetVertex(c00);
FVector3d V10 = Mesh.GetVertex(c10);
FVector3d V01 = Mesh.GetVertex(c01);
FVector3d V11 = Mesh.GetVertex(c11);
// for this special case we only store the 4 corners in the InteriorBorderLoop, this will be detected in
// the profile code and used correctly there
Vertex.InteriorVertices.Reserve(FMath::Max((NumEdgeVerts - 1)* (NumEdgeVerts - 1), 0));
Vertex.InteriorBorderLoop = TArray<int32>({ c00, c10, c01, c11 });
// append new vertices for the interior, while storing their U/V coords in the BorderFrameWeights
for (int yi = 1; yi < NumEdgeVerts-1; ++yi)
{
double ty = (double)yi / (double)(NumEdgeVerts - 1);
FVector3d A = Lerp(V00, V01, ty);
FVector3d B = Lerp(V10, V11, ty);
for (int xi = 1; xi < NumEdgeVerts-1; ++xi)
{
ensure(VertexGrid.At(xi, yi) == -1);
double tx = (double)xi / (double)(NumEdgeVerts - 1);
FVector3d InterpPos = Lerp(A, B, tx);
int32 NewVID = Mesh.AppendVertex(InterpPos);
VertexGrid.At(xi, yi) = NewVID;
FBevelVertex_InteriorVertex& InteriorVertex = Vertex.InteriorVertices.Emplace_GetRef();
InteriorVertex.VertexID = NewVID;
InteriorVertex.BorderFrameWeight.Add(FVector3d(tx, ty, 0));
}
}
// create new vertices for any that don't already have a mapping back to boundary ring
TArray<FIndex3i> Triangles;
Vertex.NewGroupID = Mesh.AllocateTriangleGroup();
for (int y0 = 0; y0 < NumEdgeVerts - 1; ++y0)
{
for (int x0 = 0; x0 < NumEdgeVerts - 1; ++x0)
{
int i00 = VertexGrid.At(x0, y0);
int i10 = VertexGrid.At(x0+1, y0);
int i01 = VertexGrid.At(x0, y0+1);
int i11 = VertexGrid.At(x0+1, y0+1);
int T0 = Mesh.AppendTriangle(i10, i00, i01, Vertex.NewGroupID);
if (Mesh.IsTriangle(T0))
{
Vertex.NewTriangles.Add(T0);
}
int T1 = Mesh.AppendTriangle(i01, i11, i10, Vertex.NewGroupID);
if (Mesh.IsTriangle(T1))
{
Vertex.NewTriangles.Add(T1);
}
}
}
return;
}
// Ok, now we are in the general case (currently used for >= 5-vertex polygons)
// We will use Uniform Tessellation to subdivide the initial polygon triangulation up to
// the target polycount. This is a bit annoying because we have to reconstruct the boundary
// correspondence, perhaps FUniformTessellate could be improved to return this information
FUniformTessellate Tesselator(&TmpMesh);
Tesselator.TessellationNum = NumEdgeVerts - 2;
bool bTesselateOK = Tesselator.Compute();
// create flattened 2D version of this tessellated mesh (maybe should optimize in 2D for inner fairness??)
FDynamicMeshUVEditor UVEditor(&TmpMesh, 0, true);
TArray<int32> AllTriangles;
for (int32 tid : TmpMesh.TriangleIndicesItr()) AllTriangles.Add(tid);
TArray<int32> TmpMeshToUVMap; bool bMapIsCompact = false;
UVEditor.SetToPerVertexUVs(TmpMeshToUVMap, bMapIsCompact);
check(bMapIsCompact == true);
UVEditor.SetTriangleUVsFromFreeBoundarySpectralConformal(AllTriangles, true, true);
UVEditor.ScaleUVAreaTo3DArea(AllTriangles, true);
FDynamicMeshUVOverlay* UVOverlay = UVEditor.GetOverlay();
// Now we need to append this triangulated patch back into the main mesh, ie "fill the hole"
// that exists for this junction vertex. Ideally we will stitch at the compatible patch border, via this map
TArray<int32> VertexMap;
VertexMap.Init(-1, TmpMesh.MaxVertexID());
// We should have an exact match between the existing loop of boundary vertices (in PolygonVertices) and
// the boundary loop of the patch. And we know the correspondences at the Corners as we constructed them
// above in the TmpMesh.AppendVertex calls. So we should be able to find Corner 0 in the boundary loop,
// and walk around the two loops from that initial correspondence. This block will do that and store it in VertexMap, if possible.
int32 NV = PolygonVertices.Num();
FMeshBoundaryLoops BoundaryLoops(&TmpMesh, true); // should only ever be one loop...
bool bFoundLoop = false;
TArray<int32> BoundaryLoopVerts;
for (int32 k = 0; k < BoundaryLoops.GetLoopCount() && bFoundLoop == false; ++k)
{
if (BoundaryLoops[k].Vertices.Num() == NV)
{
BoundaryLoopVerts = BoundaryLoops[k].Vertices;
bFoundLoop = true; // conceivably it's possible this isn't the correct loop, somehow. That case is not handled
// find our known-correspondence vertices, from the initial polygon corners
int32 CornerVID = PolygonCornerVIDs[0];
int32 FoundIdx = BoundaryLoopVerts.IndexOfByKey(0);
int32 SecondCornerVID = PolygonCornerVIDs[1];
int32 FoundSecondIdx = BoundaryLoopVerts.IndexOfByKey(1);
if (FoundIdx != INDEX_NONE && FoundSecondIdx != INDEX_NONE)
{
// detect if the boundary loop is reversed, and if so, flip it
if (BoundaryLoopVerts[(FoundIdx+(NumEdgeVerts-1)) % NV] != BoundaryLoopVerts[FoundSecondIdx] )
{
Algo::Reverse(BoundaryLoopVerts);
FoundIdx = BoundaryLoopVerts.IndexOfByKey(0);
FoundSecondIdx = BoundaryLoopVerts.IndexOfByKey(1);
}
if (ensure(BoundaryLoopVerts[(FoundIdx+(NumEdgeVerts-1)) % NV] == BoundaryLoopVerts[FoundSecondIdx]))
{
// walk around loop at corresponding indices and populate VertexMap
for (int32 j = 0; j < NV; ++j)
{
int32 ExistingID = PolygonVertices[j];
int32 NewID = BoundaryLoopVerts[(FoundIdx + j) % NV];
VertexMap[NewID] = ExistingID;
}
}
}
}
}
Vertex.InteriorVertices.Reserve(FMath::Max(TmpMesh.VertexCount() - NV, 0));
int32 NumLoopVerts = BoundaryLoopVerts.Num();
FPolygon2d BorderPolygon;
for (int32 vid : BoundaryLoopVerts)
{
BorderPolygon.AppendVertex( (FVector2d)UVOverlay->GetElement(vid) );
}
// Create new vertices for any that don't already have a mapping back to boundary ring.
// For those interior vertices we also want to compute 2D Mean Value Coordinates (MVC)
// relative to the boundary polygon. We will use these later to interpolate 3D positions from
// the 3D border.
TArray<FIndex3i> Triangles;
Vertex.NewGroupID = Mesh.AllocateTriangleGroup();
for (int32 vid : TmpMesh.VertexIndicesItr())
{
if (VertexMap[vid] == -1)
{
int32 NewVID = Mesh.AppendVertex(TmpMesh.GetVertex(vid));
VertexMap[vid] = NewVID;
// construct interior MVC weights from 2D mesh
FBevelVertex_InteriorVertex& InteriorVertex = Vertex.InteriorVertices.Emplace_GetRef();
InteriorVertex.VertexID = NewVID;
InteriorVertex.BorderFrameWeight.Reserve(BoundaryLoopVerts.Num());
FVector2d UVPosition = (FVector2d)UVOverlay->GetElement(vid);
double WeightSum = 0;
for (int32 k = 0; k < NumLoopVerts; ++k)
{
int32 BoundaryVID = BoundaryLoopVerts[k];
int32 NewBoundaryVID = VertexMap[BoundaryVID];
checkSlow(NewBoundaryVID >= 0);
FVector2d BoundaryUVPosition = BorderPolygon[k];
FVector2d Prev = BorderPolygon[(k-1+NumLoopVerts) % NumLoopVerts];
FVector2d Next = BorderPolygon[(k+1) % NumLoopVerts];
FVector2d BoundaryFrameX = Normalized(Next - Prev);
FVector2d BoundaryFrameY = PerpCW(BoundaryFrameX);
FVector2d DeltaUV = UVPosition - BoundaryUVPosition;
double DeltaX = BoundaryFrameX.Dot(DeltaUV);
double DeltaY = BoundaryFrameY.Dot(DeltaUV);
// compute Polygon MVC weight ( https://cgvr.cs.uni-bremen.de/teaching/cg_literatur/barycentric_floater.pdf )
double Dist = Distance(UVPosition, BoundaryUVPosition);
double Weight = 1.0;
if ( Dist > FMathd::ZeroTolerance )
{
FVector2d DeltaP = Normalized(BoundaryUVPosition - UVPosition);
double T1 = UE::Geometry::VectorUtil::VectorTanHalfAngle(Normalized(Prev - UVPosition), DeltaP);
double T2 = UE::Geometry::VectorUtil::VectorTanHalfAngle(Normalized(Next - UVPosition), DeltaP);
Weight = (T1 + T2) / Dist;
}
InteriorVertex.BorderFrameWeight.Add( FVector3d(DeltaX, DeltaY, Weight) );
WeightSum += Weight;
}
for (FVector3d& Weight : InteriorVertex.BorderFrameWeight)
{
Weight.Z /= WeightSum; // normalize MVC weights
}
}
}
Vertex.InteriorBorderLoop.Reserve(NumLoopVerts);
for (int32 vid : BoundaryLoopVerts)
{
Vertex.InteriorBorderLoop.Add(VertexMap[vid]);
}
// PolygonVertices array is always constructed in reversed orientation, so patch will be flipped otherwise
TmpMesh.ReverseOrientation();
// append new triangles
for (FIndex3i Tri : TmpMesh.TrianglesItr())
{
int32 A = VertexMap[Tri.A];
int32 B = VertexMap[Tri.B];
int32 C = VertexMap[Tri.C];
int32 tid = Mesh.AppendTriangle(A, B, C, Vertex.NewGroupID);
if (Mesh.IsTriangle(tid))
{
Vertex.NewTriangles.Add(tid);
}
}
}
void FMeshBevel::AppendTerminatorVertexTriangles_Multi(FDynamicMesh3& Mesh, FBevelVertex& Vertex)
{
// A Terminator Vertex occurs at the end of an non-loop bevel-edge, where the bevel "ends".
// Disconnecting the mesh to insert the bevel edge-strip will have created a triangle-shaped hole
// in the mesh that must be filled. In the Multi-case, we have already meshed the adjacent bevel-edge,
// so it's not a simple triangle but one with subdivisions along the edge adajacent to the bevel-edge.
// So basically we have to find that already-meshed edge, and extract the column from it's quadpatch
// that we want to stitch to, and then add a triangle-fan to fill the hole polygon
// TODO: maybe could do delaunay triangulation if the polygon below is nearly coplanar...
MESH_BEVEL_DEBUG_CHECK(Vertex.VertexType == EBevelVertexType::TerminatorVertex);
check(Vertex.IncomingBevelEdgeIndices.Num() == 1);
int32 RingSplitEdgeID = Vertex.TerminatorInfo.A;
if (Mesh.IsEdge(RingSplitEdgeID))
{
FIndex2i SplitEdgeV = Mesh.GetEdgeV(RingSplitEdgeID);
int32 FarVertexID = SplitEdgeV.OtherElement(Vertex.VertexID);
int32 BevelEdgeIndex = Vertex.IncomingBevelEdgeIndices[0];
const FBevelEdge& IncomingEdge = Edges[BevelEdgeIndex];
int32 WedgeVertexA = Vertex.Wedges[0].WedgeVertex;
int32 WedgeVertexB = Vertex.Wedges[1].WedgeVertex;
// figure out which side of the incoming-edge quad-strip the terminator connects to
int32 ColumnIndex = IncomingEdge.StripQuadPatch.FindColumnIndex(WedgeVertexA);
check(ColumnIndex == 0 || ColumnIndex == IncomingEdge.StripQuadPatch.NumVertexCols() - 1);
TArray<int32> QuadStripEdgeVerts;
IncomingEdge.StripQuadPatch.GetVertexColumn(ColumnIndex, QuadStripEdgeVerts);
check(QuadStripEdgeVerts.Contains(WedgeVertexB));
// make sure it is oriented consistently
int32 FirstEdgeID = Mesh.FindEdge(QuadStripEdgeVerts[0], QuadStripEdgeVerts[1]);
FIndex2i QuadEdgeV = Mesh.GetOrientedBoundaryEdgeV(FirstEdgeID);
if (QuadEdgeV.A != QuadStripEdgeVerts[0])
{
Algo::Reverse(QuadStripEdgeVerts);
}
// should have computed this GroupID in initial setup
int32 UseGroupID = (Vertex.NewGroupID >= 0) ? Vertex.NewGroupID : Mesh.AllocateTriangleGroup();
int32 NumEdges = QuadStripEdgeVerts.Num()-1;
for (int32 k = 0; k < NumEdges; ++k)
{
int32 tid = Mesh.AppendTriangle(QuadStripEdgeVerts[k+1], QuadStripEdgeVerts[k], FarVertexID, UseGroupID);
MESH_BEVEL_DEBUG_CHECK(tid >= 0);
if (Mesh.IsTriangle(tid))
{
Vertex.NewTriangles.Add(tid);
}
}
}
}
void FMeshBevel::AppendTerminatorVertexPairQuad_Multi(FDynamicMesh3& Mesh, FBevelVertex& Vertex0, FBevelVertex& Vertex1)
{
MESH_BEVEL_DEBUG_CHECK(Vertex0.VertexType == EBevelVertexType::TerminatorVertex);
MESH_BEVEL_DEBUG_CHECK(Vertex1.VertexType == EBevelVertexType::TerminatorVertex);
// This is a variant of AppendTerminatorVertexTriangle that handles the case where basically two
// Terminator Vertices are directly connected by a non-beveled mesh edge that was used as the ring-split-edge.
// Since both sides were opened, we have a quad-shaped hole instead of a triangle-shaped hole, with a
// (subdivided, in the multi-case) quad-edge at each end. So this hole can be filled with a quad-patch that
// stitches together the existing edges (which must have already been meshed)
auto CollectTerminatorVtxInfo = [this](FDynamicMesh3& Mesh, FBevelVertex& Vertex, TArray<int32>& QuadStripEdgeVertsOut)
{
int32 BevelEdgeIndex = Vertex.IncomingBevelEdgeIndices[0];
const FBevelEdge& IncomingEdge = Edges[BevelEdgeIndex];
int32 ColumnIndex = IncomingEdge.StripQuadPatch.FindColumnIndex(Vertex.Wedges[0].WedgeVertex);
check(ColumnIndex == 0 || ColumnIndex == IncomingEdge.StripQuadPatch.NumVertexCols() - 1);
IncomingEdge.StripQuadPatch.GetVertexColumn(ColumnIndex, QuadStripEdgeVertsOut);
check(QuadStripEdgeVertsOut.Contains(Vertex.Wedges[1].WedgeVertex));
int32 FirstEdgeID = Mesh.FindEdge(QuadStripEdgeVertsOut[0], QuadStripEdgeVertsOut[1]);
FIndex2i QuadEdgeV = Mesh.GetOrientedBoundaryEdgeV(FirstEdgeID);
if (QuadEdgeV.A != QuadStripEdgeVertsOut[0])
{
Algo::Reverse(QuadStripEdgeVertsOut);
}
};
TArray<int32> QuadStripEdgeVerts0, QuadStripEdgeVerts1;
CollectTerminatorVtxInfo(Mesh, Vertex0, QuadStripEdgeVerts0);
CollectTerminatorVtxInfo(Mesh, Vertex1, QuadStripEdgeVerts1);
if (QuadStripEdgeVerts0.Num() != QuadStripEdgeVerts1.Num() || QuadStripEdgeVerts0.Num() == 0)
{
// this could happen if the quadstrip failed on one or both sides? will leave a hole.
MESH_BEVEL_DEBUG_CHECK(false);
return;
}
// BIASED? should have computed this GroupID in initial setup
int32 UseGroupID = (Vertex0.NewGroupID >= 0) ? Vertex0.NewGroupID : Mesh.AllocateTriangleGroup();
int32 NumEdges = QuadStripEdgeVerts0.Num() - 1;
for (int32 k = 0; k < NumEdges; ++k)
{
int32 A0 = QuadStripEdgeVerts0[k];
int32 B0 = QuadStripEdgeVerts0[k+1];
int32 A1 = QuadStripEdgeVerts1[NumEdges-(k)];
int32 B1 = QuadStripEdgeVerts1[NumEdges-(k+1)];
int32 tid0 = Mesh.AppendTriangle(B0, A0, A1, UseGroupID);
MESH_BEVEL_DEBUG_CHECK(tid0 >= 0);
if (Mesh.IsTriangle(tid0))
{
Vertex0.NewTriangles.Add(tid0);
}
int32 tid1 = Mesh.AppendTriangle(A1, B1, B0, UseGroupID);
MESH_BEVEL_DEBUG_CHECK(tid1 >= 0);
if (Mesh.IsTriangle(tid1))
{
Vertex0.NewTriangles.Add(tid1);
}
}
}
void FMeshBevel::CreateBevelMeshing_Multi(FDynamicMesh3& Mesh)
{
// This is the top-level driver function that is called after the mesh has been pulled apart along
// the bevelled edges. There are four cases - open edge spans, edge loops, corners/vertices with bevel-valence > 3 (become polygons),
// and "terminator" vertices of bevel-valence 1 (become triangles, except if directly connected, then they become quads).
// First we figure out the mesh connectivity, ie the 'stitching' between the pulled-apart geometry,
// and then we (optionally) apply a profile-curve shape along the bevel strips
// We will later need normals along each exterior "side" of the bevel edge to define the arcs along
// rounded bevel edges, ie basically these are the smooth boundary conditions.
// It ought to be possible to compute this after adding the bevel geometry, by filtering out the bevel-edge tris,
// but for now it's simpler to just do it here before we add the bevel tris and cache it...
for (FBevelEdge& Edge : Edges)
{
Edge.NormalsA.SetNum(Edge.MeshVertices.Num());
Edge.NormalsB.SetNum(Edge.MeshVertices.Num());
for (int32 k = 0; k < Edge.MeshVertices.Num(); ++k)
{
Edge.NormalsA[k] = FMeshNormals::ComputeVertexNormal(Mesh, Edge.MeshVertices[k]);
Edge.NormalsB[k] = FMeshNormals::ComputeVertexNormal(Mesh, Edge.NewMeshVertices[k]);
}
}
for (FBevelLoop& Loop : Loops)
{
Loop.NormalsA.SetNum(Loop.MeshVertices.Num());
Loop.NormalsB.SetNum(Loop.MeshVertices.Num());
for (int32 k = 0; k < Loop.MeshVertices.Num(); ++k)
{
Loop.NormalsA[k] = FMeshNormals::ComputeVertexNormal(Mesh, Loop.MeshVertices[k]);
Loop.NormalsB[k] = FMeshNormals::ComputeVertexNormal(Mesh, Loop.NewMeshVertices[k]);
}
}
for (FBevelEdge& Edge : Edges)
{
AppendEdgeQuads_Multi(Mesh, Edge);
}
for (FBevelLoop& Loop : Loops)
{
AppendLoopQuads_Multi(Mesh, Loop);
}
for (FBevelVertex& Vertex : Vertices)
{
if (Vertex.VertexType == EBevelVertexType::JunctionVertex)
{
if (Vertex.Wedges.Num() > 2)
{
AppendJunctionVertexPolygon_Multi(Mesh, Vertex);
}
}
}
// easier to do terminators last so that we can use quad edge to orient the triangle
TSet<FIndex2i> HandledQuadVtxPairs;
for (FBevelVertex& Vertex : Vertices)
{
if (Vertex.VertexType == EBevelVertexType::TerminatorVertex)
{
if (Vertex.ConnectedBevelVertex >= 0)
{
FBevelVertex& OtherVertex = Vertices[Vertex.ConnectedBevelVertex];
FIndex2i VtxPair(Vertex.VertexID, OtherVertex.VertexID);
VtxPair.Sort();
if (HandledQuadVtxPairs.Contains(VtxPair) == false)
{
AppendTerminatorVertexPairQuad_Multi(Mesh, Vertex, OtherVertex);
HandledQuadVtxPairs.Add(VtxPair);
}
}
else
{
AppendTerminatorVertexTriangles_Multi(Mesh, Vertex);
}
}
}
// At this point, all topology is determined. Now if desired a profile-curve shape can be applied as a postprocess.
// (Not entirely certain this is the right strategy for all profile types but it works OK for a simple round profile)
if (FMathd::Abs(RoundWeight) > FMathf::ZeroTolerance)
{
ApplyProfileShape_Round(Mesh);
}
}
FInterpCurveVector FMeshBevel::MakeArcSplineCurve(const FVector3d& PosA, FVector3d& NormalA, const FVector3d& PosB, FVector3d& NormalB) const
{
FInterpCurveVector Curve;
// basic idea here is to approximate an arc w/ a bezier curve. We know A and B,
// and we need TangentA (T_A) and TangentB. We have a surface Normal at A and B, so
// for T_A we can project B onto the surface tangent plane at A (ie with NormalA),
// and then B-A gives us a direction for T_A, and the same works for for B
//
// T_A
// <-----
// ^ __-*A
// | /
// T_B| / (this is the arc, sorry)
// | |
// *B
//
// The lengths of the Tangents in this approach end up being the lengths of the sides
// of the square, if this were a 2D situation. Which could effectively define a 2D arc.
// For now, we are use a FInterpCurve instead, which is not quite a Bezier. With those
// lengths, the curve will end up too flat, so it is scaled by a parameter (default sqrt 2).
// This could perhaps be exposed as an option...
//
// The advantage of using a curve here instead of an arc is that it allows something reasonable
// to happen for messy cases, like where the curve might not be planar. But likely some
// issues are going to arise with ugly projections...
// project the vector (B-A) onto the plane (A,NormalA).
FFrame3d PlaneNormalA(PosA, NormalA);
FVector3d TangentA = PlaneNormalA.ToPlane(PosB) - PosA;
// same for A-B onto (B, NormalB)
FFrame3d PlaneNormalB(PosB, NormalB);
FVector3d TangentB = PlaneNormalB.ToPlane(PosA) - PosB;
Curve.AddPoint(0, PosA);
Curve.AddPoint(1, PosB);
Curve.Points[0].InterpMode = EInterpCurveMode::CIM_CurveUser;
Curve.Points[1].InterpMode = EInterpCurveMode::CIM_CurveUser;
double TangentScale = FMathd::Abs(RoundWeight) * FMathd::Sqrt2;
if (RoundWeight >= 0)
{
Curve.Points[0].ArriveTangent = Curve.Points[0].LeaveTangent = TangentScale * TangentA;
Curve.Points[1].ArriveTangent = Curve.Points[1].LeaveTangent = -TangentScale * TangentB;
}
else
{
Curve.Points[0].ArriveTangent = Curve.Points[0].LeaveTangent = -TangentScale * TangentB;
Curve.Points[1].ArriveTangent = Curve.Points[1].LeaveTangent = TangentScale * TangentA;
}
return Curve;
}
void FMeshBevel::ApplyProfileShape_Round(FDynamicMesh3& Mesh)
{
// This function applies round profile curves to the bevel edge quadstrips &
// bevel vertex tessellated-polygons that were computed in the _Multi() functions.
// All the geometry already exists so the job here is just to deform it into rounder shapes.
//
// The current code is based on various different strategies but the basic idea is to
// compute a arc-shaped 3D splines between correspondeng edge-vertex pairs , and then derive
// the shape of the vertex patches using the now-curved borders. For 4-sided patches
// this is relatively simple, 5+-sided we use a sort of MVC-based hole-filling strategy, and
// for 3-sided currently using a 3-sided spline batch taken from PN-tessellation.
// The 3-sided case currently does not work very well though.
// Loops are an easy case as there are no junction vertices, so each vertex-pair gets a separate
// spline and everything is done.
for (FBevelLoop& Loop : Loops)
{
FQuadGridPatch& Patch = Loop.StripQuadPatch;
int32 NumCols = Patch.NumVertexCols();
for (int32 Col = 0; Col < NumCols-1; ++Col)
{
TArray<int32> ColVerts;
Patch.GetVertexColumn(Col, ColVerts);
int32 NV = ColVerts.Num();
int32 A = ColVerts[0], B = ColVerts.Last();
FVector3d PosA = Mesh.GetVertex(A), PosB = Mesh.GetVertex(B);
FVector3d NormalA = Loop.NormalsA[Col], NormalB = Loop.NormalsB[Col];
// project normals onto section plane defined by original and inset vertex positions.
// (do we even need the normals anymore? could they be defined by the 2D perp operator in the section plane?)
FVector3d InitialPosition = Loop.InitialPositions[Col];
FVector3d Direction1 = Normalized(PosA - InitialPosition);
FVector3d Direction2 = Normalized(PosB - InitialPosition);
FVector3d PlaneNormal = Normalized(Cross(Direction1, Direction2));
NormalA = Normalized(NormalA - NormalA.Dot(PlaneNormal) * PlaneNormal);
NormalB = Normalized(NormalB - NormalB.Dot(PlaneNormal) * PlaneNormal);
FInterpCurveVector Curve = MakeArcSplineCurve(PosA, NormalA, PosB, NormalB);
// TODO: should have special case here for flat patches? they get squished out a bit...
for (int32 k = 1; k < (NV - 1); ++k)
{
int32 VID = ColVerts[k];
FVector3d Pos = Mesh.GetVertex(VID);
double T = (double)k / (double)(NV-1);
FVector3d CurvePos = Curve.Eval((float)T, Lerp(PosA, PosB, T));
Mesh.SetVertex(VID, CurvePos);
}
}
}
// kinda gross approach to keeping track of the normals along the ends of edge spans,
// ie after we make them curved, we want the normals along those curves, ie what we
// want to use as the normal/tangent constraint for the bevelvertex-polygon. At this point
// the mesh topo should be finalized so we can just use an array...
TArray<FVector3d> DeformNormals;
DeformNormals.Init(FVector3d::Zero(), Mesh.MaxVertexID());
// we need to keep track of the curve used between each split pair of beveledge-vertices,
// and we need to be able to loop them up based on the vertex-pair.
TMap<FIndex2i, FInterpCurveVector> BorderCurves;
// search function for BorderCurves list
auto FindCurve = [&BorderCurves](int i0, int i1, bool& bReversed)
{
FInterpCurveVector* FoundCurve = BorderCurves.Find(FIndex2i(i0, i1));
bReversed = false;
if (FoundCurve == nullptr)
{
FoundCurve = BorderCurves.Find(FIndex2i(i1, i0));
bReversed = true;
}
return FoundCurve;
};
// Each edge is processed similar to a loop, ie the column of vertices bewteen each vertex-pair on
// either side of the quad-strip gets deformed by fitting a spline curve based on the endpoints and end-normals.
//
for (FBevelEdge& Edge : Edges)
{
FQuadGridPatch& Patch = Edge.StripQuadPatch;
bool bPatchIsFlippedX = false;
int32 NumCols = Patch.NumVertexCols();
for (int32 Col = 0; Col < NumCols; ++Col)
{
TArray<int32> ColVerts;
Patch.GetVertexColumn(Col, ColVerts);
int32 NumColVerts = ColVerts.Num();
// The Edge contains various vertex lists like Edge.MeshVertices that have a consistent ordering.
// However because of how the patches are constructed, the columns may be reversed (unclear why...)
// Detect that case so that the indexing Col/Array indexing can be inverted where necessary
if (Col == 0 && ColVerts.Contains(Edge.MeshVertices[0]) == false)
{
bPatchIsFlippedX = true;
}
int32 A = ColVerts[0];
int32 B = ColVerts.Last();
FVector3d PosA = Mesh.GetVertex(A);
FVector3d PosB = Mesh.GetVertex(B);
int UseEdgeVertIndex = (bPatchIsFlippedX) ? (NumCols-Col-1) : Col;
FVector3d NormalA = Edge.NormalsA[UseEdgeVertIndex];
FVector3d NormalB = Edge.NormalsB[UseEdgeVertIndex];
// Ok for each column along a bevel edge-strip, we want to bend the column into a curve.
// We have the endpoints we want to interpolate, and we have normals at those points that we
// computed elsewhere and are going to assume are good, ie those are the normals we want the
// perfect rounded bevel to have, if it had infinite sections.
//
// The issue is that we have 2 points and 2 normals and they may not all lie in the same plane.
// For most cases, the original vertex position has been inset in two directions (to PosA and PosB), and
// so that gives us the plane they all should lie in. However at valence3+ junction vertices this is not true,
// as the one corner vertex was inset along 3+ edges and so we don't have the 'InitialPosition'
// value below for each of those edges, that we would need to define the simple arc-sections.
//
// (todo: maybe keeping track of those positions would be better than what we do now
bool bInferTangentPlaneFromInitialPosition = true;
bool bIsEndpoint = (UseEdgeVertIndex == 0) || (UseEdgeVertIndex == NumCols - 1);
if ( bIsEndpoint )
{
int32 BevelVertexIndex = (UseEdgeVertIndex == 0) ? Edge.BevelVertices.A : Edge.BevelVertices.B;
const FBevelVertex& BevelVtx = Vertices[BevelVertexIndex];
if (BevelVtx.VertexType == EBevelVertexType::JunctionVertex && BevelVtx.IncomingBevelEdgeIndices.Num() > 2)
{
bInferTangentPlaneFromInitialPosition = false;
}
}
FVector3d InitialPosition = Edge.InitialPositions[UseEdgeVertIndex];
FVector3d Direction1 = Normalized(PosA - InitialPosition);
FVector3d Direction2 = Normalized(PosB - InitialPosition);
FVector3d SectionPlaneNormal = Normalized(Cross(Direction1, Direction2));
if (!bInferTangentPlaneFromInitialPosition)
{
FVector3d InitialEdgeDirection = (UseEdgeVertIndex == 0) ?
(Edge.InitialPositions[1] - InitialPosition) : (InitialPosition - Edge.InitialPositions[NumCols-2]);
if (InitialEdgeDirection.Normalize())
{
FFrame3d TempFrame(PosA, Normalized(PosB - PosA));
TempFrame.ConstrainedAlignAxis(1, InitialEdgeDirection, TempFrame.Z());
SectionPlaneNormal = TempFrame.Y();
}
}
// project normals onto section plane
NormalA = Normalized(NormalA - NormalA.Dot(SectionPlaneNormal) * SectionPlaneNormal);
NormalB = Normalized(NormalB - NormalB.Dot(SectionPlaneNormal) * SectionPlaneNormal);
// TODO: should have special case here for flat patches? they get squished out a bit...
// This may update NormalA/NormalB for 'inverted' bevels (ie w/ negative RoundWeight)
FInterpCurveVector Curve = MakeArcSplineCurve(PosA, NormalA, PosB, NormalB);
// accumulate normal at endpoints
DeformNormals[A] += NormalA;
DeformNormals[B] += NormalB;
// save this curve in the curves list
BorderCurves.Add(FIndex2i(A, B), Curve);
// map linear-interpolation to curve parameter and evaluate curve
TArray<FVector3d> CurveVerts;
CurveVerts.SetNum(NumColVerts);
CurveVerts[0] = PosA; CurveVerts[NumColVerts-1] = PosB;
for (int32 k = 1; k < (NumColVerts - 1); ++k)
{
int32 VID = ColVerts[k];
FVector3d Pos = Mesh.GetVertex(VID);
double T = (double)k / (double)(NumColVerts-1);
FVector3d CurvePos = Curve.Eval((float)T, Lerp(PosA, PosB, T));
Mesh.SetVertex(VID, CurvePos);
CurveVerts[k] = CurvePos;
}
// accumulate new interior normals (only triangles inside the edge are considered)
// (do we need these anywhere??)
for (int32 k = 1; k < (NumColVerts - 1); ++k)
{
int32 VID = ColVerts[k];
FVector3d CurveEdgeNormal = FMeshNormals::ComputeVertexNormal(Mesh, VID,
[&](int32 TriangleID) { return Mesh.GetTriangleGroup(TriangleID) == Edge.NewGroupID; }, true, true);
DeformNormals[VID] += CurveEdgeNormal;
}
}
}
// re-normalize here because we accumulated normals above...
for (FVector3d& Normal : DeformNormals)
{
Normal.Normalize();
}
// Process vertices. This code has special-cases for valence 3 and 4, which should be factored out into separate functions.
for (FBevelVertex& Vertex : Vertices)
{
int32 LoopN = Vertex.InteriorBorderLoop.Num();
for (const FBevelVertex_InteriorVertex& InteriorVtx : Vertex.InteriorVertices)
{
// Special case for valence-3 vertex, ie triangular patch. In this case we use
// a triangular spline, the math is based on PN triangulation, where the vertex/normal
// pairs at the endpoints are used. However a center-point/normal is also necessary.
// This does an OK job but seems to come out too flat in many cases...ultimately it is
// not going to even be C0 with the boundary spline curves we already decided on.
// Perhaps a better option would be to do it similar to the valence-4 case, where basically
// we construct interpolated splines based on the barycentrics and border splines
if (InteriorVtx.BorderFrameWeight.Num() == 1 && Vertex.InteriorBorderLoop.Num() == 3)
{
// Nearly all of this work below is identical for every interior vertex!!! It should be done once and cached.
double w = InteriorVtx.BorderFrameWeight[0].X, u = InteriorVtx.BorderFrameWeight[0].Y, v = InteriorVtx.BorderFrameWeight[0].Z;
int i300 = Vertex.InteriorBorderLoop[0];
FVector3d b300 = Mesh.GetVertex(i300);
int i030 = Vertex.InteriorBorderLoop[1];
FVector3d b030 = Mesh.GetVertex(i030);
int i003 = Vertex.InteriorBorderLoop[2];
FVector3d b003 = Mesh.GetVertex(i003);
FVector3d N300 = DeformNormals[i300];
FVector3d N030 = DeformNormals[i030];
FVector3d N003 = DeformNormals[i003];
bool bReversedA = false, bReversedB = false, bReversedC = false;
FInterpCurveVector* CurveA = FindCurve(i300, i030, bReversedA);
FInterpCurveVector* CurveB = FindCurve(i030, i003, bReversedB);
FInterpCurveVector* CurveC = FindCurve(i003, i300, bReversedC);
if ( !ensure(CurveA != nullptr && CurveB != nullptr && CurveC != nullptr )) continue;
// PN triangle sides are defined by bezier curves, however FInterpCurve is not actually a Bezier, it's missing a 3
// on the tangents in the math. So scaling by 1/3 here corrects for this (...ish?)
const double TangentScale = 1.0 / 3.0;
FVector3d b210 = TangentScale * ((bReversedA) ? -CurveA->Points[1].LeaveTangent : CurveA->Points[0].LeaveTangent);
b210 += b300;
FVector3d b120 = TangentScale * ((bReversedA) ? CurveA->Points[0].LeaveTangent : -CurveA->Points[1].LeaveTangent);
b120 += b030;
FVector3d b021 = TangentScale * ((bReversedB) ? -CurveB->Points[1].LeaveTangent : CurveB->Points[0].LeaveTangent);
b021 += b030;
FVector3d b012 = TangentScale * ((bReversedB) ? CurveB->Points[0].LeaveTangent : -CurveB->Points[1].LeaveTangent);
b012 += b003;
FVector3d b102 = TangentScale * ((bReversedC) ? -CurveC->Points[1].LeaveTangent : CurveC->Points[0].LeaveTangent);
b102 += b003;
FVector3d b201 = TangentScale * ((bReversedC) ? CurveC->Points[0].LeaveTangent : -CurveC->Points[1].LeaveTangent);
b201 += b300;
// this computed midpoint tends to be too flat...
FVector3d E = (b210 + b120 + b021 + b012 + b102 + b201) / 6.0;
FVector3d V = (b300 + b030 + b003) / 3.0;
FVector3d b111 = E + RoundWeight * (E - V) / 2.0;
FVector InterpPos = b300*w*w*w + b030*u*u*u + b003*v*v*v
+ b210*3*w*w*u + b120*3*w*u*u + b201*3*w*w*v
+ b021*3*u*u*v + b102*3*w*v*v + b012*3*u*v*v
+ b111*6*w*u*v;
Mesh.SetVertex(InteriorVtx.VertexID, InterpPos);
continue;
}
// this block handles special case of valence-4 vertex that can be done w/ a quad patch interpolating boundary curves
// TODO: refactor this to a separate first pass so that we can pull the curve setup out of each iteration
if (InteriorVtx.BorderFrameWeight.Num() == 1 && Vertex.InteriorBorderLoop.Num() == 4)
{
// Nearly all of this work below is identical for every interior vertex!!! It should be done once and cached.
// here is the situation: We have a tessellated quad patch, when we tessellated it, it was planar (or
// at least the edges were straight). At tessellation time we computed barycentric coordinates for each interior vertex.
// Now we have curved the edges of the patch along spline curves (above). So basically we want to compute new interior
// positions by blending the four edge curve positions. If we think of the quad as having 2 axes X and Y, we are
// going to blend the two X curves along the two Y curves, and then evaluate the blended curve to get the vertex position.
// This is messy because (1) we have to look up the curves and (2) each one might have swapped end-vertices with a reversed parameter space.
// Most of the code below is about handling that weirdness.
//
// Note that since these are (almost) Beziers, the 'curve blending' is strictly about the tangents, as the endpoints are fixed/known
//
//c01 X2 c11 (diagram corresponds to variable naming below)
// *--------------* ty=1
// Y1| |Y2
// | XInterp |
// A*==============*B
// | |
// *--------------* ty=0
//c00 X1 c10
//
// tx=0 tx=1
// these are the UV (XY) coords of the vertex inside the initial planar quad
double tx = InteriorVtx.BorderFrameWeight[0].X, ty = InteriorVtx.BorderFrameWeight[0].Y;
// four ordered corner vertices of the initial planar quad
int c00 = Vertex.InteriorBorderLoop[0];
int c10 = Vertex.InteriorBorderLoop[1];
int c01 = Vertex.InteriorBorderLoop[2];
int c11 = Vertex.InteriorBorderLoop[3];
// locate the two "Y" edge curves from their corner vertices, handling case of curve being reversed
FInterpCurveVector* CurveY1 = BorderCurves.Find(FIndex2i(c00, c01));
bool bReversed1 = false;
if (CurveY1 == nullptr)
{
CurveY1 = BorderCurves.Find(FIndex2i(c01, c00));
bReversed1 = true;
}
if ( ! ensure(CurveY1 != nullptr) ) continue;
FInterpCurveVector* CurveY2 = BorderCurves.Find(FIndex2i(c10, c11));
bool bReversed2 = false;
if (CurveY2 == nullptr)
{
CurveY2 = BorderCurves.Find(FIndex2i(c11, c10));
bReversed2 = true;
}
if (!ensure(CurveY2 != nullptr)) continue;
// evaluate each edge curve at the Y coord
double tA = bReversed1 ? (1.0 - ty) : ty;
FVector A = CurveY1->Eval((float)tA, FVector::Zero()); // TODO: should lerp here instead of using ::Zero() obviously...
double tB = bReversed2 ? (1.0 - ty) : ty;
FVector B = CurveY2->Eval((float)tB, FVector::Zero()); // TODO: should lerp here instead of using ::Zero() obviously...
// now find the two "X" edge curves from their corner vertices, again handling case of reversed edge
FInterpCurveVector* CurveX1 = BorderCurves.Find(FIndex2i(c00, c10));
bool bReversedX1 = false;
if (CurveX1 == nullptr)
{
CurveX1 = BorderCurves.Find(FIndex2i(c10, c00));
bReversedX1 = true;
}
if (!ensure(CurveX1 != nullptr)) continue;
FInterpCurveVector* CurveX2 = BorderCurves.Find(FIndex2i(c01, c11));
bool bReversedX2 = false;
if (CurveX2 == nullptr)
{
CurveX2 = BorderCurves.Find(FIndex2i(c11, c01));
bReversedX2 = true;
}
if (!ensure(CurveX2 != nullptr)) continue;
// extract tangents of X curves, need to blend these to compute interpolated tangents at Y-curve points A/B
FVector3d Tangent00 = (bReversedX1) ? CurveX1->Points[1].LeaveTangent : -CurveX1->Points[0].LeaveTangent;
FVector3d Tangent10 = (bReversedX1) ? -CurveX1->Points[0].LeaveTangent : CurveX1->Points[1].LeaveTangent;
FVector3d Tangent01 = (bReversedX2) ? CurveX2->Points[1].LeaveTangent : -CurveX2->Points[0].LeaveTangent;
FVector3d Tangent11 = (bReversedX2) ? -CurveX2->Points[0].LeaveTangent : CurveX2->Points[1].LeaveTangent;
// should perhaps be based on interpolating tangents along Y splines instead of just lerp? is it equivalent?
FVector TangentA = Lerp(Tangent00, Tangent01, ty);
FVector TangentB = Lerp(Tangent10, Tangent11, ty);
// construct interpolated X curve, has endpoints evaluated along Y curves, with X curve endpoint tangents
// blended along Y curves
FInterpCurveVector InterpolatedXCurve;
InterpolatedXCurve.AddPoint(0, A);
InterpolatedXCurve.AddPoint(1, B);
InterpolatedXCurve.Points[0].ArriveTangent = InterpolatedXCurve.Points[0].LeaveTangent = -TangentA;
InterpolatedXCurve.Points[1].ArriveTangent = InterpolatedXCurve.Points[1].LeaveTangent = TangentB;
InterpolatedXCurve.Points[0].InterpMode = InterpolatedXCurve.Points[1].InterpMode = EInterpCurveMode::CIM_CurveUser;
// evaluate this new X curve at the vertex X position
FVector InterpPos = InterpolatedXCurve.Eval((float)tx, Lerp(A, B, tx));
Mesh.SetVertex(InteriorVtx.VertexID, InterpPos);
continue;
}
// This should only happen for valence 3 and 4 that we already handled. But if it happens
// elsewhere, it means we will just leave that patch flat
if (InteriorVtx.BorderFrameWeight.Num() != LoopN) continue;
// ok the general-case solution is basically to compute the new position for this vertex in the rotated
// frame of each boundary-polygon vertex, and blend those positions using the MVC coordinates. This produces
// a smooth interpolating surface but there is no continuity at the border, and the 'far' vertices will tend
// to exert too much influence
FVector3d BlendedPos = FVector3d::Zero();
double WeightSum = 0;
for (int32 k = 0; k < LoopN; ++k)
{
int32 BorderVID = Vertex.InteriorBorderLoop[k];
FVector3d BorderPos = Mesh.GetVertex(BorderVID);
FVector3d BorderFrameX = Mesh.GetVertex(Vertex.InteriorBorderLoop[(k+1) % LoopN]) -
Mesh.GetVertex(Vertex.InteriorBorderLoop[(k-1 + LoopN) % LoopN]);
BorderFrameX = Normalized(BorderFrameX);
FVector3d BorderFrameN = DeformNormals[BorderVID];
if (RoundWeight < 0)
{
FQuaterniond RotQuat(BorderFrameX, -45, true);
BorderFrameN = RotQuat * BorderFrameN;
}
FVector3d BorderFrameY = Cross(BorderFrameN, BorderFrameX);
FVector3d FrameDeltaWeight = InteriorVtx.BorderFrameWeight[k];
FVector3d ReconstructedPos = BorderPos + (FrameDeltaWeight.X*BorderFrameX) + (FrameDeltaWeight.Y*BorderFrameY);
BlendedPos += FrameDeltaWeight.Z * ReconstructedPos;
WeightSum += FrameDeltaWeight.Z;
}
BlendedPos *= (1.0 / WeightSum);
Mesh.SetVertex(InteriorVtx.VertexID, BlendedPos);
}
}
}
void FMeshBevel::ComputeNormals(FDynamicMesh3& Mesh)
{
if (Mesh.HasAttributes() == false)
{
return;
}
FDynamicMeshNormalOverlay* NormalOverlay = Mesh.Attributes()->PrimaryNormals();
auto SetNormalsOnTriRegion = [NormalOverlay](const TArray<int32>& Triangles)
{
if (Triangles.Num() > 0)
{
FMeshNormals::InitializeOverlayRegionToPerVertexNormals(NormalOverlay, Triangles);
}
};
for (FBevelVertex& Vertex : Vertices)
{
SetNormalsOnTriRegion(Vertex.NewTriangles);
}
TArray<int32> TriList;
for (FBevelEdge& Edge : Edges)
{
UELocal::QuadsToTris(Mesh, Edge.StripQuads, TriList, true);
SetNormalsOnTriRegion(TriList);
}
for (FBevelLoop& Loop : Loops)
{
UELocal::QuadsToTris(Mesh, Loop.StripQuads, TriList, true);
SetNormalsOnTriRegion(TriList);
}
}
void FMeshBevel::ComputeUVs(FDynamicMesh3& Mesh)
{
if (Mesh.HasAttributes() == false)
{
return;
}
FDynamicMeshUVOverlay* UVOverlay = Mesh.Attributes()->PrimaryUV();
auto SetUVsOnTriRegion = [&Mesh, UVOverlay](const TArray<int32>& Triangles)
{
if (Triangles.Num() > 0)
{
UE::Geometry::ComputeArbitraryTrianglePatchUVs(Mesh, *UVOverlay, Triangles);
}
};
TArray<int32> TriList;
for (FBevelEdge& Edge : Edges)
{
UELocal::QuadsToTris(Mesh, Edge.StripQuads, TriList, true);
SetUVsOnTriRegion(TriList);
}
for (FBevelLoop& Loop : Loops)
{
UELocal::QuadsToTris(Mesh, Loop.StripQuads, TriList, true);
SetUVsOnTriRegion(TriList);
}
// do vertices last because until edges have UVs, the vertex polygons have no neighbour UVs islands
for (FBevelVertex& Vertex : Vertices)
{
SetUVsOnTriRegion(Vertex.NewTriangles);
}
}
void FMeshBevel::ComputeMaterialIDs(FDynamicMesh3& Mesh)
{
if (Mesh.HasAttributes() == false || Mesh.Attributes()->HasMaterialID() == false)
{
return;
}
FDynamicMeshMaterialAttribute* MaterialIDs = Mesh.Attributes()->GetMaterialID();
if (MaterialIDMode == EMaterialIDMode::ConstantMaterialID)
{
for (int32 tid : NewTriangles)
{
MaterialIDs->SetValue(tid, SetConstantMaterialID);
}
}
else
{
auto SetQuadMaterial = [&Mesh, MaterialIDs](const FIndex2i& Quad, int32 MaterialID)
{
if (Quad.A >= 0)
{
MaterialIDs->SetValue(Quad.A, MaterialID);
}
if (Quad.B >= 0)
{
MaterialIDs->SetValue(Quad.B, MaterialID);
}
};
// Try to set materials on the new triangles along a beveled edge based on the adjacent pre-bevel triangles.
// Could be improved to at least be more consistent in ambiguous cases
auto SetEdgeMaterials = [&Mesh, MaterialIDs, this, SetQuadMaterial](const TArray<FIndex2i>& StripQuads, const TArray<FIndex2i>& EdgeTris)
{
int32 NumEdges = EdgeTris.Num();
if (StripQuads.Num() == NumEdges)
{
TArray<int32> SawMaterialIDs;
TArray<int32> AmbiguousEdges;
for (int32 k = 0; k < StripQuads.Num(); ++k)
{
FIndex2i NbrTris = EdgeTris[k];
int MatIDA = MaterialIDs->GetValue(NbrTris.A);
int MatIDB = (NbrTris.A >= 0) ? MaterialIDs->GetValue(NbrTris.B) : MatIDA;
SawMaterialIDs.AddUnique(MatIDA);
SawMaterialIDs.AddUnique(MatIDB);
int SetMaterialID = (MatIDA == MatIDB) ? MatIDA : SetConstantMaterialID;
if (MatIDA != MatIDB)
{
if (MaterialIDMode == EMaterialIDMode::InferMaterialID_ConstantIfAmbiguous)
{
SetMaterialID = SetConstantMaterialID;
}
else
{
AmbiguousEdges.Add(k);
}
}
SetQuadMaterial(StripQuads[k], SetMaterialID);
}
if (AmbiguousEdges.Num() > 0)
{
SawMaterialIDs.Sort();
if (AmbiguousEdges.Num() == NumEdges) // if all ambigous, just pick one
{
for (int32 k : AmbiguousEdges)
{
SetQuadMaterial(StripQuads[k], SawMaterialIDs[0]);
}
}
else
{
// TODO: what we probably want to do here is "infill" from known neighbours.
// for now we will just punt and pick one
for (int32 k : AmbiguousEdges)
{
SetQuadMaterial(StripQuads[k], SawMaterialIDs[0]);
}
}
}
}
else
{
for (const FIndex2i& Quad : StripQuads)
{
SetQuadMaterial(Quad, SetConstantMaterialID);
}
}
};
for (FBevelEdge& Edge : Edges)
{
SetEdgeMaterials(Edge.StripQuads, Edge.MeshEdgeTris);
}
for (FBevelLoop& Loop : Loops)
{
SetEdgeMaterials(Loop.StripQuads, Loop.MeshEdgeTris);
}
// find all the unique material IDs of neighbours of the Triangles list (that are not in Triangles list) and
// return (MaterialID, NbrTriCount) tuples as a pair of lists
auto CountUniqueBorderMaterialIDs = [&](const FDynamicMesh3& Mesh, const FDynamicMeshMaterialAttribute& MaterialAttrib, const TArray<int32>& Triangles, TArray<int32>& MaterialIDs, TArray<int32>& Counts)
{
MaterialIDs.Reset(); Counts.Reset();
for (int32 tid : Triangles)
{
FIndex3i TriNbrs = Mesh.GetTriNeighbourTris(tid);
for (int32 j = 0; j < 3; ++j)
{
int32 NbrTriangleID = TriNbrs[j];
if ( Mesh.IsTriangle(NbrTriangleID) == false || Triangles.Contains(NbrTriangleID) )
{
continue;
}
int MatID = MaterialAttrib.GetValue(NbrTriangleID);
int32 Index = MaterialIDs.AddUnique(MatID);
if (Counts.Num() != MaterialIDs.Num())
{
Counts.Add(0);
Counts[Index]++;
}
}
}
};
// For each bevel-vertex-polygon, pick the nbr material ID that was most frequent.
// Terminator vertices are also handled this way, which is not ideal, should probably
// ignore the new 'edge' faces for the terminator vertex
for (FBevelVertex& Vertex : Vertices)
{
TArray<int32> NbrMaterialIDs, NbrMaterialIDCounts;
CountUniqueBorderMaterialIDs(Mesh, *MaterialIDs, Vertex.NewTriangles, NbrMaterialIDs, NbrMaterialIDCounts);
int32 SetMaterialID = SetConstantMaterialID;
if (NbrMaterialIDs.Num() > 0)
{
int32 MinIndex = 0;
for (int32 k = 1; k < NbrMaterialIDs.Num(); ++k)
{
if (NbrMaterialIDCounts[k] < NbrMaterialIDCounts[MinIndex])
{
MinIndex = k;
}
}
SetMaterialID = NbrMaterialIDs[MinIndex];
}
for (int32 tid : Vertex.NewTriangles)
{
MaterialIDs->SetValue(tid, SetMaterialID);
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink