Direct answer: fix Blender collision and scale before reimporting to Unreal
For a static mesh, create simple collision as separate convex Blender objects, apply object rotation and scale, and name each hull after the render mesh with Unreal's collision prefix, for example UCX_Rock_01_00, UCX_Rock_01_01. Export the render mesh and its collision objects together, keep Import Collision enabled, then open the Static Mesh Editor and use the collision visualization to confirm the imported hulls match the asset.
For a skeletal mesh, UCX hulls are not a substitute for a Physics Asset. First prove that the skeletal mesh, armature, bones, and animation arrive at the correct size. Then create or regenerate the Physics Asset and inspect its bodies and constraints. If the Physics Asset is roughly 100 times too large or small, fix the Blender unit/object/armature export chain before manually resizing every body. A one-hundred-times symptom is evidence of a unit conversion boundary, not a reason to hide the source error in the Physics Asset.
This is the shortest reliable Blender-to-Unreal path: prepare and name in Blender → export a controlled FBX → import once into a clean Unreal folder → preview scale and collision → fix the source or importer boundary → optimize hull count → reimport → validate in a representative map. Do not accept a successful import dialog as proof that collision, scale, materials, animation, or runtime cost is correct.
Choose the right collision owner before editing
The first decision is whether the asset is static or skeletal. A Static Mesh stores simple and complex collision in its Static Mesh asset. A Skeletal Mesh normally uses a Physics Asset containing bodies and constraints associated with its skeleton. These pipelines can fail in similar-looking ways, but they have different owners and different fixes.
| Asset and symptom | Collision owner | First place to inspect | Avoid | |---|---|---|---| | Static prop blocks the player in the wrong shape | Static Mesh simple collision / BodySetup | UCX names, convexity, import option, Static Mesh Editor | Editing the render mesh just to hide a collision error | | Static prop has no custom collision after import | FBX custom collision objects | Exact render-mesh name and UCX_ suffix, applied transforms | Assuming a Blender collection name becomes a collision name | | Skeletal character or vehicle has giant physics bodies | Physics Asset plus skeletal import scale | Mesh bounds, armature/bone scale, FBX unit conversion | Shrinking every body by eye before fixing the scale chain | | Animation size differs from the reference mesh | Skeletal Mesh and animation import | Skeleton identity, export set, transform and import settings | Treating it as a Physics Asset-only problem |
Epic's FBX Static Mesh Pipeline documents custom collision naming and import behavior. Epic's Physics Asset Editor is the source of truth for bodies, constraints, and skeletal physics. Keep those systems separate while debugging.
Prepare a one-metre scale witness in Blender
Before touching the production asset, add a simple reference object with a known real-world dimension, such as a one-metre cube. Put it beside the asset, record the Blender scene unit settings, and inspect object scale, rotation, dimensions, origin, and parent transforms. The purpose is not to enforce one universal Blender preset; it is to make the conversion observable.
Unreal's world scale is centimetre-based. A one-metre witness should therefore measure 100 Unreal units after import. If the witness and mesh disagree, the error is already in the source hierarchy or export selection. If both arrive wrong by the same factor, the export/import unit boundary is the better suspect. If the render mesh is correct but generated Physics Asset bodies are wrong, inspect armature and bone scale plus Physics Asset generation rather than changing the whole level.
For a disposable test copy, apply Rotation and Scale to the render mesh and custom-collision objects so their object transforms read as expected before export. Treat a rigged armature more carefully: applying transforms can change an established rig or animation relationship. Duplicate the file, preserve the known-good version, and confirm reference mesh and animation behavior after any armature change.
Record four values in the handoff note: Blender scene units, render-object dimensions, object/armature scale, and expected Unreal dimensions. That small table prevents a teammate from repeating a 100× conversion without knowing where it entered.
Build UCX collision that Unreal can import
Use custom UCX geometry for static props when primitives are not enough. Duplicate or model a low-complexity hull around each solid region, then separate concave shapes into multiple convex pieces. Keep the hulls simple: collision is evaluated frequently, so a dense duplicate of the visible mesh defeats the purpose of simple collision.
Match the render mesh name exactly. If the visible object is SM_Cliff_A, use names such as UCX_SM_Cliff_A_00, UCX_SM_Cliff_A_01, and UCX_SM_Cliff_A_02. The numeric suffix distinguishes hulls; the UCX_ prefix identifies them as convex collision. Apply transforms to the render mesh and hulls in the controlled test file, confirm the hull origins and dimensions align, and export them in the same FBX selection.
Do not rely on a Blender collection, viewport color, material, or parent name to communicate collision intent. Unreal reads the exported object names and geometry. Also avoid overlapping or paper-thin hulls where possible. If a complex opening matters to gameplay, build several clean convex hulls around the opening and verify the traversable space in Unreal rather than trusting the Blender viewport.
Export a controlled FBX instead of a whole scene
Select only the render mesh, its UCX objects, and the rig/animation objects that belong to this test. Export to a new FBX so an old file cannot mask the result. Preserve a screenshot or text record of the exporter version, selected-object setting, transform settings, axis settings, unit conversion, and animation choices.
Epic's current FBX pages state that Unreal's FBX pipeline uses FBX 2020.2. An exporter can still write a usable file from a newer DCC release, but when behavior differs, reduce the test to one mesh and compare against the pipeline version Epic documents. Do not claim that a filename extension alone proves compatibility.
For static collision debugging, leave out the armature, animation, unrelated meshes, cameras, and lights. For skeletal debugging, export one reference mesh and one short animation first. The smaller file makes it possible to answer whether the failure belongs to object naming, source transforms, importer options, skeleton reuse, or Physics Asset generation.
Import and prove static collision in Unreal
Import the FBX into a clean test folder, not directly over the production asset. Keep Import Collision enabled for the static-mesh test. Open the resulting Static Mesh asset and inspect its dimensions, pivot, materials, normals, LOD state, and collision visualization. The custom hulls should appear as simple collision around the visible mesh; the UCX objects should not appear as ordinary render meshes.
Use at least two tests. First, enable collision visualization in the Static Mesh Editor and inspect every side and opening. Second, place the asset in a representative map and test the actual trace or pawn that matters. A hull can look plausible yet still block a doorway, miss a step, or behave differently under the project's collision channels.
Check the Static Mesh collision complexity setting before drawing conclusions. Use Complex Collision As Simple may make a scene appear fixed while bypassing the intended UCX hulls, and it changes performance and simulation trade-offs. Keep the project's actual query/simulation needs visible and do not use a complexity switch to conceal an import mismatch.
Diagnose “imported collision does not match UCX”
An Epic forum report dated July 2026 describes imported collision that does not match the supplied UCX meshes. Treat that report as a discovery signal, not a universal engine defect. Reproduce the asset with a clean import and work through the ownership chain:
- Confirm the exported render-mesh name exactly matches the text after
UCX_. - Confirm every custom hull is convex, closed, selected, and exported in the same FBX.
- Confirm render mesh and hull dimensions, origins, rotation, and scale align in Blender.
- Confirm Import Collision is enabled and the UCX objects did not arrive as visible meshes.
- Compare a new clean import with reimport of the existing asset; stale asset settings can make these paths differ.
- Inspect simple collision in the Static Mesh Editor, then test the real pawn or trace channel.
If one large UCX object is being decomposed in an unexpected way, replace it with several explicitly convex hulls and name each hull separately. If a clean test imports correctly but the production reimport does not, compare the existing Static Mesh's collision and reimport state before changing the Blender source again. Preserve both receipts so the team knows whether the fix was source geometry or asset state.
Diagnose 100× Physics Asset scale
Another July 2026 Epic forum report describes a Blender scale problem visible in a Physics Asset. Begin outside the Physics Asset Editor. Verify the imported Skeletal Mesh bounds against the one-metre witness, inspect the Skeleton tree and reference pose, and play a short known animation. Epic's FBX Skeletal Mesh Pipeline provides the versioned import context; the Physics Asset should be diagnosed only after the skeletal data is known to be coherent.
Use this split:
- Mesh, bones, and animation are all 100× wrong: return to Blender scene/object/armature units and the FBX unit-conversion path.
- Mesh is right but bones or animation are wrong: compare armature and bone transforms, export selection, skeleton reuse, and animation import settings.
- Mesh and animation are right but generated bodies are wrong: create a new test Physics Asset, review minimum bone size and generation choices, and compare it with the old asset.
- Only one body is wrong: inspect the owning bone and local constraint/body transform rather than rescaling the entire asset.
Do not use a blanket 0.01 or 100 multiplier without first recording which boundary it corrects. A magic factor can make the editor look right while leaving animation retargeting, sockets, root motion, attached props, or runtime physics inconsistent. After the source chain is corrected, regenerate or deliberately rebuild the affected bodies and constraints, then repeat the same movement and simulation test.
Optimize collision without changing gameplay
Collision quality is not measured by how closely the hulls imitate every vertex. Use the fewest convex hulls that preserve the gameplay spaces, contact surfaces, and trace results the asset actually needs. Record hull count and test it with the character capsule, camera traces, projectiles, navigation, and physics simulation that apply to the asset.
Keep render optimization and collision optimization separate. Nanite or a dense render mesh does not automatically provide an appropriate simple collision representation. Likewise, a visually low-poly asset can still have poor collision if its hull blocks entrances or contains many unnecessary pieces. Profile the representative map and validate packaged behavior on target hardware when collision volume or simulation count is meaningful.
For team handoff, store the Blender source, exported FBX, expected Unreal dimensions, UCX naming list, engine version, importer settings, Static Mesh or Physics Asset path, and the acceptance test. Reimport once from that package. If the result changes, the pipeline is not yet reproducible.
Where SEELE fits—and where it does not
SEELE can support the pre-Unreal asset workflow: upload or import an exported model, preview it, identify scale/material/geometry issues, optimize or convert a supported asset, and carry a cleaner deliverable into Unreal validation. The Unreal 3D asset optimizer is a relevant handoff for that pre-import work.
SEELE does not open or modify a native .uproject, install an Unreal plugin, author a Physics Asset inside Unreal, configure collision channels, regenerate bodies, enable Nanite, compile Blueprint or C++, or prove packaged-build behavior. UCX import, Physics Asset editing, collision-channel tests, performance checks, and final acceptance remain in the real Unreal game.
Continue with the UE 5.8 FBX import performance checklist for the broader interchange pipeline, the 3D model file formats guide when choosing FBX, glTF, OBJ, or USD, and the Chaos Physics guide for engine-side concepts. This page owns the Blender-specific UCX and Physics Asset scale troubleshooting intent rather than creating another near-duplicate route.
Official sources and evidence limits
- Epic: FBX Static Mesh Pipeline — custom collision naming, static-mesh import, and FBX pipeline behavior.
- Epic: Physics Asset Editor — skeletal bodies and constraints.
- Epic: FBX Skeletal Mesh Pipeline — skeletal mesh and animation import context.
- Epic forum: Physics Asset Blender scale issue — dated problem signal; not treated as an official universal fix.
- Epic forum: imported collision does not match UCX meshes — dated problem signal; not treated as proof of an engine-wide regression.
Engine import behavior can vary with Unreal version, Blender exporter version, project settings, asset history, and the exact FBX. Preserve those versions with the reproduction. Where the two forum reports do not provide a confirmed Epic resolution, this guide gives a controlled diagnostic path instead of presenting speculation as a released fix.
Frequently asked questions
What is the correct UCX naming convention from Blender to Unreal?
Name each convex collision object with UCX_, then the exact render-mesh object name, then a unique numeric suffix. For a mesh named SM_Rock_A, use UCX_SM_Rock_A_00, UCX_SM_Rock_A_01, and so on. Export the render mesh and hulls together, keep Import Collision enabled, and verify simple collision in the Static Mesh Editor.
Why does Unreal ignore my UCX collision from Blender?
Start with exact object names, export selection, applied transforms, and convex closed hulls. Confirm Import Collision is enabled and test a clean import, because an existing Static Mesh can preserve settings that make reimport behave differently. If a concave shape is required, split it into several simple convex UCX objects and validate the actual pawn or trace channel.
Why is my Blender Physics Asset 100 times too large in Unreal?
A roughly 100× mismatch usually points to a metre-to-centimetre conversion boundary in scene, object, armature, export, or import state. Check a one-metre witness, Skeletal Mesh bounds, bone scale, and animation before resizing Physics Asset bodies. Fix the earliest wrong boundary, then create or rebuild the Physics Asset and retest constraints and simulation.
Should I use UCX collision for a skeletal mesh?
UCX naming is primarily part of the Static Mesh custom-collision pipeline. Skeletal meshes normally use a Physics Asset whose bodies are associated with skeleton bones. Diagnose the Skeletal Mesh, Skeleton, and animation scale first, then edit or regenerate the Physics Asset. Do not treat static UCX hulls as a universal replacement for skeletal physics bodies.
Should I enable Use Complex Collision As Simple when UCX fails?
Not as the first fix. That setting can make traces appear correct by using render geometry instead of the intended simple hulls, but it changes performance and simulation trade-offs. First prove why UCX was not imported or matched, then choose collision complexity deliberately for the asset and validate the project's real query, navigation, and physics needs.
Can SEELE fix UCX collision or a Physics Asset inside my Unreal game?
No. SEELE can help preview, inspect, optimize, or convert a supported exported 3D asset before Unreal import. It does not modify a .uproject, author collision in the Static Mesh Editor, create Physics Asset bodies, configure collision channels, install plugins, or validate a packaged build. Complete and verify those steps in Unreal Editor.
