Skip to content

Break Hit Result

At a glance

Lives in: Blueprint API / Collision - Target: Gameplay Statics - Input: one FHitResult struct - Returns: the struct's fields; object outputs such as Hit Actor, Hit Component, and Phys Mat may be None - Fails by: it does not fail or validate the hit; an empty/default result simply breaks into empty/default values - Official docs: Break Hit Result

The one-minute version

  • An FHitResult is one collision report. Break Hit Result only opens that report into pins. It does not run another trace, confirm a target, or change the result.
  • Check the node that produced the result first. A single trace's Return Value, Blocking Hit, and Initial Overlap tell you whether the remaining fields describe a normal block, a start-in-penetration case, an overlap/touch, or no useful contact.
  • For a line trace, Location and Impact Point are normally the same. For a swept sphere, capsule, or box, Location is where the swept shape can stop; Impact Point is where that shape touched the other surface.
  • For a shape sweep, Normal describes the swept shape's side of the contact; Impact Normal describes the surface that was hit. A line has no radius, so the two are normally the same for line tests.
  • Hit Actor, Hit Component, Phys Mat, and bone names are conditional data. They can be None or None-like even though the struct itself exists.
  • A no-hit result is still a valid struct value. Breaking it is safe; using its empty Hit Actor without a branch or validity check is not.

What it actually does

Blueprint wires can carry a struct: several named values bundled into one value. Collision queries, swept movement, and hit events use FHitResult so they can pass the contact position, normal, component, actor, and query context together.

Break Hit Result is the native break function for that struct:

pseudocode of the engine behavior - not engine source

function BreakHitResult(Hit):
    output BlockingHit   = Hit.bBlockingHit
    output InitialOverlap = Hit.bStartPenetrating
    output Time          = Hit.Time
    output Distance      = Hit.Distance
    output Location      = Hit.Location
    output ImpactPoint   = Hit.ImpactPoint
    output Normal        = Hit.Normal
    output ImpactNormal  = Hit.ImpactNormal
    output HitActor      = Hit.GetActor()
    output HitComponent  = Hit.GetComponent()
    output remaining fields from Hit

That extraction is all it does. The collision work already happened when a trace, sweep, movement operation, or event created the struct. The break node is pure: it has no execution pins and no side effects.

Read the producer before the fields

The same struct is used by several systems, so a field's usefulness depends on where the value came from.

Producer What the result usually describes First thing to check
Single trace or sweep The first matching/blocking result for that query family. Branch on the trace Return Value, then inspect the hit.
Multi trace or sweep One entry among several contacts, which may include overlap/touch results. Iterate the array and inspect each entry's Blocking Hit plus target fields.
Swept movement Contact produced while a component tried to move with Sweep enabled. Check whether movement blocked and which component actually moved.
Event Hit / On Component Hit Blocking contact reported by movement or physics. Use the event's Other, Other Comp, and Hit together.
Begin Overlap sweep result Contact details only when the overlap began because the other body moved with a sweep. Check From Sweep before treating the sweep result as contact data.
A stored or made hit result Whatever the code that filled the struct chose to provide. Do not assume optional fields were populated.

Break Hit Result cannot tell you which producer made the value. Keep that context visible in the graph instead of passing anonymous hit results through unrelated systems.

The status fields

Blocking Hit

Blocking Hit is true when this result represents blocking collision. It is not a general "the struct is valid" flag.

  • A single trace node commonly returns the same blocking status on its Boolean Return Value.
  • A multi trace by channel can contain overlap/touch entries where Blocking Hit is false but the entry still describes something encountered.
  • A default/no-hit result also has Blocking Hit = false, so false by itself does not distinguish an overlap entry from no useful result. The producer and the rest of the fields matter.

Initial Overlap

Initial Overlap means the swept query began already penetrating blocking collision. In C++ this field is named bStartPenetrating.

Interpret several outputs differently in that case:

  • Time = 0;
  • Distance = 0;
  • Location and Impact Point are equal;
  • Normal and Impact Normal are equal and describe a direction that can be used to move out of penetration when the query could calculate one.

This is not the same as "first overlap in an array." It is specifically the start-inside/penetration case.

Time, distance, and trace endpoints

Field What it means Common trap
Time Fraction along the attempted trace or sweep, from 0 at Trace Start toward 1 at Trace End. A normally initialized no-hit query result uses 1. It is normalized travel, not seconds.
Distance World-space distance from Trace Start to Location. It is 0 for an initial overlap. It measures to Location, not always the visible contact point.
Trace Start Start point supplied by the query or movement sweep. Event/made results may not carry the deliberate camera trace you expected.
Trace End Furthest endpoint the query attempted. It is not the impact location.

For a straight line trace, this relationship is useful:

approximately:
Location = TraceStart + (TraceEnd - TraceStart) * Time
Distance = length(Location - TraceStart)

Do not use Time as a timer duration. Use it to understand where along the attempted movement or trace the contact occurred.

Location vs Impact Point

For a line trace, the query shape has no thickness, so the two positions are normally equal.

For a swept shape, they answer different questions:

sphere sweep moving right

safe center Location        surface Impact Point
          o-------------------------x| wall
         ( )                         |
  • Location is the world location where the swept shape can be placed at contact without continuing through the blocker. For a sphere sweep, think "sphere center at the stopping pose."
  • Impact Point is the world point where the swept shape touched the object it hit. Spawn a decal, spark, or contact marker here.

For shape traces, placing an impact effect at Location can make it float one radius away from the surface. Placing a teleported character capsule at Impact Point can put its center inside the obstacle. Pick the field by the question.

Normal vs Impact Normal

Normals are world-space direction vectors perpendicular to a contact surface.

  • Normal is the contact normal for the object or shape that was swept. For a sphere sweep, it points toward the sphere's center.
  • Impact Normal is the outward normal of the object that was hit by the sweep. Use it to orient surface effects or reason about the struck surface.
  • For a line test, the swept object has no volume, so Normal and Impact Normal are normally equal.

Hit events can adjust these directions based on which body moved and which actor receives the event. Treat the normal together with that event's Other and Self Moved context rather than assuming every hit result points from attacker to victim.

Actor, component, material, and bone fields

Field What you get Why it may be empty or unhelpful
Hit Actor Actor associated with the hit object/component. The pin is declared Actor; the runtime object can be any Actor subclass. No useful hit, unusual world geometry, or the actor was destroyed before a stored result was read.
Hit Component Exact PrimitiveComponent hit: capsule, mesh, shield, trigger, and so on. The runtime object can be a subclass such as Static Mesh Component. No useful hit, component removed/destroyed, or producer did not provide one.
Phys Mat PhysicalMaterial reported for the contacted surface. The query did not request it, the collision representation has none to return, or the result came from a path that did not fill it.
Hit Bone Name Bone on the skeletal mesh that was hit, when that collision path supplies a bone. Non-skeletal targets, Physics Asset/setup limitations, or no per-bone result.
Bone Name Bone on the swept/"my" side of a two-body contact, when supplied. A simple line trace has no swept skeletal bone, so this is commonly None.
Face Index Triangle/face identifier for supported triangle-mesh or Landscape hits. Simple collision, unsupported geometry, or a query that did not request face data.
Hit Item / Element Index Primitive-specific sub-item identifiers. Meaning varies by component type; they are not universal gameplay IDs.

The Hit Actor pin being typed as Actor does not mean the runtime object is only a base Actor. It can carry your BP_EnemyCharacter; cast, call an interface, or inspect a component only after validating the reference.

Do not save Hit Item, Element Index, or Face Index as durable identity unless the specific component API documents that contract. These are collision-result details, not general SaveGame IDs.

When it "fails" (and what failure does)

The break node itself has no failure path. It accepts an FHitResult value and outputs whatever is in it.

A common no-hit graph looks like this:

Line Trace By Channel
-> Return Value = false
-> Out Hit is still an FHitResult value
-> Break Hit Result safely outputs default/empty fields
-> Hit Actor is None

The dangerous step is not breaking the struct. It is calling a function on an empty Hit Actor or Hit Component afterward.

Common misleading results:

  1. You skipped the producer's Boolean. Default vectors such as (0,0,0) look like a real world point even when no hit occurred.
  2. You expected every multi-hit entry to block. Channel multi traces may include overlap/touch results before the blocker.
  3. You used shape Location as the surface point. The effect floats away from the wall by the shape's radius or extent.
  4. You expected a Physical Material automatically. Optional query and collision setup did not provide it, so Phys Mat is None.
  5. You read a stored result after lifetime changed. Actor/component outputs are object references and can become invalid after destruction.
  6. You treated a Begin Overlap sweep result as unconditional. If From Sweep is false, the event's sweep details are not a reliable contact report.

Failure is silent: no warning, retry, alternate trace, or hidden branch runs.

The pattern everyone actually uses

For a hit-scan interaction or weapon:

Line Trace By Channel
-> Branch Return Value
    false -> clear target / do nothing
    true  -> Break Hit Result
             -> Is Valid (Hit Actor)
             -> filter by interface, class, team, owner, or tag
             -> use Impact Point / Impact Normal for feedback
             -> apply gameplay once

For a multi trace:

Multi Sphere Trace By Channel
-> For Each Out Hits
    -> Break Hit Result
    -> Is Valid (Hit Actor)
    -> if actor not already in HitActorsThisSwing
         add actor to set
         apply gameplay

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

void ATrainingWeapon::HandleTraceHit(const FHitResult& Hit)
{
    AActor* HitActor = Hit.GetActor();
    if (!Hit.bBlockingHit || !IsValid(HitActor))
    {
        return;
    }

    SpawnImpactFeedback(Hit.ImpactPoint, Hit.ImpactNormal);
}

What Break Hit Result does not do

  • It does not perform or repeat a collision query.
  • It does not validate that a hit occurred.
  • It does not guarantee any object output is non-None.
  • It does not choose Location vs Impact Point for your use case.
  • It does not request Physical Material, face, or bone data retroactively.
  • It does not apply damage, spawn feedback, de-duplicate actors, or filter teams/owners.
  • It does not keep hit actor/component references alive and does not replicate the struct for you.

Lookalikes - which one do I want?

Node or operation Use when Watch out
Break Hit Result You already have one hit-result struct and need its fields. It reads; it does not validate or query.
Split Struct Pin You want selected fields directly on a node's Hit Result pin. Same data as breaking the struct; too many split pins can make a graph unreadable.
Make Hit Result You need to construct a struct for an API that accepts one. A made result is only as complete and truthful as the fields you provide.
Line/shape trace You need the world to perform a collision query now. Branch on that node's result before consuming the hit.
Get Overlapping Actors / Components You need current overlap state, not contact position/normal details. These return arrays, not hit results.
Event Hit / On Component Hit You need a callback when blocking movement or physics contact happens. The event is a producer; Break Hit Result only reads its Hit pin.

Rule of thumb: query or receive the contact first, prove what kind of result you have, then break the struct.

Going deeper