UnrealSpecifiers

The Blueprintable specifier allows a class to be used as a base class for creating new Blueprints.

Key Behaviors:

• Only classes marked as Blueprintable can be chosen as base classes in the Blueprint editor.
• Inheritance Rule: If a class is NotBlueprintable, it cannot be inherited within Blueprints, and its inherent effects cannot be treated as variables. However, a subclass can become Blueprintable even if its parent was not, provided the metadata is explicitly set.
• Variable Usage: Whether a class can be used as a variable type depends on the BlueprintType tag of the parent class hierarchy.

/* Example: A class that can be used as a base for Blueprints */
UCLASS(Blueprintable)
class INSIDER_API UMyClass_Blueprintable : public UObject
{
	GENERATED_BODY()
};

/* Example: A class that cannot be used as a base for Blueprints */
UCLASS(NotBlueprintable)
class INSIDER_API UMyClass_NotBlueprintable : public UObject
{
	GENERATED_BODY()
};

ModuleRelativePath is a metadata specifier managed by the Unreal Header Tool (UHT) that records the relative path of a header file within a module.

Key Characteristics

• Purpose: It allows the engine editor to locate the exact .h file where a type is defined. This enables features like double-clicking a type in the editor to open its source code in Visual Studio.
• Scope: Unlike IncludePath (which is only present on UCLASS), ModuleRelativePath is present on various type information, including classes, properties, and functions.
• Path Structure: The value can include directory prefixes such as Classes/, Public/, Internal/, or Private/.

Comparison with IncludePath

Best Practices

It is recommended to organize your .h and .cpp files into the following four directories to align with standard engine patterns:

• Classes/
• Public/
• Internal/
• Private/

In Unreal Engine's Python scripting, ScriptDefaultMake and ScriptDefaultBreak are metadata tags used with USTRUCT to control how structures are initialized and converted to tuples.

• ScriptDefaultMake: When this tag is present, the Python initialization (__init__) will call the default script-side make function instead of the C++ function specified by HasNativeMake.
• ScriptDefaultBreak: When this tag is present, calling .to_tuple() on the Python object will use the default script-side break logic (converting each attribute to a tuple) instead of the C++ function specified by HasNativeBreak.

If these tags are not present, the engine falls back to the native C++ functions defined via HasNativeMake and HasNativeBreak metadata.

// Example of how the logic behaves in C++
// If ScriptDefaultMake is found, the function specified by HasNativeMake is ignored.
if (!InStruct->HasMetaData(InScriptDefaultMetaDataKey))
{
    const FString MakeBreakFunctionName = InStruct->GetMetaData(InNativeMetaDataKey);
    // ... logic to find and use the native function ...
}

By default, an async node created from a UBlueprintAsyncActionBase subclass does not expose the task object. However, if you create a helper class like UCancellableAsyncAction that provides a Cancel() method and use ExposedAsyncProxy in your implementation, the resulting Blueprint node will feature an extra output pin. This pin provides a reference to the async action instance, enabling the user to call Cancel() on it later in the Blueprint graph.

// Base class providing cancellation logic
UCLASS(Abstract, BlueprintType, meta = (ExposedAsyncProxy = AsyncAction), MinimalAPI)
class UCancellableAsyncAction : public UBlueprintAsyncActionBase
{
    UFUNCTION(BlueprintCallable, Category = "Async Action")
    ENGINE_API virtual void Cancel();
};

// Implementation using the proxy
UCLASS(Blueprintable, BlueprintType, meta = (ExposedAsyncProxy = MyAsyncObject))
class INSIDER_API UMyFunction_Async : public UCancellableAsyncAction
{
    GENERATED_BODY()
};

Asset management in UE5 distinguishes between three types of assets:

1. PrimaryAsset: Root assets (like levels or character data) that can be manually loaded/released. They often act as the entry point for a tree of references.
2. SecondaryAsset: Assets like textures, sounds, or materials that are typically referenced by PrimaryAssets. They are usually loaded automatically when the PrimaryAsset is loaded.
3. AssetBundle: A logical grouping of assets. Instead of loading all secondary assets referenced by a PrimaryAsset, you can group them into bundles (e.g., "UI" vs "Game") and use UAssetManager to load only the specific bundle required for the current context.

Workflow:

1. Define AssetBundles metadata on soft properties in a UPrimaryDataAsset.
2. UAssetManager analyzes this metadata during PreSave or PostLoad and stores it in AssetBundleData.
3. At runtime, use UAssetManager::ChangeBundleStateForPrimaryAssets (or similar loading logic) to specify which LoadBundles to include.