Properties

Property Declaration

Properties are declared using standard C++ variable syntax, preceded by the UPROPERTY macro which defines property metadata and variable specifiers.

	UPROPERTY([specifier, specifier, ...], [meta(key=value, key=value, ...)])
	Type VariableName;
Copy full snippet

UPROPERTY([specifier, specifier, ...], [meta(key=value, key=value, ...)]) Type VariableName;

Core Data Types

Integers

The convention for integral data types is "int" or "uint" followed by the size in bits.

As Bitmasks

Integer properties can now be exposed to the Editor as bitmasks. To mark an integer property as a bitmask, just add "bitmask" to the meta section, as follows:

	/*~ BasicBits appears as a list of generic flags in the editor, instead of an integer field. */
	UPROPERTY(EditAnywhere, Meta = (Bitmask))
	int32 BasicBits;
Copy full snippet

/*~ BasicBits appears as a list of generic flags in the editor, instead of an integer field. */ UPROPERTY(EditAnywhere, Meta = (Bitmask)) int32 BasicBits;

Adding this meta tag will cause the integer to be editable as a drop-down list of generically-named flags ("Flag 1", "Flag 2", "Flag 3", etc.) that can be turned on or off individually.

You can also make integer parameters to Blueprint-callable functions behave as bitmasks, by adding the Bitmask meta tag (no value necessary) to a UPARAM Specifier for the parameter.

	/*~ You can set MyFunction using a generic list of flags instead of typing in an integer value. */
	UFUNCTION(BlueprintCallable)
	void MyFunction(UPARAM(meta=(Bitmask)) int32 BasicBitsParam)
Copy full snippet

/*~ You can set MyFunction using a generic list of flags instead of typing in an integer value. */ UFUNCTION(BlueprintCallable) void MyFunction(UPARAM(meta=(Bitmask)) int32 BasicBitsParam)

In order to customize the bitflags' names, we must first create a UENUM with the "bitflags" meta tag:

	UENUM(Meta = (Bitflags))
	enum class EColorBits
	{
		ECB_Red,
		ECB_Green,
		ECB_Blue
	};
Copy full snippet

UENUM(Meta = (Bitflags)) enum class EColorBits { ECB_Red, ECB_Green, ECB_Blue };

The supported value range for a bitmask enumerated type is 0 to 31, inclusive. This corresponds to the bits (starting at bit 0) of a 32-bit integer variable. In the example above, bit 0 is ECB_Red, bit 1 is ECB_Green, and bit 2 is ECB_Blue.

As an alternate declaration style, you can use the ENUM_CLASS_FLAGS to turn your enumerated type into a bitmask after defining it. In order to use the flag selector in the editor, we must also add the meta field UseEnumValuesAsMaskValuesInEditor and set it to true. The key difference is that this method uses the mask values directly, instead of the bit numbers. The equivalent enumerated type, made using this method, would look like this:

	UENUM(Meta = (Bitflags, UseEnumValuesAsMaskValuesInEditor = "true"))
	enum class EColorBits
	{
		ECB_Red = 0x01,
		ECB_Green = 0x02,
		ECB_Blue = 0x04
	};

	ENUM_CLASS_FLAGS(EColorBits);
Copy full snippet

UENUM(Meta = (Bitflags, UseEnumValuesAsMaskValuesInEditor = "true")) enum class EColorBits { ECB_Red = 0x01, ECB_Green = 0x02, ECB_Blue = 0x04 }; ENUM_CLASS_FLAGS(EColorBits);

After creating this UENUM, we can reference it with the "BitmaskEnum" meta tag, like this:

	/*~ This property lists flags matching the names of values from EColorBits. */
	UPROPERTY(EditAnywhere, Meta = (Bitmask, BitmaskEnum = "EColorBits"))
	int32 ColorFlags;
Copy full snippet

/*~ This property lists flags matching the names of values from EColorBits. */ UPROPERTY(EditAnywhere, Meta = (Bitmask, BitmaskEnum = "EColorBits")) int32 ColorFlags;

Following this change, the bitflags listed in the drop-down box will take on the names and values of the enumerated class entries. In the example above, ECB_Red is value 0, meaning it will activate bit 0 (adding 1 to ColorFlags) when checked. ECB_Green corresponds to bit 1 (adding 2 to ColorFlags), and ECB_Blue corresponds to bit 2 (adding 4 to ColorFlags).

Similarly, you can add BitmaskEnum and the appropriate enumerated type name to the meta section of your UPARAM tag to customize it.

	/*~ MyOtherFunction shows flags named after the values from EColorBits. */
	UFUNCTION(BlueprintCallable)
	void MyOtherFunction(UPARAM(meta=(Bitmask, BitmaskEnum = "EColorBits")) int32 ColorFlagsParam)
Copy full snippet

/*~ MyOtherFunction shows flags named after the values from EColorBits. */ UFUNCTION(BlueprintCallable) void MyOtherFunction(UPARAM(meta=(Bitmask, BitmaskEnum = "EColorBits")) int32 ColorFlagsParam)

While enumerated types can contain more than 32 entries, only the first 32 values will be visible in a bitmask association in the Property Editor UI. Similarly, while explicit-value entries are accepted, entries with explicit values not between 0 and 31 will not be included in the drop-down.

Floating Point Types

Unreal uses the standard C++ floating point types, float, and double.

Boolean Types

Boolean types can be represented either with the C++ bool keyword or as a bitfield.

	uint32 bIsHungry : 1;
	bool bIsThirsty;
Copy full snippet

uint32 bIsHungry : 1; bool bIsThirsty;

Strings

Unreal Engine 4 supports three core types of strings.

• FString is a classic "dynamic array of chars" string type.
• FName is a reference to an immutable case-insensitive string in a global string table. It is smaller and more efficient to pass around than an FString, but more difficult to manipulate.
• FText is a more robust string representation designed to handle localization.

For most uses, Unreal relies on the TCHAR type for characters. The TEXT() macro is available to denote TCHAR literals.

	MyDogPtr->DogName = FName(TEXT("Samson Aloysius"));
Copy full snippet

MyDogPtr->DogName = FName(TEXT("Samson Aloysius"));

For more on the three string types, when to use each one, and how to work with them, see the String Handling documentation.

Property Specifiers