TSharedRef<SWidget> UUModComboBox::HandleGenerateWidget(TSharedPtr<FString> Item) const
{
FString StringItem = Item.IsValid() ? *Item : FString();
// Call the user's delegate to see if they want to generate a custom widget bound to the data source.
if (!IsDesignTime() && OnGenerateWidgetEvent.IsBound())
{
UWidget* Widget = OnGenerateWidgetEvent.Execute(StringItem);
if (Widget != NULL)
{
return Widget->TakeWidget();
}
}
//UMod ComboBoxString Customize injector start
TSharedRef<STextBlock> widget = SNew(STextBlock).Text(FText::FromString(StringItem));
if (!ElementsTooltipText.IsEmpty()) {
FString rep = ElementsTooltipText.Replace(TEXT("%e"), **Item, ESearchCase::IgnoreCase);
widget->SetToolTipText(FText::FromString(rep));
}
FTextBlockStyle fuckUE4Const = ElementsTextStyle;
FTextBlockStyle *style = new FTextBlockStyle(ElementsTextStyle);
widget->SetTextStyle(style);
return widget;
//UMod ComboBoxString Customize injector end
}
bool FUMGSequencerObjectBindingManager::TryGetObjectBindingDisplayName(const TSharedRef<FMovieSceneInstance>& MovieSceneInstance, const FGuid& ObjectGuid, FText& DisplayName) const
{
// TODO: This gets called every frame for every bound object and could be a potential performance issue for a really complicated animation.
TArray<TWeakObjectPtr<UObject>> BindingObjects;
GuidToPreviewObjectsMap.MultiFind(ObjectGuid, BindingObjects);
TArray<TWeakObjectPtr<UObject>> SlotContentBindingObjects;
GuidToSlotContentPreviewObjectsMap.MultiFind(ObjectGuid, SlotContentBindingObjects);
if (BindingObjects.Num() == 0 && SlotContentBindingObjects.Num() == 0)
{
DisplayName = LOCTEXT("NoBoundObjects", "No bound objects");
}
else if (BindingObjects.Num() + SlotContentBindingObjects.Num() > 1)
{
DisplayName = LOCTEXT("Multiple bound objects", "Multilple bound objects");
}
else if (BindingObjects.Num() == 1)
{
DisplayName = FText::FromString(BindingObjects[0].Get()->GetName());
}
else // SlotContentBindingObjects.Num() == 1
{
UWidget* SlotContent = Cast<UWidget>(SlotContentBindingObjects[0].Get());
FText PanelName = SlotContent->Slot != nullptr && SlotContent->Slot->Parent != nullptr
? FText::FromString(SlotContent->Slot->Parent->GetName())
: LOCTEXT("InvalidPanel", "Invalid Panel");
FText ContentName = FText::FromString(SlotContent->GetName());
DisplayName = FText::Format(LOCTEXT("SlotObject", "{0} ({1} Slot)"), ContentName, PanelName);
}
return true;
}
FReply STransformHandle::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if ( MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton )
{
Action = ComputeActionAtLocation(MyGeometry, MouseEvent);
FWidgetReference SelectedWidget = Designer->GetSelectedWidget();
UWidget* Preview = SelectedWidget.GetPreview();
UWidget* Template = SelectedWidget.GetTemplate();
if ( UCanvasPanelSlot* Slot = Cast<UCanvasPanelSlot>(Preview->Slot) )
{
StartingOffsets = Slot->GetOffsets();
}
MouseDownPosition = MouseEvent.GetScreenSpacePosition();
ScopedTransaction = new FScopedTransaction(LOCTEXT("ResizeWidget", "Resize Widget"));
Template->Modify();
return FReply::Handled().CaptureMouse(SharedThis(this));
}
return FReply::Unhandled();
}
void FWidgetBlueprintEditor::MigrateFromChain(FEditPropertyChain* PropertyThatChanged, bool bIsModify)
{
UWidgetBlueprint* Blueprint = GetWidgetBlueprintObj();
UUserWidget* PreviewActor = GetPreview();
if ( PreviewActor != nullptr )
{
for ( FWidgetReference& WidgetRef : SelectedWidgets )
{
UWidget* PreviewWidget = WidgetRef.GetPreview();
if ( PreviewWidget )
{
FName PreviewWidgetName = PreviewWidget->GetFName();
UWidget* TemplateWidget = Blueprint->WidgetTree->FindWidget(PreviewWidgetName);
if ( TemplateWidget )
{
FEditPropertyChain::TDoubleLinkedListNode* PropertyChainNode = PropertyThatChanged->GetHead();
MigratePropertyValue(PreviewWidget, TemplateWidget, PropertyChainNode, PropertyChainNode->GetValue(), bIsModify);
}
}
}
}
}
TSharedRef<SWidget> UMenuAnchor::HandleGetMenuContent()
{
TSharedPtr<SWidget> SlateMenuWidget;
if ( OnGetMenuContentEvent.IsBound() )
{
UWidget* MenuWidget = OnGetMenuContentEvent.Execute();
if ( MenuWidget )
{
SlateMenuWidget = MenuWidget->TakeWidget();
}
}
else
{
if ( MenuClass != nullptr && !MenuClass->HasAnyClassFlags(CLASS_Abstract) )
{
UUserWidget* MenuWidget = CreateWidget<UUserWidget>(GetWorld(), MenuClass);
if ( MenuWidget )
{
SlateMenuWidget = MenuWidget->TakeWidget();
}
}
}
return SlateMenuWidget.IsValid() ? SlateMenuWidget.ToSharedRef() : SNullWidget::NullWidget;
}
TSharedPtr<SWidget> UUserWidget::GetSlateWidgetFromName(const FName& Name) const
{
UWidget* WidgetObject = WidgetTree->FindWidget(Name);
if ( WidgetObject )
{
return WidgetObject->GetCachedWidget();
}
return TSharedPtr<SWidget>();
}
void UUserWidget::ReleaseSlateResources(bool bReleaseChildren)
{
Super::ReleaseSlateResources(bReleaseChildren);
UWidget* RootWidget = GetRootWidget();
if ( RootWidget )
{
RootWidget->ReleaseSlateResources(bReleaseChildren);
}
}
void FWidgetBlueprintEditor::InitWidgetBlueprintEditor(const EToolkitMode::Type Mode, const TSharedPtr< IToolkitHost >& InitToolkitHost, const TArray<UBlueprint*>& InBlueprints, bool bShouldOpenInDefaultsMode)
{
TSharedPtr<FWidgetBlueprintEditor> ThisPtr(SharedThis(this));
WidgetToolbar = MakeShareable(new FWidgetBlueprintEditorToolbar(ThisPtr));
InitBlueprintEditor(Mode, InitToolkitHost, InBlueprints, bShouldOpenInDefaultsMode);
// register for any objects replaced
GEditor->OnObjectsReplaced().AddSP(this, &FWidgetBlueprintEditor::OnObjectsReplaced);
UWidgetBlueprint* Blueprint = GetWidgetBlueprintObj();
// If this blueprint is empty, add a canvas panel as the root widget.
if ( Blueprint->WidgetTree->RootWidget == nullptr )
{
UWidget* RootWidget = Blueprint->WidgetTree->ConstructWidget<UCanvasPanel>(UCanvasPanel::StaticClass());
RootWidget->SetDesignerFlags(GetCurrentDesignerFlags());
Blueprint->WidgetTree->RootWidget = RootWidget;
}
UpdatePreview(GetWidgetBlueprintObj(), true);
// If the user has close the sequencer tab, this will not be initialized.
if ( SequencerObjectBindingManager.IsValid() )
{
SequencerObjectBindingManager->InitPreviewObjects();
}
DesignerCommandList = MakeShareable(new FUICommandList);
DesignerCommandList->MapAction(FGenericCommands::Get().Delete,
FExecuteAction::CreateSP(this, &FWidgetBlueprintEditor::DeleteSelectedWidgets),
FCanExecuteAction::CreateSP(this, &FWidgetBlueprintEditor::CanDeleteSelectedWidgets)
);
DesignerCommandList->MapAction(FGenericCommands::Get().Copy,
FExecuteAction::CreateSP(this, &FWidgetBlueprintEditor::CopySelectedWidgets),
FCanExecuteAction::CreateSP(this, &FWidgetBlueprintEditor::CanCopySelectedWidgets)
);
DesignerCommandList->MapAction(FGenericCommands::Get().Cut,
FExecuteAction::CreateSP(this, &FWidgetBlueprintEditor::CutSelectedWidgets),
FCanExecuteAction::CreateSP(this, &FWidgetBlueprintEditor::CanCutSelectedWidgets)
);
DesignerCommandList->MapAction(FGenericCommands::Get().Paste,
FExecuteAction::CreateSP(this, &FWidgetBlueprintEditor::PasteWidgets),
FCanExecuteAction::CreateSP(this, &FWidgetBlueprintEditor::CanPasteWidgets)
);
}
UWidget* FWidgetTemplateClass::CreateNamed(class UWidgetTree* Tree, FName NameOverride)
{
if (NameOverride != NAME_None)
{
UObject* ExistingObject = StaticFindObject(UObject::StaticClass(), Tree, *NameOverride.ToString());
if (ExistingObject != nullptr)
{
NameOverride = MakeUniqueObjectName(Tree, WidgetClass.Get(), NameOverride);
}
}
UWidget* NewWidget = Tree->ConstructWidget<UWidget>(WidgetClass.Get(), NameOverride);
NewWidget->OnCreationFromPalette();
return NewWidget;
}
TSharedRef<SWidget> UComboBoxString::HandleGenerateWidget(TSharedPtr<FString> Item) const
{
FString StringItem = Item.IsValid() ? *Item : FString();
// Call the user's delegate to see if they want to generate a custom widget bound to the data source.
if ( !IsDesignTime() && OnGenerateWidgetEvent.IsBound() )
{
UWidget* Widget = OnGenerateWidgetEvent.Execute(StringItem);
if ( Widget != NULL )
{
return Widget->TakeWidget();
}
}
// If a row wasn't generated just create the default one, a simple text block of the item's name.
return SNew(STextBlock).Text(FText::FromString(StringItem));
}
void FWidgetBlueprintEditor::ExtendSequencerAddTrackMenu( FMenuBuilder& AddTrackMenuBuilder, TArray<UObject*> ContextObjects )
{
if ( ContextObjects.Num() == 1 )
{
UWidget* Widget = Cast<UWidget>( ContextObjects[0] );
if ( Widget != nullptr && Widget->GetParent() != nullptr && Widget->Slot != nullptr )
{
AddTrackMenuBuilder.BeginSection( "Slot", LOCTEXT( "SlotSection", "Slot" ) );
{
FUIAction AddSlotAction( FExecuteAction::CreateRaw( this, &FWidgetBlueprintEditor::AddSlotTrack, Widget->Slot ) );
FText AddSlotLabel = FText::Format(LOCTEXT("SlotLabelFormat", "{0} Slot"), FText::FromString(Widget->GetParent()->GetName()));
FText AddSlotToolTip = FText::Format(LOCTEXT("SlotToolTipFormat", "Add {0} slot"), FText::FromString( Widget->GetParent()->GetName()));
AddTrackMenuBuilder.AddMenuEntry(AddSlotLabel, AddSlotToolTip, FSlateIcon(), AddSlotAction);
}
AddTrackMenuBuilder.EndSection();
}
}
}
void GetBindableObjects(UWidget* RootWidget, TArray<FObjectAndDisplayName>& BindableObjects)
{
TArray<UWidget*> ToTraverse;
ToTraverse.Add(RootWidget);
while (ToTraverse.Num() > 0)
{
UWidget* Widget = ToTraverse[0];
ToTraverse.RemoveAt(0);
BindableObjects.Add(FObjectAndDisplayName(FText::FromString(Widget->GetName()), Widget));
UUserWidget* UserWidget = Cast<UUserWidget>(Widget);
if (UserWidget != nullptr)
{
TArray<FName> SlotNames;
UserWidget->GetSlotNames(SlotNames);
for (FName SlotName : SlotNames)
{
UWidget* Content = UserWidget->GetContentForSlot(SlotName);
if (Content != nullptr)
{
ToTraverse.Add(Content);
}
}
}
UPanelWidget* PanelWidget = Cast<UPanelWidget>(Widget);
if (PanelWidget != nullptr)
{
for (UPanelSlot* Slot : PanelWidget->GetSlots())
{
if (Slot->Content != nullptr)
{
FText SlotDisplayName = FText::Format(LOCTEXT("AddMenuSlotFormat", "{0} ({1} Slot)"), FText::FromString(Slot->Content->GetName()), FText::FromString(PanelWidget->GetName()));
BindableObjects.Add(FObjectAndDisplayName(SlotDisplayName, Slot));
ToTraverse.Add(Slot->Content);
}
}
}
}
}
const FSlateBrush* FWidgetTemplateClass::GetIcon() const
{
UWidget* DefaultWidget = WidgetClass->GetDefaultObject<UWidget>();
return DefaultWidget->GetEditorIcon();
}
FReply FCanvasSlotExtension::HandleAnchorDragging(const FGeometry& Geometry, const FPointerEvent& Event, EAnchorWidget::Type AnchorType)
{
if ( bMovingAnchor && !Event.GetCursorDelta().IsZero() )
{
float InverseSize = 1.0f / Designer->GetPreviewScale();
for ( FWidgetReference& Selection : SelectionCache )
{
UWidget* PreviewWidget = Selection.GetPreview();
if ( UCanvasPanel* Canvas = Cast<UCanvasPanel>(PreviewWidget->GetParent()) )
{
UCanvasPanelSlot* PreviewCanvasSlot = Cast<UCanvasPanelSlot>(PreviewWidget->Slot);
FGeometry Geometry;
if ( Canvas->GetGeometryForSlot(PreviewCanvasSlot, Geometry) )
{
FGeometry CanvasGeometry = Canvas->GetCanvasWidget()->GetCachedGeometry();
FVector2D StartLocalPosition = CanvasGeometry.AbsoluteToLocal(MouseDownPosition);
FVector2D NewLocalPosition = CanvasGeometry.AbsoluteToLocal(Event.GetScreenSpacePosition());
FVector2D LocalPositionDelta = NewLocalPosition - StartLocalPosition;
FVector2D AnchorDelta = LocalPositionDelta / CanvasGeometry.Size;
const FAnchorData OldLayoutData = PreviewCanvasSlot->LayoutData;
FAnchorData LayoutData = OldLayoutData;
switch ( AnchorType )
{
case EAnchorWidget::Center:
LayoutData.Anchors.Maximum = BeginAnchors.Maximum + AnchorDelta;
LayoutData.Anchors.Minimum = BeginAnchors.Minimum + AnchorDelta;
LayoutData.Anchors.Minimum.X = FMath::Clamp(LayoutData.Anchors.Minimum.X, 0.0f, 1.0f);
LayoutData.Anchors.Maximum.X = FMath::Clamp(LayoutData.Anchors.Maximum.X, 0.0f, 1.0f);
LayoutData.Anchors.Minimum.Y = FMath::Clamp(LayoutData.Anchors.Minimum.Y, 0.0f, 1.0f);
LayoutData.Anchors.Maximum.Y = FMath::Clamp(LayoutData.Anchors.Maximum.Y, 0.0f, 1.0f);
break;
}
switch ( AnchorType )
{
case EAnchorWidget::Left:
case EAnchorWidget::TopLeft:
case EAnchorWidget::BottomLeft:
LayoutData.Anchors.Minimum.X = BeginAnchors.Minimum.X + AnchorDelta.X;
LayoutData.Anchors.Minimum.X = FMath::Clamp(LayoutData.Anchors.Minimum.X, 0.0f, LayoutData.Anchors.Maximum.X);
break;
}
switch ( AnchorType )
{
case EAnchorWidget::Right:
case EAnchorWidget::TopRight:
case EAnchorWidget::BottomRight:
LayoutData.Anchors.Maximum.X = BeginAnchors.Maximum.X + AnchorDelta.X;
LayoutData.Anchors.Maximum.X = FMath::Clamp(LayoutData.Anchors.Maximum.X, LayoutData.Anchors.Minimum.X, 1.0f);
break;
}
switch ( AnchorType )
{
case EAnchorWidget::Top:
case EAnchorWidget::TopLeft:
case EAnchorWidget::TopRight:
LayoutData.Anchors.Minimum.Y = BeginAnchors.Minimum.Y + AnchorDelta.Y;
LayoutData.Anchors.Minimum.Y = FMath::Clamp(LayoutData.Anchors.Minimum.Y, 0.0f, LayoutData.Anchors.Maximum.Y);
break;
}
switch ( AnchorType )
{
case EAnchorWidget::Bottom:
case EAnchorWidget::BottomLeft:
case EAnchorWidget::BottomRight:
LayoutData.Anchors.Maximum.Y = BeginAnchors.Maximum.Y + AnchorDelta.Y;
LayoutData.Anchors.Maximum.Y = FMath::Clamp(LayoutData.Anchors.Maximum.Y, LayoutData.Anchors.Minimum.Y, 1.0f);
break;
}
// Major percentage snapping
{
const float MajorAnchorLine = 0.1f;
const float MajorAnchorLineSnapDistance = 0.1f;
if ( LayoutData.Anchors.Minimum.X != OldLayoutData.Anchors.Minimum.X )
{
ProximitySnapValue(MajorAnchorLine, MajorAnchorLineSnapDistance, LayoutData.Anchors.Minimum.X);
}
if ( LayoutData.Anchors.Minimum.Y != OldLayoutData.Anchors.Minimum.Y )
{
ProximitySnapValue(MajorAnchorLine, MajorAnchorLineSnapDistance, LayoutData.Anchors.Minimum.Y);
}
if ( LayoutData.Anchors.Maximum.X != OldLayoutData.Anchors.Maximum.X )
{
ProximitySnapValue(MajorAnchorLine, MajorAnchorLineSnapDistance, LayoutData.Anchors.Maximum.X);
}
if ( LayoutData.Anchors.Maximum.Y != OldLayoutData.Anchors.Maximum.Y )
{
ProximitySnapValue(MajorAnchorLine, MajorAnchorLineSnapDistance, LayoutData.Anchors.Maximum.Y);
}
}
// Rebase the layout and restore the old value after calculating the new final layout
// result.
{
PreviewCanvasSlot->SaveBaseLayout();
PreviewCanvasSlot->LayoutData = LayoutData;
PreviewCanvasSlot->RebaseLayout();
LayoutData = PreviewCanvasSlot->LayoutData;
PreviewCanvasSlot->LayoutData = OldLayoutData;
}
// If control is pressed reset all positional offset information
if ( FSlateApplication::Get().GetModifierKeys().IsControlDown() )
{
FMargin NewOffsets = FMargin(0, 0, LayoutData.Anchors.IsStretchedHorizontal() ? 0 : LayoutData.Offsets.Right, LayoutData.Anchors.IsStretchedVertical() ? 0 : LayoutData.Offsets.Bottom);
LayoutData.Offsets = NewOffsets;
}
UWidget* TemplateWidget = Selection.GetTemplate();
UCanvasPanelSlot* TemplateCanvasSlot = CastChecked<UCanvasPanelSlot>(TemplateWidget->Slot);
static const FName LayoutDataName(TEXT("LayoutData"));
FObjectEditorUtils::SetPropertyValue<UCanvasPanelSlot, FAnchorData>(PreviewCanvasSlot, LayoutDataName, LayoutData);
FObjectEditorUtils::SetPropertyValue<UCanvasPanelSlot, FAnchorData>(TemplateCanvasSlot, LayoutDataName, LayoutData);
}
};
return FReply::Handled();
}
}
return FReply::Unhandled();
}
EBTNodeResult::Type UBTTask_ShowPhrases::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
EBTNodeResult::Type NodeResult = ShowingNumPhrase <= PhrasesCount ? EBTNodeResult::InProgress : NodeResult = EBTNodeResult::Succeeded;
// reset timer handle
TimerHandle.Invalidate();
//AudioComponent = NULL;
if (!DialogueWidget.IsNone())
{
FName WidgetKeyName = DialogueWidget.SelectedKeyName;
BlackboardComp = OwnerComp.GetBlackboardComponent();
Widget = Cast<UUserWidget>(BlackboardComp->GetValueAsObject(WidgetKeyName));
WidgetComp = Cast<UWidgetComponent>(BlackboardComp->GetValueAsObject(WidgetKeyName));
OwnerActor = OwnerComp.GetOwner();
if (!Widget && !WidgetComp)
{
#if WITH_EDITOR
FMessageLog("PIE").Error()
->AddToken(FTextToken::Create(LOCTEXT("InvalidWidgetKey", "Invalid key for Dialogue Widget in ")))
->AddToken(FUObjectToken::Create((UObject*)OwnerComp.GetCurrentTree()));
#endif
return EBTNodeResult::Failed;
}
if (WidgetComp)
{
Widget = CreateWidget<UUserWidget>(GetWorld(), WidgetComp->GetWidgetClass());
bIsUserWidget = false;
}
else
{
bIsUserWidget = true;
}
if (Widget && Widget->IsInViewport())
{
Widget->RemoveFromParent();
}
if (Widget && !Widget->IsInViewport())
{
UWidgetTree* WidgetTree = Widget->WidgetTree;
UWidget* DialogueQuestionsSlot = WidgetTree->FindWidget(DialogueTextOptions.DialogueQuestionsSlotName);
if (DialogueQuestionsSlot != nullptr)
{
DialogueQuestionsSlot->SetVisibility(ESlateVisibility::Hidden);
}
// text
DialoguePhraseSlot = WidgetTree->FindWidget(DialogueTextOptions.DialoguePhraseSlotName);
if (DialoguePhraseSlot != nullptr)
{
DialoguePhraseSlot->SetVisibility(ESlateVisibility::Visible);
UTextBlock* StartPhraseTextBlock = Cast<UTextBlock>(DialoguePhraseSlot);
if (StartPhraseTextBlock)
{
if (DialogueTextOptions.bShowTextPhrases)
{
PhrasesCount = DialogueTextOptions.Phrases.Num() - 1; // starts from 0
if (ShowingNumPhrase > PhrasesCount)
{
ShowingNumPhrase = 0;
}
FText StartPhrase = DialogueTextOptions.Phrases.Num() > 0 ? DialogueTextOptions.Phrases[ShowingNumPhrase].Phrase : FText::GetEmpty();
if (DialogueTextOptions.TextEffect == ETextEffect::NoEffect || DialogueTextOptions.Delay == 0.0f)
{
StartPhraseTextBlock->SetText(FText::Format(NSLOCTEXT("DialogueSystem", "ShowPhraseText", "{0}"), StartPhrase));
float ShowingTime = DialogueTextOptions.UseGeneralTime ? DialogueTextOptions.GeneralShowingTime : DialogueTextOptions.Phrases[ShowingNumPhrase].ShowingTime;
TimerDelegate = FTimerDelegate::CreateUObject(this, &UBTTask_ShowPhrases::ShowNewDialoguePhrase, false);
OwnerActor->GetWorldTimerManager().SetTimer(TimerHandle, TimerDelegate, ShowingTime, false);
}
else
{
if (DialogueTextOptions.TextEffect == ETextEffect::Typewriter)
{
CurrentCharNum = 1; StringToDisplay = "";
FullString = StartPhrase.ToString().GetCharArray();
StringToDisplay.AppendChar(FullString[0]);
if (StartPhraseTextBlock)
{
StartPhraseTextBlock->SetText(FText::Format(NSLOCTEXT("DialogueSystem", "ShowPhraseText", "{0}"), FText::FromString(StringToDisplay)));
}
TimerDelegate = FTimerDelegate::CreateUObject(this, &UBTTask_ShowPhrases::ShowNewChar);
OwnerActor->GetWorldTimerManager().SetTimer(TimerHandle, TimerDelegate, DialogueTextOptions.Delay, false);
}
}
// play phrase sound
if (DialogueTextOptions.Phrases[ShowingNumPhrase].SoundToPlay)
{
PhraseAudioComponent = UGameplayStatics::SpawnSound2D(GetWorld(), DialogueTextOptions.Phrases[ShowingNumPhrase].SoundToPlay);
}
}
else
{
DialoguePhraseSlot->SetVisibility(ESlateVisibility::Hidden);
bTextFinished = true;
}
}
}
// name
DialogueNameSlot = WidgetTree->FindWidget(DialogueNameOptions.DialogueSpeakerNameSlotName);
if (DialogueNameSlot != nullptr)
{
if (DialogueNameOptions.bShowName)
{
DialogueNameSlot->SetVisibility(ESlateVisibility::Visible);
UTextBlock* NameTextBlock = Cast<UTextBlock>(DialogueNameSlot);
if (NameTextBlock)
{
NameTextBlock->SetText(DialogueNameOptions.Name);
}
}
else
{
DialogueNameSlot->SetVisibility(ESlateVisibility::Hidden);
}
}
// image
DialogueImageSlot = WidgetTree->FindWidget(DialogueImageOptions.DialogueSpeakerImageSlotName);
if (DialogueImageSlot != nullptr)
{
if (DialogueImageOptions.bShowImage)
{
DialogueImageSlot->SetVisibility(ESlateVisibility::Visible);
UImage* DialogueImage = Cast<UImage>(DialogueImageSlot);
if (DialogueImage)
{
DialogueImage->SetBrushFromTexture(DialogueImageOptions.Image);
}
}
else
{
DialogueImageSlot->SetVisibility(ESlateVisibility::Hidden);
}
}
// general sound
if (DialogueSoundOptions.bPlaySound)
{
if (DialogueSoundOptions.SoundToPlay)
{
GeneralAudioComponent = UGameplayStatics::SpawnSound2D(GetWorld(), DialogueSoundOptions.SoundToPlay);
}
}
// camera
if (DialogueCameraOptions.bUseCamera)
{
if (!DialogueCameraOptions.CameraToView.IsNone() && !DialogueCameraOptions.PlayerCamera.IsNone() && !DialogueCinematicOptions.bPlayMatinee)
{
FName CameraToViewKeyName = DialogueCameraOptions.CameraToView.SelectedKeyName;
BlackboardComp = OwnerComp.GetBlackboardComponent();
UCameraComponent* CameraToView = Cast<UCameraComponent>(BlackboardComp->GetValueAsObject(CameraToViewKeyName));
FName PlayerCameraKeyName = DialogueCameraOptions.PlayerCamera.SelectedKeyName;
PlayerCamera = Cast<UCameraComponent>(BlackboardComp->GetValueAsObject(PlayerCameraKeyName));
if (PlayerCamera && CameraToView)
{
SaveDefaultCameraData(PlayerCamera);
if (PlayerCamera == CameraToView)
{
PlayerCamera->SetWorldLocationAndRotation(DefaultCameraLocation, DefaultCameraRotation);
}
else
{
PlayerCamera->SetWorldLocationAndRotation(CameraToView->GetComponentLocation(), CameraToView->GetComponentRotation());
}
}
}
}
// cinematic
if (DialogueCinematicOptions.bPlayMatinee && !DialogueCinematicOptions.Matinee.Equals("None"))
{
for (TActorIterator<AMatineeActor> It(OwnerActor->GetWorld()); It; ++It)
{
MatineeActor = *It;
if (MatineeActor && MatineeActor->GetName().Equals(DialogueCinematicOptions.Matinee))
{
MatineeActor->bLooping = DialogueCinematicOptions.bLoop;
MatineeActor->Play();
break;
}
}
}
// character animation
if (DialogueCharacterAnimationOptions.bPlayAnimation && !DialogueCharacterAnimationOptions.Mesh.IsNone() && DialogueCharacterAnimationOptions.Animation != nullptr)
{
FName MeshKeyName = DialogueCharacterAnimationOptions.Mesh.SelectedKeyName;
BlackboardComp = OwnerComp.GetBlackboardComponent();
Mesh = Cast<USkeletalMeshComponent>(BlackboardComp->GetValueAsObject(MeshKeyName));
if (Mesh)
{
UAnimInstance *AnimInst = Mesh->GetAnimInstance();
if (AnimInst)
{
AnimInst->PlaySlotAnimationAsDynamicMontage(DialogueCharacterAnimationOptions.Animation,
DialogueCharacterAnimationOptions.AnimationBlendOptions.SlotNodeName,
DialogueCharacterAnimationOptions.AnimationBlendOptions.BlendInTime,
DialogueCharacterAnimationOptions.AnimationBlendOptions.BlendOutTime,
DialogueCharacterAnimationOptions.AnimationBlendOptions.InPlayRate);
}
if (DialogueCharacterAnimationOptions.bWaitEndOfAnimation)
{
UAnimSequenceBase* SequenceBase = DialogueCharacterAnimationOptions.Animation;
CharacterAnimationDuration = SequenceBase->SequenceLength / SequenceBase->RateScale;
}
}
bCharacterAnimationStarted = true;
}
// Event Listener
UWidget* DialogueEventListener = WidgetTree->FindWidget(FName("DialogueEventListener"));
if (DialogueEventListener != nullptr)
{
UDialogueEventListener* EventListener = Cast<UDialogueEventListener>(DialogueEventListener);
if (EventListener)
{
EventListener->ShowPhrasesNode = this;
}
}
if (bIsUserWidget)
{
Widget->AddToViewport();
}
else
{
WidgetComp->SetWidget(Widget);
WidgetComp->SetVisibility(true);
}
PlayerController = Widget->GetOwningPlayer();
if (InputMode == EWidggetInputMode::UIOnly)
{
FInputModeUIOnly InputModeUIOnly;
InputModeUIOnly.SetWidgetToFocus(Widget->TakeWidget());
PlayerController->SetInputMode(InputModeUIOnly);
}
else
{
FInputModeGameAndUI InputModeGameAndUI;
InputModeGameAndUI.SetWidgetToFocus(Widget->TakeWidget());
PlayerController->SetInputMode(InputModeGameAndUI);
}
}
else
{
bTextFinished = true;
NodeResult = EBTNodeResult::Failed;
}
}
return NodeResult;
}
