lucastucious/Mirror_Animation_System
1
0
Fork 0
mirror of https://github.com/lucastucious/Mirror_Animation_System.git synced 2025-05-11 23:05:54 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Compare commits

base: lucastucious:main
Branches Tags
lucastucious:main
lucastucious:fix/CreateSequence
lucastucious:5.4
lucastucious:4.27
lucastucious:5.4
..
compare: lucastucious:4.27
Branches Tags
lucastucious:fix/CreateSequence
lucastucious:main
lucastucious:5.4
lucastucious:4.27
lucastucious:5.4

No commits in common. "main" and "4.27" have entirely different histories.
main ... 4.27

18 changed files with 261 additions and 271 deletions
Show stats Expand all files Collapse all files

BIN
Content/MirrorTableLibrary/Mixamo_MirrorTable.uasset
View file

Binary file not shown.

BIN
Content/MirrorTableLibrary/UE4_Mannequin_MirrorTable.uasset
View file

Binary file not shown.

14
MirrorAnimationSystem.uplugin
View file

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

14
Source/MirrorAnimationSystem/Private/AnimNode_FullMirror.cpp → Source/MirrorAnimationSystem/Private/AnimNode_Mirror.cpp
View file

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

24
Source/MirrorAnimationSystem/Private/AnimNode_FullMirrorCS.cpp → Source/MirrorAnimationSystem/Private/AnimNode_MirrorCS.cpp
View file

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

6
Source/MirrorAnimationSystem/Private/ExtCharacterMovementComponent.cpp
View file

@ -243,12 +243,12 @@ void UExtCharacterMovementComponent::PerformMovement(float DeltaSeconds)
FTransform TmpRootMootTr = RootMotionParams.GetRootMotionTransform(); FTransform TmpRootMootTr = RootMotionParams.GetRootMotionTransform();
TmpRootMootTr.Mirror(MirrorAxis, FlipAxis); TmpRootMootTr.Mirror(MirrorAxis, FlipAxis);
TmpRootMootTr.SetScale3D(TmpRootMootTr.GetScale3D().GetAbs()); TmpRootMootTr.SetScale3D(TmpRootMootTr.GetScale3D().GetAbs());
RootMotionParams.Set(ConvertLocalRootMotionToWorld(TmpRootMootTr,DeltaSeconds)); RootMotionParams.Set(ConvertLocalRootMotionToWorld(TmpRootMootTr));
} }
else 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. // 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(),DeltaSeconds)); RootMotionParams.Set(ConvertLocalRootMotionToWorld(RootMotionParams.GetRootMotionTransform()));
} }
} }
@ -320,7 +320,7 @@ void UExtCharacterMovementComponent::PerformMovement(float DeltaSeconds)
// Update character state based on change from movement // Update character state based on change from movement
UpdateCharacterStateAfterMovement(DeltaSeconds); UpdateCharacterStateAfterMovement(DeltaSeconds);
if ((bAllowPhysicsRotationDuringAnimRootMotion || !HasAnimRootMotion()) ) //@TODO: check if not owned by Levelsequence if ((bAllowPhysicsRotationDuringAnimRootMotion || !HasAnimRootMotion()) && !CharacterOwner->IsMatineeControlled())
{ {
PhysicsRotation(DeltaSeconds); PhysicsRotation(DeltaSeconds);
} }

6
Source/MirrorAnimationSystem/Public/AnimNode_FullMirror.h → Source/MirrorAnimationSystem/Public/AnimNode_Mirror.h
View file

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

8
Source/MirrorAnimationSystem/Public/AnimNode_FullMirrorCS.h → Source/MirrorAnimationSystem/Public/AnimNode_MirrorCS.h
View file

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

24
Source/MirrorAnimationSystem/Public/MirrorTable.h
View file

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

232
Source/MirrorAnimationSystemDev/Private/MASFunctionLibrary.cpp
View file

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

34
Source/MirrorAnimationSystemEditor/Private/AnimGraphNode_FullMirror.cpp
View file

@ -1,34 +0,0 @@
// 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

53
Source/MirrorAnimationSystemEditor/Private/AnimGraphNode_FullMirrorCS.cpp
View file

@ -1,53 +0,0 @@
// 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

34
Source/MirrorAnimationSystemEditor/Private/AnimGraphNode_Mirror.cpp Normal file
View file

@ -0,0 +1,34 @@
// 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

53
Source/MirrorAnimationSystemEditor/Private/AnimGraphNode_MirrorCS.cpp Normal file
View file

@ -0,0 +1,53 @@
// 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

6
Source/MirrorAnimationSystemEditor/Private/ContentBrowserTools.cpp
View file

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

2
Source/MirrorAnimationSystemEditor/Private/MirrorTableFromSkeletonDialog.cpp
View file

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

10
Source/MirrorAnimationSystemEditor/Public/AnimGraphNode_FullMirror.h → Source/MirrorAnimationSystemEditor/Public/AnimGraphNode_Mirror.h
View file

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

12
Source/MirrorAnimationSystemEditor/Public/AnimGraphNode_FullMirrorCS.h → Source/MirrorAnimationSystemEditor/Public/AnimGraphNode_MirrorCS.h
View file

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