Home › System plugins › AFS_UX_Grip

System

AFS_UX_Grip

The grip stack: pickup, latch, drag and physics interactions, grip sockets, multi-hand carries, hand grab abilities and custom hand poses.

What it gives you

Pick up and carry objects with either or both hands
Latch interactions for levers, knobs, drawers and dials
Socket-based hand placement with distance priority
Custom hand poses per object

Requires

AFM_Abilities AFM_AutoDestroy AFM_Replication AFM_State AFS_Core_Highlight AFS_Core_Snapping AFS_Libraries AFS_UX_Select

Required by

AFE_Showroom AFM_Spawner AFS_UISpace_Hand AFS_UX_Laser AFS_UX_Overlap AF_Examples

20 assets126 API members

Description

Grip is the largest interaction stack in the framework, because "grabbing" covers several genuinely different behaviours.

Pickup detaches the object and carries it. Latch leaves the object in place and lets the hand drive it along a constrained axis — this is what levers, knobs and drawers use. Latch Drag and Latch Physics specialise that for drag-driven and physics-driven cases.

Which hand attaches where is decided by sockets. BPC_Socket_Grip components mark valid attachment points; when several are in range the closest one wins, scored by distance within Max Attach Distance. BPC_PickupCoordinator handles the case where two hands hold the same object.

Setup

Enable AFS_UX_Grip. It requires AFM_Abilities, AFS_Core_Highlight and AFA_Sounds.
On the pawn, confirm BPC_PawnAbility_Grip is present.
On each motion controller, confirm BPC_ControllerAbility_Hand_Grab is present.
On the object, add the interaction component matching the behaviour you want — BPC_Interaction_Grip_Pickup or one of the _Latch variants.
Add BPC_Socket_Grip components where hands should attach, keeping the Grip_ name prefix.

Usage

Making something carryable

See Make an object grabbable.

Making a lever or knob

Use BPC_Interaction_Grip_Latch and pair it with a BPC_State_Drag component configured for the axis. The hand drives the drag; the state component reports the value, and UI can bind to it.

Two-handed carries

Add BPC_PickupCoordinator to the object. It arbitrates between hands and decides grab type, upright constraint and controller snapping.

Restricting which hand or socket

Set Required Prefix on the interaction to accept only sockets with a matching prefix. Set Allow Grip If Occupied to false to prevent stealing an object from the other hand.

Auto-grip

Set Should Auto Grip to have hand-tracked palms grab the object on contact without an explicit input. Only meaningful for hand motion controllers.

Custom poses

Fill Custom Hand Poses Left and Custom Hand Poses Right, keyed by socket name. The hand adopts the pose when it snaps to that socket.

Key properties

Property When to change

Max Attach Distance How near a hand must be to a socket to use it. Raise for large objects with sparse sockets

Min Detach Distance How far the hand must travel from the object before it is dropped automatically

Required Prefix To make this object accept only certain sockets

Allow Grip If Occupied Set false to stop the other hand stealing the object

Should Auto Grip For hand-tracked grabbing on contact

Haptics Grip / Haptics Release Feedback curves on grab and release

Property	When to change
`Max Attach Distance`	How near a hand must be to a socket to use it. Raise for large objects with sparse sockets
`Min Detach Distance`	How far the hand must travel from the object before it is dropped automatically
`Required Prefix`	To make this object accept only certain sockets
`Allow Grip If Occupied`	Set false to stop the other hand stealing the object
`Should Auto Grip`	For hand-tracked grabbing on contact
`Haptics Grip` / `Haptics Release`	Feedback curves on grab and release

Extending

Derive from BPC_Interaction_Grip for a new grip behaviour, and override CanBeGripped to change how candidates are scored. Implement Interface_Grip on the owning actor to veto conditionally without subclassing.

Implement Interface_GrabbingActor on your own ability if it should be able to hold framework objects.

Multiplayer notes

Multiplayer

Add BPC_Replication_Actor to carried objects. Authority follows the player who picks the object up, handled automatically by CheckIfOwnerChanged. Latch interactions replicate through the associated state component rather than through transform replication.

Example map

Map_Examples_Grip covers pickup, latch, drag and multi-axis. Map_Examples_Interaction_Hands adds hand tracking and custom poses.

Troubleshooting

The hand snaps to the wrong place. Sockets are matched by distance — add a socket nearer the intended grip point, or narrow Max Attach Distance.

Two hands cannot hold the object. It needs a BPC_PickupCoordinator.

The object drops immediately. Min Detach Distance is too small for the object's size, or the hand collision is pushing the object away — set hand collision to none while carrying via MCHands_SetHandCollision.

API reference

Every blueprint asset in this plugin. Expand an asset to see its members.

Components/ControllerAbilities

BPC_ControllerAbility_Hand_Grab25 members

extends BPC_ControllerAbility · implements Interface_GrabbingActor

Kind	Name	Signature	Description
var	`SearchDistance`Settings	`float`	How far ahead of the hand's grab point the sphere trace looks for something to grip, in centimetres.
var	`SearchRadius`Settings	`float`	Radius of the sphere trace the hand sweeps when looking for a grippable component, in centimetres. Widen it to make grabbing more forgiving, at the cost of catching the wrong object in cluttered scenes.
var	`Debug`Debug	`bool`	Draws the hand's grip search in the world so you can see what the trace is hitting. Leave off outside of development.
var	`Mapping Contexts Default`Input	`ST_MappingContext_Side`	Input mapping contexts applied for the left and right hand, giving this hand its grab bindings. The ability's own side decides which of the two is used.
var	`Mapping Contexts ButtonForward`Input	`ST_MappingContext_Side`	Input mapping contexts added while something is held, so this hand's buttons are forwarded to the held object instead of driving the pawn. Removed again as soon as the grip is released.
var	`GripHandPoses_Left`Poses	`Map<name, AnimSequenceBase>`	Fallback left-hand poses, keyed by the third underscore-separated part of the grip socket name, so a socket called Grip_L_Handle looks up Handle. Consulted only when the gripped component supplies no pose of its own; unmatched sockets fall back to the default grip pose.
var	`GripHandPoses_Right`Poses	`Map<name, AnimSequenceBase>`	Fallback right-hand poses, keyed the same way as the left-hand map. Consulted only when the gripped component supplies no pose of its own.
fn	`getAllAttachedActors`	`(out Actors: Actor[])`	Returns the held actor, but only when the grip is a pickup; latched actors are deliberately left out so the motion controller does not treat them as carried. Comes back empty when the hand is holding nothing.
fn	`DetermineGripSpecifics`Grip	`(GripComponent: BPC_Interaction_Grip, Socket: ST_Socket, ImpactLocation: Vector)`	Works out how to take hold of a grip component and then starts the grab. Latches go straight through with the pose for the chosen socket; pickups use the socket's relative transform when there is one, and otherwise position the helper handles from the impact point so the object keeps its offset from the palm.
fn	`TranslateSocketToHandPose`Poses	`(GripComponent: BPC_Interaction_Grip, Socket: name, out GripPose: AnimSequenceBase)`	Returns the hand pose to apply for a grip socket, preferring the pose the gripped component defines for this hand, then this ability's own pose map, and finally the default grip pose.
fn	`CheckAutoGrip`Grip	`()`	Starts or stops the auto-pickup polling loop from the current state. Polling runs only while the ability is active, nothing is already held and the cooldown after a release has expired.
event	`InitiateControllerAbility`	`(Pawn: Pawn, MotionController: Actor, Side: E_Side)`	Called by the motion controller once it has spawned this ability, handing over the owning pawn, controller actor and hand side. Extend it to add setup that needs to know which hand the ability belongs to.
event	`GrabbingActor_Release`	`()`	Lets go of whatever this hand is holding: clears the replicated grab definition on client and server, resets the hand pose and socket snap, removes the button-forwarding context, gives up the controller's focus and re-arms auto-pickup. Does nothing when the hand is empty.
event	`GrabbingActor_Grip`	`(GripComponent: BPC_Interaction_Grip)`	Takes hold of the given grip component from where the hand currently is, picking the closest grip socket for this hand side. Use it to make the hand grab something without the player reaching for it.
event	`Server_GrabActor`	`(GripComponent: BPC_Interaction_Grip, DesiredRelativeTransform: Transform, GripSocket: ST_Socket)`	Runs on the server to record the held component, its relative transform and the grip socket in the replicated grab definition, which is what makes remote clients replay the grab.
event	`Server_ReleaseGrab`	`()`	Runs on the server to clear the replicated grab definition, which drops the actor on every remote client.
event	`GrabActor`	`(GrabComponent: BPC_Interaction_Grip, DesiredRelativeTransform: Transform, HandPose: AnimSequenceBase, GripSocket: ST_Socket)`	Carries out the grab: releases anything already held on either side, stores the grab definition, applies the hand pose and socket snap, takes focus of the controller and adds the button-forwarding context. Pickups are then held by the scene handles or by the physics handle depending on their grab type, while latches spawn a latching helper.
event	`Tick_AutoPickup`	`(Condition: bool)`	Runs the polling loop that watches for an open hand near an auto-grip object. Driven by Check Auto Grip rather than called directly; passing false ends the loop.
event	`TemporaryRemoveHandCollision`	`()`	Switches the hand mesh to no collision and restores query and physics collision a second later, unless something has been gripped in the meantime. Used after a release so the dropped object cannot shove the hand away.
event	`ButtonForwardKey`	`(Key: E_Controller_Buttons, Set: bool)`	Forwards a button press or release on this hand to the held component, along with the Source Info of the hand. Called by the hand's grip helper actor from the forwarded input actions rather than directly.
event	`ButtonForwardThumbstick`	`(Axis: Vector2D)`	Forwards this hand's thumbstick axes to the held component, along with the Source Info of the hand.
event	`ButtonForwardTriggerAxis`	`(Value: float)`	Forwards this hand's analogue trigger value to the held component, so a held object can read a continuous squeeze.
event	`GrabbingAbility_GripNewActorWithSameProperties`	`(GripComponent: BPC_Interaction_Grip)`	Moves this hand's grip onto a different component, keeping the relative transform, socket and current hand pose. Used when an object swaps itself for another actor while it is being held.
event	`OnDestroyed_Event_1`	`(DestroyedActor: Actor)`	Internal handler that releases the grip when the held actor is destroyed.
event	`Server_SetPickupTransform`	`(PickupTransform: Transform)`	Runs on the server to store the transform this hand wants the held actor to have. Replicated so the pickup coordinator can average it with the other hands holding the same actor.

Components/Interactions

BPC_Interaction_Grip20 members

extends BPC_Interaction

Kind	Name	Signature	Description
var	`Haptics_Grip`Haptics	`HapticFeedbackEffect_Curve`	Haptic curve played on the acting hand when this interaction is gripped. Leave empty for no feedback.
var	`Haptics_Release`Haptics	`HapticFeedbackEffect_Curve`	Haptic curve played on the acting hand when the grip is released. Leave empty for no feedback.
var	`Sound_Grip`Sound\|Grip	`SoundBase`	Sound played at the centre of the owning actor when it is gripped. Leave empty for a silent grab.
var	`Sound_Release`Sound\|Grip	`SoundBase`	Sound played at the centre of the owning actor when the grip is released. Leave empty for a silent release.
var	`ShouldAutoGrip`Conditions	`bool`	Whether an open hand closes around this object on its own, without the grip button. Only the hand motion controller reads it; laser, desktop and mobile grabbing ignore it entirely.
var	`AllowGripIfOccupied`Conditions	`bool`	Whether a second ability may take this object while another already holds it. With it on the grip check ignores the current holder and the previous ability is released as the new grab starts; with it off the check returns no priority for as long as somebody is holding on.
var	`MaxAttachDistance`Settings	`float`	Furthest a grip socket may sit from the trace hit, in centimetres, for this object to offer that socket. Despite the wording of the old tooltip it bounds the initial socket search, not the automatic detach, which is Min Detach Distance.
var	`RequiredPrefix`Conditions	`name`	Socket prefix an ability must be searching with before this object looks for a grip socket. When the prefix does not match, the grip is still accepted but with no socket and the lowest priority. Leave as None to accept any prefix.
var	`MinDetachDistance`Settings	`float`	Distance in centimetres between the holder and the gripped socket at which Socket Out Of Range reports the grip has been stretched too far, so the holder can let go.
var	`CustomHandPoses_Left`Hand	`Map<name, AnimSequenceBase>`	Left-hand poses this object supplies, keyed by the third underscore-separated part of the grip socket name, so a socket called Grip_L_Handle looks up Handle. Takes precedence over the poses on the grabbing ability; leave empty to use the ability's own poses.
var	`CustomHandPoses_Right`Hand	`Map<name, AnimSequenceBase>`	Right-hand poses this object supplies, keyed the same way as the left-hand map. Takes precedence over the poses on the grabbing ability; leave empty to use the ability's own poses.
fn	`IsAutoPickup`Internal	`(out True: bool)`	Returns whether this object is marked for automatic gripping. Internal accessor over Should Auto Grip.
fn	`CanBeGripped`Info	`(SourceInfo: ST_SourceInfo, HitComponent: PrimitiveComponent, SupportedSocketPrefix: name, Location: Vector, out ResponsibleComponent: BPC_Interaction_Grip, out Priority: float, out Socket: ST_Socket)`	Decides whether this object accepts a grip from the ability described by the Source Info, and how strongly it wants it. Refuses when the interaction is inactive, when the hit component is outside Relevant Components, or when the owning actor vetoes through its own Can Be Gripped; otherwise the closest socket within Max Attach Distance sets a priority inside the component's priority range.
fn	`CurrentGrippingAbility`Info	`(out GrippingAbility: ActorComponent)`	Returns the ability currently holding this object, or nothing while it is free.
fn	`Socket Out Of Range`Grip	`(ReferenceLocation: Vector, Socket: ST_Socket, out OutOfRange: bool)`	Returns whether the given socket has been pulled further than Min Detach Distance from the reference location. Holders poll it to decide when to let go of an object that has been dragged out of reach.
fn	`getSourceInfo`SourceInfo	`(out SourceInfo: ST_SourceInfo)`	Returns the Source Info of the ability currently holding this object, so listeners can tell which pawn and hand acted. Comes back empty while nothing holds it.
event	`Gripped`	`(GrippingAbility: ActorComponent)`	Called by a grabbing ability once it has taken hold. Stores that ability, broadcasts On Gripped Start with its Source Info, and plays the grip haptics on the acting hand and the grip sound at the centre of the owning actor.
event	`Released`	`()`	Called by the holding ability when it lets go. Broadcasts On Gripped Release with the Source Info and plays the release haptics and sound; the stored gripping ability is left as it was, so read it through Current Gripping Ability only while a grip is live.
event	`ReleaseCurrentGrippingAbility`	`()`	Asks whichever ability is holding this object to let go of it. Called before a new ability takes over, and safe to call when nothing holds it.
event	`OnDestroyed_Event_0`	`(DestroyedActor: Actor)`	Internal handler that makes the holding ability release its grip when the owning actor is destroyed.

BPC_Interaction_Grip_Latch8 members

extends BPC_Interaction_Grip

Kind	Name	Signature	Description
var	`ComponentTagToAttachTo`Settings	`name`	Component tag picking which of the owning actor's meshes the hand or pawn latches onto, for actors with more than one candidate mesh.
fn	`Create Latching Helper`Latch	`(SpawnTransform: Transform, SourceInfo: ST_SourceInfo, ComponentToAttachTo: SceneComponent, out SocketName: ST_Socket)`	Spawns the latching helper at the grab transform, attaches it to the component the ability hands in, and reports back the attach point socket it settled on. Called by the grabbing ability once it has decided to latch.
fn	`DrawDebug`Debug	`()`	Draws a sphere at the nearest attach point socket with the radius of Max Attach Distance, coloured by latch type. Run it from the details panel while setting an actor up.
fn	`SpawnLatchHelper`Latch	`(SpawnTransform: Transform, SourceInfo: ST_SourceInfo, AttachedSocket: ST_Socket) → BP_Helper_Latch`	Spawns the plain latch helper at the given transform, passing it the owning actor, the Source Info of the grabbing ability and the attach socket. Override it in a child component to spawn a different helper, as the drag and physics variants do.
fn	`CanBeGripped`	`(SourceInfo: ST_SourceInfo, HitComponent: PrimitiveComponent, SupportedSocketPrefix: name = "None", Location: Vector = "0, 0, 0", out ResponsibleComponent: BPC_Interaction_Grip, out Priority: float, out Socket: ST_Socket)`	Overrides the parent's socket and prefix test with a check of the gripping ability's latch capabilities, but returns the same answer either way: priority zero with no Responsible Component set. As written the latch is never offered to a grab, whether or not the ability supports its latch type.
event	`Gripped`	`(GrippingAbility: ActorComponent)`	Called by the grabbing ability once it has latched on, in place of the parent's pickup-oriented handling. The helper actor that actually holds the latch together is created separately, through Create Latching Helper.
event	`Released`	`()`	Called when the latching ability lets go, in place of the parent's release handling. Tearing down the spawned helper is the helper's own job, through its Release event.
event	`OnDestroyed_Event_0`	`(DestroyedActor: Actor)`	Internal handler that makes the latching ability release when the owning actor is destroyed.

BPC_Interaction_Grip_Latch_Drag2 members

extends BPC_Interaction_Grip_Latch

Kind	Name	Signature	Description
var	`DragTag`Drag	`name`	Tag selecting which drag states on the owning actor this latch drives. Handed to the spawned helper, which collects every drag component carrying the tag, so it must match the tag on the drag component you want moved.
fn	`SpawnLatchHelper`	`(SpawnTransform: Transform, SourceInfo: ST_SourceInfo, AttachedSocket: ST_Socket) → BP_Helper_Latch`	Spawns the drag variant of the latch helper instead of the plain one, passing the Drag Tag along so the helper can find the drag components it should move.

BPC_Interaction_Grip_Latch_Physics1 members

extends BPC_Interaction_Grip_Latch

Kind	Name	Signature	Description
fn	`SpawnLatchHelper`	`(SpawnTransform: Transform, SourceInfo: ST_SourceInfo, AttachedSocket: ST_Socket) → BP_Helper_Latch`	Spawns the physics variant of the latch helper, placed at the attach point socket rather than at the ability's grab transform and owned by the latched actor, so its breakable constraint has something to pull against.

BPC_Interaction_Grip_Pickup8 members

extends BPC_Interaction_Grip

Kind	Name	Signature	Description
fn	`getGrabType`	`(out GrabType: E_Pickup_Type)`	Returns how this actor should be carried, read from the pickup coordinator on the owning actor.
fn	`getShouldStayUpright`	`(out ShouldKeepUpright: bool)`	Returns whether the carried actor should be kept upright, read from the pickup coordinator. Only the laser and desktop grabbing act on it.
fn	`getShouldSnapToController`	`(out SnapToController: bool)`	Returns whether the actor snaps to a fixed transform on the controller when picked up, read from the pickup coordinator. Only the laser acts on it.
fn	`getRelativeControllerPosition`	`(out RelativeControllerPosition: Transform)`	Returns the relative transform the actor takes on the controller when it snaps, read from the pickup coordinator.
fn	`getGrabCoordinator`	`() → BPC_PickupCoordinator`	Returns the pickup coordinator on the owning actor. Every pickup on an actor shares that one coordinator for its settings and its list of holders, so an actor without one cannot be carried properly.
event	`ReleaseGrippingAbility`	`()`	Asks the ability currently carrying this pickup to drop it. Use it to take an object out of the player's hands from gameplay code.
event	`Gripped`	`(GrippingAbility: ActorComponent)`	Called by a grabbing ability once it has taken hold of this pickup, in place of the parent's handling. The ability is handed to the owning actor's pickup coordinator, which is what switches physics and connectors over to the carried state.
event	`Released`	`()`	Called when the holding ability lets go. Unregisters that ability from the pickup coordinator, which applies the release physics, resumes connector searching and snaps the actor onto a connector if one is in reach.

BPC_Interaction_Grip_Proxy2 members

extends BPC_Interaction_Grip

Kind	Name	Signature	Description
fn	`getResponsibleGripComponent`Info	`(out GrabComponent: BPC_Interaction_Grip)`	Returns the grip component on the actor this one is attached to, which is the component that answers on its behalf. Comes back empty when the owner is not attached to another actor.
fn	`CanBeGripped`	`(SourceInfo: ST_SourceInfo, HitComponent: PrimitiveComponent, SupportedSocketPrefix: name = "None", Location: Vector = "0, 0, 0", out ResponsibleComponent: BPC_Interaction_Grip, out Priority: float, out Socket: ST_Socket)`	Passes the grip check on to the parent actor's grip component and returns its answer unchanged, so grabbing this actor grabs the parent instead. The socket prefix is dropped on the way, and the check quietly refuses when there is no parent actor or the parent resolves back to this component.

BPC_PickupCoordinator16 members

extends ActorComponent

Kind	Name	Signature	Description
var	`Grab Type`Settings	`E_Pickup_Type`	How the actor behaves while carried. Normal moves the actor to the holder's transform, Physics Handle drives it through a physics handle so it keeps colliding with the world on the way.
var	`ReleaseType`Settings	`E_Pickup_Release`	What happens once the last holder lets go. Free Placement leaves the actor floating where it was released, Physics switches simulation back on so it falls.
var	`ShouldKeepUpright`Laser	`bool`	Whether the carried actor is rotated so its up axis stays parallel to the world up axis. Read by the laser and desktop grabbing; hand motion controllers ignore it.
var	`SnapToController`Laser	`bool`	Whether the actor snaps to a fixed transform on the controller when picked up, taking its controls over. Only the laser acts on it.
var	`RelativeControllerPosition`Laser	`Transform`	Relative transform the actor takes on the controller while Snap To Controller is on.
var	`GrabInterpolationSpeed`Settings	`float`	How quickly the actor is interpolated towards the transform its holders ask for. Raise it for a tighter, stiffer hold and lower it for a laggier, heavier feel.
fn	`SetPhysics`Phyiscs	`(Set: bool)`	Switches physics simulation on or off on the owning actor's root component. Does nothing when the root is not a primitive component.
fn	`SetPhysicsIfAllowed`Phyiscs	`(IsAllowed: bool)`	Applies the simulation setting that Release Type asks for, or forces simulation off when the caller says physics is not allowed at all.
fn	`ContainsAbilityOfPawn`Pawn	`(Pawn: Pawn, out ContainsPawn: bool)`	Returns whether any ability currently holding this actor belongs to the given pawn. Used to tell a player's second hand apart from another player joining in on the same object.
fn	`CalculateCurrentDesiredTransform`Transform	`(out DesiredTransform: Transform)`	Averages the transforms every current holder asks for, which is what lets an object held in two hands sit between them.
fn	`CheckConnectors`Connectors	`(out Connector: BPC_Connector, out DesiredTransform: Transform, out SceneComponent: SceneComponent, out Socket: name)`	Searches the owning actor's active connectors for the best destination in reach and returns that connector together with the transform, component and socket it would attach to. The highest priority wins; nothing comes back when no destination is in range.
fn	`SetSearchForConnectors`Connectors	`(Set: bool)`	Turns connector searching on or off for every connector on the owning actor, so snap previews only run while the object is actually being carried.
fn	`DisconnectConnectors`Connectors	`()`	Detaches every connector on the owning actor from whatever it is plugged into. Called as the object is picked up so it comes free of its socket.
event	`RegisterPickupComponent`	`(GrippingAbility: ActorComponent)`	Adds a gripping ability to this actor's list of holders and switches the actor into its carried state: ticking starts, connectors are disconnected and On Actor Pickup is broadcast, and a locally controlled holder begins searching for connectors to snap to. Physics is left on only when the ability supports a physics handle and Grab Type is Physics Handle; every other case switches it off. The first ability a given pawn registers also files the owning actor in that pawn's attachment registry, so it travels with the pawn.
event	`UnregisterPickupComponent`	`(GrippingAbility: ActorComponent)`	Removes an ability from this actor's holders. Once the last one has gone, ticking stops, physics is applied according to Release Type, On Actor Released is broadcast and the locally controlled holder snaps the actor onto the best connector in reach.
event	`OnDestroyed_Event`	`(DestroyedActor: Actor)`	Internal handler that stops connector searching when the owning actor is destroyed.

Components/PawnAbilities

BPC_PawnAbility_Grip21 members

extends BPC_PawnAbility · implements Interface_GrabbingActor

Kind	Name	Signature	Description
var	`MouseHitDistance`Settings	`float`	Furthest the carried actor may be pushed from the camera while zooming, in centimetres. The near limit is fixed at 50.
var	`Input_Grab`Input	`InputMappingContext`	Input mapping context holding the grab and release bindings for this pawn.
var	`Input_GrabActions`Input	`InputMappingContext`	Input mapping context added while a physics-handle pickup is carried, adding the zoom and rotate bindings that only make sense with something in hand.
var	`PickupInteractionStyle`Style	`PDA_InteractionState`	Interaction state describing how the cursor and accent colour read while the pawn is carrying a pickup.
var	`PickupHoverInteractionStyle`Style	`PDA_InteractionState`	Interaction state requested each frame the pawn hovers a pickup it could grab, which is what changes the cursor before the player presses anything.
var	`LatchInteractionStyle`Style	`PDA_InteractionState`	Interaction state describing how the cursor and accent colour read while the pawn is holding a latch.
var	`LatchHoverInteractionStyle`Style	`PDA_InteractionState`	Interaction state requested each frame the pawn hovers a latch, so latches can be told apart from pickups before grabbing.
fn	`HighlightInteraction`Highlight	`(ref const Hit: HitResult)`	Keeps the highlight alive on the highest-priority grippable under the given hit and requests the matching hover state, pickup or latch. Called every frame with the pawn's current trace; does nothing when the hit actor has no grip component.
fn	`getPlaneIntersection`Trace	`(StartLocation: Vector, ForwardLocation: Vector, out Intersection: Vector)`	Returns where a ray from the given start along the given direction crosses the vertical plane through the grab handle, which is how the carried actor follows the cursor at a fixed depth.
fn	`getCameraScene`Trace	`(out MainCamera: SceneComponent)`	Returns the pawn's camera component, asked for through the pawn info interface so the ability works on any pawn type.
event	`Zoom`	`(XAxis: float)`	Pushes the carried actor towards or away from the camera along the view direction. Bound to the desktop zoom action and clamped to stay at least 50 centimetres away and no further than Mouse Hit Distance.
event	`AddGrabbedActorRotation`	`(AxisValue: float)`	Turns the carried actor around the world up axis. Normal pickups are rotated directly, physics-handle pickups have the handle's target yaw adjusted instead so the object keeps colliding on the way round.
event	`Server_GrabActor`	`(Comp_Grip: BPC_Interaction_Grip)`	Runs on the server to record which component this pawn has grabbed in the replicated grab definition, which is what makes remote clients replay the grab.
event	`GrabActor`	`(GrabComponent: BPC_Interaction_Grip, HitLocation: Vector)`	Grabs the given component at a world location: drops anything already held, frees the component from its previous holder, stores the grab definition and moves the grab handle to the hit point. Pickups then set their target rotation and, for physics-handle types, add the grab action bindings; latches spawn their latching helper on the handle.
event	`ReleaseActor`	`()`	Drops whatever the pawn is carrying by clearing the grab definition, on the server too when the held actor replicates. Bound to the release half of the desktop grab action.
event	`Server_ReleaseGrab`	`()`	Runs on the server to clear the replicated grab definition, which drops the actor on every client.
event	`GrabbingActor_Grip`	`(GripComponent: BPC_Interaction_Grip)`	Grabs the given component at its owner's actor location. Use it to hand this pawn something to hold without a trace or a button press.
event	`GrabbingActor_Release`	`()`	Drops whatever the pawn is carrying, by way of Release Actor.
event	`GrabbingAbility_GripNewActorWithSameProperties`	`(GripComponent: BPC_Interaction_Grip)`	Moves the pawn's grip onto a different component without moving the grab handle, so a swapped-in actor is picked up exactly where the old one was.
event	`Grip`	`()`	Grabs whatever the pawn's latest trace is pointing at, taking the highest-priority grip component on the hit actor. Bound to the desktop grab action; does nothing when the trace found nothing grippable.
event	`Server_SetPickupTransform`	`(PickupTransform: Transform)`	Runs on the server to store the transform this pawn wants the held actor to have. Replicated to the other clients but skipped for the owning one, which already knows where it asked for the object.

Components/Sockets

BPC_Socket_AttachPoint0 members

extends BPC_Socket

No editor-visible members; this asset configures defaults only.

BPC_Socket_Grip1 members

extends BPC_Socket

Kind	Name	Signature	Description
fn	`Socket_getSocketName`	`(out Name: name)`	Returns the name configured on this socket, which is what grabbing abilities match their hand-side prefix against. Keep the Grip_ prefix and the hand side in the name, as in Grip_L_Handle, or the search will not find it.

Helper/ControllerAbility

BP_Helper_ControllerAbility_Hand_Grip1 members

extends BP_Helper_ControllerAbility

Kind	Name	Signature	Description
var	`ControllerAbilityHandGrab`	`BPC_ControllerAbility_Hand_Grab`	The hand grab ability this helper belongs to. Set when the ability spawns the helper, which then forwards the grip and button-forwarding input actions to it.

BP_Helper_PickupOffset0 members

extends Actor

No editor-visible members; this asset configures defaults only.

Helper/Latch

BP_Helper_Latch4 members

extends Actor

Kind	Name	Signature	Description
var	`AssignedActor`	`Actor`	The actor being latched onto. Set when the latch component spawns this helper.
var	`SourceInfo`	`ST_SourceInfo`	Identity of the ability that created this latch, so the helper can call back to the right pawn and hand when the latch ends.
var	`AttachedSocket`	`ST_Socket`	Attach point socket the helper was spawned on, picked as the closest one to the grab position.
event	`Release`	`()`	Implemented by each latch helper variant to undo whatever the latch set up. The base helper does nothing; the drag variant lets go of its drag components and the physics variant breaks its constraint.

BP_Helper_Latch_Drag3 members

extends BP_Helper_Latch

Kind	Name	Signature	Description
var	`DragTag`	`name`	Tag identifying which drag components on the latched actor this helper drives. Copied from the latch component when the helper is spawned.
fn	`getDragComponents`	`(out DragComponent: BPC_State_Drag[])`	Returns the drag states on the latched actor that carry the Drag Tag. Comes back empty when nothing carries the tag, in which case the latch moves nothing.
event	`Release`	`()`	Ends the drag latch and lets go of the drag components this helper was driving. Called when the grabbing ability releases.

BP_Helper_Latch_Physics3 members

extends BP_Helper_Latch

Kind	Name	Signature	Description
fn	`Get`	`(out OutputPin: PrimitiveComponent)`	Placeholder accessor that always returns nothing. Override it in a child helper if the constraint should be driven against a specific component.
event	`OnConstraintBroken_Event_0`	`(ConstraintIndex: int)`	Internal handler that tells the grabbing ability to release once the constraint holding this latch snaps, so pulling hard enough lets go rather than leaving a dead latch behind.
event	`OnDestroyed_Event_0`	`(DestroyedActor: Actor)`	Internal handler that breaks the constraint and unbinds the constraint-broken delegate when the latched actor is destroyed, so no release is fired for an actor that has already gone.

Helper/PawnAbility

BP_Helper_PawnAbility_Grab0 members

extends Actor

No editor-visible members; this asset configures defaults only.

Interfaces

Interface_GrabbingActor7 members

extends Interface

Kind	Name	Signature	Description
fn	`GrabbingActor_Grip`Grab	`(GripComponent: BPC_Interaction_Grip)`	Implemented by a grabbing ability to take hold of the given grip component. Call it to make a hand or pawn grab something without the player reaching for it.
fn	`GrabbingActor_Release`Grab	`()`	Implemented by a grabbing ability to let go of whatever it is holding. Grip components call it to force a release, for instance when their actor is destroyed or another ability takes over.
fn	`GrabbingActor_getCurrentGripComponent`Grab	`(out GripComponent: BPC_Interaction_Grip)`	Implemented by a grabbing ability to report the component it is holding, or nothing while its hands are empty.
fn	`GrabbingActor_SupportPhysicsHandle`Grab	`(out SupportPhysicsHandle: bool)`	Implemented by a grabbing ability to say whether it can carry objects through a physics handle. The pickup coordinator uses the answer to decide whether simulation stays on while the object is held; the default answer is no.
fn	`GrippingAbility_getLatchCapabilities`Gripping Ability	`(out SupportedLatchTypes: E_Latch_Type[])`	Implemented by a grabbing ability to list the latch types it can drive. A latch offers itself for gripping only when its own type appears in that list, so an ability that returns nothing can never latch.
fn	`GrippingAbility_getDesiredGrippedActorTransform`Gripping Ability	`(out Transform: Transform)`	Implemented by a grabbing ability to report where it wants the held actor to sit. The pickup coordinator averages the answers of every holder, which is what makes two-handed carrying work.
fn	`GrabbingAbility_GripNewActorWithSameProperties`Gripping Ability	`(GripComponent: BPC_Interaction_Grip)`	Implemented by a grabbing ability to move its grip onto a different component while keeping the hold as it was. Called when an object replaces itself with another actor mid-grab.

Interface_Grip1 members

extends Interface

Kind	Name	Signature	Description
fn	`CanBeGripped`Latch	`(GripComponent: BPC_Interaction_Grip, SourceInfo: ST_SourceInfo, out IsGrippable: bool)`	Implemented by the actor owning a grip component to veto a grip before it happens, judging the ability from its Source Info. Actors that do not implement the interface are always grippable, but once it is implemented the default answer is no, so return true deliberately.

Libraries

FL_Interaction3 members

extends BlueprintFunctionLibrary

Kind	Name	Signature	Description
fn	`FindClosestSocket`Sockets	`(ReferenceLocation: Vector, Prefix: name, UseMaxDistance: bool, MaxDistance: float, ComponentsToSearchOn: SceneComponent[], __WorldContext: Object, out Socket: ST_Socket, out Distance: float)`	Returns the socket nearest a reference location whose name starts with the given prefix, searching the supplied scene components. Components implementing the socket interface offer only their own socket name, anything else offers all of its mesh sockets. With Use Max Distance off the search is unbounded, and Distance comes back enormous when nothing matched.
fn	`FindHighestPriorityGripComponent`Grip	`(ActorToGrab: Actor, HitComponent: PrimitiveComponent, SourceInfo: ST_SourceInfo, SupportedSocketPrefix: name, Location: Vector, __WorldContext: Object, out GripComponent: BPC_Interaction_Grip, out Socket: ST_Socket)`	Asks every grip component on the actor whether it accepts the grip and returns the one offering the highest priority, together with the socket it chose. Comes back empty when no component on the actor is willing.
fn	`FindHighestPrioritySelectComponent`Grip	`(Actor: Actor, ref const HitComponent: PrimitiveComponent, SourceInfo: ST_SourceInfo, __WorldContext: Object, out SelectComponent: BPC_Interaction_Select)`	Returns the first select component on the actor that accepts a selection from the given Source Info. Despite the name it stops at the first willing component rather than comparing priorities.