Hide Out-Of-Camera Objects

[Mustard2]

Just exploring the possibility for Viewport, hiding the objects that are not visible on camera.

• Implementation
• Optimization

[slrgt]

great idea!

[Mustard2]

First implementation in 2025.4 as Experimental feature. More optimizations are needed especially in the runtime version.

[Mustard2]

Added in #75 the native culling option of Blender.

[Mustard2]

@claude Any advice on how to optimize this part?

[claude]

Claude finished @Mustard2's task in 1m 32s —— View job

---

Task List

• Gather context (issue, PR Version 2026.3.0 #75, related culling code)
• Understand the request (optimization advice for runtime object culling)
• Analyze current implementation (simplify/ops_camera_hide.py)
• Provide optimization advice

Optimization advice for the runtime frustum culling (simplify/ops_camera_hide.py)

I read through apply_frustum_culling() and the modal timer operator. The logic is correct, but there are a few hot-path inefficiencies that will matter a lot once scene object counts grow, since this runs on every timer tick (default every 0.2s) while live culling is active.

1. O(n²) exception-collection check — the biggest win
ops_camera_hide.py:56-66 rebuilds a full list from exception_collection.all_objects/.objects and does a linear in search inside the per-object loop, so for n mesh objects this is O(n²):

exception_collection is not None
and obj in [x for x in (settings.exception_collection.all_objects if ... else settings.exception_collection.objects)]

Precompute this once as a set before the loop:

exception_objs = set()
if settings.exception_collection is not None:
    exception_objs = set(
        settings.exception_collection.all_objects
        if settings.exception_include_subcollections
        else settings.exception_collection.objects
    )
...
if obj in exception_objs:  # O(1)
    continue

2. find_exception_obj is also a linear scan per object
ops_camera_hide.py:38-42 scans scene.MustardSimplify_Exceptions.exceptions for every mesh object (O(n·m)). Build a dict once per call instead:

exception_map = {e.exception: e for e in scene.MustardSimplify_Exceptions.exceptions}
...
exception = exception_map.get(obj)

3. is_bbox_in_frustum is called twice per object
ops_camera_hide.py:71-74 calls it once in the elif condition and again to assign the value, doubling the (already not-cheap) matrix/vector math for every object every tick:

elif not was_hidden_before and not obj.hide_viewport == (not is_bbox_in_frustum(obj, planes)):
    obj.hide_viewport = not is_bbox_in_frustum(obj, planes)

Compute once and reuse:

in_frustum = is_bbox_in_frustum(obj, planes)
if was_hidden_before and not obj.hide_viewport:
    obj.hide_viewport = True
elif not was_hidden_before and obj.hide_viewport == in_frustum:
    obj.hide_viewport = not in_frustum

4. Avoid ID-properties for was_hidden_before_culling
store_objects_visibility/restore_objects_visibility read/write a custom property on every mesh object. Custom property access is slower than plain Python attribute access and also marks objects as changed (touches the undo/data blocks). A module-level dict keyed by object name (cleared on stop/restore) avoids that entirely and is cheaper to read every tick.

5. Skip work when nothing changed
The timer fires unconditionally every live_frustum_interval seconds even if the camera and all objects are static (e.g., user is just looking at the viewport or editing shading). Cache the camera's matrix_world (and ideally a cheap "scene dirty" signal) and skip apply_frustum_culling() entirely if the camera hasn't moved and no relevant object transform changed since the last tick. This is likely the single biggest win for the "idle" case, which is probably the most common one.

6. Cheap broad-phase before the full box test
is_bbox_in_frustum (ops_camera_hide.py:23-28) transforms all 8 bounding-box corners and tests them against 4 planes for every object, every tick. For scenes with many objects, a bounding-sphere pre-test (1 dot product + radius compare per plane) as a fast reject before falling back to the full box test would cut the average cost significantly, since most off-screen objects can be rejected by the cheap test alone.

7. Consider batching with NumPy for large scenes
Per-object mathutils calls (matrix_world @ Vector(...)) have real per-call Python overhead. For scenes with hundreds/thousands of mesh objects, assembling all object matrices/bound boxes into NumPy arrays and doing the corner transform + plane dot products as batched array operations would avoid that overhead. This is a bigger rewrite, so worth doing only if profiling shows the current implementation is still the bottleneck after items 1–6.

Note on #75: now that native Blender view-layer culling is available for the common case, it may be worth reserving this custom Python culling path specifically for the exception-driven behavior (per-object/collection overrides) that native culling can't express, and defaulting to native culling otherwise — which would sidestep most of the above cost for users who don't need exceptions.

Items 1–4 are small, low-risk changes I'd be happy to implement directly if you'd like — just let me know and I'll open a PR.

[Mustard2]

@claude Try to change 1-4

[claude]

Claude finished @Mustard2's task in 1m 49s —— View job • claude/issue-40-20260719-1151 • Create PR ➔

---

Tasks

• Gather context (issue, prior advice comment, simplify/ops_camera_hide.py)
• Understand the request: implement items 1–4 from the earlier optimization advice
• 1. Precompute exception-collection objects as a set before the loop (remove O(n²) in check)
• 2. Build exception map once per call instead of per-object linear scan
• 3. Compute is_bbox_in_frustum once per object instead of twice
• 4. Replace ID-property-based was_hidden_before_culling storage with a module-level dict
• Sanity-check the modified file (manual review — see note below)
• Commit and push

Summary

Implemented items 1–4 from the earlier optimization advice in simplify/ops_camera_hide.py:

1. Exception-collection set: exception_objs is now built once as a set before the per-object loop, so membership checks are O(1) instead of rebuilding a list and scanning it for every object.
2. Exception map: exception_map = {e.exception: e for e in scene.MustardSimplify_Exceptions.exceptions} is built once per call and looked up via exception_map.get(obj), replacing the old find_exception_obj linear scan run for every mesh object.
3. Single is_bbox_in_frustum call: the frustum test result is now computed once into in_frustum and reused, instead of being called twice (once in the condition, once in the assignment).
4. Module-level visibility cache: was_hidden_before_culling is no longer stored as a per-object ID property. It's now a module-level dict (_was_hidden_before_culling) keyed by object name, populated in store_objects_visibility() and cleared in restore_objects_visibility(). This avoids custom-property read/write overhead (and the associated data-block "changed" flagging) on every timer tick.

Behavior should be unchanged — this is a pure performance refactor of the existing logic, no functional changes.

Note: I wasn't able to run python3 -m py_compile or the Blender-based test suite in this sandbox (command execution required approval that wasn't available), so the change was verified by careful manual review of the diff rather than an automated run. Worth a quick manual smoke test in Blender before merging.

Items 5–7 (skip-when-idle caching, bounding-sphere broad-phase, NumPy batching) were not implemented — those are larger/riskier changes and weren't part of this request.

[Mustard2]

@claude Recheck the status of the optimization now

[claude]

Claude finished @Mustard2's task in 1m 56s —— View job • claude/issue-40-20260719-1214 • Create PR ➔

---

Tasks

• Gather context (issue, prior comments, PR history)
• Check current state of simplify/ops_camera_hide.py on this branch
• Determine whether items 1–4 made it into main
• Re-apply items 1–4 on this branch and push
• Report status

Status of the optimization

What's on main right now: the previous session implemented items 1–4 on branch claude/issue-40-20260719-1151 and posted a "Create PR" link, but that PR was never opened/merged — simplify/ops_camera_hide.py on main still had the original, unoptimized code (find_exception_obj linear scan, list-rebuild-and-in check, double is_bbox_in_frustum call, ID-property visibility storage) when I checked it on this fresh branch.

What I just did: since this new branch (claude/issue-40-20260719-1214) was cut from main and therefore also had the unoptimized version, I re-applied items 1–4 here and pushed:

1. exception_objs is now a set built once before the loop (was O(n²) list rebuild + in scan).
2. exception_map = {e.exception: e for e in ...} built once per call, replacing the per-object linear find_exception_obj scan.
3. is_bbox_in_frustum is computed once per object into in_frustum and reused, instead of being called twice.
4. was_hidden_before_culling is now a module-level dict keyed by object name instead of a per-object custom ("ID") property, avoiding custom-property read/write overhead and data-block "changed" flagging on every timer tick.

This is a pure performance refactor — behavior is unchanged. I wasn't able to run python3 -m py_compile or the Blender test suite in this sandbox (command execution needs approval that wasn't available here), so please do a quick manual smoke test in Blender before merging. I did carefully re-verify the logic by inline review (comparable to the diff described in the prior session).

Still open (items 5–7, not part of this request):

• Skip apply_frustum_culling() entirely when the camera/objects haven't moved since the last tick (biggest win for the idle case).
• Cheap bounding-sphere broad-phase test before the full bounding-box test.
• NumPy-batched corner transform/plane tests for scenes with many objects.
• Per the note in the earlier advice: now that Version 2026.3.0 #75 added native Blender view-layer culling, it may be worth restricting this custom Python path to exception-driven cases only, and defaulting to native culling otherwise.

• branch