Fix #571: Loose-island collider generation hangs and crashes for large assets

[amechtley]

Issue

Generating colliders from a mesh with an EdgeSplit modifier and "Use Modifier Stack" disabled caused Simple Collider to hang indefinitely or crash with a RecursionError. The root cause was that apply_all_modifiers() was called unconditionally before island detection, splitting what should have been a single mesh into ~11k separate triangle islands. Once that many islands were in play, a cascade of quadratic and linear-per-island operations made the operator unusable. Post-hang generation also left thousands of orphaned mesh data blocks in bpy.data.meshes.

The root causes were spread across several files and compounded each other; no single change was sufficient to unblock the pathological case.

---

Root causes and fixes

1. RecursionError + O(N²) island detection (mesh_split_by_island.py)

Problem: _get_linked_faces() was a recursive DFS that hit Python's default recursion limit on large connected islands. A sys.setrecursionlimit workaround masked a separate RecursionError in Welzl's algorithm (fixed in PR #594). The extend()-based result accumulation was also O(N²) — every level of recursion copied partial results up the call stack. construct_python_faces() used a linear scan (v.co not in py_verts) for vertex deduplication, another O(N²) operation. get_face_islands() carried a mutable default argument (face_islands=[]) that caused islands from one call to bleed into the next.

Fix: Convert both functions to iterative algorithms. _get_linked_faces() uses an explicit stack and BMFace.tag to track visited faces — O(N) with no recursion. _get_face_islands() iterates over all faces and skips already-tagged ones, eliminating the recursive get_face_islands() wrapper and the mutable-default-argument bug. construct_python_faces() replaces the list scan with a dict keyed on BMVert objects for O(1) lookup. bm.faces.ensure_lookup_table() is removed since the iterative code never accesses faces by integer index.

Measured speedup (Apple M4 Max, Blender 5.0.1, 50×50 grid, 50 trials):

	mean	median	std dev	min	max
Before (v1)	150.807 ms	149.910 ms	2.614 ms	147.464 ms	160.670 ms
After (v2)	2.030 ms	1.776 ms	1.030 ms	1.700 ms	6.486 ms

~84× speedup (median).

---

2. Modifiers applied unconditionally; edit-mode leak (mesh_split_by_island.py, add_bounding_primitive.py)

Problem: apply_all_modifiers() was called at the loose-island split site regardless of my_use_modifier_stack. Any object with a modifier had it baked into the mesh before island detection even when "Use Modifier Stack" was OFF. create_objs_from_island() switched to edit mode via bpy.ops.object.mode_set() + bmesh.from_edit_mesh(), then called bm.free() on the resulting bmesh — which is owned by Blender's edit-mesh system and must not be freed by the caller. The object was also left in edit mode after the function returned.

Fix: Guard apply_all_modifiers() with if self.my_use_modifier_stack. Replace the mode_set + from_edit_mesh pattern in create_objs_from_island() with bmesh.new() + bm.from_mesh(obj.data), which reads the same mesh data without any mode switch, owns the bmesh correctly, and leaves the object in OBJECT mode.

---

3. O(N²) hide_set calls; O(N) depsgraph evaluations during parenting (add_bounding_primitive.py)

Problem: primitive_postprocessing() (called once per collider) iterated self.tmp_meshes and called hide_set(True) on every entry — N iterations over N objects = N² calls for N islands (~121 million for 11k islands). custom_set_parent() used bpy.ops.object.parent_set(), which triggers a full depsgraph evaluation on every call; with N islands that is N full rebuilds, each growing more expensive as the scene accumulates objects.

Fix: Move the tmp_meshes hide loop from primitive_postprocessing() to reset_to_initial_state() (called once per execute()), reducing N² calls to N. Replace bpy.ops.object.parent_set() with direct Python matrix assignment:

mtx = Matrix.LocRotScale(child.location, child.rotation_euler, child.scale)
child.parent = parent
child.matrix_parent_inverse = parent.matrix_world.inverted()
child.matrix_world = mtx

child.matrix_world is only updated by the depsgraph; for cylinder and sphere colliders obj.location is set after the last depsgraph-updating operation, so matrix_world is stale and would capture the old cursor/origin position rather than the intended center. child.location, child.rotation_euler, and child.scale are always current because they are stored directly on the object, not computed by the depsgraph. This defers all depsgraph evaluation to Blender's natural update cycle.

---

4. O(N²) name search in unique_name() (add_bounding_primitive.py)

Problem: unique_name() reset its counter to 1 on every call. With N islands all sharing the same name base, total bpy.data.objects lookups were 1 + 2 + … + N ≈ N²/2 — about 60 million for 11k islands.

Fix: Add an optional cache parameter (a plain dict mapping base name → last used count). Each subsequent call for the same base starts from the cached position rather than restarting at 1, reducing total lookups to O(N). The cache is initialised in __init__(), reset to {} at the start of each execute(), and threaded through collider_name() and class_collider_name(). All callers outside the operator hierarchy (e.g. regenerate_name, convert_to_shape) pass no cache and retain their existing search-from-1 semantics.

---

5. Orphaned mesh data + stale StructRNA in remove_objects() (add_bounding_primitive.py)

Problem: The per-object bpy.data.objects.remove() loop left associated bpy.types.Mesh data blocks orphaned in bpy.data.meshes. For the 11k-island case this accumulated ~22k orphaned meshes per execute cycle. Additionally, get_pre_processed_mesh_objs() appends tmp_ob to self.tmp_meshes then removes it via the modifier-stack path; the stale Python StructRNA wrapper remained in the list, and accessing ob.data on it raised ReferenceError on the next call to remove_objects().

Fix: Switch to bpy.data.batch_remove(). Before building the removal list, collect each object's bpy.types.Mesh when ob.data.users == 1 (exclusively owned) and add it to the same batch. Wrap per-object data access in try/except ReferenceError to silently skip stale wrappers. Also consolidate the hand-rolled removal loop in cancel_cleanup() to call remove_objects(), giving it the same batch behaviour and mesh cleanup.

---

6. O(N²) depsgraph re-evaluations in the confirmation loop (add_bounding_primitive.py, utility_operators.py)

Problem: Two independent sources of per-object depsgraph updates in the confirmation loop compounded to 2N evaluations for N colliders (~20k for 10k islands):

• set_origin_to_center_of_mass() called evaluated_depsgraph_get() internally; each preceding obj.location = com dirtied the depsgraph, so every call forced a full scene re-evaluation (O(N²) total).
• fix_inverse_matrix() called view_layer.update() once per object (N evaluations), and the confirmation loop called it again before each fix_inverse_matrix() call (another N).

Fix: Add an optional depsgraph parameter to set_origin_to_center_of_mass(); hoist a single evaluated_depsgraph_get() call before the loop and pass it to every iteration. Add update_depsgraph=True to fix_inverse_matrix(); set it to False in the confirmation loop and bracket the entire pass with two view_layer.update() calls (one before, one after), reducing 2N evaluations to 2.

---

Test status

tests/test_mesh_split_by_island.py — 7/7 pass

Test	Result
test_single_island	pass
test_two_islands	pass
test_many_islands	pass
test_connected_faces_single_island	pass
test_large_connected_island	pass
test_performance_large_connected_island	pass
test_performance_many_disconnected_islands	pass

tests/test_bounding_object_operator.py — 14/14 pass (1 skipped without macOS extension support)

Test	Result
TestApplyModifiersGuard.test_modifier_not_applied_when_stack_disabled	pass
TestApplyModifiersGuard.test_modifier_applied_when_stack_enabled	pass
TestCreateObjsFromIsland.test_does_not_leave_object_in_edit_mode	pass
TestCreateObjsFromIsland.test_returns_one_object_per_island	pass
TestCustomSetParentPreservesTransform.test_child_parent_is_set	pass
TestCustomSetParentPreservesTransform.test_child_world_transform_preserved	pass
TestCustomSetParentPreservesTransform.test_child_world_position_when_location_set_without_depsgraph_update	pass
TestFixInverseMatrixUpdateDepsgraph.test_batched_result_matches_individual	pass
TestPrimitivePostprocessingDoesNotHideTmpMeshes.test_does_not_hide_tmp_meshes	pass (requires add-on enabled)
TestRemoveObjectsCleansUpMeshData.test_mesh_data_removed_with_objects	pass
TestRemoveObjectsCleansUpMeshData.test_shared_mesh_data_not_removed	pass
TestRemoveObjectsCleansUpMeshData.test_handles_stale_object_reference	pass
TestSetOriginToCoMDepsgraphParam.test_prefetched_depsgraph_matches_result	pass
TestUniqueNameDoesNotRestartCounterPerCall.test_call_count_is_linear_not_quadratic	pass

TestPrimitivePostprocessingDoesNotHideTmpMeshes requires the add-on to be fully enabled so that its custom Scene.active_physics_material property is registered. On platforms not listed in blender_manifest.toml (currently windows-x64 and linux-x64) the extension fails to enable and the test is skipped cleanly. A later PR will add macos-arm64 support, but I confirmed the test passes on macOS with local changes.

---

Files changed

File	Change
bmesh_operations/mesh_split_by_island.py	Iterative island/face traversal, O(1) vertex dedup, mutable-default fix
collider_shapes/add_bounding_primitive.py	Modifier guard, hide-loop relocation, direct-assignment parenting, naming cache, batch removal, hoisted depsgraph
collider_operators/utility_operators.py	update_depsgraph parameter for fix_inverse_matrix()
tests/test_mesh_split_by_island.py	New unit and performance tests
tests/test_bounding_object_operator.py	New integration and unit tests for all fixes

[Weisl]

Hi,
I set up a simple test case to try out the changes and noticed some unexpected behavior with the loose islands feature. Specifically, I created a cube, duplicated it 150 times in a spiral using an array modifier, applied a box collider, and enabled both “Use Modifier” and “Use Loose Islands.” The resulting mesh collisions don’t seem to match what I’d expect—you can see the issue in the attached screenshot and test file.

Screenshot:

Test File:
Loose_island_testcase.blend.zip

’ll do some more testing on my end to better understand the root cause, but I wanted to share this with you in case you have a chance to look into it. Let me know if you need more details or if there’s anything else I can provide to help debug this.
Thanks again for your contribution!

[Weisl]

See previous comment.

[amechtley]

Interesting! This is what I see when I try that file locally, which as far as I can tell is the same before and after the changes.

Just for the sake of being thorough, are you able to make a recording using ScreenCast Keys or something similar?

[amechtley]

(As a note - I also gave it a try on a Windows machine and see the same there, too, so at least that much is ruled out.) So maybe also a screenshot or copy of your current settings for the add-on could help!

[Weisl]

I applied the modifier to simplify the test case. It does not appear to have an impact on the result. This time I also noticed that it works at times and produces different results when applied multiple times: See the video:

571_incosistant_result.mp4

I use the default addon settings and am currently testing on a linux machine. I will test on windows next:

[Weisl]

Looks like this only happens on Linux—Windows is fine. Any idea why the OS would make a difference?
If we can’t track it down, maybe we should just disable loose island on Linux for now. Better to have it work reliably for most users than be flaky for everyone.

windows_losse_parts.mp4

[amechtley]

Is it possible it is just a graphics issue, though the colliders themselves are correct?

E.g., if you produce the colliders on Linux, save them, and open the file on Windows, does it look correct? What about going the other direction?

[Weisl]

Opening the Blend file generated on Linux in Windows does not solve the issue. The collider mesh is apparently being generated incorrectly. The process works fine the other way around.

Linux -> Windows (mesh still broken)
Windows -> Linux (mesh OK)

[amechtley]

Just to confirm: Is the weird behavior with the array-of-cubes a regression introduced by these changes, or does it also appear like that in main?

[Weisl]

It appears to work on main. I made a smaller test case so that it wouldn't crash.

main.mp4

[amechtley]

OK I will set up a Linux VM locally and see if I can reproduce the issue! Am I right you are using Ubuntu?

[Weisl]

It appears that both main and pr/603 work on the smaller test case. I need to leave now

[Weisl]

I am using Mint (Ubuntu based)

[amechtley]

Just a quick update: I did manage to get a VM setup with Mint today, and can reproduce the problem on my end, so should be able to get it figured out :)

[amechtley]

Ok! I managed to fix it locally with d81fb2f. Please give it a try and see if it works again :)

[Weisl]

The Use Loose Island command is working as expected now. Thank you for all your hard work. I appreciate the general performance and cleanup improvements, especially the significant reduction in dependency graph updates. This benefits the entire addon.
Looking at the code and checking the comments, I feel like I can learn a lot from you! Great update.

[Weisl]

I'm having trouble understanding the cache parameter. It appears to be either "None" or an empty dictionary, but I'm not sure where it's set or used. I understand that it is used for counting in the naming process, but I don't know how.

[amechtley]

Hey! So the idea behind the default None value is just that other call sites outside add_bounding_primitive.py don't have to be updated to continue functioning as they were. (Though looking at this, there's only one other call site and it would probably also benefit from using the cache - I'll take care of that quick in a follow-up.)

Where we get a benefit is when we know we need to create a bunch of unique names in one go (i.e. tons of islands). In that case, we don't need/want to start counting from 1 every time we need a new name - we want to count from the last number we know we used. As you noted, the add_bounding_object base class basically creates an empty one when a new operator instance is created, but also each time the base execute() implementation is called. So we have a clean cache for each execute() call, which may get used thousands of times for that single run.