Collision meshes

A collision mesh is a simplified, invisible shape that the physics engine uses instead of the visible model. The player walks on it, bullets hit it, physics props bounce off it. The visible model (the render mesh) can have thousands of triangles; its collision is often a handful of boxes.

Collision is part of every game-ready asset. The Level Design Book calls it "one of the biggest issues" when building modular kits (The Level Design Book: Modular kit design). Poor collision can make an otherwise well-made level feel broken.

#Why collision is separate from the render mesh

Three reasons:

1. Cost. Physics tests run constantly. Godot's documentation advises: "try to use a few primitive collision shapes", adding that "Primitive shapes often have the best performance and reliability" (Godot Engine documentation: Node type customization using name suffixes). Unity notes that contact generation "is resource-intensive" (Unity Manual: Mesh collider component reference).
2. Feel. Players should slide smoothly along walls and up stairs, not snag on every bolt and moulding.
3. Gameplay. Collision decides what is walkable and what blocks. It can be bigger, smaller or a different shape from the visible art on purpose.

The player is a collision shape too. The Level Design Book stresses that the player's bounding box is usually much bigger than the character model: "It's not a hitbox" (The Level Design Book: Metrics). Collision on the world has to be designed around that box. See grids and metrics.

#The shape vocabulary

Physics engines handle a few shape types, from cheapest to most expensive:

A convex shape is one where a straight line between any two points inside it stays inside. A box, a sphere and a wedge are convex; an L, an arch and a cup are not. Godot puts it this way: "a convex shape can only accurately represent a shape that doesn't have any concave angles" (Godot Engine documentation: Node type customization using name suffixes).

#Simple and complex collision

Unreal makes the split explicit. Simple collision means "primitives like cubes, spheres, capsules, and convex hulls"; complex collision is "the trimesh of a given object", meaning the render triangles themselves (Epic Developer Community documentation: Simple versus Complex Collision in Unreal…). By default the engine builds both and uses whichever a query asks for (Epic Developer Community documentation: Simple versus Complex Collision in Unreal…).

Each static mesh has a Collision Complexity setting (Epic Developer Community documentation: Simple versus Complex Collision in Unreal…):

• Project Default: simple queries use simple shapes, complex queries use the triangle mesh.
• Use Simple Collision As Complex: everything uses the simple shapes. This can save memory and improve performance, because the triangle mesh does not need to be baked.
• Use Complex Collision As Simple: everything uses the triangle mesh. Epic notes the limitation: "you cannot simulate the object, but you can use it to collide with other simulated (simple) objects" (Epic Developer Community documentation: Simple versus Complex Collision in Unreal…).

Unity has a similar split. A Mesh Collider "takes a mesh asset and builds a collider that matches the geometry of that mesh" (Unity Manual: Mesh collider component reference). Ticking Convex lets it collide with other mesh colliders, but "Convex mesh colliders are limited to 255 triangles" (Unity Manual: Mesh collider component reference). For moving objects, Unity says "primitive colliders can be more efficient because they offer more stability" (Unity Manual: Mesh collider component reference).

#Building collision by hand

#In your 3D software (Unreal naming)

Unreal's FBX importer finds collision meshes by name: "Collision meshes are identified by the importer based on their name" (Epic Developer Community documentation: FBX Static Mesh Pipeline in Unreal Engine). Model the collision shapes next to the render mesh, export both in the same FBX, and name them with a prefix:

The pattern is UCX_[RenderMeshName]_##, and the name must match the render mesh exactly (Epic Developer Community documentation: FBX Static Mesh Pipeline in Unreal Engine). Rules from Epic's pipeline page (Epic Developer Community documentation: FBX Static Mesh Pipeline in Unreal Engine):

• A UCX_ object "can be any completely closed convex 3D shape".
• Boxes must be "a regular rectangular 3D object"; don't move their vertices.
• Capsules and spheres don't need many segments; "8 is a good number", because they are converted to true primitives.
• Spheres are used only for rigid-body collision and zero-extent traces, not for player movement traces.
• Boxes and spheres don't work on non-uniformly scaled meshes; Epic recommends UCX_ shapes instead.
• Several convex hulls work best when they don't intersect.
• When one file holds several meshes with custom collision, "only the first mesh's collision will be imported". Export one asset per file. See 3D file formats.

For concave objects, Epic warns that automatically "Breaking up a non-convex mesh into convex primitives is a complex operation, and can give unpredictable results" (Epic Developer Community documentation: FBX Static Mesh Pipeline in Unreal Engine). Split it yourself: an archway becomes two pillars and a lintel.

#In the engine editor

Unreal's Static Mesh Editor can also add collision directly (Epic Developer Community documentation: Setting Up Collisions With Static Meshes in…):

• Sphere, Capsule, Box add a simple shape around the mesh. New shapes stack: "the new collision does not replace the other collision, but adds to it."
• K-DOP (10, 18 or 26) "takes K axis-aligned planes and pushes them as close to the Static Mesh as possible". A 10-DOP is a box with four bevelled edges; a 26-DOP bevels all edges and corners.
• Auto Convex Collision runs convex decomposition with settings for hull count and precision. "The higher these values, the more precise your collision mesh will be, but also the more complex."
• Without collision, Simulate Physics is unavailable (Epic Developer Community documentation: Setting Up Collisions With Static Meshes in…).

#Godot import hints

Godot reads suffixes on object names when importing a 3D scene (Godot Engine documentation: Node type customization using name suffixes):

• -col adds a static collision child "using the same geometry as the mesh" (a triangle mesh).
• -convcol makes a convex shape instead.
• -colonly removes the visual mesh and keeps only the collision, so you can model collision as separate objects.
• -convcolonly does the same with a convex shape built by "convex decomposition".
• -rigid imports the object as a rigid body.

Godot notes that triangle meshes are accurate but slow, and convex shapes suit simple or dynamic objects rather than level geometry (Godot Engine documentation: Node type customization using name suffixes).

#Collision for level geometry

Collision on architecture is a level-design concern as much as an art one:

• Smooth the walkable surface. One option for stairs is a sloped collision ramp under the visible steps, so the capsule glides instead of stepping on every tread. Test either approach against your step height: in CS:GO the player steps over anything up to 18 units without jumping (World of Level Design: CS:GO SDK Player and Architecture Scale…).
• Leave clearance. The CS:GO player is 72 units tall but needs 73 to pass under something (World of Level Design: CS:GO SDK Player and Architecture Scale…). Build collision with the same margin.
• Block what should be blocked. Invisible blocking volumes stop players from climbing scenery or leaving the map. Use them deliberately and sparingly: an invisible wall in front of something that looks climbable contradicts what the art promises. See affordance.
• Stay inside the footprint. For modular pieces, The Level Design Book says to "stay in footprint / bounding box" and make sure players "can't get stuck" (The Level Design Book: Modular kit design). See modular kits.
• Clutter. Decide per prop whether the player needs to touch it at all. A bottle on the floor may need no collision; a crate the player hides behind needs a box that matches its faces. See set dressing and art passes.

#In different tools

• Unreal Engine: UBX_/UCP_/USP_/UCX_ meshes on import, or shapes added in the Static Mesh Editor; Collision Complexity per mesh (Epic Developer Community documentation: FBX Static Mesh Pipeline in Unreal Engine; Epic Developer Community documentation: Setting Up Collisions With Static Meshes in…; Epic Developer Community documentation: Simple versus Complex Collision in Unreal…).
• Unity: Box, Sphere and Capsule colliders combined on child objects, or a Mesh Collider (Convex limited to 255 triangles) (Unity Manual: Mesh collider component reference).
• Godot: -col, -convcol, -colonly, -convcolonly suffixes, or CollisionShape3D nodes added in the editor (Godot Engine documentation: Node type customization using name suffixes).
• Blender, Maya, 3ds Max: model collision shapes as separate objects with the right names and export them with the render mesh. See the game asset pipeline and modeling software.

#Further reading and watching