Frame13/ayon-core
1
0
Fork 1
mirror of https://github.com/ynput/ayon-core.git synced 2026-01-02 00:44:52 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Updated plugin for UE5

Browse source
This commit is contained in:
Simone Barbieri 2022-05-03 16:29:45 +01:00
parent ddddb86e77
commit 25fd05df9e
7 changed files with 116 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

2
openpype/hosts/unreal/integration/Source/OpenPype/OpenPype.Build.cs
View file

@ -36,7 +36,9 @@ public class OpenPype : ModuleRules
{
"Projects",
"InputCore",
"EditorFramework",
"UnrealEd",
"ToolMenus",
"LevelEditor",
"CoreUObject",
"Engine",

110
openpype/hosts/unreal/integration/Source/OpenPype/Private/OpenPype.cpp
View file

@ -1,7 +1,10 @@
#include "OpenPype.h"
#include "LevelEditor.h"
#include "OpenPypePythonBridge.h"
#include "OpenPypeStyle.h"
#include "OpenPypeCommands.h"
#include "OpenPypePythonBridge.h"
#include "LevelEditor.h"
#include "Misc/MessageDialog.h"
#include "ToolMenus.h"
static const FName OpenPypeTabName("OpenPype");
@ -11,82 +14,61 @@ static const FName OpenPypeTabName("OpenPype");
// This function is triggered when the plugin is staring up
void FOpenPypeModule::StartupModule()
{
FOpenPypeStyle::Initialize();
FOpenPypeStyle::SetIcon("Logo", "openpype40");
FOpenPypeStyle::ReloadTextures();
FOpenPypeCommands::Register();
// Create the Extender that will add content to the menu
FLevelEditorModule& LevelEditorModule = FModuleManager::LoadModuleChecked<FLevelEditorModule>("LevelEditor");
TSharedPtr<FExtender> MenuExtender = MakeShareable(new FExtender());
TSharedPtr<FExtender> ToolbarExtender = MakeShareable(new FExtender());
PluginCommands = MakeShareable(new FUICommandList);
MenuExtender->AddMenuExtension(
"LevelEditor",
EExtensionHook::After,
NULL,
FMenuExtensionDelegate::CreateRaw(this, &FOpenPypeModule::AddMenuEntry)
);
ToolbarExtender->AddToolBarExtension(
"Settings",
EExtensionHook::After,
NULL,
FToolBarExtensionDelegate::CreateRaw(this, &FOpenPypeModule::AddToobarEntry));
LevelEditorModule.GetMenuExtensibilityManager()->AddExtender(MenuExtender);
LevelEditorModule.GetToolBarExtensibilityManager()->AddExtender(ToolbarExtender);
PluginCommands->MapAction(
FOpenPypeCommands::Get().OpenPypeTools,
FExecuteAction::CreateRaw(this, &FOpenPypeModule::MenuPopup),
FCanExecuteAction());
PluginCommands->MapAction(
FOpenPypeCommands::Get().OpenPypeToolsDialog,
FExecuteAction::CreateRaw(this, &FOpenPypeModule::MenuDialog),
FCanExecuteAction());
UToolMenus::RegisterStartupCallback(FSimpleMulticastDelegate::FDelegate::CreateRaw(this, &FOpenPypeModule::RegisterMenus));
}
void FOpenPypeModule::ShutdownModule()
{
UToolMenus::UnRegisterStartupCallback(this);
UToolMenus::UnregisterOwner(this);
FOpenPypeStyle::Shutdown();
FOpenPypeCommands::Unregister();
}
void FOpenPypeModule::AddMenuEntry(FMenuBuilder& MenuBuilder)
void FOpenPypeModule::RegisterMenus()
{
// Create Section
MenuBuilder.BeginSection("OpenPype", TAttribute<FText>(FText::FromString("OpenPype")));
// Owner will be used for cleanup in call to UToolMenus::UnregisterOwner
FToolMenuOwnerScoped OwnerScoped(this);
{
// Create a Submenu inside of the Section
MenuBuilder.AddMenuEntry(
FText::FromString("Tools..."),
FText::FromString("Pipeline tools"),
FSlateIcon(FOpenPypeStyle::GetStyleSetName(), "OpenPype.Logo"),
FUIAction(FExecuteAction::CreateRaw(this, &FOpenPypeModule::MenuPopup))
);
MenuBuilder.AddMenuEntry(
FText::FromString("Tools dialog..."),
FText::FromString("Pipeline tools dialog"),
FSlateIcon(FOpenPypeStyle::GetStyleSetName(), "OpenPype.Logo"),
FUIAction(FExecuteAction::CreateRaw(this, &FOpenPypeModule::MenuDialog))
);
UToolMenu* Menu = UToolMenus::Get()->ExtendMenu("LevelEditor.MainMenu.Tools");
{
// FToolMenuSection& Section = Menu->FindOrAddSection("OpenPype");
FToolMenuSection& Section = Menu->AddSection(
"OpenPype",
TAttribute<FText>(FText::FromString("OpenPype")),
FToolMenuInsert("Programming", EToolMenuInsertType::Before)
);
Section.AddMenuEntryWithCommandList(FOpenPypeCommands::Get().OpenPypeTools, PluginCommands);
Section.AddMenuEntryWithCommandList(FOpenPypeCommands::Get().OpenPypeToolsDialog, PluginCommands);
}
UToolMenu* ToolbarMenu = UToolMenus::Get()->ExtendMenu("LevelEditor.LevelEditorToolBar.PlayToolBar");
{
FToolMenuSection& Section = ToolbarMenu->FindOrAddSection("PluginTools");
{
FToolMenuEntry& Entry = Section.AddEntry(FToolMenuEntry::InitToolBarButton(FOpenPypeCommands::Get().OpenPypeTools));
Entry.SetCommandList(PluginCommands);
}
}
}
MenuBuilder.EndSection();
}
void FOpenPypeModule::AddToobarEntry(FToolBarBuilder& ToolbarBuilder)
{
ToolbarBuilder.BeginSection(TEXT("OpenPype"));
{
ToolbarBuilder.AddToolBarButton(
FUIAction(
FExecuteAction::CreateRaw(this, &FOpenPypeModule::MenuPopup),
NULL,
FIsActionChecked()
),
NAME_None,
LOCTEXT("OpenPype_label", "OpenPype"),
LOCTEXT("OpenPype_tooltip", "OpenPype Tools"),
FSlateIcon(FOpenPypeStyle::GetStyleSetName(), "OpenPype.Logo")
);
}
ToolbarBuilder.EndSection();
}

13
openpype/hosts/unreal/integration/Source/OpenPype/Private/OpenPypeCommands.cpp Normal file
View file

@ -0,0 +1,13 @@
// Copyright Epic Games, Inc. All Rights Reserved.
#include "OpenPypeCommands.h"
#define LOCTEXT_NAMESPACE "FOpenPypeModule"
void FOpenPypeCommands::RegisterCommands()
{
UI_COMMAND(OpenPypeTools, "OpenPype Tools", "Pipeline tools", EUserInterfaceActionType::Button, FInputChord());
UI_COMMAND(OpenPypeToolsDialog, "OpenPype Tools Dialog", "Pipeline tools dialog", EUserInterfaceActionType::Button, FInputChord());
}
#undef LOCTEXT_NAMESPACE

53
openpype/hosts/unreal/integration/Source/OpenPype/Private/OpenPypeStyle.cpp
View file

@ -1,10 +1,14 @@
#include "OpenPype.h"
#include "OpenPypeStyle.h"
#include "Framework/Application/SlateApplication.h"
#include "Styling/SlateStyle.h"
#include "Styling/SlateStyleRegistry.h"
#include "Slate/SlateGameResources.h"
#include "Interfaces/IPluginManager.h"
#include "Styling/SlateStyleMacros.h"
#define RootToContentDir Style->RootToContentDir
TUniquePtr< FSlateStyleSet > FOpenPypeStyle::OpenPypeStyleInstance = nullptr;
TSharedPtr<FSlateStyleSet> FOpenPypeStyle::OpenPypeStyleInstance = nullptr;
void FOpenPypeStyle::Initialize()
{
@ -17,11 +21,9 @@ void FOpenPypeStyle::Initialize()
void FOpenPypeStyle::Shutdown()
{
if (OpenPypeStyleInstance.IsValid())
{
FSlateStyleRegistry::UnRegisterSlateStyle(*OpenPypeStyleInstance);
OpenPypeStyleInstance.Reset();
}
FSlateStyleRegistry::UnRegisterSlateStyle(*OpenPypeStyleInstance);
ensure(OpenPypeStyleInstance.IsUnique());
OpenPypeStyleInstance.Reset();
}
FName FOpenPypeStyle::GetStyleSetName()
@ -30,41 +32,30 @@ FName FOpenPypeStyle::GetStyleSetName()
return StyleSetName;
}
FName FOpenPypeStyle::GetContextName()
{
static FName ContextName(TEXT("OpenPype"));
return ContextName;
}
#define IMAGE_BRUSH(RelativePath, ...) FSlateImageBrush( Style->RootToContentDir( RelativePath, TEXT(".png") ), __VA_ARGS__ )
const FVector2D Icon16x16(16.0f, 16.0f);
const FVector2D Icon20x20(20.0f, 20.0f);
const FVector2D Icon40x40(40.0f, 40.0f);
TUniquePtr< FSlateStyleSet > FOpenPypeStyle::Create()
TSharedRef< FSlateStyleSet > FOpenPypeStyle::Create()
{
TUniquePtr< FSlateStyleSet > Style = MakeUnique<FSlateStyleSet>(GetStyleSetName());
Style->SetContentRoot(FPaths::ProjectPluginsDir() / TEXT("OpenPype/Resources"));
TSharedRef< FSlateStyleSet > Style = MakeShareable(new FSlateStyleSet("OpenPypeStyle"));
Style->SetContentRoot(IPluginManager::Get().FindPlugin("OpenPype")->GetBaseDir() / TEXT("Resources"));
Style->Set("OpenPype.OpenPypeTools", new IMAGE_BRUSH(TEXT("openpype40"), Icon40x40));
Style->Set("OpenPype.OpenPypeToolsDialog", new IMAGE_BRUSH(TEXT("openpype40"), Icon40x40));
return Style;
}
void FOpenPypeStyle::SetIcon(const FString& StyleName, const FString& ResourcePath)
void FOpenPypeStyle::ReloadTextures()
{
FSlateStyleSet* Style = OpenPypeStyleInstance.Get();
FString Name(GetContextName().ToString());
Name = Name + "." + StyleName;
Style->Set(*Name, new FSlateImageBrush(Style->RootToContentDir(ResourcePath, TEXT(".png")), Icon40x40));
FSlateApplication::Get().GetRenderer()->ReloadTextureResources();
if (FSlateApplication::IsInitialized())
{
FSlateApplication::Get().GetRenderer()->ReloadTextureResources();
}
}
#undef IMAGE_BRUSH
const ISlateStyle& FOpenPypeStyle::Get()
{
check(OpenPypeStyleInstance);
return *OpenPypeStyleInstance;
return *OpenPypeStyleInstance;
}

8
openpype/hosts/unreal/integration/Source/OpenPype/Public/OpenPype.h
View file

@ -2,7 +2,8 @@
#pragma once
#include "Engine.h"
#include "CoreMinimal.h"
#include "Modules/ModuleManager.h"
class FOpenPypeModule : public IModuleInterface
@ -12,10 +13,11 @@ public:
virtual void ShutdownModule() override;
private:
void RegisterMenus();
void AddMenuEntry(FMenuBuilder& MenuBuilder);
void AddToobarEntry(FToolBarBuilder& ToolbarBuilder);
void MenuPopup();
void MenuDialog();
private:
TSharedPtr<class FUICommandList> PluginCommands;
};

24
openpype/hosts/unreal/integration/Source/OpenPype/Public/OpenPypeCommands.h Normal file
View file

@ -0,0 +1,24 @@
// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include "Framework/Commands/Commands.h"
#include "OpenPypeStyle.h"
class FOpenPypeCommands : public TCommands<FOpenPypeCommands>
{
public:
FOpenPypeCommands()
: TCommands<FOpenPypeCommands>(TEXT("OpenPype"), NSLOCTEXT("Contexts", "OpenPype", "OpenPype Tools"), NAME_None, FOpenPypeStyle::GetStyleSetName())
{
}
// TCommands<> interface
virtual void RegisterCommands() override;
public:
TSharedPtr< FUICommandInfo > OpenPypeTools;
TSharedPtr< FUICommandInfo > OpenPypeToolsDialog;
};

12
openpype/hosts/unreal/integration/Source/OpenPype/Public/OpenPypeStyle.h
View file

@ -1,22 +1,18 @@
#pragma once
#include "CoreMinimal.h"
class FSlateStyleSet;
class ISlateStyle;
#include "Styling/SlateStyle.h"
class FOpenPypeStyle
{
public:
static void Initialize();
static void Shutdown();
static void ReloadTextures();
static const ISlateStyle& Get();
static FName GetStyleSetName();
static FName GetContextName();
static void SetIcon(const FString& StyleName, const FString& ResourcePath);
private:
static TUniquePtr< FSlateStyleSet > Create();
static TUniquePtr< FSlateStyleSet > OpenPypeStyleInstance;
static TSharedRef< class FSlateStyleSet > Create();
static TSharedPtr< class FSlateStyleSet > OpenPypeStyleInstance;
};