C++ FAnimMontageInstance类代码示例

bool ACharacter::CanUseRootMotionRepMove(const FSimulatedRootMotionReplicatedMove& RootMotionRepMove, const FAnimMontageInstance& ClientMontageInstance) const
{
    // Ignore outdated moves.
    if( GetWorld()->TimeSince(RootMotionRepMove.Time) <= 0.5f )
    {
        // Make sure montage being played matched between client and server.
        if( RootMotionRepMove.RootMotion.AnimMontage && (RootMotionRepMove.RootMotion.AnimMontage == ClientMontageInstance.Montage) )
        {
            UAnimMontage * AnimMontage = ClientMontageInstance.Montage;
            const float ServerPosition = RootMotionRepMove.RootMotion.Position;
            const float ClientPosition = ClientMontageInstance.GetPosition();
            const float DeltaPosition = (ClientPosition - ServerPosition);
            const int32 CurrentSectionIndex = AnimMontage->GetSectionIndexFromPosition(ClientPosition);
            if( CurrentSectionIndex != INDEX_NONE )
            {
                const int32 NextSectionIndex = (CurrentSectionIndex < ClientMontageInstance.NextSections.Num()) ? ClientMontageInstance.NextSections[CurrentSectionIndex] : INDEX_NONE;

                // We can only extract root motion if we are within the same section.
                // It's not trivial to jump through sections in a deterministic manner, but that is luckily not frequent.
                const bool bSameSections = (AnimMontage->GetSectionIndexFromPosition(ServerPosition) == CurrentSectionIndex);
                // if we are looping and just wrapped over, skip. That's also not easy to handle and not frequent.
                const bool bHasLooped = (NextSectionIndex == CurrentSectionIndex) && (FMath::Abs(DeltaPosition) > (AnimMontage->GetSectionLength(CurrentSectionIndex) / 2.f));
                // Can only simulate forward in time, so we need to make sure server move is not ahead of the client.
                const bool bServerAheadOfClient = ((DeltaPosition * ClientMontageInstance.GetPlayRate()) < 0.f);

                UE_LOG(LogRootMotion, Log,  TEXT("\t\tACharacter::CanUseRootMotionRepMove ServerPosition: %.3f, ClientPosition: %.3f, DeltaPosition: %.3f, bSameSections: %d, bHasLooped: %d, bServerAheadOfClient: %d"),
                       ServerPosition, ClientPosition, DeltaPosition, bSameSections, bHasLooped, bServerAheadOfClient);

                return bSameSections && !bHasLooped && !bServerAheadOfClient;
            }
        }
    }
    return false;
}

/** Play a Montage. Returns Length of Montage in seconds. Returns 0.f if failed to play. */
float UAnimInstance::Montage_Play(UAnimMontage * MontageToPlay, float InPlayRate)
{
	if( MontageToPlay && (MontageToPlay->SequenceLength > 0.f) ) 
	{
		if( CurrentSkeleton->IsCompatible(MontageToPlay->GetSkeleton()) )
		{
			// when stopping old animations, make sure it does give current new blendintime to blend out
			StopAllMontages(MontageToPlay->BlendInTime);

			FAnimMontageInstance * NewInstance = new FAnimMontageInstance(this);
			check (NewInstance);

			NewInstance->Initialize(MontageToPlay);
			NewInstance->Play(InPlayRate);
			MontageInstances.Add(NewInstance);

			UpdateRootMotionMontageInstance();

			return NewInstance->Montage->SequenceLength;
		}
		else
		{
			UE_LOG(LogAnimation, Warning, TEXT("Playing a Montage (%s) for the wrong Skeleton (%s) instead of (%s)."), 
				*GetNameSafe(MontageToPlay), *GetNameSafe(MontageToPlay->GetSkeleton()), *GetNameSafe(CurrentSkeleton));
		}
	}
	else
	{
		UE_LOG(LogAnimation, Warning, TEXT("Trying to play invalid Montage (%s)"), *GetNameSafe(MontageToPlay));
	}

	return 0.f;
}

void UAnimInstance::Montage_Stop(float InBlendOutTime)
{
	FAnimMontageInstance * CurMontageInstance = GetActiveMontageInstance();
	if ( CurMontageInstance )
	{
		CurMontageInstance->Stop(InBlendOutTime);
	}
}

void UAnimSingleNodeInstance::Montage_Advance(float DeltaTime)
{
	Super::Montage_Advance(DeltaTime);
		
	FAnimMontageInstance * CurMontageInstance = GetActiveMontageInstance();
	if ( CurMontageInstance )
	{
		CurrentTime = CurMontageInstance->GetPosition();
	}
}

float UAnimInstance::GetSlotWeight(FName SlotNodeName)
{
	float TotalSum = 0.f;
#if DEBUGMONTAGEWEIGHT
	float TotalDesiredWeight = 0.f;
#endif
	// first get all the montage instance weight this slot node has
	for (int32 I = 0; I < MontageInstances.Num(); ++I)
	{
		FAnimMontageInstance* MontageInstance = MontageInstances[I];

		if (MontageInstance && MontageInstance->IsValid() && MontageInstance->Montage->IsValidSlot(SlotNodeName))
		{
			TotalSum += MontageInstance->Weight;
#if DEBUGMONTAGEWEIGHT			
			TotalDesiredWeight += MontageInstance->DesiredWeight;
#endif			
		}
	}

	// this can happen when it's blending in OR when newer animation comes in with shorter blendtime
	// say #1 animation was blending out time with current blendtime 1.0 #2 animation was blending in with 1.0 (old) but got blend out with new blendtime 0.2f
	// #3 animation was blending in with the new blendtime 0.2f, you'll have sum of #1, 2, 3 exceeds 1.f
	if (TotalSum > 1.f + ZERO_ANIMWEIGHT_THRESH)
	{
		// first get all the montage instance weight this slot node has
		for (int32 I=0; I<MontageInstances.Num(); ++I)
		{
			FAnimMontageInstance * MontageInstance = MontageInstances[I];

			if (MontageInstance && MontageInstance->IsValid() && MontageInstance->Montage->IsValidSlot(SlotNodeName))
			{
				MontageInstance->Weight/=TotalSum;
			}
		} 
	}
#if DEBUGMONTAGEWEIGHT
	else if (TotalDesiredWeight == 1.f && TotalSum < 1.f - ZERO_ANIMWEIGHT_THRESH)
	{
		// this can happen when it's blending in OR when newer animation comes in with longer blendtime
		// say #1 animation was blending out time with current blendtime 0.2 #2 animation was blending in with 0.2 (old) but got blend out with new blendtime 1.f
		// #3 animation was blending in with the new blendtime 1.f, you'll have sum of #1, 2, 3 doesn't meet 1.f
		UE_LOG(LogAnimation, Warning, TEXT("[%s] Montage has less weight. Blending in?(%f)"), *SlotNodeName.ToString(), TotalSum);
	}
#endif

	return FMath::Clamp<float>(TotalSum, 0.f, 1.f);
}

void UAnimInstance::SlotEvaluatePose(FName SlotNodeName, const FA2Pose & SourcePose, FA2Pose & BlendedPose, float SlotNodeWeight)
{
	SCOPE_CYCLE_COUNTER(STAT_AnimNativeEvaluatePoses);
	if ( SlotNodeWeight > ZERO_ANIMWEIGHT_THRESH )
	{
		// final output of slot pose
		FA2Pose SlotPose;
		SlotPose.Bones.AddUninitialized(SourcePose.Bones.Num());

		/// blend helper variables
		TArray<FA2Pose>						MontagePoses;
		TArray<float>						MontageWeights;
		TArray<FAnimMontageInstance *>		ValidMontageInstances;

		// first pass we go through collect weights and valid montages. 
		for (auto Iter = MontageInstances.CreateConstIterator(); Iter; ++Iter)
		{
			FAnimMontageInstance * MontageInstance = (*Iter);

			// @todo make this struct?
			if (MontageInstance->IsValid() && MontageInstance->Montage->IsValidSlot(SlotNodeName))
			{
				int32 NewIndex = MontageWeights.AddUninitialized(1);
				MontagePoses.AddZeroed(1);
				ValidMontageInstances.Add(MontageInstance);

				MontagePoses[NewIndex].Bones.AddUninitialized(BlendedPose.Bones.Num());
				MontageWeights[NewIndex] = MontageInstance->Weight;
			}
		}

		// clean up the MontageWeights to see if they're not summing up correctly
		float TotalSum = 0.f;
		for (int32 I=0; I<MontageWeights.Num(); ++I)
		{
			// normalize I
			TotalSum += MontageWeights[I];
		}

		// if it has any valid weight
		if ( TotalSum > ZERO_ANIMWEIGHT_THRESH )
		{
			// but not 1.f. If 1.f it's useless
			if (FMath::IsNearlyEqual(TotalSum, 1.f) == false)
			{
				for (int32 I=0; I<MontageWeights.Num(); ++I)
				{
					// normalize I
					MontageWeights[I] /= TotalSum;
				}
			}
		}
		else
		{
			FAnimationRuntime::FillWithRefPose(BlendedPose.Bones, RequiredBones);
			// nothing else to do here, there is no weight
			return;
		}

		// if not, something went wrong. It should have something
		check (ValidMontageInstances.Num() > 0);

		// second pass, we fill up MontagePoses with valid data to be full pose
		for (int32 I=0; I<ValidMontageInstances.Num(); ++I)
		{
			FAnimMontageInstance * MontageInstance = ValidMontageInstances[I];
			const FAnimTrack * AnimTrack = MontageInstance->Montage->GetAnimationData(SlotNodeName);

			// find out if this is additive animation
			EAdditiveAnimationType AdditiveAnimType = AAT_None;
			if (AnimTrack->IsAdditive())
			{
				AdditiveAnimType = AnimTrack->IsRotationOffsetAdditive()? AAT_RotationOffsetMeshSpace : AAT_LocalSpaceBase;
			}

			// get the pose data, temporarily use SlotPose
			FAnimExtractContext ExtractionContext(MontageInstance->Position, false, MontageInstance->Montage->bEnableRootMotionTranslation, MontageInstance->Montage->bEnableRootMotionRotation, MontageInstance->Montage->RootMotionRootLock);
			FAnimationRuntime::GetPoseFromAnimTrack(*AnimTrack, RequiredBones, SlotPose.Bones, ExtractionContext);

			// if additive, we should blend with source to make it fullbody
			if (AdditiveAnimType == AAT_LocalSpaceBase)
			{
				ApplyAdditiveSequence(SourcePose,SlotPose,MontageWeights[I],MontagePoses[I]);
			}
			else if (AdditiveAnimType == AAT_RotationOffsetMeshSpace)
			{
				BlendRotationOffset(SourcePose,SlotPose,MontageWeights[I],MontagePoses[I]);
			}
			else 
			{
				CopyPose(SlotPose, MontagePoses[I]);
			}
		}
	
		// allocate for blending
		FTransformArrayA2** BlendingPoses = new FTransformArrayA2*[MontagePoses.Num()];

		for (int32 I=0; I<MontagePoses.Num(); ++I)
		{
			BlendingPoses[I] = &MontagePoses[I].Bones;
//.........这里部分代码省略.........

void UAnimSingleNodeInstance::NativeUpdateAnimation(float DeltaTimeX)
{
	float NewPlayRate = PlayRate;
	UAnimSequence* PreviewBasePose = NULL;

	if (bPlaying == false)
	{
		// we still have to tick animation when bPlaying is false because 
		NewPlayRate = 0.f;
	}

	if(CurrentAsset != NULL)
	{
		FAnimGroupInstance* SyncGroup;
		if (UBlendSpaceBase* BlendSpace = Cast<UBlendSpaceBase>(CurrentAsset))
		{
			FAnimTickRecord& TickRecord = CreateUninitializedTickRecord(INDEX_NONE, /*out*/ SyncGroup);
			MakeBlendSpaceTickRecord(TickRecord, BlendSpace, BlendSpaceInput, BlendSampleData, BlendFilter, bLooping, NewPlayRate, 1.f, /*inout*/ CurrentTime);
#if WITH_EDITORONLY_DATA
			PreviewBasePose = BlendSpace->PreviewBasePose;
#endif
		}
		else if (UAnimSequence* Sequence = Cast<UAnimSequence>(CurrentAsset))
		{
			FAnimTickRecord& TickRecord = CreateUninitializedTickRecord(INDEX_NONE, /*out*/ SyncGroup);
			MakeSequenceTickRecord(TickRecord, Sequence, bLooping, NewPlayRate, 1.f, /*inout*/ CurrentTime);
			// if it's not looping, just set play to be false when reached to end
			if (!bLooping)
			{
				if ((NewPlayRate < 0.f && CurrentTime <= 0.f) || (NewPlayRate > 0.f && CurrentTime >= Sequence->SequenceLength))
				{
					SetPlaying(false);
				}
			}
		}
		else if(UAnimComposite* Composite = Cast<UAnimComposite>(CurrentAsset))
		{
			FAnimTickRecord& TickRecord = CreateUninitializedTickRecord(INDEX_NONE, /*out*/ SyncGroup);
			MakeSequenceTickRecord(TickRecord, Composite, bLooping, NewPlayRate, 1.f, /*inout*/ CurrentTime);
			// if it's not looping, just set play to be false when reached to end
			if (!bLooping)
			{
				if ((NewPlayRate < 0.f && CurrentTime <= 0.f) || (NewPlayRate > 0.f && CurrentTime >= Composite->SequenceLength))
				{
					SetPlaying(false);
				}
			}
		}
		else if (UAnimMontage * Montage = Cast<UAnimMontage>(CurrentAsset))
		{
			// Full weight , if you don't have slot track, you won't be able to see animation playing
			if ( Montage->SlotAnimTracks.Num() > 0 )
			{
				UpdateSlotNodeWeight(Montage->SlotAnimTracks[0].SlotName, 1.f);		
			}
			// get the montage position
			// @todo anim: temporarily just choose first slot and show the location
			FAnimMontageInstance * ActiveMontageInstance = GetActiveMontageInstance();
			if (ActiveMontageInstance)
			{
				CurrentTime = ActiveMontageInstance->GetPosition();
			}
			else if (bPlaying)
			{
				SetPlaying(false);
			}
#if WITH_EDITORONLY_DATA
			PreviewBasePose = Montage->PreviewBasePose;
#endif
		}
	}
	else if(CurrentVertexAnim != NULL)
	{
		float MoveDelta = DeltaTimeX * NewPlayRate;
		FAnimationRuntime::AdvanceTime(bLooping, MoveDelta, CurrentTime, CurrentVertexAnim->GetAnimLength());
	}

#if WITH_EDITORONLY_DATA
	if(PreviewBasePose)
	{
		float MoveDelta = DeltaTimeX * NewPlayRate;
		const bool bIsPreviewPoseLooping = true;

		FAnimationRuntime::AdvanceTime(bIsPreviewPoseLooping, MoveDelta, PreviewPoseCurrentTime, PreviewBasePose->SequenceLength);
	}
#endif
}

//.........这里部分代码省略.........
			CharacterMovement->DisplayDebug(Canvas, DebugDisplay, YL, YPos);
		}
		const bool Crouched = CharacterMovement && CharacterMovement->IsCrouching();
		FString T = FString::Printf(TEXT("Crouched %i"), Crouched);
		Canvas->DrawText(RenderFont, T, Indent, YPos );
		YPos += YL;
	}

	if(Mesh && Mesh->GetAnimInstance())
	{
		static FName NAME_Animation = FName(TEXT("Animation"));
		if( DebugDisplay.Contains(NAME_Animation) )
		{
			YPos += YL;

			Canvas->DrawText(RenderFont, TEXT("Animation"), Indent, YPos );
			YPos += YL;
			Indenter AnimIndent(Indent);

			//Display Sync Groups
			UAnimInstance* AnimInstance = Mesh->GetAnimInstance();
			
			FString Heading = FString::Printf(TEXT("SyncGroups: %i"), AnimInstance->SyncGroups.Num());
			Canvas->DrawText(RenderFont, Heading, Indent, YPos );
			YPos += YL;

			for (int32 GroupIndex = 0; GroupIndex < AnimInstance->SyncGroups.Num(); ++GroupIndex)
			{
				Indenter GroupIndent(Indent);
				FAnimGroupInstance& SyncGroup = AnimInstance->SyncGroups[GroupIndex];

				FString GroupLabel = FString::Printf(TEXT("Group %i - Players %i"), GroupIndex, SyncGroup.ActivePlayers.Num());
				Canvas->DrawText(RenderFont, GroupLabel, Indent, YPos );
				YPos += YL;

				if (SyncGroup.ActivePlayers.Num() > 0)
				{
					const int32 GroupLeaderIndex = FMath::Max(SyncGroup.GroupLeaderIndex, 0);

					for(int32 PlayerIndex = 0; PlayerIndex < SyncGroup.ActivePlayers.Num(); ++PlayerIndex)
					{
						Indenter PlayerIndent(Indent);
						FAnimTickRecord& Player = SyncGroup.ActivePlayers[PlayerIndex];

						Canvas->SetLinearDrawColor( (PlayerIndex == GroupLeaderIndex) ? FLinearColor::Green : FLinearColor::Yellow);

						FString PlayerEntry = FString::Printf(TEXT("%i) %s W:%.3f"), PlayerIndex, *Player.SourceAsset->GetName(), Player.EffectiveBlendWeight);
						Canvas->DrawText(RenderFont, PlayerEntry, Indent, YPos );
						YPos += YL;
					}
				}
			}

			Heading = FString::Printf(TEXT("Ungrouped: %i"), AnimInstance->UngroupedActivePlayers.Num());
			Canvas->DrawText(RenderFont, Heading, Indent, YPos );
			YPos += YL;

			Canvas->SetLinearDrawColor( FLinearColor::Yellow );

			for (int32 PlayerIndex = 0; PlayerIndex < AnimInstance->UngroupedActivePlayers.Num(); ++PlayerIndex)
			{
				Indenter PlayerIndent(Indent);
				const FAnimTickRecord& Player = AnimInstance->UngroupedActivePlayers[PlayerIndex];
				FString PlayerEntry = FString::Printf(TEXT("%i) %s W:%.3f"), PlayerIndex, *Player.SourceAsset->GetName(), Player.EffectiveBlendWeight);
				Canvas->DrawText(RenderFont, PlayerEntry, Indent, YPos );
				YPos += YL;
			}

			Heading = FString::Printf(TEXT("Montages: %i"), AnimInstance->MontageInstances.Num());
			Canvas->DrawText(RenderFont, Heading, Indent, YPos );
			YPos += YL;

			for (int32 MontageIndex = 0; MontageIndex < AnimInstance->MontageInstances.Num(); ++MontageIndex)
			{
				Indenter PlayerIndent(Indent);

				Canvas->SetLinearDrawColor( (MontageIndex == (AnimInstance->MontageInstances.Num()-1)) ? FLinearColor::Green : FLinearColor::Yellow );

				FAnimMontageInstance* MontageInstance = AnimInstance->MontageInstances[MontageIndex];

				FString MontageEntry = FString::Printf(TEXT("%i) %s Sec: %s W:%.3f DW:%.3f"), MontageIndex, *MontageInstance->Montage->GetName(), *MontageInstance->GetCurrentSection().ToString(), MontageInstance->Weight, MontageInstance->DesiredWeight);
				Canvas->DrawText(RenderFont, MontageEntry, Indent, YPos );
				YPos += YL;
			}

		}

		static FName NAME_SimpleBones = FName(TEXT("SimpleBones"));
		static FName NAME_Bones = FName(TEXT("Bones"));

		if( DebugDisplay.Contains(NAME_SimpleBones) )
		{
			Mesh->DebugDrawBones(Canvas,true);
		}
		else if( DebugDisplay.Contains(NAME_Bones) )
		{
			Mesh->DebugDrawBones(Canvas,false);
		}
	}
}