Skip to content

Get Actor Bounds / Get Component Bounds / Get Local Bounds

At a glance

Lives in: Blueprint API / Collision for Actor and Component bounds; Components / Static Mesh for Local Bounds - Returns: world-space Origin plus half-size Box Extent for Actor/Component; Component also returns Sphere Radius; Static Mesh Local Bounds returns local-space Min and Max - Fails by: returning zero/empty-looking values with no success pin, or reading a stale/estimated cached bound - Official docs: Get Actor Bounds, Get Component Bounds, and Get Local Bounds

The one-minute version

  • Get Actor Bounds combines the cached world bounds of eligible registered Primitive Components owned by one Actor. It returns a world-axis-aligned box.
  • Get Component Bounds reads one Scene Component's cached world bound. It returns the bound center, world-axis box half-size, and bounding-sphere radius.
  • Get Local Bounds on a Static Mesh Component reads the Static Mesh asset's local-axis box as Min and Max. It does not apply that component's current location, rotation, or scale.
  • Origin is the center of the bound, not necessarily the Actor location, component location, mesh pivot, center of mass, or a point on geometry.
  • Box Extent is half-size. Full size is Box Extent * 2. For local bounds, size is Max - Min and center is (Min + Max) / 2.
  • World outputs use Unreal world units (normally centimeters). Local Min/Max use the Static Mesh asset's local units before component scale.
  • World boxes are axis-aligned: rotate a long object diagonally and its X/Y extents grow to keep enclosing it. They are not exact oriented boxes.
  • Only Colliding Components filters Actor contributors by collision-enabled state. It does not replace their cached bounds with exact collision shapes.
  • Hidden components can still contribute. Unregistered components do not contribute to Actor bounds. Child Actors are excluded unless Include from Child Actors is true.
  • Bounds are broad, cheap envelopes. Use them for rough framing, placement, culling-like tests, and first-pass range checks—not exact surface distance, free spawn space, line of sight, or hit detection.

The three coordinate contracts

Node Scope Space Outputs
Get Actor Bounds Eligible Primitive Components owned by one Actor World Origin, Box Extent
Get Component Bounds One Scene Component's cached bound World Origin, Box Extent, Sphere Radius
Get Local Bounds One Static Mesh asset through its component Component/mesh local Min, Max

The world-space nodes answer "what simple volume encloses this here and now?" The local node answers "what simple box encloses this Static Mesh around its imported pivot before this component's transform?"

Do not mix their values directly:

wrong:
    WorldSpawnPoint = LocalMax

right:
    WorldTopCorner = StaticMeshComponent
        .GetComponentTransform()
        .TransformPosition(LocalCorner)

For a rotated local box, transforming only Min and Max is not enough to construct its world axis-aligned box. Transform all eight local corners, then take the world minimum/maximum, or use the component's already-computed world bounds.

What Get Actor Bounds actually does

The Actor node visits the Actor's components and combines qualifying world boxes:

pseudocode - not engine source

CombinedBox = empty

for each component owned by Actor:
    if component is a registered Primitive Component:
        if OnlyCollidingComponents is false
           OR component has collision enabled:
            CombinedBox += component cached world box

if IncludeFromChildActors:
    include qualifying components owned by managed Child Actors recursively

Origin, BoxExtent = center and half-size of CombinedBox

Actor Components without geometry do not add a useful spatial box. Scene Components provide transforms, but Primitive Components are the normal render/collision contributors: meshes, capsules, boxes, spheres, and similar geometry.

The union can be much larger than the visible body:

BP_Character owns:
    Capsule at body
    Skeletal Mesh
    Weapon mesh attached to hand
    large interaction sphere

Get Actor Bounds includes every eligible owned Primitive Component

If Only Colliding Components is false, a no-collision VFX, mesh, or helper primitive can expand the result. If it is true, any collision-enabled mode can qualify, but the returned box remains that component's cached bounds—not a newly calculated exact union of collision triangles.

Child Actors and ordinary attachments

Include from Child Actors follows Actors managed through Child Actor Components. It does not mean "include every Actor attached anywhere below me."

Relationship Included by default? Included with Child Actor pin?
Primitive Component owned by this Actor Yes, if otherwise eligible Yes
Component attached to this Actor but owned by another ordinary Actor No No
Actor spawned/managed by a Child Actor Component No Yes
Actor elsewhere in the level No No

Choose the pin deliberately for authored composite objects such as a vehicle whose turret or equipment is implemented as Child Actors.

What Get Component Bounds actually returns

Get Component Bounds reads the component's cached Bounds structure:

Origin       = center shared by the cached box and sphere
Box Extent   = distance from center to each world-axis box face
Sphere Radius = radius of a conservative sphere around the component

Example:

Origin     = (100, 200, 50)
Box Extent = (40, 20, 10)

World Min  = Origin - Box Extent = (60, 180, 40)
World Max  = Origin + Box Extent = (140, 220, 60)
Full Size  = Box Extent * 2      = (80, 40, 20)

The sphere radius is one scalar in world units. It is useful for a cheap is-this-roughly-near comparison or conservative camera distance. It is not the distance from the Actor pivot to the mesh surface, and a sphere contains empty space around non-spherical objects.

The input accepts a Scene Component reference, but a plain Scene Component's default bound can be zero-sized. Primitive subclasses provide the meaningful geometry-specific bounds most readers expect.

What Get Local Bounds actually returns

Get Local Bounds is a member of Static Mesh Component. It reads the assigned Static Mesh asset's bounding box and exposes its local minimum and maximum:

LocalMin = AssetBoundsOrigin - AssetBoxExtent
LocalMax = AssetBoundsOrigin + AssetBoxExtent

LocalCenter = (LocalMin + LocalMax) / 2
LocalExtent = (LocalMax - LocalMin) / 2
LocalSize   = LocalMax - LocalMin

The values are around the mesh's imported pivot. They do not have to be symmetrical around zero:

mesh pivot is at the bottom center

Min = (-50, -50, 0)
Max = ( 50,  50, 200)

Local center = (0, 0, 100), not (0, 0, 0)

The component's current transform is not baked into these outputs:

  • moving the component does not change local Min/Max;
  • rotating it does not rotate the returned vectors;
  • scaling it does not multiply local Min/Max.

Apply the component transform when you need world points. This node is specific to Static Mesh Component; a Skeletal Mesh's animated pose, a Niagara system, and a collision shape have different bound sources.

Rotation, scale, and why the box looks too large

Actor and Component boxes align with world X, Y, and Z. They do not rotate with the object.

Imagine a long thin board:

unrotated:
    most size lies on world X

rotated 45 degrees around Z:
    the same board spreads across world X and world Y
    the world-axis box grows in both axes to contain it

That larger box is correct for an axis-aligned bounding box (AABB). It is conservative, not an exact description of occupied space.

World bounds include current component scale. Non-uniform scale changes each world dimension, and rotation then mixes those scaled local axes into the world-axis envelope. Local Static Mesh bounds remain unscaled asset values.

If you need an oriented box for custom math:

  1. get local Min/Max;
  2. calculate local center and local half-size;
  3. use the component transform for world center and local axes;
  4. apply absolute world scale to the half-sizes; and
  5. implement an oriented-box test that understands those axes.

Do not feed a local half-size straight into a world-axis overlap test after rotation.

When they fail (and what failure does)

None of these nodes returns a success Boolean. Common failure shapes:

  1. Get Component Bounds receives None. The library function returns zero Origin, zero Box Extent, and zero Sphere Radius. It does not create a fallback component.
  2. Get Actor Bounds Target is invalid. The member call cannot run; Blueprint produces its normal invalid-target diagnostic and output pins remain default-looking.
  3. The Actor has no eligible registered Primitive Components. Its combined box is empty, producing zero Origin and zero Extent—not the Actor's current location.
  4. Only Colliding Components filters everything. An Actor made only of No Collision primitives produces the same empty-looking output.
  5. A Static Mesh Component has no Static Mesh assigned. Blueprint has no asset bound to return; expect default/zero-looking local outputs.
  6. The component is not registered or has not updated bounds yet. Actor aggregation skips unregistered primitives, while a direct component read can expose a zero or older cached bound.
  7. The result is legitimately degenerate. A point-like component or flat asset can have zero on one or more axes.

Never use Extent == (0,0,0) as your only validity test. Validate the Actor or Component reference, confirm the Static Mesh assignment when using local bounds, and decide whether the chosen components should contribute.

Bounds are cached and component-specific

Get Component Bounds is cheap because it reads current cached bounds; it does not scan every rendered vertex when called.

Get Actor Bounds still walks the Actor's owned components and, when requested, managed Child Actors before combining those cached boxes. One occasional query is ordinary work; querying many Actors recursively every Tick is a search loop worth avoiding. Cache stable Static Mesh local dimensions, and recompute dynamic world bounds only when the decision needs a fresh snapshot.

Normal transform updates refresh component-to-world state and bounds, but several systems affect what "current" means:

  • Attachment: child transforms and bounds update from their parents. Use Attach Parent Bound can deliberately make an attached component reuse its parent's bound.
  • Animation: Skeletal Mesh bounds can come from a physics asset, fixed bounds, leader/master pose settings, or the evaluated pose, depending on component settings. A read before that frame's animation update can observe earlier state.
  • Niagara/particles: dynamic systems estimate or calculate bounds according to system settings; fixed bounds can be intentionally conservative.
  • World Position Offset and vertex deformation: rendered vertices can move outside the asset box unless bounds settings account for that movement.
  • Bounds Scale / bounds extensions: Primitive Component or asset settings can enlarge the cached volume for safe rendering at a performance cost.
  • Collision changes: the Actor filter notices whether collision is enabled, but a render/asset bound and an exact collision shape are still different concepts.
  • Hidden state: hiding a component does not erase its cached bounds or automatically remove it from Actor aggregation.
  • Registration/destruction: an unregistered or destroyed component no longer contributes to the Actor union.

When timing matters, query after the system that owns the change has updated, not earlier in Construction Script or before an async asset/animation update has completed. A pure bounds node does not force all those systems to finish.

Which bound should drive the task?

Camera or Scene Capture framing

Use Actor bounds when the whole composed Actor matters:

Get Actor Bounds
Only Colliding Components = false
Include from Child Actors = matches composition
-> choose camera target = Origin
-> calculate distance from Box Extent / field of view
-> add framing margin

Check for oversized helper components. A huge interaction sphere or hidden mesh can push the camera far away. For one known visual mesh, Component Bounds is usually more stable.

Spawn clearance

Bounds provide a conservative first estimate, but they do not prove free space:

candidate point
-> broad bounds estimate
-> actual overlap/shape query using intended collision channel
-> spawn only if gameplay collision says clear

An axis-aligned box around a rotated mesh includes empty corners, while mesh collision can extend differently from render bounds. Use the collision query as the authority.

World-space UI or nameplates

A rough top-center point is:

Get Component Bounds
Top = Origin + (0, 0, BoxExtent.Z)
Project World Location to Widget Position

That can jitter on animated characters as bounds change. A head socket or an authored Scene Component anchor is usually better for a stable nameplate.

Rough range and broad-phase tests

The component sphere is convenient:

Distance(Point, Origin) <= SphereRadius + Margin

This says the point is near the bounding sphere. It does not say the point touches geometry. Use a trace, overlap, or closest-point-on-collision query for the exact gameplay question.

The patterns everyone actually uses

Fit a trigger to a Static Mesh in local space

StaticMeshComponent.GetLocalBounds
-> LocalCenter = (Min + Max) * 0.5
-> LocalExtent = (Max - Min) * 0.5

BoxCollision attached to StaticMeshComponent
-> Set Relative Location(LocalCenter)
-> Set Box Extent(LocalExtent + Padding)

Because the Box Collision shares the mesh's parent/local space, the authored local values stay meaningful. Confirm collision scale behavior and avoid a zero scale axis.

Find the visual top of one component

Is Valid(TargetMesh)
-> Get Component Bounds(TargetMesh)
-> WorldTop = Origin + (0, 0, 1) * BoxExtent.Z

This uses world Z. For an Actor that can lie sideways, use a socket or transform the local top point instead.

The C++ twin, for the curious (our own example code):

FVector Origin = FVector::ZeroVector;
FVector Extent = FVector::ZeroVector;
float SphereRadius = 0.0f;

if (IsValid(TargetMesh))
{
    UKismetSystemLibrary::GetComponentBounds(
        TargetMesh, Origin, Extent, SphereRadius);
}

const FVector FullWorldSize = Extent * 2.0;

Local snapshots and multiplayer

Bounds are computed from the component state available on the machine running the graph. The nodes do not request a fresh transform, pose, collision shape, or bound from the server.

Use cases split naturally:

  • client camera framing, nameplates, and cosmetic culling can use local presentation bounds;
  • server-authoritative spawn clearance, damage, pickup, or overlap rules should use server collision queries and server state;
  • replicated moving Actors can have slightly different client/server snapshots because transform and animation updates arrive/evaluate at different times.

Do not replicate a bound every frame merely to make a client UI exact. Replicate the gameplay state/transform that already owns the object, and let each machine derive presentation. If a gameplay volume is a rule, model it as an explicit collision component or replicated dimensions rather than an incidental render bound.

What these nodes do not do

They do not:

  • return exact occupied geometry or an oriented box;
  • measure Actor/component pivot-to-surface distance;
  • test collision, overlap, line of sight, or navigable clearance;
  • include every attached Actor automatically;
  • exclude hidden components automatically;
  • force animation, rendering, collision, or async asset state to update;
  • return a success flag;
  • keep a stored result live after the object moves; or
  • reconcile client and server snapshots.

Lookalikes - which one do I want?

Node / value Returns Use when
Get Actor Bounds Combined world AABB The whole Actor's eligible owned primitives matter.
Get Component Bounds One cached world AABB + sphere One exact component is the scope.
Get Local Bounds Static Mesh local Min/Max You need asset dimensions or a box in the component's local axes.
Get Actor / Component Location Pivot/origin point You need the transform point, not geometry size.
Get Socket Location Named world point You need a stable authored/animated anchor such as head or muzzle.
Get Closest Point on Collision Closest collision-surface point/distance when available The question is about collision surface distance.
Box / Sphere / Capsule Collision dimensions Designed collision shape The volume itself is a gameplay rule.
Line / shape trace or overlap Actual query result You need visibility, blocking, contact, or free-space evidence.

Rule of thumb: Actor bounds for the composition, Component bounds for one world-space envelope, Local bounds for Static Mesh asset dimensions, and collision queries for gameplay truth.

Going deeper