RealDocs

50 results for "transform"

function
UKismetMathLibrary::TransformVector4 Engine

Multiplies a FVector4 by an FMatrix (Matrix * Vec4) and returns the resulting FVector4.

function
UGameplayStatics::TransformWorldToFirstPerson Engine

Transforms a world-space position into first-person view space, replicating the GPU-side morphing applied to first-person primitives.

function
AActor::AddActorLocalTransform Engine

Applies a delta transform (offset + rotation + scale) to this actor in its local reference frame.

function
AActor::AddActorWorldTransform Engine

Applies a delta transform to this actor in world space, combining the delta rotation and location with the current transform.

function
AActor::AddActorWorldTransformKeepScale Engine

Applies a delta transform to this actor in world space while preserving the actor's existing scale.

function
UKismetMathLibrary::Conv_MatrixToTransform Engine

Converts an FMatrix to an FTransform, decomposing it into translation, rotation, and scale.

function
UKismetMathLibrary::Conv_RotatorToTransform Engine

Creates a FTransform with the given rotation, zero translation, and unit scale.

function
UKismetMathLibrary::Conv_VectorToTransform Engine

Creates an FTransform with the given location, identity rotation, and uniform scale of 1.

function
AActor::GetActorTransform Engine

Returns the full world-space transform (location, rotation, scale) of the actor's root component as an FTransform.

function
ACharacter::GetGravityTransform Engine

Returns a quaternion that rotates from world space into gravity-relative space, allowing movement and orientation calculations to be performed relative to the current gravity direction.

function
APawn::GetGravityTransform Engine

Returns a quaternion that transforms from world space into gravity-relative space, where the negative Z axis aligns with the gravity direction.

function
AActor::GetLevelTransform Engine

Returns the transform of the ULevel this actor belongs to.

function
ACharacter::GetReplayLastTransformUpdateTimeStamp Engine

Returns the timestamp of the most recent transform update that was replicated to the replay recording connection.

function
ACharacter::GetReplicatedServerLastTransformUpdateTimeStamp Engine

Returns the server's last transform update timestamp as replicated to simulated proxies.

function
AActor::GetTransform Engine

Returns the actor-to-world transform of the RootComponent.

function
UActorComponent::IsRenderTransformDirty Engine

Returns whether this component's transform has been modified but not yet flushed to the render thread.

function
AActor::K2_AddActorLocalTransform Engine

Adds a delta transform to the actor in its local reference frame, affecting location, rotation, and scale together.

function
AActor::K2_AddActorWorldTransform Engine

Adds a delta transform to the actor in world space.

function
AActor::K2_AddActorWorldTransformKeepScale Engine

Adds a delta transform to the actor in world space while preserving the actor's current scale.

function
AActor::K2_SetActorRelativeTransform Engine

Sets the actor's full transform (location, rotation, and scale) relative to its parent in one call.

function
AActor::K2_SetActorTransform Engine

Sets the actor's world-space transform (location, rotation, and scale) in one call.

function
UActorComponent::MarkRenderTransformDirty Engine

Marks the component's transform as dirty so it will be sent to the render thread at the end of the current frame.

function
UKismetMathLibrary::Matrix_InverseTransformPosition Engine

Transforms a position vector by the inverse of the matrix, correctly handling scale.

function
UKismetMathLibrary::Matrix_InverseTransformVector Engine

Transforms a direction vector by the inverse of the matrix without applying translation.

function
UKismetMathLibrary::Matrix_TransformPosition Engine

Transforms a 3D position vector by the matrix, including the translation component.

function
UKismetMathLibrary::Matrix_TransformVector Engine

Transforms a direction vector by the matrix without applying the translation component.

function
UKismetMathLibrary::Matrix_TransformVector4 Engine

Transforms a homogeneous FVector4 by the full 4x4 matrix.

function
ACharacter::OnRep_ReplayLastTransformUpdateTimeStamp Engine

RepNotify called on replay connections when ReplayLastTransformUpdateTimeStamp is received.

function
AGameModeBase::RestartPlayerAtTransform Engine

Spawns or respawns a player's pawn at a specific world transform instead of at a player start actor.

function
AActor::SetActorRelativeTransform Engine

Sets the full transform (location, rotation, and scale) of this actor's root component relative to its parent in the attachment hierarchy.

function
UWidget::SetRenderTransform UMG

Applies a 2D render transform (translation, rotation, scale, shear) to the widget.

function
UWidget::SetRenderTransformAngle UMG

Sets only the rotation component of the widget's render transform in degrees, leaving translation, scale, and shear unchanged.

function
AGameModeBase::SpawnDefaultPawnAtTransform Engine

Spawns an instance of the default pawn class at the given transform and returns it.

function
AActor::UpdateComponentTransforms Engine

Propagates the actor's current world transform to all attached scene components, updating their cached transforms without re-registering them.

class
AActor Engine

The base class for all actors that can be placed or spawned in the world.

property
FGeometry::AbsolutePosition SlateCore deprecated

Position of the geometry in absolute space, equivalent to the translation of the accumulated layout transform.

function
FGeometry::AbsoluteToLocal SlateCore

Transforms a point from absolute space into this widget's local space by inverting the accumulated render transform.

function
USlateBlueprintLibrary::AbsoluteToLocal UMG

Transforms a point from absolute Slate space into a widget's local space.

function
AActor::ActorToWorld Engine

Returns the local-to-world transform of the actor's RootComponent.

function
UKismetMathLibrary::Add_MatrixMatrix Engine

Adds two 4x4 matrices element-wise (A + B).

function
AActor::AttachToActor Engine

Attaches this actor's RootComponent to the RootComponent of another actor.

function
AActor::AttachToComponent Engine

Attaches this actor's RootComponent to a specific SceneComponent, with full control over how the existing transform is preserved or reset.

function
UAnimInstance::BlueprintPostEvaluateAnimation Engine

Blueprint event called after the animation graph has been evaluated and final pose computed.

function
UKismetMathLibrary::Conv_MatrixToRotator Engine

Extracts the rotation component from an FMatrix as an FRotator (Pitch/Yaw/Roll in degrees).

function
AActor::DebugShowComponentHierarchy Engine

Prints the full scene component attachment hierarchy of this actor to the log, optionally showing each component's world-space position.

function
AActor::DetachFromActor Engine

Detaches this actor's RootComponent from its current parent, releasing the attachment.

function
USceneComponent::DetachFromComponent Engine

Detaches this component from its parent scene component, resolving the transform according to DetachmentRules.

struct
FGeometry SlateCore

Represents the position, size, and absolute position of a Slate widget in the widget hierarchy.

function
UKismetMathLibrary::FindRelativeLookAtRotation Engine

Returns the local-space rotator (clamped to [-180, 180] per axis) that an object with StartTransform needs to face TargetLocation.

function
FGeometry::GetAbsolutePositionAtCoordinates SlateCore

Returns the absolute position of a point on the widget surface identified by normalized (0–1) local coordinates, accounting for the full accumulated render transform.