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 appearance data, such as images, fonts, that may be mapped to your plugin's UI elements.

TODO

• FSlateStyleSet
• FSlateStyleRegistry
• StyleSetName
• StyleSet Content Root
• Mapping StyleSetName.CommandTitle to images, etc

Extenders and UI Extension Points

TODO

Slate UI Framework

Plugin Editor Settings

Automation Scripts

Tools

Custom Editor Mode

Tips