text
stringlengths
0
17.2k
Key End Effectors Match Name Array
List of bone names to treat with higher precision, in addition to any bones with sockets.
Force Recompression
If enabled, this setting will forcibly recompress every animation. Disable this setting before checking in your project, otherwise the Engine will recompress all animations each time the project is opened, affecting the performance negatively for all users of this project.
Enable Performance Log
If true, recompression will log performance information.
Strip Animation Data on Dedicated Server
If true, animation track data will be stripped from dedicated server cooked data.
Tick Animation on Skeletal Mesh Init
When this property is enabled, an Animation-Tick will occur upon the initialization of a Skeletal Mesh, which is a behavior known as Zero-Ticking. This property is disabled by default. Zero-Ticking Animations during a Skeletal Mesh initialization was the default behavior for all versions of Unreal Engine before 4.19.
Bone Timecode Custom Attribute Name Settings
Names that identify bone custom attributes representing the individual components of a timecode and a subframe along with a take name. These will be included in the list of bone custom attribute names to import.
Bone Custom Attributes Names
List of custom attributes to import directly on their corresponding bone. The meaning field is used to contextualize the attribute name and customize tooling for it.
Bone Names With Custom Attributes
List of bone names for which all custom attributes are directly imported on the bone.
Attribute Blend Modes
Custom Attribute-specific blend types (by name). Override Blend
Default Attribute Blend Mode
Default Custom Attribute blend type.
Transform Attribute Names
Names to match against when importing FBX node transform curves as attributes (can use ? and * wildcards).
Mirror Find Replace Expressions
Find and Replace Expressions used for mirroring.
Remarks
You can choose from the following options:
Actor Network Dormancy
Actor Network Dormancy (AActor::NetDormancy) is one of the most impactful server optimizations a multiplayer project can make, potentially saving multiple milliseconds of server CPU time per frame — especially if your project has a large number of replicated actors that don't change often. During a net update, the NetDriver gathers a list of all the replicated actors relevant to a connection, then iterates over these actors and their properties to determine what has changed and should be sent to the client. An actor's network dormancy controls whether the actor is added to the connection's gathered actors list. Dormant actors are not added to the list while awake (not dormant) actors are added to the list. Iterating over actors and their properties can be expensive, especially for projects with a large number of replicated actors. As a result of this, effectively using network dormancy to filter actors out of the considered for replication list can be a vital optimization for multiplayer projects.
Follow these steps to use network dormancy effectively in your project:
Set the actor's AActor::NetDormancy to ENetDormancy::DORM_DormantAll in its constructor:
When a replicated actor is marked as dormant, the NetDriver is able to skip adding it to the connection's gathered actors list. This saves time otherwise spent considering the actor for replication and comparing its properties. Until a dormant actor is awoken or has its dormancy flushed, the actor is not considered for replication; therefore, any changes to its replicated properties are not sent to clients. It is also important to note that an actor's replicated state should not change while it is dormant, as these changes might be lost when the actor is awoken. This means that actors that change their replicated properties infrequently are good candidates for dormancy. Actors that require frequent updates, such as pawns, are not likely to benefit, and, due to the additional overhead of changing or flushing an actor's dormancy state, doing this too frequently might be even less performant than just keeping the actor awake.
While the actor channel for a replicated actor will close when it goes dormant, dormant actors still exist on both the server and client. This is different to how Actor Relevancy is handled: dynamic, replicated actors are destroyed on the client when they are no longer relevant. It is worth noting that dormant actors are not checked for relevancy, so if a dormant actor would otherwise go out of relevancy on a client, it is not destroyed on that client (unless you are using a Replication Graph with the Net.RepGraph.DormantDynamicActorsDestruction console variable enabled).
An actor's dormancy state is stored in its AActor::NetDormancy property. This property can be changed by calling AActor::SetNetDormancy. While AActor::NetDormancy is public, this property should not be set directly outside of the actor's constructor. AActor::SetNetDormancy should be called to change an actor's dormancy, as this function also handles notifying the NetDriver of the change.
There are five dormancy states described in the ENetDormancy enumeration class (defined in EngineTypes.h). The table below describes these dormancy states:
This actor never goes dormant.
This is not enforced by the dormancy system. An actor marked as ENetDormancy::DORM_Never can be made dormant.
This actor is dormant on some connections, but not all. Use AActor::GetNetDormancy to determine which connections the actor is dormant for.
We do not recommend that you use partial dormancy. Partial dormancy is planned for deprecation.
This actor is initially dormant on all connections.
This should only be used by actors initially placed in the map.
There are two primary ways to wake a dormant actor:
You can wake a dormant actor by calling AActor::SetNetDormancy(ENetDormancy::DORM_Awake). While the actor is awake, it replicates as normal until it is set back to dormant by calling AActor::SetNetDormancy(ENetDormancy::DORM_DormantAll) from the actor. This is useful in cases where a dormant actor is going to begin changing every frame, such as a stationary object beginning to move.
Once a statically placed, initially dormant actor has been awoken, you should not set it back to ENetDormancy::DORM_Initial. Use ENetDormancy::DORM_DormantAll instead.
You can also replicate changes for a dormant actor by calling AActor::FlushNetDormancy on the actor. This forces the actor to replicate at least one update to all connections on which it is relevant without actually changing its dormancy state. There is one exception to this, if you call AActor::FlushNetDormancy on an actor that has its AActor::NetDormancy set to ENetDormancy::DORM_Initial, the call to AActor::FlushNetDormancy changes the actor's dormancy to ENetDormancy::DORM_DormantAll.
Calling AActor::ForceNetUpdate on a dormant actor will also call AActor::FlushNetDormancy, while also ensuring the actor is considered for replication on the next net update. This is useful for infrequent, one-off updates to an actor that happen in a single frame.
After an actor's dormancy is flushed (or when it is set dormant after being awake), the actor may send multiple updates as it does not immediately become dormant. Instead, the actor continues to replicate until it and its subobjects have no more unacknowledged changes that should be sent. If dormancy hysteresis is enabled, it also keeps the actor from immediately going dormant (see UActorChannel::ReadyForDormancy and FObjectReplicator::ReadyForDormancy).
AActor::SetNetDormancy(ENetDormancy::DORM_Awake) or AActor::FlushNetDormancy should be called on an actor before making changes to its replicated properties. Waking a dormant actor reinitializes the actor's shadow state (the state used to compare what properties have changed and need to be replicated) by copying all the current values for its replicated properties. This is also why an actor's replicated state shouldn't be changed while it is dormant, as when the actor is awoken, these changes won't be detected when comparing its properties for replication.
In most cases, however, calling it after making changes might still result in those changes being replicated as expected. However, this behavior is an implementation detail, and you shouldn't rely on it. For instance, there are certain situations, such as when changing a dormant fast array, where calling AActor::FlushNetDormancy after changing the property results in the changes not being replicated at all.
When using dormancy with a Blueprint actor, the actor automatically calls AActor::FlushNetDormancy when you set a replicated property.
This does not happen automatically when setting replicated properties on an ActorComponent blueprint, but we are working to make this behavior consistent.