RealDocs

30 results for "template"

function
AActor::CreateComponentFromTemplate Engine

Instantiates a new component by duplicating a template object, used during Blueprint construction script execution to stamp out component instances.

function
AActor::CreateComponentFromTemplateData Engine

Creates a component instance from pre-cooked serialized data, allowing Blueprint component construction to bypass the more expensive template duplication path used in the editor.

function
AActor::FindComponentByInterface (IInterface template overload) Engine

The `TIsIInterface`-constrained template overload of `FindComponentByInterface`, introduced in UE 5.

function
FMath::Abs Core

Returns the absolute (non-negative) value of A.

function
AActor::AddComponent Engine

Blueprint-internal function that instantiates a component from a named template and optionally attaches it.

function
AActor::AddComponentByClass Engine

Blueprint-internal function that creates a component from a class reference rather than a named template, powering the 'Add Component by Class' Blueprint node.

property
TArray::AllocatorInstance Core

The allocator object responsible for managing the raw memory backing the array.

function
UAnimInstance::CanTransitionSignature Engine

Delegate signature function used as the prototype for custom transition rule functions in state machines.

function
AActor::FindComponentByClass Engine

Searches the actor's owned components and returns the first one that is an instance of the given class.

function
AActor::FindComponentByInterface Engine

Searches the actor's owned components and returns the first one that implements the specified UInterface.

function
TArray::FindItemByClass Core

Searches a TArray of UObject pointers for the first element whose runtime class matches (via IsA) the template parameter SearchType.

function
AActor::GetActorClassDefaultComponent Engine

Returns the first CDO component of a given type from the actor class, including Blueprint-added components.

function
UWorld::GetAuthGameMode Engine

Returns the current AGameModeBase instance cast to the template type.

function
AActor::GetComponentByClass Engine

Returns the first component of the given class attached to this actor, or null if none is found.

function
AActor::GetComponentsByClass Engine

Returns all components of the given class attached to this actor.

function
APawn::GetController Engine

Returns the controller currently possessing this pawn, or null if unpossessed.

function
UWorld::GetGameState Engine

Returns the current GameState instance cast to the template type.

function
APlayerController::GetPawn Engine

Returns the pawn currently possessed by this controller, or `nullptr` if no pawn is possessed.

function
AActor::K2_GetComponentsByClass Engine

Returns all components on this actor that are of or derive from ComponentClass.

function
TSoftClassPtr::LoadSynchronous CoreUObject

Synchronously loads the class referenced by this soft pointer if it is not already in memory, then returns it.

function
FMath: MIX_FLOATS_2_ARGS Core

Preprocessor macro that injects a two-argument template overload for mixing float/double/integral argument types, promoting all arguments to the highest-precision floating-point type.

function
FMath: MIX_FLOATS_3_ARGS Core

Preprocessor macro that injects a template overload for a three-argument function, allowing mixed float/double/integral argument lists by promoting all arguments to the highest-precision floating-point type among them.

function
UActorComponent::SetupActorComponentTickFunction Engine

Configures a tick function with standard component tick rules: tick after the actor, skip static or template actors, and respect the owner's pause-tick setting.

function
TArray::SwapMemory Core

Swaps two elements by directly exchanging their raw memory bytes via the global Swap template.

function
FMath: UE_REQUIRES Core

Preprocessor macro that wraps a C++20 requires-clause (or a SFINAE equivalent on older standards) to constrain template overloads inside FMath and other UE template-heavy code.

function
TArray — UE_REQUIRES constraint Core

Template constraint applied to TArray cross-type constructors and assignment operators.

function
TSharedPtr::UE_REQUIRES Core

Template constraint applied to TSharedPtr's converting constructors and assignment operators.

function
TSharedRef::UE_REQUIRES Core

Template constraint on TSharedRef's converting constructors that ensures only type-compatible (upcast-safe) pointer types can implicitly construct a TSharedRef<ObjectType>.

function
TSoftClassPtr::UE_REQUIRES CoreUObject

Template constraint on TSoftClassPtr's converting constructor and assignment operators.

class
USubsystem Engine

Base class for all UE subsystems — auto-instanced singletons that share the lifetime of a specific engine construct (Engine, GameInstance, World, or LocalPlayer).