 |
UDocumentation UE5.7 10.02.2026 (Source)
API documentation for Unreal Engine 5.7
|
|
UDocumentation UE5.7 10.02.2026 (Source)
API documentation for Unreal Engine 5.7
|
#include <Actor.h>
Inheritance diagram for AActor:Classes | |
| struct | FFillReplicationParamsContext |
| struct | FOnReplicationStartedParams |
| struct | FOnStopReplicationParams |
Static Public Attributes | |
| static ENGINE_API FOnProcessEvent | ProcessEventDelegate |
Additional Inherited Members | |
| Public Types inherited from UObject | |
| enum class | ENetFields_Private { NETFIELD_REP_START = 0 , NETFIELD_REP_END = -1 } |
| typedef UObject | WithinClass |
Actor is the base class for an Object that can be placed or spawned in a level. Actors may contain a collection of ActorComponents, which can be used to control how actors move, how they are rendered, etc. The other main function of an Actor is the replication of properties and function calls across the network during play.
Actor initialization has multiple steps, here's the order of important virtual functions that get called:
| AActor::AActor | ( | ) |
Default constructor for AActor
| AActor::AActor | ( | const FObjectInitializer & | ObjectInitializer | ) |
Constructor for AActor that takes an ObjectInitializer for backward compatibility
| float AActor::ActorGetDistanceToCollision | ( | const FVector & | Point, |
| ECollisionChannel | TraceChannel, | ||
| FVector & | ClosestPointOnCollision, | ||
| UPrimitiveComponent ** | OutPrimitiveComponent = nullptr |
||
| ) | const |
returns Distance to closest Body Instance surface. Checks against all components of this Actor having valid collision and blocking TraceChannel.
| Point | World 3D vector |
| TraceChannel | The 'channel' used to determine which components to consider. |
| ClosestPointOnCollision | Point on the surface of collision closest to Point |
| OutPrimitiveComponent | PrimitiveComponent ClosestPointOnCollision is on. |
See if this actor's Tags array contains the supplied name tag
| bool AActor::ActorLineTraceSingle | ( | struct FHitResult & | OutHit, |
| const FVector & | Start, | ||
| const FVector & | End, | ||
| ECollisionChannel | TraceChannel, | ||
| const struct FCollisionQueryParams & | Params | ||
| ) | const |
Trace a ray against the Components of this Actor and return the first blocking hit
| OutHit | First blocking hit found |
| Start | Start location of the ray |
| End | End location of the ray |
| TraceChannel | The 'channel' that this ray is in, used to determine which components to hit |
| Params | Additional parameters used for the trace |
|
inline |
Get the local-to-world transform of the RootComponent. Identical to GetTransform().
| void AActor::AddActorComponentReplicatedSubObject | ( | UActorComponent * | OwnerComponent, |
| UObject * | SubObject, | ||
| ELifetimeCondition | NetCondition = COND_None |
||
| ) |
Register a SubObject that will get replicated along with the actor component owning it. The subobject needs to be manually removed from the list before it gets deleted.
| SubObject | The SubObject to replicate |
| NetCondition | Optional condition to select which type of connection we will replicate the object to. |
| void AActor::AddActorLocalOffset | ( | FVector | DeltaLocation, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| void AActor::AddActorLocalRotation | ( | const FQuat & | DeltaRotation, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| void AActor::AddActorLocalRotation | ( | FRotator | DeltaRotation, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| void AActor::AddActorLocalTransform | ( | const FTransform & | NewTransform, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| void AActor::AddActorWorldOffset | ( | FVector | DeltaLocation, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| void AActor::AddActorWorldRotation | ( | const FQuat & | DeltaRotation, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| void AActor::AddActorWorldRotation | ( | FRotator | DeltaRotation, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| void AActor::AddActorWorldTransform | ( | const FTransform & | DeltaTransform, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| void AActor::AddActorWorldTransformKeepScale | ( | const FTransform & | DeltaTransform, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| UActorComponent * AActor::AddComponent | ( | FName | TemplateName, |
| bool | bManualAttachment, | ||
| const FTransform & | RelativeTransform, | ||
| const UObject * | ComponentTemplateContext, | ||
| bool | bDeferredFinish = false |
||
| ) |
Creates a new component and assigns ownership to the Actor this is called for. Automatic attachment causes the first component created to become the root, and all subsequent components to be attached under that root. When bManualAttachment is set, automatic attachment is skipped and it is up to the user to attach the resulting component (or set it up as the root) themselves.
| TemplateName | The name of the Component Template to use. |
| bManualAttachment | Whether manual or automatic attachment is to be used |
| RelativeTransform | The relative transform between the new component and its attach parent (automatic only) |
| ComponentTemplateContext | Optional UBlueprintGeneratedClass reference to use to find the template in. If null (or not a BPGC), component is sought in this Actor's class |
| bDeferredFinish | Whether or not to immediately complete the creation and registration process for this component. Will be false if there are expose on spawn properties being set |
| UActorComponent * AActor::AddComponentByClass | ( | UPARAM(meta=(AllowAbstract="false")) TSubclassOf< UActorComponent > | Class, |
| bool | bManualAttachment, | ||
| const FTransform & | RelativeTransform, | ||
| bool | bDeferredFinish | ||
| ) |
Creates a new component and assigns ownership to the Actor this is called for. Automatic attachment causes the first component created to become the root, and all subsequent components to be attached under that root. When bManualAttachment is set, automatic attachment is skipped and it is up to the user to attach the resulting component (or set it up as the root) themselves.
| Class | The class of component to create |
| bManualAttachment | Whether manual or automatic attachment is to be used |
| RelativeTransform | The relative transform between the new component and its attach parent (automatic only) |
| bDeferredFinish | Whether or not to immediately complete the creation and registration process for this component. Will be false if there are expose on spawn properties being set |
| void AActor::AddInstanceComponent | ( | UActorComponent * | Component | ) |
Adds a component to the instance components array
| void AActor::AddOwnedComponent | ( | UActorComponent * | Component | ) |
Puts a component in to the OwnedComponents array of the Actor. The Component must be owned by the Actor or else it will assert In general this should not need to be called directly by anything other than UActorComponent functions
|
static |
| void AActor::AddReplicatedSubObject | ( | UObject * | SubObject, |
| ELifetimeCondition | NetCondition = COND_None |
||
| ) |
Register a SubObject that will get replicated along with the actor. The subobject needs to be manually removed from the list before it gets deleted.
| SubObject | The SubObject to replicate |
| NetCondition | Optional condition to select which type of connection we will replicate the object to. |
Make this actor tick after PrerequisiteActor. This only applies to this actor's tick function; dependencies for owned components must be set up separately if desired.
|
virtual |
Make this actor tick after PrerequisiteComponent. This only applies to this actor's tick function; dependencies for owned components must be set up separately if desired.
|
virtual |
Allows classes to control if a replicated component can actually be replicated or not in a specific actor class. You can also choose a netcondition to filter to whom the component is replicated to. Called on existing replicated component right before BeginPlay() and after that on every new replicated component added to the OwnedComponent list
| ComponentToReplicate | The replicated component added to the actor. |
|
inline |
Return the value of bAllowReceiveTickEventOnDedicatedServer, indicating whether the Blueprint ReceiveTick() event will occur on dedicated servers.
Called by owning level to shift an actor location and all relevant data structures by specified delta
| InOffset | Offset vector to shift actor location |
| bWorldShift | Whether this call is part of whole world shifting |
Reimplemented in APlayerCameraManager, and ANavigationData.
Override this function to implement custom logic to be executed every physics step. bAsyncPhysicsTick must be set to true.
| DeltaTime | - The physics step delta time |
| SimTime | - This is the total sim time since the sim began. |
| bool AActor::AttachToActor | ( | AActor * | ParentActor, |
| const FAttachmentTransformRules & | AttachmentRules, | ||
| FName | SocketName = NAME_None |
||
| ) |
Attaches the RootComponent of this Actor to the RootComponent of the supplied actor, optionally at a named socket.
| ParentActor | Actor to attach this actor's RootComponent to |
| AttachmentRules | How to handle transforms and modification when attaching. |
| SocketName | Socket name to attach to, if any |
| bool AActor::AttachToComponent | ( | USceneComponent * | Parent, |
| const FAttachmentTransformRules & | AttachmentRules, | ||
| FName | SocketName = NAME_None |
||
| ) |
Attaches the RootComponent of this Actor to the supplied component, optionally at a named socket. It is not valid to call this on components that are not Registered.
| Parent | Parent to attach to. |
| AttachmentRules | How to handle transforms and welding when attaching. |
| SocketName | Optional socket to attach to on the parent. |
|
virtual |
Called when this actor becomes the given PlayerController's ViewTarget. Triggers the Blueprint event K2_OnBecomeViewTarget.
|
overridevirtual |
Called before destroying the object. This is called immediately upon deciding to destroy the object, to allow the object to begin an asynchronous cleanup process.
Reimplemented from UObject.
Reimplemented in AMapBuildDataActor, AConstraintsActor, and AGameplayDebuggerPlayerManager.
|
protectedvirtual |
Overridable native event for when play begins for this actor.
Reimplemented in APlayerController, AWorldPartitionCustomHLOD, AWorldPartitionHLOD, ANavigationDataChunkActor, AConstraintsActor, AChaosSolverActor, AGeometryCollectionRenderLevelSetActor, AGameplayDebuggerCategoryReplicator, AGameplayDebuggerPlayerManager, ALevelSequenceActor, and ANavSystemConfigOverride.
|
protectedvirtual |
Called for all Actors set to replicate during BeginPlay, It will also be called if SetReplicates(true) is called and the object is not already replicating
|
protected |
Helper to BeginReplication passing on additional parameters to the ReplicationSystem, typically called from code overriding normal BeginReplication()
| Params | Additional parameters we want to pass on |
|
virtual |
Calculate camera view point, when viewing this actor.
| DeltaTime | Delta time seconds since last update |
| OutResult | Camera configuration |
Reimplemented in ASceneCapture2D, and APlayerController.
|
virtual |
Calculates the actor space bounding box of all components in this Actor. This is slower than GetComponentsBoundingBox(), because the local bounds of the components are not cached – they are recalculated every time this function is called.
| bNonColliding | Indicates that you want to include non-colliding components in the bounding box |
| bIncludeFromChildActors | If true then recurse in to ChildActor components and find components of the appropriate type in those Actors as well |
| void AActor::CallPreReplication | ( | UNetDriver * | NetDriver | ) |
Called by the networking system to call PreReplication on this actor and its components using the given NetDriver to find or create RepChangedPropertyTrackers.
|
overridevirtual |
Call the actor's function remotely
| Function | function to call |
| Parms | arguments to the function call |
| OutParms | out parameter information (irrelevant for RPC's) |
| Stack | stack frame for the function call |
Reimplemented from UObject.
|
virtual |
Return true if the given Pawn can be "based" on this actor (ie walk on it).
| Pawn | - The pawn that wants to be based on this actor |
|
inline |
Gets the literal value of bCanBeDamaged.
This exists so subclasses don't need to have direct access to the bCanBeDamaged property so it can be made private later.
|
overridevirtual |
Called during cluster construction if the object can be added to a cluster
Reimplemented from UObjectBaseUtility.
|
inline |
Accessor for the value of bCanEverTick
| bool AActor::CanTriggerResimulation | ( | ) | const |
Can this body trigger a resimulation when Physics Prediction is enabled
|
protected |
Checks components for validity, implemented in AActor
Checks for and resolve any name conflicts prior to instancing a new Blueprint Component.
|
overridevirtual |
Checks default sub-object assumptions.
Reimplemented from UObject.
|
virtual |
This will check to see if the Actor is still in the world. It will check things like the KillZ, outside world bounds, etc. and handle the situation.
| void AActor::ClearComponentOverlaps | ( | ) |
Dispatch all EndOverlap for all of the Actor's PrimitiveComponents. Generally used when removing the Actor from the world.
|
virtual |
Do anything needed to clear out cross level references; Called from ULevel::PreSave
Clears the instance components array
| bool AActor::ContainsDataLayer | ( | const UDataLayerAsset * | DataLayerAsset | ) | const |
Copies RemoteRole from another Actor and adds this actor to the list of network actors if necessary.
| UActorComponent * AActor::CreateComponentFromTemplate | ( | UActorComponent * | Template, |
| const FName | InName = NAME_None |
||
| ) |
Util to create a component based on a template
| UActorComponent * AActor::CreateComponentFromTemplateData | ( | const struct FBlueprintCookedComponentInstancingData * | TemplateData, |
| const FName | InName = NAME_None |
||
| ) |
|
virtual |
Creates an input component from the input component passed in
| InputComponentToCreate | The UInputComponent to create. |
| ENGINE_API void AActor::DebugShowComponentHierarchy | ( | const TCHAR * | Info, |
| bool | bShowPosition = true |
||
| ) |
Debug helper to show the component hierarchy of this actor.
| Info | Optional String to display at top of info |
| bShowPosition | If true, will display component's position in world space |
| ENGINE_API void AActor::DebugShowOneComponentHierarchy | ( | USceneComponent * | SceneComp, |
| int32 & | NestLevel, | ||
| bool | bShowPosition | ||
| ) |
Debug helper for showing the component hierarchy of one component
Destroy this actor. Returns true if the actor is destroyed or already marked for destruction, false if indestructible. Destruction is latent. It occurs at the end of the tick.
| bNetForce | [opt] Ignored unless called during play. Default is false. |
| bShouldModifyLevel | [opt] If true, Modify() the level before removing the actor. Default is true. |
| void AActor::DestroyConstructedComponents | ( | ) |
Destroys the constructed components.
|
virtual |
Called when this actor is explicitly being destroyed during gameplay or in the editor, not called during level streaming or gameplay ending
Reimplemented in APlayerCameraManager, AController, APlayerController, AConstraintsActor, and ANavigationData.
|
virtual |
Called by DestroyActor(), gives actors a chance to op out of actor destruction Used by network code to have the net connection timeout/cleanup first
Reimplemented in APlayerController.
| void AActor::DestroyReplicatedSubObjectOnRemotePeers | ( | UActorComponent * | OwnerComponent, |
| UObject * | SubObject | ||
| ) |
Similar to the other destroy function but for subobjects owned by an ActorComponent
Stop replicating a subobject and tell actor channels to delete the replica of this subobject next time the Actor gets replicated. Note it is up to the caller to delete the local object on the authority. If you are using the legacy subobject replication method (ReplicateSubObjects() aka bReplicateUsingRegisteredSubObjectList=false) make sure the subobject doesn't get replicated there either.
| SubObject | THe SubObject to delete |
| void AActor::DetachAllSceneComponents | ( | class USceneComponent * | InParentComponent, |
| const FDetachmentTransformRules & | DetachmentRules | ||
| ) |
Detaches all SceneComponents in this Actor from the supplied parent SceneComponent.
| InParentComponent | SceneComponent to detach this actor's components from |
| DetachmentRules | Rules to apply when detaching components |
| void AActor::DetachFromActor | ( | const FDetachmentTransformRules & | DetachmentRules | ) |
Detaches the RootComponent of this Actor from any SceneComponent it is currently attached to.
| DetachmentRules | How to handle transforms when detaching. |
| void AActor::DisableComponentsSimulatePhysics | ( | ) |
Stop all simulation from all components in this actor
|
virtual |
Removes this actor from the stack of input being handled by a PlayerController.
| PlayerController | The PlayerController whose input events we no longer want to receive. If null, this actor will stop receiving input from all PlayerControllers. |
Reimplemented in APlayerController.
Initiate a begin play call on this Actor, will handle calling in the correct order.
| void AActor::DispatchBlockingHit | ( | UPrimitiveComponent * | MyComp, |
| UPrimitiveComponent * | OtherComp, | ||
| bool | bSelfMoved, | ||
| FHitResult const & | Hit | ||
| ) |
Call ReceiveHit, as well as delegates on Actor and Component
|
virtual |
Dispatches ReceiveHit virtual and OnComponentHit delegate
|
virtual |
Draw important Actor variables on canvas. HUD will call DisplayDebug() on the current ViewTarget when the ShowDebug exec is used
| Canvas | Canvas to draw on |
| DebugDisplay | Contains information about what debug data to display |
| YL | [in] Height of the previously drawn line. [out] Height of the last line drawn by this function. |
| YPos | [in] Y position on Canvas for the previously drawn line. YPos += YL, gives position to draw text for next debug line. [out] Y position on Canvas for the last line drawn by this function. |
| void AActor::DrawDebugComponents | ( | FColor const & | BaseColor = FColor::White | ) | const |
Debug rendering to visualize the component tree for this actor.
|
virtual |
Pushes this actor on to the stack of input being handled by a PlayerController.
| PlayerController | The PlayerController whose input events we want to receive. |
Reimplemented in APlayerController.
|
protectedvirtual |
Overridable function called whenever this actor is being removed from a level
Reimplemented in APlayerCameraManager, APlayerController, AEmitterCameraLensEffectBase, AWorldPartitionCustomHLOD, AWorldPartitionHLOD, ANavigationDataChunkActor, AGameplayDebuggerCategoryReplicator, ALevelSequenceActor, ANavigationData, AGameplayDebuggerPlayerManager, and AChaosSolverActor.
|
protectedvirtual |
Called when we want to end replication for this actor, typically called from EndPlay() for actors that should be replicated during their lifespan
|
virtual |
Called when this actor is no longer the given PlayerController's ViewTarget. Also triggers the Blueprint event K2_OnEndViewTarget.
| bool AActor::ExecuteConstruction | ( | const FTransform & | Transform, |
| const struct FRotationConversionCache * | TransformRotationCache, | ||
| const class FComponentInstanceDataCache * | InstanceDataCache, | ||
| bool | bIsDefaultTransform = false, |
||
| ESpawnActorScaleMethod | TransformScaleMethod = ESpawnActorScaleMethod::OverrideRootScale |
||
| ) |
Run any construction script for this Actor. Will call OnConstruction.
| Transform | The transform to construct the actor at. |
| TransformRotationCache | Optional rotation cache to use when applying the transform. |
| InstanceDataCache | Optional cache of state to apply to newly created components (e.g. precomputed lighting) |
| bIsDefaultTransform | Whether or not the given transform is a "default" transform, in which case it can be overridden by template defaults |
|
virtual |
Called when the actor falls out of the world 'safely' (below KillZ and such)
Reimplemented in APlayerController.
|
virtual |
Called if using iris replication right before an actor start replicating, override to provide custom actor replication parameters
|
inline |
Templatized version of FindComponentByClass that handles casting for you
|
virtual |
Searches components array and returns first encountered component of the specified class, native version of GetComponentByClass
|
inline |
Templatized version of FindComponentByInterface that handles casting for you
|
inline |
Templatized version of FindComponentByInterface that handles casting for you
|
virtual |
Searches components array and returns first encountered component that implements the given interface.
|
inline |
Templatized version of FindComponentByTag that handles casting for you
| void AActor::FinishAddComponent | ( | UActorComponent * | Component, |
| bool | bManualAttachment, | ||
| const FTransform & | RelativeTransform | ||
| ) |
Completes the creation of a new actor component. Called either from blueprint after expose on spawn properties are set, or directly from AddComponent
| Component | The component created in AddComponent to finish creation of |
| bManualAttachment | Whether manual or automatic attachment is to be used |
| RelativeTransform | The relative transform between the new component and its attach parent (automatic only) |
| void AActor::FinishAndRegisterComponent | ( | UActorComponent * | Component | ) |
Helper function to register the specified component, and add it to the serialized components array
| Component | Component to be finalized |
| void AActor::FinishSpawning | ( | const FTransform & | Transform, |
| bool | bIsDefaultTransform = false, |
||
| const FComponentInstanceDataCache * | InstanceDataCache = nullptr, |
||
| ESpawnActorScaleMethod | TransformScaleMethod = ESpawnActorScaleMethod::OverrideRootScale |
||
| ) |
Called to finish the spawning process, generally in the case of deferred spawning
| void AActor::FlushNetDormancy | ( | ) |
Forces dormant actor to replicate but doesn't change NetDormancy state (i.e., they will go dormant again if left dormant)
Removes the actor from the NetDriver's dormancy list: forcing at least one more update.
|
virtual |
Forces this actor to be net relevant if it is not already by default
|
virtual |
Force actor to be updated to clients/demo net drivers
| void AActor::ForcePropertyCompare | ( | ) |
Forces properties on this actor to do a compare for one frame (rather than share shadow state)
| void AActor::ForEachAttachedActors | ( | TFunctionRef< bool(class AActor *)> | Functor | ) | const |
Call a functor for Actors which are attached directly to a component in this actor. Functor should return true to carry on, false to abort.
|
inline |
Calls the compile-time lambda on each component of the specified type
| ComponentType | The component class to find all components of a class derived from |
| bIncludeFromChildActors | If true then recurse in to ChildActor components and find components of the appropriate type in those Actors as well |
|
inline |
Calls the compile-time lambda on each valid component
| bIncludeFromChildActors | If true then recurse in to ChildActor components and find components of the appropriate type in those Actors as well |
|
static |
Iterate over the components of ActorClass's CDO, including the ones added via the BP editor (which AActor.GetComponents fails to return).
| InActorClass | Class of AActor for which we will retrieve all components. |
| InComponentClass | Only consider components of this type. |
| InFunc | Code that will be executed for each component. Must return true to continue iteration, or false to stop. |
|
inlinestatic |
Templated version of ForEachComponentOfActorClassDefault()
|
virtual |
Fills ReplicatedMovement property
|
virtual |
Returns the bounding box of all components that make up this Actor (excluding ChildActorComponents).
| bOnlyCollidingComponents | If true, will only return the bounding box for components with collision enabled. |
| Origin | Set to the center of the actor in world space |
| BoxExtent | Set to half the actor's size in 3d space |
| bIncludeFromChildActors | If true then recurse in to ChildActor components |
Reimplemented in ANavigationDataChunkActor, and AMapBuildDataActor.
|
inlinestatic |
Templated version of GetActorClassDefaultComponent()
|
static |
Fetches the first component of ActorClass's CDO which match the requested component class. Will include the components added via the BP editor (which AActor.GetComponents fails to do for CDOs).
| InActorClass | Class of AActor for which we will retrieve all components. |
| InComponentClass | Only retrieve components of this type. |
| OutComponents | this is where the found components will end up. Note that the preexisting contents of OutComponents will get overridden. |
|
static |
Get the component of ActorClass's CDO that matches the given object name. Will consider all components, including the ones added via the BP editor (which AActor.GetComponents fails to do for CDOs).
| InActorClass | Class of AActor for which we will search all components. |
| InComponentClass | Only consider components of this type. |
| OutComponents | this is where the found components will end up. Note that the preexisting contents of OutComponents will get overridden. |
|
inlinestatic |
Templated version of GetActorClassDefaultComponentByName()
|
static |
Fetches all the components of ActorClass's CDO, including the ones added via the BP editor (which AActor.GetComponents fails to do for CDOs).
| InActorClass | Class of AActor for which we will retrieve all components. |
| InComponentClass | Only retrieve components of this type. |
| OutComponents | this is where the found components will end up. Note that the preexisting contents of OutComponents will get overridden. |
|
inlinestatic |
Templated version of GetActorClassDefaultComponents()
|
inline |
Get current state of collision for the whole actor
Returns the point of view of the actor. Note that this doesn't mean the camera, but the 'eyes' of the actor. For example, for a Pawn, this would define the eye height location, and view rotation (which is different from the pawn rotation which has a zeroed pitch component). A camera first person view will typically use this view point. Most traces (weapon, AI) will be done from this view point.
| OutLocation | - location of view point |
| OutRotation | - view rotation of actor. |
Reimplemented in APlayerController, and AController.
|
inline |
Get the forward (X) vector (length 1.0) from this Actor, in world space.
|
inline |
|
inline |
Returns the location of the RootComponent of this Actor
|
inline |
|
inline |
Returns the quaternion of the RootComponent of this Actor
| FVector AActor::GetActorRelativeScale3D | ( | ) | const |
Return the actor's relative scale 3d
|
inline |
Get the right (Y) vector (length 1.0) from this Actor, in world space.
|
inline |
Returns the rotation of the RootComponent of this Actor
|
inline |
Returns the scale of the RootComponent of this Actor
| FVector AActor::GetActorScale3D | ( | ) | const |
Returns the Actor's world-space scale.
| float AActor::GetActorTickInterval | ( | ) | const |
Returns the tick interval of this actor's primary tick function
| float AActor::GetActorTimeDilation | ( | ) | const |
Get ActorTimeDilation - this can be used for input control or speed control for slomo. We don't want to scale input globally because input can be used for UI, which do not care for TimeDilation.
More efficient version that takes the Actor's current world.
|
inline |
Returns the transform of the RootComponent of this Actor
|
inline |
Get the up (Z) vector (length 1.0) from this Actor, in world space.
| void AActor::GetAllChildActors | ( | TArray< AActor * > & | ChildActors, |
| bool | bIncludeDescendants = true |
||
| ) | const |
Returns a list of all actors spawned by our Child Actor Components, including children of children. This does not return the contents of the Children array
| void AActor::GetAttachedActors | ( | TArray< AActor * > & | OutActors, |
| bool | bResetArray = true, |
||
| bool | bRecursivelyIncludeAttachedActors = false |
||
| ) | const |
Find all Actors which are attached directly to a component in this actor
|
inline |
Get read-only access to current AttachmentReplication.
| AActor * AActor::GetAttachParentActor | ( | ) | const |
Walk up the attachment chain from RootComponent until we encounter a different actor, and return it. If we are not attached to a component in a different actor, returns nullptr
| FName AActor::GetAttachParentSocketName | ( | ) | const |
Walk up the attachment chain from RootComponent until we encounter a different actor, and return the socket name in the component. If we are not attached to a component in a different actor, returns NAME_None
|
inline |
Gets the property name for bCanBeDamaged. This exists so subclasses don't need to have direct access to the bCanBeDamaged property so it can be made private later.
|
inline |
Templated version of GetComponentByClass
|
inline |
Get a direct reference to the Components set rather than a copy with the null pointers removed. WARNING: anything that could cause the component to change ownership or be destroyed will invalidate this array, so use caution when iterating this set!
|
inline |
Get all components derived from class 'ComponentType' and fill in the OutComponents array with the result. It's recommended to use TArrays with a TInlineAllocator to potentially avoid memory allocation costs. TInlineComponentArray is defined to make this easier, for example: { TInlineComponentArray<UPrimitiveComponent*> PrimComponents(Actor); }
| bIncludeFromChildActors | If true then recurse in to ChildActor components and find components of the appropriate type in those Actors as well |
|
inline |
Get all components derived from class 'ComponentType' and fill in the OutComponents array with the result. It's recommended to use TArrays with a TInlineAllocator to potentially avoid memory allocation costs. TInlineComponentArray is defined to make this easier, for example: { TInlineComponentArray<UPrimitiveComponent*> PrimComponents(Actor); }
| bIncludeFromChildActors | If true then recurse in to ChildActor components and find components of the appropriate type in those Actors as well |
|
inline |
Get all components derived from class 'T' and fill in the OutComponents array with the result. It's recommended to use TArrays with a TInlineAllocator to potentially avoid memory allocation costs. TInlineComponentArray is defined to make this easier, for example: { TInlineComponentArray<UPrimitiveComponent*> PrimComponents(Actor); }
| bIncludeFromChildActors | If true then recurse in to ChildActor components and find components of the appropriate type in those Actors as well |
|
inline |
UActorComponent specialization of GetComponents() to avoid unnecessary casts. It's recommended to use TArrays with a TInlineAllocator to potentially avoid memory allocation costs. TInlineComponentArray is defined to make this easier, for example: { TInlineComponentArray<UActorComponent*> PrimComponents; Actor->GetComponents(PrimComponents); }
| bIncludeFromChildActors | If true then recurse in to ChildActor components and find components of the appropriate type in those Actors as well |
|
inline |
Get all components derived from specified ComponentClass and fill in the OutComponents array with the result. It's recommended to use TArrays with a TInlineAllocator to potentially avoid memory allocation costs. TInlineComponentArray is defined to make this easier, for example: { TInlineComponentArray<UPrimitiveComponent*> PrimComponents(Actor); }
| ComponentClass | The component class to find all components of a class derived from |
| bIncludeFromChildActors | If true then recurse in to ChildActor components and find components of the appropriate type in those Actors as well |
|
virtual |
Returns the world space bounding box of all components in this Actor.
| bNonColliding | Indicates that you want to include non-colliding components in the bounding box |
| bIncludeFromChildActors | If true then recurse in to ChildActor components and find components of the appropriate type in those Actors as well |
Reimplemented in ALODActor.
|
virtual |
Get half-height/radius of a big axis-aligned cylinder around this actors registered colliding components, or all registered components if bNonColliding is false.
| bNonColliding | Indicates that you want to include non-colliding components in the bounding cylinder |
| bIncludeFromChildActors | If true then recurse in to ChildActor components and find components of the appropriate type in those Actors as well |
| TArray< UActorComponent * > AActor::GetComponentsByInterface | ( | TSubclassOf< UInterface > | Interface | ) | const |
Gets all the components that implements the given interface.
|
virtual |
Get Collision Response to the passed in Channel for all components It returns Max of state - i.e. if Component A overlaps, but if Component B blocks, it will return block as response if Component A ignores, but if Component B overlaps, it will return overlap
Retrieves actor's name used for logging, or string "NULL" if Actor is null
|
inlinevirtual |
Returns this actor's default attachment component for attaching children to
Reimplemented in ACameraRig_Crane, and ACameraRig_Rail.
Returns the distance from this Actor to OtherActor.
Returns the dot product from this Actor to OtherActor. Returns -2.0 on failure. Returns 0.0 for coincidental actors.
| const UExternalDataLayerAsset * AActor::GetExternalDataLayerAsset | ( | ) | const |
Return the space this function should be called. Checks to see if this function should be called locally, remotely, or simply absorbed under the given conditions
| Function | function to call |
| Stack | stack frame for the function call |
Reimplemented from UObject.
| UGameInstance * AActor::GetGameInstance | ( | ) | const |
Gets the GameInstance that ultimately contains this actor.
|
inline |
Gets the GameInstance that ultimately contains this actor cast to the template type. May return NULL if the cast fails.
| float AActor::GetGameTimeSinceCreation | ( | ) | const |
The number of seconds (in game time) since this Actor was created, relative to Get Game Time In Seconds.
Gets the property name for bHidden. This exists so subclasses don't need to have direct access to the bHidden property so it can be made private later.
|
virtual |
Return the list of components to use when building the HLOD representation of this actor.
Returns the distance from this Actor to OtherActor, ignoring Z.
Returns the dot product from this Actor to OtherActor, ignoring Z. Returns -2.0 on failure. Returns 0.0 for coincidental actors.
|
virtual |
Returns the human readable string representation of an object.
Reimplemented in AController.
Gets the value of the input axis key if input is enabled for this actor.
Gets the value of the input axis if input is enabled for this actor.
Gets the value of the input axis key if input is enabled for this actor.
| const TArray< UActorComponent * > & AActor::GetInstanceComponents | ( | ) | const |
Returns the instance components array
| APawn * AActor::GetInstigator | ( | ) | const |
Returns the instigator for this actor, or nullptr if there is none.
|
inline |
Get the instigator, cast as a specific class.
| AController * AActor::GetInstigatorController | ( | ) | const |
Returns the instigator's controller for this actor, or nullptr if there is none.
|
inline |
Returns the instigator's controller, cast as a specific class.
Gets the property name for Instigator. This exists so subclasses don't need to have direct access to the Instigator property so it can be made private later.
|
inline |
Returns whether replication is enabled or not.
|
virtual |
Returns the most recent time any of this actor's components were rendered
| FTransform AActor::GetLevelTransform | ( | ) | const |
Return the FTransform of the level this actor is a part of.
|
virtual |
Get the remaining lifespan of this actor. If zero is returned the actor lives forever.
|
overridevirtual |
Returns the properties used for network replication, this needs to be overridden by all actor classes with native replicated properties
Reimplemented from UObject.
Reimplemented in AController, ALightWeightInstanceManager, ALightWeightInstanceStaticMeshManager, APlayerController, and ALevelInstance.
|
inline |
Returns how much control the local machine has over this actor.
| float AActor::GetMinNetUpdateFrequency | ( | ) | const |
Get the frequency to throttle down to when replicated properties are changing infrequently.
|
virtual |
Get the owning connection used for communicating between client/server
Reimplemented in APlayerController, and ANoPawnPlayerController.
| float AActor::GetNetCullDistanceSquared | ( | ) | const |
Get the square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
|
virtual |
Returns true if the actor should be dormant for a specific net connection. Only checked for DORM_DormantPartial
| UNetDriver * AActor::GetNetDriver | ( | ) | const |
Returns the net driver that this actor is bound to, may be null
|
inline |
Returns name of the net driver associated with this actor (all RPCs will go out via this connection)
|
inline |
Get the network mode (dedicated server, client, standalone, etc) for this actor.
Return the actor responsible for replication, if any. Typically the player controller
Reimplemented in APlayerController, and AGameplayDebuggerCategoryReplicator.
|
virtual |
Return the owning UPlayer (if any) of this actor if it's role is ROLE_Authority. This will be a local player, a net connection, or nullptr.
Reimplemented in APlayerController.
|
virtual |
Return the owning UPlayer (if any) of this actor, regardless of it's current role. This will be a local player, a net connection, or nullptr.
Reimplemented in APlayerController.
|
virtual |
Function used to prioritize actors when deciding which to replicate
| ViewPos | Position of the viewer |
| ViewDir | Vector direction of viewer |
| Viewer | "net object" owned by the client for whom net priority is being determined (typically player controller) |
| ViewTarget | The actor that is currently being viewed/controlled by Viewer, usually a pawn |
| InChannel | Channel on which this actor is being replicated. |
| Time | Time since actor was last replicated |
| bLowBandwidth | True if low bandwidth of viewer |
Reimplemented in APlayerController.
| float AActor::GetNetUpdateFrequency | ( | ) | const |
Get the current frequency at which this object will be considered for replication.
| void AActor::GetOverlappingActors | ( | TArray< AActor * > & | OverlappingActors, |
| TSubclassOf< AActor > | ClassFilter = nullptr |
||
| ) | const |
Returns list of actors this actor is overlapping (any component overlapping any component). Does not return itself.
| OverlappingActors | [out] Returned list of overlapping actors |
| ClassFilter | [optional] If set, only returns actors of this class or subclasses |
| void AActor::GetOverlappingActors | ( | TSet< AActor * > & | OverlappingActors, |
| TSubclassOf< AActor > | ClassFilter = nullptr |
||
| ) | const |
Returns set of actors this actor is overlapping (any component overlapping any component). Does not return itself.
| OverlappingActors | [out] Returned list of overlapping actors |
| ClassFilter | [optional] If set, only returns actors of this class or subclasses |
| void AActor::GetOverlappingComponents | ( | TArray< UPrimitiveComponent * > & | OverlappingComponents | ) | const |
Returns list of components this actor is overlapping.
| void AActor::GetOverlappingComponents | ( | TSet< UPrimitiveComponent * > & | OverlappingComponents | ) | const |
Returns set of components this actor is overlapping.
|
inline |
Get the owner of this Actor, used primarily for network replication.
|
inline |
Templated version of GetOwner(), will return nullptr if cast fails
| AActor * AActor::GetParentActor | ( | ) | const |
If this Actor was created by a Child Actor Component returns the Actor that owns that Child Actor Component
| UChildActorComponent * AActor::GetParentComponent | ( | ) | const |
If this Actor was created by a Child Actor Component returns that Child Actor Component
| EPhysicsReplicationMode AActor::GetPhysicsReplicationMode | ( | ) |
Get the physics replication mode of this body, via EPhysicsReplicationMode
|
virtual |
Get the physics volume that is currently applied to this Actor (there can only ever be one)
| FVector AActor::GetPlacementExtent | ( | ) | const |
Get the extent used when placing this actor in the editor, used for 'pulling back' hit.
| int32 AActor::GetRayTracingGroupId | ( | ) | const |
Return the RayTracingGroupId for this actor.
|
inline |
Returns how much control the remote machine has over this actor.
|
virtual |
Similar to GetNetPriority, but will only be used for prioritizing actors while recording a replay.
| ViewPos | Position of the viewer |
| ViewDir | Vector direction of viewer |
| Viewer | "net object" owned by the client for whom net priority is being determined (typically player controller) |
| ViewTarget | The actor that is currently being viewed/controlled by Viewer, usually a pawn |
| InChannel | Channel on which this actor is being replicated. |
| Time | Time since actor was last replicated |
|
inline |
Returns a constant reference to the replicated components set
|
overridevirtual |
Called when this actor begins replicating to initialize the state of custom property conditions
Reimplemented from UObject.
|
inline |
Gets the literal value of ReplicatedMovement.
This exists so subclasses don't need to have direct access to the Role property so it can be made private later.
| FRepMovement & AActor::GetReplicatedMovement_Mutable | ( | ) |
Gets a reference to ReplicatedMovement with the expectation that it will be modified.
This exists so subclasses don't need to have direct access to the ReplicatedMovement property so it can be made private later.
Gets the property name for bReplicateMovement. This exists so subclasses don't need to have direct access to the bReplicateMovement property so it can be made private later.
| float AActor::GetResimulationThreshold | ( | ) | const |
Get the error threshold in centimeters before this object should enforce a resimulation to trigger.
Gets the property name for Role. This exists so subclasses don't need to have direct access to the Role property so it can be made private later.
|
inline |
Returns this actor's root component.
|
virtual |
Returns top most selection parent
|
virtual |
Returns immediate selection parent
|
virtual |
Get axis-aligned cylinder around this actor, used for simple collision checks (ie Pawns reaching a destination). If IsRootComponentCollisionRegistered() returns true, just returns its bounding cylinder, otherwise falls back to GetComponentsBoundingCylinder.
Reimplemented in ANavigationObjectBase.
|
inline |
Returns collision extents vector for this Actor, based on GetSimpleCollisionCylinder().
|
inline |
Returns the half height of the collision cylinder from GetSimpleCollisionCylinder().
|
inline |
Returns the radius of the collision cylinder from GetSimpleCollisionCylinder().
Returns the squared distance from this Actor to OtherActor.
Returns the squared distance from this Actor to OtherActor, ignoring Z.
Returns the optimal location to fire weapons at this actor
| RequestedBy | - the Actor requesting the target location |
|
inline |
If true, this actor is no longer replicated to new clients, and is "torn off" (becomes a ROLE_Authority) on clients to which it was being replicated.
| bool AActor::GetTickableWhenPaused | ( | ) |
Gets whether this actor can tick when paused.
|
inline |
Get the actor-to-world transform.
| EActorUpdateOverlapsMethod AActor::GetUpdateOverlapsMethodDuringLevelStreaming | ( | ) | const |
Get the method used to UpdateOverlaps() when loaded via level streaming. Resolves the 'UseConfigDefault' option to the class default specified in config.
|
virtual |
Returns velocity (in cm/s (Unreal Units/second) of the rootcomponent if it is either using physics or has an associated MovementComponent
Returns the distance from this Actor to OtherActor, ignoring XY.
|
finaloverridevirtual |
Getter for the cached world pointer, will return null if the actor is not actually spawned in a level
| AWorldSettings * AActor::GetWorldSettings | ( | ) | const |
Returns the WorldSettings for the World the actor is in If you'd like to know what UWorld this placed actor (not dynamic spawned actor) belong to, use GetTypedOuter<UWorld>()
| FTimerManager & AActor::GetWorldTimerManager | ( | ) | const |
Get the timer instance from the actors world
| void AActor::HandleRegisterComponentWithWorld | ( | UActorComponent * | Component | ) |
Finish initializing the component and register tick functions and beginplay if it's the proper time to do so.
Returns true if the actor contains an active camera component
|
virtual |
Returns true if the actor contains an active locked to HMD camera component
|
inline |
Returns whether an actor has had BeginPlay called on it (and not subsequently had EndPlay called)
|
inline |
Returns bHasRegisteredAllComponents which indicates whether this actor has registered all their components without unregisatering all of them them. bHasRegisteredAllComponents is set true just before PostRegisterAllComponents() is called and false just before PostUnregisterAllComponents() is called.
|
inline |
Returns whether this actor has network authority
| bool AActor::HasContentBundle | ( | ) | const |
| bool AActor::HasDataLayers | ( | ) | const |
|
inline |
Returns true if Actor has deferred the RegisterAllComponents() call at spawn time (e.g. pending Blueprint SCS execution to set up a scene root component).
|
virtual |
Indicates whether this actor can provide HLOD relevant components.
|
virtual |
Does this actor have a locally controlled owner responsible for replication? (APlayerController typically)
|
virtual |
Does this actor have an owner responsible for replication? (APlayerController typically)
Reimplemented in APlayerController.
| bool AActor::HasNonTrivialUserConstructionScript | ( | ) | const |
Returns true if the actor's class has a non trivial user construction script.
| bool AActor::HasValidRootComponent | ( | ) | const |
Returns true if Actor has a registered root component
| bool AActor::IncrementalRegisterComponents | ( | int32 | NumComponentsToRegister, |
| FRegisterComponentContext * | Context = nullptr |
||
| ) |
Incrementally registers components associated with this actor, used during level streaming
| NumComponentsToRegister | Number of components to register in this run, 0 for all |
| void AActor::InitializeComponents | ( | ) |
Iterate over components array and call InitializeComponent, which happens once per actor
|
protectedvirtual |
|
protectedvirtual |
Reimplemented in AInstancedFoliageActor.
|
inline |
Invalidate lighting cache with default options.
Invalidates anything produced by the last lighting build.
|
inline |
Returns whether an actor is in the process of beginning play
|
inline |
Returns whether an actor is beginning play in DispatchBeginPlay() during level streaming (which includes initial level load).
|
inline |
Returns true if this actor is currently being destroyed, some gameplay events may be unsafe
| bool AActor::IsActorComponentReplicatedSubObjectRegistered | ( | const UActorComponent * | OwnerComponent, |
| const UObject * | SubObject | ||
| ) | const |
Tells if an object owned by a component has been registered as a replicated subobject of the component
|
inline |
Returns whether an actor has been initialized for gameplay
| bool AActor::IsActorOrSelectionParentSelected | ( | ) | const |
Returns if actor or selection parent is selected
| bool AActor::IsActorTickEnabled | ( | ) | const |
Returns whether this actor has tick enabled or not
|
overridevirtual |
Returns true if this object is considered an asset.
Reimplemented from UObject.
Iterates up the attachment chain to see whether or not this Actor is attached to the given Actor
| Other | the Actor to test for |
Iterates up the movement base chain to see whether or not this Actor is based on the given Actor, defaults to checking attachment
| Other | the Actor to test for |
| bool AActor::IsChildActor | ( | ) | const |
Returns whether this Actor was spawned by a child actor component
|
inlinevirtual |
Check if owned component should be relevant for navigation Allows implementing master switch to disable e.g. collision export in projectiles
Reimplemented in AWorldPartitionHLOD.
|
overridevirtual |
Called during saving to determine if the object is forced to be editor only or not
Reimplemented from UObject.
Reimplemented in AWorldPartitionHLOD.
|
inline |
Gets the literal value of bHidden.
This exists so subclasses don't need to have direct access to the bHidden property so it can be made private later.
|
virtual |
Indicates whether this actor contributes to the HLOD generation.
Reimplemented in AWorldPartitionHLOD.
Returns true if this actor is contained by TestLevel.
Returns whether this Actor is in the persistent level, i.e. not a sublevel
Indicates whether this actor should participate in level bounds calculations
Reimplemented in ALODActor, AReflectionCapture, ALightmassPortal, ARuntimeVirtualTextureVolume, AInstancedFoliageActor, and ALandscapeGizmoActor.
| bool AActor::IsMainPackageActor | ( | ) | const |
Used to check if Actor is the main actor of a package (currently Child Actors are not)
|
overridevirtual |
IsNameStableForNetworking means an object can be referred to its path name (relative to outer) over the network
Reimplemented from UObject.
Test whether net mode is the given mode. In optimized non-editor builds this can be more efficient than GetNetMode() because it can check the static build flags without considering PIE.
|
virtual |
Checks to see if this actor is relevant for a specific network connection
| RealViewer | - is the "controlling net object" associated with the client for which network relevancy is being checked (typically player controller) |
| ViewTarget | - is the Actor being used as the point of view for the RealViewer |
| SrcLocation | - is the viewing location |
Reimplemented in APlayerController.
| bool AActor::IsNetStartupActor | ( | ) | const |
Returns true if this is a replicated actor that was placed in the map
Check whether any component of this Actor is overlapping any component of another Actor.
| Other | The other Actor to test against |
See if this actor is owned by TestOwner.
|
inline |
Returns true if this actor has begun the destruction process. This is set to true in UWorld::DestroyActor, after the network connection has been closed but before any other shutdown has been performed.
|
overridevirtual |
Called to check if the object is ready for FinishDestroy. This is called after BeginDestroy to check the completion of the potentially asynchronous object cleanup.
Reimplemented from UObject.
|
virtual |
Check if this actor is the owner when doing relevancy checks for actors marked bOnlyRelevantToOwner
| ReplicatedActor | - the actor we're doing a relevancy test on |
| ActorOwner | - the owner of ReplicatedActor |
| ConnectionActor | - the controller of the connection that we're doing relevancy checks for |
|
virtual |
Checks to see if this actor is relevant for a recorded replay
| RealViewer | - is the "controlling net object" associated with the client for which network relevancy is being checked (typically player controller) |
| ViewTarget | - is the Actor being used as the point of view for the RealViewer |
| SrcLocation | - is the viewing location |
| bool AActor::IsReplicatedActorComponentRegistered | ( | const UActorComponent * | ReplicatedComponent | ) | const |
Tells if the component has been registered as a replicated component
Tells if the object has been registered as a replicated subobject of this actor
|
inline |
Gets the literal value of bReplicateMovement.
This exists so subclasses don't need to have direct access to the bReplicateMovement property so it can be made private later.
|
virtual |
Gives the actor a chance to pause replication to a player represented by the passed in actor - only called on server
|
virtual |
Returns true if the root component is registered and has collision enabled.
| bool AActor::IsRootComponentMovable | ( | ) | const |
See if the root component has Mobility of EComponentMobility::Movable
| bool AActor::IsRootComponentStatic | ( | ) | const |
See if the root component has ModifyFrequency of MF_Static
| bool AActor::IsRootComponentStationary | ( | ) | const |
See if the root component has Mobility of EComponentMobility::Stationary
|
inline |
Returns if this actor is currently running the User Construction Script
Reimplemented in AWorldPartitionHLOD.
|
virtual |
Returns whether this Actor is part of another's actor selection
|
virtual |
Returns whether this actor can select its attached actors
|
overridevirtual |
IsSupportedForNetworking means an object can be referenced over the network
Reimplemented from UObject.
|
inline |
Returns true if this actor is replicating SubObjects & ActorComponents via the registration list. Returns false when it replicates them via the virtual ReplicateSubobjects method.
Determines whether or not the distance between the given SrcLocation and the Actor's location is within the net relevancy distance. Actors outside relevancy distance may not be replicated.
| SrcLocation | Location to test against. |
| void AActor::K2_AddActorLocalOffset | ( | FVector | DeltaLocation, |
| bool | bSweep, | ||
| FHitResult & | SweepHitResult, | ||
| bool | bTeleport | ||
| ) |
Adds a delta to the location of this component in its local reference frame.
| DelatLocation | The change in location in local space. |
| bSweep | Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect. |
| bTeleport | Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the location without teleporting will not update the location of simulated child/attached components. |
| void AActor::K2_AddActorLocalRotation | ( | FRotator | DeltaRotation, |
| bool | bSweep, | ||
| FHitResult & | SweepHitResult, | ||
| bool | bTeleport | ||
| ) |
Adds a delta to the rotation of this component in its local reference frame
| DeltaRotation | The change in rotation in local space. |
| bSweep | Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect. |
| bTeleport | Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the rotation without teleporting will not update the rotation of simulated child/attached components. |
| void AActor::K2_AddActorLocalTransform | ( | const FTransform & | NewTransform, |
| bool | bSweep, | ||
| FHitResult & | SweepHitResult, | ||
| bool | bTeleport | ||
| ) |
Adds a delta to the transform of this component in its local reference frame
| NewTransform | The change in transform in local space. |
| bSweep | Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect. |
| bTeleport | Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the transform without teleporting will not update the transform of simulated child/attached components. |
| void AActor::K2_AddActorWorldOffset | ( | FVector | DeltaLocation, |
| bool | bSweep, | ||
| FHitResult & | SweepHitResult, | ||
| bool | bTeleport | ||
| ) |
Adds a delta to the location of this actor in world space.
| DeltaLocation | The change in location. |
| bSweep | Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect. |
| bTeleport | Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the location without teleporting will not update the location of simulated child/attached components. |
| SweepHitResult | The hit result from the move if swept. |
| void AActor::K2_AddActorWorldRotation | ( | FRotator | DeltaRotation, |
| bool | bSweep, | ||
| FHitResult & | SweepHitResult, | ||
| bool | bTeleport | ||
| ) |
Adds a delta to the rotation of this actor in world space.
| DeltaRotation | The change in rotation. |
| bSweep | Whether to sweep to the target rotation (not currently supported for rotation). |
| bTeleport | Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the rotation without teleporting will not update the rotation of simulated child/attached components. |
| SweepHitResult | The hit result from the move if swept. |
| void AActor::K2_AddActorWorldTransform | ( | const FTransform & | DeltaTransform, |
| bool | bSweep, | ||
| FHitResult & | SweepHitResult, | ||
| bool | bTeleport | ||
| ) |
Adds a delta to the transform of this actor in world space. Ignores scale and sets it to (1,1,1).
| void AActor::K2_AddActorWorldTransformKeepScale | ( | const FTransform & | DeltaTransform, |
| bool | bSweep, | ||
| FHitResult & | SweepHitResult, | ||
| bool | bTeleport | ||
| ) |
Adds a delta to the transform of this actor in world space. Scale is unchanged.
| bool AActor::K2_AttachToActor | ( | AActor * | ParentActor, |
| FName | SocketName, | ||
| EAttachmentRule | LocationRule, | ||
| EAttachmentRule | RotationRule, | ||
| EAttachmentRule | ScaleRule, | ||
| bool | bWeldSimulatedBodies | ||
| ) |
Attaches the RootComponent of this Actor to the supplied actor, optionally at a named socket.
| ParentActor | Actor to attach this actor's RootComponent to |
| SocketName | Socket name to attach to, if any |
| LocationRule | How to handle translation when attaching. |
| RotationRule | How to handle rotation when attaching. |
| ScaleRule | How to handle scale when attaching. |
| bWeldSimulatedBodies | Whether to weld together simulated physics bodies.This transfers the shapes in the welded object into the parent (if simulated), which can result in permanent changes that persist even after subsequently detaching. |
| bool AActor::K2_AttachToComponent | ( | USceneComponent * | Parent, |
| FName | SocketName, | ||
| EAttachmentRule | LocationRule, | ||
| EAttachmentRule | RotationRule, | ||
| EAttachmentRule | ScaleRule, | ||
| bool | bWeldSimulatedBodies | ||
| ) |
Attaches the RootComponent of this Actor to the supplied component, optionally at a named socket. It is not valid to call this on components that are not Registered.
| Parent | Parent to attach to. |
| SocketName | Optional socket to attach to on the parent. |
| LocationRule | How to handle translation when attaching. |
| RotationRule | How to handle rotation when attaching. |
| ScaleRule | How to handle scale when attaching. |
| bWeldSimulatedBodies | Whether to weld together simulated physics bodies. This transfers the shapes in the welded object into the parent (if simulated), which can result in permanent changes that persist even after subsequently detaching. |
|
virtual |
Destroy the actor
Reimplemented in AController.
| void AActor::K2_DetachFromActor | ( | EDetachmentRule | LocationRule = EDetachmentRule::KeepRelative, |
| EDetachmentRule | RotationRule = EDetachmentRule::KeepRelative, |
||
| EDetachmentRule | ScaleRule = EDetachmentRule::KeepRelative |
||
| ) |
Detaches the RootComponent of this Actor from any SceneComponent it is currently attached to.
| LocationRule | How to handle translation when detaching. |
| RotationRule | How to handle rotation when detaching. |
| ScaleRule | How to handle scale when detaching. |
|
inline |
Returns the location of the RootComponent of this Actor
|
inline |
Returns rotation of the RootComponent of this Actor.
| TArray< UActorComponent * > AActor::K2_GetComponentsByClass | ( | TSubclassOf< UActorComponent > | ComponentClass | ) | const |
Gets all the components that inherit from the given class. Currently returns an array of UActorComponent which must be cast to the correct type. This intended to only be used by blueprints. Use GetComponents() in C++.
|
inline |
Returns the RootComponent of this Actor
| ENGINE_API void AActor::K2_OnBecomeViewTarget | ( | class APlayerController * | PC | ) |
Event called when this Actor becomes the view target for the given PlayerController.
| ENGINE_API void AActor::K2_OnEndViewTarget | ( | class APlayerController * | PC | ) |
Event called when this Actor is no longer the view target for the given PlayerController.
| ENGINE_API void AActor::K2_OnReset | ( | ) |
Event called when this Actor is reset to its initial state - used when restarting level without reloading.
| bool AActor::K2_SetActorLocation | ( | FVector | NewLocation, |
| bool | bSweep, | ||
| FHitResult & | SweepHitResult, | ||
| bool | bTeleport | ||
| ) |
Move the Actor to the specified location.
| NewLocation | The new location to move the Actor to. |
| bSweep | Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect. |
| bTeleport | Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the location without teleporting will not update the location of simulated child/attached components. |
| SweepHitResult | The hit result from the move if swept. |
| bool AActor::K2_SetActorLocationAndRotation | ( | FVector | NewLocation, |
| FRotator | NewRotation, | ||
| bool | bSweep, | ||
| FHitResult & | SweepHitResult, | ||
| bool | bTeleport | ||
| ) |
Move the actor instantly to the specified location and rotation.
| NewLocation | The new location to teleport the Actor to. |
| NewRotation | The new rotation for the Actor. |
| bSweep | Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect. |
| bTeleport | Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the location without teleporting will not update the location of simulated child/attached components. |
| SweepHitResult | The hit result from the move if swept. |
| void AActor::K2_SetActorRelativeLocation | ( | FVector | NewRelativeLocation, |
| bool | bSweep, | ||
| FHitResult & | SweepHitResult, | ||
| bool | bTeleport | ||
| ) |
Set the actor's RootComponent to the specified relative location.
| NewRelativeLocation | New relative location of the actor's root component |
| bSweep | Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect. |
| bTeleport | Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the location without teleporting will not update the location of simulated child/attached components. |
| void AActor::K2_SetActorRelativeRotation | ( | FRotator | NewRelativeRotation, |
| bool | bSweep, | ||
| FHitResult & | SweepHitResult, | ||
| bool | bTeleport | ||
| ) |
Set the actor's RootComponent to the specified relative rotation
| NewRelativeRotation | New relative rotation of the actor's root component |
| bSweep | Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect. |
| bTeleport | Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the rotation without teleporting will not update the rotation of simulated child/attached components. |
| void AActor::K2_SetActorRelativeTransform | ( | const FTransform & | NewRelativeTransform, |
| bool | bSweep, | ||
| FHitResult & | SweepHitResult, | ||
| bool | bTeleport | ||
| ) |
Set the actor's RootComponent to the specified relative transform
| NewRelativeTransform | New relative transform of the actor's root component |
| bSweep | Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect. |
| bTeleport | Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the transform without teleporting will not update the transform of simulated child/attached components. |
Set the Actor's rotation instantly to the specified rotation.
| NewRotation | The new rotation for the Actor. |
| bTeleportPhysics | Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the rotation without teleporting will not update the rotation of simulated child/attached components. |
| bool AActor::K2_SetActorTransform | ( | const FTransform & | NewTransform, |
| bool | bSweep, | ||
| FHitResult & | SweepHitResult, | ||
| bool | bTeleport | ||
| ) |
Set the Actors transform to the specified one.
| NewTransform | The new transform. |
| bSweep | Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect. |
| bTeleport | Whether we teleport the physics state (if physics collision is enabled for this object). If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If false, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the transform without teleporting will not update the transform of simulated child/attached components. |
Teleport this actor to a new location. If the actor doesn't fit exactly at the location specified, tries to slightly move it out of walls and such.
| DestLocation | The target destination point |
| DestRotation | The target rotation at the destination |
|
virtual |
Called when the lifespan of an actor expires (if it has one).
| void AActor::MakeNoise | ( | float | Loudness = 1.f, |
| APawn * | NoiseInstigator = nullptr, |
||
| FVector | NoiseLocation = FVector::ZeroVector, |
||
| float | MaxRange = 0.f, |
||
| FName | Tag = NAME_None |
||
| ) |
Trigger a noise caused by a given Pawn, at a given location. Note that the NoiseInstigator Pawn MUST have a PawnNoiseEmitterComponent for the noise to be detected by a PawnSensingComponent. Senders of MakeNoise should have an Instigator if they are not pawns, or pass a NoiseInstigator.
| Loudness | The relative loudness of this noise. Usual range is 0 (no noise) to 1 (full volume). If MaxRange is used, this scales the max range, otherwise it affects the hearing range specified by the sensor. |
| NoiseInstigator | Pawn responsible for this noise. Uses the actor's Instigator if NoiseInstigator is null |
| NoiseLocation | Position of noise source. If zero vector, use the actor's location. |
| MaxRange | Max range at which the sound may be heard. A value of 0 indicates no max range (though perception may have its own range). Loudness scales the range. (Note: not supported for legacy PawnSensingComponent, only for AIPerception) |
| Tag | Identifier for the noise. |
|
static |
Default Implementation of MakeNoise
Called to mark all components as garbage when the actor is being destroyed
| bModify | if True, Modify will be called on actor before marking components |
| void AActor::MarkComponentsRenderStateDirty | ( | ) |
Flags all component's render state as dirty
| void AActor::MarkNeedsRecomputeBoundsOnceForGame | ( | ) |
Marks the bounds of all SceneComponents attached to this actor which have bComputeBoundsOnceForGame as needing to be recomputed the next time UpdateBounds is called. This might be necessary if the bounds that were cached on cook no longer reflect the actor's transform (ex. if level transform is applied).
|
virtual |
Event when this actor has the mouse moved over it with the clickable interface.
Event when this actor overlaps another actor, for example a player walking into a trigger. For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
|
virtual |
Event when this actor has the mouse moved off of it with the clickable interface.
Event when an actor no longer overlaps another actor, and they have separated.
|
virtual |
Event when this actor is clicked by the mouse when using the clickable interface.
Event when this actor is touched when click events are enabled.
Event when this actor is under the finger when untouched when click events are enabled.
Event when this actor has a finger moved over it with the clickable interface.
Event when this actor has a finger moved off of it with the clickable interface.
|
virtual |
Event when this actor is under the mouse when left mouse button is released while using the clickable interface.
|
virtual |
Event when this actor bumps into a blocking object, or blocks another actor that bumps into it. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation. For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
|
inlinevirtual |
Allows for a specific response from the actor when the actor channel is opened (client side)
| InBunch | Bunch received at time of open |
| Connection | the connection associated with this actor |
Reimplemented in APlayerController.
|
inlinevirtual |
Called when an instance of this class is placed (in editor) or spawned.
| Transform | The transform the actor was constructed at. |
Reimplemented in AFieldSystemActor.
|
inlinevirtual |
Handles cleaning up the associated Actor when killing the connection
| Connection | the connection associated with this actor |
Reimplemented in APlayerController.
|
virtual |
Called on client when updated AttachmentReplication value is received for this actor.
|
virtual |
Called on clients when Instigator is replicated.
|
protectedvirtual |
Called when owner changes, does nothing by default but can be overridden
|
virtual |
ReplicatedMovement struct replication event
|
virtual |
Called on client when updated bReplicateMovement value is received for this actor.
Called on the client when the replication paused value is changed
|
protectedvirtual |
Called if using iris replication after an actor has started to replicate with iris replication, Normally this will occur right before BeginPlay, but might will also be called later if SetReplicates(true) is called and the object is not already replicating
Reimplemented in APlayerController, and AGameplayDebuggerCategoryReplicator.
SerializeNewActor has just been called on the actor before network replication (server side)
| OutBunch | Bunch containing serialized contents of actor prior to replication |
Reimplemented in APlayerController.
|
protectedvirtual |
Called if using iris replication when we are about to stop replicating an actor, typically called from EndPlay() for actors that should be replicated during their lifespan
Called on the actor when a new subobject is dynamically created via replication
Called on the actor when a subobject is dynamically destroyed via replication
|
virtual |
Called when the Actor is outside the hard limit on world bounds
| void AActor::PostActorConstruction | ( | ) |
Called after the actor has run its construction. Responsible for finishing the actor spawn process.
|
virtual |
Called when an actor is done spawning into the world (from UWorld::SpawnActor), both in the editor and during gameplay For actors with a root component, the location and rotation will have already been set. This is called before calling construction scripts, but after native components have been created
Reimplemented in AEmitter.
|
protected |
Called after instancing a new Blueprint Component from either a template or cooked data.
|
virtual |
Allow actors to initialize themselves on the C++ side after all of their components have been initialized, only called during gameplay
Reimplemented in AAIController, ASkeletalMeshActor, APlayerCameraManager, ADebugCameraController, AController, APlayerController, ANoPawnPlayerController, AEmitter, AEmitterCameraLensEffectBase, ALevelSequenceActor, and ANavigationData.
|
overridevirtual |
Called after the C++ constructor and after the properties have been initialized, including those loaded from config. This is called before any serialization or other setup has happened.
Reimplemented from UObject.
Reimplemented in ALevelSequenceActor, ANavigationData, and ANavSystemConfigOverride.
|
overridevirtual |
Do any object-specific cleanup required immediately after loading an object. This is not called for newly-created objects, and by default will always execute on the game thread.
Reimplemented from UObject.
Reimplemented in ALODActor, APlanarReflection, ASceneCapture, APlayerController, AEmitterCameraLensEffectBase, APhysicsConstraintActor, AInstancedPlacementPartitionActor, AMaterialInstanceActor, AWorldPartitionHLOD, AMapBuildDataActor, AChaosSolverActor, AInstancedFoliageActor, ALevelSequenceActor, AAbstractNavData, and ANavigationData.
|
overridevirtual |
Instances components for objects being loaded from disk, if necessary. Ensures that component references between nested components are fixed up correctly.
| OuterInstanceGraph | when calling this method on subobjects, specifies the instancing graph which contains all instanced subobjects and components for a subobject root. |
Reimplemented from UObject.
|
virtual |
Always called immediately after spawning and reading in replicated properties
Reimplemented in ALevelInstance.
|
overridevirtual |
Always called immediately after properties are received from the remote.
Reimplemented from UObject.
Reimplemented in AGameplayDebuggerCategoryReplicator, and ALevelSequenceActor.
|
virtual |
Update location and rotation from ReplicatedMovement. Not called for simulated physics!
|
virtual |
Update and smooth simulated physic state, replaces PostNetReceiveLocation() and PostNetReceiveVelocity()
|
virtual |
Always called immediately after a new Role is received from the remote.
Update velocity - typically from ReplicatedMovement, not called for simulated physics!
|
virtual |
Called after all the components in the Components array are registered, called both in editor and during gameplay. bHasRegisteredAllComponents must be set true prior to calling this function.
Reimplemented in AAIController, ALODActor, ALevelInstance, AWorldPartitionHLODOnlyLevelInstance, AWorldPartitionStandaloneHLOD, AConstraintsActor, and AChaosSolverActor.
|
virtual |
Hook to allow actors to render HUD overlays for themselves. Called from AHUD::DrawActorOverlays().
| PC | is the PlayerController on whose view this overlay is rendered |
| Canvas | is the Canvas on which to draw the overlay |
| CameraPosition | Position of Camera |
| CameraDir | direction camera is pointing in. |
|
virtual |
|
overridevirtual |
Called from within SavePackage on the passed in base/root object. This function is called after the package has been saved and can perform cleanup.
| ObjectSaveContext | Context providing access to parameters of the save and to values from PreSaveRoot |
Reimplemented from UObject.
| void AActor::PostSpawnInitialize | ( | FTransform const & | SpawnTransform, |
| AActor * | InOwner, | ||
| APawn * | InInstigator, | ||
| bool | bRemoteOwned, | ||
| bool | bNoFail, | ||
| bool | bDeferConstruction, | ||
| ESpawnActorScaleMethod | TransformScaleMethod = ESpawnActorScaleMethod::MultiplyWithRoot |
||
| ) |
Called after the actor is spawned in the world. Responsible for setting up actor for play.
|
virtual |
Called after all currently registered components are cleared
Reimplemented in ALevelInstance, AWorldPartitionHLODOnlyLevelInstance, AWorldPartitionStandaloneHLOD, AMapBuildDataActor, and AChaosSolverActor.
|
inlinevirtual |
|
virtual |
Called right before components are initialized, only called during gameplay
Reimplemented in AChaosSolverActor, and ALevelSequenceActor.
|
overridevirtual |
Always called immediately before properties are received from the remote.
Reimplemented from UObject.
|
virtual |
Called before all the components in the Components array are registered, called both in editor and during gameplay
Reimplemented in AWorldPartitionHLOD, and AMapBuildDataActor.
|
virtual |
Called on the actor right before replication occurs. Only called on Server, and for autonomous proxies if recording a Client Replay.
Reimplemented in AWorldPartitionReplay, and AGameplayDebuggerCategoryReplicator.
|
virtual |
Called on the actor right before replication occurs. Called for everyone when recording a Client Replay, including Simulated Proxies.
|
overridevirtual |
Presave function. Gets called once before an object gets serialized for saving. This function is necessary for save time computation as Serialize gets called three times per object from within SavePackage.
Reimplemented from UObject.
|
virtual |
|
overridevirtual |
Called from within SavePackage on the passed in base/root object. The return value of this function will be passed to PostSaveRoot. This is used to allow objects used as a base to perform required actions before saving and cleanup afterwards.
| ObjectSaveContext | Context providing access to parameters of the save, Also allows storage of variables like bCleanupIsRequired for use in PostSaveRoot |
Reimplemented from UObject.
|
virtual |
Calls PrestreamTextures() for all the actor's meshcomponents.
| Seconds | - Number of seconds to force all mip-levels to be resident |
| bEnableStreaming | - Whether to start (true) or stop (false) streaming |
| CinematicTextureGroups | - Bitfield indicating which texture groups that use extra high-resolution mips |
|
protected |
Runs UserConstructionScript, delays component registration until it's complete.
|
virtual |
Push Selection to actor
| ENGINE_API void AActor::ReceiveActorBeginCursorOver | ( | ) |
Event when this actor has the mouse moved over it with the clickable interface.
| ENGINE_API void AActor::ReceiveActorBeginOverlap | ( | AActor * | OtherActor | ) |
Event when this actor overlaps another actor, for example a player walking into a trigger. For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
| ENGINE_API void AActor::ReceiveActorEndCursorOver | ( | ) |
Event when this actor has the mouse moved off of it with the clickable interface.
| ENGINE_API void AActor::ReceiveActorEndOverlap | ( | AActor * | OtherActor | ) |
Event when an actor no longer overlaps another actor, and they have separated.
| ENGINE_API void AActor::ReceiveActorOnClicked | ( | FKey | ButtonPressed = EKeys::LeftMouseButton | ) |
Event when this actor is clicked by the mouse when using the clickable interface.
| ENGINE_API void AActor::ReceiveActorOnInputTouchBegin | ( | const ETouchIndex::Type | FingerIndex | ) |
Event when this actor is touched when click events are enabled.
| ENGINE_API void AActor::ReceiveActorOnInputTouchEnd | ( | const ETouchIndex::Type | FingerIndex | ) |
Event when this actor is under the finger when untouched when click events are enabled.
| ENGINE_API void AActor::ReceiveActorOnInputTouchEnter | ( | const ETouchIndex::Type | FingerIndex | ) |
Event when this actor has a finger moved over it with the clickable interface.
| ENGINE_API void AActor::ReceiveActorOnInputTouchLeave | ( | const ETouchIndex::Type | FingerIndex | ) |
Event when this actor has a finger moved off of it with the clickable interface.
| ENGINE_API void AActor::ReceiveActorOnReleased | ( | FKey | ButtonReleased = EKeys::LeftMouseButton | ) |
Event when this actor is under the mouse when left mouse button is released while using the clickable interface.
| ENGINE_API void AActor::ReceiveAnyDamage | ( | float | Damage, |
| const class UDamageType * | DamageType, | ||
| class AController * | InstigatedBy, | ||
| AActor * | DamageCauser | ||
| ) |
Event when this actor takes ANY damage
| ENGINE_API void AActor::ReceiveAsyncPhysicsTick | ( | float | DeltaSeconds, |
| float | SimSeconds | ||
| ) |
Event called every physics tick if bAsyncPhysicsTickEnabled is true
|
protected |
Event when play begins for this actor.
| ENGINE_API void AActor::ReceiveDestroyed | ( | ) |
Called when the actor has been explicitly destroyed.
|
protected |
Event to notify blueprints this actor is being deleted or removed from a level.
| ENGINE_API void AActor::ReceiveHit | ( | class UPrimitiveComponent * | MyComp, |
| AActor * | Other, | ||
| class UPrimitiveComponent * | OtherComp, | ||
| bool | bSelfMoved, | ||
| FVector | HitLocation, | ||
| FVector | HitNormal, | ||
| FVector | NormalImpulse, | ||
| const FHitResult & | Hit | ||
| ) |
Event when this actor bumps into a blocking object, or blocks another actor that bumps into it. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation. For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
| ENGINE_API void AActor::ReceivePointDamage | ( | float | Damage, |
| const class UDamageType * | DamageType, | ||
| FVector | HitLocation, | ||
| FVector | HitNormal, | ||
| class UPrimitiveComponent * | HitComponent, | ||
| FName | BoneName, | ||
| FVector | ShotFromDirection, | ||
| class AController * | InstigatedBy, | ||
| AActor * | DamageCauser, | ||
| const FHitResult & | HitInfo | ||
| ) |
Event when this actor takes POINT damage
| ENGINE_API void AActor::ReceiveRadialDamage | ( | float | DamageReceived, |
| const class UDamageType * | DamageType, | ||
| FVector | Origin, | ||
| const struct FHitResult & | HitInfo, | ||
| class AController * | InstigatedBy, | ||
| AActor * | DamageCauser | ||
| ) |
Event when this actor takes RADIAL damage
| ENGINE_API void AActor::ReceiveTick | ( | float | DeltaSeconds | ) |
Event called every frame, if ticking is enabled
Virtual call chain to register all tick functions for the actor class hierarchy
| bRegister | - true to register, false, to unregister |
When called, will call the virtual call chain to register all of the tick functions for both the actor and optionally all components Do not override this function or make it virtual
| bRegister | - true to register, false, to unregister |
| bDoComponents | - true to also apply the change to all components |
|
virtual |
Ensure that all the components in the Components array are registered
| void AActor::RegisterAsFocalPointInPhysicsReplicationLOD | ( | ) | const |
Register this actors root components physics object as a focal particle in Physics Repliocation LOD
|
overridevirtual |
RegisterReplicationFragments is called when we an object is added to the ReplicationSystem, it allows an object to register new or existing ReplicationFragments describing data to be replicated and how it should be accessed For more information about ReplicationFragments see ReplicationFragment.h
| Context | Context FFragmentRegistrationContext in which FReplicationFragments could be registered |
| RegistrationFlags | Flags specifying what should be registered in the call |
Reimplemented from UObject.
| void AActor::RemoveActorComponentReplicatedSubObject | ( | UActorComponent * | OwnerComponent, |
| UObject * | SubObject | ||
| ) |
Unregister a SubObject owned by an ActorComponent so it stops being replicated.
| SubObject | The SubObject to remove |
| void AActor::RemoveInstanceComponent | ( | UActorComponent * | Component | ) |
Removes a component from the instance components array
| void AActor::RemoveOwnedComponent | ( | UActorComponent * | Component | ) |
Removes a component from the OwnedComponents array of the Actor. In general this should not need to be called directly by anything other than UActorComponent functions
Unregister a SubObject to stop replicating it's properties to clients. This does not remove or delete it from connections where it was already replicated. By default a replicated subobject gets deleted on clients when the original pointer on the authority becomes invalid. If you want to immediately remove it from client use the DestroyReplicatedSubObjectOnRemotePeers or TearOffReplicatedSubObject functions instead of this one.
| SubObject | The SubObject to remove |
Remove tick dependency on PrerequisiteActor.
|
virtual |
Remove tick dependency on PrerequisiteComponent.
|
overridevirtual |
Rename this object to a unique name, or change its outer.
| NewName | The new name of the object, if null then NewOuter should be set |
| NewOuter | New Outer this object will be placed within, if null it will use the current outer |
| Flags | Flags to specify what happens during the rename |
Reimplemented from UObject.
|
virtual |
Method that allows an actor to replicate subobjects on its actor channel. Must return true if any data was serialized into the bunch. This method is used only when bReplicateUsingRegisteredSubObjectList is false. Otherwise this function is not called and only the ReplicatedSubObjects list is used.
|
virtual |
Will reregister all components on this actor. Does a lot of work - should only really be used in editor, generally use UpdateComponentTransforms or MarkComponentsRenderStateDirty.
|
virtual |
Reset actor to initial state - used when restarting level without reloading.
Reimplemented in AAIController, AController, and APlayerController.
| void AActor::ResetOwnedComponents | ( | ) |
Force the Actor to clear and rebuild its OwnedComponents array by evaluating all children (recursively) and locating components In general this should not need to be called directly, but can sometimes be necessary as part of undo/redo code paths.
| void AActor::ResetPropertiesForConstruction | ( | ) |
Reset private properties to defaults, and all FRandomStream structs in this Actor, so they will start their sequence of random numbers again.
|
virtual |
Called on the actor before checkpoint data is applied during a replay. Only called if bReplayRewindable is set.
Reimplemented in AWorldPartitionReplay, and ALevelSequenceActor.
| void AActor::RouteEndPlay | ( | const EEndPlayReason::Type | EndPlayReason | ) |
Non-virtual function to evaluate which portions of the EndPlay process should be dispatched for each actor
Handles reading, writing, and reference collecting using FArchive. This implementation handles all FProperty serialization, but can be overridden for native variables.
Reimplemented from UObject.
Reimplemented in ARuntimeVirtualTextureVolume, ALODActor, ASceneCapture, APlayerController, AInstancedPlacementPartitionActor, ALevelInstance, APackedLevelActor, AWorldPartitionHLOD, AChaosSolverActor, and AInstancedFoliageActor.
Allows enabling/disabling collision for the whole actor
Sets the actor to be hidden in the game
| bNewHidden | Whether or not to hide the actor and all its components |
This should only be used by UNetActorFactory
| bool AActor::SetActorLocation | ( | const FVector & | NewLocation, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
Move the actor instantly to the specified location.
| NewLocation | The new location to teleport the Actor to. |
| bSweep | Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect. |
| Teleport | How we teleport the physics state (if physics collision is enabled for this object). If equal to ETeleportType::TeleportPhysics, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If equal to ETeleportType::None, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the location without teleporting will not update the location of simulated child/attached components. |
| OutSweepHitResult | The hit result from the move if swept. |
| bool AActor::SetActorLocationAndRotation | ( | FVector | NewLocation, |
| const FQuat & | NewRotation, | ||
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| bool AActor::SetActorLocationAndRotation | ( | FVector | NewLocation, |
| FRotator | NewRotation, | ||
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
Move the actor instantly to the specified location and rotation.
| NewLocation | The new location to teleport the Actor to. |
| NewRotation | The new rotation for the Actor. |
| bSweep | Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something. Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect. |
| Teleport | How we teleport the physics state (if physics collision is enabled for this object). If equal to ETeleportType::TeleportPhysics, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If equal to ETeleportType::None, physics velocity is updated based on the change in position (affecting ragdoll parts). If CCD is on and not teleporting, this will affect objects along the entire swept volume. Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the location without teleporting will not update the location of simulated child/attached components. |
| OutSweepHitResult | The hit result from the move if swept. |
| void AActor::SetActorRelativeLocation | ( | FVector | NewRelativeLocation, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| void AActor::SetActorRelativeRotation | ( | const FQuat & | NewRelativeRotation, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| void AActor::SetActorRelativeRotation | ( | FRotator | NewRelativeRotation, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
Set the actor's RootComponent to the specified relative scale 3d
| NewRelativeScale | New scale to set the actor's RootComponent to |
| void AActor::SetActorRelativeTransform | ( | const FTransform & | NewRelativeTransform, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| bool AActor::SetActorRotation | ( | const FQuat & | NewRotation, |
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| bool AActor::SetActorRotation | ( | FRotator | NewRotation, |
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
Set the Actor's rotation instantly to the specified rotation.
| NewRotation | The new rotation for the Actor. |
| Teleport | How we teleport the physics state (if physics collision is enabled for this object). If equal to ETeleportType::TeleportPhysics, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location). If equal to ETeleportType::None, physics velocity is updated based on the change in position (affecting ragdoll parts). Note that when teleporting, any child/attached components will be teleported too, maintaining their current offset even if they are being simulated. Setting the rotation without teleporting will not update the rotation of simulated child/attached components. |
Set this actor's tick functions to be enabled or disabled. Only has an effect if the function is registered This only modifies the tick function on actor itself
| bEnabled | Whether it should be enabled or not |
Sets the tick interval of this actor's primary tick function. Will not enable a disabled tick function. Takes effect on next tick.
| TickInterval | The rate at which this actor should be ticking |
| bool AActor::SetActorTransform | ( | const FTransform & | NewTransform, |
| bool | bSweep = false, |
||
| FHitResult * | OutSweepHitResult = nullptr, |
||
| ETeleportType | Teleport = ETeleportType::None |
||
| ) |
| void AActor::SetAutonomousProxy | ( | const bool | bInAutonomousProxy, |
| const bool | bAllowForcePropertyCompare = true |
||
| ) |
Sets whether or not this Actor is an autonomous proxy, which is an actor on a network client that is controlled by a user on that client.
Set whether or not we should make calls to PreReplication.
Set whether or not we should make calls to PreReplicationForReplay.
Sets the value of bCanBeDamaged without causing other side effects to this instance.
Set the current state as a faked networked physics state for physics replication Limited for use with actors using EPhysicsReplicationMode::PredictiveInterpolation only.
| bShouldSleep | Should the replication force the object to sleep |
|
inline |
Sets bHasRegisteredAllComponents true. bHasRegisteredAllComponents must be set true just prior to calling PostRegisterAllComponents().
Sets the value of bHidden without causing other side effects to this instance.
SetActorHiddenInGame is preferred preferred in most cases because it respects virtual behavior.
| void AActor::SetInstigator | ( | APawn * | InInstigator | ) |
Sets the value of Instigator without causing other side effects to this instance.
Set the lifespan of this actor. When it expires the object will be destroyed. If requested lifespan is 0, the timer is cleared and the actor will not be destroyed.
Set LOD Parent component for all of our components, normally associated with an ALODActor.
| InLODParent | This component used to compute visibility when hierarchical LOD is enabled. |
| InParentDrawDistance | Updates the MinDrawDistances of the LODParent |
|
static |
Modifies the global delegate used for handling MakeNoise
Set the frequency to throttle down to when replicated properties are changing infrequently.
| void AActor::SetNetAddressable | ( | ) |
Allows this actor to be net-addressable by full path name, even if the actor was spawned after map load.
Set the square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
| void AActor::SetNetDormancy | ( | ENetDormancy | NewDormancy | ) |
Puts actor in dormant networking state
Set the name of the net driver associated with this actor. Will move the actor out of the list of network actors from the old net driver and add it to the new list
| NewNetDriverName | name of the new net driver association |
Set the frequency at which this object will be considered for replication.
Set the owner of this Actor, used primarily for network replication.
| NewOwner | The Actor who takes over ownership of this Actor |
| void AActor::SetPhysicsReplicationMode | ( | const EPhysicsReplicationMode | ReplicationMode | ) |
Set the physics replication mode of this body, via EPhysicsReplicationMode
Specify a RayTracingGroupId for this actors. Components with invalid RayTracingGroupId will inherit the actors.
This function should only be used in the constructor of classes that need to set the RemoteRole for backwards compatibility purposes
| void AActor::SetReplicatedComponentNetCondition | ( | const UActorComponent * | ReplicatedComponent, |
| ELifetimeCondition | NetCondition | ||
| ) |
Change the network condition of a replicated component but only after BeginPlay. Using a network condition can allow you to filter to which client the component gets replicated to.
| void AActor::SetReplicatedMovement | ( | const FRepMovement & | InReplicatedMovement | ) |
Sets the value of ReplicatedMovement without causing other side effects to this instance.
Set whether this actor's movement replicates to network clients.
| bInReplicateMovement | Whether this Actor's movement replicates to clients. |
Set whether this actor replicates to network clients. When this actor is spawned on the server it will be sent to clients as well. Properties flagged for replication will update on clients if they change on the server. Internally changes the RemoteRole property and handles the cases where the actor needs to be added to the network actor list.
| bInReplicates | Whether this Actor replicates to network clients. |
Sets the value of bReplicateMovement without causing other side effects to this instance.
Sets the value of Role without causing other side effects to this instance.
| bool AActor::SetRootComponent | ( | USceneComponent * | NewRootComponent | ) |
Sets root component to be the specified component. NewRootComponent's owner should be this actor.
Only components owned by this actor can be used as a its root component.
Sets whether this actor can tick when paused.
| void AActor::SetTickGroup | ( | ETickingGroup | NewTickGroup | ) |
Sets the ticking group for this actor.
| NewTickGroup | the new value to assign |
|
virtual |
If true, actor is ticked even if TickType==LEVELTICK_ViewportsOnly
If true, actor is ticked even if TickType==LEVELTICK_ViewportsOnly
Reimplemented in ACameraRig_Crane, ACameraRig_Rail, and APlayerCameraManager.
|
virtual |
Returns true if actor can be selected as a sub selection of its root selection parent
| void AActor::SwapRoles | ( | ) |
Calls this to swap the Role and RemoteRole. Only call this if you know what you're doing!
|
protected |
Sync IsSimulatingPhysics() with ReplicatedMovement.bRepPhysics
|
virtual |
Apply damage to this actor.
| DamageAmount | How much damage to apply |
| DamageEvent | Data package that fully describes the damage received. |
| EventInstigator | The Controller responsible for the damage. |
| DamageCauser | The Actor that directly caused the damage (e.g. the projectile that exploded, the rock that landed on you) |
|
virtual |
Networking - Server - TearOff this actor to stop replication to clients. Will set bTearOff to true.
| void AActor::TearOffReplicatedSubObjectOnRemotePeers | ( | UActorComponent * | OwnerComponent, |
| UObject * | SubObject | ||
| ) |
Similar to the other tear off function but for subobjects owned by an ActorComponent
Stop replicating a subobject and tell actor channels who spawned a replica of this subobject to release ownership over it. This means that on the remote connection the network engine will stop holding a reference to the subobject and it's up to other systems to keep that reference active or the subobject will get garbage collected. Note that the subobject won't be replicated anymore, so it's final state on the client will be the one from the last replication update sent. If you are using the legacy subobject replication method (ReplicateSubObjects() aka bReplicateUsingRegisteredSubObjectList=false) make sure the subobject doesn't get replicated there either.
| SubObject | The SubObject to tear off |
Called from TeleportTo() when teleport succeeds
|
virtual |
Used for adding actors to levels or teleporting them to a new location. The result of this function is independent of the actor's current location and rotation. If the actor doesn't fit exactly at the location specified, tries to slightly move it out of walls and such if bNoCheck is false.
| DestLocation | The target destination point |
| DestRotation | The target rotation at the destination |
| bIsATest | is true if this is a test movement, which shouldn't cause any notifications (used by AI pathfinding, for example) |
| bNoCheck | is true if we should skip checking for encroachment in the world or other actors |
Function called every frame on this Actor. Override this function to implement custom logic to be executed every frame. Note that Tick is disabled by default, and you will need to check PrimaryActorTick.bCanEverTick is set to true to enable it.
| DeltaSeconds | Game time elapsed during last frame modified by the time dilation |
Reimplemented in ALightWeightInstanceManager, ALODActor, AAIController, ACameraRig_Crane, ACameraRig_Rail, and AConstraintsActor.
|
virtual |
Dispatches the once-per frame Tick() function for this actor
| DeltaTime | The time slice of this tick |
| TickType | The type of tick that is happening |
| ThisTickFunction | The tick function that is firing, useful for getting the completion handle |
Reimplemented in AController, APlayerController, AGameplayDebuggerCategoryReplicator, and ANavigationData.
|
virtual |
Networking - called on client when actor is torn off (bTearOff==true), meaning it's no longer replicated to clients.
| AActor::UE_DEPRECATED | ( | 5. | 5, |
| "Public access MinNetUpdateFrequency has been deprecated. Use SetMinNetUpdateFrequency() and GetMinNetUpdateFrequency() instead." | |||
| ) |
Used to determine what rate to throttle down to when replicated properties are changing infrequently
| AActor::UE_DEPRECATED | ( | 5. | 5, |
| "Public access to NetCullDistanceSquared has been deprecated. Use SetNetCullDistanceSquared() and GetNetCullDistanceSquared() instead." | |||
| ) |
Square of the max distance from the client's viewpoint that this actor is relevant and will be replicated.
| AActor::UE_DEPRECATED | ( | 5. | 5, |
| "Public access to NetUpdateFrequency has been deprecated. Use SetNetUpdateFrequency() and GetNetUpdateFrequency() instead." | |||
| ) |
How often (per second) this actor will be considered for replication, used to determine NetUpdateTime
| AActor::UFUNCTION | ( | BlueprintCallable | , |
| Category | = "Actor", |
||
| meta | = (ComponentClass = "/Script/Engine.ActorComponent"), |
||
| meta | = (DeterminesOutputType = "ComponentClass") |
||
| ) |
Gets all the components that inherit from the given class with a given tag.
| AActor::UFUNCTION | ( | BlueprintCallable | , |
| Category | = "Actor", |
||
| meta | = (ComponentClass = "/Script/Engine.ActorComponent"), |
||
| meta | = (DeterminesOutputType = "ComponentClass") |
||
| ) |
Searches components array and returns first encountered component with a given tag.
| AActor::UFUNCTION | ( | BlueprintCallable | , |
| Category | = "Actor", |
||
| meta | = (ComponentClass="/Script/Engine.ActorComponent"), |
||
| meta | = (DeterminesOutputType="ComponentClass") |
||
| ) | const |
Searches components array and returns first encountered component of the specified class
| AActor::UFUNCTION | ( | BlueprintCallable | , |
| meta | = (DisplayName = "AttachRootComponentTo (Deprecated)", ScriptNoExport, AttachLocationType = "KeepRelativeOffset"), |
||
| Category | = "Transformation" |
||
| ) |
DEPRECATED - Use AttachToComponent() instead
| AActor::UFUNCTION | ( | BlueprintCallable | , |
| meta | = (DisplayName = "AttachRootComponentToActor (Deprecated)", ScriptNoExport, AttachLocationType = "KeepRelativeOffset"), |
||
| Category | = "Transformation" |
||
| ) |
DEPRECATED - Use AttachToActor() instead
| AActor::UFUNCTION | ( | BlueprintCallable | , |
| meta | = (DisplayName="DetachActorFromActor (Deprecated)", ScriptNoExport), |
||
| Category | = "Transformation" |
||
| ) |
DEPRECATED - Use DetachFromActor() instead
| void AActor::UninitializeComponents | ( | ) |
Iterate over components array and call UninitializeComponent, called when the actor is ending play
Unregister all currently registered components
| bForReregister | If true, RegisterAllComponents will be called immediately after this so some slow operations can be avoided |
| void AActor::UnregisterAsFocalPointInPhysicsReplicationLOD | ( | ) | const |
Unregister this actors root components physics object from being a focal particle in Physics Repliocation LOD
| void AActor::UpdateAllReplicatedComponents | ( | ) |
Completely synchronizes the replicated components array so that it contains exactly the number of replicated components currently owned
| void AActor::UpdateComponentTransforms | ( | ) |
Update all components transforms
| void AActor::UpdateComponentVisibility | ( | ) |
Update all components visibility state
Queries world and updates overlap detection state for this actor.
| bDoNotifies | True to dispatch being/end overlap notifications when these events occur. |
|
protected |
Pushes the owning NetConnection for the actor and all of its children to the replication system. This information decides whether properties with owner conditionals are replicated or not.
| void AActor::UpdateReplicatedComponent | ( | UActorComponent * | Component | ) |
Called when the replicated state of a component changes to update the Actor's cached ReplicatedComponents array
|
protected |
Updates the ReplicatePhysics condition. That information needs to be pushed to the ReplicationSystem.
| ENGINE_API void AActor::UserConstructionScript | ( | ) |
Construction script, the place to spawn components and do other setup.
Used by the net connection to determine if a net owning actor should switch to using the shortened timeout value
Reimplemented in APlayerController.
Returns true if this actor has been rendered "recently", with a tolerance in seconds to define what "recent" means. e.g.: If a tolerance of 0.1 is used, this function will return true only if the actor was rendered in the last 0.1 seconds of game time.
| Tolerance | How many seconds ago the actor last render time can be and still count as having been "recently" rendered. |
|
friend |
|
friend |
|
friend |
|
friend |
| uint8 AActor::ActorCategory = 0 |
Project-specific field that help to categorize actors for reporting purposes
| FName EAttachLocation::Type AActor::AttachLocationType = EAttachLocation::KeepRelativeOffset |
|
protected |
Used for replicating attachment of this actor's RootComponent to another actor. This is filled in via GatherCurrentMovement() when the RootComponent has an AttachParent.
| TEnumAsByte<EAutoReceiveInput::Type> AActor::AutoReceiveInput |
Automatically registers this actor to receive input from a player.
| uint8 AActor::bActorSeamlessTraveled |
Indicates the actor was pulled through a seamless travel.
|
protected |
If false, the Blueprint ReceiveTick() event will be disabled on dedicated servers.
| uint8 AActor::bAllowTickBeforeBeginPlay |
Whether we allow this Actor to tick before it receives the BeginPlay event. Normally we don't tick actors until after BeginPlay; this setting allows this behavior to be overridden. This Actor must be able to tick for this setting to be relevant.
| uint8 AActor::bAlwaysRelevant |
Always relevant for network (overrides bOnlyRelevantToOwner).
|
protected |
Whether to use use the async physics tick with this actor.
| uint8 AActor::bBlockInput |
If true, all input on the stack below this actor will not be considered
|
protected |
If true, this actor can be put inside of a GC Cluster to improve Garbage Collection performance
| uint8 AActor::bCollideWhenPlacing |
This actor collides with the world when placing in the editor, even if RootComponent collision is disabled. Does not affect spawning,
| uint8 AActor::bEnableAutoLODGeneration |
Whether this actor should be considered or not during HLOD generation.
| uint8 AActor::bExchangedRoles |
Whether we have already exchanged Role/RemoteRole on the client, as when removing then re-adding a streaming level. Causes all initialization to be performed again even though the actor may not have actually been reloaded.
| uint8 AActor::bFindCameraComponentWhenViewTarget |
If true, this actor should search for an owned camera component to view through when used as a view target.
| uint8 AActor::bGenerateOverlapEventsDuringLevelStreaming |
If true, this actor will generate overlap Begin/End events when spawned as part of level streaming, which includes initial level load. You might enable this is in the case where a streaming level loads around an actor and you want Begin/End overlap events to trigger.
| uint8 AActor::bIgnoresOriginShifting |
Whether this actor should not be affected by world origin shifting.
| uint8 AActor::bIsEditorOnlyActor |
Whether this actor is editor-only. Use with care, as if this actor is referenced by anything else that reference will be NULL in cooked builds
| TArray<TObjectPtr<UActorComponent> > AActor::BlueprintCreatedComponents |
Array of ActorComponents that are created by blueprints and serialized per-instance.
|
protected |
Flag indicating we have checked initial simulating physics state to sync networked proxies to the server.
| uint8 AActor::bNetLoadOnClient |
This actor will be loaded on network clients during map load
| uint8 AActor::bNetStartup |
If true, this actor was loaded directly from the map, and for networking purposes can be addressed by its full path name
| uint8 AActor::bNetTemporary |
If true, when the actor is spawned it will be sent to the client but receive no further replication updates from the server afterwards.
| uint8 AActor::bNetUseOwnerRelevancy |
If actor has valid Owner, call Owner's IsNetRelevantFor and GetNetPriority
| uint8 AActor::bOnlyRelevantToOwner |
If true, this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
| uint8 AActor::bRelevantForLevelBounds |
If true, this actor's component's bounds will be included in the level's bounding box unless the Actor's class has overridden IsLevelBoundsRelevant
| uint8 AActor::bRelevantForNetworkReplays |
If true, this actor will be replicated to network replays (default is true)
| uint8 AActor::bReplayRewindable |
If true, this actor will only be destroyed during scrubbing if the replay is set to a time before the actor existed. Otherwise, RewindForReplay will be called if we detect the actor needs to be reset. Note, this Actor must not be destroyed by gamecode, and RollbackViaDeletion may not be used.
|
protected |
If true, this actor will replicate to remote machines
|
protected |
When true the replication system will only replicate the registered subobjects and the replicated actor components list When false the replication system will instead call the virtual ReplicateSubobjects() function where the subobjects and actor components need to be manually replicated.
| FName EAttachLocation::Type bool AActor::bWeldSimulatedBodies = true) |
| TArray<TObjectPtr<AActor> > AActor::Children |
Array of all Actors whose Owner is this actor, these are not necessarily spawned by UChildActorComponent
| float AActor::CreationTime |
The time this actor was created, relative to World->GetTimeSeconds().
| float AActor::CustomTimeDilation |
Allow each actor to run at a different time speed. The DeltaTime for a frame is multiplied by the global TimeDilation (in WorldSettings) and this CustomTimeDilation for this actor's tick.
| FRenderCommandFence AActor::DetachFence |
A fence to track when the primitive is detached from the scene in the rendering thread.
| float AActor::InitialLifeSpan |
How long this Actor lives before dying, 0=forever. Note this is the INITIAL value and should not be modified once play has begun.
| TObjectPtr<class UInputComponent> AActor::InputComponent |
Component that handles input for this actor, if input is enabled.
| int32 AActor::InputPriority |
The priority of this input component when pushed in to the stack.
Layers the actor belongs to. This is outside of the editoronly data to allow hiding of LD-specified layers at runtime for profiling.
| TEnumAsByte<enum ENetDormancy> AActor::NetDormancy |
Dormancy setting for actor to take itself off of the replication list without being destroyed on clients.
|
protected |
Used to specify the net driver to replicate on (NAME_None || NAME_GameNetDriver is the default net driver)
| float AActor::NetPriority |
Priority for this actor when checking for replication in a low bandwidth or saturated situation, higher priority means it is more likely to replicate
| int32 AActor::NetTag |
Internal - used by UNetDriver
| FActorBeginOverlapSignature AActor::OnActorBeginOverlap |
Called when another actor begins to overlap this actor, for example a player walking into a trigger. For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.
| FActorEndOverlapSignature AActor::OnActorEndOverlap |
Called when another actor stops overlapping this actor.
| FActorHitSignature AActor::OnActorHit |
Called when this Actor hits (or is hit by) something solid. This could happen due to things like Character movement, using Set Location with 'sweep' enabled, or physics simulation. For events when objects overlap (e.g. walking into a trigger) see the 'Overlap' event.
| FActorBeginCursorOverSignature AActor::OnBeginCursorOver |
Called when the mouse cursor is moved over this actor if mouse over events are enabled in the player controller.
| FActorOnClickedSignature AActor::OnClicked |
Called when the left mouse button is clicked while the mouse is over this actor and click events are enabled in the player controller.
| FActorDestroyedSignature AActor::OnDestroyed |
Event triggered when the actor has been explicitly destroyed.
| FActorEndCursorOverSignature AActor::OnEndCursorOver |
Called when the mouse cursor is moved off this actor if mouse over events are enabled in the player controller.
| FActorEndPlaySignature AActor::OnEndPlay |
Event triggered when the actor is being deleted or removed from a level.
| FActorOnInputTouchBeginSignature AActor::OnInputTouchBegin |
Called when a touch input is received over this actor when touch events are enabled in the player controller.
| FActorOnInputTouchEndSignature AActor::OnInputTouchEnd |
Called when a touch input is received over this component when touch events are enabled in the player controller.
| FActorBeginTouchOverSignature AActor::OnInputTouchEnter |
Called when a finger is moved over this actor when touch over events are enabled in the player controller.
| FActorEndTouchOverSignature AActor::OnInputTouchLeave |
Called when a finger is moved off this actor when touch over events are enabled in the player controller.
| FActorOnReleasedSignature AActor::OnReleased |
Called when the left mouse button is released while the mouse is over this actor and click events are enabled in the player controller.
| FTakeAnyDamageSignature AActor::OnTakeAnyDamage |
Called when the actor is damaged in any way.
| FTakePointDamageSignature AActor::OnTakePointDamage |
Called when the actor is damaged by point damage.
| FTakeRadialDamageSignature AActor::OnTakeRadialDamage |
Called when the actor is damaged by radial damage.
| TObjectPtr<AActor> AActor::Owner |
Owner of this Actor, used primarily for replication (bNetUseOwnerRelevancy & bOnlyRelevantToOwner) and visibility (PrimitiveComponent bOwnerNoSee and bOnlyOwnerSee)
| struct FActorTickFunction AActor::PrimaryActorTick |
Primary Actor tick function, which calls TickActor(). Tick functions can be configured to control whether ticking is enabled, at what time during a frame the update occurs, and to set up tick dependencies.
|
static |
Delegate for globally hooking ProccessEvent calls - used by a non-public testing plugin
|
protected |
Set of replicated components, stored as an array to save space as this is generally not very large
|
protected |
The component that defines the transform (location, rotation, scale) of this Actor in the world, all other components must be attached to this one somehow
| ESpawnActorCollisionHandlingMethod AActor::SpawnCollisionHandlingMethod |
Controls how to handle spawning this actor in a situation where it's colliding with something else. "Default" means AlwaysSpawn here.
|
protected |
Handle for efficient management of LifeSpanExpired timer
|
protected |
Condition for calling UpdateOverlaps() to initialize overlap state when loaded in during level streaming. If set to 'UseConfigDefault', the default specified in ini (displayed in 'DefaultUpdateOverlapsMethodDuringLevelStreaming') will be used. If overlaps are not initialized, this actor and attached components will not have an initial state of what objects are touching it, and overlap events may only come in once one of those objects update overlaps themselves (for example when moving). However if an object touching it does initialize state, both objects will know about their touching state with each other. This can be a potentially large performance savings during level loading and streaming, and is safe if the object and others initially overlapping it do not need the overlap state because they will not trigger overlap notifications.
Note that if 'bGenerateOverlapEventsDuringLevelStreaming' is true, overlaps are always updated in this case, but that flag determines whether the Begin/End overlap events are triggered.
1.9.8 