---
title: AFS_UX_Grip
product: Advanced Framework Pro
version: 1.0
engine: Unreal Engine 5.8
updated: 2026-10-05
canonical: https://docs.human-codeable.com/plugins/afs-ux-grip.html
---

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

None

#### Required by

None

21 assets125 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

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

[![Grip sockets positioned on a mesh](../images/AFS_UX_Grip_setup-1600.webp?v=c9397b97)](../images/AFS_UX_Grip_setup-1600.webp?v=c9397b97)

Grip sockets positioned on a mesh

## Usage

### Making something carryable

See [Make an object grabbable](../workflows/make-object-grabbable.html).

### 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 |

## 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_Grab**25 members

extends `BPC_ControllerAbility` · implements `Interface_GrabbingActor`

Hand ability letting a hand-mesh motion controller take hold of things. A sphere trace at the palm finds the highest-priority grip interaction, then pickups are held on the helper's physics handle or snapped to a grip socket with a matching hand pose, and latches get a latching helper. Add it to a hand controller, which must answer the hands motion controller contract for posing, snapping and collision. It forwards face, trigger and thumbstick input to whatever is held.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Search Distance`Settings | `float` | How far ahead of the hand's grab point the sphere trace looks for something to grip, in centimetres. |
| var | `Search Radius`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 Button Forward`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 | `Default Grip Pose Right`Poses | `AnimSequenceBase` | — |
| var | `Default Grip Pose Left`Poses | `AnimSequenceBase` | — |
| var | `Grip Hand Poses 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 | `Grip Hand Poses 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 | `UpdatePickupTransform`Grip | `()` | Keeps a held object where the hand is, taking one of two routes depending on the pickup's grab type. One takes the transform from the grip helper's second handle, stores it in the replicated pickup transform and sends it to the server; the other drives the helper's physics handle to the hand's own location and rotation. Called while something is held. |
| 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. |
| 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 | `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 | `getAllAttachedActors`Ability | `(out Actors: Actor[])` | Returns every actor this ability currently owns or has attached to itself, so the motion controller can gather everything it is carrying. |
| 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 | `Server_GrabActor` | `(Grip Component: 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 | `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. |
| event | `OnDestroyed_Event_1` | `(DestroyedActor: Actor)` | Internal handler that releases the grip when the held actor is destroyed. |

### Components/Interactions

**BPC_Interaction_Grip**20 members

extends `BPC_Interaction`

Base interaction making its owner grabbable, the target side of every grip. It answers Can Be Gripped with a priority worked out from the distance to the closest grip socket, remembers the ability currently holding it, plays the grip and release sounds and haptics, and releases the holder if the owner is destroyed. Add the pickup, latch or proxy variant rather than this one; subclass it when a hold of your own needs different rules.

| 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 | `Should Auto Grip`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 | `Allow Grip if Occupied`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 | `Max Attach Distance`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 | `Assigned Sockets`Conditions | `name[]` | List of allowed sockets. Leave as "None" to accept any socket. |
| var | `Min Detach Distance`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 | `Custom Hand Poses 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 | `Custom Hand Poses 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 | `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. |
| 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 | `CurrentGrippingAbility`Info | `(out GrippingAbility: ActorComponent)` | Returns the ability currently holding this object, or nothing while it is free. |
| fn | `CanBeGripped`Info | `(SourceInfo: ST_SourceInfo, HitComponent: PrimitiveComponent, SocketPrefix: 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 | `IsAutoPickup`Internal | `(out True: bool)` | Returns whether this object is marked for automatic gripping. Internal accessor over Should Auto Grip. |
| 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_Latch**8 members

extends `BPC_Interaction_Grip`

Grip interaction for something worked in place rather than carried away, a lever, a valve or a drawer. Gripping spawns a latch helper at the closest attach-point socket and parents it to the hand, and the grabbing ability's supported latch types decide whether it may be taken hold of at all. Add the drag or physics variant for a working latch; subclass this one when the helper it spawns should be yours.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Component Tag to Attach To`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 | `CanBeGripped`Info | `(SourceInfo: ST_SourceInfo, HitComponent: PrimitiveComponent, SocketPrefix: 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 | `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 | `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 | `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. |
| 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_Drag**2 members

extends `BPC_Interaction_Grip_Latch`

Latch that drives drag components on its owner. Gripping spawns a drag latch helper carrying the drag tag, and every drag component on the owner marked with that tag follows the hand. Add it to levers, knobs, sliders, valves and hinged doors and set the tag to match the drag components it should move; it is the latch nearly all the shipped examples use.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Drag Tag`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`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. |

**BPC_Interaction_Grip_Latch_Physics**1 members

extends `BPC_Interaction_Grip_Latch`

Latch that holds its owner through a breakable physics constraint instead of driving it directly, spawning the physics latch helper at the attach-point socket. Add it when the object should resist and swing rather than track the hand exactly; pulling past the break threshold releases the hold. Nothing in the shipped content uses it, so treat it as a starting point rather than a worked example.

| Kind | Name | Signature | Description |
|---|---|---|---|
| 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. |

**BPC_Interaction_Grip_Pickup**8 members

extends `BPC_Interaction_Grip`

Grip interaction for an object meant to be picked up and carried, and the most-used grip in the framework. Add it alongside a pickup coordinator on the same actor: this component is the grabbable side that a hand, a laser or a desktop pawn finds, while the coordinator holds the grab type, release rule, upright and snapping settings it reads back and unregisters from on release.

| Kind | Name | Signature | Description |
|---|---|---|---|
| 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. |
| fn | `getRelativeControllerPosition` | `(out RelativeControllerPosition: Transform)` | Returns the relative transform the actor takes on the controller when it snaps, read from the pickup coordinator. |
| 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 | `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 | `getGrabType` | `(out GrabType: E_Pickup_Type)` | Returns how this actor should be carried, read from the pickup coordinator on the owning actor. |
| 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_Proxy**2 members

extends `BPC_Interaction_Grip`

Grip interaction that passes the grab on to its attach parent. Asked whether it can be gripped, it puts the question to the grip component on the actor it is attached to and names that component as responsible, so the parent is held rather than the child. Add it to an attached actor that should be grabbed by the thing it hangs off.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `CanBeGripped`Info | `(SourceInfo: ST_SourceInfo, HitComponent: PrimitiveComponent, SocketPrefix: 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 | `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. |

**BPC_PickupCoordinator**16 members

extends `ActorComponent`

Settings and state hub for a pick-up-able actor, one per actor however many hands hold it. Carries the grab and release types, the upright, snapping and interpolation options, tracks every ability currently holding the actor and averages their desired transforms for two-handed carries, and switches physics simulation on and off at the right moments. It also searches the snapping connectors while the actor is held and connects on release. Pair it with the pickup grip interaction.

| 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 | `Release Type`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 | `Should Keep Upright`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 | `Snap to Controller`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 | `Relative Controller Position`Laser | `Transform` | Relative transform the actor takes on the controller while Snap To Controller is on. |
| var | `Grab Interpolation Speed`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 | `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. |
| 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 | `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 | `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 | `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 | `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 | `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. |
| 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_Grip**20 members

extends `BPC_PawnAbility` · implements `Interface_GrabbingActor`

Pawn ability giving a desktop or mobile pawn the ability to grab. The pawn's latest trace finds the highest-priority grip interaction; pickups are carried on a physics handle out in front of the camera, latches get a latching helper. Add it to a non-VR pawn, which must answer the pawn info contract for its camera. Zoom pushes and pulls the held object, and the four interaction state assets set the cursor as the pointer passes over something grabbable. Replicated through its grab definition.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Mouse Hit Distance`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 Grip`Input | `InputMappingContext` | Input mapping context holding the grab and release bindings for this pawn. |
| var | `Input Grip Actions`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 | `Pickup Interaction Style`Style | `PDA_InteractionState` | Interaction state describing how the cursor and accent colour read while the pawn is carrying a pickup. |
| var | `Pickup Hover Interaction Style`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 | `Latch Interaction Style`Style | `PDA_InteractionState` | Interaction state describing how the cursor and accent colour read while the pawn is holding a latch. |
| var | `Latch Hover Interaction Style`Style | `PDA_InteractionState` | Interaction state requested each frame the pawn hovers a latch, so latches can be told apart from pickups before grabbing. |
| var | `Input Grip Rotate`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 | `Rotation Speed`Settings | `float` | How far a carried actor turns for a given mouse movement, as a multiplier on the input axis. Add Grabbed Actor Rotation scales both axes by it, so raising it makes the object spin further for the same movement. Two by default. |
| 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. |
| 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 | `HighlightInteraction`Highlight | `(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. |
| 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: Vector2D)` | 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 | `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_AttachPoint**0 members

extends `BPC_Socket`

Socket marking a place a latch may take hold of, with its name preset to the Attach Point prefix the latch interaction searches for. Add one per handhold on a lever, valve or drawer; gripping picks whichever of the owner's attach points sits closest to the hand and parents the latch helper there.

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

**BPC_Socket_Grip**1 members

extends `BPC_Socket`

Socket marking where a hand may take hold of an object, with its name preset to the Grip prefix that grabbing searches for. Name each one for the hand and the pose, Grip_L_ or Grip_R_ followed by a pose key, and the hand ability picks the socket for the correct side and looks the matching hand pose up on the grip interaction. Add one per hold position.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Socket_getSocketName` | `(out Name: name)` | Returns this socket's name, used to match sockets against the prefix an ability is looking for. |

### Helper/ControllerAbility

**BP_Helper_ControllerAbility_Hand_Grip**1 members

extends `BP_Helper_ControllerAbility`

World-side helper the hand grabbing ability spawns. Holds the physics handle that actually carries picked-up objects, the handles fixing where a held object sits relative to the hand, and the palm offset used when nothing snaps to a socket. It is also where the VR button, trigger and thumbstick actions arrive before the ability forwards them to whatever is being held. Spawned with the ability; not something to place.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Controller Ability Hand Grab` | `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_PickupOffset**0 members

extends `Actor`

Bare marker actor: a single scene root and nothing else. Nothing in the framework spawns or references it, and it has no logic of its own, so treat it as a stub left for positioning a picked-up object rather than as working content.

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

### Helper/Latch

**BP_Helper_Latch**4 members

extends `Actor`

Base for the actor a latch spawns between the hand and the thing being worked. Spawned owned by the grabbing ability and attached to it, it remembers the latched actor, the Source Info of whoever took hold and the socket it took hold of, and tidies itself away through the auto-destroy component. It does nothing on its own; the drag and physics subclasses do the work, and a latch of your own spawns its own subclass of this.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Assigned Actor` | `Actor` | The actor being latched onto. Set when the latch component spawns this helper. |
| var | `Source Info` | `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 | `Attached Socket` | `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_Drag**3 members

extends `BP_Helper_Latch`

Latch helper that works drag components. It gathers every drag component on the latched actor carrying the drag tag and feeds them the hand's movement each frame, which is what turns a valve, slides a drawer or swings a lever. Spawned by the drag latch interaction rather than placed, and destroyed with the hold.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Drag Tag` | `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_Physics**2 members

extends `BP_Helper_Latch`

Latch helper that holds the object through a physics constraint rather than driving it: a hidden handle mesh with a breakable linear and angular drive between hand and body. Breaking the constraint releases the grabbing ability, and destroying the helper breaks it first so nothing is left attached. Spawned by the physics latch interaction; not something to place.

| Kind | Name | Signature | Description |
|---|---|---|---|
| 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_Grab**0 members

extends `Actor`

World-side helper the desktop and mobile grabbing ability works through: a physics handle plus the grabbing, offset and hovering handles that decide where a carried object floats in front of the camera. It has no logic of its own, the ability moves the handles, and it is spawned for you rather than placed.

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

### Interfaces

**Interface_GrabbingActor**7 members

extends `Interface`

Contract every grabbing ability answers to: take hold and let go, which grip interaction it currently holds, whether it can offer a physics handle, which latch types it can work and the transform it wants the held actor to have. Grip interactions and the pickup coordinator call it without knowing whether a hand, a laser or a desktop pawn is holding them, so implement it on a grabbing ability of your own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `GrabbingAbility_GripNewActorWithSameProperties`Gripping Ability | `(Grip Component: 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. |
| 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 | `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 | `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 | `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_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_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. |

**Interface_Grip**1 members

extends `Interface`

One-question contract letting an actor veto being grabbed. Grip interactions ask their owner Can Be Gripped before reporting themselves available, so answering false for a given Source Info leaves the object unable to be picked up by that ability while remaining perfectly grabbable by another. Implement it on an actor that has to decide for itself; an actor that does not implement it stays grabbable throughout.

| 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_Interaction**3 members

extends `BlueprintFunctionLibrary`

Function library behind grabbing and selecting, called statically with no component to add. Find Closest Socket searches a set of scene components for the nearest socket whose name starts with a given prefix, and the two highest-priority functions walk an actor's grip or select interactions and return the one that wins. The grabbing abilities are built on these, and an ability of your own can call them the same way.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `FindHighestPrioritySelectComponent`Grip | `(Actor: Actor, 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. |
| fn | `FindHighestPriorityGripComponent`Grip | `(ActorToGrab: Actor, HitComponent: PrimitiveComponent, SourceInfo: ST_SourceInfo, SocketPrefix: 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 | `FindClosestSocket`Sockets | `(ReferenceLocation: Vector, Prefix: name, out AllowedSockets: name[], UseMaxDistance: bool, MaxDistance: float, out 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. |

### Settings

**BP_Value_Settings_Integer_Grip_GrabAssist**1 members

extends `BP_Value_Settings_Integer`

Ready-made selector for how forgiving grabbing is, widening or narrowing the hand's grab search. Point a selector row at it to offer precise, normal and generous reach; it is the single biggest accessibility win on a settings screen.

| Kind | Name | Signature | Description |
|---|---|---|---|
| event | `Value_setInteger`Value_Integer | `(SourceInfo: ST_SourceInfo, Value: int)` | Implemented by an integer value to take a new value from the pawn described by the source info. Drop-downs call it when one of their options is chosen. |