[UE] Weapon Plugin 1: Slate UI Plugin 만들기

using UnrealBuildTool;
 
public class Weapon : ModuleRules
{
	public Weapon(ReadOnlyTargetRules Target) : base(Target)
	{
		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
 
        PrivateIncludePaths.Add(ModuleDirectory);
 
		PublicDependencyModuleNames.Add("Core");
		PrivateDependencyModuleNames.Add("U2212_06");//프로젝트명
 
		PrivateDependencyModuleNames.Add("CoreUObject");
        PrivateDependencyModuleNames.Add("Engine");
        PrivateDependencyModuleNames.Add("Slate");
        PrivateDependencyModuleNames.Add("SlateCore");
 
        PrivateDependencyModuleNames.Add("UnrealEd");//UFactory 
    }
}

#pragma once
 
#include "CoreMinimal.h"
#include "Modules/ModuleManager.h"
 
class FWeaponModule : public IModuleInterface
{
public:
	virtual void StartupModule() override;
	virtual void ShutdownModule() override;
 
private:
	TSharedPtr<class FWeaponContextMenu> ContextMenu;//언리얼 내 우클릭 대분류목록
};

#include "WeaponModule.h"
#include "WeaponContextMenu.h"
#include "IAssetTools.h"
#include "AssetToolsModule.h"
 
#define LOCTEXT_NAMESPACE "FWeaponModule"
IMPLEMENT_MODULE(FWeaponModule, Weapon)
 
void FWeaponModule::StartupModule()
{
	IAssetTools& assetTools = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools").Get();
	EAssetTypeCategories::Type categories = assetTools.RegisterAdvancedAssetCategory("WeaponAsset", FText::FromString("Weapon"));//
	ContextMenu = MakeShareable(new FWeaponContextMenu(categories));
	assetTools.RegisterAssetTypeActions(ContextMenu.ToSharedRef());
}
 
void FWeaponModule::ShutdownModule()
{
	if (ContextMenu.IsValid())
		ContextMenu.Reset();
}
 
#undef LOCTEXT_NAMESPACE

#pragma once
 
#include "CoreMinimal.h"
#include "Factories/Factory.h"
#include "WeaponAssetFactory.generated.h"
 
UCLASS()
class WEAPON_API UWeaponAssetFactory : public UFactory
{
	GENERATED_BODY()
 
public:
	UWeaponAssetFactory();
 
	//FactoryCreateFile 파일을 읽어들여 에셋을 직접 생성할 때 사용한다.
	//FactorCreateNew는 새로 에셋을 생성할 때 사용한다.
	UObject* FactoryCreateNew(UClass* InClass, UObject* InParent, FName InName, EObjectFlags Flags, UObject* Context, FFeedbackContext* Warn, FName CallingContext) override;
};

#include "WeaponAssetFactory.h"
#include "Weapons/CWeaponAsset.h"
 
UWeaponAssetFactory::UWeaponAssetFactory()
{
	bCreateNew = true;//없으면 터질 수 있다.
 
	//Factory.h의 SupportedClass 사용.
	//Q.어떤 클래스 타입에 대한 factory냐? A.WeaponAsset의 StaticClass다. 
	SupportedClass = UCWeaponAsset::StaticClass();
}
 
UObject* UWeaponAssetFactory::FactoryCreateNew(UClass* InClass, UObject* InParent, FName InName, EObjectFlags Flags,
	UObject* Context, FFeedbackContext* Warn, FName CallingContext)
{
	UCWeaponAsset* asset = NewObject<UCWeaponAsset>(InParent, InClass, InName, Flags);
 
	return nullptr;
}

#pragma once
 
#include "CoreMinimal.h"
#include "AssetTypeActions_Base.h"
#include "AssetTypeCategories.h"
 
//_Base 붙는것은 Abstract 지칭하는 네이밍컨벤션
class WEAPON_API FWeaponContextMenu
	: public FAssetTypeActions_Base 
{
public:
	FWeaponContextMenu(EAssetTypeCategories::Type InCategory);
 
public:
	virtual FText GetName() const override;
	virtual UClass* GetSupportedClass() const override;
	virtual FColor GetTypeColor() const override;
	uint32 GetCategories() override;
 
private:
	EAssetTypeCategories::Type Category;
};

#include "WeaponContextMenu.h"
#include "Weapons/CWeaponAsset.h"
 
FWeaponContextMenu::FWeaponContextMenu(EAssetTypeCategories::Type InCategory)
{
	Category = InCategory;
}
 
FText FWeaponContextMenu::GetName() const
{
	return FText::FromString("DataAsset");
}
 
UClass* FWeaponContextMenu::GetSupportedClass() const
{
	return UCWeaponAsset::StaticClass();//factory가 동작할 클래스로 리턴.
}
 
FColor FWeaponContextMenu::GetTypeColor() const
{
	return FColor::Blue;
}
 
uint32 FWeaponContextMenu::GetCategories()
{
	return Category;//만든 것이 소속될 (우클릭해서 나오는)카테고리를 리턴.
}

#pragma once
 
#include "CoreMinimal.h"
 
class WEAPON_API FWeaponStyle
{
public:
	static TSharedRef<FWeaponStyle> Get();
	static void Shutdown();
 
private:
	static TSharedPtr<FWeaponStyle> Instance;
 
public:
	FWeaponStyle();
	~FWeaponStyle();
 
private:
	void RegisterIcon(const FString& InName, const FString& InPath, const FVector2D& InIconSize, FSlateIcon& OutSlateIcon);
 
private:
	static const FName StyleSetName;
 
private:
	TSharedPtr<class FSlateStyleSet> StyleSet;
 
public:
	FSlateIcon ToolBar_Icon;
};

#include "WeaponStyle.h"
#include "Styling/SlateStyle.h"
#include "Styling/SlateStyleRegistry.h"
 
const FName FWeaponStyle::StyleSetName = "WeaponStyle";
 
TSharedPtr<FWeaponStyle> FWeaponStyle::Instance = nullptr;
 
TSharedRef<FWeaponStyle> FWeaponStyle::Get()
{
    if (Instance == nullptr)
        Instance = MakeShareable(new FWeaponStyle());
 
    return Instance.ToSharedRef();
}
 
void FWeaponStyle::Shutdown()
{
    if (Instance.IsValid())
        Instance.Reset();
}
 
FWeaponStyle::FWeaponStyle()
{
    StyleSet = MakeShareable(new FSlateStyleSet(StyleSetName));
 
 
    FString path = "";
 
    path = FPaths::ProjectPluginsDir() / "Weapon" / "Resources";
    RegisterIcon("ToolBar_Icon", path / "weapon_thumnail_icon.png", FVector2D(40, 40), ToolBar_Icon);
 
    FSlateStyleRegistry::RegisterSlateStyle(*StyleSet.Get());
}
 
FWeaponStyle::~FWeaponStyle()
{
    if (StyleSet.IsValid() == false) return;
 
    FSlateStyleRegistry::UnRegisterSlateStyle(StyleSetName);
    StyleSet.Reset();
}
 
void FWeaponStyle::RegisterIcon(const FString& InName, const FString& InPath, const FVector2D& InIconSize, FSlateIcon& OutSlateIcon)
{
    FSlateImageBrush* brush = new FSlateImageBrush(InPath, InIconSize);
 
    FString name = StyleSetName.ToString() + "." + InName;
    StyleSet->Set(FName(name), brush);
 
    OutSlateIcon = FSlateIcon(FName(StyleSetName), FName(name));
}