Assumed Knowledge

You are an experienced programmer that has experience with object-oriented programming languages, such as C++ and Java. You have moderate experience or have mastered basic programming concepts, such as variables, functions, classes, reflection, modules, compiling, debugging, etc; and you can write and compile your own programs.

Plugins

A Plugin is similar to a Module except it may include Content (assets) as well as code.

Project and Engine Plugins

Project Plugins will reside in the

Plugins

folder, which is in the Project's root directory (where the .uproject resides).

Engine Plugins will initially be created as a Project Plugin where they will be programmed and debugged, but when distributed, they will reside in the Engine's installation directory. For example, Marketplace Plugins are installed to the folder:

.../UE_/Engine/Plugins/Marketplace/

Plugin Descriptor File

A .uplugin file, which is a plain-text file that stores Plugin Descriptors in a JSON object. It will exist at the root directory of the Plugin.

Plugin File Structure

Modules

Plugins may contain one or more Modules, which are implemented by creating a class that inherits from

IModuleInterface

and overriding the '''

StartupModule

''' and '''

ShutdownModule

''' methods, etc. Each Module will exist in its own subfolder under the Plugin's "Source" folder. A Module may also act as a controller (in an MVC architecture) in which methods are implemented to perform actions. When a new Plugin is created, a Module will automatically be generated in the Plugin's "Source" folder and its generated folder and module will be given the same name as the Plugin, e.g.

The Module's path:

/MyPluginTitle/Source/MyPluginTitle

The Module's header file:

/MyPluginTitle/Source/MyPluginTitle/Public/MyPluginTitle.h

The Module's type name:

FMyPluginTitleModule

Listing 1 below shows the module header generated for a plugin from the Editor Toolbar Button template with the name MyEditorToolbarButton. Note that it does not contain a reflection header, i.e. *.generated.h

Listing 1: Generated Module from Editor Toolbar Button Template

// MyEditorToolbarButton.h
// Copyright 1998-2018 Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "Modules/ModuleManager.h"

class FToolBarBuilder;
class FMenuBuilder;

class FMyEditorToolbarButtonModule : public IModuleInterface
{
public:

    /** IModuleInterface implementation */
    virtual void StartupModule() override;
    virtual void ShutdownModule() override;
    
    /** This function will be bound to Command. */
    void PluginButtonClicked();
    
private:

    void AddToolbarExtension(FToolBarBuilder& Builder);
    void AddMenuExtension(FMenuBuilder& Builder);

private:
    TSharedPtr PluginCommands;
};

A Module may also contain Commands, which contains metadata that may be mapped to UI elements. And those Commands may have methods or Actions or mapped to them using the

MapAction

method. For example, the generated Module above contains the variable "PluginCommands", which stores a list of Commands.

A Module may also have style data that can be applied to UI elements, which may be stored in a Style class.

Module Descriptors

Module's also have Descriptors that will be defined in the Plugin's Descriptor file and they consist of the properties Name, Type, and LoadingPhase. Please read the official documentation for further details.

New Reflected Types

Warnings and Tips

Commands

Commands are instances of the

FUICommandInfo

class, which contains metadata about the appearance and functionality of a command that may be mapped to a UI element, such as ActiveChords, Label, Description, Icon, UIStyle, CommandName, UserInterfaceType (See UICommandInfo.h).

Command Registration

When a new plugin is created, it may have automatically generated a subclass of

TCommands

and overridden the method

RegisterCommands()

. Within this method, the Commands will be instantiated using the

UI_COMMAND

macro.

void FMyToolbarButtonCommands::RegisterCommands()
{
    UI_COMMAND(PluginAction, "MyToolbarButton", "Execute MyToolbarButton action", EUserInterfaceActionType::Button, FInputGesture());
}

The

RegisterCommands()

method is invoked during the Module's

StartupModule()

method.

void FMyToolbarButtonModule::StartupModule()
{
    ...

    FMyToolbarButtonCommands::Register();
    ...

Mapping Actions to Commands

After a Command has been instantiated, it may be mapped to a method or an Action.

    PluginCommands = MakeShareable(new FUICommandList);

    PluginCommands->MapAction(
        FMyToolbarButtonCommands::Get().PluginAction,
        FExecuteAction::CreateRaw(this, &FMyToolbarButtonModule::PluginButtonClicked),
        FCanExecuteAction());

Editor Keyboard Shortcuts

Commands may be assigned keyboard shortcuts in the Editor Preferences:

Editor Preferences > Keyboard Shortcuts > General - Keyboard Shortcuts

Actions

Actions are instances of the struct

FUIAction

and contains FExecuteAction*** delegates (see UIAction.h). An Action may also be mapped to a Command using the

MapAction

method.

Style

A Style class is a base class that contains Slate appearance data, such as images and fonts, that may be mapped to a Plugin's Slate UI elements. A "Style" class will automatically be generated with some Plugin Templates as the file

***Style.h

within a Module's Source folder.

Style Set Name

The Style Set Name is a string of the type

FName

and is similar to a package name. In automatically generated

***Style.h

classes, the method

GetStyleSetName()

will be implemented and return a string such as, "[MyModuleTitle]Style" or "[MyPluginTitle]Style".

Slate Style Set

The class

FSlateStyleSet

is a subclass of

ISlateStyle

, and encapsulates Slate appearance properties. A variable of the type

FSlateStyleSet

will automatically be created with some Plugin Templates in the

***Style.h

class, e.g:

static TSharedPtr< class FSlateStyleSet > StyleInstance;

The variable

StyleInstance

is instantiated in the Style class's

Create()

method for automatically generated Style classes. Within this method, the root directory of the style's content is assigned to the Plugin's folder "Resources". This method is also used to create the mapping of property names to appearance data, such as fonts and images, etc using the method

FSlateStyleSet::Set

, e.g:

Style->Set("MyModule.PropertyName", new IMAGE_BRUSH(TEXT("Filename"), Icon40x40));

Property Names

Property Names are strings of the type

FName

and are typically assigned in the format "MyModule.PropertyName". They are mapped to appearance data using the

Set

method and they may be referenced when creating instances of Slate objects, e.g:

FSlateIcon(FMyModuleStyle::GetStyleSetName(), "MyModule.PropertyName")

Style Lifecycle Methods

In automatically generated

***Style.h

classes, the lifecycle methods

Initialize

and

Shutdown

and

ReloadTextures

will be implemented. The Initialize and ReloadTexture methods will be invoked during a Module's StartupModule method and the Shutdown method will be invoked during the Module's ShutdownModule method.

Extenders and UI Extension Points

TODO

Slate UI Framework

Plugin Editor Settings

Automation Scripts

Tools

Custom Editor Mode

Tips