UE4: Guidebook
4.25
4.25
  • Introduction
  • Quick Reference
    • C++ Data Type Snippets
    • The UPROPERTY Macro
    • The UFUNCTION Macro
  • Wiki Archives
    • Debugging & Utilities
      • Exec Functions
      • How To Prevent Crashes Due To Dangling Actor Pointers
      • Profiling: How to Count CPU Cycles
      • Logs: Printing Messages to Yourself during Runtime
    • Macros & Data Types
      • Structs, USTRUCTS(), They're Awesome
      • Enums For Both C++ and BP
      • Delegates in UE4, Raw C++, and BP Exposed
      • Interfaces in C++
      • Iterators
      • String Conversions: FString to FName, FString to Int32, Float to FString
    • Networking
      • Standalone Dedicated Server
      • How To Use Sessions In C++
      • Spawn Different Pawns For Players in Multiplayer
      • Spawn Different Pawns For Every Player
      • Gameplay Abilities and You
    • DevOps
      • Linking DLLs
    • AR & VR
      • Integrating OpenCV into Unreal Engine 4
Powered by GitBook
On this page
  • Overview
  • BP Graphs: Switch on Enum
  • C++ .h File
  • Testing the Value in the C++
  • Get Name of Enum as String
  • GetEnumFromString
  • Summary

Was this helpful?

  1. Wiki Archives
  2. Macros & Data Types

Enums For Both C++ and BP

This wiki article was written by Rama.

PreviousStructs, USTRUCTS(), They're AwesomeNextDelegates in UE4, Raw C++, and BP Exposed

Last updated 5 years ago

Was this helpful?

This article is still in the process of being cleaned up, but it has been captured for preservation.

Overview

Dear Community,

Here's how you can create your own Enums that can be used with C++ and BP graphs!

Enums basically give you ability to define a series of related types with long human-readible names, using a low-cost data type.

These could be AI states, object types, ammo types, weapon types, tree types, or anything really :)

Enumgraph.jpg

BP Graphs: Switch on Enum

For BP Graphs, one of the most wonderful things about ENUMS is the ability to use Switch on Enum() instead of having to do a series of branches and testing one value many times

C++ .h File

You need to add the UENUM definition above your class and then actually create a member variable in your class that you want to have be an instance of this enum.

If you want an enum to be used in many different classes (instances of this enum in many classes) you can define the enum in some class that holds all your other important definitions like USTRUCTS().

UENUM(BlueprintType)
enum class EVictory : uint8 {
    VE_Dance       UMETA(DisplayName="Dance"),
    VE_Rain        UMETA(DisplayName="Rain"),
    VE_Song        UMETA(DisplayName="Song"),
};

Testing the Value in the C++

UCLASS()
class YourClass : public YourSuperClass {
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    EVictory VictoryEnum;

};
if (EVictory == EVictory::VE_Dance) {
    EVictory = EVictory::VE_Song;
} else {
    EVictory = EVictory::VE_Rain;
};

Get Name of Enum as String

FString GetVictoryEnumAsString(EVictory::Type EnumValue) {
const UEnum* EnumPtr = FindObject<UEnum>(ANY_PACKAGE, TEXT("EVictoryEnum"), true);
    if (!EnumPtr) return FString("Invalid");
        return EnumPtr->GetNameByValue((int64)EnumValue); // for EnumValue == VE_Dance returns "VE_Dance"
    }
}

Templatized Version

// Example usage GetEnumValueAsString<EVictoryEnum>("EVictoryEnum", VictoryEnum))); 

template<typename TEnum>
static FORCEINLINE FString GetEnumValueAsString(const FString& Name, TEnum Value) {
    const UEnum* enumPtr = FindObject<UEnum>(ANY_PACKAGE, *Name, true);
    if (!enumPtr) return FString("Invalid");
    return enumPtr->GetNameByValue((int64)Value).ToString();
} 

{ return FString("Invalid"); }

   return enumPtr->GetNameByValue((int64)Value).ToString();

}

// Example usage GetEnumValueAsString<EVictoryEnum>("EVictoryEnum", VictoryEnum))); </syntaxhighlight>

Also, if you want to avoid retyping the enum class name as a string on every call to GetEnumValueAsString, you can also define a c++ macro in the .h file where the function is defined.

For example, if you have defined GetEnumValueAsString in a class UTextUtil in TextUtil.h, you would have this macro

<syntaxhighlight lang="cpp">

  1. define EnumToString(EnumClassName, ValueOfEnum) UTextUtil::GetEnumValueAsString<EnumClassName>(FString(TEXT(#EnumClassName)), (ValueOfEnum))

</syntaxhighlight>

This way in any other file where you want a FString from an enum value, you would do:

FString EnumString = EnumToString(EVictoryEnum, EVictoryEnum::VE_Dance);

GetEnumFromString

If you want to retrieve an Enum value after storing the Enum as a string, here is how!

template <typename EnumType>
static FORCEINLINE EnumType GetEnumValueFromString(const FString& EnumName, const FString& String) {
  UEnum* Enum = FindObject<UEnum>(ANY_PACKAGE, *EnumName, true);
  if(!Enum) { 
    return EnumType(0);
  }		
  return (EnumType)Enum->FindEnumIndex(FName(*String));
}

//Sample Usage FString ParseLine = GetEnumValueAsString<EChallenge>("EChallenge", VictoryEnumValue))); //To String EChallenge Challenge = GetEnumValueFromString<EChallenge>("EChallenge", ParseLine); //Back From String!

Summary

Now you know how to make enums that are project specific, that can be used in both C++ and Blueprints!

Enjoy!

Rama