void FVisualLoggerTimeSliderController::HorizontalScrollBar_OnUserScrolled(float ScrollOffset)
{
if (!TimeSliderArgs.ViewRange.IsBound())
{
TRange<float> LocalViewRange = TimeSliderArgs.ViewRange.Get();
float LocalViewRangeMin = LocalViewRange.GetLowerBoundValue();
float LocalViewRangeMax = LocalViewRange.GetUpperBoundValue();
float LocalClampMin = TimeSliderArgs.ClampRange.Get().GetLowerBoundValue();
float LocalClampMax = TimeSliderArgs.ClampRange.Get().GetUpperBoundValue();
float InThumbSizeFraction = (LocalViewRangeMax - LocalViewRangeMin) / (LocalClampMax - LocalClampMin);
float NewViewOutputMin = LocalClampMin + ScrollOffset * (LocalClampMax - LocalClampMin);
// The output is not bound to a delegate so we'll manage the value ourselves
float NewViewOutputMax = FMath::Min<float>(NewViewOutputMin + (LocalViewRangeMax - LocalViewRangeMin), LocalClampMax);
NewViewOutputMin = NewViewOutputMax - (LocalViewRangeMax - LocalViewRangeMin);
float InOffsetFraction = (NewViewOutputMin - LocalClampMin) / (LocalClampMax - LocalClampMin);
//if (InOffsetFraction + InThumbSizeFraction <= 1)
{
TimeSliderArgs.ViewRange.Set(TRange<float>(NewViewOutputMin, NewViewOutputMax));
Scrollbar->SetState(InOffsetFraction, InThumbSizeFraction);
}
}
}
void FSubMovieSceneTrackInstance::Update( float Position, float LastPosition, const TArray<UObject*>& RuntimeObjects, class IMovieScenePlayer& Player )
{
const TArray<UMovieSceneSection*>& AllSections = SubMovieSceneTrack->GetAllSections();
TArray<UMovieSceneSection*> TraversedSections = MovieSceneHelpers::GetTraversedSections( AllSections, Position, LastPosition );
for( int32 SectionIndex = 0; SectionIndex < TraversedSections.Num(); ++SectionIndex )
{
USubMovieSceneSection* Section = CastChecked<USubMovieSceneSection>( TraversedSections[SectionIndex] );
TSharedPtr<FMovieSceneSequenceInstance> Instance = SubMovieSceneInstances.FindRef( Section );
FMovieSceneSequenceInstance* InstancePtr = Instance.Get();
if( InstancePtr )
{
TRange<float> TimeRange = InstancePtr->GetMovieSceneTimeRange();
// Position for the movie scene needs to be in local space
float LocalDelta = TimeRange.GetLowerBoundValue() - Section->GetStartTime();
float LocalPosition = Position + LocalDelta;
InstancePtr->Update(LocalPosition, LastPosition + LocalDelta, Player);
}
}
}
int32 FSequencerTimeSliderController::OnPaintTimeSlider( bool bMirrorLabels, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
const bool bEnabled = bParentEnabled;
const ESlateDrawEffect::Type DrawEffects = bEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
TRange<float> LocalViewRange = TimeSliderArgs.ViewRange.Get();
const float LocalViewRangeMin = LocalViewRange.GetLowerBoundValue();
const float LocalViewRangeMax = LocalViewRange.GetUpperBoundValue();
const float LocalSequenceLength = LocalViewRangeMax-LocalViewRangeMin;
FVector2D Scale = FVector2D(1.0f,1.0f);
if ( LocalSequenceLength > 0)
{
FScrubRangeToScreen RangeToScreen( LocalViewRange, AllottedGeometry.Size );
const float MajorTickHeight = 9.0f;
FDrawTickArgs Args;
Args.AllottedGeometry = AllottedGeometry;
Args.bMirrorLabels = bMirrorLabels;
Args.bOnlyDrawMajorTicks = false;
Args.TickColor = FLinearColor::White;
Args.ClippingRect = MyClippingRect;
Args.DrawEffects = DrawEffects;
Args.StartLayer = LayerId;
Args.TickOffset = bMirrorLabels ? 0.0f : FMath::Abs( AllottedGeometry.Size.Y - MajorTickHeight );
Args.MajorTickHeight = MajorTickHeight;
DrawTicks( OutDrawElements, RangeToScreen, Args );
const float HandleSize = 13.0f;
float HalfSize = FMath::TruncToFloat(HandleSize/2.0f);
// Draw the scrub handle
const float XPos = RangeToScreen.InputToLocalX( TimeSliderArgs.ScrubPosition.Get() );
// Should draw above the text
const int32 ArrowLayer = LayerId + 2;
FPaintGeometry MyGeometry = AllottedGeometry.ToPaintGeometry( FVector2D( XPos-HalfSize, 0 ), FVector2D( HandleSize, AllottedGeometry.Size.Y ) );
FLinearColor ScrubColor = InWidgetStyle.GetColorAndOpacityTint();
// @todo Sequencer this color should be specified in the style
ScrubColor.A = ScrubColor.A*0.5f;
ScrubColor.B *= 0.1f;
ScrubColor.G *= 0.2f;
FSlateDrawElement::MakeBox(
OutDrawElements,
ArrowLayer,
MyGeometry,
bMirrorLabels ? ScrubHandleUp : ScrubHandleDown,
MyClippingRect,
DrawEffects,
ScrubColor
);
return ArrowLayer;
}
return LayerId;
}
FReply FSequencer::OnPlay()
{
if( PlaybackState == EMovieScenePlayerStatus::Playing ||
PlaybackState == EMovieScenePlayerStatus::Recording )
{
PlaybackState = EMovieScenePlayerStatus::Stopped;
// Update on stop (cleans up things like sounds that are playing)
RootMovieSceneInstance->Update( ScrubPosition, ScrubPosition, *this );
}
else
{
TRange<float> TimeBounds = GetTimeBounds();
if (!TimeBounds.IsEmpty())
{
float CurrentTime = GetGlobalTime();
if (CurrentTime < TimeBounds.GetLowerBoundValue() || CurrentTime >= TimeBounds.GetUpperBoundValue())
{
SetGlobalTime(TimeBounds.GetLowerBoundValue());
}
PlaybackState = EMovieScenePlayerStatus::Playing;
// Make sure Slate ticks during playback
SequencerWidget->RegisterActiveTimerForPlayback();
}
}
return FReply::Handled();
}
void print(TRange range)
{
for(int i = 0; !range.IsEmpty() && i < 77; range.Pop(), ++i)
{
putchar(48 + range.Front());
}
puts("");
}
std::vector<value_type_t> toVector() {
std::vector<value_type_t> v;
while (range_.ok()) {
typename TRange::iter_t i = range_.take();
if (i != range_.end())
v.push_back(*i);
}
return v;
}
T to() {
T t;
while (range_.ok()) {
typename TRange::iter_t i = range_.take();
if (i != range_.end())
t.push_back(*i);
}
return t;
}
void FSequencerTimeSliderController::SetPlaybackRangeStart(float NewStart)
{
TRange<float> PlaybackRange = TimeSliderArgs.PlaybackRange.Get();
if (NewStart <= PlaybackRange.GetUpperBoundValue())
{
TimeSliderArgs.OnPlaybackRangeChanged.ExecuteIfBound(TRange<float>(NewStart, PlaybackRange.GetUpperBoundValue()));
}
}
void FSequencerTimeSliderController::SetPlaybackRangeEnd(float NewEnd)
{
TRange<float> PlaybackRange = TimeSliderArgs.PlaybackRange.Get();
if (NewEnd >= PlaybackRange.GetLowerBoundValue())
{
TimeSliderArgs.OnPlaybackRangeChanged.ExecuteIfBound(TRange<float>(PlaybackRange.GetLowerBoundValue(), NewEnd));
}
}
FReply FSequencer::OnStepToBeginning()
{
PlaybackState = EMovieScenePlayerStatus::Stopped;
TRange<float> TimeBounds = GetTimeBounds();
if (!TimeBounds.IsEmpty())
{
SetGlobalTime(TimeBounds.GetLowerBoundValue());
}
return FReply::Handled();
}
ITERATE ( TRanges, it, m_Ranges ) {
if ( it != m_Ranges.begin() ) {
out << ',';
}
TRange range = it->second.GetTotalRange();
out << it->first.AsString();
if ( range != TRange::GetWhole() ) {
out << "(" << range.GetFrom() << "-" << range.GetTo() << ")";
}
}
int32 FSequencerTimeSliderController::DrawPlaybackRange(const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FScrubRangeToScreen& RangeToScreen, const FPaintPlaybackRangeArgs& Args) const
{
if (!TimeSliderArgs.PlaybackRange.IsSet())
{
return LayerId;
}
TRange<float> PlaybackRange = TimeSliderArgs.PlaybackRange.Get();
float PlaybackRangeL = RangeToScreen.InputToLocalX(PlaybackRange.GetLowerBoundValue()) - 1;
float PlaybackRangeR = RangeToScreen.InputToLocalX(PlaybackRange.GetUpperBoundValue()) + 1;
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry(FVector2D(PlaybackRangeL, 0.f), FVector2D(Args.BrushWidth, AllottedGeometry.Size.Y)),
Args.StartBrush,
MyClippingRect,
ESlateDrawEffect::None,
FColor(32, 128, 32) // 120, 75, 50 (HSV)
);
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry(FVector2D(PlaybackRangeR - Args.BrushWidth, 0.f), FVector2D(Args.BrushWidth, AllottedGeometry.Size.Y)),
Args.EndBrush,
MyClippingRect,
ESlateDrawEffect::None,
FColor(128, 32, 32) // 0, 75, 50 (HSV)
);
// Black tint for excluded regions
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry(FVector2D(0.f, 0.f), FVector2D(PlaybackRangeL, AllottedGeometry.Size.Y)),
FEditorStyle::GetBrush("WhiteBrush"),
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Black.CopyWithNewOpacity(0.2f)
);
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry(FVector2D(PlaybackRangeR, 0.f), FVector2D(AllottedGeometry.Size.X - PlaybackRangeR, AllottedGeometry.Size.Y)),
FEditorStyle::GetBrush("WhiteBrush"),
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Black.CopyWithNewOpacity(0.2f)
);
return LayerId + 1;
}
int32 FSequencerTimeSliderController::OnPaintSectionView( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, bool bEnabled, bool bDisplayTickLines, bool bDisplayScrubPosition ) const
{
const ESlateDrawEffect::Type DrawEffects = bEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
TRange<float> LocalViewRange = TimeSliderArgs.ViewRange.Get();
float LocalScrubPosition = TimeSliderArgs.ScrubPosition.Get();
float ViewRange = LocalViewRange.Size<float>();
float PixelsPerInput = ViewRange > 0 ? AllottedGeometry.Size.X / ViewRange : 0;
float LinePos = (LocalScrubPosition - LocalViewRange.GetLowerBoundValue()) * PixelsPerInput;
FScrubRangeToScreen RangeToScreen( LocalViewRange, AllottedGeometry.Size );
if( bDisplayTickLines )
{
// Draw major tick lines in the section area
FDrawTickArgs Args;
Args.AllottedGeometry = AllottedGeometry;
Args.bMirrorLabels = false;
Args.bOnlyDrawMajorTicks = true;
Args.TickColor = FLinearColor( 0.3f, 0.3f, 0.3f, 0.3f );
Args.ClippingRect = MyClippingRect;
Args.DrawEffects = DrawEffects;
// Draw major ticks under sections
Args.StartLayer = LayerId-1;
// Draw the tick the entire height of the section area
Args.TickOffset = 0.0f;
Args.MajorTickHeight = AllottedGeometry.Size.Y;
DrawTicks( OutDrawElements, RangeToScreen, Args );
}
if( bDisplayScrubPosition )
{
// Draw a line for the scrub position
TArray<FVector2D> LinePoints;
LinePoints.AddUninitialized(2);
LinePoints[0] = FVector2D( 1.0f, 0.0f );
LinePoints[1] = FVector2D( 1.0f, FMath::RoundToFloat( AllottedGeometry.Size.Y ) );
FSlateDrawElement::MakeLines(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry( FVector2D(LinePos, 0.0f ), FVector2D(1.0f,1.0f) ),
LinePoints,
MyClippingRect,
DrawEffects,
FLinearColor::White,
false
);
}
return LayerId;
}
void FSequencerTimeSliderController::PanByDelta( float InDelta )
{
TRange<float> LocalViewRange = TimeSliderArgs.ViewRange.Get().GetAnimationTarget();
float CurrentMin = LocalViewRange.GetLowerBoundValue();
float CurrentMax = LocalViewRange.GetUpperBoundValue();
// Adjust the delta to be a percentage of the current range
InDelta *= ScrubConstants::ScrollPanFraction * (CurrentMax - CurrentMin);
SetViewRange(CurrentMin + InDelta, CurrentMax + InDelta, EViewRangeInterpolation::Animated);
}
void UMovieSceneActorReferenceSection::GetKeyHandles(TSet<FKeyHandle>& OutKeyHandles, TRange<float> TimeRange) const
{
if (!TimeRange.Overlaps(GetRange()))
{
return;
}
for ( auto It( ActorGuidIndexCurve.GetKeyHandleIterator() ); It; ++It )
{
float Time = ActorGuidIndexCurve.GetKeyTime( It.Key() );
if (TimeRange.Contains(Time))
{
OutKeyHandles.Add(It.Key());
}
}
}
void FVisualLoggerTimeSliderController::SetClampRange(float MinValue, float MaxValue)
{
TRange<float> LocalViewRange = TimeSliderArgs.ViewRange.Get();
float LocalClampMin = TimeSliderArgs.ClampRange.Get().GetLowerBoundValue();
float LocalClampMax = TimeSliderArgs.ClampRange.Get().GetUpperBoundValue();
const float CurrentDistance = LocalClampMax - LocalClampMin;
const float ZoomDelta = (LocalViewRange.GetUpperBoundValue() - LocalViewRange.GetLowerBoundValue()) / CurrentDistance;
MaxValue = MinValue + (MaxValue - MinValue < 2 ? CurrentDistance : MaxValue - MinValue);
TimeSliderArgs.ClampRange = TRange<float>(MinValue, MaxValue);
const float LocalViewRangeMin = FMath::Clamp(LocalViewRange.GetLowerBoundValue(), MinValue, MaxValue);
const float LocalViewRangeMax = FMath::Clamp(LocalViewRange.GetUpperBoundValue(), MinValue, MaxValue);
SetTimeRange(ZoomDelta >= 1 ? MinValue : LocalViewRangeMin, ZoomDelta >= 1 ? MaxValue : LocalViewRangeMax);
}
void ULevelSequencePlayer::Initialize(ULevelSequence* InLevelSequence, UWorld* InWorld, const FLevelSequencePlaybackSettings& Settings)
{
LevelSequence = InLevelSequence;
World = InWorld;
PlaybackSettings = Settings;
if (UMovieScene* MovieScene = LevelSequence->GetMovieScene())
{
TRange<float> PlaybackRange = MovieScene->GetPlaybackRange();
SetPlaybackRange(PlaybackRange.GetLowerBoundValue(), PlaybackRange.GetUpperBoundValue());
}
// Ensure everything is set up, ready for playback
Stop();
}
FReply FSequencerTimeSliderController::OnMouseWheel( TSharedRef<SWidget> WidgetOwner, const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
if ( TimeSliderArgs.AllowZoom )
{
const float ZoomDelta = -0.1f * MouseEvent.GetWheelDelta();
{
TRange<float> LocalViewRange = TimeSliderArgs.ViewRange.Get();
float LocalViewRangeMax = LocalViewRange.GetUpperBoundValue();
float LocalViewRangeMin = LocalViewRange.GetLowerBoundValue();
const float OutputViewSize = LocalViewRangeMax - LocalViewRangeMin;
const float OutputChange = OutputViewSize * ZoomDelta;
float NewViewOutputMin = LocalViewRangeMin - (OutputChange * 0.5f);
float NewViewOutputMax = LocalViewRangeMax + (OutputChange * 0.5f);
if( FMath::Abs( OutputChange ) > 0.01f && NewViewOutputMin < NewViewOutputMax )
{
TOptional<float> LocalClampMin = TimeSliderArgs.ClampMin.Get();
TOptional<float> LocalClampMax = TimeSliderArgs.ClampMax.Get();
// Clamp the range if clamp values are set
if ( LocalClampMin.IsSet() && NewViewOutputMin < LocalClampMin.GetValue() )
{
NewViewOutputMin = LocalClampMin.GetValue();
}
if ( LocalClampMax.IsSet() && NewViewOutputMax > LocalClampMax.GetValue() )
{
NewViewOutputMax = LocalClampMax.GetValue();
}
TimeSliderArgs.OnViewRangeChanged.ExecuteIfBound(TRange<float>(NewViewOutputMin, NewViewOutputMax));
if( !TimeSliderArgs.ViewRange.IsBound() )
{
// The output is not bound to a delegate so we'll manage the value ourselves
TimeSliderArgs.ViewRange.Set( TRange<float>( NewViewOutputMin, NewViewOutputMax ) );
}
}
}
return FReply::Handled();
}
return FReply::Unhandled();
}
bool FMovieSceneCinematicShotTrackInstance::ShouldEvaluateIfOverlapping(const TArray<UMovieSceneSection*>& TraversedSections, UMovieSceneSection* Section) const
{
// Check with this shot's exclusive upper bound for when shots are adjacent to each other but on different rows.
TRange<float> ThisSectionWithExclusiveUpper = TRange<float>(Section->GetRange().GetLowerBoundValue(), Section->GetRange().GetUpperBoundValue());
// Only evaluate the top most row on overlapping cinematic shot sections. Disregard overlap priority.
const bool bShouldRemove = TraversedSections.ContainsByPredicate([=](UMovieSceneSection* OtherSection){
if (Section->GetRowIndex() > OtherSection->GetRowIndex() &&
ThisSectionWithExclusiveUpper.Overlaps(OtherSection->GetRange()))
{
return true;
}
return false;
});
return bShouldRemove;
}
const UMovieSceneSection* UMovieSceneSection::OverlapsWithSections(const TArray<UMovieSceneSection*>& Sections, int32 TrackDelta, float TimeDelta) const
{
int32 NewTrackIndex = RowIndex + TrackDelta;
TRange<float> NewSectionRange = TRange<float>(StartTime + TimeDelta, EndTime + TimeDelta);
for (int32 SectionIndex = 0; SectionIndex < Sections.Num(); ++SectionIndex)
{
const UMovieSceneSection* InSection = Sections[SectionIndex];
if (this != InSection && InSection->GetRowIndex() == NewTrackIndex)
{
if (NewSectionRange.Overlaps(InSection->GetRange()))
{
return InSection;
}
}
}
return NULL;
}
void CTestRangeMap::TestRangeMap(void) const
{
Filling("CRangeMap");
typedef CRangeMultimap<CConstRef<CObject> > TMap;
typedef TMap::const_iterator TMapCI;
TMap m;
// fill
for ( int count = 0; count < m_RangeNumber; ) {
TRange range = RandomRange();
m.insert(TMap::value_type(range, CConstRef<CObject>(0)));
++count;
Added(range);
}
if ( m_PrintSize ) {
Filled(m.size());
// Stat(m.stat());
}
for ( TMapCI i = m.begin(); i; ++i ) {
FromAll(i.GetInterval());
}
size_t scannedCount = 0;
for ( int count = 0; count < m_ScanCount; ++count ) {
for ( int pos = 0; pos <= m_Length + 2*m_RangeLength;
pos += m_ScanStep ) {
TRange range;
range.Set(pos, pos + m_ScanLength - 1);
StartFrom(range);
for ( TMapCI i = m.begin(range); i; ++i ) {
From(range, i.GetInterval());
++scannedCount;
}
}
}
PrintTotalScannedNumber(scannedCount);
End();
}
void UMovieSceneShotTrack::AddNewShot(FGuid CameraHandle, UMovieScene& ShotMovieScene, const TRange<float>& TimeRange, const FText& ShotName, int32 ShotNumber )
{
Modify();
FName UniqueShotName = MakeUniqueObjectName( this, UMovieSceneShotSection::StaticClass(), *ShotName.ToString() );
UMovieSceneShotSection* NewSection = NewObject<UMovieSceneShotSection>( this, UniqueShotName, RF_Transactional );
NewSection->SetMovieScene( &ShotMovieScene );
NewSection->SetStartTime( TimeRange.GetLowerBoundValue() );
NewSection->SetEndTime( TimeRange.GetUpperBoundValue() );
NewSection->SetCameraGuid( CameraHandle );
NewSection->SetShotNameAndNumber( ShotName , ShotNumber );
SubMovieSceneSections.Add( NewSection );
// When a new shot is added, sort all shots to ensure they are in the correct order
SortShots();
}
bool FSequencerTimeSliderController::ZoomByDelta( float InDelta, float MousePositionFraction )
{
TRange<float> LocalViewRange = TimeSliderArgs.ViewRange.Get().GetAnimationTarget();
float LocalViewRangeMax = LocalViewRange.GetUpperBoundValue();
float LocalViewRangeMin = LocalViewRange.GetLowerBoundValue();
const float OutputViewSize = LocalViewRangeMax - LocalViewRangeMin;
const float OutputChange = OutputViewSize * InDelta;
float NewViewOutputMin = LocalViewRangeMin - (OutputChange * MousePositionFraction);
float NewViewOutputMax = LocalViewRangeMax + (OutputChange * (1.f - MousePositionFraction));
if( FMath::Abs( OutputChange ) > 0.01f && NewViewOutputMin < NewViewOutputMax )
{
SetViewRange(NewViewOutputMin, NewViewOutputMax, EViewRangeInterpolation::Animated);
return true;
}
return false;
}
TSharedRef<SWidget> FSequencerTimeSliderController::OpenSetPlaybackRangeMenu(float MouseTime)
{
const bool bShouldCloseWindowAfterMenuSelection = true;
FMenuBuilder MenuBuilder(bShouldCloseWindowAfterMenuSelection, nullptr);
FText NumericText;
if (SequencerSnapValues::IsTimeSnapIntervalFrameRate(TimeSliderArgs.Settings->GetTimeSnapInterval()) && TimeSliderArgs.Settings->GetShowFrameNumbers())
{
NumericText = FText::Format(LOCTEXT("FrameTextFormat", "Playback Range (at frame {0}):"), FText::AsNumber(TimeToFrame(MouseTime)));
}
else
{
NumericText = FText::Format(LOCTEXT("TimeTextFormat", "Playback Range (at {0}s):"), FText::AsNumber(MouseTime));
}
TRange<float> PlaybackRange = TimeSliderArgs.PlaybackRange.Get();
MenuBuilder.BeginSection("SequencerPlaybackRangeMenu", NumericText);
{
MenuBuilder.AddMenuEntry(
FText::Format(LOCTEXT("SetPlaybackStart", "Set Start Time"), NumericText),
FText(),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateLambda([=]{ return SetPlaybackRangeStart(MouseTime); }),
FCanExecuteAction::CreateLambda([=]{ return MouseTime <= PlaybackRange.GetUpperBoundValue(); })
)
);
MenuBuilder.AddMenuEntry(
FText::Format(LOCTEXT("SetPlaybackEnd", "Set End Time"), NumericText),
FText(),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateLambda([=]{ return SetPlaybackRangeEnd(MouseTime); }),
FCanExecuteAction::CreateLambda([=]{ return MouseTime >= PlaybackRange.GetLowerBoundValue(); })
)
);
}
MenuBuilder.EndSection(); // SequencerPlaybackRangeMenu
return MenuBuilder.MakeWidget();
}
void FSequencer::ZoomToSelectedSections()
{
TArray< TRange<float> > Bounds;
for (TWeakObjectPtr<UMovieSceneSection> SelectedSection : *Selection.GetSelectedSections())
{
Bounds.Add(SelectedSection->GetRange());
}
TRange<float> BoundsHull = TRange<float>::Hull(Bounds);
if (BoundsHull.IsEmpty())
{
BoundsHull = GetTimeBounds();
}
if (!BoundsHull.IsEmpty() && !BoundsHull.IsDegenerate())
{
OnViewRangeChanged(BoundsHull, true);
}
}
void SSequencerTrackArea::Tick( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime )
{
CachedGeometry = AllottedGeometry;
auto SequencerPin = SequencerWidget.Pin();
if (SequencerPin.IsValid())
{
SequencerPin->GetEditTool().Tick(AllottedGeometry, InCurrentTime, InDeltaTime);
}
FVector2D Size = AllottedGeometry.GetLocalSize();
if (!bLockInOutToStartEndRange.Get())
{
if (SizeLastFrame.IsSet() && Size.X != SizeLastFrame->X)
{
// Zoom by the difference in horizontal size
const float Difference = Size.X - SizeLastFrame->X;
TRange<float> OldRange = TimeSliderController->GetViewRange().GetAnimationTarget();
TimeSliderController->SetViewRange(
OldRange.GetLowerBoundValue(),
OldRange.GetUpperBoundValue() + (Difference * OldRange.Size<float>() / SizeLastFrame->X),
EViewRangeInterpolation::Immediate
);
}
}
SizeLastFrame = Size;
for (int32 Index = 0; Index < Children.Num(); )
{
if (!StaticCastSharedRef<SWeakWidget>(Children[Index].GetWidget())->ChildWidgetIsValid())
{
Children.RemoveAt(Index);
}
else
{
++Index;
}
}
}
bool FSequencer::IsSectionVisible(UMovieSceneSection* Section) const
{
// if no shots are being filtered, don't filter at all
bool bShowAll = !IsShotFilteringOn();
bool bIsAShotSection = Section->IsA<UMovieSceneShotSection>();
bool bIsUnfilterable = UnfilterableSections.Find(Section) != INDEX_NONE;
// do not draw if not within the filtering shot sections
TRange<float> SectionRange = Section->GetRange();
bool bIsVisible = bShowAll || bIsAShotSection || bIsUnfilterable;
for (int32 i = 0; i < FilteringShots.Num() && !bIsVisible; ++i)
{
TRange<float> ShotRange = FilteringShots[i]->GetRange();
bIsVisible |= SectionRange.Overlaps(ShotRange);
}
return bIsVisible;
}
bool FMoveSection::IsSectionAtNewLocationValid(UMovieSceneSection* InSection, int32 RowIndex, float DeltaTime, TSharedPtr<FTrackNode> SequencerNode) const
{
// Also get the closest borders on either side
const TArray< TSharedRef<ISequencerSection> >& Sections = SequencerNode->GetSections();
for (int32 SectionIndex = 0; SectionIndex < Sections.Num(); ++SectionIndex)
{
const UMovieSceneSection* MovieSection = Sections[SectionIndex]->GetSectionObject();
if (InSection != MovieSection && MovieSection->GetRowIndex() == RowIndex)
{
TRange<float> OffsetSectionRange = TRange<float>(
InSection->GetRange().GetLowerBoundValue() + DeltaTime,
InSection->GetRange().GetUpperBoundValue() + DeltaTime);
if (OffsetSectionRange.Overlaps(MovieSection->GetRange()))
{
return false;
}
}
}
return true;
}
void FVisualLoggerTimeSliderController::CommitScrubPosition( float NewValue, bool bIsScrubbing )
{
// Manage the scrub position ourselves if its not bound to a delegate
if ( !TimeSliderArgs.ScrubPosition.IsBound() )
{
TimeSliderArgs.ScrubPosition.Set( NewValue );
}
TRange<float> LocalViewRange = TimeSliderArgs.ViewRange.Get();
const float RangeSize = LocalViewRange.Size<float>();
if (NewValue < LocalViewRange.GetLowerBoundValue())
{
SetTimeRange(NewValue, NewValue + RangeSize);
}
else if (NewValue > LocalViewRange.GetUpperBoundValue())
{
SetTimeRange(NewValue - RangeSize, NewValue);
}
TimeSliderArgs.OnScrubPositionChanged.ExecuteIfBound( NewValue, bIsScrubbing );
}
const UMovieSceneSection* UMovieSceneSection::OverlapsWithSections(const TArray<UMovieSceneSection*>& Sections, int32 TrackDelta, float TimeDelta) const
{
// Check overlaps with exclusive ranges so that sections can butt up against each other
int32 NewTrackIndex = RowIndex + TrackDelta;
TRange<float> NewSectionRange = TRange<float>(TRange<float>::BoundsType::Exclusive(StartTime + TimeDelta), TRange<float>::BoundsType::Exclusive(EndTime + TimeDelta));
for (const auto Section : Sections)
{
check(Section);
if ((this != Section) && (Section->GetRowIndex() == NewTrackIndex))
{
TRange<float> ExclusiveSectionRange = TRange<float>(TRange<float>::BoundsType::Exclusive(Section->GetRange().GetLowerBoundValue()), TRange<float>::BoundsType::Exclusive(Section->GetRange().GetUpperBoundValue()));
if (NewSectionRange.Overlaps(ExclusiveSectionRange))
{
return Section;
}
}
}
return nullptr;
}
