Axes fixes

Author: Nebukam

Source/PCGExtendedToolkit/Private/Data/PCGExPointIOMerger.cpp

@@ -6,7 +6,7 @@
 
 #include "Data/PCGExDataFilter.h"
 #include "Data/PCGExDataTag.h"
-#include "Paths/PCGExShiftPath.h"
+#include "Paths/PCGExPathShift.h"
 
 
 PCGExPointIOMerger::FIdentityRef::FIdentityRef()

Source/PCGExtendedToolkit/Private/Details/PCGExDetailsAxis.cpp

@@ -67,34 +67,66 @@ namespace PCGEx
 		const FVector& XAxis, const FVector& YAxis, const FVector& ZAxis,
 		int32& X, int32& Y, int32& Z, const bool bPermute)
 	{
-		const FVector QuatAxes[3] = { Quat.GetAxisX(), Quat.GetAxisY(), Quat.GetAxisZ() };
+		const FVector QA[3] = { Quat.GetAxisX(), Quat.GetAxisY(), Quat.GetAxisZ() };
 
-		auto FindBest = [&](const FVector& Ref)
+		double M[3][3];
+		for (int i = 0; i < 3; ++i)
 		{
-			const double DX = FMath::Abs(FVector::DotProduct(XAxis, Ref));
-			const double DY = FMath::Abs(FVector::DotProduct(YAxis, Ref));
-			const double DZ = FMath::Abs(FVector::DotProduct(ZAxis, Ref));
-			return (DX > DY && DX > DZ) ? 0 : (DY > DZ ? 1 : 2);
-		};
+			M[i][0] = FMath::Abs(FVector::DotProduct(QA[i], XAxis));
+			M[i][1] = FMath::Abs(FVector::DotProduct(QA[i], YAxis));
+			M[i][2] = FMath::Abs(FVector::DotProduct(QA[i], ZAxis));
+		}
+
+		// choose best X/Y/Z directly
+		int32 Best[3];
+		for (int i = 0; i < 3; ++i)
+		{
+			const double DX = M[i][0];
+			const double DY = M[i][1];
+			const double DZ = M[i][2];
+			Best[i] = (DX >= DY && DX >= DZ) ? 0 : ((DY >= DZ) ? 1 : 2);
+		}
 
-		X = FindBest(QuatAxes[0]);
-		Y = FindBest(QuatAxes[1]);
-		Z = FindBest(QuatAxes[2]);
+		if (!bPermute)
+		{
+			X = Best[0];
+			Y = Best[1];
+			Z = Best[2];
+			return;
+		}
 
-		if (bPermute)
+		// guaranteed permutation with constant-time deterministic resolution
+		static const int32 Permutations[6][3] =
 		{
-			const int OldX = X;
-			const int OldY = Y;
-			const int OldZ = Z;
+			{0,1,2}, {0,2,1},
+			{1,0,2}, {1,2,0},
+			{2,0,1}, {2,1,0}
+		};
+
+		int32 BestScore = -1;
+		const int32* BestPerm = Permutations[0];
 
-			uint8 Inv[3];
-			Inv[OldX] = 0;
-			Inv[OldY] = 1;
-			Inv[OldZ] = 2;
+		for (int p = 0; p < 6; ++p)
+		{
+			const int32* P = Permutations[p];
+			const double Score =
+				M[0][P[0]] +
+				M[1][P[1]] +
+				M[2][P[2]];
 
-			X = Inv[0];
-			Y = Inv[1];
-			Z = Inv[2];
+			if (Score > BestScore)
+			{
+				BestScore = Score;
+				BestPerm = P;
+			}
 		}
+
+		X = BestPerm[0];
+		Y = BestPerm[1];
+		Z = BestPerm[2];
+
+		check(X >= 0 && X <= 2);
+		check(Y >= 0 && Y <= 2);
+		check(Z >= 0 && Z <= 2);
 	}
 }

Source/PCGExtendedToolkit/Private/Graph/PCGExClusterCentrality.cpp

@@ -11,7 +11,6 @@
 #include "Graph/PCGExGraph.h"
 #include "Graph/Pathfinding/Heuristics/PCGExHeuristics.h"
 #include "Graph/Pathfinding/Search/PCGExScoredQueue.h"
-#include "Paths/PCGExShiftPath.h"
 
 #define LOCTEXT_NAMESPACE "PCGExClusterCentralityElement"
 #define PCGEX_NAMESPACE ClusterCentrality

Source/PCGExtendedToolkit/Private/Paths/PCGExResamplePath.cpp renamed to Source/PCGExtendedToolkit/Private/Paths/PCGExPathResample.cpp

@@ -1,7 +1,7 @@
 // Copyright 2025 Timothé Lapetite and contributors
 // Released under the MIT license https://opensource.org/license/MIT/
 
-#include "Paths/PCGExResamplePath.h"
+#include "Paths/PCGExPathResample.h"
 
 #include "PCGExRandom.h"
 #include "Data/PCGExPointIO.h"

Source/PCGExtendedToolkit/Private/Paths/PCGExShiftPath.cpp renamed to Source/PCGExtendedToolkit/Private/Paths/PCGExPathShift.cpp

@@ -1,7 +1,7 @@
 // Copyright 2025 Timothé Lapetite and contributors
 // Released under the MIT license https://opensource.org/license/MIT/
 
-#include "Paths/PCGExShiftPath.h"
+#include "Paths/PCGExPathShift.h"
 
 #include "Data/PCGExData.h"
 #include "Data/PCGExPointIO.h"

Source/PCGExtendedToolkit/Private/Paths/PCGExShrinkPath.cpp renamed to Source/PCGExtendedToolkit/Private/Paths/PCGExPathShrink.cpp

@@ -1,7 +1,7 @@
 // Copyright 2025 Timothé Lapetite and contributors
 // Released under the MIT license https://opensource.org/license/MIT/
 
-#include "Paths/PCGExShrinkPath.h"
+#include "Paths/PCGExPathShrink.h"
 
 #include "Data/PCGExAttributeHelpers.h"
 #include "Data/PCGExData.h"

Source/PCGExtendedToolkit/Private/Paths/PCGExPathSolidify.cpp

@@ -15,8 +15,8 @@ UPCGExPathSolidifySettings::UPCGExPathSolidifySettings(const FObjectInitializer&
 	: Super(ObjectInitializer)
 {
 	RotationMapping.Add(EPCGExAxisOrder::XYZ, EPCGExMakeRotAxis::X);
-	RotationMapping.Add(EPCGExAxisOrder::YZX, EPCGExMakeRotAxis::XY);
-	RotationMapping.Add(EPCGExAxisOrder::ZXY, EPCGExMakeRotAxis::Y);
+	RotationMapping.Add(EPCGExAxisOrder::YZX, EPCGExMakeRotAxis::Z);
+	RotationMapping.Add(EPCGExAxisOrder::ZXY, EPCGExMakeRotAxis::X);
 	RotationMapping.Add(EPCGExAxisOrder::YXZ, EPCGExMakeRotAxis::XY);
 	RotationMapping.Add(EPCGExAxisOrder::ZYX, EPCGExMakeRotAxis::XY);
 	RotationMapping.Add(EPCGExAxisOrder::XZY, EPCGExMakeRotAxis::X);
@@ -260,9 +260,9 @@ namespace PCGExPathSolidify
 		TPCGValueRange<FVector> BoundsMin = PointDataFacade->GetOut()->GetBoundsMinValueRange(false);
 		TPCGValueRange<FVector> BoundsMax = PointDataFacade->GetOut()->GetBoundsMaxValueRange(false);
 
-		int32 Main = 0;
-		int32 Sec = 0;
-		int32 Ter = 0;
+		int32 A = 0;
+		int32 B = 0;
+		int32 C = 0;
 
 		PCGEX_SCOPE_LOOP(Index)
 		{
@@ -295,10 +295,10 @@ namespace PCGExPathSolidify
 			const FQuat Quat = PCGEx::MakeRot(GetConstruction(Order, Index), XAxis, YAxis, ZAxis);
 
 			// Find primary / secondary / tertiary components
-			PCGEx::FindOrderMatch(Quat, RealXAxis, RealYAxis, RealZAxis, Main, Sec, Ter);
+			PCGEx::FindOrderMatch(Quat, RealXAxis, RealYAxis, RealZAxis, A, B, C);
 
 			const FVector QuatAxes[3] = {Quat.GetAxisX(), Quat.GetAxisY(), Quat.GetAxisZ()};
-			const bool bForwardFlipped = FVector::DotProduct(QuatAxes[Main], RealXAxis) < 0;
+			const bool bForwardFlipped = FVector::DotProduct(QuatAxes[A], RealXAxis) < 0;
 			double EdgeLerp = FMath::Clamp(SolidificationLerp->Read(Index), 0.0, 1.0);
 			//if (bForwardFlipped) { EdgeLerp = 1.0 - EdgeLerp; }
 
@@ -313,21 +313,21 @@ namespace PCGExPathSolidify
 			// Yey
 			const double EdgeLerpInv = 1.0 - EdgeLerp;
 
-			OutBoundsMin[Main] = (-Length * EdgeLerp) * InvScale[Main];
-			OutBoundsMax[Main] = (Length * EdgeLerpInv) * InvScale[Main];
+			OutBoundsMin[A] = (-Length * EdgeLerp) * InvScale[A];
+			OutBoundsMax[A] = (Length * EdgeLerpInv) * InvScale[A];
 
 			if (SecondaryRadius)
 			{
 				const double Rad = FMath::Abs(SecondaryRadius->Read(Index));
-				OutBoundsMin[Sec] = -Rad * InvScale[Sec];
-				OutBoundsMax[Sec] = Rad * InvScale[Sec];
+				OutBoundsMin[B] = -Rad * InvScale[B];
+				OutBoundsMax[B] = Rad * InvScale[B];
 			}
 
 			if (TertiaryRadius)
 			{
 				const double Rad = FMath::Abs(TertiaryRadius->Read(Index));
-				OutBoundsMin[Ter] = -Rad * InvScale[Ter];
-				OutBoundsMax[Ter] = Rad * InvScale[Ter];
+				OutBoundsMin[C] = -Rad * InvScale[C];
+				OutBoundsMax[C] = Rad * InvScale[C];
 			}
 		}
 	}

Source/PCGExtendedToolkit/Public/Paths/PCGExResamplePath.h renamed to Source/PCGExtendedToolkit/Public/Paths/PCGExPathResample.h

@@ -12,7 +12,7 @@
 
 #include "Shapes/PCGExShapes.h"
 
-#include "PCGExResamplePath.generated.h"
+#include "PCGExPathResample.generated.h"
 
 namespace PCGExPaths
 {

Source/PCGExtendedToolkit/Public/Paths/PCGExShiftPath.h renamed to Source/PCGExtendedToolkit/Public/Paths/PCGExPathShift.h

@@ -10,7 +10,7 @@
 #include "PCGExPaths.h"
 #include "Data/Blending/PCGExDataBlending.h"
 
-#include "PCGExShiftPath.generated.h"
+#include "PCGExPathShift.generated.h"
 
 namespace PCGExData
 {

Source/PCGExtendedToolkit/Public/Paths/PCGExShrinkPath.h renamed to Source/PCGExtendedToolkit/Public/Paths/PCGExPathShrink.h

@@ -10,7 +10,7 @@
 #include "Data/PCGExPointFilter.h"
 
 
-#include "PCGExShrinkPath.generated.h"
+#include "PCGExPathShrink.generated.h"
 
 UENUM()
 enum class EPCGExPathShrinkMode : uint8