1134 lines
46 KiB
C++
1134 lines
46 KiB
C++
|
// Copyright Epic Games, Inc. All Rights Reserved.
|
||
|
|
|
||
|
|
#include "CoreMinimal.h"
|
||
|
|
#include "UObject/ObjectMacros.h"
|
||
|
|
#include "GameFramework/Actor.h"
|
||
|
|
#include "Camera/CameraActor.h"
|
||
|
|
#include "Camera/CameraComponent.h"
|
||
|
|
#include "Editor.h"
|
||
|
|
#include "Matinee/MatineeActorCameraAnim.h"
|
||
|
|
#include "Matinee/InterpGroup.h"
|
||
|
|
#include "Matinee/InterpGroupInst.h"
|
||
|
|
#include "Matinee/InterpData.h"
|
||
|
|
#include "Matinee/InterpTrackMove.h"
|
||
|
|
#include "Matinee/InterpTrackMoveAxis.h"
|
||
|
|
#include "Matinee/InterpTrackInstMove.h"
|
||
|
|
#include "Matinee/InterpTrackFloatProp.h"
|
||
|
|
#include "Matinee/InterpTrackInstFloatProp.h"
|
||
|
|
|
||
|
|
#include "FbxImporter.h"
|
||
|
|
|
||
|
|
namespace UnFbx
|
||
|
|
{
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Retrieves whether there are any unknown camera instances within the FBX document that the camera is not in Unreal scene.
|
||
|
|
*/
|
||
|
|
inline bool _HasUnknownCameras(AMatineeActor* InMatineeActor, FbxNode* Node, const TCHAR* Name)
|
||
|
|
{
|
||
|
|
FbxNodeAttribute* Attr = Node->GetNodeAttribute();
|
||
|
|
if (Attr && Attr->GetAttributeType() == FbxNodeAttribute::eCamera)
|
||
|
|
{
|
||
|
|
// If we have a Matinee, try to name-match the node with a Matinee group name
|
||
|
|
if (InMatineeActor != NULL && InMatineeActor->MatineeData != NULL)
|
||
|
|
{
|
||
|
|
UInterpGroupInst* GroupInst = InMatineeActor->FindFirstGroupInstByName(FString(Name));
|
||
|
|
if (GroupInst != NULL)
|
||
|
|
{
|
||
|
|
AActor* GrActor = GroupInst->GetGroupActor();
|
||
|
|
// Make sure we have an actor
|
||
|
|
if (GrActor != NULL &&
|
||
|
|
GrActor->IsA(ACameraActor::StaticClass()))
|
||
|
|
{
|
||
|
|
// OK, we found an existing camera!
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Attempt to name-match the scene node for this camera with one of the actors.
|
||
|
|
AActor* Actor = FindObject<AActor>(ANY_PACKAGE, Name);
|
||
|
|
if (Actor == NULL || Actor->IsPendingKill())
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// If you trigger this assertion, then you've got a name
|
||
|
|
// clash between the FBX file and the level.
|
||
|
|
check(Actor->IsA(ACameraActor::StaticClass()));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool FFbxImporter::HasUnknownCameras(AMatineeActor* InMatineeActor) const
|
||
|
|
{
|
||
|
|
if (Scene == NULL)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check recursively
|
||
|
|
FbxNode* RootNode = Scene->GetRootNode();
|
||
|
|
int32 NodeCount = RootNode->GetChildCount();
|
||
|
|
for (int32 NodeIndex = 0; NodeIndex < NodeCount; ++NodeIndex)
|
||
|
|
{
|
||
|
|
FbxNode* Node = RootNode->GetChild(NodeIndex);
|
||
|
|
if (_HasUnknownCameras(InMatineeActor, Node, UTF8_TO_TCHAR(Node->GetName())))
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Look through children as well
|
||
|
|
int32 ChildNodeCount = Node->GetChildCount();
|
||
|
|
for (int32 ChildIndex = 0; ChildIndex < ChildNodeCount; ++ChildIndex)
|
||
|
|
{
|
||
|
|
FbxNode* ChildNode = Node->GetChild(ChildIndex);
|
||
|
|
if (_HasUnknownCameras(InMatineeActor, ChildNode, UTF8_TO_TCHAR(ChildNode->GetName())))
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool FFbxImporter::IsNodeAnimated(FbxNode* Node, FbxAnimLayer* AnimLayer)
|
||
|
|
{
|
||
|
|
if (!AnimLayer)
|
||
|
|
{
|
||
|
|
FbxAnimStack* AnimStack = Scene->GetMember<FbxAnimStack>(0);
|
||
|
|
if (!AnimStack)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
AnimLayer = AnimStack->GetMember<FbxAnimLayer>(0);
|
||
|
|
if (AnimLayer == NULL)
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// verify that the node is animated.
|
||
|
|
bool bIsAnimated = false;
|
||
|
|
FbxTimeSpan AnimTimeSpan(FBXSDK_TIME_INFINITE, FBXSDK_TIME_MINUS_INFINITE);
|
||
|
|
|
||
|
|
// translation animation
|
||
|
|
FbxProperty TransProp = Node->LclTranslation;
|
||
|
|
for (int32 i = 0; i < TransProp.GetSrcObjectCount<FbxAnimCurveNode>(); i++)
|
||
|
|
{
|
||
|
|
FbxAnimCurveNode* CurveNode = TransProp.GetSrcObject<FbxAnimCurveNode>(i);
|
||
|
|
if (CurveNode && AnimLayer->IsConnectedSrcObject(CurveNode))
|
||
|
|
{
|
||
|
|
bIsAnimated |= (bool)CurveNode->GetAnimationInterval(AnimTimeSpan);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// rotation animation
|
||
|
|
FbxProperty RotProp = Node->LclRotation;
|
||
|
|
for (int32 i = 0; bIsAnimated == false && i < RotProp.GetSrcObjectCount<FbxAnimCurveNode>(); i++)
|
||
|
|
{
|
||
|
|
FbxAnimCurveNode* CurveNode = RotProp.GetSrcObject<FbxAnimCurveNode>(i);
|
||
|
|
if (CurveNode && AnimLayer->IsConnectedSrcObject(CurveNode))
|
||
|
|
{
|
||
|
|
bIsAnimated |= (bool)CurveNode->GetAnimationInterval(AnimTimeSpan);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return bIsAnimated;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Finds a camera in the passed in node or any child nodes
|
||
|
|
* @return NULL if the camera is not found, a valid pointer if it is
|
||
|
|
*/
|
||
|
|
static FbxCamera* FindCamera(FbxNode* Parent)
|
||
|
|
{
|
||
|
|
FbxCamera* Camera = Parent->GetCamera();
|
||
|
|
if (!Camera)
|
||
|
|
{
|
||
|
|
int32 NodeCount = Parent->GetChildCount();
|
||
|
|
for (int32 NodeIndex = 0; NodeIndex < NodeCount && !Camera; ++NodeIndex)
|
||
|
|
{
|
||
|
|
FbxNode* Child = Parent->GetChild(NodeIndex);
|
||
|
|
Camera = Child->GetCamera();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return Camera;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool FFbxImporter::ImportMatineeSequence(AMatineeActor* InMatineeActor)
|
||
|
|
{
|
||
|
|
if (Scene == NULL || InMatineeActor == NULL)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
// merge animation layer at first
|
||
|
|
FbxAnimStack* AnimStack = Scene->GetMember<FbxAnimStack>(0);
|
||
|
|
if (!AnimStack)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
FbxAnimLayer* AnimLayer = AnimStack->GetMember<FbxAnimLayer>(0);
|
||
|
|
if (AnimLayer == NULL)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
// If the Matinee editor is not open, we need to initialize the sequence.
|
||
|
|
// bool InitializeMatinee = InMatineeActor->MatineeData == NULL;
|
||
|
|
// if (InitializeMatinee)
|
||
|
|
//{
|
||
|
|
// Force the initialization of the sequence
|
||
|
|
// This sets the sequence in editor mode as well?
|
||
|
|
// InMatineeActor->InitInterp();
|
||
|
|
//}
|
||
|
|
|
||
|
|
UInterpData* MatineeData = InMatineeActor->MatineeData;
|
||
|
|
float InterpLength = -1.0f;
|
||
|
|
|
||
|
|
FbxNode* RootNode = Scene->GetRootNode();
|
||
|
|
int32 NodeCount = RootNode->GetChildCount();
|
||
|
|
for (int32 NodeIndex = 0; NodeIndex < NodeCount; ++NodeIndex)
|
||
|
|
{
|
||
|
|
FbxNode* Node = RootNode->GetChild(NodeIndex);
|
||
|
|
|
||
|
|
AActor* Actor = NULL;
|
||
|
|
|
||
|
|
const bool bIsCameraAnim = InMatineeActor->IsA<AMatineeActorCameraAnim>();
|
||
|
|
|
||
|
|
// Find a group instance to import into
|
||
|
|
UInterpGroupInst* FoundGroupInst = nullptr;
|
||
|
|
if (bIsCameraAnim)
|
||
|
|
{
|
||
|
|
// We can only ever import into the camera anim group
|
||
|
|
FoundGroupInst = InMatineeActor->GroupInst[0];
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Check to see if the scene node name matches a Matinee group name
|
||
|
|
FoundGroupInst = InMatineeActor->FindFirstGroupInstByName(FString(Node->GetName()));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (FoundGroupInst != NULL)
|
||
|
|
{
|
||
|
|
// OK, we found an actor bound to a Matinee group that matches this scene node name
|
||
|
|
Actor = FoundGroupInst->GetGroupActor();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Attempt to name-match the scene node with one of the actors.
|
||
|
|
if (Actor == NULL)
|
||
|
|
{
|
||
|
|
Actor = FindObject<AActor>(ANY_PACKAGE, UTF8_TO_TCHAR(Node->GetName()));
|
||
|
|
}
|
||
|
|
|
||
|
|
FbxCamera* CameraNode = NULL;
|
||
|
|
if (Actor == NULL || Actor->IsPendingKill())
|
||
|
|
{
|
||
|
|
CameraNode = FindCamera(Node);
|
||
|
|
if (bCreateUnknownCameras && CameraNode != NULL)
|
||
|
|
{
|
||
|
|
Actor = GEditor->AddActor(InMatineeActor->GetWorld()->GetCurrentLevel(), ACameraActor::StaticClass(), FTransform::Identity);
|
||
|
|
Actor->SetActorLabel(UTF8_TO_TCHAR(CameraNode->GetName()));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
UInterpGroupInst* MatineeGroup = InMatineeActor->FindGroupInst(Actor);
|
||
|
|
|
||
|
|
// Before attempting to create/import a movement track: verify that the node is animated.
|
||
|
|
bool IsAnimated = IsNodeAnimated(Node, AnimLayer);
|
||
|
|
|
||
|
|
if (IsAnimated)
|
||
|
|
{
|
||
|
|
if (MatineeGroup == NULL)
|
||
|
|
{
|
||
|
|
MatineeGroup = CreateMatineeGroup(InMatineeActor, Actor, FString(Node->GetName()));
|
||
|
|
}
|
||
|
|
else if (bIsCameraAnim)
|
||
|
|
{
|
||
|
|
MatineeGroup->Group->GroupName = Node->GetName();
|
||
|
|
}
|
||
|
|
|
||
|
|
float TimeLength = ImportMatineeActor(Node, MatineeGroup);
|
||
|
|
InterpLength = FMath::Max(InterpLength, TimeLength);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Right now, cameras are the only supported import entity type.
|
||
|
|
if (Actor->IsA(ACameraActor::StaticClass()))
|
||
|
|
{
|
||
|
|
// there is a pivot node between the FbxNode and node attribute
|
||
|
|
if (!CameraNode)
|
||
|
|
{
|
||
|
|
CameraNode = FindCamera(Node);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (CameraNode)
|
||
|
|
{
|
||
|
|
if (MatineeGroup == NULL)
|
||
|
|
{
|
||
|
|
MatineeGroup = CreateMatineeGroup(InMatineeActor, Actor, FString(Node->GetName()));
|
||
|
|
}
|
||
|
|
else if (bIsCameraAnim)
|
||
|
|
{
|
||
|
|
MatineeGroup->Group->GroupName = Node->GetName();
|
||
|
|
}
|
||
|
|
|
||
|
|
ImportCamera((ACameraActor*)Actor, MatineeGroup, CameraNode);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (MatineeGroup != NULL)
|
||
|
|
{
|
||
|
|
MatineeGroup->Modify();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
MatineeData->InterpLength = (InterpLength < 0.0f) ? 5.0f : InterpLength;
|
||
|
|
InMatineeActor->Modify();
|
||
|
|
|
||
|
|
return true;
|
||
|
|
// if (InitializeMatinee)
|
||
|
|
//{
|
||
|
|
// InMatineeActor->TermInterp();
|
||
|
|
// }
|
||
|
|
}
|
||
|
|
|
||
|
|
void FFbxImporter::ImportCamera(ACameraActor* Actor, UInterpGroupInst* MatineeGroup, FbxCamera* Camera)
|
||
|
|
{
|
||
|
|
// Get the real camera node that stores customed camera attributes
|
||
|
|
// Note: there is a pivot node between the Fbx camera Node and node attribute
|
||
|
|
FbxNode* FbxCameraNode = Camera->GetNode()->GetParent();
|
||
|
|
// Import the aspect ratio
|
||
|
|
Actor->GetCameraComponent()->AspectRatio = Camera->FilmAspectRatio.Get(); // Assumes the FBX comes from Unreal or Maya
|
||
|
|
ImportAnimatedProperty(&Actor->GetCameraComponent()->AspectRatio, TEXT("AspectRatio"), MatineeGroup,
|
||
|
|
Actor->GetCameraComponent()->AspectRatio, FbxCameraNode->FindProperty("UE_AspectRatio"));
|
||
|
|
|
||
|
|
FbxPropertyT<FbxDouble> AperatureModeProperty;
|
||
|
|
|
||
|
|
if (Camera->FocalLength.IsValid() && Camera->GetApertureMode() == FbxCamera::eFocalLength)
|
||
|
|
{
|
||
|
|
Actor->GetCameraComponent()->FieldOfView = Camera->ComputeFieldOfView(Camera->FocalLength.Get()); // Assumes the FBX comes from Unreal or Maya
|
||
|
|
|
||
|
|
AperatureModeProperty = Camera->FocalLength;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Actor->GetCameraComponent()->FieldOfView = Camera->FieldOfView.Get();
|
||
|
|
|
||
|
|
AperatureModeProperty = Camera->FieldOfView;
|
||
|
|
}
|
||
|
|
|
||
|
|
ImportAnimatedProperty(&Actor->GetCameraComponent()->FieldOfView, TEXT("FOVAngle"), MatineeGroup, AperatureModeProperty.Get(), AperatureModeProperty, true, Camera);
|
||
|
|
}
|
||
|
|
|
||
|
|
void FFbxImporter::ImportAnimatedProperty(float* Value, const TCHAR* ValueName, UInterpGroupInst* MatineeGroup, const float FbxValue, FbxProperty InProperty, bool bImportFOV, FbxCamera* Camera)
|
||
|
|
{
|
||
|
|
if (Scene == NULL || Value == NULL || MatineeGroup == NULL)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Retrieve the FBX animated element for this value and verify that it contains an animation curve.
|
||
|
|
if (!InProperty.IsValid() || !InProperty.GetFlag(FbxPropertyFlags::eAnimatable))
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// verify the animation curve and it has valid key
|
||
|
|
FbxAnimCurveNode* CurveNode = InProperty.GetCurveNode();
|
||
|
|
if (!CurveNode)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
FbxAnimCurve* FbxCurve = CurveNode->GetCurve(0U);
|
||
|
|
if (!FbxCurve || FbxCurve->KeyGetCount() <= 1)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
*Value = FbxValue;
|
||
|
|
|
||
|
|
// Look for a track for this property in the Matinee group.
|
||
|
|
UInterpTrackFloatProp* PropertyTrack = NULL;
|
||
|
|
int32 TrackCount = MatineeGroup->Group->InterpTracks.Num();
|
||
|
|
for (int32 TrackIndex = 0; TrackIndex < TrackCount; ++TrackIndex)
|
||
|
|
{
|
||
|
|
UInterpTrackFloatProp* Track = Cast<UInterpTrackFloatProp>(MatineeGroup->Group->InterpTracks[TrackIndex]);
|
||
|
|
if (Track != NULL && Track->PropertyName == ValueName)
|
||
|
|
{
|
||
|
|
PropertyTrack = Track;
|
||
|
|
PropertyTrack->FloatTrack.Reset(); // Remove all the existing keys from this track.
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// If a track for this property was not found, create one.
|
||
|
|
if (PropertyTrack == NULL)
|
||
|
|
{
|
||
|
|
PropertyTrack = NewObject<UInterpTrackFloatProp>(MatineeGroup->Group, NAME_None, RF_Transactional);
|
||
|
|
MatineeGroup->Group->InterpTracks.Add(PropertyTrack);
|
||
|
|
UInterpTrackInstFloatProp* PropertyTrackInst = NewObject<UInterpTrackInstFloatProp>(MatineeGroup, NAME_None, RF_Transactional);
|
||
|
|
MatineeGroup->TrackInst.Add(PropertyTrackInst);
|
||
|
|
PropertyTrack->PropertyName = ValueName;
|
||
|
|
PropertyTrack->TrackTitle = ValueName;
|
||
|
|
PropertyTrackInst->InitTrackInst(PropertyTrack);
|
||
|
|
}
|
||
|
|
FInterpCurveFloat& Curve = PropertyTrack->FloatTrack;
|
||
|
|
|
||
|
|
int32 KeyCount = FbxCurve->KeyGetCount();
|
||
|
|
// create each key in the first path
|
||
|
|
// for animation curve for all property in one track, they share time and interpolation mode in animation keys
|
||
|
|
for (int32 KeyIndex = Curve.Points.Num(); KeyIndex < KeyCount; ++KeyIndex)
|
||
|
|
{
|
||
|
|
FbxAnimCurveKey CurKey = FbxCurve->KeyGet(KeyIndex);
|
||
|
|
|
||
|
|
// Create the curve keys
|
||
|
|
FInterpCurvePoint<float> Key;
|
||
|
|
Key.InVal = CurKey.GetTime().GetSecondDouble();
|
||
|
|
|
||
|
|
Key.InterpMode = GetUnrealInterpMode(CurKey);
|
||
|
|
|
||
|
|
// Add this new key to the curve
|
||
|
|
Curve.Points.Add(Key);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Fill in the curve keys with the correct data for this dimension.
|
||
|
|
for (int32 KeyIndex = 0; KeyIndex < KeyCount; ++KeyIndex)
|
||
|
|
{
|
||
|
|
FbxAnimCurveKey CurKey = FbxCurve->KeyGet(KeyIndex);
|
||
|
|
FInterpCurvePoint<float>& UnrealKey = Curve.Points[KeyIndex];
|
||
|
|
|
||
|
|
float OutVal;
|
||
|
|
|
||
|
|
if (bImportFOV && Camera && Camera->GetApertureMode() == FbxCamera::eFocalLength)
|
||
|
|
{
|
||
|
|
OutVal = Camera->ComputeFieldOfView(CurKey.GetValue());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
OutVal = CurKey.GetValue();
|
||
|
|
}
|
||
|
|
|
||
|
|
float ArriveTangent = 0.0f;
|
||
|
|
float LeaveTangent = 0.0f;
|
||
|
|
|
||
|
|
// Convert the Bezier control points, if available, into Hermite tangents
|
||
|
|
if (CurKey.GetInterpolation() == FbxAnimCurveDef::eInterpolationCubic)
|
||
|
|
{
|
||
|
|
float LeftTangent = FbxCurve->KeyGetLeftDerivative(KeyIndex);
|
||
|
|
float RightTangent = FbxCurve->KeyGetRightDerivative(KeyIndex);
|
||
|
|
|
||
|
|
if (KeyIndex > 0)
|
||
|
|
{
|
||
|
|
ArriveTangent = LeftTangent * (CurKey.GetTime().GetSecondDouble() - FbxCurve->KeyGetTime(KeyIndex - 1).GetSecondDouble());
|
||
|
|
}
|
||
|
|
|
||
|
|
if (KeyIndex < KeyCount - 1)
|
||
|
|
{
|
||
|
|
LeaveTangent = RightTangent * (FbxCurve->KeyGetTime(KeyIndex + 1).GetSecondDouble() - CurKey.GetTime().GetSecondDouble());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
UnrealKey.OutVal = OutVal;
|
||
|
|
UnrealKey.ArriveTangent = ArriveTangent;
|
||
|
|
UnrealKey.LeaveTangent = LeaveTangent;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
UInterpGroupInst* FFbxImporter::CreateMatineeGroup(AMatineeActor* InMatineeActor, AActor* Actor, FString GroupName)
|
||
|
|
{
|
||
|
|
// There are no groups for this actor: create the Matinee group data structure.
|
||
|
|
UInterpGroup* MatineeGroupData = NewObject<UInterpGroup>(InMatineeActor->MatineeData, NAME_None, RF_Transactional);
|
||
|
|
MatineeGroupData->GroupName = FName(*GroupName);
|
||
|
|
InMatineeActor->MatineeData->InterpGroups.Add(MatineeGroupData);
|
||
|
|
|
||
|
|
// Instantiate the Matinee group data structure.
|
||
|
|
UInterpGroupInst* MatineeGroup = NewObject<UInterpGroupInst>(InMatineeActor, NAME_None, RF_Transactional);
|
||
|
|
InMatineeActor->GroupInst.Add(MatineeGroup);
|
||
|
|
MatineeGroup->InitGroupInst(MatineeGroupData, Actor);
|
||
|
|
MatineeGroup->SaveGroupActorState();
|
||
|
|
InMatineeActor->InitGroupActorForGroup(MatineeGroupData, Actor);
|
||
|
|
|
||
|
|
return MatineeGroup;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Imports a FBX scene node into a Matinee actor group.
|
||
|
|
*/
|
||
|
|
float FFbxImporter::ImportMatineeActor(FbxNode* Node, UInterpGroupInst* MatineeGroup)
|
||
|
|
{
|
||
|
|
FName DefaultName(NAME_None);
|
||
|
|
|
||
|
|
if (Scene == NULL || Node == NULL || MatineeGroup == NULL)
|
||
|
|
return -1.0f;
|
||
|
|
|
||
|
|
// Bake the pivots.
|
||
|
|
// Based in sample code in kfbxnode.h, re: Pivot Management
|
||
|
|
{
|
||
|
|
FbxVector4 ZeroVector(0, 0, 0);
|
||
|
|
Node->SetPivotState(FbxNode::eSourcePivot, FbxNode::ePivotActive);
|
||
|
|
Node->SetPivotState(FbxNode::eDestinationPivot, FbxNode::ePivotActive);
|
||
|
|
|
||
|
|
EFbxRotationOrder RotationOrder;
|
||
|
|
Node->GetRotationOrder(FbxNode::eSourcePivot, RotationOrder);
|
||
|
|
Node->SetRotationOrder(FbxNode::eDestinationPivot, RotationOrder);
|
||
|
|
|
||
|
|
// For cameras and lights (without targets) let's compensate the postrotation.
|
||
|
|
if (Node->GetCamera() || Node->GetLight())
|
||
|
|
{
|
||
|
|
if (!Node->GetTarget())
|
||
|
|
{
|
||
|
|
FbxVector4 RotationVector(90, 0, 0);
|
||
|
|
if (Node->GetCamera())
|
||
|
|
RotationVector.Set(0, 90, 0);
|
||
|
|
|
||
|
|
FbxAMatrix RotationMtx;
|
||
|
|
RotationMtx.SetR(RotationVector);
|
||
|
|
|
||
|
|
FbxVector4 PostRotationVector = Node->GetPostRotation(FbxNode::eSourcePivot);
|
||
|
|
|
||
|
|
// Rotation order don't affect post rotation, so just use the default XYZ order
|
||
|
|
FbxAMatrix lSourceR;
|
||
|
|
lSourceR.SetR(PostRotationVector);
|
||
|
|
|
||
|
|
RotationMtx = lSourceR * RotationMtx;
|
||
|
|
|
||
|
|
PostRotationVector = RotationMtx.GetR();
|
||
|
|
|
||
|
|
Node->SetPostRotation(FbxNode::eSourcePivot, PostRotationVector);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Point light do not need to be adjusted (since they radiate in all the directions).
|
||
|
|
if (Node->GetLight() && Node->GetLight()->LightType.Get() == FbxLight::ePoint)
|
||
|
|
{
|
||
|
|
Node->SetPostRotation(FbxNode::eSourcePivot, FbxVector4(0, 0, 0, 0));
|
||
|
|
}
|
||
|
|
|
||
|
|
// apply Pre rotations only on bones / end of chains
|
||
|
|
if ((Node->GetNodeAttribute() && Node->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::eSkeleton) || (Node->GetMarker() && Node->GetMarker()->GetType() == FbxMarker::eEffectorFK) || (Node->GetMarker() && Node->GetMarker()->GetType() == FbxMarker::eEffectorIK))
|
||
|
|
{
|
||
|
|
Node->SetPreRotation(FbxNode::eDestinationPivot, Node->GetPreRotation(FbxNode::eSourcePivot));
|
||
|
|
|
||
|
|
// No pivots on bones
|
||
|
|
Node->SetRotationPivot(FbxNode::eDestinationPivot, ZeroVector);
|
||
|
|
Node->SetScalingPivot(FbxNode::eDestinationPivot, ZeroVector);
|
||
|
|
Node->SetRotationOffset(FbxNode::eDestinationPivot, ZeroVector);
|
||
|
|
Node->SetScalingOffset(FbxNode::eDestinationPivot, ZeroVector);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// any other type: no pre-rotation support but...
|
||
|
|
Node->SetPreRotation(FbxNode::eDestinationPivot, ZeroVector);
|
||
|
|
|
||
|
|
// support for rotation and scaling pivots.
|
||
|
|
Node->SetRotationPivot(FbxNode::eDestinationPivot, Node->GetRotationPivot(FbxNode::eSourcePivot));
|
||
|
|
Node->SetScalingPivot(FbxNode::eDestinationPivot, Node->GetScalingPivot(FbxNode::eSourcePivot));
|
||
|
|
// Rotation and scaling offset are supported
|
||
|
|
Node->SetRotationOffset(FbxNode::eDestinationPivot, Node->GetRotationOffset(FbxNode::eSourcePivot));
|
||
|
|
Node->SetScalingOffset(FbxNode::eDestinationPivot, Node->GetScalingOffset(FbxNode::eSourcePivot));
|
||
|
|
//
|
||
|
|
// If we supported scaling pivots, we could simply do:
|
||
|
|
// Node->SetRotationPivot(FbxNode::eDESTINATION_SET, ZeroVector);
|
||
|
|
// Node->SetScalingPivot(FbxNode::eDESTINATION_SET, ZeroVector);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Recursively convert the animation data according to pivot settings.
|
||
|
|
Node->ConvertPivotAnimationRecursive(
|
||
|
|
NULL, // Use the first animation stack by default
|
||
|
|
FbxNode::eDestinationPivot, // Convert from Source set to Destination set
|
||
|
|
FbxTime::GetFrameRate(Scene->GetGlobalSettings().GetTimeMode()), // Resampling frame rate in frames per second
|
||
|
|
false); // Do not apply key reducing filter
|
||
|
|
}
|
||
|
|
|
||
|
|
// Search for a Movement track in the Matinee group.
|
||
|
|
UInterpTrackMove* MovementTrack = NULL;
|
||
|
|
int32 TrackCount = MatineeGroup->Group->InterpTracks.Num();
|
||
|
|
for (int32 TrackIndex = 0; TrackIndex < TrackCount && MovementTrack == NULL; ++TrackIndex)
|
||
|
|
{
|
||
|
|
MovementTrack = Cast<UInterpTrackMove>(MatineeGroup->Group->InterpTracks[TrackIndex]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check whether the actor should be pivoted in the FBX document.
|
||
|
|
|
||
|
|
AActor* Actor = MatineeGroup->GetGroupActor();
|
||
|
|
check(Actor != NULL); // would this ever be triggered?
|
||
|
|
|
||
|
|
// Find out whether the FBX node is animated.
|
||
|
|
// Bucket the transforms at the same time.
|
||
|
|
// The Matinee Movement track can take in a Translation vector
|
||
|
|
// and three animated Euler rotation angles.
|
||
|
|
FbxAnimStack* AnimStack = Scene->GetMember<FbxAnimStack>(0);
|
||
|
|
if (!AnimStack)
|
||
|
|
return -1.0f;
|
||
|
|
|
||
|
|
FbxAnimLayer* AnimLayer = AnimStack->GetMember<FbxAnimLayer>(0);
|
||
|
|
if (AnimLayer == NULL)
|
||
|
|
return -1.0f;
|
||
|
|
|
||
|
|
bool bNodeAnimated = IsNodeAnimated(Node, AnimLayer);
|
||
|
|
bool ForceImportSampling = false;
|
||
|
|
|
||
|
|
// Add a Movement track if the node is animated and the group does not already have one.
|
||
|
|
if (MovementTrack == NULL && bNodeAnimated)
|
||
|
|
{
|
||
|
|
MovementTrack = NewObject<UInterpTrackMove>(MatineeGroup->Group, NAME_None, RF_Transactional);
|
||
|
|
MatineeGroup->Group->InterpTracks.Add(MovementTrack);
|
||
|
|
UInterpTrackInstMove* MovementTrackInst = NewObject<UInterpTrackInstMove>(MatineeGroup, NAME_None, RF_Transactional);
|
||
|
|
MatineeGroup->TrackInst.Add(MovementTrackInst);
|
||
|
|
MovementTrackInst->InitTrackInst(MovementTrack);
|
||
|
|
}
|
||
|
|
|
||
|
|
// List of casted subtracks in this movement track.
|
||
|
|
TArray<UInterpTrackMoveAxis*> SubTracks;
|
||
|
|
|
||
|
|
// Remove all the keys in the Movement track
|
||
|
|
if (MovementTrack != NULL)
|
||
|
|
{
|
||
|
|
MovementTrack->PosTrack.Reset();
|
||
|
|
MovementTrack->EulerTrack.Reset();
|
||
|
|
MovementTrack->LookupTrack.Points.Reset();
|
||
|
|
|
||
|
|
if (MovementTrack->SubTracks.Num() > 0)
|
||
|
|
{
|
||
|
|
for (int32 SubTrackIndex = 0; SubTrackIndex < MovementTrack->SubTracks.Num(); ++SubTrackIndex)
|
||
|
|
{
|
||
|
|
UInterpTrackMoveAxis* SubTrack = CastChecked<UInterpTrackMoveAxis>(MovementTrack->SubTracks[SubTrackIndex]);
|
||
|
|
SubTrack->FloatTrack.Reset();
|
||
|
|
SubTrack->LookupTrack.Points.Reset();
|
||
|
|
SubTracks.Add(SubTrack);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
float TimeLength = -1.0f;
|
||
|
|
|
||
|
|
// Fill in the Movement track with the FBX keys
|
||
|
|
if (bNodeAnimated)
|
||
|
|
{
|
||
|
|
// Check: The position and rotation tracks must have the same number of keys, the same key timings and
|
||
|
|
// the same segment interpolation types.
|
||
|
|
FbxAnimCurve *TransCurves[6], *RealCurves[6];
|
||
|
|
|
||
|
|
TransCurves[0] = Node->LclTranslation.GetCurve(AnimLayer, FBXSDK_CURVENODE_COMPONENT_X, true);
|
||
|
|
TransCurves[1] = Node->LclTranslation.GetCurve(AnimLayer, FBXSDK_CURVENODE_COMPONENT_Y, true);
|
||
|
|
TransCurves[2] = Node->LclTranslation.GetCurve(AnimLayer, FBXSDK_CURVENODE_COMPONENT_Z, true);
|
||
|
|
|
||
|
|
TransCurves[3] = Node->LclRotation.GetCurve(AnimLayer, FBXSDK_CURVENODE_COMPONENT_X, true);
|
||
|
|
TransCurves[4] = Node->LclRotation.GetCurve(AnimLayer, FBXSDK_CURVENODE_COMPONENT_Y, true);
|
||
|
|
TransCurves[5] = Node->LclRotation.GetCurve(AnimLayer, FBXSDK_CURVENODE_COMPONENT_Z, true);
|
||
|
|
// remove empty curves
|
||
|
|
int32 CurveIndex;
|
||
|
|
int32 RealCurveNum = 0;
|
||
|
|
for (CurveIndex = 0; CurveIndex < 6; CurveIndex++)
|
||
|
|
{
|
||
|
|
if (TransCurves[CurveIndex] && TransCurves[CurveIndex]->KeyGetCount() > 1)
|
||
|
|
{
|
||
|
|
RealCurves[RealCurveNum++] = TransCurves[CurveIndex];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool bResample = false;
|
||
|
|
if (RealCurveNum > 1)
|
||
|
|
{
|
||
|
|
int32 KeyCount = RealCurves[0]->KeyGetCount();
|
||
|
|
// check key count of all curves
|
||
|
|
for (CurveIndex = 1; CurveIndex < RealCurveNum; CurveIndex++)
|
||
|
|
{
|
||
|
|
if (KeyCount != RealCurves[CurveIndex]->KeyGetCount())
|
||
|
|
{
|
||
|
|
bResample = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// check key time for each key
|
||
|
|
for (int32 KeyIndex = 0; !bResample && KeyIndex < KeyCount; KeyIndex++)
|
||
|
|
{
|
||
|
|
FbxTime KeyTime = RealCurves[0]->KeyGetTime(KeyIndex);
|
||
|
|
FbxAnimCurveDef::EInterpolationType Interpolation = RealCurves[0]->KeyGetInterpolation(KeyIndex);
|
||
|
|
// KFbxAnimCurveDef::ETangentMode Tangent = RealCurves[0]->KeyGetTangentMode(KeyIndex);
|
||
|
|
|
||
|
|
for (CurveIndex = 1; CurveIndex < RealCurveNum; CurveIndex++)
|
||
|
|
{
|
||
|
|
if (KeyTime != RealCurves[CurveIndex]->KeyGetTime(KeyIndex) ||
|
||
|
|
Interpolation != RealCurves[CurveIndex]->KeyGetInterpolation(KeyIndex)) // ||
|
||
|
|
// Tangent != RealCurves[CurveIndex]->KeyGetTangentMode(KeyIndex))
|
||
|
|
{
|
||
|
|
bResample = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (bResample)
|
||
|
|
{
|
||
|
|
// Get the re-sample time span
|
||
|
|
FbxTime Start, Stop;
|
||
|
|
Start = RealCurves[0]->KeyGetTime(0);
|
||
|
|
Stop = RealCurves[0]->KeyGetTime(RealCurves[0]->KeyGetCount() - 1);
|
||
|
|
for (CurveIndex = 1; CurveIndex < RealCurveNum; CurveIndex++)
|
||
|
|
{
|
||
|
|
if (Start > RealCurves[CurveIndex]->KeyGetTime(0))
|
||
|
|
{
|
||
|
|
Start = RealCurves[CurveIndex]->KeyGetTime(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Stop < RealCurves[CurveIndex]->KeyGetTime(RealCurves[CurveIndex]->KeyGetCount() - 1))
|
||
|
|
{
|
||
|
|
Stop = RealCurves[CurveIndex]->KeyGetTime(RealCurves[CurveIndex]->KeyGetCount() - 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
double ResampleRate;
|
||
|
|
ResampleRate = FbxTime::GetFrameRate(Scene->GetGlobalSettings().GetTimeMode());
|
||
|
|
FbxTime FramePeriod;
|
||
|
|
FramePeriod.SetSecondDouble(1.0 / ResampleRate);
|
||
|
|
|
||
|
|
for (CurveIndex = 0; CurveIndex < 6; CurveIndex++)
|
||
|
|
{
|
||
|
|
bool bRemoveConstantKey = false;
|
||
|
|
// for the constant animation curve, the key may be not in the resample time range,
|
||
|
|
// so we need to remove the constant key after resample,
|
||
|
|
// otherwise there must be one more key
|
||
|
|
if (TransCurves[CurveIndex]->KeyGetCount() == 1 && TransCurves[CurveIndex]->KeyGetTime(0) < Start)
|
||
|
|
{
|
||
|
|
bRemoveConstantKey = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// only re-sample from Start to Stop
|
||
|
|
FbxAnimCurveFilterResample CurveResampler;
|
||
|
|
CurveResampler.SetPeriodTime(FramePeriod);
|
||
|
|
CurveResampler.SetStartTime(Start);
|
||
|
|
CurveResampler.SetStopTime(Stop);
|
||
|
|
CurveResampler.SetKeysOnFrame(true);
|
||
|
|
CurveResampler.Apply(*TransCurves[CurveIndex]);
|
||
|
|
|
||
|
|
// remove the key that is not in the resample time range
|
||
|
|
// the constant key always at the time 0, so it is OK to remove the first key
|
||
|
|
if (bRemoveConstantKey)
|
||
|
|
{
|
||
|
|
TransCurves[CurveIndex]->KeyRemove(0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
FbxAMatrix Matrix = ComputeTotalMatrix(Node);
|
||
|
|
FbxVector4 DefaultPos = Node->LclTranslation.Get();
|
||
|
|
FbxVector4 DefaultRot = Node->LclRotation.Get();
|
||
|
|
|
||
|
|
FbxAMatrix FbxCamToUnrealRHMtx, InvFbxCamToUnrealRHMtx;
|
||
|
|
FbxAMatrix UnrealRHToUnrealLH, InUnrealRHToUnrealLH;
|
||
|
|
|
||
|
|
Actor->SetActorLocation(FVector(-DefaultPos[1], -DefaultPos[0], DefaultPos[2]), false);
|
||
|
|
|
||
|
|
bool bIsCamera = false;
|
||
|
|
if (!Node->GetCamera())
|
||
|
|
{
|
||
|
|
Actor->SetActorRotation(FRotator::MakeFromEuler(FVector(DefaultRot[0], -DefaultRot[1], -DefaultRot[2])));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Note: the camera rotations contain rotations from the Fbx Camera to the converted
|
||
|
|
// right-hand Unreal coordinates. So we must negate the Fbx Camera -> Unreal WorldRH, then convert
|
||
|
|
// the remaining rotation to left-handed coordinates
|
||
|
|
|
||
|
|
// Describing coordinate systems as <Up, Forward, Left>:
|
||
|
|
// Fbx Camera: < Y, -Z, -X>
|
||
|
|
// Unreal Right-handed World: < Z, -Y, X>
|
||
|
|
// Unreal Left-handed World: < Z, X, -Y>
|
||
|
|
|
||
|
|
FbxAMatrix DefaultRotMtx;
|
||
|
|
DefaultRotMtx.SetR(DefaultRot);
|
||
|
|
|
||
|
|
FbxCamToUnrealRHMtx[0] = FbxVector4(-1.f, 0.f, 0.f, 0.f);
|
||
|
|
FbxCamToUnrealRHMtx[1] = FbxVector4(0.f, 0.f, 1.f, 0.f);
|
||
|
|
FbxCamToUnrealRHMtx[2] = FbxVector4(0.f, 1.f, 0.f, 0.f);
|
||
|
|
InvFbxCamToUnrealRHMtx = FbxCamToUnrealRHMtx.Inverse();
|
||
|
|
|
||
|
|
UnrealRHToUnrealLH[0] = FbxVector4(0.f, 1.f, 0.f, 0.f);
|
||
|
|
UnrealRHToUnrealLH[1] = FbxVector4(1.f, 0.f, 0.f, 0.f);
|
||
|
|
UnrealRHToUnrealLH[2] = FbxVector4(0.f, 0.f, 1.f, 0.f);
|
||
|
|
InUnrealRHToUnrealLH = UnrealRHToUnrealLH.Inverse();
|
||
|
|
|
||
|
|
// Remove the FbxCamera's local to world rotation
|
||
|
|
FbxAMatrix UnrealCameraRotationMtx = DefaultRotMtx * InvFbxCamToUnrealRHMtx;
|
||
|
|
|
||
|
|
// Convert the remaining rotation into world space
|
||
|
|
UnrealCameraRotationMtx = UnrealRHToUnrealLH * UnrealCameraRotationMtx * InUnrealRHToUnrealLH;
|
||
|
|
|
||
|
|
FbxVector4 UnrealCameraRotationEuler = UnrealCameraRotationMtx.GetR();
|
||
|
|
|
||
|
|
Actor->SetActorRotation(FRotator::MakeFromEuler(FVector(UnrealCameraRotationEuler[0], UnrealCameraRotationEuler[1], UnrealCameraRotationEuler[2])));
|
||
|
|
bIsCamera = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (MovementTrack && MovementTrack->SubTracks.Num() > 0)
|
||
|
|
{
|
||
|
|
check(bIsCamera == false);
|
||
|
|
ImportMoveSubTrack(TransCurves[0], 0, SubTracks[0], 0, false, RealCurves[0], DefaultPos[0]);
|
||
|
|
ImportMoveSubTrack(TransCurves[1], 1, SubTracks[1], 1, true, RealCurves[0], DefaultPos[1]);
|
||
|
|
ImportMoveSubTrack(TransCurves[2], 2, SubTracks[2], 2, false, RealCurves[0], DefaultPos[2]);
|
||
|
|
ImportMoveSubTrack(TransCurves[3], 3, SubTracks[3], 0, false, RealCurves[0], DefaultRot[0]);
|
||
|
|
ImportMoveSubTrack(TransCurves[4], 4, SubTracks[4], 1, true, RealCurves[0], DefaultRot[1]);
|
||
|
|
ImportMoveSubTrack(TransCurves[5], 5, SubTracks[5], 2, true, RealCurves[0], DefaultRot[2]);
|
||
|
|
|
||
|
|
for (int32 SubTrackIndex = 0; SubTrackIndex < SubTracks.Num(); ++SubTrackIndex)
|
||
|
|
{
|
||
|
|
UInterpTrackMoveAxis* SubTrack = SubTracks[SubTrackIndex];
|
||
|
|
// Generate empty look-up keys.
|
||
|
|
int32 KeyIndex;
|
||
|
|
for (KeyIndex = 0; KeyIndex < SubTrack->FloatTrack.Points.Num(); ++KeyIndex)
|
||
|
|
{
|
||
|
|
SubTrack->LookupTrack.AddPoint(SubTrack->FloatTrack.Points[KeyIndex].InVal, DefaultName);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
float StartTime;
|
||
|
|
// Scale the track timing to ensure that it is large enough
|
||
|
|
MovementTrack->GetTimeRange(StartTime, TimeLength);
|
||
|
|
}
|
||
|
|
else if (MovementTrack)
|
||
|
|
{
|
||
|
|
ImportMatineeAnimated(TransCurves[0], MovementTrack->PosTrack, 1, true, RealCurves[0], DefaultPos[0]);
|
||
|
|
ImportMatineeAnimated(TransCurves[1], MovementTrack->PosTrack, 0, true, RealCurves[0], DefaultPos[1]);
|
||
|
|
ImportMatineeAnimated(TransCurves[2], MovementTrack->PosTrack, 2, false, RealCurves[0], DefaultPos[2]);
|
||
|
|
|
||
|
|
if (bIsCamera)
|
||
|
|
{
|
||
|
|
// Import the rotation data unmodified
|
||
|
|
ImportMatineeAnimated(TransCurves[3], MovementTrack->EulerTrack, 0, false, RealCurves[0], DefaultRot[0]);
|
||
|
|
ImportMatineeAnimated(TransCurves[4], MovementTrack->EulerTrack, 1, false, RealCurves[0], DefaultRot[1]);
|
||
|
|
ImportMatineeAnimated(TransCurves[5], MovementTrack->EulerTrack, 2, false, RealCurves[0], DefaultRot[2]);
|
||
|
|
|
||
|
|
// Once the individual Euler channels are imported, then convert the rotation into Unreal coords
|
||
|
|
for (int32 PointIndex = 0; PointIndex < MovementTrack->EulerTrack.Points.Num(); ++PointIndex)
|
||
|
|
{
|
||
|
|
FInterpCurvePoint<FVector>& CurveKey = MovementTrack->EulerTrack.Points[PointIndex];
|
||
|
|
|
||
|
|
FbxAMatrix CurveMatrix;
|
||
|
|
CurveMatrix.SetR(FbxVector4(CurveKey.OutVal.X, CurveKey.OutVal.Y, CurveKey.OutVal.Z));
|
||
|
|
|
||
|
|
// Remove the FbxCamera's local to world rotation
|
||
|
|
FbxAMatrix UnrealCameraRotationMtx = CurveMatrix * InvFbxCamToUnrealRHMtx;
|
||
|
|
|
||
|
|
// Convert the remaining rotation into world space
|
||
|
|
UnrealCameraRotationMtx = UnrealRHToUnrealLH * UnrealCameraRotationMtx * InUnrealRHToUnrealLH;
|
||
|
|
|
||
|
|
FbxVector4 UnrealCameraRotationEuler = UnrealCameraRotationMtx.GetR();
|
||
|
|
CurveKey.OutVal.X = UnrealCameraRotationEuler[0];
|
||
|
|
CurveKey.OutVal.Y = UnrealCameraRotationEuler[1];
|
||
|
|
CurveKey.OutVal.Z = UnrealCameraRotationEuler[2];
|
||
|
|
}
|
||
|
|
|
||
|
|
// The FInterpCurve code doesn't differentiate between angles and other data, so an interpolation from 179 to -179
|
||
|
|
// will cause the camera to rotate all the way around through 0 degrees. So here we make a second pass over the
|
||
|
|
// Euler track to convert the angles into a more interpolation-friendly format.
|
||
|
|
float CurrentAngleOffset[3] = {0.f, 0.f, 0.f};
|
||
|
|
for (int32 PointIndex = 1; PointIndex < MovementTrack->EulerTrack.Points.Num(); ++PointIndex)
|
||
|
|
{
|
||
|
|
const FInterpCurvePoint<FVector>& CurveKeyPrev = MovementTrack->EulerTrack.Points[PointIndex - 1];
|
||
|
|
FInterpCurvePoint<FVector>& CurveKey = MovementTrack->EulerTrack.Points[PointIndex];
|
||
|
|
|
||
|
|
FVector PreviousOutVal = CurveKeyPrev.OutVal;
|
||
|
|
FVector CurrentOutVal = CurveKey.OutVal;
|
||
|
|
|
||
|
|
for (int32 AxisIndex = 0; AxisIndex < 3; ++AxisIndex)
|
||
|
|
{
|
||
|
|
float DeltaAngle = (CurrentOutVal[AxisIndex] + CurrentAngleOffset[AxisIndex]) - PreviousOutVal[AxisIndex];
|
||
|
|
|
||
|
|
if (DeltaAngle >= 180)
|
||
|
|
{
|
||
|
|
CurrentAngleOffset[AxisIndex] -= 360;
|
||
|
|
}
|
||
|
|
else if (DeltaAngle <= -180)
|
||
|
|
{
|
||
|
|
CurrentAngleOffset[AxisIndex] += 360;
|
||
|
|
}
|
||
|
|
|
||
|
|
CurrentOutVal[AxisIndex] += CurrentAngleOffset[AxisIndex];
|
||
|
|
}
|
||
|
|
|
||
|
|
CurveKey.OutVal = CurrentOutVal;
|
||
|
|
}
|
||
|
|
|
||
|
|
// we don't support different interpolation modes for position & rotation sub-tracks, so unify them here
|
||
|
|
ConsolidateMovementTrackInterpModes(MovementTrack);
|
||
|
|
|
||
|
|
// Recalculate the tangents using the new data
|
||
|
|
MovementTrack->EulerTrack.AutoSetTangents();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ImportMatineeAnimated(TransCurves[3], MovementTrack->EulerTrack, 0, false, RealCurves[0], DefaultRot[0]);
|
||
|
|
ImportMatineeAnimated(TransCurves[4], MovementTrack->EulerTrack, 1, true, RealCurves[0], DefaultRot[1]);
|
||
|
|
ImportMatineeAnimated(TransCurves[5], MovementTrack->EulerTrack, 2, true, RealCurves[0], DefaultRot[2]);
|
||
|
|
|
||
|
|
// we don't support different interpolation modes for position & rotation sub-tracks, so unify them here
|
||
|
|
ConsolidateMovementTrackInterpModes(MovementTrack);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Generate empty look-up keys.
|
||
|
|
int32 KeyIndex;
|
||
|
|
for (KeyIndex = 0; KeyIndex < RealCurves[0]->KeyGetCount(); ++KeyIndex)
|
||
|
|
{
|
||
|
|
MovementTrack->LookupTrack.AddPoint((float)RealCurves[0]->KeyGet(KeyIndex).GetTime().GetSecondDouble(), DefaultName);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Scale the track timing to ensure that it is large enough
|
||
|
|
TimeLength = (float)RealCurves[0]->KeyGet(KeyIndex - 1).GetTime().GetSecondDouble();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Inform the engine and UI that the tracks have been modified.
|
||
|
|
if (MovementTrack != NULL)
|
||
|
|
{
|
||
|
|
MovementTrack->Modify();
|
||
|
|
}
|
||
|
|
MatineeGroup->Modify();
|
||
|
|
|
||
|
|
return TimeLength;
|
||
|
|
}
|
||
|
|
|
||
|
|
void FFbxImporter::ConsolidateMovementTrackInterpModes(UInterpTrackMove* MovementTrack)
|
||
|
|
{
|
||
|
|
check(MovementTrack->EulerTrack.Points.Num() == MovementTrack->PosTrack.Points.Num());
|
||
|
|
for (int32 KeyIndex = 0; KeyIndex < MovementTrack->PosTrack.Points.Num(); KeyIndex++)
|
||
|
|
{
|
||
|
|
MovementTrack->EulerTrack.Points[KeyIndex].InterpMode = MovementTrack->PosTrack.Points[KeyIndex].InterpMode;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
EInterpCurveMode FFbxImporter::GetUnrealInterpMode(FbxAnimCurveKey FbxKey)
|
||
|
|
{
|
||
|
|
EInterpCurveMode Mode = CIM_CurveUser;
|
||
|
|
// Convert the interpolation type from FBX to Unreal.
|
||
|
|
switch (FbxKey.GetInterpolation())
|
||
|
|
{
|
||
|
|
case FbxAnimCurveDef::eInterpolationCubic: {
|
||
|
|
switch (FbxKey.GetTangentMode())
|
||
|
|
{
|
||
|
|
// Auto tangents will now be imported as user tangents to allow the
|
||
|
|
// user to modify them without inadvertently resetting other tangents
|
||
|
|
// case KFbxAnimCurveDef::eTANGENT_AUTO:
|
||
|
|
// if ((KFbxAnimCurveDef::eTANGENT_GENERIC_CLAMP & FbxKey.GetTangentMode(true)))
|
||
|
|
// {
|
||
|
|
// Mode = CIM_CurveAutoClamped;
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// Mode = CIM_CurveAuto;
|
||
|
|
// }
|
||
|
|
// break;
|
||
|
|
case FbxAnimCurveDef::eTangentBreak:
|
||
|
|
Mode = CIM_CurveBreak;
|
||
|
|
break;
|
||
|
|
case FbxAnimCurveDef::eTangentAuto:
|
||
|
|
Mode = CIM_CurveAuto;
|
||
|
|
break;
|
||
|
|
case FbxAnimCurveDef::eTangentUser:
|
||
|
|
case FbxAnimCurveDef::eTangentTCB:
|
||
|
|
Mode = CIM_CurveUser;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case FbxAnimCurveDef::eInterpolationConstant:
|
||
|
|
if (FbxKey.GetTangentMode() != (FbxAnimCurveDef::ETangentMode)FbxAnimCurveDef::eConstantStandard)
|
||
|
|
{
|
||
|
|
// warning not support
|
||
|
|
;
|
||
|
|
}
|
||
|
|
Mode = CIM_Constant;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case FbxAnimCurveDef::eInterpolationLinear:
|
||
|
|
Mode = CIM_Linear;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
return Mode;
|
||
|
|
}
|
||
|
|
|
||
|
|
void FFbxImporter::ImportMoveSubTrack(FbxAnimCurve* FbxCurve, int32 FbxDimension, UInterpTrackMoveAxis* SubTrack, int32 CurveIndex, bool bNegative, FbxAnimCurve* RealCurve, float DefaultVal)
|
||
|
|
{
|
||
|
|
if (CurveIndex >= 3)
|
||
|
|
return;
|
||
|
|
|
||
|
|
FInterpCurveFloat& Curve = SubTrack->FloatTrack;
|
||
|
|
// the FBX curve has no valid keys, so fake the Unreal Matinee curve
|
||
|
|
if (FbxCurve == NULL || FbxCurve->KeyGetCount() < 2)
|
||
|
|
{
|
||
|
|
int32 KeyIndex;
|
||
|
|
for (KeyIndex = Curve.Points.Num(); KeyIndex < RealCurve->KeyGetCount(); ++KeyIndex)
|
||
|
|
{
|
||
|
|
float Time = (float)RealCurve->KeyGet(KeyIndex).GetTime().GetSecondDouble();
|
||
|
|
// Create the curve keys
|
||
|
|
FInterpCurvePoint<float> Key;
|
||
|
|
Key.InVal = Time;
|
||
|
|
Key.InterpMode = GetUnrealInterpMode(RealCurve->KeyGet(KeyIndex));
|
||
|
|
|
||
|
|
Curve.Points.Add(Key);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (KeyIndex = 0; KeyIndex < RealCurve->KeyGetCount(); ++KeyIndex)
|
||
|
|
{
|
||
|
|
FInterpCurvePoint<float>& Key = Curve.Points[KeyIndex];
|
||
|
|
Key.OutVal = DefaultVal;
|
||
|
|
Key.ArriveTangent = 0;
|
||
|
|
Key.LeaveTangent = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
int32 KeyCount = (int32)FbxCurve->KeyGetCount();
|
||
|
|
|
||
|
|
for (int32 KeyIndex = Curve.Points.Num(); KeyIndex < KeyCount; ++KeyIndex)
|
||
|
|
{
|
||
|
|
FbxAnimCurveKey CurKey = FbxCurve->KeyGet(KeyIndex);
|
||
|
|
|
||
|
|
// Create the curve keys
|
||
|
|
FInterpCurvePoint<float> Key;
|
||
|
|
Key.InVal = CurKey.GetTime().GetSecondDouble();
|
||
|
|
|
||
|
|
Key.InterpMode = GetUnrealInterpMode(CurKey);
|
||
|
|
|
||
|
|
// Add this new key to the curve
|
||
|
|
Curve.Points.Add(Key);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Fill in the curve keys with the correct data for this dimension.
|
||
|
|
for (int32 KeyIndex = 0; KeyIndex < KeyCount; ++KeyIndex)
|
||
|
|
{
|
||
|
|
FbxAnimCurveKey CurKey = FbxCurve->KeyGet(KeyIndex);
|
||
|
|
FInterpCurvePoint<float>& UnrealKey = Curve.Points[KeyIndex];
|
||
|
|
|
||
|
|
// Prepare the FBX values to import into the track key.
|
||
|
|
// Convert the Bezier control points, if available, into Hermite tangents
|
||
|
|
float OutVal = bNegative ? -CurKey.GetValue() : CurKey.GetValue();
|
||
|
|
|
||
|
|
float ArriveTangent = 0.0f;
|
||
|
|
float LeaveTangent = 0.0f;
|
||
|
|
|
||
|
|
if (CurKey.GetInterpolation() == FbxAnimCurveDef::eInterpolationCubic)
|
||
|
|
{
|
||
|
|
ArriveTangent = bNegative ? -FbxCurve->KeyGetLeftDerivative(KeyIndex) : FbxCurve->KeyGetLeftDerivative(KeyIndex);
|
||
|
|
LeaveTangent = bNegative ? -FbxCurve->KeyGetRightDerivative(KeyIndex) : FbxCurve->KeyGetRightDerivative(KeyIndex);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Fill in the track key with the prepared values
|
||
|
|
UnrealKey.OutVal = OutVal;
|
||
|
|
UnrealKey.ArriveTangent = ArriveTangent;
|
||
|
|
UnrealKey.LeaveTangent = LeaveTangent;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void FFbxImporter::ImportMatineeAnimated(FbxAnimCurve* FbxCurve, FInterpCurveVector& Curve, int32 CurveIndex, bool bNegative, FbxAnimCurve* RealCurve, float DefaultVal)
|
||
|
|
{
|
||
|
|
if (CurveIndex >= 3)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// the FBX curve has no valid keys, so fake the Unreal Matinee curve
|
||
|
|
if (FbxCurve == NULL || FbxCurve->KeyGetCount() < 2)
|
||
|
|
{
|
||
|
|
int32 KeyIndex;
|
||
|
|
for (KeyIndex = Curve.Points.Num(); KeyIndex < RealCurve->KeyGetCount(); ++KeyIndex)
|
||
|
|
{
|
||
|
|
float Time = (float)RealCurve->KeyGet(KeyIndex).GetTime().GetSecondDouble();
|
||
|
|
// Create the curve keys
|
||
|
|
FInterpCurvePoint<FVector> Key;
|
||
|
|
Key.InVal = Time;
|
||
|
|
Key.InterpMode = GetUnrealInterpMode(RealCurve->KeyGet(KeyIndex));
|
||
|
|
|
||
|
|
Curve.Points.Add(Key);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (KeyIndex = 0; KeyIndex < RealCurve->KeyGetCount(); ++KeyIndex)
|
||
|
|
{
|
||
|
|
FInterpCurvePoint<FVector>& Key = Curve.Points[KeyIndex];
|
||
|
|
switch (CurveIndex)
|
||
|
|
{
|
||
|
|
case 0:
|
||
|
|
Key.OutVal.X = DefaultVal;
|
||
|
|
Key.ArriveTangent.X = 0;
|
||
|
|
Key.LeaveTangent.X = 0;
|
||
|
|
break;
|
||
|
|
case 1:
|
||
|
|
Key.OutVal.Y = DefaultVal;
|
||
|
|
Key.ArriveTangent.Y = 0;
|
||
|
|
Key.LeaveTangent.Y = 0;
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
default:
|
||
|
|
Key.OutVal.Z = DefaultVal;
|
||
|
|
Key.ArriveTangent.Z = 0;
|
||
|
|
Key.LeaveTangent.Z = 0;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
int32 KeyCount = (int32)FbxCurve->KeyGetCount();
|
||
|
|
|
||
|
|
for (int32 KeyIndex = Curve.Points.Num(); KeyIndex < KeyCount; ++KeyIndex)
|
||
|
|
{
|
||
|
|
FbxAnimCurveKey CurKey = FbxCurve->KeyGet(KeyIndex);
|
||
|
|
|
||
|
|
// Create the curve keys
|
||
|
|
FInterpCurvePoint<FVector> Key;
|
||
|
|
Key.InVal = CurKey.GetTime().GetSecondDouble();
|
||
|
|
|
||
|
|
Key.InterpMode = GetUnrealInterpMode(CurKey);
|
||
|
|
|
||
|
|
// Add this new key to the curve
|
||
|
|
Curve.Points.Add(Key);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Fill in the curve keys with the correct data for this dimension.
|
||
|
|
for (int32 KeyIndex = 0; KeyIndex < KeyCount; ++KeyIndex)
|
||
|
|
{
|
||
|
|
FbxAnimCurveKey CurKey = FbxCurve->KeyGet(KeyIndex);
|
||
|
|
FInterpCurvePoint<FVector>& UnrealKey = Curve.Points[KeyIndex];
|
||
|
|
|
||
|
|
// Prepare the FBX values to import into the track key.
|
||
|
|
// Convert the Bezier control points, if available, into Hermite tangents
|
||
|
|
float OutVal = (bNegative ? -CurKey.GetValue() : CurKey.GetValue());
|
||
|
|
|
||
|
|
float ArriveTangent = 0.0f;
|
||
|
|
float LeaveTangent = 0.0f;
|
||
|
|
|
||
|
|
if (CurKey.GetInterpolation() == FbxAnimCurveDef::eInterpolationCubic)
|
||
|
|
{
|
||
|
|
ArriveTangent = bNegative ? -FbxCurve->KeyGetLeftDerivative(KeyIndex) : FbxCurve->KeyGetLeftDerivative(KeyIndex);
|
||
|
|
LeaveTangent = bNegative ? -FbxCurve->KeyGetRightDerivative(KeyIndex) : FbxCurve->KeyGetRightDerivative(KeyIndex);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Fill in the track key with the prepared values
|
||
|
|
switch (CurveIndex)
|
||
|
|
{
|
||
|
|
case 0:
|
||
|
|
UnrealKey.OutVal.X = OutVal;
|
||
|
|
UnrealKey.ArriveTangent.X = ArriveTangent;
|
||
|
|
UnrealKey.LeaveTangent.X = LeaveTangent;
|
||
|
|
break;
|
||
|
|
case 1:
|
||
|
|
UnrealKey.OutVal.Y = OutVal;
|
||
|
|
UnrealKey.ArriveTangent.Y = ArriveTangent;
|
||
|
|
UnrealKey.LeaveTangent.Y = LeaveTangent;
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
default:
|
||
|
|
UnrealKey.OutVal.Z = OutVal;
|
||
|
|
UnrealKey.ArriveTangent.Z = ArriveTangent;
|
||
|
|
UnrealKey.LeaveTangent.Z = LeaveTangent;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace UnFbx
|