USkeleton* FAnimationTrackEditor::AcquireSkeletonFromObjectGuid(const FGuid& Guid)
{
TArray<UObject*> OutObjects;
GetSequencer()->GetRuntimeObjects(GetSequencer()->GetFocusedMovieSceneInstance(), Guid, OutObjects);
USkeleton* Skeleton = NULL;
for (int32 i = 0; i < OutObjects.Num(); ++i)
{
AActor* Actor = Cast<AActor>(OutObjects[i]);
if (Actor != NULL)
{
TInlineComponentArray<USkeletalMeshComponent*> SkeletalMeshComponents;
Actor->GetComponents(SkeletalMeshComponents);
for (int32 j = 0; j <SkeletalMeshComponents.Num(); ++j)
{
USkeletalMeshComponent* SkeletalMeshComp = SkeletalMeshComponents[j];
if (SkeletalMeshComp->SkeletalMesh && SkeletalMeshComp->SkeletalMesh->Skeleton)
{
// @todo Multiple actors, multiple components
check(!Skeleton);
Skeleton = SkeletalMeshComp->SkeletalMesh->Skeleton;
}
}
}
}
return Skeleton;
}
void SSection::CreateDragOperation( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent, bool bKeysUnderMouse )
{
check( !DragOperation.IsValid() );
if( bKeysUnderMouse )
{
DragOperation = MakeShareable( new FMoveKeys( GetSequencer(), GetSequencer().GetSelection().GetSelectedKeys(), PressedKey ) );
}
else
{
UMovieSceneSection* SectionObject = SectionInterface->GetSectionObject();
if( bLeftEdgePressed || bLeftEdgeHovered )
{
// Selected the start of a section
DragOperation = MakeShareable( new FResizeSection( GetSequencer(), *SectionObject, false ) );
}
else if( bRightEdgePressed || bRightEdgeHovered )
{
// Selected the end of a section
DragOperation = MakeShareable( new FResizeSection( GetSequencer(), *SectionObject, true ) );
}
else
{
// Entire selection moved
DragOperation = MakeShareable( new FMoveSection( GetSequencer(), *SectionObject ) );
}
}
}
void FSlomoTrackEditor::HandleAddSlomoTrackMenuEntryExecute()
{
UMovieSceneSequence* FocusedSequence = GetSequencer()->GetFocusedMovieSceneSequence();
UMovieScene* MovieScene = FocusedSequence->GetMovieScene();
if (MovieScene == nullptr)
{
return;
}
UMovieSceneTrack* SlomoTrack = MovieScene->FindMasterTrack( UMovieSceneSlomoTrack::StaticClass() );
if (SlomoTrack != nullptr)
{
return;
}
const FScopedTransaction Transaction(NSLOCTEXT("Sequencer", "AddSlomoTrack_Transaction", "Add Play Rate Track"));
MovieScene->Modify();
SlomoTrack = GetMasterTrack( UMovieSceneSlomoTrack::StaticClass() );
ensure(SlomoTrack);
SlomoTrack->AddSection(SlomoTrack->CreateNewSection());
GetSequencer()->NotifyMovieSceneDataChanged();
}
void FParticleTrackEditor::AddParticleKey( const FGuid ObjectGuid )
{
TArray<TWeakObjectPtr<UObject>> OutObjects;
GetSequencer()->GetRuntimeObjects( GetSequencer()->GetFocusedMovieSceneSequenceInstance(), ObjectGuid, OutObjects );
AnimatablePropertyChanged( FOnKeyProperty::CreateRaw( this, &FParticleTrackEditor::AddKeyInternal, OutObjects ) );
}
void FColorPropertyTrackEditor::BuildTrackContextMenu( FMenuBuilder& MenuBuilder, UMovieSceneTrack* Track )
{
UInterpTrackColorProp* ColorPropTrack = nullptr;
UInterpTrackLinearColorProp* LinearColorPropTrack = nullptr;
for ( UObject* CopyPasteObject : GUnrealEd->MatineeCopyPasteBuffer )
{
ColorPropTrack = Cast<UInterpTrackColorProp>( CopyPasteObject );
LinearColorPropTrack = Cast<UInterpTrackLinearColorProp>( CopyPasteObject );
if ( ColorPropTrack != nullptr || LinearColorPropTrack != nullptr )
{
break;
}
}
UMovieSceneColorTrack* ColorTrack = Cast<UMovieSceneColorTrack>( Track );
MenuBuilder.AddMenuEntry(
NSLOCTEXT( "Sequencer", "PasteMatineeColorTrack", "Paste Matinee Color Track" ),
NSLOCTEXT( "Sequencer", "PasteMatineeColorTrackTooltip", "Pastes keys from a Matinee color track into this track." ),
FSlateIcon(),
FUIAction(
ColorPropTrack != nullptr ?
FExecuteAction::CreateStatic( &CopyInterpColorTrack, GetSequencer().ToSharedRef(), ColorPropTrack, ColorTrack ) :
FExecuteAction::CreateStatic( &CopyInterpLinearColorTrack, GetSequencer().ToSharedRef(), LinearColorPropTrack, ColorTrack ),
FCanExecuteAction::CreateLambda( [=]()->bool { return ((ColorPropTrack != nullptr && ColorPropTrack->GetNumKeys() > 0) || (LinearColorPropTrack != nullptr && LinearColorPropTrack->GetNumKeys() > 0)) && ColorTrack != nullptr; } ) ) );
MenuBuilder.AddMenuSeparator();
FKeyframeTrackEditor::BuildTrackContextMenu(MenuBuilder, Track);
}
void FParticleTrackEditor::AddParticleKey(const FGuid ObjectGuid, bool bTrigger)
{
TArray<UObject*> OutObjects;
GetSequencer()->GetRuntimeObjects( GetSequencer()->GetFocusedMovieSceneInstance(), ObjectGuid, OutObjects );
AnimatablePropertyChanged( UMovieSceneParticleTrack::StaticClass(), false,
FOnKeyProperty::CreateRaw( this, &FParticleTrackEditor::AddKeyInternal, OutObjects, bTrigger) );
}
void SSection::HandleSectionSelection( const FPointerEvent& MouseEvent )
{
if( !MouseEvent.IsControlDown() )
{
GetSequencer().GetSelection().EmptySelectedSections();
}
// handle selecting sections
UMovieSceneSection* Section = SectionInterface->GetSectionObject();
GetSequencer().GetSelection().AddToSelection(Section);
}
void FAnimationTrackEditor::AddKey(const FGuid& ObjectGuid, UObject* AdditionalAsset)
{
UAnimSequence* AnimSequence = Cast<UAnimSequence>(AdditionalAsset);
if (AnimSequence)
{
TArray<UObject*> OutObjects;
GetSequencer()->GetRuntimeObjects( GetSequencer()->GetFocusedMovieSceneInstance(), ObjectGuid, OutObjects);
AnimatablePropertyChanged( UMovieSceneAnimationTrack::StaticClass(), false,
FOnKeyProperty::CreateRaw( this, &FAnimationTrackEditor::AddKeyInternal, OutObjects, AnimSequence) );
}
}
FReply FSequencerEditTool_Default::OnMouseButtonUp(SWidget& OwnerWidget, const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
FSequencer& Sequencer = static_cast<FSequencer&>(GetSequencer());
Sequencer.GetSelection().EmptySelectedSections();
Sequencer.GetSelection().EmptySelectedKeys();
return FReply::Unhandled();
}
TSharedRef<SWidget> FWidgetBlueprintEditor::CreateSequencerWidget()
{
TSharedRef<SOverlay> SequencerOverlayRef =
SNew(SOverlay)
.AddMetaData<FTagMetaData>(FTagMetaData(TEXT("Sequencer")));
SequencerOverlay = SequencerOverlayRef;
TSharedRef<STextBlock> NoAnimationTextBlockRef =
SNew(STextBlock)
.TextStyle(FEditorStyle::Get(), "UMGEditor.NoAnimationFont")
.Text(LOCTEXT("NoAnimationSelected", "No Animation Selected"));
NoAnimationTextBlock = NoAnimationTextBlockRef;
SequencerOverlayRef->AddSlot(0)
[
GetSequencer()->GetSequencerWidget()
];
SequencerOverlayRef->AddSlot(1)
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
[
NoAnimationTextBlockRef
];
return SequencerOverlayRef;
}
TSharedRef<ISequencerSection> FParticleTrackEditor::MakeSectionInterface( UMovieSceneSection& SectionObject, UMovieSceneTrack& Track )
{
check( SupportsType( SectionObject.GetOuter()->GetClass() ) );
const TSharedPtr<ISequencer> OwningSequencer = GetSequencer();
return MakeShareable( new FParticleSection( SectionObject, OwningSequencer.ToSharedRef() ) );
}
bool F3DAttachTrackEditor::AddKeyInternal( float KeyTime, const TArray<TWeakObjectPtr<UObject>> Objects, const FName SocketName, const FName ComponentName, AActor* ParentActor)
{
bool bHandleCreated = false;
bool bTrackCreated = false;
bool bTrackModified = false;
FGuid ParentActorId;
if (ParentActor != nullptr)
{
FFindOrCreateHandleResult HandleResult = FindOrCreateHandleToObject(ParentActor);
ParentActorId = HandleResult.Handle;
bHandleCreated |= HandleResult.bWasCreated;
}
if (!ParentActorId.IsValid())
{
return false;
}
for( int32 ObjectIndex = 0; ObjectIndex < Objects.Num(); ++ObjectIndex )
{
UObject* Object = Objects[ObjectIndex].Get();
FFindOrCreateHandleResult HandleResult = FindOrCreateHandleToObject( Object );
FGuid ObjectHandle = HandleResult.Handle;
bHandleCreated |= HandleResult.bWasCreated;
if (ObjectHandle.IsValid())
{
FFindOrCreateTrackResult TrackResult = FindOrCreateTrackForObject( ObjectHandle, UMovieScene3DAttachTrack::StaticClass());
UMovieSceneTrack* Track = TrackResult.Track;
bTrackCreated |= TrackResult.bWasCreated;
if (ensure(Track))
{
// Clamp to next attach section's start time or the end of the current sequencer view range
float AttachEndTime = GetSequencer()->GetViewRange().GetUpperBoundValue();
for (int32 AttachSectionIndex = 0; AttachSectionIndex < Track->GetAllSections().Num(); ++AttachSectionIndex)
{
float StartTime = Track->GetAllSections()[AttachSectionIndex]->GetStartTime();
float EndTime = Track->GetAllSections()[AttachSectionIndex]->GetEndTime();
if (KeyTime < StartTime)
{
if (AttachEndTime > StartTime)
{
AttachEndTime = StartTime;
}
}
}
Cast<UMovieScene3DAttachTrack>(Track)->AddConstraint( KeyTime, AttachEndTime, SocketName, ComponentName, ParentActorId );
bTrackModified = true;
}
}
}
return bHandleCreated || bTrackCreated || bTrackModified;
}
void FSequencerObjectBindingNode::SetDisplayName(const FText& NewDisplayName)
{
UMovieScene* MovieScene = GetSequencer().GetFocusedMovieSceneSequence()->GetMovieScene();
if (MovieScene != nullptr)
{
MovieScene->SetObjectDisplayName(ObjectBinding, NewDisplayName);
}
}
FMarginTrackEditor::~FMarginTrackEditor()
{
TSharedPtr<ISequencer> Sequencer = GetSequencer();
if( Sequencer.IsValid() )
{
ISequencerObjectChangeListener& ObjectChangeListener = Sequencer->GetObjectChangeListener();
ObjectChangeListener.GetOnAnimatablePropertyChanged( "Margin" ).RemoveAll( this );
}
}
void FSequencerObjectBindingNode::HandlePropertyMenuItemExecute(TArray<UProperty*> PropertyPath)
{
FSequencer& Sequencer = GetSequencer();
UObject* BoundObject = GetSequencer().FindSpawnedObjectOrTemplate(ObjectBinding);
TArray<UObject*> KeyableBoundObjects;
if (BoundObject != nullptr)
{
if (Sequencer.CanKeyProperty(FCanKeyPropertyParams(BoundObject->GetClass(), PropertyPath)))
{
KeyableBoundObjects.Add(BoundObject);
}
}
FKeyPropertyParams KeyPropertyParams(KeyableBoundObjects, PropertyPath, ESequencerKeyMode::ManualKeyForced);
Sequencer.KeyProperty(KeyPropertyParams);
}
TOptional<FGuid> FActorReferencePropertySection::GetActorGuid() const
{
TOptional<AActor*> CurrentActor = GetPropertyValue<AActor*>();
if (CurrentActor.IsSet() && CurrentActor.GetValue() != nullptr)
{
return TOptional<FGuid>(GetSequencer()->GetFocusedMovieSceneSequenceInstance()->FindObjectId(*CurrentActor.GetValue()));
}
return TOptional<FGuid>(FGuid());
}
void SSection::HandleKeySelection( const FSelectedKey& Key, const FPointerEvent& MouseEvent, bool bSelectDueToDrag )
{
if( Key.IsValid() )
{
// Clear previous key selection if:
// we are selecting due to drag and the key being dragged is not selected or control is not down
bool bShouldClearSelectionDueToDrag = bSelectDueToDrag ? !GetSequencer().GetSelection().IsSelected( Key ) : true;
// Keep key selection if right clicking to bring up a menu and the current key is selected
bool bKeepKeySelection = MouseEvent.GetEffectingButton() == EKeys::RightMouseButton && GetSequencer().GetSelection().IsSelected( Key );
if( (!MouseEvent.IsControlDown() && bShouldClearSelectionDueToDrag) && !bKeepKeySelection )
{
GetSequencer().GetSelection().EmptySelectedKeys();
}
GetSequencer().GetSelection().AddToSelection( Key );
}
}
FReply SSequencerSectionAreaView::OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
// Clear selected sections
if( !MouseEvent.IsControlDown() )
{
GetSequencer().ClearSectionSelection();
}
return FReply::Handled();
}
void FFaceFXAnimationTrackEditor::OnFaceFXTrackDialogClosed(FGuid ObjectBinding)
{
TSharedPtr<ISequencer> LocalSequencer = GetSequencer();
if (LocalSequencer.IsValid())
{
UObject* Object = LocalSequencer->FindSpawnedObjectOrTemplate(ObjectBinding);
AnimatablePropertyChanged(FOnKeyProperty::CreateRaw(this, &FFaceFXAnimationTrackEditor::AddFaceFXSection, Object, KeyDialog.GetSelectedAnimSet()));
}
}
bool F3DAttachTrackEditor::IsActorPickable(const AActor* const ParentActor, FGuid ObjectBinding, UMovieSceneSection* InSection)
{
// Can't pick the object that this track binds
TArray<TWeakObjectPtr<UObject>> OutObjects;
GetSequencer()->GetRuntimeObjects( GetSequencer()->GetFocusedMovieSceneSequenceInstance(), ObjectBinding, OutObjects);
if (OutObjects.Contains(ParentActor))
{
return false;
}
if (ParentActor->IsListedInSceneOutliner() &&
!FActorEditorUtils::IsABuilderBrush(ParentActor) &&
!ParentActor->IsA( AWorldSettings::StaticClass() ) &&
!ParentActor->IsPendingKill())
{
return true;
}
return false;
}
void FSequencerObjectBindingNode::HandleLabelsSubMenuCreate(FMenuBuilder& MenuBuilder)
{
const TSet< TSharedRef<FSequencerDisplayNode> >& SelectedNodes = GetSequencer().GetSelection().GetSelectedOutlinerNodes();
TArray<FGuid> ObjectBindingIds;
for (TSharedRef<const FSequencerDisplayNode> SelectedNode : SelectedNodes )
{
if (SelectedNode->GetType() == ESequencerNode::Object)
{
TSharedRef<const FSequencerObjectBindingNode> ObjectBindingNode = StaticCastSharedRef<const FSequencerObjectBindingNode>(SelectedNode);
FGuid ObjectBindingId = ObjectBindingNode->GetObjectBinding();
if (ObjectBindingId.IsValid())
{
ObjectBindingIds.Add(ObjectBindingId);
}
}
}
MenuBuilder.AddWidget(SNew(SSequencerLabelEditor, GetSequencer(), ObjectBindingIds), FText::GetEmpty(), true);
}
bool FSubMovieSceneTrackEditor::HandleAssetAdded(UObject* Asset, const FGuid& TargetObjectGuid)
{
if (Asset->IsA<UMovieScene>())
{
GetSequencer()->AddSubMovieScene( CastChecked<UMovieScene>( Asset ) );
return true;
}
return false;
}
UMaterialInterface* FComponentMaterialTrackEditor::GetMaterialInterfaceForTrack( FGuid ObjectBinding, UMovieSceneMaterialTrack* MaterialTrack )
{
UObject* ComponentObject = GetSequencer()->GetFocusedMovieSceneSequence()->FindObject( ObjectBinding );
UPrimitiveComponent* Component = Cast<UPrimitiveComponent>( ComponentObject );
UMovieSceneComponentMaterialTrack* ComponentMaterialTrack = Cast<UMovieSceneComponentMaterialTrack>( MaterialTrack );
if ( Component != nullptr && ComponentMaterialTrack != nullptr )
{
return Component->GetMaterial( ComponentMaterialTrack->GetMaterialIndex() );
}
return nullptr;
}
FText FSequencerObjectBindingNode::GetDisplayName() const
{
UMovieScene* MovieScene = GetSequencer().GetFocusedMovieSceneSequence()->GetMovieScene();
if (MovieScene != nullptr)
{
return MovieScene->GetObjectDisplayName(ObjectBinding);
}
return DefaultDisplayName;
}
bool F3DPathTrackEditor::IsActorPickable(const AActor* const ParentActor, FGuid ObjectBinding, UMovieSceneSection* InSection)
{
// Can't pick the object that this track binds
TArray<TWeakObjectPtr<UObject>> OutObjects;
GetSequencer()->GetRuntimeObjects( GetSequencer()->GetFocusedMovieSceneSequenceInstance(), ObjectBinding, OutObjects);
if (OutObjects.Contains(ParentActor))
{
return false;
}
// Can't pick the object that this track attaches to
UMovieScene3DPathSection* PathSection = Cast<UMovieScene3DPathSection>(InSection);
if (PathSection != nullptr)
{
FGuid ConstraintId = PathSection->GetConstraintId();
if (ConstraintId.IsValid())
{
TArray<TWeakObjectPtr<UObject>> ConstraintObjects;
GetSequencer()->GetRuntimeObjects( GetSequencer()->GetFocusedMovieSceneSequenceInstance(), ConstraintId, ConstraintObjects);
if (ConstraintObjects.Contains(ParentActor))
{
return false;
}
}
}
if (ParentActor->IsListedInSceneOutliner() &&
!FActorEditorUtils::IsABuilderBrush(ParentActor) &&
!ParentActor->IsA( AWorldSettings::StaticClass() ) &&
!ParentActor->IsPendingKill())
{
TArray<USplineComponent*> SplineComponents;
ParentActor->GetComponents(SplineComponents);
if (SplineComponents.Num())
{
return true;
}
}
return false;
}
bool FSubMovieSceneTrackEditor::HandleAssetAdded(UObject* Asset, const FGuid& TargetObjectGuid)
{
UMovieSceneSequence* Animation = Cast<UMovieSceneSequence>( Asset );
if( Animation )
{
GetSequencer()->AddSubMovieScene( Animation );
return true;
}
return false;
}
FReply SSection::OnMouseButtonDoubleClick( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent )
{
ResetState();
UMovieSceneSection* SectionObject = SectionInterface->GetSectionObject();
if( GetSequencer().IsSectionVisible( SectionObject ) )
{
FReply Reply = SectionInterface->OnSectionDoubleClicked( MyGeometry, MouseEvent );
if (Reply.IsEventHandled()) {return Reply;}
if( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton )
{
GetSequencer().ZoomToSelectedSections();
return FReply::Handled();
}
}
return FReply::Unhandled();
}
void F3DPathTrackEditor::ActorSocketPicked(const FName SocketName, USceneComponent* Component, AActor* ParentActor, FGuid ObjectGuid, UMovieSceneSection* Section)
{
if (Section != nullptr)
{
const FScopedTransaction Transaction(LOCTEXT("UndoSetPath", "Set Path"));
UMovieScene3DPathSection* PathSection = (UMovieScene3DPathSection*)(Section);
FGuid SplineId = FindOrCreateHandleToObject(ParentActor).Handle;
if (SplineId.IsValid())
{
PathSection->SetConstraintId(SplineId);
}
}
else if (ObjectGuid.IsValid())
{
TArray<TWeakObjectPtr<UObject>> OutObjects;
GetSequencer()->GetRuntimeObjects( GetSequencer()->GetFocusedMovieSceneSequenceInstance(), ObjectGuid, OutObjects);
AnimatablePropertyChanged( FOnKeyProperty::CreateRaw( this, &F3DPathTrackEditor::AddKeyInternal, OutObjects, ParentActor) );
}
}
UFaceFXComponent* FFaceFXAnimationTrackEditor::GetFaceFXComponent(const FGuid& Guid)
{
TSharedPtr<ISequencer> LocalSequencer = GetSequencer();
UObject* BoundObject = LocalSequencer.IsValid() ? LocalSequencer->FindSpawnedObjectOrTemplate(Guid) : nullptr;
if (AActor* Actor = Cast<AActor>(BoundObject))
{
return Actor->FindComponentByClass<UFaceFXComponent>();
}
//Fallback to direct cast
return Cast<UFaceFXComponent>(BoundObject);
}
FSelectedKey SSection::GetKeyUnderMouse( const FVector2D& MousePosition, const FGeometry& AllottedGeometry ) const
{
UMovieSceneSection& Section = *SectionInterface->GetSectionObject();
// Search every key area until we find the one under the mouse
for( int32 KeyAreaIndex = 0; KeyAreaIndex < KeyAreas.Num(); ++KeyAreaIndex )
{
const FKeyAreaElement& Element = KeyAreas[KeyAreaIndex];
TSharedRef<IKeyArea> KeyArea = Element.KeyAreaNode.GetKeyArea( SectionIndex );
// Compute the current key area geometry
FGeometry KeyAreaGeometryPadded = GetKeyAreaGeometry( Element, AllottedGeometry );
// Is the key area under the mouse
if( KeyAreaGeometryPadded.IsUnderLocation( MousePosition ) )
{
FGeometry SectionGeometry = AllottedGeometry.MakeChild(FVector2D(SequencerSectionConstants::SectionGripSize, 0), AllottedGeometry.GetDrawSize() - FVector2D(SequencerSectionConstants::SectionGripSize*2, 0.0f));
FGeometry KeyAreaGeometry = GetKeyAreaGeometry( Element, SectionGeometry );
FVector2D LocalSpaceMousePosition = KeyAreaGeometry.AbsoluteToLocal( MousePosition );
FTimeToPixel TimeToPixelConverter = Section.IsInfinite() ?
FTimeToPixel( ParentGeometry, GetSequencer().GetViewRange()) :
FTimeToPixel( KeyAreaGeometry, TRange<float>( Section.GetStartTime(), Section.GetEndTime() ) );
// Check each key until we find one under the mouse (if any)
TArray<FKeyHandle> KeyHandles = KeyArea->GetUnsortedKeyHandles();
for( int32 KeyIndex = 0; KeyIndex < KeyHandles.Num(); ++KeyIndex )
{
FKeyHandle KeyHandle = KeyHandles[KeyIndex];
float KeyPosition = TimeToPixelConverter.TimeToPixel( KeyArea->GetKeyTime(KeyHandle) );
FGeometry KeyGeometry = KeyAreaGeometry.MakeChild(
FVector2D( KeyPosition - FMath::TruncToFloat(SequencerSectionConstants::KeySize.X/2.0f), ((KeyAreaGeometry.Size.Y*.5f)-(SequencerSectionConstants::KeySize.Y*.5f)) ),
SequencerSectionConstants::KeySize );
if( KeyGeometry.IsUnderLocation( MousePosition ) )
{
// The current key is under the mouse
return FSelectedKey( Section, KeyArea, KeyHandle );
}
}
// no key was selected in the current key area but the mouse is in the key area so it cannot possibly be in any other key area
return FSelectedKey();
}
}
// No key was selected in any key area
return FSelectedKey();
}
