Bugfixes

Author: Nebukam

Plugins/PCGExtendedToolkit/Source/PCGExtendedToolkit/Private/Graph/Edges/Refining/PCGExEdgeRefinePrimMST.cpp

@@ -56,7 +56,7 @@ void UPCGExEdgeRefinePrimMST::Process(
 			if (Score >= ScoredQueue->Scores[NeighborIndex]) { continue; }
 
 			ScoredQueue->Scores[NeighborIndex] = Score;
-			Parent[NeighborIndex] = AdjacencyHash;
+			Parent[NeighborIndex] = PCGEx::H64(CurrentNodeIndex, EdgeIndex);
 
 			ScoredQueue->Enqueue(NeighborIndex, Score);
 		}
@@ -66,6 +66,7 @@ void UPCGExEdgeRefinePrimMST::Process(
 	{
 		uint32 NeighborIndex;
 		uint32 EdgeIndex;
+		
 		PCGEx::H64(Parent[i], NeighborIndex, EdgeIndex);
 
 		if (NeighborIndex == i) { continue; }

Plugins/PCGExtendedToolkit/Source/PCGExtendedToolkit/Public/Geometry/PCGExGeoMesh.h

@@ -149,9 +149,9 @@ namespace PCGExGeo
 				const int32* BPtr = IndexedUniquePositions.Find(VB);
 				const int32* CPtr = IndexedUniquePositions.Find(VC);
 
-				const uint32 A = APtr ? *APtr : IndexedUniquePositions.FindOrAdd(VA, Idx++);
-				const uint32 B = BPtr ? *BPtr : IndexedUniquePositions.FindOrAdd(VB, Idx++);
-				const uint32 C = CPtr ? *CPtr : IndexedUniquePositions.FindOrAdd(VC, Idx++);
+				const uint32 A = APtr ? *APtr : IndexedUniquePositions.Add(VA, Idx++);
+				const uint32 B = BPtr ? *BPtr : IndexedUniquePositions.Add(VB, Idx++);
+				const uint32 C = CPtr ? *CPtr : IndexedUniquePositions.Add(VC, Idx++);
 
 				Edges.Add(PCGEx::H64U(A, B));
 				Edges.Add(PCGEx::H64U(B, C));
@@ -199,9 +199,9 @@ namespace PCGExGeo
 				const int32* BPtr = IndexedUniquePositions.Find(VB);
 				const int32* CPtr = IndexedUniquePositions.Find(VC);
 
-				const uint32 A = APtr ? *APtr : IndexedUniquePositions.FindOrAdd(VA, Idx++);
-				const uint32 B = BPtr ? *BPtr : IndexedUniquePositions.FindOrAdd(VB, Idx++);
-				const uint32 C = CPtr ? *CPtr : IndexedUniquePositions.FindOrAdd(VC, Idx++);
+				const uint32 A = APtr ? *APtr : IndexedUniquePositions.Add(VA, Idx++);
+				const uint32 B = BPtr ? *BPtr : IndexedUniquePositions.Add(VB, Idx++);
+				const uint32 C = CPtr ? *CPtr : IndexedUniquePositions.Add(VC, Idx++);
 
 				const uint64 AB = PCGEx::H64U(A, B);
 				const uint64 BC = PCGEx::H64U(B, C);
@@ -219,16 +219,18 @@ namespace PCGExGeo
 				const uint64* AdjacencyBCPtr = EdgeAdjacency.Find(BC);
 				const uint64* AdjacencyACPtr = EdgeAdjacency.Find(AC);
 
-				Triangles[TriangleIndex++] = FIntVector3(A, B, C);
+				Triangles[TriangleIndex] = FIntVector3(A, B, C);
 
-				if (AdjacencyABPtr) { EdgeAdjacency.Add(AB, PCGEx::NH64(TriangleIndex, PCGEx::H64B(*AdjacencyABPtr))); }
+				if (AdjacencyABPtr) { EdgeAdjacency.Add(AB, PCGEx::NH64(TriangleIndex, PCGEx::NH64B(*AdjacencyABPtr))); }
 				else { EdgeAdjacency.Add(AB, PCGEx::NH64(-1, TriangleIndex)); }
 
-				if (AdjacencyBCPtr) { EdgeAdjacency.Add(BC, PCGEx::NH64(TriangleIndex, PCGEx::H64B(*AdjacencyBCPtr))); }
+				if (AdjacencyBCPtr) { EdgeAdjacency.Add(BC, PCGEx::NH64(TriangleIndex, PCGEx::NH64B(*AdjacencyBCPtr))); }
 				else { EdgeAdjacency.Add(BC, PCGEx::NH64(-1, TriangleIndex)); }
 
-				if (AdjacencyACPtr) { EdgeAdjacency.Add(AC, PCGEx::NH64(TriangleIndex, PCGEx::H64B(*AdjacencyACPtr))); }
+				if (AdjacencyACPtr) { EdgeAdjacency.Add(AC, PCGEx::NH64(TriangleIndex, PCGEx::NH64B(*AdjacencyACPtr))); }
 				else { EdgeAdjacency.Add(AC, PCGEx::NH64(-1, TriangleIndex)); }
+
+				TriangleIndex++;
 			}
 
 			int32 ENum = EdgeAdjacency.Num();

Plugins/PCGExtendedToolkit/Source/PCGExtendedToolkit/Public/PCGEx.h

@@ -323,28 +323,17 @@ namespace PCGEx
 			       static_cast<uint64>(B) << 32 | A;
 	}
 
-	// Unsigned uint64 hash
-	FORCEINLINE static uint64 H64NOT(const uint64 Hash, const uint32 Not)
-	{
-		const uint32 A = static_cast<uint32>(Hash >> 32);
-		return A == Not ? static_cast<uint32>(Hash) : A;
-	}
-
-	// Unsigned uint64 hash
-	FORCEINLINE static uint64 NH64NOT(const uint64 Hash, const int32 Not)
-	{
-		const int32 A = static_cast<int32>(static_cast<uint32>(Hash >> 32)) - 1;
-		return A == Not ? static_cast<int32>(static_cast<uint32>(Hash)) - 1 : A;
-	}
-
 	// Signed uint64 hash
 	FORCEINLINE static uint64 H64(const uint32 A, const uint32 B) { return static_cast<uint64>(A) << 32 | B; }
-	FORCEINLINE static uint64 NH64(const uint32 A, const uint32 B) { return static_cast<uint64>(A + 1) << 32 | (B + 1); }
+	FORCEINLINE static uint64 NH64(const int32 A, const int32 B) { return H64(A + 1, B + 1); }
 
 	// Expand uint64 hash
 	FORCEINLINE static uint32 H64A(const uint64 Hash) { return static_cast<uint32>(Hash >> 32); }
 	FORCEINLINE static uint32 H64B(const uint64 Hash) { return static_cast<uint32>(Hash); }
 
+	FORCEINLINE static int32 NH64A(const uint64 Hash) { return static_cast<int32>(H64A(Hash)) - 1; }
+	FORCEINLINE static int32 NH64B(const uint64 Hash) { return static_cast<int32>(H64B(Hash)) - 1; }
+
 	FORCEINLINE static void H64(const uint64 Hash, uint32& A, uint32& B)
 	{
 		A = H64A(Hash);
@@ -353,8 +342,20 @@ namespace PCGEx
 
 	FORCEINLINE static void NH64(const uint64 Hash, int32& A, int32& B)
 	{
-		A = H64A(Hash) - 1;
-		B = H64B(Hash) - 1;
+		A = NH64A(Hash);
+		B = NH64B(Hash);
+	}
+
+	FORCEINLINE static uint64 H64NOT(const uint64 Hash, const uint32 Not)
+	{
+		const uint32 A = H64A(Hash);
+		return A == Not ? H64B(Hash) : A;
+	}
+
+	FORCEINLINE static int32 NH64NOT(const uint64 Hash, const int32 Not)
+	{
+		const int32 A = NH64A(Hash);
+		return A == Not ? NH64B(Hash) : A;
 	}
 
 	FORCEINLINE static uint64 H6416(const uint16 A, const uint16 B, const uint16 C, const uint16 D)