Colliders & Baking

For objects to push apart and rest on each other believably, Grabbit needs colliders that match their shape. A simple box or sphere collider is fine for crates and balls, but it's wrong for a chair, a rock, or anything concave. Grabbit solves this by baking accurate colliders from your meshes in the background.

How Grabbit Gets Colliders

When you grab an object, Grabbit needs a collider for it. It draws from, in order of preference depending on your settings:

• Existing colliders already on the object.
• Generated convex colliders: a set of convex pieces that together approximate the mesh's true shape, produced by convex decomposition (the Balance or Precision strategy, see below).
• A quick convex fallback: a single convex collider used immediately while the accurate colliders are still baking.

Grabbit reads geometry from both Mesh Filters and Skinned Mesh Renderers, so rigged props and characters collide and can be placed too (skinned meshes are baked in their bind pose, what the editor shows).

The collider status currently in use is shown in the overlay's object info as one of:

Label	Meaning
Mesh pieces (N)	Accurate generated decomposition, made of N convex pieces
Rough shape	A quick single-collider approximation, shown while the accurate pieces bake
Simple shapes (N)	N fitted boxes / spheres / capsules (the Performance strategy)
Own colliders	The object's own pre-existing colliders
Exact mesh (N)	Colliders Grabbit added for a static obstacle
No collider	No usable collision shape

What Grabbit Won't Grab

Grabbit only drives objects it can build a collision shape for. While the tool is active, selecting anything with no mesh and no collider of its own (a light, a camera, an audio source, an empty parent used for organising) leaves it alone and shows No Mesh Or Collider To Grab next to it in the scene. Nothing is added to the object, and the mode's handles stay hidden until you select something grabbable.

An empty parent still grabs normally when its children carry the geometry: the whole group moves as one object. Terrains are also left alone, since a terrain can't be moved by physics and has to keep colliding as scene geometry while you work.

Baking in the Background

Generating accurate colliders for a detailed mesh takes a moment, so Grabbit does it off the main thread, in a separate helper process. (The helper is a small program compiled locally, the first time it's needed, from readable source that ships with Grabbit; there is nothing to download or install.) That isolation matters in three ways:

• Cancelling is instant. Cancel a bake (from the progress window) and the CPU is freed immediately; you never wait for a half-finished decomposition.
• The editor never waits on a bake. Entering play mode, recompiling scripts, or quitting Unity no longer blocks until an in-flight bake finishes.
• A bad mesh can't take the editor down. If the decomposition library crashes or hangs on a pathological mesh, only the helper process is affected; Grabbit notes the failure, uses the simple convex fallback for that mesh, and won't retry it on every selection. The same applies if the editor is ever closed or crashes mid-bake: on the next launch the interrupted mesh is skipped instead of re-baked into the same problem.

The first time you interact with a complex object Grabbit uses the quick convex fallback, queues the mesh for baking, and seamlessly swaps in the accurate colliders once they're ready.

While baking is running, the overlay shows:

⚙ Baking colliders: N remaining...

Baked results are cached, so each mesh only needs to bake once; subsequent grabs of the same mesh are instant.

When Baking Happens

Two timing options control when meshes are baked:

• On scene open: meshes are baked as the scene loads, so everything is ready before you start. Good for scenes you revisit often.
• On selection: meshes bake the first time you actually select/grab them. Good for very large scenes where you only touch a fraction of the objects.

You can also have Grabbit bake automatically when new models are imported, or batch-bake the whole project at once.

Reviewing and Trimming Baked Colliders

Open Window > Jungle > Grabbit > Baked Colliders to see every mesh Grabbit has baked, each with a live preview, the pieces it produced, and a Regenerate button to rebake that one mesh with different settings. The Grabbit overlay's Baked Colliders button opens the same window already scoped to your current selection.

Decomposition is automatic, so now and then it adds a piece you don't actually want: a thin sliver, a collider filling a gap that should stay open, or a redundant piece on a part the rest already covers. Rather than rebake and hope, you can switch individual pieces off.

Expand a mesh entry and each generated collider gets an on/off toggle. Switch a piece off and Grabbit drops it from the colliders it builds for that mesh, the grabbed object, the static surface, and the dynamic colliders all stop using it, while the piece's data is kept so you can switch it straight back on with no rebake. The change is per source mesh, so it applies to every object that shares that mesh. The entry header shows how many pieces are off and offers Enable All to clear them in one click.

Objects already in the scene pick up the change the next time they're registered, when you grab or re-select them, the same as after a Regenerate. Switched-off pieces are remembered with the bake; a Regenerate starts fresh with every piece back on, since the new decomposition's pieces won't line up with the old ones.

Disable vs. delete

Disabling is reversible and the right tool for trimming a bake. To remove a whole mesh's colliders use the entry's ✕, or Clear All to empty the cache; both are regenerated on demand the next time you grab the object.

Controlling Quality vs. Speed

Collider decomposition trades fidelity against bake time and runtime cost. The key settings (see the Settings Reference for the full list):

Setting	Effect
Use Existing Colliders / Generate Only If None	Whether to use existing colliders, generated ones, or a mix (two toggles on the overlay's Simulation section)
Use dynamic non-convex colliders	Turn multi-piece collider decomposition on or off
Max mesh colliders created	Cap the number of convex pieces per mesh; fewer is faster but coarser. Large surfaces auto-scale the budget upward so they don't get crushed into a few coarse hulls
Collider resolution	How finely the mesh is sampled; higher is more accurate, slower to bake. Resolution also scales with surface size so large meshes get more detail automatically
Adaptive resolution	Let Grabbit pick a resolution per mesh based on complexity
Max concurrent bake jobs	How many meshes bake in parallel. Baking always runs off the main thread, so the editor never blocks. Balance/Precision bakes are additionally capped by your machine's core count, since each one is internally multithreaded

Choose your collider approach at startup

The Grabbit startup window lets you pick a default collider approach: precise concave colliders for accuracy, or the simpler single convex shape for speed. You can change this any time in the settings, or reopen the window from Tools > Jungle > Grabbit > Open Startup Menu.

Performance: Colliding With Static Surfaces

The grabbed object isn't the only collider in play; Grabbit also registers the nearby static surfaces you push against (floors, walls, terrain, props) so objects settle on them. Resolving contact between a moving object and a detailed triangle mesh is the most expensive thing PhysX does here, several times more than free movement, and it's that contact, not the number of objects selected, that drives the slowdown you feel the moment an object touches a surface.

Grabbit picks each surface's collision shape in this order, cheapest-accurate first:

1. The surface's own colliders, if it has any. A surface that already carries a collider (including one you baked permanently) is collided against that; Grabbit no longer also stacks its full mesh on top, so giving your surfaces colliders is now a real speedup.
2. Baked decomposition, if the surface's mesh is in the bake cache. The convex hull pieces follow the true (concave) shape accurately and collide far cheaper than the raw mesh, so baking your scene surfaces speeds up collisions with no accuracy loss. This is automatic; no setting required.
3. The exact mesh otherwise, accurate but the most expensive option.

The Simulation Quality tier also affects how static surfaces collide. On Low, static obstacles that have a baked decomposition use those convex hulls instead of the exact mesh, which is roughly 2-3x cheaper; if no bake exists yet, the exact mesh is used until one finishes. On Medium and above, the exact mesh is always kept so objects rest on the true surface, not a hull that fills concavities. Baking your scene surfaces (option 2 above) is the best way to get both speed and concave accuracy on Low.

Baking Strategy: Balance, Precision, Performance

Grabbit can decompose meshes with one of three strategies, chosen under Project Settings → Grabbit → Collider Baking → Baking Strategy:

Strategy	Best for	Trade-off
Balance (V-HACD)	Most scenes; fast iteration	Voxel-based convex decomposition; the default. Quick to bake, solid all-round accuracy.
Precision (CoACD)	Tricky concave shapes where collision accuracy matters	Collision-aware, captures concavities (holes, handles) more faithfully with fewer colliders, but bakes much slower. It bakes in the background like every method, so the editor stays responsive while it runs.
Performance (Primitives)	Blocky / architectural / kit assets; large scenes	Fits a box, sphere, capsule, cylinder, frustum or trapezoidal prism to each piece instead of a convex collider. Cheapest at runtime, almost no stored data, and box/sphere/capsule are clean native colliders. Less faithful on organic, deeply-concave shapes.

When Precision is selected, an extra Concavity slider appears: lower values preserve finer concave detail (and produce more collider pieces); higher values are coarser and cheaper.

When Performance is selected, two extra controls appear:

• Merge Tolerance: a fidelity floor. By default the decomposition merges pieces down to Max Pieces no matter how loose the fit gets; raise this and a merge is rejected once it would grow a collider past that fraction of the object's bounding box, so more (tighter) pieces are kept where the shape needs them. 0 = off.
• Native Colliders Only: restricts fitting to box / sphere / capsule (Unity's native shapes) and skips cylinder / frustum / trapezoidal prism. Those three have no native collider and bake to small convex mesh colliders, so turning this on trades a little tightness on round/tapered parts for cheaper, fully-native colliders.

Balance and Precision produce convex colliders; Performance decomposes the mesh directly and fits the tightest primitive to each piece (an oriented piece is applied via a rotated child object). Disconnected sub-meshes are bridged so the result still honours Max Pieces. Either way, caching and the overlay labels work the same, the overlay shows Simple shapes (N) or Mesh pieces (N) depending on what was baked.

Switching strategy archives the old bake

Changing the baking strategy does not throw away existing colliders. The old bake is archived, and if you switch back to the same strategy later it is restored instantly with no re-bake. The Baked Colliders browser shows "Also Cached" when an archived bake exists and offers a "Switch To Cached" button to flip back. Clearing or regenerating an entry starts fresh.

Baking Colliders Permanently Onto Objects

The background bake above is a tool cache, it lives in an editor-only asset and is gone in a player build. When you want the generated colliders to become a permanent part of an object (so it ships with accurate collision and needs no Grabbit code at runtime), bake them onto the object directly.

How: select one or more objects and run Bake Colliders…, available as:

• Right-click in the Hierarchy (or the main GameObject menu) → Grabbit → Bake Colliders…, for scene objects and prefab instances.
• Right-click in the Project window (or the main Assets menu) → Grabbit → Bake Colliders…, for prefab assets.
• Tools > Jungle > Grabbit > Bake Colliders On Selection…, or the Bake Onto Selection button in Project Settings → Grabbit → Collider Baking.

A small dialog opens first and asks which collider type to bake — Balance, Precision, or Performance — along with the piece count and the per-child layout, so the result is never a surprise. (The settings-panel button skips the dialog and just bakes with the current strategy.) The dialog's choices override the global strategy for that one bake only; the Precision concavity and the Performance shape set still come from the settings panel.

Automatic fallback on very large meshes

Every strategy has a mesh-size ceiling. If a mesh exceeds the Performance ceiling, Grabbit doesn't fail: it falls back to Balance convex pieces, and to a single convex collider only if that also can't run, logging a warning each time. Balance and Precision cap at 150k faces: past that, a decomposition would burn full-core CPU for a very long time, so Grabbit skips straight to the single-convex-collider fallback (the result is cached, so the mesh isn't re-attempted on every selection). You always get usable colliders. If you do want the heavy bake, the skipped mesh shows up in the Baked Colliders window marked "skipped, too heavy" with a Bake Anyway button: the bake runs in the background and can be cancelled at any point. Otherwise, decimate the mesh if you need an accurate decomposition on a very dense one.

This works on:

• Scene objects and prefab instances (undoable; use Overrides → Apply to push to the prefab).
• Prefab contents opened in Prefab Mode.
• Prefab assets selected in the Project window: Grabbit loads the prefab, bakes, and saves it back automatically. (Imported model prefabs, .fbx/.obj, are read-only; drag one into a scene or make it a regular prefab and bake there instead.)

What it produces, using the current Baking Strategy:

• Balance / Precision → convex hulls, saved as standalone shippable Mesh assets under Assets/Grabbit Baked Colliders/ (folder-mirrored, one asset per mesh, reused by every object that shares that mesh), applied as convex MeshColliders.
• Performance → native BoxCollider / SphereCollider / CapsuleColliders where possible (no stored mesh at all), plus tiny convex hull assets for the cylinder / frustum / prism shapes Unity has no native collider for.

All baked colliders are parented under a single Grabbit Colliders child on the object that holds the mesh. Re-baking simply rebuilds that child, so the action is idempotent, it never piles up duplicates and leaves any hand-authored colliders elsewhere untouched.

One collider per child

By default every piece shares the Grabbit Colliders child. Turn on Each Collider On Own Child (in the Collider Baking settings) to give every piece its own child GameObject, easier to inspect or remove individually. (Oriented box/capsule pieces always get their own rotated child, because Unity's native colliders are axis-aligned to their transform.)

Visualizing Colliders

Toggle Show Colliders in the overlay to see exactly what Grabbit is colliding against. This is the quickest way to diagnose odd settling behavior, if an object passes through something it shouldn't, the visualization usually shows the collider hasn't baked yet (it's still showing Rough shape) or the decomposition is too coarse. Bump the resolution or wait for baking to finish.