USkeletalMeshComponent

Physics-engine representation of aggregate which contains a physics asset instance with more than numbers of bodies.

Whether to use Animation Blueprint or play Single Animation Asset.

The AnimBlueprint class to use. Use 'SetAnimInstanceClass' to change at runtime.

Temporary storage for curves

The active animation graph program instance.

If true, AnimTree has been initialised.

Enables blending in of physics bodies whether Simulate or not

Whether the clothing simulation is suspended (not the same as disabled, we no longer run the sim but keep the last valid sim data around)

Can't collide with part of attached children if total collision volumes exceed 16 capsules or 32 planes per convex

Can't collide with part of environment if total collision volumes exceed 16 capsules or 32 planes per convex

OptimizationWhether animation and world transform updates are deferred.

Indicates that this SkeletalMeshComponent has deferred kinematic bone updates until next physics sim.

Disable cloth simulation and play original animation without simulation

If true, line checks will test against the bounding box of this skeletal mesh component and return a hit if there is a collision.

Uses skinned data for collision data.

If true, simulate physics for this component on a dedicated server.

Misc If true, force the mesh into the reference pose - is an optimization.

If true, there is at least one body in the current PhysicsAsset with a valid bone in the current SkeletalMesh

If true, the Location of this Component will be included into its bounds calculation (this can be useful when using SMU_OnlyTickPoseWhenRendered on a character that moves away from the root and no bones are left near the origin of the component)

True if calling TickPose() from Autonomous networking updates.

Temporary fix for local space kinematics.

It's worth trying this option when you feel that the current cloth simulation is unstable.

Skips Ticking and Bone Refresh.

Array of FBodyInstance objects, storing per-instance state about about each body.

Used for per poly collision.

If bForceRefPose was set last tick.

If true TickPose() will not be called from the Component's TickComponent function.

Pauses this component's animations (doesn't tick them, but still refreshes bones)

To save previous state

If true, propagates calls to ApplyAnimationCurvesToComponent for slave components, only needed if slave components do not tick themselves

If false, indicates that on the next call to UpdateSkelPose the RequiredBones array should be recalculated.

Reset the clothing after moving the clothing position (called teleport)

Bool that enables debug drawing of the skeleton before it is passed to the physics.

Indicates that simulation (if it's enabled) is entirely responsible for children transforms.

Whether to skip bounds update when interpolating.

Whether to skip UpdateKinematicBonesToAnim() when interpolating.

If true, this will Tick until disabled

If we should pass joint position to joints each frame, so that they can be used by motorized joints to drive the ragdoll based on the animation.

Controls whether blending in physics bones will refresh overlaps on this component, defaults to true but can be disabled in cases where we know anim->physics blending doesn't meaningfully change overlaps

On InitAnim should we set to ref pose (if false use first tick of animation data)

Cache AnimCurveUidVersion from Skeleton and this will be used to identify if it needs to be updated

Weight to blend between simulated results and key-framed positions if weight is 1.0, shows only cloth simulation results and 0.0 will show only skinned results

Class of the object responsible for

Whether we need to teleport cloth.

Array of FConstraintInstance structs, storing per-instance state about each constraint.

Simulation data written back to the component after the simulation has taken place This should only ever be written to during the clothing completion task.

Temporary array of bone indices required to populate component space transforms

Used to scale speed of all animations on this skeletal mesh.

If we are running physics, should we update non-simulated bones based on the animation bone positions.

If bEnableLineCheckWithBounds is true, scale the bounds by this value before doing line check.

Broadcast when the components anim instance is initialized.

Notification when constraint is broken.

Array of physical interactions for the frame.

Whether physics simulation updates component transform.

An instance created from the PostPhysicsBlueprint property of the skeletal mesh we're using, Runs after physics has been blended

Threshold for physics asset bodies above which we use an aggregate for broadphase collisions

Temporary array of bone indices required this frame. Filled in by UpdateSkelPose.

Index of the 'Root Body', or top body in the asset hierarchy.

Offset of the root bone from the reference pose. Used to offset bounding box.

Accumulate AddPhysicsBlendWeight to physics blendweight for all of the bones below passed in bone to be simulated

Add a collision source for the cloth on this component.

Given bounds InOutBounds, expand them to also enclose the clothing simulation mesh

Add a force to all rigid bodies below.

Add impulse to all single rigid bodies below. Good for one time instant burst.

Apply animation curves to this component

Set physics transforms for all bodies

If this component has a valid MasterPoseComponent then this function makes cloth items on the slave component take the transforms of the cloth items on the master component instead of simulating separately.

Take the results of the physics and blend them with the animation state (based on the PhysicsWeight parameter), and update the SpaceBases array.

Blend of Physics Bones with PhysicsWeight and Animated Bones with (1-PhysicsWeight)

Break a constraint off a Gore mesh.

Returns whether we're able to run a simulation (ignoring the suspend flag)

Check linear and angular thresholds for clothing teleport

Clears currently stored errors. Call before triggering anim notifies for a particular mesh.

Clear cached animation data generated for URO during evaluation

Clear all Morph Target that are set to this mesh

Parallel evaluation wrappers.

Callback when the parallel clothing task finishes, copies needed data back to component for gamethread

Computes the required bones in this SkeletalMeshComponent based on current SkeletalMesh, LOD and PhysicsAsset

Consume and return pending root motion from our internal anim instances (main, sub and post)

Consume and return pending root motion from our internal anim instances (main, sub and post)

Take extracted RootMotion and convert it from local space to world space.

Copy children's cloth collisions to parent, where parent means this component

Copy cloth collision sources to this, where parent means components above it in the hierarchy

Copy parent's cloth collisions to attached children, where parent means this component

Draw the currently clothing state, using the editor extender interface

Evaluates the post process instance from the skeletal mesh this component is using.

Extract collisions for cloth from this component (given a component we want to apply the data to)

Find if this component has collisions for clothing and return the results calculated by bone transforms

Find Constraint Name from index

Find Constraint Index from the name

Find instance of the constraint that matches the name supplied.

Find the root body index

Used to indicate we should force 'teleport' during the next call to UpdateClothState, This will transform positions and velocities and thus keep the simulation state, just translate it to a new pose.

Used to indicate we should force 'teleport and reset' during the next call to UpdateClothState.

Calls a function on each of the anim instances that this mesh component hosts, including linked and post-process instances

Iterates over all bodies below and executes Func. Returns number of bodies found

Access Curve Array for reading

Get the anim instance class via getter callable by sequencer.

Returns the animation instance that is driving the class (if available).

Returns the mass (in kg) of the given bone

This is explicit copy because this buffer is reused during evaluation we want to have reference and emptied during evaluation

Access cached component space transforms

Iterates through all bodies in our PhysicsAsset and returns the location of the closest bone associated with a body that has collision enabled.

Given a world position, find the closest point on the physics asset.

Get the current clothing simulation (read only)

Get the current interactor for a clothing simulation, if the current simulation supports runtime interaction.

Get/Set the max distance scale of clothing mesh vertices

If the vertex index is valid for simulated vertices, returns the position in world space

Get the current simulation data map for the clothing on this component.

Gets the current Angular state for a named bone constraint

Gets whether the post process blueprint is currently disabled for this component

Get Access to the current editable Curve Array - uses same buffer as space bases

Returns the a tagged linked instance node.

Returns all tagged linked instance nodes that match the tag.

Get the anim instances linked to the main AnimScriptInstance

Gets the first layer linked instance corresponding to the specified class

Gets the layer linked instance corresponding to the specified group

Get Morph target with given name

Animation play functions

Animation play functions

Returns the active post process instance is one is available.

Returns the center of mass of the skeletal mesh, instead of the root body's location

Gets the teleportation distance threshold.

Gets the teleportation rotation threshold.

Utility which returns total mass of all bones below the supplied one in the hierarchy (including this one).

Return true if currently updating in editor is true this is non BP because this is only used for slave component to detect master component ticking state

Store cloth simulation data into OutClothSimData

Management function for if we want to do an evaluation but may already be running one bBlockOnTask - if true and we are currently performing parallel eval we wait for it to finish bPerformPostAnimEvaluation - if true and we are currently performing parallel eval we call PostAnimEvaluation too return true if parallel task was running.

Returns whether there are any valid instances to run, currently this means whether we have have an animation instance or a post process instance available to process.

Animation

Initialize PhysicsAssetInstance for the physicsAsset

Initialize SkelControls

Instantiates bodies given a physics asset.

Instantiates bodies given a physics asset like InstantiatePhysicsAsset but instead of reading the current component state, this reads the ref-pose from the reference skeleton of the mesh.

Checks whether or not gravity is enabled on the given bone.

Gets whether or not the clothing simulation is currently suspended

Animation play functions

Are we currently within PostAnimEvaluation.

Returns whether we are currently trying to run a parallel animation evaluation task.

Given a world position, find the closest point on the physics asset.

Runs through all layer nodes, attempting to find layer nodes that are implemented by the specified class, then sets up a linked instance of the class for each.

Runs through all nodes, attempting to find linked instance by name/tag, then sets the class of each node if the tag matches

Notifier when look at control goes beyond of limit - candidate for delegate

This overrides current AnimationData parameter in the SkeletalMeshComponent.

Parallel evaluation wrappers.

Runs the animation evaluation for the current pose into the supplied variables PerformAnimationProcessing runs evaluation based on bInDoEvaluation.

Animation play functions

Animation play functions

Checked whether we have already ticked the pose this frame

Recalculates the RequiredBones array in this SkeletalMeshComponent based on current SkeletalMesh, LOD and PhysicsAsset.

Recalculates the AnimCurveUids array in RequiredBone of this SkeletalMeshComponent based on current required bone set Is called when Skeleton->IsRequiredCurvesUpToDate() = false

Destroys and recreates the clothing actors in the current simulation

Handle registering our pre cloth tick function.

Handle registering our end physics tick function.

Register/Unregister for physics state creation callback

Register / Unregister delegates called when the skeletal mesh property is changed

Register/Unregister for teleport callback

Remove all clothing actors from their simulation and clear any other necessary clothing data to leave the simulations in a clean state

Remove clothing actors from their simulation

Remove a cloth collision source defined by a component

Remove a cloth collision source defined by both a component and a physics asset

Subclasses such as DebugSkelMeshComponent keep track of errors in the anim notifies so they can be displayed to the user.

Allows you to reset bodies Simulate state based on where bUsePhysics is set to true in the BodySetup.

By reset, it will allow all the curves to be evaluated

Informs any active anim instances (main instance, linked instances, post instance) that a dynamics reset is required for example if a teleport occurs.

Reset the teleport mode of a next update to 'Continuous'

Reset Root Body Index

Resumes a previously suspended clothing simulation, teleporting the clothing on the next tick

Set all of the bones below passed in bone to be simulated

Set all of the bones below passed in bone to be simulated

Set the movement channel of all bodies

Set the rigid body notification state for all bodies.

Set bSimulatePhysics to true for all bone bodies.

Set Angular Drive motors params for all constraint instances

Enable or Disable AngularPositionDrive.

Enable or Disable AngularVelocityDrive.

Resets, and then only allow the following list to be allowed/disallowed

Sets whether or not to allow rigid body animation nodes for this component

Sets the Angular Motion Ranges for a named bone

Animation play functions

Below are the interface to control animation when animation mode, not blueprint mode

Set the anim instance class.

Set the anim instance class.

Changes the value of bNotifyRigidBodyCollision for a given body

Sets the constraint profile properties (limits, motors, etc...) to match the constraint profile as defined in the physics asset.

Sets the constraint profile properties (limits, motors, etc...) to match the constraint profile as defined in the physics asset for all constraints.

Sets whether the post process blueprint is currently running for this component.

Enables or disables gravity for the given bone.

Enables or disables gravity to all bodies below the given bone.

Disable physics blending of bones

Change whether to force mesh into ref pose (and use cheaper vertex shader)

Set Morph Target with Name and Value(0-1)

Enable or Disable AngularPositionDrive based on a list of bone names

Enable or Disable AngularVelocityDrive based on a list of bone names

Changes the value of bNotifyRigidBodyCollision on all bodies below a given bone

This is global set up for setting physics blend weight This does multiple things automatically If PhysicsBlendWeight == 1.f, it will enable Simulation, and if PhysicsBlendWeight == 0.f, it will disable Simulation.

Animation play functions

Animation play functions

Set Root Body Index

Sets the teleportation distance threshold.

Sets the teleportation rotation threshold.

Sets whether or not to force tick component in order to update animation and refresh transform for this component This is supported only in the editor

If VisibilityBasedAnimTickOption == EVisibilityBasedAnimTickOption::OnlyTickMontagesWhenNotRendered Should we tick Montages only?

Returns whether we need to run the Cloth Tick or not.

Conditions used to gate when post process events happen.

We detach the Component once we are done playing it.

Takes a snapshot of this skeletal mesh component's pose and saves it to the specified snapshot.

Animation play functions

Stops simulating clothing, but does not show clothing ref pose.

Turn off all physics and remove the instance.

Terminate physics on all bodies below the named bone, effectively disabling collision forever.

Tick Animation system

Tick Clothing Animation , basically this is called inside TickComponent

Toggles whether the post process blueprint will run for this component

If this component has a valid MasterPoseComponent and has previously had its cloth bound to the MCP, this function will unbind the cloth and resume simulation.

Runs through all layer nodes, attempting to find layer nodes that are currently running the specified class, then resets each to its default value.

Update the bone mapping on each body instance.

Updates cloth collision inside the cloth asset (from a physics asset).

Update the clothing simulation state and trigger the simulation task

Updates cloth collision outside the cloth asset (environment collision, child collision, etc...) Should be called when scene changes or world position changes

Update bHasValidBodies flag

Iterate over each physics body in the physics for this mesh, and for each 'kinematic' (ie fixed or default if owner isn't simulating) one, update its transform based on the animated transform.

Look up all bodies for broken constraints.

Iterate over each joint in the physics for this mesh, setting its AngularPositionTarget based on the animation information.

Validates the animation asset or blueprint, making sure it is compatible with the current skeleton

Allocate Transform Data array including SpaceBases, BoneVisibilityStates

Clear any applied ref pose override

Parallel Tick Pose In the case where we do not want to refresh bone transforms (and would therefore not normally kick off a parallel eval task) we perform this 'mini tick' that kicks off the task.

Finalize bone transform of this current tick After this function, any query to bone transform should be latest of the data

Hides the specified bone. You can also set option for physics body.

Update functions Refresh Bone Transforms Each class will need to implement this function Ideally this function should be atomic (not relying on Tick or any other update.)

Override the Physics Asset of the mesh.

Apply an override for the current mesh ref pose

Change the SkeletalMesh that is rendered for this Component.

Should tick pose (by calling TickPose) in Tick

Should update transform in Tick

Tick Pose, this function ticks and do whatever it needs to do in this frame, should be called before RefreshBoneTransforms

Unhides the specified bone.

Update the PredictedLODLevel and MaxDistanceFactor in the component from its MeshObject.

Update Slave Component. This gets called when MasterPoseComponent!=NULL

Add a force to all bodies in this component, originating from the supplied world-space location.

Add an impulse to all rigid bodies in this component, radiating out from the specified position.

Returns the calculated mass in kg.

Determines whether or not the simulate physics setting can be edited interactively on this component

Determines whether the supplied bounding box intersects with the component.

Determines whether the supplied frustum intersects with the component.

Override this method for custom behavior for ComponentOverlapComponent()

Test the collision of the supplied component at the supplied location/rotation, and determine the set of components that it overlaps

Collects custom navigable geometry of component.

Returns BodyInstance of the component.

Return the BodySetup to use for this PrimitiveComponent (single body case)

Called to get the Component To World Transform from the Root BodyInstance This needs to be virtual since SkeletalMeshComponent Root has to undo its own transform Without this, the root LocalToAtom is overridden by physics simulation, causing kinematic velocity to accelerate simulation

Returns the mass of this component in kg.

Returns The square of the distance to closest Body Instance surface.

Adds the bodies that are currently welded to the OutWeldedBodies array

Returns if any body in this component is currently awake and simulating.

Returns whether this component is affected by gravity.

Trace a ray against just this component.

Called when the BodyInstance ResponseToChannels, CollisionEnabled or bNotifyRigidBodyCollision changes, in case subclasses want to use that information.

Test the collision of the supplied shape at the supplied location, and determine if it overlaps this component.

Force all bodies in this component to sleep.

Updates the renderer with the center of mass data

Change the mass scale used fo all bodies in this component

Set the linear velocity of all bodies in this component.

Set the position of all bodies in this component.

Set the rotation of all bodies in this component.

Set the rotation of all bodies in this component.

Set whether all bodies in this component should use Continuous Collision Detection

Set the collision object type on the skeletal mesh

Enables/disables whether this component is affected by gravity.

Changes the value of bNotifyRigidBodyCollision

Changes the current PhysMaterialOverride for this component.

Sets whether or not a single body should use physics simulation, or should be 'fixed' (kinematic).

Trace a shape against just this component.

Internal function that updates physics objects to match the component collision settings.

Ensure simulation is running for all bodies in this component.

Calculate the bounds of the component. Default behavior is a bounding box/sphere of zero size.

Skeletal mesh component should not be able to have its mobility set to static

Returns whether the specified body is currently using physics simulation

Override this method for custom behavior for MoveComponent

Native callback when this component is moved

Queries world and updates overlap tracking state for this component.

Used to detach physics objects before simulation begins.

Initializes the component.

Used to create any physics engine information for this component

Used to shut down and physics engine structure for this component

Called when a component is registered, after Scene is set, but before CreateRenderState_Concurrent or OnCreatePhysicsState are called.

Called when a component is unregistered.

Virtual call chain to register all tick functions

Return true if CreatePhysicsState() should be called.

Function called every frame on this ActorComponent.

Get the size of the object/resource for use in memory tools or to display to artists/LDs in the Editor This is the extended version which separates up the used memory into different memory regions (the actual definition of which may be platform specific).

Called when the object was loaded from another class via active class redirects.

Called when a property on this object has been modified externally

Do any object-specific cleanup required immediately after loading an object.

Handles reading, writing, and reference collecting using FArchive.

Animation anim: Matinee related data start - this needs to be replaced to new system.

This property is deprecated. Please use AnimClass instead

Direct access to this property is deprecated, please use GetBoneSpaceTransforms instead. We will move to private in the future.

Water: 1.0 Cotton: 0.155 Wool: 0.13 Silk: 0.133

Direct access to this property is deprecated and the array is no longer used. Storage is now in LinkedInstances. Please use GetLinkedAnimInstances() instead.

Function renamed, please use UnlinkAnimClassLayers

This function is deprecated. Please use GetAllowedAnimCurveEvaluate instead. Note that the meaning is reversed.

Function renamed, please use GetLinkedAnimLayerInstanceByClass

Function renamed, please use GetLinkedLayerInstanceByGroup

This function is deprecated. Please use GetLinkedAnimGraphInstanceByTag

This function is deprecated. Please use GetLinkedAnimGraphInstanceByTag

Function renamed, please use GetLinkedAnimGraphInstancesByTag

This function is deprecated. Please use SetAnimClass instead.

This function is deprecated. Please use SetAllowAnimCurveEvaluation instead. Note that the meaning is reversed.

Function renamed, please use LinkAnimClassLayers

Function renamed, please use LinkAnimGraphByTag