// Fill out your copyright notice in the Description page of Project Settings.
#include "RewindComponent.h"
#include "Components/SkeletalMeshComponent.h"
#include "Components/StaticMeshComponent.h"
#include "DrawDebugHelpers.h"
#include "Engine/StaticMeshActor.h"
#include "Engine/World.h"
#include "GameFramework/Actor.h"
#include "GameFramework/Character.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "GameFramework/MovementComponent.h"
#include "GameFramework/PawnMovementComponent.h"
#include "RewindCharacter.h"
#include "RewindGameMode.h"
#include "RewindVisualizationComponent.h"
URewindComponent::URewindComponent()
{
PrimaryComponentTick.bCanEverTick = true;
// Tick after movement is completed
PrimaryComponentTick.TickGroup = TG_PostPhysics;
}
void URewindComponent::BeginPlay()
{
TRACE_CPUPROFILER_EVENT_SCOPE(URewindComponent::BeginPlay);
Super::BeginPlay();
GameMode = Cast<ARewindGameMode>(GetWorld()->GetAuthGameMode());
if (!GameMode)
{
// Disable ticking if we can't find the rewind game mode; no hope of
rewinding
SetComponentTickEnabled(false);
return;
}
// Grab owner's root component to manipulate physics during rewind
OwnerRootComponent = Cast<UPrimitiveComponent>(GetOwner()-
>GetRootComponent());
// Grab owner's rewind visualization component, if it exists
OwnerVisualizationComponent = GetOwner()-
>FindComponentByClass<URewindVisualizationComponent>();
// If movement snapshotting is enabled, grab the owner's movement component
ACharacter* Character = Cast<ACharacter>(GetOwner());
if (bSnapshotMovementVelocityAndMode)
{
OwnerMovementComponent = Character ?
Cast<UCharacterMovementComponent>(Character->GetMovementComponent()) : nullptr;
}
// If configured to pause animations, grab the owner's skeletal mesh
if (bPauseAnimationDuringTimeScrubbing) { OwnerSkeletalMesh = Character ?
Character->GetMesh() : nullptr; }
// Bind to rewind/time scrub start/complete events on the game mode
GameMode->OnGlobalRewindStarted.AddUniqueDynamic(this,
&URewindComponent::OnGlobalRewindStarted);
GameMode->OnGlobalRewindCompleted.AddUniqueDynamic(this,
&URewindComponent::OnGlobalRewindCompleted);
GameMode->OnGlobalFastForwardStarted.AddUniqueDynamic(this,
&URewindComponent::OnGlobalFastForwardStarted);
GameMode->OnGlobalFastForwardCompleted.AddUniqueDynamic(this,
&URewindComponent::OnGlobalFastForwardCompleted);
GameMode->OnGlobalTimeScrubStarted.AddUniqueDynamic(this,
&URewindComponent::OnGlobalTimeScrubStarted);
GameMode->OnGlobalTimeScrubCompleted.AddUniqueDynamic(this,
&URewindComponent::OnGlobalTimeScrubCompleted);
// Bind to timeline visualization events on the game mode
GameMode->OnGlobalTimelineVisualizationEnabled.AddUniqueDynamic(this,
&URewindComponent::OnGlobalTimelineVisualizationEnabled);
GameMode->OnGlobalTimelineVisualizationDisabled.AddUniqueDynamic(this,
&URewindComponent::OnGlobalTimelineVisualizationDisabled);
bIsVisualizingTimeline = GameMode->IsGlobalTimelineVisualizationEnabled();
// Preallocate the space required in the ring buffers
InitializeRingBuffers(GameMode->MaxRewindSeconds);
}
void URewindComponent::TickComponent(float DeltaTime, ELevelTick TickType,
FActorComponentTickFunction* ThisTickFunction)
{
TRACE_CPUPROFILER_EVENT_SCOPE(URewindComponent::TickComponent);
Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
if (bIsRewinding) { PlaySnapshots(DeltaTime, true /*bRewinding*/); }
else if (bIsFastForwarding) { PlaySnapshots(DeltaTime, false /*bRewinding*/);
}
else if (bIsTimeScrubbing) { PauseTime(DeltaTime,
bLastTimeManipulationWasRewind); }
else { RecordSnapshot(DeltaTime); }
if (bIsVisualizingTimeline) { VisualizeTimeline(); }
}
void URewindComponent::SetIsRewindingEnabled(bool bEnabled)
{
bIsRewindingEnabled = bEnabled;
if (!bIsRewindingEnabled)
{
// Stop rewinding if necessary
if (bIsRewinding) { OnGlobalRewindCompleted(); }
// Stop fast forwarding if necessary
if (bIsFastForwarding) { OnGlobalFastForwardCompleted(); }
// Stop time scrubbing if necessary
if (bIsTimeScrubbing) { OnGlobalTimeScrubCompleted(); }
}
else
{
check(GameMode);
// Start rewinding if a global rewind is in progress
if (!bIsRewinding && GameMode->IsGlobalRewinding())
{ OnGlobalRewindStarted(); }
// Start fast forwarding if necessary
if (!bIsFastForwarding && GameMode->IsGlobalFastForwarding())
{ OnGlobalFastForwardStarted(); }
// Start time scrubbing if a global time scrub is in progress
if (!bIsTimeScrubbing && GameMode->IsGlobalTimeScrubbing())
{ OnGlobalTimeScrubStarted(); }
}
}
void URewindComponent::OnGlobalRewindStarted()
{
// Attempt to start rewinding; reset TimeSinceSnapshostsChanged if not time
scrubbing
bool bAlreadyManipulatingTime = IsTimeBeingManipulated();
if (TryStartTimeManipulation(bIsRewinding, !bIsTimeScrubbing))
{
// Notify event subscribers that rewind (and possibly time
manipulation) started
OnRewindStarted.Broadcast();
if (!bAlreadyManipulatingTime) { OnTimeManipulationStarted.Broadcast();
}
}
}
void URewindComponent::OnGlobalFastForwardStarted()
{
// Fast forwarding is only allowed when time scrubbing
// Attempt to start fast forwarding; reset TimeSinceSnapshostsChanged if not
time scrubbing
bool bAlreadyManipulatingTime = IsTimeBeingManipulated();
if (bIsTimeScrubbing && TryStartTimeManipulation(bIsFastForwarding, !
bIsTimeScrubbing))
{
// Notify event subscribers that fast forward (and possibly time
manipulation) started
OnFastForwardStarted.Broadcast();
if (!bAlreadyManipulatingTime) { OnTimeManipulationStarted.Broadcast();
}
}
}
void URewindComponent::OnGlobalTimeScrubStarted()
{
// Attempt to start time scrubbing; never reset TimeSinceSnapshostsChanged
for time scrubbing
bool bAlreadyManipulatingTime = IsTimeBeingManipulated();
if (TryStartTimeManipulation(bIsTimeScrubbing, false))
{
// Notify event subscribers that rewind (and possibly time
manipulation) started
OnTimeScrubStarted.Broadcast();
if (!bAlreadyManipulatingTime) { OnTimeManipulationStarted.Broadcast();
}
}
}
void URewindComponent::OnGlobalRewindCompleted()
{
// Attempt to stop rewinding
if (TryStopTimeManipulation(bIsRewinding, !bIsTimeScrubbing, false
/*bResetMovementVelocity*/))
{
// Mark last operation as a rewind for subsequent time scrubbing
bLastTimeManipulationWasRewind = true;
// Notify event subscribers that rewind (and possibly time
manipulation) completed
OnRewindCompleted.Broadcast();
if (!IsTimeBeingManipulated())
{ OnTimeManipulationCompleted.Broadcast(); }
}
}
void URewindComponent::OnGlobalFastForwardCompleted()
{
// Attempt to stop fast forwarding
if (TryStopTimeManipulation(bIsFastForwarding, !bIsTimeScrubbing, false
/*bResetMovementVelocity*/))
{
// Mark last operation as a fast forward for subsequent time scrubbing
bLastTimeManipulationWasRewind = false;
// Notify event subscribers that fast forward (and possibly time
manipulation) completed
OnFastForwardCompleted.Broadcast();
if (!IsTimeBeingManipulated())
{ OnTimeManipulationCompleted.Broadcast(); }
}
}
void URewindComponent::OnGlobalTimeScrubCompleted()
{
// Attempt to stop time scrubbing; reset movement velocity to match player
expectations
if (TryStopTimeManipulation(bIsTimeScrubbing, false
/*bResetTimeSinceSnapshotsChanged*/, true /*bResetMovementVelocity*/))
{
// Notify event subscribers that time scrubbing (and possibly time
manipulation) completed
OnFastForwardCompleted.Broadcast();
if (!IsTimeBeingManipulated())
{ OnTimeManipulationCompleted.Broadcast(); }
}
}
void URewindComponent::OnGlobalTimelineVisualizationEnabled()
{
bIsVisualizingTimeline = true;
}
void URewindComponent::OnGlobalTimelineVisualizationDisabled()
{
bIsVisualizingTimeline = false;
if (OwnerVisualizationComponent) { OwnerVisualizationComponent-
>ClearInstances(); }
}
void URewindComponent::InitializeRingBuffers(float MaxRewindSeconds)
{
// Figure out how many snapshots we need to store
MaxSnapshots = FMath::CeilToInt32(MaxRewindSeconds /
SnapshotFrequencySeconds);
// Make sure we're not accidentally allocating an obscene amount of memory
constexpr uint32 OneMB = 1024 * 1024;
constexpr uint32 ThreeMB = 3 * OneMB;
if (!bSnapshotMovementVelocityAndMode)
{
uint32 SnapshotBytes = sizeof(FTransformAndVelocitySnapshot);
uint32 TotalSnapshotBytes = MaxSnapshots * SnapshotBytes;
ensureMsgf(
TotalSnapshotBytes < OneMB,
TEXT("Actor %s has rewind component that requested %d bytes of
snapshots. Check snapshot frequency!"),
*GetOwner()->GetName(),
TotalSnapshotBytes);
MaxSnapshots = FMath::Min(MaxSnapshots, static_cast<uint32>(OneMB /
SnapshotBytes));
}
else
{
uint32 SnapshotBytes = sizeof(FTransformAndVelocitySnapshot) +
sizeof(FMovementVelocityAndModeSnapshot);
uint32 TotalSnapshotBytes = MaxSnapshots * SnapshotBytes;
ensureMsgf(
TotalSnapshotBytes < ThreeMB,
TEXT("Actor %s has rewind component that requested %d bytes of
snapshots. Check snapshot frequency!"),
*GetOwner()->GetName(),
TotalSnapshotBytes);
MaxSnapshots = FMath::Min(MaxSnapshots, static_cast<uint32>(ThreeMB /
SnapshotBytes));
}
// Initialize buffer
TransformAndVelocitySnapshots.Reserve(MaxSnapshots);
// Grab owner's root component to manipulate physics during rewind
if (bSnapshotMovementVelocityAndMode && OwnerMovementComponent)
{
// Initialize buffer for movement component snapshots
MovementVelocityAndModeSnapshots.Reserve(MaxSnapshots);
}
}
void URewindComponent::RecordSnapshot(float DeltaTime)
{
TRACE_CPUPROFILER_EVENT_SCOPE(URewindComponent::RecordSnapshot);
TimeSinceSnapshotsChanged += DeltaTime;
// Early out if last snapshot was taken within the desired snapshot cadence
if (TimeSinceSnapshotsChanged < SnapshotFrequencySeconds &&
TransformAndVelocitySnapshots.Num() != 0) { return; }
// If the buffer is full, drop the oldest snapshot
if (TransformAndVelocitySnapshots.Num() == MaxSnapshots)
{ TransformAndVelocitySnapshots.PopFront(); }
// Record the transform and velocity
FTransform Transform = GetOwner()->GetActorTransform();
FVector LinearVelocity = OwnerRootComponent ? OwnerRootComponent-
>GetPhysicsLinearVelocity() : FVector::Zero();
FVector AngularVelocityInRadians = OwnerRootComponent ? OwnerRootComponent-
>GetPhysicsAngularVelocityInRadians() : FVector::Zero();
LatestSnapshotIndex =
TransformAndVelocitySnapshots.Emplace(TimeSinceSnapshotsChanged,
Transform, LinearVelocity, AngularVelocityInRadians);
if (bSnapshotMovementVelocityAndMode && OwnerMovementComponent)
{
// If the buffer is full, drop the oldest snapshot
if (MovementVelocityAndModeSnapshots.Num() == MaxSnapshots)
{ MovementVelocityAndModeSnapshots.PopFront(); }
// Record the movement velocity and movement mode
FVector MovementVelocity = OwnerMovementComponent->Velocity;
TEnumAsByte<EMovementMode> MovementMode = OwnerMovementComponent-
>MovementMode;
int32 LatestMovementSnapshotIndex =
MovementVelocityAndModeSnapshots.Emplace(TimeSinceSnapshotsChanged,
MovementVelocity, MovementMode);
check(LatestSnapshotIndex == LatestMovementSnapshotIndex);
}
TimeSinceSnapshotsChanged = 0.0f;
}
void URewindComponent::EraseFutureSnapshots()
{
// Pop snapshots until the latest snapshot is the last one in the buffer
while (LatestSnapshotIndex < TransformAndVelocitySnapshots.Num() - 1)
{
TransformAndVelocitySnapshots.Pop();
}
if (bSnapshotMovementVelocityAndMode)
{
// Pop snapshots until the latest snapshot is the last one in the
buffer
while (LatestSnapshotIndex < MovementVelocityAndModeSnapshots.Num() -
1)
{
MovementVelocityAndModeSnapshots.Pop();
}
}
}
void URewindComponent::PlaySnapshots(float DeltaTime, bool bRewinding)
{
TRACE_CPUPROFILER_EVENT_SCOPE(URewindComponent::PlaySnapshots);
UnpauseAnimation();
if (HandleInsufficientSnapshots()) { return; }
// Apply time dilation to delta time
DeltaTime *= GameMode->GetGlobalRewindSpeed();
TimeSinceSnapshotsChanged += DeltaTime;
bool bReachedEndOfTrack = false;
float LatestSnapshotTime =
TransformAndVelocitySnapshots[LatestSnapshotIndex].TimeSinceLastSnapshot;
if (bRewinding)
{
// Drop any snapshots that are too old to be relevant
while (LatestSnapshotIndex > 0 && TimeSinceSnapshotsChanged >
LatestSnapshotTime)
{
TimeSinceSnapshotsChanged -= LatestSnapshotTime;
LatestSnapshotTime =
TransformAndVelocitySnapshots[LatestSnapshotIndex].TimeSinceLastSnapshot;
--LatestSnapshotIndex;
}
// If we don't have any snapshots in the future, we can't interpolate,
so just snap to the latest snapshot
if (LatestSnapshotIndex == TransformAndVelocitySnapshots.Num() - 1)
{
ApplySnapshot(TransformAndVelocitySnapshots[LatestSnapshotIndex],
false /*bApplyPhysics*/);
if (bSnapshotMovementVelocityAndMode)
{
ApplySnapshot(MovementVelocityAndModeSnapshots[LatestSnapshotIndex], true
/*bApplyTimeDilationToVelocity*/);
}
return;
}
bReachedEndOfTrack = LatestSnapshotIndex == 0;
}
else
{
// Drop any snapshots that are too old to be relevant
while (LatestSnapshotIndex < TransformAndVelocitySnapshots.Num() - 1 &&
TimeSinceSnapshotsChanged > LatestSnapshotTime)
{
TimeSinceSnapshotsChanged -= LatestSnapshotTime;
LatestSnapshotTime =
TransformAndVelocitySnapshots[LatestSnapshotIndex].TimeSinceLastSnapshot;
++LatestSnapshotIndex;
}
bReachedEndOfTrack = LatestSnapshotIndex ==
TransformAndVelocitySnapshots.Num() - 1;
}
// If we've reached the end of our track, clamp the interpolation and repause
animation
if (bReachedEndOfTrack)
{
TimeSinceSnapshotsChanged = FMath::Min(TimeSinceSnapshotsChanged,
LatestSnapshotTime);
if (bAnimationsPausedAtStartOfTimeManipulation) { PauseAnimation(); }
}
InterpolateAndApplySnapshots(bRewinding);
}
void URewindComponent::PauseTime(float DeltaTime, bool bRewinding)
{
TRACE_CPUPROFILER_EVENT_SCOPE(URewindComponent::PauseTime);
if (HandleInsufficientSnapshots()) { return; }
if (bRewinding)
{
// If we don't have any snapshots in the future, use the latest
snapshot
if (LatestSnapshotIndex == TransformAndVelocitySnapshots.Num() - 1)
{
ApplySnapshot(TransformAndVelocitySnapshots[LatestSnapshotIndex],
false /*bApplyPhysics*/);
if (bSnapshotMovementVelocityAndMode)
{
ApplySnapshot(MovementVelocityAndModeSnapshots[LatestSnapshotIndex], true
/*bApplyTimeDilationToVelocity*/);
}
PauseAnimation();
return;
}
}
// Continue interpolation until we reach the next snapshot
float LatestSnapshotTime =
TransformAndVelocitySnapshots[LatestSnapshotIndex].TimeSinceLastSnapshot;
if (TimeSinceSnapshotsChanged < LatestSnapshotTime)
{
// Apply time dilation clamped to snapshot time
DeltaTime *= GameMode->GetGlobalRewindSpeed();
TimeSinceSnapshotsChanged = FMath::Min(TimeSinceSnapshotsChanged +
DeltaTime, LatestSnapshotTime);
}
InterpolateAndApplySnapshots(bRewinding);
if (FMath::IsNearlyEqual(TimeSinceSnapshotsChanged, LatestSnapshotTime))
{ PauseAnimation(); }
}
bool URewindComponent::TryStartTimeManipulation(bool& bStateToSet, bool
bResetTimeSinceSnapshotsChanged)
{
if (!bIsRewindingEnabled || bStateToSet) { return false; }
// Turn on requested time manipulation (i.e. bIsRewinding, bIsFastForwarding,
bIsTimeScrubbing)
bStateToSet = true;
// Caller may want to maintain current interpolation (ex. during time
scrubbing)
if (bResetTimeSinceSnapshotsChanged) { TimeSinceSnapshotsChanged = 0.0f; }
// Physics simulation disabled during rewinding
PausePhysics();
// Check whether animations were paused when we started this time
manipulation operation
bAnimationsPausedAtStartOfTimeManipulation = bPausedAnimation;
return true;
}
bool URewindComponent::TryStopTimeManipulation(bool& bStateToSet, bool
bResetTimeSinceSnapshotsChanged, bool bResetMovementVelocity)
{
if (!bStateToSet) { return false; }
// Turn off requested time manipulation (i.e. bIsRewinding,
bIsFastForwarding, bIsTimeScrubbing)
bStateToSet = false;
// If transitioning from rewind to regular play, restore state
if (!bIsTimeScrubbing)
{
if (bResetTimeSinceSnapshotsChanged) { TimeSinceSnapshotsChanged =
0.0f; }
// Resume physics simulation
UnpausePhysics();
// Restore animation
UnpauseAnimation();
// Snap to the last snapshot before exiting rewind
if (LatestSnapshotIndex >= 0)
{
ApplySnapshot(TransformAndVelocitySnapshots[LatestSnapshotIndex],
true /*bApplyPhysics*/);
if (bSnapshotMovementVelocityAndMode)
{
ApplySnapshot(MovementVelocityAndModeSnapshots[LatestSnapshotIndex], false
/*bApplyTimeDilationToVelocity*/);
// Players will be surprised if they continue moving after
time scrubbing; clear movement velocity
if (bResetMovementVelocity && OwnerMovementComponent)
{ OwnerMovementComponent->Velocity = FVector::ZeroVector; }
}
}
// Delete any future snapshots on the timeline that should be
overwritten by new snapshots
EraseFutureSnapshots();
}
return true;
}
void URewindComponent::PausePhysics()
{
// Pause physics if it's simulating
if (OwnerRootComponent && OwnerRootComponent->BodyInstance.bSimulatePhysics)
{
bPausedPhysics = true;
OwnerRootComponent->SetSimulatePhysics(false);
}
}
void URewindComponent::UnpausePhysics()
{
// Restart physics if simulation was paused
if (!bPausedPhysics) { return; }
check(OwnerRootComponent);
bPausedPhysics = false;
OwnerRootComponent->SetSimulatePhysics(true);
OwnerRootComponent->RecreatePhysicsState();
}
void URewindComponent::PauseAnimation()
{
if (!bPauseAnimationDuringTimeScrubbing) { return; }
check(OwnerSkeletalMesh);
bPausedAnimation = true;
OwnerSkeletalMesh->bPauseAnims = true;
}
void URewindComponent::UnpauseAnimation()
{
if (!bPausedAnimation) { return; }
check(OwnerSkeletalMesh);
bPausedAnimation = false;
OwnerSkeletalMesh->bPauseAnims = false;
}
bool URewindComponent::HandleInsufficientSnapshots()
{
// Nothing to do if no snapshots are available
check(!bSnapshotMovementVelocityAndMode ||
TransformAndVelocitySnapshots.Num() == MovementVelocityAndModeSnapshots.Num());
if (LatestSnapshotIndex < 0 || TransformAndVelocitySnapshots.Num() == 0)
{ return true; }
// If only one snapshot is available, snap to it
if (TransformAndVelocitySnapshots.Num() == 1)
{
ApplySnapshot(TransformAndVelocitySnapshots[0], false
/*bApplyPhysics*/);
if (bSnapshotMovementVelocityAndMode)
{ ApplySnapshot(MovementVelocityAndModeSnapshots[0], true
/*bApplyTimeDilationToVelocity*/); }
return true;
}
// Sanity check invariant
check(LatestSnapshotIndex >= 0 && LatestSnapshotIndex <
TransformAndVelocitySnapshots.Num());
return false;
}
void URewindComponent::InterpolateAndApplySnapshots(bool bRewinding)
{
// Interpolate between the two relevant snapshots
constexpr int MinSnapshotsForInterpolation = 2;
check(TransformAndVelocitySnapshots.Num() >= MinSnapshotsForInterpolation);
check(bRewinding && LatestSnapshotIndex < TransformAndVelocitySnapshots.Num()
- 1 || !bRewinding && LatestSnapshotIndex > 0);
int PreviousIndex = bRewinding ? LatestSnapshotIndex + 1 :
LatestSnapshotIndex - 1;
// Blend and apply transform and velocity snapshots (scoped to avoid variable
shadowing)
{
const FTransformAndVelocitySnapshot& PreviousSnapshot =
TransformAndVelocitySnapshots[PreviousIndex];
const FTransformAndVelocitySnapshot& NextSnapshot =
TransformAndVelocitySnapshots[LatestSnapshotIndex];
ApplySnapshot(
BlendSnapshots(PreviousSnapshot, NextSnapshot,
TimeSinceSnapshotsChanged / NextSnapshot.TimeSinceLastSnapshot),
false /*bApplyPhysics*/);
}
// Blend and apply movement velocity and mode snapshots
if (bSnapshotMovementVelocityAndMode)
{
const FMovementVelocityAndModeSnapshot& PreviousSnapshot =
MovementVelocityAndModeSnapshots[PreviousIndex];
const FMovementVelocityAndModeSnapshot& NextSnapshot =
MovementVelocityAndModeSnapshots[LatestSnapshotIndex];
ApplySnapshot(
BlendSnapshots(PreviousSnapshot, NextSnapshot,
TimeSinceSnapshotsChanged / NextSnapshot.TimeSinceLastSnapshot),
true /*bApplyTimeDilationToVelocity*/);
}
}
FTransformAndVelocitySnapshot URewindComponent::BlendSnapshots(
const FTransformAndVelocitySnapshot& A,
const FTransformAndVelocitySnapshot& B,
float Alpha)
{
Alpha = FMath::Clamp(Alpha, 0.0f, 1.0f);
FTransformAndVelocitySnapshot BlendedSnapshot;
BlendedSnapshot.Transform.Blend(A.Transform, B.Transform, Alpha);
BlendedSnapshot.LinearVelocity = FMath::Lerp(A.LinearVelocity,
B.LinearVelocity, Alpha);
BlendedSnapshot.AngularVelocityInRadians =
FMath::Lerp(A.AngularVelocityInRadians, B.AngularVelocityInRadians, Alpha);
return BlendedSnapshot;
}
FMovementVelocityAndModeSnapshot URewindComponent::BlendSnapshots(
const FMovementVelocityAndModeSnapshot& A,
const FMovementVelocityAndModeSnapshot& B,
float Alpha)
{
Alpha = FMath::Clamp(Alpha, 0.0f, 1.0f);
FMovementVelocityAndModeSnapshot BlendedSnapshot;
BlendedSnapshot.MovementVelocity = FMath::Lerp(A.MovementVelocity,
B.MovementVelocity, Alpha);
BlendedSnapshot.MovementMode = Alpha < 0.5f ? A.MovementMode :
B.MovementMode;
return BlendedSnapshot;
}
void URewindComponent::ApplySnapshot(const FTransformAndVelocitySnapshot& Snapshot,
bool bApplyPhysics)
{
GetOwner()->SetActorTransform(Snapshot.Transform);
if (OwnerRootComponent && bApplyPhysics)
{
OwnerRootComponent->SetPhysicsLinearVelocity(Snapshot.LinearVelocity);
OwnerRootComponent-
>SetPhysicsAngularVelocityInRadians(Snapshot.AngularVelocityInRadians);
}
}
void URewindComponent::ApplySnapshot(const FMovementVelocityAndModeSnapshot&
Snapshot, bool bApplyTimeDilationToVelocity)
{
if (OwnerMovementComponent)
{
OwnerMovementComponent->Velocity =
bApplyTimeDilationToVelocity ? Snapshot.MovementVelocity *
GameMode->GetGlobalRewindSpeed() : Snapshot.MovementVelocity;
OwnerMovementComponent->SetMovementMode(Snapshot.MovementMode);
}
}
void URewindComponent::VisualizeTimeline()
{
TRACE_CPUPROFILER_EVENT_SCOPE(URewindComponent::VisualizeTimeline);
if (!OwnerVisualizationComponent || !bIsVisualizingTimeline) { return; }
OwnerVisualizationComponent-
>SetInstancesFromSnapshots(TransformAndVelocitySnapshots);
}
