Add mirror table library

MirrorAnimationSystem.uplugin

@@ -1,7 +1,7 @@
 {
 	"FileVersion": 3,
-	"Version": 1,
+	"Version": 2,
-	"VersionName": "2.0",
+	"VersionName": "3.0",
 	"FriendlyName": "Mirror Animation System",
 	"Description": "Incorporates functionalities that allow the mirroring of animations with their root motion at runtime, as well as inside the editor.",
 	"Category": "Animation",
@@ -10,27 +10,27 @@
 	"DocsURL": "https://github.com/Rexocrates/Mirror_Animation_System/blob/main/Mirror%20Animation%20System%20Documentation.pdf",
 	"MarketplaceURL": "com.epicgames.launcher://ue/marketplace/content/36b1fe6319794a25ab6dfffb82e1b29b",
 	"SupportURL": "https://github.com/Rexocrates/Mirror_Animation_System/issues",
-	"EngineVersion": "4.27.0",
+	"EngineVersion": "5.4.0",
-	"CanContainContent": false,
+	"CanContainContent": true,
 	"Installed": true,
 	"Modules": [
 		{
 			"Name": "MirrorAnimationSystem",
 			"Type": "Runtime",
 			"LoadingPhase": "PreDefault",
-			"WhitelistPlatforms": [ "Win64", "Win32", "PS4", "XboxOne", "Mac" ]
+			"WhitelistPlatforms": [ "Win64" ]
 		},
 		{
 			"Name": "MirrorAnimationSystemDev",
 			"Type": "DeveloperTool",
 			"LoadingPhase": "PreDefault",
-			"WhitelistPlatforms": [ "Win64", "Win32", "PS4", "XboxOne", "Mac" ]
+			"WhitelistPlatforms": [ "Win64" ]
 		},
 		{
 			"Name": "MirrorAnimationSystemEditor",
 			"Type": "Editor",
 			"LoadingPhase": "PreDefault",
-			"WhitelistPlatforms": [ "Win64", "Win32", "PS4", "XboxOne", "Mac" ]
+			"WhitelistPlatforms": [ "Win64" ]
 		}
 	]
 }

Source/MirrorAnimationSystem/Private/AnimNode_FullMirror.cpp

@@ -1,17 +1,17 @@
 // Copyright 2017-2021 Rexocrates. All Rights Reserved.
-#include "AnimNode_Mirror.h"
+#include "AnimNode_FullMirror.h"
 #include "MirrorAnimationSystem.h"
 
 //#include "AnimationRuntime.h"
 
-FAnimNode_Mirror::FAnimNode_Mirror()
+FAnimNode_FullMirror::FAnimNode_FullMirror()
 	: 
 	MirrorTable(NULL)
 {
 
 }
 
-void FAnimNode_Mirror::Initialize_AnyThread(const FAnimationInitializeContext & Context)
+void FAnimNode_FullMirror::Initialize_AnyThread(const FAnimationInitializeContext & Context)
 {
 	
 	FAnimNode_Base::Initialize_AnyThread(Context);
@@ -19,20 +19,20 @@ void FAnimNode_Mirror::Initialize_AnyThread(const FAnimationInitializeContext &
 	BasePose.Initialize(Context);
 }
 
-void FAnimNode_Mirror::CacheBones_AnyThread(const FAnimationCacheBonesContext & Context)
+void FAnimNode_FullMirror::CacheBones_AnyThread(const FAnimationCacheBonesContext & Context)
 {
 	
 	BasePose.CacheBones(Context);
 }
 
-void FAnimNode_Mirror::Update_AnyThread(const FAnimationUpdateContext & Context)
+void FAnimNode_FullMirror::Update_AnyThread(const FAnimationUpdateContext & Context)
 {
 	GetEvaluateGraphExposedInputs().Execute(Context);
 	BasePose.Update(Context);
 }
 
 
-void FAnimNode_Mirror::Evaluate_AnyThread(FPoseContext & Output)
+void FAnimNode_FullMirror::Evaluate_AnyThread(FPoseContext & Output)
 {
 	// Evaluate the input
 
@@ -143,7 +143,7 @@ void FAnimNode_Mirror::Evaluate_AnyThread(FPoseContext & Output)
 }
 
 
-void FAnimNode_Mirror::GatherDebugData(FNodeDebugData & DebugData)
+void FAnimNode_FullMirror::GatherDebugData(FNodeDebugData & DebugData)
 {
 	FString DebugLine = DebugData.GetNodeName(this);
 

Source/MirrorAnimationSystem/Private/AnimNode_FullMirrorCS.cpp

@@ -1,5 +1,5 @@
 // Copyright 2017-2021 Rexocrates. All Rights Reserved.
-#include "AnimNode_MirrorCS.h"
+#include "AnimNode_FullMirrorCS.h"
 #include "MirrorAnimationSystem.h"
 
 #include "AnimationRuntime.h"
@@ -8,16 +8,16 @@
 #include "MASUtils.h"
 
 /////////////////////////////////////////////////////
-// FAnimNode_MirrorCS
+// FAnimNode_FullMirrorCS
 
-FAnimNode_MirrorCS::~FAnimNode_MirrorCS()
+FAnimNode_FullMirrorCS::~FAnimNode_FullMirrorCS()
 {
 	TwinPairs.Empty();
 	NonTwinIDs.Empty();
 	NonTwinFlipAxis.Empty();
 }
 
-FAnimNode_MirrorCS::FAnimNode_MirrorCS() :
+FAnimNode_FullMirrorCS::FAnimNode_FullMirrorCS() :
 CompletlySymmetrical(false)
 {
 	TwinPairs.Empty();
@@ -25,12 +25,12 @@ CompletlySymmetrical(false)
 	NonTwinFlipAxis.Empty();
 }
 
-void FAnimNode_MirrorCS::GatherDebugData(FNodeDebugData& DebugData)
+void FAnimNode_FullMirrorCS::GatherDebugData(FNodeDebugData& DebugData)
 {
 	Super::GatherDebugData(DebugData);
 }
 
-void FAnimNode_MirrorCS::EvaluateSkeletalControl_AnyThread(FComponentSpacePoseContext& Output, TArray<FBoneTransform>& OutBoneTransforms)
+void FAnimNode_FullMirrorCS::EvaluateSkeletalControl_AnyThread(FComponentSpacePoseContext& Output, TArray<FBoneTransform>& OutBoneTransforms)
 {
 	check(OutBoneTransforms.Num() == 0);
 
@@ -88,7 +88,7 @@ void FAnimNode_MirrorCS::EvaluateSkeletalControl_AnyThread(FComponentSpacePoseCo
 			
 		
 
-			// twin 1º
+			// twin 1<EFBFBD>
 			{
 				const FTransform MirrRef = RefTM * TwinMirrorModTM;
 				const FTransform Delta = TwinRefTM.GetRelativeTransform(MirrRef);
@@ -126,7 +126,7 @@ void FAnimNode_MirrorCS::EvaluateSkeletalControl_AnyThread(FComponentSpacePoseCo
 				NewCSTMs[TwinBoneIndex] = MirrTM;
 			}
 
-			// twin 2º
+			// twin 2<EFBFBD>
 			{
 				FTransform TwinMirrRef = TwinRefTM * TwinMirrorModTM;
 				const FQuat TwinDeltaQuat = TwinMirrRef.GetRotation().Inverse() * RefTM.GetRotation();
@@ -171,25 +171,25 @@ void FAnimNode_MirrorCS::EvaluateSkeletalControl_AnyThread(FComponentSpacePoseCo
 	}
 }
 
-bool FAnimNode_MirrorCS::IsValidToEvaluate(const USkeleton* Skeleton, const FBoneContainer& RequiredBones)
+bool FAnimNode_FullMirrorCS::IsValidToEvaluate(const USkeleton* Skeleton, const FBoneContainer& RequiredBones)
 {
 	return true;
 }
 
-void FAnimNode_MirrorCS::InitializeBoneReferences(const FBoneContainer& RequiredBones)
+void FAnimNode_FullMirrorCS::InitializeBoneReferences(const FBoneContainer& RequiredBones)
 {
 	Super::InitializeBoneReferences(RequiredBones);
 
 	SetMirrorDataIfDirty(RequiredBones.GetReferenceSkeleton());
 }
 
-void FAnimNode_MirrorCS::Initialize_AnyThread(const FAnimationInitializeContext& Context)
+void FAnimNode_FullMirrorCS::Initialize_AnyThread(const FAnimationInitializeContext& Context)
 {
 	Super::Initialize_AnyThread(Context);
 }
 
 
-void FAnimNode_MirrorCS::SetMirrorDataIfDirty(const FReferenceSkeleton& RefSkeleton)
+void FAnimNode_FullMirrorCS::SetMirrorDataIfDirty(const FReferenceSkeleton& RefSkeleton)
 {
 	if (RefSkeleton.GetNum() == LastBoneNum) return;
 

Source/MirrorAnimationSystem/Private/ExtCharacterMovementComponent.cpp

@@ -243,12 +243,12 @@ void UExtCharacterMovementComponent::PerformMovement(float DeltaSeconds)
 						FTransform TmpRootMootTr = RootMotionParams.GetRootMotionTransform();
 						TmpRootMootTr.Mirror(MirrorAxis, FlipAxis);
 						TmpRootMootTr.SetScale3D(TmpRootMootTr.GetScale3D().GetAbs());
-						RootMotionParams.Set(ConvertLocalRootMotionToWorld(TmpRootMootTr));
+						RootMotionParams.Set(ConvertLocalRootMotionToWorld(TmpRootMootTr,DeltaSeconds));
 					}
 					else
 					{
 						// Convert Local Space Root Motion to world space. Do it right before used by physics to make sure we use up to date transforms, as translation is relative to rotation.
-						RootMotionParams.Set(ConvertLocalRootMotionToWorld(RootMotionParams.GetRootMotionTransform()));
+						RootMotionParams.Set(ConvertLocalRootMotionToWorld(RootMotionParams.GetRootMotionTransform(),DeltaSeconds));
 					}
 				}
 
@@ -320,7 +320,7 @@ void UExtCharacterMovementComponent::PerformMovement(float DeltaSeconds)
 		// Update character state based on change from movement
 		UpdateCharacterStateAfterMovement(DeltaSeconds);
 
-		if ((bAllowPhysicsRotationDuringAnimRootMotion || !HasAnimRootMotion()) && !CharacterOwner->IsMatineeControlled())
+		if ((bAllowPhysicsRotationDuringAnimRootMotion || !HasAnimRootMotion()) ) //@TODO: check if not owned by Levelsequence
 		{
 			PhysicsRotation(DeltaSeconds);
 		}

Source/MirrorAnimationSystem/Public/AnimNode_FullMirror.h

@@ -4,14 +4,14 @@
 #include "Animation/AnimNodeBase.h"
 #include "Animation/AnimInstanceProxy.h"
 #include "MirrorTable.h"
-#include "AnimNode_Mirror.generated.h"
+#include "AnimNode_FullMirror.generated.h"
 /**
 *
 */
 /*Runtime code for the AnimGraph Node Mirror Pose, 
 takes in a pose in local space and Mirrors each bone according to a Mirror Table*/
 USTRUCT(BlueprintInternalUseOnly)
-struct MIRRORANIMATIONSYSTEM_API FAnimNode_Mirror : public FAnimNode_Base
+struct MIRRORANIMATIONSYSTEM_API FAnimNode_FullMirror : public FAnimNode_Base
 {
 	GENERATED_BODY()
 
@@ -22,7 +22,7 @@ struct MIRRORANIMATIONSYSTEM_API FAnimNode_Mirror : public FAnimNode_Base
 		UMirrorTable* MirrorTable;
 public:
 
-	FAnimNode_Mirror();
+	FAnimNode_FullMirror();
 
 	// FAnimNode_Base interface
 	virtual void Initialize_AnyThread(const FAnimationInitializeContext& Context) override;

Source/MirrorAnimationSystem/Public/AnimNode_FullMirrorCS.h

@@ -10,12 +10,12 @@
 
 #include "MirrorTable.h"
 
-#include "AnimNode_MirrorCS.generated.h"
+#include "AnimNode_FullMirrorCS.generated.h"
 
 
 // Component Space version of the Mirror Pose node.
 USTRUCT(BlueprintInternalUseOnly)
-struct MIRRORANIMATIONSYSTEM_API FAnimNode_MirrorCS : public FAnimNode_SkeletalControlBase
+struct MIRRORANIMATIONSYSTEM_API FAnimNode_FullMirrorCS : public FAnimNode_SkeletalControlBase
 {
 	GENERATED_BODY()
 
@@ -29,8 +29,8 @@ struct MIRRORANIMATIONSYSTEM_API FAnimNode_MirrorCS : public FAnimNode_SkeletalC
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = MirrorBones)
 	FString Substring_B;
 
-	~FAnimNode_MirrorCS();
+	~FAnimNode_FullMirrorCS();
-	FAnimNode_MirrorCS();
+	FAnimNode_FullMirrorCS();
 
 	// FAnimNode_Base interface
 	virtual void GatherDebugData(FNodeDebugData& DebugData) override;

Source/MirrorAnimationSystem/Public/MirrorTable.h

@@ -18,22 +18,22 @@ struct MIRRORANIMATIONSYSTEM_API FMirrorBone
 	FName BoneName;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "MirrorAnimation")
-		TEnumAsByte<EAxis::Type> MirrorAxis;
+	TEnumAsByte<EAxis::Type> MirrorAxis = EAxis::None;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "MirrorAnimation")
-		TEnumAsByte<EAxis::Type> FlipAxis;
+	TEnumAsByte<EAxis::Type> FlipAxis = EAxis::None;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "MirrorAnimation")
-		FRotator RotationOffset;
+	FRotator RotationOffset = FRotator::ZeroRotator;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "MirrorAnimation")
-		bool IsTwinBone;
+	bool IsTwinBone = false;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "MirrorAnimation")
 	FName TwinBoneName;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "MirrorAnimation")
-		bool MirrorTranslation;
+	bool MirrorTranslation = false;
 };
 
 /*Data asset class that holds the MirrorBone's parameters for an entire skeleton, 
@@ -42,8 +42,8 @@ UCLASS(BlueprintType)
 class MIRRORANIMATIONSYSTEM_API UMirrorTable : public UDataAsset
 {
 	GENERATED_BODY()
+
 public:
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "MirrorBoneSettings")
-		TArray <FMirrorBone> MirrorBones;
+	TArray<FMirrorBone> MirrorBones;
-	
 };

Source/MirrorAnimationSystemDev/Private/MASFunctionLibrary.cpp

@@ -11,8 +11,7 @@
 
 #if WITH_EDITOR
 #include "AssetToolsModule.h"
-#include "AssetRegistryModule.h"
+#include "AssetRegistry/AssetRegistryModule.h"
-#include "Toolkits/AssetEditorManager.h"
 
 #include "Framework/Notifications/NotificationManager.h"
 #include "Widgets/Notifications/SNotificationList.h"
@@ -153,8 +152,13 @@ void UMASFunctionLibrary::CreateMirrorSequenceFromAnimSequence(UAnimSequence* Mi
 		int NumMirrorBones = MirrorTable->MirrorBones.Num();
 
 		int NumFrames = MirrorSequence->GetNumberOfFrames();
-		TArray<FRawAnimSequenceTrack> SourceRawAnimDatas = MirrorSequence->GetRawAnimationData();
+		IAnimationDataController& MirrorSequenceController = MirrorSequence->GetController();
-		const auto& TrackNames = MirrorSequence->GetAnimationTrackNames();
+		TArray<FBoneAnimationTrack> SourceBoneAnimData = MirrorSequenceController.GetModel()->GetBoneAnimationTracks();
+		/************* SourceRawAnimDatas should be replaced by SourceBoneAnimData ************/
+		// TArray<FRawAnimSequenceTrack> SourceRawAnimDatas = MirrorSequence->GetRawAnimationData();
+		
+		TArray<FName> TrackNames;
+		MirrorSequenceController.GetModel()->GetBoneTrackNames(TrackNames);
 
 		for (int i = 0; i < NumMirrorBones; i++)
 		{
@@ -180,66 +184,67 @@ void UMASFunctionLibrary::CreateMirrorSequenceFromAnimSequence(UAnimSequence* Mi
 					continue;
 				}
 
-				TArray <FVector> MirrorPosKeys;
+				TArray <FVector3f> MirrorPosKeys;
-				TArray <FQuat> MirrorRotKeys;
+				TArray <FQuat4f> MirrorRotKeys;
-				TArray <FVector> MirrorScaleKeys;
+				TArray <FVector3f> MirrorScaleKeys;
 
-				TArray <FVector> TwinMirrorPosKeys;
+				TArray <FVector3f> TwinMirrorPosKeys;
-				TArray <FQuat> TwinMirrorRotKeys;
+				TArray <FQuat4f> TwinMirrorRotKeys;
-				TArray <FVector> TwinMirrorScaleKeys;
+				TArray <FVector3f> TwinMirrorScaleKeys;
 
 				// Original Bone
 				if (TrackIndex != INDEX_NONE)
 				{
-					auto& MirroredRawTrack = SourceRawAnimDatas[TrackIndex];
+					auto& MirroredRawTrack = SourceBoneAnimData[TrackIndex];
 
 					for (int u = 0; u < NumFrames; u++)
 					{
-						FTransform MirrorTM;
+						FTransform3f MirrorTM;
 
 						bool bSetPos = false;
 						bool bSetRot = false;
 						bool bSetScale = false;
 
-						if (MirroredRawTrack.PosKeys.IsValidIndex(u))
+						if (MirroredRawTrack.InternalTrackData.PosKeys.IsValidIndex(u))
 						{
-							MirrorTM.SetTranslation(MirroredRawTrack.PosKeys[u]);
+							MirrorTM.SetTranslation(MirroredRawTrack.InternalTrackData.PosKeys[u]);
 							bSetPos = true;
 						}
-						if (MirroredRawTrack.RotKeys.IsValidIndex(u))
+						if (MirroredRawTrack.InternalTrackData.RotKeys.IsValidIndex(u))
 						{
-							MirrorTM.SetRotation(MirroredRawTrack.RotKeys[u]);
+							MirrorTM.SetRotation(MirroredRawTrack.InternalTrackData.RotKeys[u]);
 							bSetRot = true;
 						}
-						if (MirroredRawTrack.ScaleKeys.IsValidIndex(u))
+						if (MirroredRawTrack.InternalTrackData.ScaleKeys.IsValidIndex(u))
 						{
-							MirrorTM.SetScale3D(MirroredRawTrack.ScaleKeys[u]);
+							MirrorTM.SetScale3D(MirroredRawTrack.InternalTrackData.ScaleKeys[u]);
 							bSetScale = true;
 						}
 
 						MirrorTM.Mirror(CurrentBone.MirrorAxis, CurrentBone.FlipAxis);
 						
-						FRotator BoneNewRotation = MirrorTM.Rotator();
+						
+						FRotator3f BoneNewRotation = MirrorTM.Rotator(); // quaternion to rotator
 
 						BoneNewRotation.Yaw += CurrentBone.RotationOffset.Yaw;
 						BoneNewRotation.Roll += CurrentBone.RotationOffset.Roll;
 						BoneNewRotation.Pitch += CurrentBone.RotationOffset.Pitch;
 
-						MirrorTM.SetRotation(FQuat(BoneNewRotation));
+						MirrorTM.SetRotation(BoneNewRotation.Quaternion());
 						MirrorTM.SetScale3D(MirrorTM.GetScale3D().GetAbs());
 						MirrorTM.NormalizeRotation();
 
 						if (bSetPos)
 						{
-							MirrorPosKeys.Add(MirrorTM.GetTranslation());
+							MirrorPosKeys.Add(FVector3f(MirrorTM.GetTranslation()));
 						}
 						if (bSetRot)
 						{
-							MirrorRotKeys.Add(MirrorTM.GetRotation());
+							MirrorRotKeys.Add(FQuat4f(MirrorTM.GetRotation()));
 						}
 						if (bSetScale)
 						{
-							MirrorScaleKeys.Add(MirrorTM.GetScale3D());
+							MirrorScaleKeys.Add(FVector3f(MirrorTM.GetScale3D()));
 						}
 					}
 				}
@@ -259,62 +264,62 @@ void UMASFunctionLibrary::CreateMirrorSequenceFromAnimSequence(UAnimSequence* Mi
 					RefTM.SetScale3D(RefTM.GetScale3D().GetAbs());
 					RefTM.NormalizeRotation();
 
-					MirrorPosKeys.Add(RefTM.GetTranslation());
+					MirrorPosKeys.Add(FVector3f(RefTM.GetTranslation()));
-					MirrorRotKeys.Add(RefTM.GetRotation());
+					MirrorRotKeys.Add(FQuat4f(RefTM.GetRotation()));
 				}
 
 				// Twin Bone
 				if (TwinTrackIndex != INDEX_NONE)
 				{
-					auto& TwinMirroredRawTrack = SourceRawAnimDatas[TwinTrackIndex];
+					auto& TwinMirroredRawTrack = SourceBoneAnimData[TwinTrackIndex];
 
 					for (int u = 0; u < NumFrames; u++)
 					{
-						FTransform TwinMirrorTM;
+						FTransform3f TwinMirrorTM;
 
 						bool TwinbSetPos = false;
 						bool TwinbSetRot = false;
 						bool TwinbSetScale = false;
 
-						if (TwinMirroredRawTrack.PosKeys.IsValidIndex(u))
+						if (TwinMirroredRawTrack.InternalTrackData.PosKeys.IsValidIndex(u))
 						{
-							TwinMirrorTM.SetTranslation(TwinMirroredRawTrack.PosKeys[u]);
+							TwinMirrorTM.SetTranslation(TwinMirroredRawTrack.InternalTrackData.PosKeys[u]);
 							TwinbSetPos = true;
 						}
-						if (TwinMirroredRawTrack.RotKeys.IsValidIndex(u))
+						if (TwinMirroredRawTrack.InternalTrackData.RotKeys.IsValidIndex(u))
 						{
-							TwinMirrorTM.SetRotation(TwinMirroredRawTrack.RotKeys[u]);
+							TwinMirrorTM.SetRotation(TwinMirroredRawTrack.InternalTrackData.RotKeys[u]);
 							TwinbSetRot = true;
 						}
-						if (TwinMirroredRawTrack.ScaleKeys.IsValidIndex(u))
+						if (TwinMirroredRawTrack.InternalTrackData.ScaleKeys.IsValidIndex(u))
 						{
-							TwinMirrorTM.SetScale3D(TwinMirroredRawTrack.ScaleKeys[u]);
+							TwinMirrorTM.SetScale3D(TwinMirroredRawTrack.InternalTrackData.ScaleKeys[u]);
 							TwinbSetScale = true;
 						}
 
 						TwinMirrorTM.Mirror(CurrentBone.MirrorAxis, CurrentBone.FlipAxis);
 
-						FRotator TwinBoneNewRotation = TwinMirrorTM.Rotator();
+						FRotator3f TwinBoneNewRotation = TwinMirrorTM.Rotator();
 
 						TwinBoneNewRotation.Yaw += CurrentBone.RotationOffset.Yaw;
 						TwinBoneNewRotation.Roll += CurrentBone.RotationOffset.Roll;
 						TwinBoneNewRotation.Pitch += CurrentBone.RotationOffset.Pitch;
 
-						TwinMirrorTM.SetRotation(FQuat(TwinBoneNewRotation));
+						TwinMirrorTM.SetRotation(TwinBoneNewRotation.Quaternion());
 						TwinMirrorTM.SetScale3D(TwinMirrorTM.GetScale3D().GetAbs());
 						TwinMirrorTM.NormalizeRotation();
 
 						if (TwinbSetPos)
 						{
-							TwinMirrorPosKeys.Add(TwinMirrorTM.GetTranslation());
+							TwinMirrorPosKeys.Add(FVector3f(TwinMirrorTM.GetTranslation()));
 						}
 						if (TwinbSetRot)
 						{
-							TwinMirrorRotKeys.Add(TwinMirrorTM.GetRotation());
+							TwinMirrorRotKeys.Add(FQuat4f(TwinMirrorTM.GetRotation()));
 						}
 						if (TwinbSetScale)
 						{
-							TwinMirrorScaleKeys.Add(TwinMirrorTM.GetScale3D());
+							TwinMirrorScaleKeys.Add(FVector3f(TwinMirrorTM.GetScale3D()));
 						}
 					}
 				}
@@ -334,8 +339,8 @@ void UMASFunctionLibrary::CreateMirrorSequenceFromAnimSequence(UAnimSequence* Mi
 					RefTM.SetScale3D(RefTM.GetScale3D().GetAbs());
 					RefTM.NormalizeRotation();
 
-					TwinMirrorPosKeys.Add(RefTM.GetTranslation());
+					TwinMirrorPosKeys.Add(FVector3f(RefTM.GetTranslation()));
-					TwinMirrorRotKeys.Add(RefTM.GetRotation());
+					TwinMirrorRotKeys.Add(FQuat4f(RefTM.GetRotation()));
 				}
 
 				// Original Bone -> Twin Bone
@@ -346,7 +351,9 @@ void UMASFunctionLibrary::CreateMirrorSequenceFromAnimSequence(UAnimSequence* Mi
 					NewTrack.RotKeys = MirrorRotKeys;
 					NewTrack.ScaleKeys = MirrorScaleKeys;
 
-					MirrorSequence->AddNewRawTrack(CurrentBone.TwinBoneName, &NewTrack);
+					//MirrorSequence->AddNewRawTrack(CurrentBone.TwinBoneName, &NewTrack);
+					MirrorSequenceController.AddBoneTrack(CurrentBone.TwinBoneName);
+					MirrorSequenceController.SetBoneTrackKeys(CurrentBone.BoneName,NewTrack.PosKeys,NewTrack.RotKeys,NewTrack.ScaleKeys);
 				}
 
 				// Twin Bone -> Original Bone
@@ -357,7 +364,8 @@ void UMASFunctionLibrary::CreateMirrorSequenceFromAnimSequence(UAnimSequence* Mi
 					NewTrack.RotKeys = TwinMirrorRotKeys;
 					NewTrack.ScaleKeys = TwinMirrorScaleKeys;
 
-					MirrorSequence->AddNewRawTrack(CurrentBone.BoneName, &NewTrack);
+					MirrorSequenceController.AddBoneTrack(CurrentBone.BoneName);
+					MirrorSequenceController.SetBoneTrackKeys(CurrentBone.BoneName,NewTrack.PosKeys,NewTrack.RotKeys,NewTrack.ScaleKeys);
 				}
 			}
 			else
@@ -369,47 +377,47 @@ void UMASFunctionLibrary::CreateMirrorSequenceFromAnimSequence(UAnimSequence* Mi
 					continue;
 				}
 
-				FRawAnimSequenceTrack MirroredRawTrack = SourceRawAnimDatas[TrackIndex];
+				FBoneAnimationTrack MirroredRawTrack = SourceBoneAnimData[TrackIndex];
 
 				//MirrorAllFrames
-				TArray <FVector> MirrorPosKeys;
+				TArray <FVector3f> MirrorPosKeys;
-				TArray <FQuat> MirrorRotKeys;
+				TArray <FQuat4f> MirrorRotKeys;
-				TArray <FVector> MirrorScaleKeys;
+				TArray <FVector3f> MirrorScaleKeys;
 
 				for (int u = 0; u < NumFrames; u++)
 				{
 					//Mirror Transform
-					FTransform MirrorTM;
+					FTransform3f MirrorTM;
 
 					bool bSetPos = false;
 					bool bSetRot = false;
 					bool bSetScale = false;
 
-					if (MirroredRawTrack.PosKeys.IsValidIndex(u))
+					if (MirroredRawTrack.InternalTrackData.PosKeys.IsValidIndex(u))
 					{
-						MirrorTM.SetTranslation(MirroredRawTrack.PosKeys[u]);
+						MirrorTM.SetTranslation(MirroredRawTrack.InternalTrackData.PosKeys[u]);
 						bSetPos = true;
 					}
-					if (MirroredRawTrack.RotKeys.IsValidIndex(u))
+					if (MirroredRawTrack.InternalTrackData.RotKeys.IsValidIndex(u))
 					{
-						MirrorTM.SetRotation(MirroredRawTrack.RotKeys[u]);
+						MirrorTM.SetRotation(MirroredRawTrack.InternalTrackData.RotKeys[u]);
 						bSetRot = true;
 					}
-					if (MirroredRawTrack.ScaleKeys.IsValidIndex(u))
+					if (MirroredRawTrack.InternalTrackData.ScaleKeys.IsValidIndex(u))
 					{
-						MirrorTM.SetScale3D(MirroredRawTrack.ScaleKeys[u]);
+						MirrorTM.SetScale3D(MirroredRawTrack.InternalTrackData.ScaleKeys[u]);
 						bSetScale = true;
 					}
 
 					MirrorTM.Mirror(CurrentBone.MirrorAxis, CurrentBone.FlipAxis);
 
-					FRotator BoneNewRotation = MirrorTM.Rotator();
+					FRotator3f BoneNewRotation = MirrorTM.Rotator();
 
 					BoneNewRotation.Yaw += CurrentBone.RotationOffset.Yaw;
 					BoneNewRotation.Roll += CurrentBone.RotationOffset.Roll;
 					BoneNewRotation.Pitch += CurrentBone.RotationOffset.Pitch;
 
-					MirrorTM.SetRotation(FQuat(BoneNewRotation));
+					MirrorTM.SetRotation(BoneNewRotation.Quaternion());
 					//MirrorTM.NormalizeRotation();
 					MirrorTM.SetScale3D(MirrorTM.GetScale3D().GetAbs());
 
@@ -432,44 +440,43 @@ void UMASFunctionLibrary::CreateMirrorSequenceFromAnimSequence(UAnimSequence* Mi
 					/////////////////////////////////
 				}
 
-				MirroredRawTrack.PosKeys = MirrorPosKeys;
+				MirroredRawTrack.InternalTrackData.PosKeys = MirrorPosKeys;
-				MirroredRawTrack.RotKeys = MirrorRotKeys;
+				MirroredRawTrack.InternalTrackData.RotKeys = MirrorRotKeys;
-				MirroredRawTrack.ScaleKeys = MirrorScaleKeys;
+				MirroredRawTrack.InternalTrackData.ScaleKeys = MirrorScaleKeys;
 
 				//Finally Setting it in the AnimSequence
 
-				MirrorSequence->AddNewRawTrack(CurrentBone.BoneName, &MirroredRawTrack);
+				//MirrorSequenceController.AddBoneTrack(CurrentBone.BoneName, &MirroredRawTrack);
+				MirrorSequenceController.AddBoneCurve(CurrentBone.BoneName);
+				MirrorSequenceController.SetBoneTrackKeys(CurrentBone.BoneName,MirroredRawTrack.InternalTrackData.PosKeys,MirroredRawTrack.InternalTrackData.RotKeys,MirroredRawTrack.InternalTrackData.ScaleKeys);
 			}
 		}
-		MirrorSequence->ClearBakedTransformData();
+		//MirrorSequence->ClearBakedTransformData();
-		MirrorSequence->RawCurveData.TransformCurves.Empty();
+		MirrorSequenceController.RemoveAllCurvesOfType(ERawCurveTrackTypes::RCT_Transform);
-		MirrorSequence->bNeedsRebake = false;
-		MirrorSequence->MarkRawDataAsModified();
-		MirrorSequence->OnRawDataChanged();
 		MirrorSequence->MarkPackageDirty();
 	}
 }
 
 
-static FTransform GetAnimBoneTM(UAnimSequence* AnimSeq, const int32 BoneTreeIndex, const float AnimTime)
+static FTransform3f GetAnimBoneTM(UAnimSequence* AnimSeq, const int32 BoneTreeIndex, const float AnimTime)
 {
 	USkeleton* Skeleton = AnimSeq->GetSkeleton();
 	//int32 BoneTreeIndex = Skeleton->GetSkeletonBoneIndexFromMeshBoneIndex(SkelMesh, BoneTreeIndex);
 	int32 BoneTrackIndex = Skeleton->GetRawAnimationTrackIndex(BoneTreeIndex, AnimSeq);
 	if (BoneTrackIndex == INDEX_NONE)
 	{
-		return Skeleton->GetReferenceSkeleton().GetRefBonePose()[BoneTreeIndex];
+		return FTransform3f(Skeleton->GetReferenceSkeleton().GetRefBonePose()[BoneTreeIndex]);
 	}
 	FTransform BoneTM = FTransform::Identity;
 	AnimSeq->GetBoneTransform(BoneTM, BoneTrackIndex, AnimTime, true);
-	return BoneTM;
+	return FTransform3f(BoneTM);
 }
 
-static FTransform GetAnimBoneCSTM(UAnimSequence* AnimSeq, const int32 BoneTreeIndex, const float AnimTime)
+static FTransform3f GetAnimBoneCSTM(UAnimSequence* AnimSeq, const int32 BoneTreeIndex, const float AnimTime)
 {
 	USkeleton* Skeleton = AnimSeq->GetSkeleton();
 	const auto& RefSkeleton = Skeleton->GetReferenceSkeleton();
-	FTransform BoneTMWS = GetAnimBoneTM(AnimSeq, BoneTreeIndex, AnimTime);
+	FTransform3f BoneTMWS = GetAnimBoneTM(AnimSeq, BoneTreeIndex, AnimTime);
 	int32 CurrBone = BoneTreeIndex;
 	while (true)
 	{
@@ -493,15 +500,16 @@ MIRRORANIMATIONSYSTEMDEV_API void UMASFunctionLibrary::CreateMirrorSequenceFromA
 	const FString Substring_B, 
 	const bool Symmetrical)
 {
-	const int32 NumFrames = MirrorSequence->GetRawNumberOfFrames();
+	IAnimationDataController& Controller = MirrorSequence->GetController();
-	const float DT = MirrorSequence->SequenceLength / NumFrames;
+	const int32 NumFrames = Controller.GetModel()->GetNumberOfFrames();
+	const float DT = MirrorSequence->GetPlayLength() / NumFrames;
 
 	USkeleton* Skeleton = MirrorSequence->GetSkeleton();
 	const auto& RefSkeleton = Skeleton->GetReferenceSkeleton();
 
 	
 	
-	TArray <bool> Already; Already.SetNumZeroed(Skeleton->GetBoneTree().Num());
+	TArray <bool> Already; Already.SetNumZeroed(Skeleton->GetReferenceSkeleton().GetRawBoneNum());
 
 	TArray<FIntPoint> TwinPairs;
 	TArray<int32> NonTwinIDs;
@@ -510,7 +518,7 @@ MIRRORANIMATIONSYSTEMDEV_API void UMASFunctionLibrary::CreateMirrorSequenceFromA
 
 	const bool DeltaStep = !Symmetrical;
 
-	FVector TwinMirrorScale = FVector(1.f);
+	FVector3f TwinMirrorScale = FVector3f(1.f);
 	FVector TargetAxis = FVector::ZeroVector;
 
 	check(MirrorAxis != EAxis::None);
@@ -518,7 +526,7 @@ MIRRORANIMATIONSYSTEMDEV_API void UMASFunctionLibrary::CreateMirrorSequenceFromA
 		TwinMirrorScale[MirrorAxis - 1] = -1.f;
 		TargetAxis[MirrorAxis - 1] = 1.f;
 	}
-	FTransform TwinMirrorModTM(FQuat::Identity, FVector::ZeroVector, TwinMirrorScale);
+	FTransform3f TwinMirrorModTM(FQuat4f::Identity, FVector3f::ZeroVector, TwinMirrorScale);
 
 
 	TMap<int32, FRawAnimSequenceTrack> BoneTracks;
@@ -530,7 +538,7 @@ MIRRORANIMATIONSYSTEMDEV_API void UMASFunctionLibrary::CreateMirrorSequenceFromA
 
 	for (int32 j = 0; j < NumFrames; j++)
 	{
-		TArray <FTransform> NewCSTMs; NewCSTMs.SetNum(RefSkeleton.GetNum());
+		TArray <FTransform3f> NewCSTMs; NewCSTMs.SetNum(RefSkeleton.GetNum());
 
 		for (int32 i = 0; i < NonTwinIDs.Num(); i++)
 		{
@@ -542,17 +550,17 @@ MIRRORANIMATIONSYSTEMDEV_API void UMASFunctionLibrary::CreateMirrorSequenceFromA
 				const int32 ParentIndex = RefSkeleton.GetParentIndex(BoneTreeIndex);
 				if (ParentIndex != INDEX_NONE)
 				{
-					NewCSTMs[BoneTreeIndex] = RefSkeleton.GetRefBonePose()[BoneTreeIndex] * NewCSTMs[ParentIndex];
+					NewCSTMs[BoneTreeIndex] = FTransform3f(RefSkeleton.GetRefBonePose()[BoneTreeIndex]) * NewCSTMs[ParentIndex];
 				}
 				else
 				{
-					NewCSTMs[BoneTreeIndex] = RefSkeleton.GetRefBonePose()[BoneTreeIndex];
+					NewCSTMs[BoneTreeIndex] = FTransform3f(RefSkeleton.GetRefBonePose()[BoneTreeIndex]);
 				}
 
 				continue;
 			}
 
-			FTransform CSTM = GetAnimBoneCSTM(MirrorSequence, BoneTreeIndex, DT * j);
+			FTransform3f CSTM = GetAnimBoneCSTM(MirrorSequence, BoneTreeIndex, DT * j);
 			CSTM.Mirror(MirrorAxis, NonTwinFlipAxis[i]);
 
 			NewCSTMs[BoneTreeIndex] = CSTM;
@@ -568,12 +576,12 @@ MIRRORANIMATIONSYSTEMDEV_API void UMASFunctionLibrary::CreateMirrorSequenceFromA
 
 			const FCompactPoseBoneIndex TwinCmptBoneIndex(TwinBoneIndex);
 
-			const FTransform RefTM = FAnimationRuntime::GetComponentSpaceTransformRefPose(RefSkeleton, BoneIndex);
+			const FTransform3f RefTM = FTransform3f(FAnimationRuntime::GetComponentSpaceTransformRefPose(RefSkeleton, BoneIndex));
-			const FTransform TwinRefTM = FAnimationRuntime::GetComponentSpaceTransformRefPose(RefSkeleton, TwinBoneIndex);
+			const FTransform3f TwinRefTM = FTransform3f(FAnimationRuntime::GetComponentSpaceTransformRefPose(RefSkeleton, TwinBoneIndex));
 
-			const FTransform TM = GetAnimBoneCSTM(MirrorSequence, BoneIndex, DT * j); 
+			const FTransform3f TM = GetAnimBoneCSTM(MirrorSequence, BoneIndex, DT * j); 
 			//Output.Pose.GetComponentSpaceTransform(CmptBoneIndex);
-			const FTransform TwinTM = GetAnimBoneCSTM(MirrorSequence, TwinBoneIndex, DT * j); 
+			const FTransform3f TwinTM = GetAnimBoneCSTM(MirrorSequence, TwinBoneIndex, DT * j); 
 			//Output.Pose.GetComponentSpaceTransform(TwinCmptBoneIndex);
 
 			const int32 ParentIndex = RefSkeleton.GetParentIndex(BoneIndex);
@@ -581,49 +589,49 @@ MIRRORANIMATIONSYSTEMDEV_API void UMASFunctionLibrary::CreateMirrorSequenceFromA
 
 			const bool SameParent = ParentIndex == TwinParentIndex;
 
-			// twin 1º
+			// twin 1<EFBFBD>
 			{
-				const FTransform MirrRef = RefTM * TwinMirrorModTM;
+				const UE::Math::TTransform<float> MirrRef = RefTM * TwinMirrorModTM;
-				const FTransform Delta = TwinRefTM.GetRelativeTransform(MirrRef);
+				const FTransform3f Delta = TwinRefTM.GetRelativeTransform(MirrRef);
-				const FQuat DeltaQuat = Delta.GetRotation();
+				const FQuat4f DeltaQuat = Delta.GetRotation();
 
-				FTransform MirrTM = TM * TwinMirrorModTM;
+				FTransform3f MirrTM = TM * TwinMirrorModTM;
 
-				MirrTM.SetRotation(MirrTM.GetRotation() * DeltaQuat);
+				MirrTM.SetRotation(MirrTM.GetRotation() * FQuat4f(DeltaQuat));
 				MirrTM.SetScale3D(TwinTM.GetScale3D());
 
 				if (DeltaStep)
 				{
 					if (SameParent)
 					{
-						FTransform RefBS = RefTM;
+						FTransform3f RefBS = RefTM;
 						RefBS = RefBS * TwinMirrorModTM;
-						const FVector PosDelta = MirrTM.GetLocation() - RefBS.GetLocation();
+						const FVector3f PosDelta = MirrTM.GetLocation() - RefBS.GetLocation();
-						MirrTM.SetLocation(TwinRefTM.GetLocation() + PosDelta);
+						MirrTM.SetLocation(FVector3f(TwinRefTM.GetLocation()) + PosDelta);
 					}
 					else
 					{
-						const FTransform& ParentTwinTM = NewCSTMs[RefSkeleton.GetParentIndex(TwinBoneIndex)];
+						const FTransform3f& ParentTwinTM = NewCSTMs[RefSkeleton.GetParentIndex(TwinBoneIndex)];
-						const FTransform& IParentTM =// Output.Pose.GetComponentSpaceTransform(FCompactPoseBoneIndex(ParentIndex));
+						const FTransform3f& IParentTM =// Output.Pose.GetComponentSpaceTransform(FCompactPoseBoneIndex(ParentIndex));
 							GetAnimBoneCSTM(MirrorSequence, ParentIndex, DT * j);
-						FTransform RefBS = RefSkeleton.GetRefBonePose()[BoneIndex] * IParentTM;
+						FTransform3f RefBS = FTransform3f(RefSkeleton.GetRefBonePose()[BoneIndex]) * IParentTM;
 						RefBS = RefBS * TwinMirrorModTM;
 						RefBS.SetRotation(RefBS.GetRotation() * DeltaQuat);
 						RefBS.SetScale3D(TwinTM.GetScale3D());
 
-						MirrTM = (MirrTM.GetRelativeTransform(RefBS) * RefSkeleton.GetRefBonePose()[TwinBoneIndex]) * ParentTwinTM;
+						MirrTM = (MirrTM.GetRelativeTransform(RefBS) * FTransform3f(RefSkeleton.GetRefBonePose()[TwinBoneIndex])) * ParentTwinTM;
 					}
 				}
 
 				NewCSTMs[TwinBoneIndex] = MirrTM;
 			}
 
-			// twin 2º
+			// twin 2<EFBFBD>
 			{
-				FTransform TwinMirrRef = TwinRefTM * TwinMirrorModTM;
+				FTransform3f TwinMirrRef = TwinRefTM * TwinMirrorModTM;
-				const FQuat TwinDeltaQuat = TwinMirrRef.GetRotation().Inverse() * RefTM.GetRotation();
+				const FQuat4f TwinDeltaQuat = TwinMirrRef.GetRotation().Inverse() * RefTM.GetRotation();
 
-				FTransform TwinMirrTM = TwinTM * TwinMirrorModTM;
+				FTransform3f TwinMirrTM = TwinTM * TwinMirrorModTM;
 
 				TwinMirrTM.SetRotation(TwinMirrTM.GetRotation() * TwinDeltaQuat);
 				TwinMirrTM.SetScale3D(TM.GetScale3D());
@@ -632,22 +640,22 @@ MIRRORANIMATIONSYSTEMDEV_API void UMASFunctionLibrary::CreateMirrorSequenceFromA
 				{
 					if (SameParent)
 					{
-						FTransform TwinRefBS = TwinRefTM;
+						FTransform3f TwinRefBS = TwinRefTM;
 						TwinRefBS = TwinRefBS * TwinMirrorModTM;
-						const FVector PosDelta = TwinMirrTM.GetLocation() - TwinRefBS.GetLocation();
+						const FVector3f PosDelta = TwinMirrTM.GetLocation() - TwinRefBS.GetLocation();
 						TwinMirrTM.SetLocation(RefTM.GetLocation() + PosDelta);
 					}
 					else
 					{
-						const FTransform& ParentTM = NewCSTMs[RefSkeleton.GetParentIndex(BoneIndex)];
+						const FTransform3f& ParentTM = NewCSTMs[RefSkeleton.GetParentIndex(BoneIndex)];
-						const FTransform& IParentTwinTM = //Output.Pose.GetComponentSpaceTransform(FCompactPoseBoneIndex(TwinParentIndex));
+						const FTransform3f& IParentTwinTM = //Output.Pose.GetComponentSpaceTransform(FCompactPoseBoneIndex(TwinParentIndex));
 							GetAnimBoneCSTM(MirrorSequence, TwinParentIndex, DT * j);
-						FTransform TwinRefBS = RefSkeleton.GetRefBonePose()[TwinBoneIndex] * IParentTwinTM;
+						FTransform3f TwinRefBS = FTransform3f(RefSkeleton.GetRefBonePose()[TwinBoneIndex]) * IParentTwinTM;
 						TwinRefBS = TwinRefBS * TwinMirrorModTM;
 						TwinRefBS.SetRotation(TwinRefBS.GetRotation() * TwinDeltaQuat);
 						TwinRefBS.SetScale3D(TM.GetScale3D());
 
-						TwinMirrTM = (TwinMirrTM.GetRelativeTransform(TwinRefBS) * RefSkeleton.GetRefBonePose()[BoneIndex]) * ParentTM;
+						TwinMirrTM = (TwinMirrTM.GetRelativeTransform(TwinRefBS) * FTransform3f(RefSkeleton.GetRefBonePose()[BoneIndex]) * ParentTM);
 					}
 				}
 
@@ -659,7 +667,7 @@ MIRRORANIMATIONSYSTEMDEV_API void UMASFunctionLibrary::CreateMirrorSequenceFromA
 		for (int32 i = 0; i < NewCSTMs.Num(); i++)
 		{
 			const int32 ParentIndex = RefSkeleton.GetParentIndex(i);
-			FTransform BSTM;
+			FTransform3f BSTM;
 			if (ParentIndex != INDEX_NONE) BSTM = NewCSTMs[i].GetRelativeTransform(NewCSTMs[ParentIndex]);
 			else BSTM = NewCSTMs[i];
 
@@ -673,11 +681,13 @@ MIRRORANIMATIONSYSTEMDEV_API void UMASFunctionLibrary::CreateMirrorSequenceFromA
 	for (auto Pair : BoneTracks)
 	{
 		const FName TrackName = Skeleton->GetReferenceSkeleton().GetBoneName(Pair.Key);
-		MirrorSequence->AddNewRawTrack(TrackName, &Pair.Value);
+		//MirrorSequence->AddNewRawTrack(TrackName, &Pair.Value);
+		Controller.AddBoneCurve(TrackName);
+		Controller.SetBoneTrackKeys(TrackName,Pair.Value.PosKeys,Pair.Value.RotKeys,Pair.Value.ScaleKeys);
+	
 	}
 	// Have to also apply to pelvis and spine_01
-	MirrorSequence->MarkRawDataAsModified();
+
-	MirrorSequence->OnRawDataChanged();
 	MirrorSequence->MarkPackageDirty();
 }
 

Source/MirrorAnimationSystemEditor/Private/AnimGraphNode_FullMirror.cpp

@@ -0,0 +1,34 @@
+// Copyright 2017-2021 Rexocrates. All Rights Reserved.
+#include "AnimGraphNode_FullMirror.h"
+#include "MirrorAnimationSystemEditor.h"
+
+
+#define LOCTEXT_NAMESPACE "A3Nodes"
+
+UAnimGraphNode_FullMirror::UAnimGraphNode_FullMirror(const FObjectInitializer& ObjectInitializer)
+	:Super(ObjectInitializer)
+{
+
+}
+
+FLinearColor UAnimGraphNode_FullMirror::GetNodeTitleColor() const
+{
+	return FLinearColor::Red;
+}
+
+FText UAnimGraphNode_FullMirror::GetTooltipText() const
+{
+	return LOCTEXT("Mirrors_the_designated_bones", "Mirrors the pose based on the designated Mirror Table");
+}
+
+FText UAnimGraphNode_FullMirror::GetNodeTitle(ENodeTitleType::Type TitleType) const
+{
+	return LOCTEXT("FullMirror_Pose", "Full Mirror Pose");
+}
+
+FString UAnimGraphNode_FullMirror::GetNodeCategory() const
+{
+	return TEXT("Tools");
+}
+
+#undef LOCTEXT_NAMESPACE

Source/MirrorAnimationSystemEditor/Private/AnimGraphNode_FullMirrorCS.cpp

@@ -0,0 +1,53 @@
+// Copyright 2017-2021 Rexocrates. All Rights Reserved.
+#include "AnimGraphNode_FullMirrorCS.h"
+#include "MirrorAnimationSystemEditor.h"
+
+
+#define LOCTEXT_NAMESPACE "A3Nodes"
+
+
+UAnimGraphNode_FullMirrorCS::UAnimGraphNode_FullMirrorCS(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+}
+
+FLinearColor UAnimGraphNode_FullMirrorCS::GetNodeTitleColor() const
+{
+	return FLinearColor::Blue;
+}
+
+FText UAnimGraphNode_FullMirrorCS::GetControllerDescription() const
+{
+	return LOCTEXT("AnimGraphNode_FullMirrorCS", "Full Mirror Pose CS");
+}
+
+FText UAnimGraphNode_FullMirrorCS::GetTooltipText() const
+{
+	return LOCTEXT("AnimGraphNode_FullMirrorCS_Tooltip", "Full Mirror the pose in Component Space.");
+}
+
+FText UAnimGraphNode_FullMirrorCS::GetNodeTitle(ENodeTitleType::Type TitleType) const
+{
+	FText NodeTitle;
+	if (TitleType == ENodeTitleType::ListView || TitleType == ENodeTitleType::MenuTitle)
+	{
+		NodeTitle = GetControllerDescription();
+	}
+	else
+	{
+		NodeTitle = FText(LOCTEXT("AnimGraphNode_FullMirrorCS_Title", "Full Mirror Pose CS"));
+	}
+	return NodeTitle;
+}
+
+void UAnimGraphNode_FullMirrorCS::ValidateAnimNodePostCompile(class FCompilerResultsLog& MessageLog, class UAnimBlueprintGeneratedClass* CompiledClass, int32 CompiledNodeIndex)
+{
+	Super::ValidateAnimNodePostCompile(MessageLog, CompiledClass, CompiledNodeIndex);
+}
+
+bool UAnimGraphNode_FullMirrorCS::IsCompatibleWithGraph(const UEdGraph* TargetGraph) const
+{
+	return Super::IsCompatibleWithGraph(TargetGraph);
+}
+
+#undef LOCTEXT_NAMESPACE

Source/MirrorAnimationSystemEditor/Private/AnimGraphNode_Mirror.cpp

@@ -1,34 +0,0 @@
-// Copyright 2017-2021 Rexocrates. All Rights Reserved.
-#include "AnimGraphNode_Mirror.h"
-#include "MirrorAnimationSystemEditor.h"
-
-
-#define LOCTEXT_NAMESPACE "A3Nodes"
-
-UAnimGraphNode_Mirror::UAnimGraphNode_Mirror(const FObjectInitializer& ObjectInitializer)
-	:Super(ObjectInitializer)
-{
-
-}
-
-FLinearColor UAnimGraphNode_Mirror::GetNodeTitleColor() const
-{
-	return FLinearColor::Red;
-}
-
-FText UAnimGraphNode_Mirror::GetTooltipText() const
-{
-	return LOCTEXT("Mirrors_the_designated_bones", "Mirrors the pose based on the designated Mirror Table");
-}
-
-FText UAnimGraphNode_Mirror::GetNodeTitle(ENodeTitleType::Type TitleType) const
-{
-	return LOCTEXT("Mirror_Pose", "Mirror Pose");
-}
-
-FString UAnimGraphNode_Mirror::GetNodeCategory() const
-{
-	return TEXT("Tools");
-}
-
-#undef LOCTEXT_NAMESPACE

Source/MirrorAnimationSystemEditor/Private/AnimGraphNode_MirrorCS.cpp

@@ -1,53 +0,0 @@
-// Copyright 2017-2021 Rexocrates. All Rights Reserved.
-#include "AnimGraphNode_MirrorCS.h"
-#include "MirrorAnimationSystemEditor.h"
-
-
-#define LOCTEXT_NAMESPACE "A3Nodes"
-
-
-UAnimGraphNode_MirrorCS::UAnimGraphNode_MirrorCS(const FObjectInitializer& ObjectInitializer)
-	: Super(ObjectInitializer)
-{
-}
-
-FLinearColor UAnimGraphNode_MirrorCS::GetNodeTitleColor() const
-{
-	return FLinearColor::Blue;
-}
-
-FText UAnimGraphNode_MirrorCS::GetControllerDescription() const
-{
-	return LOCTEXT("AnimGraphNode_MirrorCS", "Mirror Pose CS");
-}
-
-FText UAnimGraphNode_MirrorCS::GetTooltipText() const
-{
-	return LOCTEXT("AnimGraphNode_MirrorCS_Tooltip", "Mirror the pose in Component Space.");
-}
-
-FText UAnimGraphNode_MirrorCS::GetNodeTitle(ENodeTitleType::Type TitleType) const
-{
-	FText NodeTitle;
-	if (TitleType == ENodeTitleType::ListView || TitleType == ENodeTitleType::MenuTitle)
-	{
-		NodeTitle = GetControllerDescription();
-	}
-	else
-	{
-		NodeTitle = FText(LOCTEXT("AnimGraphNode_MirrorCS_Title", "Mirror Pose CS"));
-	}
-	return NodeTitle;
-}
-
-void UAnimGraphNode_MirrorCS::ValidateAnimNodePostCompile(class FCompilerResultsLog& MessageLog, class UAnimBlueprintGeneratedClass* CompiledClass, int32 CompiledNodeIndex)
-{
-	Super::ValidateAnimNodePostCompile(MessageLog, CompiledClass, CompiledNodeIndex);
-}
-
-bool UAnimGraphNode_MirrorCS::IsCompatibleWithGraph(const UEdGraph* TargetGraph) const
-{
-	return Super::IsCompatibleWithGraph(TargetGraph);
-}
-
-#undef LOCTEXT_NAMESPACE

Source/MirrorAnimationSystemEditor/Private/ContentBrowserTools.cpp

@@ -195,11 +195,11 @@ public:
 		for (auto AssetIt = SelectedAssets.CreateConstIterator(); AssetIt; ++AssetIt)
 		{
 			const FAssetData& Asset = *AssetIt;
-			bShowButton = bShowButton || (Asset.AssetClass == UAnimSequence::StaticClass()->GetFName()) || (Asset.AssetClass == USkeleton::StaticClass()->GetFName());
+			bShowButton = bShowButton || (Asset.AssetClassPath == UAnimSequence::StaticClass()->GetClassPathName()) || (Asset.AssetClassPath == USkeleton::StaticClass()->GetClassPathName());
-			bIsSkeletonAsset = (Asset.AssetClass == USkeleton::StaticClass()->GetFName());
+			bIsSkeletonAsset = (Asset.AssetClassPath == USkeleton::StaticClass()->GetClassPathName());
 		}
 
-		if (bShowButton)
+		if (bShowButton) //@TODO: This should be true !!
 		{
 			if (bIsSkeletonAsset)
 			{

Source/MirrorAnimationSystemEditor/Private/MirrorTableFromSkeletonDialog.cpp

@@ -20,7 +20,7 @@
 #include "Framework/Docking/TabManager.h"
 #include "EditorStyleSet.h"
 #include "CanvasItem.h"
-#include "AssetRegistryModule.h"
+#include "AssetRegistry/AssetRegistryModule.h"
 #include "PropertyEditorModule.h"
 #include "IContentBrowserSingleton.h"
 #include "ContentBrowserModule.h"

Source/MirrorAnimationSystemEditor/Public/AnimGraphNode_FullMirror.h

@@ -2,18 +2,18 @@
 
 #pragma once
 #include "AnimGraphNode_Base.h"
-#include "AnimNode_Mirror.h"
+#include "AnimNode_FullMirror.h"
-#include "AnimGraphNode_Mirror.generated.h"
+#include "AnimGraphNode_FullMirror.generated.h"
 /**
  * 
  */
 /*class that holds Editor version of the AnimGraph Node Mirror Pose, along its tittle, tooltip, Node Color, and the category of the node*/
 UCLASS()
-class MIRRORANIMATIONSYSTEMEDITOR_API UAnimGraphNode_Mirror : public UAnimGraphNode_Base
+class MIRRORANIMATIONSYSTEMEDITOR_API UAnimGraphNode_FullMirror : public UAnimGraphNode_Base
 {
 	GENERATED_BODY()
 	UPROPERTY(EditAnywhere, Category = Settings)
-		FAnimNode_Mirror Node;
+		FAnimNode_FullMirror Node;
 
 	//~ Begin UEdGraphNode Interface.
 	virtual FLinearColor GetNodeTitleColor() const override;
@@ -25,5 +25,5 @@ class MIRRORANIMATIONSYSTEMEDITOR_API UAnimGraphNode_Mirror : public UAnimGraphN
 	virtual FString GetNodeCategory() const override;
 	//~ End UAnimGraphNode_Base Interface
 
-	UAnimGraphNode_Mirror(const FObjectInitializer& ObjectInitializer);
+	UAnimGraphNode_FullMirror(const FObjectInitializer& ObjectInitializer);
 };

Source/MirrorAnimationSystemEditor/Public/AnimGraphNode_FullMirrorCS.h

@@ -3,19 +3,19 @@
 #pragma once
 //#include "AnimGraphNode_Base.h"
 #include "AnimGraphNode_SkeletalControlBase.h"
-#include "AnimNode_MirrorCS.h"
+#include "AnimNode_FullMirrorCS.h"
-#include "AnimGraphNode_MirrorCS.generated.h"
+#include "AnimGraphNode_FullMirrorCS.generated.h"
 /**
  * 
  */
 /*class that holds Editor version of the AnimGraph Node Mirror Pose, along its tittle, tooltip, Node Color, and the category of the node*/
 UCLASS()
-class MIRRORANIMATIONSYSTEMEDITOR_API UAnimGraphNode_MirrorCS : public UAnimGraphNode_SkeletalControlBase
+class MIRRORANIMATIONSYSTEMEDITOR_API UAnimGraphNode_FullMirrorCS : public UAnimGraphNode_SkeletalControlBase
 {
 	GENERATED_BODY()
 
 	UPROPERTY(EditAnywhere, Category = Settings)
-		FAnimNode_MirrorCS Node;
+		FAnimNode_FullMirrorCS Node;
 	/*
 	//~ Begin UEdGraphNode Interface.
 	virtual FLinearColor GetNodeTitleColor() const override;
@@ -27,12 +27,12 @@ class MIRRORANIMATIONSYSTEMEDITOR_API UAnimGraphNode_MirrorCS : public UAnimGrap
 	virtual FString GetNodeCategory() const override;
 	//~ End UAnimGraphNode_Base Interface
 
-	UAnimGraphNode_MirrorCS(const FObjectInitializer& ObjectInitializer);
+	UAnimGraphNode_FullMirrorCS(const FObjectInitializer& ObjectInitializer);
 	*/
 
 
 public:
-	UAnimGraphNode_MirrorCS(const FObjectInitializer& ObjectInitializer);
+	UAnimGraphNode_FullMirrorCS(const FObjectInitializer& ObjectInitializer);
 
 	// UEdGraphNode interface
 	virtual FLinearColor GetNodeTitleColor() const override;