void USkeletalMeshComponent::UpdateKinematicBonesToAnim(const TArray<FTransform>& InSpaceBases, ETeleportType Teleport, bool bNeedsSkinning) { SCOPE_CYCLE_COUNTER(STAT_UpdateRBBones); // This below code produces some interesting result here // - below codes update physics data, so if you don't update pose, the physics won't have the right result // - but if we just update physics bone without update current pose, it will have stale data // If desired, pass the animation data to the physics joints so they can be used by motors. // See if we are going to need to update kinematics const bool bUpdateKinematics = (KinematicBonesUpdateType != EKinematicBonesUpdateToPhysics::SkipAllBones); const bool bTeleport = Teleport == ETeleportType::TeleportPhysics; // If desired, update physics bodies associated with skeletal mesh component to match. if(!bUpdateKinematics && !(bTeleport && IsAnySimulatingPhysics())) { // nothing to do return; } // Get the scene, and do nothing if we can't get one. FPhysScene* PhysScene = nullptr; if (GetWorld() != nullptr) { PhysScene = GetWorld()->GetPhysicsScene(); } if(PhysScene == nullptr) { return; } const FTransform& CurrentLocalToWorld = ComponentToWorld; // Gracefully handle NaN if(CurrentLocalToWorld.ContainsNaN()) { return; } // If desired, draw the skeleton at the point where we pass it to the physics. if (bShowPrePhysBones && SkeletalMesh && InSpaceBases.Num() == SkeletalMesh->RefSkeleton.GetNum()) { for (int32 i = 1; i<InSpaceBases.Num(); i++) { FVector ThisPos = CurrentLocalToWorld.TransformPosition(InSpaceBases[i].GetLocation()); int32 ParentIndex = SkeletalMesh->RefSkeleton.GetParentIndex(i); FVector ParentPos = CurrentLocalToWorld.TransformPosition(InSpaceBases[ParentIndex].GetLocation()); GetWorld()->LineBatcher->DrawLine(ThisPos, ParentPos, AnimSkelDrawColor, SDPG_Foreground); } } // warn if it has non-uniform scale const FVector& MeshScale3D = CurrentLocalToWorld.GetScale3D(); #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) if( !MeshScale3D.IsUniform() ) { UE_LOG(LogPhysics, Log, TEXT("USkeletalMeshComponent::UpdateKinematicBonesToAnim : Non-uniform scale factor (%s) can cause physics to mismatch for %s SkelMesh: %s"), *MeshScale3D.ToString(), *GetFullName(), SkeletalMesh ? *SkeletalMesh->GetFullName() : TEXT("NULL")); } #endif if (bEnablePerPolyCollision == false) { const UPhysicsAsset* const PhysicsAsset = GetPhysicsAsset(); if (PhysicsAsset && SkeletalMesh && Bodies.Num() > 0) { #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) if (!ensure(PhysicsAsset->BodySetup.Num() == Bodies.Num())) { // related to TTP 280315 UE_LOG(LogPhysics, Warning, TEXT("Mesh (%s) has PhysicsAsset(%s), and BodySetup(%d) and Bodies(%d) don't match"), *SkeletalMesh->GetName(), *PhysicsAsset->GetName(), PhysicsAsset->BodySetup.Num(), Bodies.Num()); return; } #endif #if WITH_PHYSX // Lock the scenes we need (flags set in InitArticulated) if(bHasBodiesInSyncScene) { SCENE_LOCK_WRITE(PhysScene->GetPhysXScene(PST_Sync)) } if (bHasBodiesInAsyncScene) { SCENE_LOCK_WRITE(PhysScene->GetPhysXScene(PST_Async)) } #endif // Iterate over each body for (int32 i = 0; i < Bodies.Num(); i++) { // If we have a physics body, and its kinematic... FBodyInstance* BodyInst = Bodies[i]; check(BodyInst); if (bTeleport || (BodyInst->IsValidBodyInstance() && !BodyInst->IsInstanceSimulatingPhysics())) { const int32 BoneIndex = BodyInst->InstanceBoneIndex; // If we could not find it - warn. if (BoneIndex == INDEX_NONE || BoneIndex >= GetNumSpaceBases()) { const FName BodyName = PhysicsAsset->BodySetup[i]->BoneName; UE_LOG(LogPhysics, Log, TEXT("UpdateRBBones: WARNING: Failed to find bone '%s' need by PhysicsAsset '%s' in SkeletalMesh '%s'."), *BodyName.ToString(), *PhysicsAsset->GetName(), *SkeletalMesh->GetName()); } else { #if WITH_PHYSX // update bone transform to world const FTransform BoneTransform = InSpaceBases[BoneIndex] * CurrentLocalToWorld; if(BoneTransform.ContainsNaN()) { const FName BodyName = PhysicsAsset->BodySetup[i]->BoneName; UE_LOG(LogPhysics, Warning, TEXT("UpdateKinematicBonesToAnim: Trying to set transform with bad data %s on PhysicsAsset '%s' in SkeletalMesh '%s' for bone '%s'"), *BoneTransform.ToHumanReadableString(), *PhysicsAsset->GetName(), *SkeletalMesh->GetName(), *BodyName.ToString()); continue; } // If kinematic and not teleporting, set kinematic target PxRigidDynamic* PRigidDynamic = BodyInst->GetPxRigidDynamic_AssumesLocked(); if (!IsRigidBodyNonKinematic_AssumesLocked(PRigidDynamic) && !bTeleport) { PhysScene->SetKinematicTarget_AssumesLocked(BodyInst, BoneTransform, true); } // Otherwise, set global pose else { const PxTransform PNewPose = U2PTransform(BoneTransform); ensure(PNewPose.isValid()); PRigidDynamic->setGlobalPose(PNewPose); } #endif // now update scale // if uniform, we'll use BoneTranform if (MeshScale3D.IsUniform()) { // @todo UE4 should we update scale when it's simulated? BodyInst->UpdateBodyScale(BoneTransform.GetScale3D()); } else { // @note When you have non-uniform scale on mesh base, // hierarchical bone transform can update scale too often causing performance issue // So we just use mesh scale for all bodies when non-uniform // This means physics representation won't be accurate, but // it is performance friendly by preventing too frequent physics update BodyInst->UpdateBodyScale(MeshScale3D); } } } else { //make sure you have physics weight or blendphysics on, otherwise, you'll have inconsistent representation of bodies // @todo make this to be kismet log? But can be too intrusive if (!bBlendPhysics && BodyInst->PhysicsBlendWeight <= 0.f && BodyInst->BodySetup.IsValid()) { UE_LOG(LogPhysics, Warning, TEXT("%s(Mesh %s, PhysicsAsset %s, Bone %s) is simulating, but no blending. "), *GetName(), *GetNameSafe(SkeletalMesh), *GetNameSafe(PhysicsAsset), *BodyInst->BodySetup.Get()->BoneName.ToString()); } } } #if WITH_PHYSX // Unlock the scenes if (bHasBodiesInSyncScene) { SCENE_UNLOCK_WRITE(PhysScene->GetPhysXScene(PST_Sync)) } if (bHasBodiesInAsyncScene) { SCENE_UNLOCK_WRITE(PhysScene->GetPhysXScene(PST_Async)) } #endif } } else { //per poly update requires us to update all vertex positions if (MeshObject)
bool UnFbx::FFbxImporter::ImportAnimation(USkeleton* Skeleton, UAnimSequence * DestSeq, const FString& FileName, TArray<FbxNode*>& SortedLinks, TArray<FbxNode*>& NodeArray, FbxAnimStack* CurAnimStack, const int32 ResampleRate, const FbxTimeSpan AnimTimeSpan) { // @todo : the length might need to change w.r.t. sampling keys FbxTime SequenceLength = AnimTimeSpan.GetDuration(); float PreviousSequenceLength = DestSeq->SequenceLength; // if you have one pose(thus 0.f duration), it still contains animation, so we'll need to consider that as MINIMUM_ANIMATION_LENGTH time length DestSeq->SequenceLength = FGenericPlatformMath::Max<float>(SequenceLength.GetSecondDouble(), MINIMUM_ANIMATION_LENGTH); if(PreviousSequenceLength > MINIMUM_ANIMATION_LENGTH && DestSeq->RawCurveData.FloatCurves.Num() > 0) { // The sequence already existed when we began the import. We need to scale the key times for all curves to match the new // duration before importing over them. This is to catch any user-added curves float ScaleFactor = DestSeq->SequenceLength / PreviousSequenceLength; for(FFloatCurve& Curve : DestSeq->RawCurveData.FloatCurves) { Curve.FloatCurve.ScaleCurve(0.0f, ScaleFactor); } } if (ImportOptions->bDeleteExistingMorphTargetCurves) { for (int32 CurveIdx=0; CurveIdx<DestSeq->RawCurveData.FloatCurves.Num(); ++CurveIdx) { auto& Curve = DestSeq->RawCurveData.FloatCurves[CurveIdx]; if (Curve.GetCurveTypeFlag(ACF_DrivesMorphTarget)) { DestSeq->RawCurveData.FloatCurves.RemoveAt(CurveIdx, 1, false); --CurveIdx; } } DestSeq->RawCurveData.FloatCurves.Shrink(); } // // import blend shape curves // { GWarn->BeginSlowTask( LOCTEXT("BeginImportMorphTargetCurves", "Importing Morph Target Curves"), true); for ( int32 NodeIndex = 0; NodeIndex < NodeArray.Num(); NodeIndex++ ) { // consider blendshape animation curve FbxGeometry* Geometry = (FbxGeometry*)NodeArray[NodeIndex]->GetNodeAttribute(); if (Geometry) { int32 BlendShapeDeformerCount = Geometry->GetDeformerCount(FbxDeformer::eBlendShape); for(int32 BlendShapeIndex = 0; BlendShapeIndex<BlendShapeDeformerCount; ++BlendShapeIndex) { FbxBlendShape* BlendShape = (FbxBlendShape*)Geometry->GetDeformer(BlendShapeIndex, FbxDeformer::eBlendShape); const int32 BlendShapeChannelCount = BlendShape->GetBlendShapeChannelCount(); FString BlendShapeName = UTF8_TO_TCHAR(MakeName(BlendShape->GetName())); for(int32 ChannelIndex = 0; ChannelIndex<BlendShapeChannelCount; ++ChannelIndex) { FbxBlendShapeChannel* Channel = BlendShape->GetBlendShapeChannel(ChannelIndex); if(Channel) { FString ChannelName = UTF8_TO_TCHAR(MakeName(Channel->GetName())); // Maya adds the name of the blendshape and an underscore to the front of the channel name, so remove it if(ChannelName.StartsWith(BlendShapeName)) { ChannelName = ChannelName.Right(ChannelName.Len() - (BlendShapeName.Len()+1)); } FbxAnimCurve* Curve = Geometry->GetShapeChannel(BlendShapeIndex, ChannelIndex, (FbxAnimLayer*)CurAnimStack->GetMember(0)); if (Curve && Curve->KeyGetCount() > 0) { FFormatNamedArguments Args; Args.Add(TEXT("BlendShape"), FText::FromString(ChannelName)); const FText StatusUpate = FText::Format(LOCTEXT("ImportingMorphTargetCurvesDetail", "Importing Morph Target Curves [{BlendShape}]"), Args); GWarn->StatusUpdate(NodeIndex + 1, NodeArray.Num(), StatusUpate); // now see if we have one already exists. If so, just overwrite that. if not, add new one. ImportCurveToAnimSequence(DestSeq, *ChannelName, Curve, ACF_DrivesMorphTarget | ACF_TriggerEvent, AnimTimeSpan, 0.01f /** for some reason blend shape values are coming as 100 scaled **/); } } } } } } GWarn->EndSlowTask(); } // // importing custom attribute START // if (ImportOptions->bImportCustomAttribute) { GWarn->BeginSlowTask( LOCTEXT("BeginImportMorphTargetCurves", "Importing Custom Attirubte Curves"), true); const int32 TotalLinks = SortedLinks.Num(); int32 CurLinkIndex=0; for(auto Node: SortedLinks) { FbxProperty Property = Node->GetFirstProperty(); while (Property.IsValid()) { FbxAnimCurveNode* CurveNode = Property.GetCurveNode(); // do this if user defined and animated and leaf node if( CurveNode && Property.GetFlag(FbxPropertyAttr::eUserDefined) && CurveNode->IsAnimated() && IsSupportedCurveDataType(Property.GetPropertyDataType().GetType()) ) { FString CurveName = UTF8_TO_TCHAR(CurveNode->GetName()); UE_LOG(LogFbx, Log, TEXT("CurveName : %s"), *CurveName ); int32 TotalCount = CurveNode->GetChannelsCount(); for (int32 ChannelIndex=0; ChannelIndex<TotalCount; ++ChannelIndex) { FbxAnimCurve * AnimCurve = CurveNode->GetCurve(ChannelIndex); FString ChannelName = CurveNode->GetChannelName(ChannelIndex).Buffer(); if (AnimCurve) { FString FinalCurveName; if (TotalCount == 1) { FinalCurveName = CurveName; } else { FinalCurveName = CurveName + "_" + ChannelName; } FFormatNamedArguments Args; Args.Add(TEXT("CurveName"), FText::FromString(FinalCurveName)); const FText StatusUpate = FText::Format(LOCTEXT("ImportingCustomAttributeCurvesDetail", "Importing Custom Attribute [{CurveName}]"), Args); GWarn->StatusUpdate(CurLinkIndex + 1, TotalLinks, StatusUpate); ImportCurveToAnimSequence(DestSeq, FinalCurveName, AnimCurve, ACF_DefaultCurve, AnimTimeSpan); } } } Property = Node->GetNextProperty(Property); } CurLinkIndex++; } GWarn->EndSlowTask(); } // importing custom attribute END const bool bSourceDataExists = (DestSeq->SourceRawAnimationData.Num() > 0); TArray<AnimationTransformDebug::FAnimationTransformDebugData> TransformDebugData; int32 TotalNumKeys = 0; const FReferenceSkeleton& RefSkeleton = Skeleton->GetReferenceSkeleton(); // import animation { GWarn->BeginSlowTask( LOCTEXT("BeginImportAnimation", "Importing Animation"), true); TArray<struct FRawAnimSequenceTrack>& RawAnimationData = bSourceDataExists? DestSeq->SourceRawAnimationData : DestSeq->RawAnimationData; DestSeq->TrackToSkeletonMapTable.Empty(); DestSeq->AnimationTrackNames.Empty(); RawAnimationData.Empty(); TArray<FName> FbxRawBoneNames; FillAndVerifyBoneNames(Skeleton, SortedLinks, FbxRawBoneNames, FileName); UnFbx::FFbxImporter* FbxImporter = UnFbx::FFbxImporter::GetInstance(); const bool bPreserveLocalTransform = FbxImporter->GetImportOptions()->bPreserveLocalTransform; // Build additional transform matrix UFbxAnimSequenceImportData* TemplateData = Cast<UFbxAnimSequenceImportData>(DestSeq->AssetImportData); FbxAMatrix FbxAddedMatrix; BuildFbxMatrixForImportTransform(FbxAddedMatrix, TemplateData); FMatrix AddedMatrix = Converter.ConvertMatrix(FbxAddedMatrix); const int32 NumSamplingKeys = FMath::FloorToInt(AnimTimeSpan.GetDuration().GetSecondDouble() * ResampleRate); const FbxTime TimeIncrement = (NumSamplingKeys > 1)? AnimTimeSpan.GetDuration() / (NumSamplingKeys - 1) : AnimTimeSpan.GetDuration(); for(int32 SourceTrackIdx = 0; SourceTrackIdx < FbxRawBoneNames.Num(); ++SourceTrackIdx) { int32 NumKeysForTrack = 0; // see if it's found in Skeleton FName BoneName = FbxRawBoneNames[SourceTrackIdx]; int32 BoneTreeIndex = RefSkeleton.FindBoneIndex(BoneName); // update status FFormatNamedArguments Args; Args.Add(TEXT("TrackName"), FText::FromName(BoneName)); Args.Add(TEXT("TotalKey"), FText::AsNumber(NumSamplingKeys)); Args.Add(TEXT("TrackIndex"), FText::AsNumber(SourceTrackIdx+1)); Args.Add(TEXT("TotalTracks"), FText::AsNumber(FbxRawBoneNames.Num())); const FText StatusUpate = FText::Format(LOCTEXT("ImportingAnimTrackDetail", "Importing Animation Track [{TrackName}] ({TrackIndex}/{TotalTracks}) - TotalKey {TotalKey}"), Args); GWarn->StatusForceUpdate(SourceTrackIdx + 1, FbxRawBoneNames.Num(), StatusUpate); if (BoneTreeIndex!=INDEX_NONE) { bool bSuccess = true; FRawAnimSequenceTrack RawTrack; RawTrack.PosKeys.Empty(); RawTrack.RotKeys.Empty(); RawTrack.ScaleKeys.Empty(); AnimationTransformDebug::FAnimationTransformDebugData NewDebugData; FbxNode* Link = SortedLinks[SourceTrackIdx]; FbxNode * LinkParent = Link->GetParent(); for(FbxTime CurTime = AnimTimeSpan.GetStart(); CurTime <= AnimTimeSpan.GetStop(); CurTime += TimeIncrement) { // save global trasnform FbxAMatrix GlobalMatrix = Link->EvaluateGlobalTransform(CurTime); // we'd like to verify this before going to Transform. // currently transform has tons of NaN check, so it will crash there FMatrix GlobalUEMatrix = Converter.ConvertMatrix(GlobalMatrix); if (GlobalUEMatrix.ContainsNaN()) { bSuccess = false; AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText::Format(LOCTEXT("Error_InvalidTransform", "Track {0} contains invalid transform. Could not import the track."), FText::FromName(BoneName))), FFbxErrors::Animation_TransformError); break; } FTransform GlobalTransform = Converter.ConvertTransform(GlobalMatrix); if (GlobalTransform.ContainsNaN()) { bSuccess = false; AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText::Format(LOCTEXT("Error_InvalidUnrealTransform", "Track {0} did not yeild valid transform. Please report this to animation team."), FText::FromName(BoneName))), FFbxErrors::Animation_TransformError); break; } // debug data, including import transformation FTransform AddedTransform(AddedMatrix); NewDebugData.SourceGlobalTransform.Add(GlobalTransform * AddedTransform); FTransform LocalTransform; if( !bPreserveLocalTransform && LinkParent) { // I can't rely on LocalMatrix. I need to recalculate quaternion/scale based on global transform if Parent exists FbxAMatrix ParentGlobalMatrix = Link->GetParent()->EvaluateGlobalTransform(CurTime); FTransform ParentGlobalTransform = Converter.ConvertTransform(ParentGlobalMatrix); LocalTransform = GlobalTransform.GetRelativeTransform(ParentGlobalTransform); NewDebugData.SourceParentGlobalTransform.Add(ParentGlobalTransform); } else { FbxAMatrix& LocalMatrix = Link->EvaluateLocalTransform(CurTime); FbxVector4 NewLocalT = LocalMatrix.GetT(); FbxVector4 NewLocalS = LocalMatrix.GetS(); FbxQuaternion NewLocalQ = LocalMatrix.GetQ(); LocalTransform.SetTranslation(Converter.ConvertPos(NewLocalT)); LocalTransform.SetScale3D(Converter.ConvertScale(NewLocalS)); LocalTransform.SetRotation(Converter.ConvertRotToQuat(NewLocalQ)); NewDebugData.SourceParentGlobalTransform.Add(FTransform::Identity); } if(TemplateData && BoneTreeIndex == 0) { // If we found template data earlier, apply the import transform matrix to // the root track. LocalTransform.SetFromMatrix(LocalTransform.ToMatrixWithScale() * AddedMatrix); } if (LocalTransform.ContainsNaN()) { bSuccess = false; AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText::Format(LOCTEXT("Error_InvalidUnrealLocalTransform", "Track {0} did not yeild valid local transform. Please report this to animation team."), FText::FromName(BoneName))), FFbxErrors::Animation_TransformError); break; } RawTrack.ScaleKeys.Add(LocalTransform.GetScale3D()); RawTrack.PosKeys.Add(LocalTransform.GetTranslation()); RawTrack.RotKeys.Add(LocalTransform.GetRotation()); NewDebugData.RecalculatedLocalTransform.Add(LocalTransform); ++NumKeysForTrack; } if (bSuccess) { //add new track int32 NewTrackIdx = RawAnimationData.Add(RawTrack); DestSeq->AnimationTrackNames.Add(BoneName); NewDebugData.SetTrackData(NewTrackIdx, BoneTreeIndex, BoneName); // add mapping to skeleton bone track DestSeq->TrackToSkeletonMapTable.Add(FTrackToSkeletonMap(BoneTreeIndex)); TransformDebugData.Add(NewDebugData); } } TotalNumKeys = FMath::Max( TotalNumKeys, NumKeysForTrack ); } DestSeq->NumFrames = TotalNumKeys; GWarn->EndSlowTask(); } // compress animation { GWarn->BeginSlowTask( LOCTEXT("BeginCompressAnimation", "Compress Animation"), true); GWarn->StatusForceUpdate(1, 1, LOCTEXT("CompressAnimation", "Compressing Animation")); // if source data exists, you should bake it to Raw to apply if(bSourceDataExists) { DestSeq->BakeTrackCurvesToRawAnimation(); } else { // otherwise just compress DestSeq->PostProcessSequence(); } // run debug mode AnimationTransformDebug::OutputAnimationTransformDebugData(TransformDebugData, TotalNumKeys, RefSkeleton); GWarn->EndSlowTask(); } return true; }
void UAnimCompress_RemoveLinearKeys::ProcessAnimationTracks( UAnimSequence* AnimSeq, const TArray<FBoneData>& BoneData, TArray<FTranslationTrack>& PositionTracks, TArray<FRotationTrack>& RotationTracks, TArray<FScaleTrack>& ScaleTracks) { // extract all the data we'll need about the skeleton and animation sequence const int32 NumBones = BoneData.Num(); const int32 NumFrames = AnimSeq->NumFrames; const float SequenceLength = AnimSeq->SequenceLength; const int32 LastFrame = NumFrames-1; const float FrameRate = (float)(LastFrame) / SequenceLength; const float TimePerFrame = SequenceLength / (float)(LastFrame); const TArray<FTransform>& RefPose = AnimSeq->GetSkeleton()->GetRefLocalPoses(); const bool bHasScale = (ScaleTracks.Num() > 0); // make sure the parent key scale is properly bound to 1.0 or more ParentKeyScale = FMath::Max(ParentKeyScale, 1.0f); // generate the raw and compressed skeleton in world-space TArray<FTransform> RawWorldBones; TArray<FTransform> NewWorldBones; RawWorldBones.Empty(NumBones * NumFrames); NewWorldBones.Empty(NumBones * NumFrames); RawWorldBones.AddZeroed(NumBones * NumFrames); NewWorldBones.AddZeroed(NumBones * NumFrames); // generate an array to hold the indices of our end effectors TArray<int32> EndEffectors; EndEffectors.Empty(NumBones); // Create an array of FTransform to use as a workspace TArray<FTransform> BoneAtoms; // setup the raw bone transformation and find all end effectors for ( int32 BoneIndex = 0; BoneIndex < NumBones; ++BoneIndex ) { // get the raw world-atoms for this bone UpdateWorldBoneTransformTable( AnimSeq, BoneData, RefPose, BoneIndex, true, RawWorldBones); // also record all end-effectors we find const FBoneData& Bone = BoneData[BoneIndex]; if (Bone.IsEndEffector()) { EndEffectors.Add(BoneIndex); } } TArray<int32> TargetBoneIndices; // for each bone... for ( int32 BoneIndex = 0; BoneIndex < NumBones; ++BoneIndex ) { const FBoneData& Bone = BoneData[BoneIndex]; const int32 ParentBoneIndex = Bone.GetParent(); const int32 TrackIndex = AnimSeq->GetSkeleton()->GetAnimationTrackIndex(BoneIndex, AnimSeq); if (TrackIndex != INDEX_NONE) { // get the tracks we will be editing for this bone FRotationTrack& RotTrack = RotationTracks[TrackIndex]; FTranslationTrack& TransTrack = PositionTracks[TrackIndex]; const int32 NumRotKeys = RotTrack.RotKeys.Num(); const int32 NumPosKeys = TransTrack.PosKeys.Num(); const int32 NumScaleKeys = (bHasScale)? ScaleTracks[TrackIndex].ScaleKeys.Num() : 0; check( (NumPosKeys == 1) || (NumRotKeys == 1) || (NumPosKeys == NumRotKeys) ); // build an array of end effectors we need to monitor TargetBoneIndices.Reset(NumBones); int32 HighestTargetBoneIndex = BoneIndex; int32 FurthestTargetBoneIndex = BoneIndex; int32 ShortestChain = 0; float OffsetLength= -1.0f; for (int32 EffectorIndex=0; EffectorIndex < EndEffectors.Num(); ++EffectorIndex) { const int32 EffectorBoneIndex = EndEffectors[EffectorIndex]; const FBoneData& EffectorBoneData = BoneData[EffectorBoneIndex]; int32 RootIndex = EffectorBoneData.BonesToRoot.Find(BoneIndex); if (RootIndex != INDEX_NONE) { if (ShortestChain == 0 || (RootIndex+1) < ShortestChain) { ShortestChain = (RootIndex+1); } TargetBoneIndices.Add(EffectorBoneIndex); HighestTargetBoneIndex = FMath::Max(HighestTargetBoneIndex, EffectorBoneIndex); float ChainLength= 0.0f; for (long FamilyIndex=0; FamilyIndex < RootIndex; ++FamilyIndex) { const int32 NextParentBoneIndex= EffectorBoneData.BonesToRoot[FamilyIndex]; ChainLength += RefPose[NextParentBoneIndex].GetTranslation().Size(); } if (ChainLength > OffsetLength) { FurthestTargetBoneIndex = EffectorBoneIndex; OffsetLength = ChainLength; } } } // if requested, retarget the FBoneAtoms towards the target end effectors if (bRetarget) { if (NumScaleKeys > 0 && ParentBoneIndex != INDEX_NONE) { // update our bone table from the current bone through the last end effector we need to test UpdateWorldBoneTransformRange( AnimSeq, BoneData, RefPose, PositionTracks, RotationTracks, ScaleTracks, BoneIndex, HighestTargetBoneIndex, false, NewWorldBones); FScaleTrack& ScaleTrack = ScaleTracks[TrackIndex]; // adjust all translation keys to align better with the destination for ( int32 KeyIndex = 0; KeyIndex < NumScaleKeys; ++KeyIndex ) { FVector& Key= ScaleTrack.ScaleKeys[KeyIndex]; const int32 FrameIndex= FMath::Clamp(KeyIndex, 0, LastFrame); const FTransform& NewWorldParent = NewWorldBones[(ParentBoneIndex*NumFrames) + FrameIndex]; const FTransform& RawWorldChild = RawWorldBones[(BoneIndex*NumFrames) + FrameIndex]; const FTransform& RelTM = (RawWorldChild.GetRelativeTransform(NewWorldParent)); const FTransform Delta = FTransform(RelTM); Key = Delta.GetScale3D(); } } if (NumRotKeys > 0 && ParentBoneIndex != INDEX_NONE) { if (HighestTargetBoneIndex == BoneIndex) { for ( int32 KeyIndex = 0; KeyIndex < NumRotKeys; ++KeyIndex ) { FQuat& Key = RotTrack.RotKeys[KeyIndex]; check(ParentBoneIndex != INDEX_NONE); const int32 FrameIndex = FMath::Clamp(KeyIndex, 0, LastFrame); FTransform NewWorldParent = NewWorldBones[(ParentBoneIndex*NumFrames) + FrameIndex]; FTransform RawWorldChild = RawWorldBones[(BoneIndex*NumFrames) + FrameIndex]; const FTransform& RelTM = (RawWorldChild.GetRelativeTransform(NewWorldParent)); FQuat Rot = FTransform(RelTM).GetRotation(); const FQuat& AlignedKey = EnforceShortestArc(Key, Rot); Key = AlignedKey; } } else { // update our bone table from the current bone through the last end effector we need to test UpdateWorldBoneTransformRange( AnimSeq, BoneData, RefPose, PositionTracks, RotationTracks, ScaleTracks, BoneIndex, HighestTargetBoneIndex, false, NewWorldBones); // adjust all rotation keys towards the end effector target for ( int32 KeyIndex = 0; KeyIndex < NumRotKeys; ++KeyIndex ) { FQuat& Key = RotTrack.RotKeys[KeyIndex]; const int32 FrameIndex = FMath::Clamp(KeyIndex, 0, LastFrame); const FTransform& NewWorldTransform = NewWorldBones[(BoneIndex*NumFrames) + FrameIndex]; const FTransform& DesiredChildTransform = RawWorldBones[(FurthestTargetBoneIndex*NumFrames) + FrameIndex].GetRelativeTransform(NewWorldTransform); const FTransform& CurrentChildTransform = NewWorldBones[(FurthestTargetBoneIndex*NumFrames) + FrameIndex].GetRelativeTransform(NewWorldTransform); // find the two vectors which represent the angular error we are trying to correct const FVector& CurrentHeading = CurrentChildTransform.GetTranslation(); const FVector& DesiredHeading = DesiredChildTransform.GetTranslation(); // if these are valid, we can continue if (!CurrentHeading.IsNearlyZero() && !DesiredHeading.IsNearlyZero()) { const float DotResult = CurrentHeading.SafeNormal() | DesiredHeading.SafeNormal(); // limit the range we will retarget to something reasonable (~60 degrees) if (DotResult < 1.0f && DotResult > 0.5f) { FQuat Adjustment= FQuat::FindBetween(CurrentHeading, DesiredHeading); Adjustment.Normalize(); Adjustment= EnforceShortestArc(FQuat::Identity, Adjustment); const FVector Test = Adjustment.RotateVector(CurrentHeading); const float Delta = (Test - DesiredHeading).Size(); if (Delta < 0.001f) { FQuat NewKey = Adjustment * Key; NewKey.Normalize(); const FQuat& AlignedKey = EnforceShortestArc(Key, NewKey); Key = AlignedKey; } } } } } } if (NumPosKeys > 0 && ParentBoneIndex != INDEX_NONE) { // update our bone table from the current bone through the last end effector we need to test UpdateWorldBoneTransformRange( AnimSeq, BoneData, RefPose, PositionTracks, RotationTracks, ScaleTracks, BoneIndex, HighestTargetBoneIndex, false, NewWorldBones); // adjust all translation keys to align better with the destination for ( int32 KeyIndex = 0; KeyIndex < NumPosKeys; ++KeyIndex ) { FVector& Key= TransTrack.PosKeys[KeyIndex]; const int32 FrameIndex= FMath::Clamp(KeyIndex, 0, LastFrame); FTransform NewWorldParent = NewWorldBones[(ParentBoneIndex*NumFrames) + FrameIndex]; FTransform RawWorldChild = RawWorldBones[(BoneIndex*NumFrames) + FrameIndex]; const FTransform& RelTM = RawWorldChild.GetRelativeTransform(NewWorldParent); const FTransform Delta = FTransform(RelTM); ensure (!Delta.ContainsNaN()); Key = Delta.GetTranslation(); } } } // look for a parent track to reference as a guide int32 GuideTrackIndex = INDEX_NONE; if (ParentKeyScale > 1.0f) { for (long FamilyIndex=0; (FamilyIndex < Bone.BonesToRoot.Num()) && (GuideTrackIndex == INDEX_NONE); ++FamilyIndex) { const int32 NextParentBoneIndex= Bone.BonesToRoot[FamilyIndex]; GuideTrackIndex = AnimSeq->GetSkeleton()->GetAnimationTrackIndex(NextParentBoneIndex, AnimSeq); } } // update our bone table from the current bone through the last end effector we need to test UpdateWorldBoneTransformRange( AnimSeq, BoneData, RefPose, PositionTracks, RotationTracks, ScaleTracks, BoneIndex, HighestTargetBoneIndex, false, NewWorldBones); // rebuild the BoneAtoms table using the current set of keys UpdateBoneAtomList(AnimSeq, BoneIndex, TrackIndex, NumFrames, TimePerFrame, BoneAtoms); // determine the EndEffectorTolerance. // We use the Maximum value by default, and the Minimum value // as we approach the end effectors float EndEffectorTolerance = MaxEffectorDiff; if (ShortestChain <= 1) { EndEffectorTolerance = MinEffectorDiff; } // Determine if a guidance track should be used to aid in choosing keys to retain TArray<float>* GuidanceTrack = NULL; float GuidanceScale = 1.0f; if (GuideTrackIndex != INDEX_NONE) { FTranslationTrack& GuideTransTrack = PositionTracks[GuideTrackIndex]; GuidanceTrack = &GuideTransTrack.Times; GuidanceScale = ParentKeyScale; } // if the TargetBoneIndices array is empty, then this bone is an end effector. // so we add it to the list to maintain our tolerance checks if (TargetBoneIndices.Num() == 0) { TargetBoneIndices.Add(BoneIndex); } if (bActuallyFilterLinearKeys) { if (bHasScale) { FScaleTrack& ScaleTrack = ScaleTracks[TrackIndex]; // filter out translations we can approximate through interpolation FilterLinearKeysTemplate<FVector>( ScaleTrack.ScaleKeys, ScaleTrack.Times, BoneAtoms, GuidanceTrack, RawWorldBones, NewWorldBones, TargetBoneIndices, NumFrames, BoneIndex, ParentBoneIndex, GuidanceScale, MaxScaleDiff, EndEffectorTolerance, EffectorDiffSocket, BoneData); // update our bone table from the current bone through the last end effector we need to test UpdateWorldBoneTransformRange( AnimSeq, BoneData, RefPose, PositionTracks, RotationTracks, ScaleTracks, BoneIndex, HighestTargetBoneIndex, false, NewWorldBones); // rebuild the BoneAtoms table using the current set of keys UpdateBoneAtomList(AnimSeq, BoneIndex, TrackIndex, NumFrames, TimePerFrame, BoneAtoms); } // filter out translations we can approximate through interpolation FilterLinearKeysTemplate<FVector>( TransTrack.PosKeys, TransTrack.Times, BoneAtoms, GuidanceTrack, RawWorldBones, NewWorldBones, TargetBoneIndices, NumFrames, BoneIndex, ParentBoneIndex, GuidanceScale, MaxPosDiff, EndEffectorTolerance, EffectorDiffSocket, BoneData); // update our bone table from the current bone through the last end effector we need to test UpdateWorldBoneTransformRange( AnimSeq, BoneData, RefPose, PositionTracks, RotationTracks, ScaleTracks, BoneIndex, HighestTargetBoneIndex, false, NewWorldBones); // rebuild the BoneAtoms table using the current set of keys UpdateBoneAtomList(AnimSeq, BoneIndex, TrackIndex, NumFrames, TimePerFrame, BoneAtoms); // filter out rotations we can approximate through interpolation FilterLinearKeysTemplate<FQuat>( RotTrack.RotKeys, RotTrack.Times, BoneAtoms, GuidanceTrack, RawWorldBones, NewWorldBones, TargetBoneIndices, NumFrames, BoneIndex, ParentBoneIndex, GuidanceScale, MaxAngleDiff, EndEffectorTolerance, EffectorDiffSocket, BoneData); } } // make sure the final compressed keys are repesented in our NewWorldBones table UpdateWorldBoneTransformRange( AnimSeq, BoneData, RefPose, PositionTracks, RotationTracks, ScaleTracks, BoneIndex, BoneIndex, false, NewWorldBones); } };