mirror of
https://github.com/lucastucious/Mirror_Animation_System.git
synced 2025-05-10 14:25:51 +00:00
752 lines
24 KiB
C++
752 lines
24 KiB
C++
// Copyright 2017-2021 Rexocrates. All Rights Reserved.
|
||
|
||
|
||
#include "MASFunctionLibrary.h"
|
||
|
||
#include "MirrorTable.h"
|
||
|
||
#include "Animation/AnimSequence.h"
|
||
|
||
#include "Misc/PackageName.h"
|
||
|
||
#if WITH_EDITOR
|
||
#include "AssetToolsModule.h"
|
||
#include "AssetRegistry/AssetRegistryModule.h"
|
||
|
||
#include "Framework/Notifications/NotificationManager.h"
|
||
#include "Widgets/Notifications/SNotificationList.h"
|
||
|
||
#endif
|
||
|
||
#include "MASUtils.h"
|
||
#include "AnimationRuntime.h"
|
||
|
||
#define LOCTEXT_NAMESPACE "MASLibrary"
|
||
|
||
UMASFunctionLibrary::UMASFunctionLibrary(const FObjectInitializer& ObjectInitializer)
|
||
: Super(ObjectInitializer)
|
||
{
|
||
}
|
||
|
||
void UMASFunctionLibrary::BulkMirrorEditorOnly(const TArray<UAnimSequence*> SourceAnims,
|
||
const UMirrorTable* MirrorTable, TArray<UAnimSequence*>& OutNewAnims)
|
||
{
|
||
if (SourceAnims.Num() == 0)
|
||
{
|
||
return;
|
||
}
|
||
if (MirrorTable == nullptr)
|
||
{
|
||
return;
|
||
}
|
||
|
||
#if WITH_EDITOR
|
||
FAssetToolsModule& AssetToolsModule = FModuleManager::Get().LoadModuleChecked<FAssetToolsModule>("AssetTools");
|
||
|
||
for (int32 i = 0; i < SourceAnims.Num(); i++)
|
||
{
|
||
// Create the asset
|
||
FString Name;
|
||
FString PackageName;
|
||
|
||
|
||
FString Suffix = TEXT("_Mirrored");
|
||
|
||
AssetToolsModule.Get().CreateUniqueAssetName(SourceAnims[i]->GetOutermost()->GetName(), Suffix, /*out*/
|
||
PackageName, /*out*/ Name);
|
||
const FString PackagePath = FPackageName::GetLongPackagePath(PackageName);
|
||
|
||
|
||
UObject* NewAsset = AssetToolsModule.Get().DuplicateAsset(Name, PackagePath, SourceAnims[i]);
|
||
|
||
if (NewAsset != nullptr)
|
||
{
|
||
UAnimSequence* MirrorAnimSequence = Cast<UAnimSequence>(NewAsset);
|
||
CreateMirrorSequenceFromAnimSequence(MirrorAnimSequence, MirrorTable);
|
||
|
||
OutNewAnims.Add(MirrorAnimSequence);
|
||
|
||
// Notify asset registry of new asset
|
||
FAssetRegistryModule::AssetCreated(MirrorAnimSequence);
|
||
|
||
// Display notification so users can quickly access
|
||
if (GIsEditor)
|
||
{
|
||
FNotificationInfo Info(FText::Format(
|
||
LOCTEXT("AnimationMirrored", "Successfully Mirrored Animation"),
|
||
FText::FromString(MirrorAnimSequence->GetName())));
|
||
Info.ExpireDuration = 8.0f;
|
||
Info.bUseLargeFont = false;
|
||
//Info.Hyperlink = FSimpleDelegate::CreateLambda([=]() { FAssetEditorManager::Get().OpenEditorForAssets(TArray<UObject*>({ MirrorAnimSequence })); });
|
||
Info.Hyperlink = FSimpleDelegate::CreateLambda([=]()
|
||
{
|
||
GEditor->GetEditorSubsystem<UAssetEditorSubsystem>()->OpenEditorForAssets(TArray<UObject*>({
|
||
MirrorAnimSequence
|
||
}));
|
||
});
|
||
|
||
Info.HyperlinkText = FText::Format(
|
||
LOCTEXT("OpenNewAnimationHyperlink", "Open {0}"), FText::FromString(MirrorAnimSequence->GetName()));
|
||
TSharedPtr<SNotificationItem> Notification = FSlateNotificationManager::Get().AddNotification(Info);
|
||
if (Notification.IsValid())
|
||
{
|
||
Notification->SetCompletionState(SNotificationItem::CS_Success);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
|
||
MIRRORANIMATIONSYSTEMDEV_API void UMASFunctionLibrary::BulkMirror_CS_EditorOnly(
|
||
const TArray<UAnimSequence*> SourceAnims,
|
||
const TEnumAsByte<EAxis::Type> MirrorAxis, const FString Substring_A, const FString Substring_B,
|
||
const bool Symmetrical, TArray<UAnimSequence*>& OutNewAnims)
|
||
{
|
||
if (SourceAnims.Num() == 0)
|
||
{
|
||
return;
|
||
}
|
||
if (MirrorAxis == EAxis::None)
|
||
{
|
||
return;
|
||
}
|
||
|
||
#if WITH_EDITOR
|
||
FAssetToolsModule& AssetToolsModule = FModuleManager::Get().LoadModuleChecked<FAssetToolsModule>("AssetTools");
|
||
|
||
for (int32 i = 0; i < SourceAnims.Num(); i++)
|
||
{
|
||
// Create the asset
|
||
FString Name;
|
||
FString PackageName;
|
||
|
||
|
||
FString Suffix = TEXT("_Mirrored");
|
||
|
||
AssetToolsModule.Get().CreateUniqueAssetName(SourceAnims[i]->GetOutermost()->GetName(), Suffix, /*out*/
|
||
PackageName, /*out*/ Name);
|
||
const FString PackagePath = FPackageName::GetLongPackagePath(PackageName);
|
||
|
||
|
||
UObject* NewAsset = AssetToolsModule.Get().DuplicateAsset(Name, PackagePath, SourceAnims[i]);
|
||
|
||
if (NewAsset != nullptr)
|
||
{
|
||
UAnimSequence* MirrorAnimSequence = Cast<UAnimSequence>(NewAsset);
|
||
CreateMirrorSequenceFromAnimSequence_CS(MirrorAnimSequence, MirrorAxis, Substring_A, Substring_B,
|
||
Symmetrical);
|
||
|
||
OutNewAnims.Add(MirrorAnimSequence);
|
||
|
||
// Notify asset registry of new asset
|
||
FAssetRegistryModule::AssetCreated(MirrorAnimSequence);
|
||
|
||
// Display notification so users can quickly access
|
||
if (GIsEditor)
|
||
{
|
||
FNotificationInfo Info(FText::Format(
|
||
LOCTEXT("AnimationMirrored", "Successfully Mirrored Animation"),
|
||
FText::FromString(MirrorAnimSequence->GetName())));
|
||
Info.ExpireDuration = 8.0f;
|
||
Info.bUseLargeFont = false;
|
||
//Info.Hyperlink = FSimpleDelegate::CreateLambda([=]() { FAssetEditorManager::Get().OpenEditorForAssets(TArray<UObject*>({ MirrorAnimSequence })); });
|
||
Info.Hyperlink = FSimpleDelegate::CreateLambda([=]()
|
||
{
|
||
GEditor->GetEditorSubsystem<UAssetEditorSubsystem>()->OpenEditorForAssets(TArray<UObject*>({
|
||
MirrorAnimSequence
|
||
}));
|
||
});
|
||
|
||
Info.HyperlinkText = FText::Format(
|
||
LOCTEXT("OpenNewAnimationHyperlink", "Open {0}"), FText::FromString(MirrorAnimSequence->GetName()));
|
||
TSharedPtr<SNotificationItem> Notification = FSlateNotificationManager::Get().AddNotification(Info);
|
||
if (Notification.IsValid())
|
||
{
|
||
Notification->SetCompletionState(SNotificationItem::CS_Success);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
|
||
#if WITH_EDITOR
|
||
|
||
void UMASFunctionLibrary::CreateMirrorSequenceFromAnimSequence(UAnimSequence* MirrorSequence,
|
||
const UMirrorTable* MirrorTable)
|
||
{
|
||
//Check if it's valid
|
||
if ((MirrorSequence != nullptr) && (MirrorTable != nullptr) && (MirrorSequence->GetSkeleton() != nullptr))
|
||
{
|
||
//Make the duplicate that I will edit
|
||
//UAnimSequence* MirrorSequence = FromAnimSequence;
|
||
const auto& Skel = MirrorSequence->GetSkeleton()->GetReferenceSkeleton();
|
||
|
||
int NumMirrorBones = MirrorTable->MirrorBones.Num();
|
||
|
||
int NumFrames = MirrorSequence->GetNumberOfFrames();
|
||
IAnimationDataController& MirrorSequenceController = MirrorSequence->GetController();
|
||
const TArray<FBoneAnimationTrack>& SourceBoneAnimData = MirrorSequenceController.GetModel()->
|
||
GetBoneAnimationTracks();
|
||
/************* SourceRawAnimDatas should be replaced by SourceBoneAnimData ************/
|
||
// TArray<FRawAnimSequenceTrack> SourceRawAnimDatas = MirrorSequence->GetRawAnimationData();
|
||
|
||
TArray<FName>* TrackNames = new TArray<FName>;
|
||
MirrorSequenceController.GetModel()->GetBoneTrackNames(*TrackNames);
|
||
|
||
for (int i = 0; i < NumMirrorBones; i++)
|
||
{
|
||
FMirrorBone CurrentBone = MirrorTable->MirrorBones[i];
|
||
|
||
if (Skel.FindBoneIndex(CurrentBone.BoneName) == INDEX_NONE)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (CurrentBone.IsTwinBone)
|
||
{
|
||
if (Skel.FindBoneIndex(CurrentBone.TwinBoneName) == INDEX_NONE)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
int32 TrackIndex = TrackNames->IndexOfByKey(CurrentBone.BoneName);
|
||
int32 TwinTrackIndex = TrackNames->IndexOfByKey(CurrentBone.TwinBoneName);
|
||
|
||
if (TrackIndex == INDEX_NONE && TwinTrackIndex == INDEX_NONE)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
TArray<FVector3f> MirrorPosKeys;
|
||
TArray<FQuat4f> MirrorRotKeys;
|
||
TArray<FVector3f> MirrorScaleKeys;
|
||
|
||
TArray<FVector3f> TwinMirrorPosKeys;
|
||
TArray<FQuat4f> TwinMirrorRotKeys;
|
||
TArray<FVector3f> TwinMirrorScaleKeys;
|
||
|
||
// Original Bone
|
||
if (TrackIndex != INDEX_NONE)
|
||
{
|
||
check(SourceBoneAnimData.Num()>0);
|
||
auto& MirroredRawTrack = SourceBoneAnimData[TrackIndex];
|
||
|
||
for (int u = 0; u < NumFrames; u++)
|
||
{
|
||
FTransform3f MirrorTM;
|
||
|
||
bool bSetPos = false;
|
||
bool bSetRot = false;
|
||
bool bSetScale = false;
|
||
|
||
if (MirroredRawTrack.InternalTrackData.PosKeys.IsValidIndex(u))
|
||
{
|
||
MirrorTM.SetTranslation(MirroredRawTrack.InternalTrackData.PosKeys[u]);
|
||
bSetPos = true;
|
||
}
|
||
if (MirroredRawTrack.InternalTrackData.RotKeys.IsValidIndex(u))
|
||
{
|
||
MirrorTM.SetRotation(MirroredRawTrack.InternalTrackData.RotKeys[u]);
|
||
bSetRot = true;
|
||
}
|
||
if (MirroredRawTrack.InternalTrackData.ScaleKeys.IsValidIndex(u))
|
||
{
|
||
MirrorTM.SetScale3D(MirroredRawTrack.InternalTrackData.ScaleKeys[u]);
|
||
bSetScale = true;
|
||
}
|
||
|
||
MirrorTM.Mirror(CurrentBone.MirrorAxis, CurrentBone.FlipAxis);
|
||
|
||
|
||
FRotator3f BoneNewRotation = MirrorTM.Rotator(); // quaternion to rotator
|
||
|
||
BoneNewRotation.Yaw += CurrentBone.RotationOffset.Yaw;
|
||
BoneNewRotation.Roll += CurrentBone.RotationOffset.Roll;
|
||
BoneNewRotation.Pitch += CurrentBone.RotationOffset.Pitch;
|
||
|
||
MirrorTM.SetRotation(BoneNewRotation.Quaternion());
|
||
MirrorTM.SetScale3D(MirrorTM.GetScale3D().GetAbs());
|
||
MirrorTM.NormalizeRotation();
|
||
|
||
if (bSetPos)
|
||
{
|
||
MirrorPosKeys.Add(FVector3f(MirrorTM.GetTranslation()));
|
||
}
|
||
if (bSetRot)
|
||
{
|
||
MirrorRotKeys.Add(FQuat4f(MirrorTM.GetRotation()));
|
||
}
|
||
if (bSetScale)
|
||
{
|
||
MirrorScaleKeys.Add(FVector3f(MirrorTM.GetScale3D()));
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
auto RefTM = Skel.GetRefBonePose()[Skel.FindBoneIndex(CurrentBone.BoneName)];
|
||
|
||
RefTM.Mirror(CurrentBone.MirrorAxis, CurrentBone.FlipAxis);
|
||
|
||
FRotator BoneNewRotation = RefTM.Rotator();
|
||
|
||
BoneNewRotation.Yaw += CurrentBone.RotationOffset.Yaw;
|
||
BoneNewRotation.Roll += CurrentBone.RotationOffset.Roll;
|
||
BoneNewRotation.Pitch += CurrentBone.RotationOffset.Pitch;
|
||
|
||
RefTM.SetRotation(FQuat(BoneNewRotation));
|
||
RefTM.SetScale3D(RefTM.GetScale3D().GetAbs());
|
||
RefTM.NormalizeRotation();
|
||
|
||
MirrorPosKeys.Add(FVector3f(RefTM.GetTranslation()));
|
||
MirrorRotKeys.Add(FQuat4f(RefTM.GetRotation()));
|
||
}
|
||
|
||
// Twin Bone
|
||
if (TwinTrackIndex != INDEX_NONE)
|
||
{
|
||
auto& TwinMirroredRawTrack = SourceBoneAnimData[TwinTrackIndex];
|
||
|
||
for (int u = 0; u < NumFrames; u++)
|
||
{
|
||
FTransform3f TwinMirrorTM;
|
||
|
||
bool TwinbSetPos = false;
|
||
bool TwinbSetRot = false;
|
||
bool TwinbSetScale = false;
|
||
|
||
if (TwinMirroredRawTrack.InternalTrackData.PosKeys.IsValidIndex(u))
|
||
{
|
||
TwinMirrorTM.SetTranslation(TwinMirroredRawTrack.InternalTrackData.PosKeys[u]);
|
||
TwinbSetPos = true;
|
||
}
|
||
if (TwinMirroredRawTrack.InternalTrackData.RotKeys.IsValidIndex(u))
|
||
{
|
||
TwinMirrorTM.SetRotation(TwinMirroredRawTrack.InternalTrackData.RotKeys[u]);
|
||
TwinbSetRot = true;
|
||
}
|
||
if (TwinMirroredRawTrack.InternalTrackData.ScaleKeys.IsValidIndex(u))
|
||
{
|
||
TwinMirrorTM.SetScale3D(TwinMirroredRawTrack.InternalTrackData.ScaleKeys[u]);
|
||
TwinbSetScale = true;
|
||
}
|
||
|
||
TwinMirrorTM.Mirror(CurrentBone.MirrorAxis, CurrentBone.FlipAxis);
|
||
|
||
FRotator3f TwinBoneNewRotation = TwinMirrorTM.Rotator();
|
||
|
||
TwinBoneNewRotation.Yaw += CurrentBone.RotationOffset.Yaw;
|
||
TwinBoneNewRotation.Roll += CurrentBone.RotationOffset.Roll;
|
||
TwinBoneNewRotation.Pitch += CurrentBone.RotationOffset.Pitch;
|
||
|
||
TwinMirrorTM.SetRotation(TwinBoneNewRotation.Quaternion());
|
||
TwinMirrorTM.SetScale3D(TwinMirrorTM.GetScale3D().GetAbs());
|
||
TwinMirrorTM.NormalizeRotation();
|
||
|
||
if (TwinbSetPos)
|
||
{
|
||
TwinMirrorPosKeys.Add(FVector3f(TwinMirrorTM.GetTranslation()));
|
||
}
|
||
if (TwinbSetRot)
|
||
{
|
||
TwinMirrorRotKeys.Add(FQuat4f(TwinMirrorTM.GetRotation()));
|
||
}
|
||
if (TwinbSetScale)
|
||
{
|
||
TwinMirrorScaleKeys.Add(FVector3f(TwinMirrorTM.GetScale3D()));
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
auto RefTM = Skel.GetRefBonePose()[Skel.FindBoneIndex(CurrentBone.TwinBoneName)];
|
||
|
||
RefTM.Mirror(CurrentBone.MirrorAxis, CurrentBone.FlipAxis);
|
||
|
||
FRotator TwinBoneNewRotation = RefTM.Rotator();
|
||
|
||
TwinBoneNewRotation.Yaw += CurrentBone.RotationOffset.Yaw;
|
||
TwinBoneNewRotation.Roll += CurrentBone.RotationOffset.Roll;
|
||
TwinBoneNewRotation.Pitch += CurrentBone.RotationOffset.Pitch;
|
||
|
||
RefTM.SetRotation(FQuat(TwinBoneNewRotation));
|
||
RefTM.SetScale3D(RefTM.GetScale3D().GetAbs());
|
||
RefTM.NormalizeRotation();
|
||
|
||
TwinMirrorPosKeys.Add(FVector3f(RefTM.GetTranslation()));
|
||
TwinMirrorRotKeys.Add(FQuat4f(RefTM.GetRotation()));
|
||
}
|
||
|
||
// Original Bone -> Twin Bone
|
||
{
|
||
FRawAnimSequenceTrack NewTrack;
|
||
|
||
NewTrack.PosKeys = CurrentBone.MirrorTranslation ? MirrorPosKeys : TwinMirrorPosKeys;
|
||
NewTrack.RotKeys = MirrorRotKeys;
|
||
NewTrack.ScaleKeys = MirrorScaleKeys;
|
||
|
||
//MirrorSequence->AddNewRawTrack(CurrentBone.TwinBoneName, &NewTrack);
|
||
MirrorSequenceController.AddBoneTrack(CurrentBone.TwinBoneName);
|
||
MirrorSequenceController.SetBoneTrackKeys(CurrentBone.BoneName, NewTrack.PosKeys, NewTrack.RotKeys,
|
||
NewTrack.ScaleKeys);
|
||
}
|
||
|
||
// Twin Bone -> Original Bone
|
||
{
|
||
FRawAnimSequenceTrack NewTrack;
|
||
|
||
NewTrack.PosKeys = CurrentBone.MirrorTranslation ? TwinMirrorPosKeys : MirrorPosKeys;
|
||
NewTrack.RotKeys = TwinMirrorRotKeys;
|
||
NewTrack.ScaleKeys = TwinMirrorScaleKeys;
|
||
|
||
MirrorSequenceController.AddBoneTrack(CurrentBone.BoneName);
|
||
MirrorSequenceController.SetBoneTrackKeys(CurrentBone.BoneName, NewTrack.PosKeys, NewTrack.RotKeys,
|
||
NewTrack.ScaleKeys);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (TrackNames) { continue; }
|
||
int32 TrackIndex = TrackNames->IndexOfByKey(CurrentBone.BoneName);
|
||
|
||
if (TrackIndex == INDEX_NONE)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
FBoneAnimationTrack MirroredRawTrack = SourceBoneAnimData[TrackIndex];
|
||
|
||
//MirrorAllFrames
|
||
TArray<FVector3f> MirrorPosKeys;
|
||
TArray<FQuat4f> MirrorRotKeys;
|
||
TArray<FVector3f> MirrorScaleKeys;
|
||
|
||
for (int u = 0; u < NumFrames; u++)
|
||
{
|
||
//Mirror Transform
|
||
FTransform3f MirrorTM;
|
||
|
||
bool bSetPos = false;
|
||
bool bSetRot = false;
|
||
bool bSetScale = false;
|
||
|
||
if (MirroredRawTrack.InternalTrackData.PosKeys.IsValidIndex(u))
|
||
{
|
||
MirrorTM.SetTranslation(MirroredRawTrack.InternalTrackData.PosKeys[u]);
|
||
bSetPos = true;
|
||
}
|
||
if (MirroredRawTrack.InternalTrackData.RotKeys.IsValidIndex(u))
|
||
{
|
||
MirrorTM.SetRotation(MirroredRawTrack.InternalTrackData.RotKeys[u]);
|
||
bSetRot = true;
|
||
}
|
||
if (MirroredRawTrack.InternalTrackData.ScaleKeys.IsValidIndex(u))
|
||
{
|
||
MirrorTM.SetScale3D(MirroredRawTrack.InternalTrackData.ScaleKeys[u]);
|
||
bSetScale = true;
|
||
}
|
||
|
||
MirrorTM.Mirror(CurrentBone.MirrorAxis, CurrentBone.FlipAxis);
|
||
|
||
FRotator3f BoneNewRotation = MirrorTM.Rotator();
|
||
|
||
BoneNewRotation.Yaw += CurrentBone.RotationOffset.Yaw;
|
||
BoneNewRotation.Roll += CurrentBone.RotationOffset.Roll;
|
||
BoneNewRotation.Pitch += CurrentBone.RotationOffset.Pitch;
|
||
|
||
MirrorTM.SetRotation(BoneNewRotation.Quaternion());
|
||
//MirrorTM.NormalizeRotation();
|
||
MirrorTM.SetScale3D(MirrorTM.GetScale3D().GetAbs());
|
||
|
||
MirrorTM.NormalizeRotation();
|
||
|
||
//Setting it up Main
|
||
if (bSetPos)
|
||
{
|
||
MirrorPosKeys.Add(MirrorTM.GetTranslation());
|
||
}
|
||
if (bSetRot)
|
||
{
|
||
MirrorRotKeys.Add(MirrorTM.GetRotation());
|
||
}
|
||
if (bSetScale)
|
||
{
|
||
MirrorScaleKeys.Add(MirrorTM.GetScale3D());
|
||
}
|
||
|
||
/////////////////////////////////
|
||
}
|
||
|
||
MirroredRawTrack.InternalTrackData.PosKeys = MirrorPosKeys;
|
||
MirroredRawTrack.InternalTrackData.RotKeys = MirrorRotKeys;
|
||
MirroredRawTrack.InternalTrackData.ScaleKeys = MirrorScaleKeys;
|
||
|
||
//Finally Setting it in the AnimSequence
|
||
|
||
//MirrorSequenceController.AddBoneTrack(CurrentBone.BoneName, &MirroredRawTrack);
|
||
MirrorSequenceController.AddBoneCurve(CurrentBone.BoneName);
|
||
MirrorSequenceController.SetBoneTrackKeys(CurrentBone.BoneName,
|
||
MirroredRawTrack.InternalTrackData.PosKeys,
|
||
MirroredRawTrack.InternalTrackData.RotKeys,
|
||
MirroredRawTrack.InternalTrackData.ScaleKeys);
|
||
}
|
||
}
|
||
//MirrorSequence->ClearBakedTransformData();
|
||
MirrorSequenceController.RemoveAllCurvesOfType(ERawCurveTrackTypes::RCT_Transform);
|
||
MirrorSequence->MarkPackageDirty();
|
||
}
|
||
}
|
||
|
||
|
||
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 FTransform3f(Skeleton->GetReferenceSkeleton().GetRefBonePose()[BoneTreeIndex]);
|
||
}
|
||
FTransform BoneTM = FTransform::Identity;
|
||
AnimSeq->GetBoneTransform(BoneTM, BoneTrackIndex, AnimTime, true);
|
||
return FTransform3f(BoneTM);
|
||
}
|
||
|
||
static FTransform3f GetAnimBoneCSTM(UAnimSequence* AnimSeq, const int32 BoneTreeIndex, const float AnimTime)
|
||
{
|
||
USkeleton* Skeleton = AnimSeq->GetSkeleton();
|
||
const auto& RefSkeleton = Skeleton->GetReferenceSkeleton();
|
||
FTransform3f BoneTMWS = GetAnimBoneTM(AnimSeq, BoneTreeIndex, AnimTime);
|
||
int32 CurrBone = BoneTreeIndex;
|
||
while (true)
|
||
{
|
||
const int32 Parent(RefSkeleton.GetParentIndex(CurrBone));
|
||
if (Parent < 0)
|
||
{
|
||
break;
|
||
}
|
||
BoneTMWS = BoneTMWS * GetAnimBoneTM(AnimSeq, Parent, AnimTime);
|
||
|
||
CurrBone = Parent;
|
||
}
|
||
return BoneTMWS;
|
||
}
|
||
|
||
MIRRORANIMATIONSYSTEMDEV_API void UMASFunctionLibrary::CreateMirrorSequenceFromAnimSequence_CS(
|
||
UAnimSequence* MirrorSequence,
|
||
const TEnumAsByte<EAxis::Type> MirrorAxis,
|
||
const FString Substring_A,
|
||
const FString Substring_B,
|
||
const bool Symmetrical)
|
||
{
|
||
IAnimationDataController& Controller = MirrorSequence->GetController();
|
||
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->GetReferenceSkeleton().GetRawBoneNum());
|
||
|
||
TArray<FIntPoint> TwinPairs;
|
||
TArray<int32> NonTwinIDs;
|
||
TArray<EAxis::Type> NonTwinFlipAxis;
|
||
FMASUtils::CSMirrorSettings(RefSkeleton, MirrorAxis, Substring_A, Substring_B, TwinPairs, NonTwinIDs,
|
||
NonTwinFlipAxis);
|
||
|
||
const bool DeltaStep = !Symmetrical;
|
||
|
||
FVector3f TwinMirrorScale = FVector3f(1.f);
|
||
FVector TargetAxis = FVector::ZeroVector;
|
||
|
||
check(MirrorAxis != EAxis::None);
|
||
{
|
||
TwinMirrorScale[MirrorAxis - 1] = -1.f;
|
||
TargetAxis[MirrorAxis - 1] = 1.f;
|
||
}
|
||
FTransform3f TwinMirrorModTM(FQuat4f::Identity, FVector3f::ZeroVector, TwinMirrorScale);
|
||
|
||
|
||
TMap<int32, FRawAnimSequenceTrack> BoneTracks;
|
||
|
||
for (int32 i = 0; i < RefSkeleton.GetNum(); i++)
|
||
{
|
||
BoneTracks.Add(i, FRawAnimSequenceTrack());
|
||
}
|
||
|
||
for (int32 j = 0; j < NumFrames; j++)
|
||
{
|
||
TArray<FTransform3f> NewCSTMs;
|
||
NewCSTMs.SetNum(RefSkeleton.GetNum());
|
||
|
||
for (int32 i = 0; i < NonTwinIDs.Num(); i++)
|
||
{
|
||
int32 BoneTreeIndex = NonTwinIDs[i];
|
||
int32 BoneTrackIndex = Skeleton->GetRawAnimationTrackIndex(BoneTreeIndex, MirrorSequence);
|
||
|
||
if (BoneTrackIndex == INDEX_NONE)
|
||
{
|
||
const int32 ParentIndex = RefSkeleton.GetParentIndex(BoneTreeIndex);
|
||
if (ParentIndex != INDEX_NONE)
|
||
{
|
||
NewCSTMs[BoneTreeIndex] = FTransform3f(RefSkeleton.GetRefBonePose()[BoneTreeIndex]) * NewCSTMs[
|
||
ParentIndex];
|
||
}
|
||
else
|
||
{
|
||
NewCSTMs[BoneTreeIndex] = FTransform3f(RefSkeleton.GetRefBonePose()[BoneTreeIndex]);
|
||
}
|
||
|
||
continue;
|
||
}
|
||
|
||
FTransform3f CSTM = GetAnimBoneCSTM(MirrorSequence, BoneTreeIndex, DT * j);
|
||
CSTM.Mirror(MirrorAxis, NonTwinFlipAxis[i]);
|
||
|
||
NewCSTMs[BoneTreeIndex] = CSTM;
|
||
}
|
||
|
||
|
||
for (int32 i = 0; i < TwinPairs.Num(); i++)
|
||
{
|
||
const int32 BoneIndex = TwinPairs[i].X;
|
||
const FCompactPoseBoneIndex CmptBoneIndex(BoneIndex);
|
||
|
||
const int32 TwinBoneIndex = TwinPairs[i].Y;
|
||
|
||
const FCompactPoseBoneIndex TwinCmptBoneIndex(TwinBoneIndex);
|
||
|
||
const FTransform3f RefTM = FTransform3f(
|
||
FAnimationRuntime::GetComponentSpaceTransformRefPose(RefSkeleton, BoneIndex));
|
||
const FTransform3f TwinRefTM = FTransform3f(
|
||
FAnimationRuntime::GetComponentSpaceTransformRefPose(RefSkeleton, TwinBoneIndex));
|
||
|
||
const FTransform3f TM = GetAnimBoneCSTM(MirrorSequence, BoneIndex, DT * j);
|
||
//Output.Pose.GetComponentSpaceTransform(CmptBoneIndex);
|
||
const FTransform3f TwinTM = GetAnimBoneCSTM(MirrorSequence, TwinBoneIndex, DT * j);
|
||
//Output.Pose.GetComponentSpaceTransform(TwinCmptBoneIndex);
|
||
|
||
const int32 ParentIndex = RefSkeleton.GetParentIndex(BoneIndex);
|
||
const int32 TwinParentIndex = RefSkeleton.GetParentIndex(TwinBoneIndex);
|
||
|
||
const bool SameParent = ParentIndex == TwinParentIndex;
|
||
|
||
// twin 1<>
|
||
{
|
||
const UE::Math::TTransform<float> MirrRef = RefTM * TwinMirrorModTM;
|
||
const FTransform3f Delta = TwinRefTM.GetRelativeTransform(MirrRef);
|
||
const FQuat4f DeltaQuat = Delta.GetRotation();
|
||
|
||
FTransform3f MirrTM = TM * TwinMirrorModTM;
|
||
|
||
MirrTM.SetRotation(MirrTM.GetRotation() * FQuat4f(DeltaQuat));
|
||
MirrTM.SetScale3D(TwinTM.GetScale3D());
|
||
|
||
if (DeltaStep)
|
||
{
|
||
if (SameParent)
|
||
{
|
||
FTransform3f RefBS = RefTM;
|
||
RefBS = RefBS * TwinMirrorModTM;
|
||
const FVector3f PosDelta = MirrTM.GetLocation() - RefBS.GetLocation();
|
||
MirrTM.SetLocation(FVector3f(TwinRefTM.GetLocation()) + PosDelta);
|
||
}
|
||
else
|
||
{
|
||
const FTransform3f& ParentTwinTM = NewCSTMs[RefSkeleton.GetParentIndex(TwinBoneIndex)];
|
||
const FTransform3f& IParentTM =
|
||
// Output.Pose.GetComponentSpaceTransform(FCompactPoseBoneIndex(ParentIndex));
|
||
GetAnimBoneCSTM(MirrorSequence, ParentIndex, DT * j);
|
||
FTransform3f RefBS = FTransform3f(RefSkeleton.GetRefBonePose()[BoneIndex]) * IParentTM;
|
||
RefBS = RefBS * TwinMirrorModTM;
|
||
RefBS.SetRotation(RefBS.GetRotation() * DeltaQuat);
|
||
RefBS.SetScale3D(TwinTM.GetScale3D());
|
||
|
||
MirrTM = (MirrTM.GetRelativeTransform(RefBS) * FTransform3f(
|
||
RefSkeleton.GetRefBonePose()[TwinBoneIndex])) * ParentTwinTM;
|
||
}
|
||
}
|
||
|
||
NewCSTMs[TwinBoneIndex] = MirrTM;
|
||
}
|
||
|
||
// twin 2<>
|
||
{
|
||
FTransform3f TwinMirrRef = TwinRefTM * TwinMirrorModTM;
|
||
const FQuat4f TwinDeltaQuat = TwinMirrRef.GetRotation().Inverse() * RefTM.GetRotation();
|
||
|
||
FTransform3f TwinMirrTM = TwinTM * TwinMirrorModTM;
|
||
|
||
TwinMirrTM.SetRotation(TwinMirrTM.GetRotation() * TwinDeltaQuat);
|
||
TwinMirrTM.SetScale3D(TM.GetScale3D());
|
||
|
||
if (DeltaStep)
|
||
{
|
||
if (SameParent)
|
||
{
|
||
FTransform3f TwinRefBS = TwinRefTM;
|
||
TwinRefBS = TwinRefBS * TwinMirrorModTM;
|
||
const FVector3f PosDelta = TwinMirrTM.GetLocation() - TwinRefBS.GetLocation();
|
||
TwinMirrTM.SetLocation(RefTM.GetLocation() + PosDelta);
|
||
}
|
||
else
|
||
{
|
||
const FTransform3f& ParentTM = NewCSTMs[RefSkeleton.GetParentIndex(BoneIndex)];
|
||
const FTransform3f& IParentTwinTM =
|
||
//Output.Pose.GetComponentSpaceTransform(FCompactPoseBoneIndex(TwinParentIndex));
|
||
GetAnimBoneCSTM(MirrorSequence, TwinParentIndex, DT * j);
|
||
FTransform3f TwinRefBS = FTransform3f(RefSkeleton.GetRefBonePose()[TwinBoneIndex]) *
|
||
IParentTwinTM;
|
||
TwinRefBS = TwinRefBS * TwinMirrorModTM;
|
||
TwinRefBS.SetRotation(TwinRefBS.GetRotation() * TwinDeltaQuat);
|
||
TwinRefBS.SetScale3D(TM.GetScale3D());
|
||
|
||
TwinMirrTM = (TwinMirrTM.GetRelativeTransform(TwinRefBS) * FTransform3f(
|
||
RefSkeleton.GetRefBonePose()[BoneIndex]) * ParentTM);
|
||
}
|
||
}
|
||
|
||
NewCSTMs[BoneIndex] = TwinMirrTM;
|
||
}
|
||
}
|
||
|
||
|
||
for (int32 i = 0; i < NewCSTMs.Num(); i++)
|
||
{
|
||
const int32 ParentIndex = RefSkeleton.GetParentIndex(i);
|
||
FTransform3f BSTM;
|
||
if (ParentIndex != INDEX_NONE)
|
||
{
|
||
BSTM = NewCSTMs[i].GetRelativeTransform(NewCSTMs[ParentIndex]);
|
||
}
|
||
else
|
||
{
|
||
BSTM = NewCSTMs[i];
|
||
}
|
||
|
||
auto& BoneTrack = BoneTracks[i];
|
||
BoneTrack.PosKeys.Add(BSTM.GetLocation());
|
||
BoneTrack.RotKeys.Add(BSTM.GetRotation());
|
||
BoneTrack.ScaleKeys.Add(BSTM.GetScale3D());
|
||
}
|
||
}
|
||
|
||
for (auto Pair : BoneTracks)
|
||
{
|
||
const FName TrackName = Skeleton->GetReferenceSkeleton().GetBoneName(Pair.Key);
|
||
//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->MarkPackageDirty();
|
||
}
|
||
|
||
#endif
|
||
|
||
#undef LOCTEXT_NAMESPACE
|