Overview

Bitmask: A mechanism that employs binary representation to manage multiple state flags efficiently. A 32-bit bitmask can store 32 individual flags, enhancing readabiltiy and operational efficiency over the use of standalone boolean variables.

Features:

• Facilitates the management of multiple boolean states.
• Enumerations provide descriptive labels for each flag for improved code clarity.

Core Bit Operations:

The primary bitwise operations utilized in bitmask manipulations are:

• AND (&): Selects bits where both operands have bits set.
• NOT (~): Inverts bits.
• OR (|): Includes bits set in either operand.
• XOR (^): Toggles bits based on exclusive setting.
• Shifts (<<, >>): Alters bit possitioning.

Usage in Blueprints

Blueprint support for bitmasks is streamlined and applicable in editor scripting.

Steps to Create a Bitmask

1. Define an enumeration within the Blueprint Editor, enabling the Bitmask Flags property.
2. Add an integer variable to the blueprint, configure it with the Bitmask property, supporting up to 32 flags.
3. Perform operations such as implicit boolean conversions and bitwise processing:

Common operations:

• Checking if any flag is set.
• Applying NOT for bit negations.
• Combining flags with OR.
• Intersecting flags with AND.

C++ Bitmask Implementation

Unreal Engine's C++ affords higher flexibility:

int32 MyBitmask = 3; // Initialize bitmask
int32 MyFlag = 1;   // Define a flag
MyBitmask |= MyFlag; // Set the flag
MyBitmask &= ~MyFlag; // Clear the flag
if (MyBitmask & MyFlag) { /* Execute conditional logic */ }

Technique 1: Shift Operations for Flag Correspondence

Use left shifts to map enumeration values to bitmask flags efficiently:

UENUM(meta = (Bitflags))
enum class EMyTypeEnum : uint32 {
    Type1 = (1 << 0),
    Type2 = (1 << 1),
    Type3 = (1 << 2),
    Type4 = (1 << 3),
    Type5 = (1 << 4),
    Type6 = (1 << 5)
};

UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (Bitmask, BitmaskEnum = "EMyTypeEnum"))
int32 MyTypeBitmask;

if (MyTypeBitmask & static_cast<uint32>(EMyTypeEnum::Type2)) {
    // Handle flag-related logic.
}

Technique 2: Macro-Assisted Flag Assignment

Simplify bit flag asssignments using macros:

#define TOFLAG(Enum) (1 << static_cast<uint8>(Enum))

UENUM(BlueprintType, meta = (Bitflags))
enum class EMyTypeEnum : uint8 {
    Type1, // Corresponds to 0
    Type2, // Corresponds to 1
    Type3, // Corresponds to 2
    Type4, // Corresponds to 3
    Type5, // Corresponds to 4
    Type6  // Corresponds to 5
};

UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (Bitmask, BitmaskEnum = "EMyTypeEnum"))
int32 MyTypeBitmask;

if (MyTypeBitmask & TOFLAG(EMyTypeEnum::Type2)) {
    // Conditional execution.
}