CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Plugins/MovieScene/MovieRenderPipeline/Source/MovieRenderPipelineEditor/Private/MoviePipelineQuickRenderMenu.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

590 lines
25 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "MoviePipelineQuickRenderMenu.h"
#include "Customizations/Graph/MovieGraphQuickRenderSettingsCustomization.h"
#include "Editor.h"
#include "Framework/Application/SlateApplication.h"
#include "Framework/Docking/TabManager.h"
#include "Graph/MovieGraphQuickRender.h"
#include "Misc/ConfigCacheIni.h"
#include "Misc/MessageDialog.h"
#include "MoviePipelineQuickRenderUIState.h"
#include "MoviePipelineUtils.h"
#include "MovieRenderPipelineCoreModule.h"
#include "MovieRenderPipelineEditorModule.h"
#include "MovieRenderPipelineEditorUtils.h"
#include "MovieRenderPipelineSettings.h"
#include "MovieRenderPipelineStyle.h"
#include "PropertyEditorModule.h"
#include "SActionButton.h"
#include "Styling/ToolBarStyle.h"
#include "ToolMenu.h"
#include "ToolMenus.h"
#include "Widgets/Input/SComboBox.h"
#include "Widgets/Text/SRichTextBlock.h"
class UMovieGraphVariable;
class UMovieGraphConfig;
#define LOCTEXT_NAMESPACE "FMoviePipelineQuickRenderMenu"
void FMoviePipelineQuickRenderMenu::AddQuickRenderButtonToToolMenu(UToolMenu* InMenu)
{
if (!InMenu)
{
return;
}
// Use a lambda to fetch the button icon so it can change dynamically with the active mode
const TAttribute<FSlateIcon> ToolbarIconAttribute = TAttribute<FSlateIcon>::CreateLambda([]()
{
const EMovieGraphQuickRenderButtonMode ButtonMode = FMoviePipelineQuickRenderUIState::GetQuickRenderButtonMode();
const EMovieGraphQuickRenderMode QuickRenderMode = FMoviePipelineQuickRenderUIState::GetQuickRenderMode();
if (ButtonMode == EMovieGraphQuickRenderButtonMode::QuickRender)
{
return GetIconForQuickRenderMode(QuickRenderMode);
}
return FSlateIcon(FMovieRenderPipelineStyle::Get().GetStyleSetName(), "MovieRenderPipeline.QuickRender.Icon.MovieRenderQueueMode");
});
// Add to the existing "Content" section in the Assets toolbar
FToolMenuSection& Section = InMenu->FindOrAddSection("Content");
const FToolMenuEntry QuickRenderLaunchButton =
FToolMenuEntry::InitToolBarButton(
"QuickRender",
FUIAction(
FExecuteAction::CreateStatic(&FMoviePipelineQuickRenderMenu::QuickRenderButtonPressed)),
LOCTEXT("QuickRenderButtonName", "Quick Render"),
TAttribute<FText>::Create(
TAttribute<FText>::FGetter::CreateLambda([]()
{
return LOCTEXT("BeginQuickRender",
"Begin Render\n\nThere are two modes to choose from:"
"\n- Movie Render Queue. This uses the job(s) that are active in the Movie Render Queue editor as the source of the render."
"\n\n- Quick Render. This performs a render without having to manually configure a queue and a graph. A typical quick render uses "
"the current map and level sequence, the level sequence's playback range, and the viewport's look, to generate frames. Several different types of quick "
"renders are available -- see the options drop-down.");
})
),
ToolbarIconAttribute
);
Section.AddEntry(QuickRenderLaunchButton);
const FToolMenuEntry QuickRenderOptionsButton = FToolMenuEntry::InitComboButton(
"QuickRenderOptions",
FUIAction(),
FOnGetContent::CreateStatic(&FMoviePipelineQuickRenderMenu::GenerateQuickRenderOptionsMenu),
LOCTEXT("QuickRenderOptionsLabel", "Quick Render Options"),
LOCTEXT("QuickRenderOptionsToolTip", "Quick Render Options"),
TAttribute<FSlateIcon>(),
true
);
Section.AddEntry(QuickRenderOptionsButton);
}
void FMoviePipelineQuickRenderMenu::RemoveQuickRenderButtonToolMenu()
{
if (UToolMenus* ToolMenus = UToolMenus::TryGet())
{
ToolMenus->RemoveEntry("LevelEditor.LevelEditorToolBar.AssetsToolBar", "Content", "QuickRender");
}
}
void FMoviePipelineQuickRenderMenu::LoadQuickRenderSettings()
{
InitQuickRenderModeSettingsFromMode(FMoviePipelineQuickRenderUIState::GetQuickRenderMode());
}
void FMoviePipelineQuickRenderMenu::QuickRenderButtonPressed()
{
LoadQuickRenderSettings();
if (FMoviePipelineQuickRenderUIState::GetQuickRenderButtonMode() == EMovieGraphQuickRenderButtonMode::QuickRender)
{
// The settings window will have its own Render button, so don't perform the render if showing the settings first
if (FMoviePipelineQuickRenderUIState::GetShouldShowSettingsBeforeRender())
{
OpenQuickRenderSettingsWindow(FToolMenuContext());
}
else
{
UMovieGraphQuickRenderSubsystem* QuickRenderSubsystem = GEditor->GetEditorSubsystem<UMovieGraphQuickRenderSubsystem>();
QuickRenderSubsystem->BeginQuickRender(FMoviePipelineQuickRenderUIState::GetQuickRenderMode(), QuickRenderModeSettings.Get());
}
}
else
{
// If there's an existing Movie Render Queue tab open, try to do a render with what's in the queue. Otherwise, just open the MRQ editor tab.
if (FGlobalTabmanager::Get()->FindExistingLiveTab(IMovieRenderPipelineEditorModule::MoviePipelineQueueTabName))
{
if (!UE::MovieRenderPipelineEditor::Private::PerformLocalRender())
{
FMessageDialog::Open(
EAppMsgType::Ok,
LOCTEXT("UnableToStartLocalRender", "Unable to start local render. Make sure a job is present in the queue, a render is not currently running, and an executor is specified in Project Settings."));
}
}
else
{
FGlobalTabmanager::Get()->TryInvokeTab(IMovieRenderPipelineEditorModule::MoviePipelineQueueTabName);
}
}
}
TSharedRef<SWidget> FMoviePipelineQuickRenderMenu::GenerateQuickRenderOptionsMenu()
{
static const FName MenuName("MoviePipeline.QuickRenderOptionsMenu");
LoadQuickRenderSettings();
if (!UToolMenus::Get()->IsMenuRegistered(MenuName))
{
UToolMenu* Menu = UToolMenus::Get()->RegisterMenu(MenuName);
GenerateModesMenuSection(Menu);
GenerateQuickRenderMenuSection(Menu);
GenerateQuickRenderConfigurationMenuSection(Menu);
GenerateOutputMenuSection(Menu);
GenerateSettingsMenuSection(Menu);
}
return UToolMenus::Get()->GenerateWidget(MenuName, FToolMenuContext());
}
void FMoviePipelineQuickRenderMenu::OpenQuickRenderSettingsWindow(const FToolMenuContext& InToolMenuContext)
{
LoadQuickRenderSettings();
if (const TSharedPtr<SWindow> SettingsWindow = WeakQuickRenderSettingsWindow.Pin())
{
SettingsWindow->DrawAttention(FWindowDrawAttentionParameters());
return;
}
// Before the window opens, sync up the mode that the Settings window is using to be the mode that the toolbar shows
FMoviePipelineQuickRenderUIState::SetWindowQuickRenderMode(FMoviePipelineQuickRenderUIState::GetQuickRenderMode());
// Init the modes that are available to switch to
QuickRenderModes.Empty();
const UEnum* ModesEnum = StaticEnum<EMovieGraphQuickRenderMode>();
for (int32 EnumIndex = 0; EnumIndex < ModesEnum->NumEnums() - 1; ++EnumIndex) // -1 to avoid MAX
{
QuickRenderModes.Add(MakeShared<FName>(ModesEnum->GetNameByIndex(EnumIndex)));
}
// Update the graph preset's variable assignments in case the graph was updated since the last time the window opened
UpdateVariableAssignmentsForCurrentGraph();
FPropertyEditorModule& PropertyEditorModule = FModuleManager::Get().LoadModuleChecked<FPropertyEditorModule>("PropertyEditor");
FDetailsViewArgs DetailsViewArgs;
DetailsViewArgs.bShowPropertyMatrixButton = false;
DetailsViewArgs.bCustomNameAreaLocation = false;
DetailsViewArgs.NameAreaSettings = FDetailsViewArgs::HideNameArea;
DetailsViewArgs.bAllowSearch = false;
DetailsViewArgs.ViewIdentifier = "MoviePipelineQuickRenderSettings";
DetailsViewArgs.bLockable = false;
// Create the details panel and display the quick render settings
const TSharedPtr<IDetailsView> DetailsView = PropertyEditorModule.CreateDetailView(DetailsViewArgs);
DetailsView->RegisterInstancedCustomPropertyLayout(
UMovieGraphQuickRenderModeSettings::StaticClass(),
FOnGetDetailCustomizationInstance::CreateStatic(&FMovieGraphQuickRenderSettingsCustomization::MakeInstance));
DetailsView->SetObject(QuickRenderModeSettings.Get());
const TSharedRef<SWindow> QuickRenderSettingsWindow = SNew(SWindow)
.Title(LOCTEXT("QuickRenderSettingsWindow_Title", "Quick Render"))
.SupportsMaximize(false)
.ClientSize(FVector2D(600.f, 510.f))
.Content()
[
SNew(SVerticalBox)
+ SVerticalBox::Slot()
.AutoHeight()
.HAlign(HAlign_Fill)
[
GenerateQuickRenderSettingsWindowToolbar()
]
+ SVerticalBox::Slot()
[
DetailsView.ToSharedRef()
]
];
if (const TSharedPtr<SWindow> RootWindow = FGlobalTabmanager::Get()->GetRootWindow())
{
FSlateApplication::Get().AddWindowAsNativeChild(QuickRenderSettingsWindow, RootWindow.ToSharedRef());
}
else
{
FSlateApplication::Get().AddWindow(QuickRenderSettingsWindow);
}
WeakDetailsPanel = DetailsView;
WeakQuickRenderSettingsWindow = QuickRenderSettingsWindow;
}
TSharedRef<SWidget> FMoviePipelineQuickRenderMenu::GenerateQuickRenderSettingsWindowToolbar()
{
auto GetWidgetForQuickRenderMode = [](TFunction<EMovieGraphQuickRenderMode()>&& GetQuickRenderMode)
{
return
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.Padding(FMargin{0.0f, 0.0f, 5.0f, 0.0f})
.AutoWidth()
[
SNew(SImage)
.ColorAndOpacity(FSlateColor::UseForeground())
.Image_Lambda([GetQuickRenderMode]()
{
return GetIconForQuickRenderMode(GetQuickRenderMode()).GetIcon();
})
.DesiredSizeOverride(FVector2d(16, 16))
]
+ SHorizontalBox::Slot()
[
SNew(STextBlock)
.Text_Lambda([GetQuickRenderMode]()
{
return StaticEnum<EMovieGraphQuickRenderMode>()->GetDisplayNameTextByValue(static_cast<int64>(GetQuickRenderMode()));
})
.ToolTipText_Lambda([GetQuickRenderMode]()
{
const UEnum* ModeEnum = StaticEnum<EMovieGraphQuickRenderMode>();
return ModeEnum->GetToolTipTextByIndex(ModeEnum->GetIndexByValue(static_cast<int64>(GetQuickRenderMode())));
})
];
};
FToolBarBuilder ToolbarBuilder(TSharedPtr<const FUICommandList>(), FMultiBoxCustomization::None);
ToolbarBuilder.BeginSection("Quick Render");
ToolbarBuilder.AddWidget(
SNew(SComboBox<TSharedPtr<FName>>)
.OptionsSource(&FMoviePipelineQuickRenderMenu::QuickRenderModes)
.OnGenerateWidget_Lambda([GetWidgetForQuickRenderMode](TSharedPtr<FName> InItem)
{
return GetWidgetForQuickRenderMode([InItem]()
{
const int64 ModeValue = StaticEnum<EMovieGraphQuickRenderMode>()->GetValueByName(*InItem);
return static_cast<EMovieGraphQuickRenderMode>(ModeValue);
});
})
.OnSelectionChanged_Lambda([](TSharedPtr<FName> InSelectedItem, ESelectInfo::Type)
{
const EMovieGraphQuickRenderMode NewRenderMode = static_cast<EMovieGraphQuickRenderMode>(
StaticEnum<EMovieGraphQuickRenderMode>()->GetValueByName(*InSelectedItem));
FMoviePipelineQuickRenderUIState::SetWindowQuickRenderMode(NewRenderMode);
// Also inform the details panel of this change. It needs to display new settings for the chosen mode.
if (const TSharedPtr<IDetailsView> DetailsPanel = WeakDetailsPanel.Pin())
{
InitQuickRenderModeSettingsFromMode(NewRenderMode);
DetailsPanel->SetObject(QuickRenderModeSettings.Get());
}
})
[
GetWidgetForQuickRenderMode([]()
{
return FMoviePipelineQuickRenderUIState::GetWindowQuickRenderMode();
})
], NAME_None, false, HAlign_Left);
ToolbarBuilder.AddWidget(
SNew(SActionButton)
.Text(LOCTEXT("QuickRenderSettingsWindow_QuickRenderButtonText", "Quick Render"))
.Icon(FAppStyle::Get().GetBrush("LevelEditor.OpenCinematic"))
.ActionButtonType(EActionButtonType::Primary)
.OnClicked_Lambda([]()
{
// Sync the Setting window's mode to the toolbar mode. This is only done when a render is performed, not when the window is closed.
FMoviePipelineQuickRenderUIState::SetQuickRenderMode(FMoviePipelineQuickRenderUIState::GetWindowQuickRenderMode());
UMovieGraphQuickRenderSubsystem* QuickRenderSubsystem = GEditor->GetEditorSubsystem<UMovieGraphQuickRenderSubsystem>();
QuickRenderSubsystem->BeginQuickRender(FMoviePipelineQuickRenderUIState::GetQuickRenderMode(), QuickRenderModeSettings.Get());
return FReply::Handled();
}),
NAME_None, false, HAlign_Right);
ToolbarBuilder.EndSection();
return ToolbarBuilder.MakeWidget();
}
void FMoviePipelineQuickRenderMenu::GenerateModesMenuSection(UToolMenu* InMenu)
{
FToolMenuSection& Section = InMenu->AddSection("MoviePipelineQuickRenderModes", LOCTEXT("QuickRenderModesSection", "Modes"));
auto AddModeAction = [&Section](const FName& InName, const FText& InLabel, const FText& InToolTip, const FSlateIcon& InIcon, EMovieGraphQuickRenderButtonMode CheckedValue)
{
FToolUIAction NewAction;
NewAction.ExecuteAction = FToolMenuExecuteAction::CreateLambda([CheckedValue](const FToolMenuContext&)
{
FMoviePipelineQuickRenderUIState::SetQuickRenderButtonMode(CheckedValue);
QuickRenderModeSettings->PostEditChange();
});
NewAction.CanExecuteAction = FToolMenuCanExecuteAction::CreateLambda([](const FToolMenuContext&) { return true; });
NewAction.GetActionCheckState = FToolMenuGetActionCheckState::CreateLambda([CheckedValue](const FToolMenuContext&)
{
return (FMoviePipelineQuickRenderUIState::GetQuickRenderButtonMode() == CheckedValue)
? ECheckBoxState::Checked
: ECheckBoxState::Unchecked;
});
Section.AddMenuEntry(InName, InLabel, InToolTip, InIcon, NewAction, EUserInterfaceActionType::RadioButton);
};
AddModeAction(
FName("QuickRender_MovieRenderQueueMode"),
LOCTEXT("QuickRenderMode_MovieRenderQueueLabel", "Movie Render Queue"),
LOCTEXT("QuickRenderMode_MovieRenderQueueToolTip", "Performs a render with the job(s) currently active in the Movie Render Queue editor."),
FSlateIcon(FMovieRenderPipelineStyle::Get().GetStyleSetName(), "MovieRenderPipeline.QuickRender.Icon.MovieRenderQueueMode"),
EMovieGraphQuickRenderButtonMode::NormalMovieRenderQueue);
AddModeAction(
FName("QuickRender_QuickRenderMode"),
LOCTEXT("QuickRenderMode_QuickRenderLabel", "Quick Render"),
LOCTEXT("QuickRenderMode_QuickRenderToolTip", "Performs a render using the Quick Render settings."),
FSlateIcon(FMovieRenderPipelineStyle::Get().GetStyleSetName(), "MovieRenderPipeline.QuickRender.Icon.QuickRenderMode"),
EMovieGraphQuickRenderButtonMode::QuickRender);
}
void FMoviePipelineQuickRenderMenu::GenerateQuickRenderMenuSection(UToolMenu* InMenu)
{
FToolMenuSection& Section = InMenu->AddSection("MoviePipelineQuickRenderType", LOCTEXT("QuickRenderType", "Quick Render"));
auto AddQuickRenderModeAction = [&Section](const FName& InName, EMovieGraphQuickRenderMode CheckedValue)
{
const UEnum* ModeEnum = StaticEnum<EMovieGraphQuickRenderMode>();
const int32 ValueIndex = ModeEnum->GetIndexByValue(static_cast<int64>(CheckedValue));
const FText ActionTooltip = ModeEnum->GetToolTipTextByIndex(ValueIndex);
const FText ActionLabel = ModeEnum->GetDisplayNameTextByIndex(ValueIndex);
FToolUIAction NewAction;
NewAction.ExecuteAction = FToolMenuExecuteAction::CreateLambda([CheckedValue](const FToolMenuContext&)
{
FMoviePipelineQuickRenderUIState::SetQuickRenderMode(CheckedValue);
QuickRenderModeSettings->PostEditChange();
});
NewAction.CanExecuteAction = FToolMenuCanExecuteAction::CreateLambda([](const FToolMenuContext&) { return true; });
NewAction.GetActionCheckState = FToolMenuGetActionCheckState::CreateLambda([CheckedValue](const FToolMenuContext&)
{
return (FMoviePipelineQuickRenderUIState::GetQuickRenderMode() == CheckedValue)
? ECheckBoxState::Checked
: ECheckBoxState::Unchecked;
});
Section.AddMenuEntry(InName, ActionLabel, ActionTooltip, GetIconForQuickRenderMode(CheckedValue), NewAction, EUserInterfaceActionType::RadioButton);
};
AddQuickRenderModeAction(
FName("QuickRender_CurrentSequence"),
EMovieGraphQuickRenderMode::CurrentSequence);
AddQuickRenderModeAction(
FName("QuickRender_UseViewportCamera"),
EMovieGraphQuickRenderMode::UseViewportCameraInSequence);
// The "Current Shot at Playhead" mode is disabled for now, may be added in the future.
/*AddQuickRenderModeAction(
FName("QuickRender_CurrentShotAtPlayhead"),
EMovieGraphQuickRenderMode::CurrentShotAtPlayhead);*/
AddQuickRenderModeAction(
FName("QuickRender_CurrentViewport"),
EMovieGraphQuickRenderMode::CurrentViewport);
AddQuickRenderModeAction(
FName("QuickRender_SelectedCameras"),
EMovieGraphQuickRenderMode::SelectedCameras);
}
void FMoviePipelineQuickRenderMenu::GenerateQuickRenderConfigurationMenuSection(UToolMenu* InMenu)
{
FToolMenuSection& Section = InMenu->AddSection("MoviePipelineQuickRenderConfiguration", LOCTEXT("QuickRenderConfiguration", "Quick Render Configuration"));
Section.AddEntry(FToolMenuEntry::InitWidget(
"QuickRenderConfiguration",
SNew(SBox)
.Padding(FMargin(16.f, 3.f))
[
SNew(SRichTextBlock)
.TextStyle(FAppStyle::Get(), "NormalText.Subdued")
.Text_Lambda([]()
{
// Generate "Configuration" text
const FText GraphName = !QuickRenderModeSettings->GraphPreset.IsNull()
? FText::FromString(QuickRenderModeSettings->GraphPreset.GetAssetName())
: LOCTEXT("QuickRenderConfigMenu_InvalidGraph", "Invalid");
// Generate "After Render" text
const FText AfterRender = (QuickRenderModeSettings->PostRenderBehavior == EMovieGraphQuickRenderPostRenderActionType::PlayRenderOutput)
? LOCTEXT("QuickRenderConfigMenu_PlayRenderOutput", "Play Render Output")
: LOCTEXT("QuickRenderConfigMenu_DoNothing", "Do Nothing");
// Generate "Viewport Look" text
const EMovieGraphQuickRenderViewportLookFlags ViewportLookFlags = static_cast<EMovieGraphQuickRenderViewportLookFlags>(QuickRenderModeSettings->ViewportLookFlags);
TArray<FText> ViewportFlags;
if (EnumHasAnyFlags(ViewportLookFlags, EMovieGraphQuickRenderViewportLookFlags::Ocio))
{
ViewportFlags.Add(LOCTEXT("QuickRenderConfigMenu_OCIO", "OCIO"));
}
if (EnumHasAnyFlags(ViewportLookFlags, EMovieGraphQuickRenderViewportLookFlags::ShowFlags))
{
ViewportFlags.Add(LOCTEXT("QuickRenderConfigMenu_ShowFlags", "Show Flags"));
}
if (EnumHasAnyFlags(ViewportLookFlags, EMovieGraphQuickRenderViewportLookFlags::ViewMode))
{
ViewportFlags.Add(LOCTEXT("QuickRenderConfigMenu_ViewMode", "View Mode"));
}
if (ViewportLookFlags == EMovieGraphQuickRenderViewportLookFlags::None)
{
ViewportFlags.Add(LOCTEXT("QuickRenderConfigMenu_DontApply", "Don't Apply"));
}
// Generate "Sequencer Frame Range" text
const FText SequencerFrameRange = StaticEnum<EMovieGraphQuickRenderFrameRangeType>()->GetDisplayNameTextByValue(static_cast<int64>(QuickRenderModeSettings->FrameRangeType));
// TODO: Add in graph variables summary as well (although this might make a summary that's too long in some cases)
FText ConfigurationSummaryText = FText::Format(
LOCTEXT("QuickRenderConfigurationSummary", "Configuration: <RichTextBlock.BoldHighlight>{0}</>\nAfter Render: {1}\nApply Viewport Look: {2}\nSequencer Frame Range: {3}"),
{
GraphName,
AfterRender,
FText::Join(LOCTEXT("CommaDelim", ", "), ViewportFlags),
SequencerFrameRange,
});
return ConfigurationSummaryText;
})
.LineHeightPercentage(1.3f)
],
FText::GetEmpty()
));
}
void FMoviePipelineQuickRenderMenu::GenerateOutputMenuSection(UToolMenu* InMenu)
{
// Only show the section if Quick Render mode is active
FToolMenuSection& Section = InMenu->AddSection("MoviePipelineQuickRenderOutput", LOCTEXT("QuickRenderOutput", "Output"));
Section.Visibility = TAttribute<EVisibility>::CreateLambda([]() -> EVisibility
{
return (FMoviePipelineQuickRenderUIState::GetQuickRenderButtonMode() == EMovieGraphQuickRenderButtonMode::QuickRender)
? EVisibility::Visible
: EVisibility::Collapsed;
});
// Menu entry for "Play Last Render"
// ---------------------------------
FToolUIAction PlayLastRenderAction;
PlayLastRenderAction.ExecuteAction = FToolMenuExecuteAction::CreateLambda([](const FToolMenuContext&)
{
UMovieGraphQuickRenderSubsystem* QuickRenderSubsystem = GEditor->GetEditorSubsystem<UMovieGraphQuickRenderSubsystem>();
QuickRenderSubsystem->PlayLastRender();
});
PlayLastRenderAction.CanExecuteAction = FToolMenuCanExecuteAction::CreateLambda([](const FToolMenuContext&)
{
UMovieGraphQuickRenderSubsystem* QuickRenderSubsystem = GEditor->GetEditorSubsystem<UMovieGraphQuickRenderSubsystem>();
return QuickRenderSubsystem->CanPlayLastRender();
});
Section.AddMenuEntry(
"QuickRender_PlayLastRender",
LOCTEXT("QuickRender_PlayLastRenderLabel", "Play Last Render"),
LOCTEXT("QuickRender_PlayLastRenderToolTip", "Play the media from the last time that Quick Render ran."),
FSlateIcon(FMovieRenderPipelineStyle::Get().GetStyleSetName(), "MovieRenderPipeline.QuickRender.Icon.PlayLastRender"),
PlayLastRenderAction);
// Menu entry for "Open Output Directory"
// --------------------------------------
FToolUIAction OpenOutputDirectoryAction;
OpenOutputDirectoryAction.ExecuteAction = FToolMenuExecuteAction::CreateLambda([](const FToolMenuContext&)
{
UMovieGraphQuickRenderSubsystem* QuickRenderSubsystem = GEditor->GetEditorSubsystem<UMovieGraphQuickRenderSubsystem>();
QuickRenderSubsystem->OpenOutputDirectory(QuickRenderModeSettings.Get());
});
OpenOutputDirectoryAction.CanExecuteAction = FToolMenuCanExecuteAction::CreateLambda([](const FToolMenuContext&) { return true; });
Section.AddMenuEntry(
"QuickRender_OpenOutputDirectory",
LOCTEXT("QuickRender_OpenOutputDirectoryLabel", "Open Output Directory"),
LOCTEXT("QuickRender_OpenOutputDirectoryToolTip", "Open the output directory that Quick Render is currently configured to save media into."),
FSlateIcon(FAppStyle::GetAppStyleSetName(), "Icons.FolderOpen"),
OpenOutputDirectoryAction);
}
void FMoviePipelineQuickRenderMenu::GenerateSettingsMenuSection(UToolMenu* InMenu)
{
FToolMenuSection& Section = InMenu->AddSection("MoviePipelineQuickRenderSettings");
Section.AddSeparator("SettingsSeparator");
FToolUIAction ShowSettingsAction;
ShowSettingsAction.ExecuteAction = FToolMenuExecuteAction::CreateLambda([](const FToolMenuContext&)
{
FMoviePipelineQuickRenderUIState::SetShouldShowSettingsBeforeRender(!FMoviePipelineQuickRenderUIState::GetShouldShowSettingsBeforeRender());
QuickRenderModeSettings->PostEditChange();
});
ShowSettingsAction.CanExecuteAction = FToolMenuCanExecuteAction::CreateLambda([](const FToolMenuContext&) { return true; });
ShowSettingsAction.GetActionCheckState = FToolMenuGetActionCheckState::CreateLambda([](const FToolMenuContext&)
{
return FMoviePipelineQuickRenderUIState::GetShouldShowSettingsBeforeRender()
? ECheckBoxState::Checked
: ECheckBoxState::Unchecked;
});
Section.AddMenuEntry(
"QuickRender_ShowSettingsBefore",
LOCTEXT("QuickRender_ShowSettingsBeforeLabel", "Show Settings Before Quick Render"),
LOCTEXT("QuickRender_ShowSettingsBeforeToolTip", "Show the quick render settings before starting a quick render."),
FSlateIcon(FAppStyle::Get().GetStyleSetName(), "Icons.OpenInExternalEditor"),
ShowSettingsAction,
EUserInterfaceActionType::ToggleButton);
FToolUIAction OpenSettingsAction;
OpenSettingsAction.ExecuteAction = FToolMenuExecuteAction::CreateStatic(&FMoviePipelineQuickRenderMenu::OpenQuickRenderSettingsWindow);
OpenSettingsAction.CanExecuteAction = FToolMenuCanExecuteAction::CreateLambda([](const FToolMenuContext&) { return true; });
Section.AddMenuEntry(
"QuickRender_OpenSettings",
LOCTEXT("QuickRender_OpenSettingsLabel", "Quick Render Settings"),
LOCTEXT("QuickRender_OpenSettingsToolTip", "Open the quick render settings."),
FSlateIcon(FAppStyle::Get().GetStyleSetName(), "Icons.Settings"),
OpenSettingsAction);
}
FSlateIcon FMoviePipelineQuickRenderMenu::GetIconForQuickRenderMode(const EMovieGraphQuickRenderMode QuickRenderMode)
{
switch(QuickRenderMode)
{
case EMovieGraphQuickRenderMode::CurrentSequence:
return FSlateIcon(FMovieRenderPipelineStyle::Get().GetStyleSetName(), "MovieRenderPipeline.QuickRender.Icon.CurrentSequenceMode");
case EMovieGraphQuickRenderMode::CurrentViewport:
return FSlateIcon(FMovieRenderPipelineStyle::Get().GetStyleSetName(), "MovieRenderPipeline.QuickRender.Icon.CurrentViewportMode");
case EMovieGraphQuickRenderMode::SelectedCameras:
return FSlateIcon(FMovieRenderPipelineStyle::Get().GetStyleSetName(), "MovieRenderPipeline.QuickRender.Icon.SelectedCamerasMode");
case EMovieGraphQuickRenderMode::UseViewportCameraInSequence:
return FSlateIcon(FMovieRenderPipelineStyle::Get().GetStyleSetName(), "MovieRenderPipeline.QuickRender.Icon.ViewportCameraInSequenceMode");
default:
return FSlateIcon();
}
}
void FMoviePipelineQuickRenderMenu::InitQuickRenderModeSettingsFromMode(const EMovieGraphQuickRenderMode QuickRenderMode)
{
QuickRenderModeSettings = TStrongObjectPtr(UMovieGraphQuickRenderSettings::GetSavedQuickRenderModeSettings(QuickRenderMode));
UpdateVariableAssignmentsForCurrentGraph();
}
void FMoviePipelineQuickRenderMenu::UpdateVariableAssignmentsForCurrentGraph()
{
MoviePipeline::RefreshVariableAssignments(QuickRenderModeSettings->GraphPreset.LoadSynchronous(), QuickRenderModeSettings->GraphVariableAssignments, QuickRenderModeSettings.Get());
}
#undef LOCTEXT_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink