Fix depth-aware sorting for offscreen entity rendering

- calculate distances from the camera to ensure proper selection order, improving visual accuracy and interaction responsiveness.

Author: ra100

draw_handler.py

@@ -4,6 +4,7 @@
 import gpu
 from bpy.types import Context, Operator
 from bpy.utils import register_class, unregister_class
+from mathutils import Vector
 
 from . import global_data
 from .utilities.preferences import use_experimental
@@ -12,29 +13,78 @@
 logger = logging.getLogger(__name__)
 
 
+def get_entity_distance_from_camera(entity, context):
+    """Calculate the distance from the entity to the camera for depth sorting."""
+    try:
+        # Get camera/view location
+        view_matrix = context.region_data.view_matrix
+        camera_location = view_matrix.inverted().translation
+
+        # Get entity location (use placement method if available, otherwise try common location attributes)
+        if hasattr(entity, 'placement'):
+            entity_location = entity.placement()
+        elif hasattr(entity, 'location'):
+            entity_location = entity.location
+        elif hasattr(entity, 'p1') and hasattr(entity.p1, 'location'):
+            # For entities like workplanes that have a p1 point
+            entity_location = entity.p1.location
+        else:
+            # Fallback: return a large distance so entity is drawn first (behind others)
+            return float('inf')
+
+        # Calculate distance
+        if hasattr(entity_location, '__len__') and len(entity_location) >= 3:
+            entity_pos = Vector(entity_location[:3])
+        else:
+            entity_pos = Vector(entity_location)
+
+        return (camera_location - entity_pos).length
+
+    except Exception as e:
+        logger.debug(f"Error calculating distance for entity {entity}: {e}")
+        # Return large distance on error so entity is drawn first
+        return float('inf')
+
+
 def draw_selection_buffer(context: Context):
-    """Draw elements offscreen"""
+    """Draw elements offscreen with depth-aware sorting"""
     region = context.region
 
     # create offscreen
     width, height = region.width, region.height
     offscreen = global_data.offscreen = gpu.types.GPUOffScreen(width, height)
 
     with offscreen.bind():
+        # Enable depth testing for proper z-buffer behavior
+        gpu.state.depth_test_set('LESS')
+        gpu.state.depth_mask_set(True)
 
         fb = gpu.state.active_framebuffer_get()
-        fb.clear(color=(0.0, 0.0, 0.0, 0.0))
+        fb.clear(color=(0.0, 0.0, 0.0, 0.0), depth=1.0)
 
-        entities = list(context.scene.sketcher.entities.all)
-        for e in reversed(entities):
+        # Get all selectable entities
+        entities = []
+        for e in context.scene.sketcher.entities.all:
             if e.slvs_index in global_data.ignore_list:
                 continue
             if not hasattr(e, "draw_id"):
                 continue
             if not e.is_selectable(context):
                 continue
+            entities.append(e)
+
+        # Sort entities by distance from camera (farthest first)
+        # This ensures closer entities are drawn last and have selection priority
+        entities.sort(key=lambda e: get_entity_distance_from_camera(e, context), reverse=True)
+
+        # Draw entities in distance-sorted order
+        for e in entities:
             e.draw_id(context)
 
+        # Restore default depth state
+        gpu.state.depth_test_set('NONE')
+        gpu.state.depth_mask_set(False)
+
 
 def ensure_selection_texture(context: Context):
     if not global_data.redraw_selection_buffer:

model/workplane.py

@@ -96,15 +96,17 @@ def draw_id(self, context):
             # This makes the entire plane selectable, not just the edges
             super().draw_id(context)
 
-            # Additionally draw the surface for selection
+            # Additionally draw the surface for selection with slight depth offset
+            # This ensures the surface is slightly behind the outline
             shader = self._id_shader
             shader.bind()
 
             from ..utilities.index import index_to_rgb
             shader.uniform_float("color", (*index_to_rgb(self.slvs_index), 1.0))
 
             coords = draw_rect_2d(0, 0, self.size, self.size)
-            coords = [Vector(co)[:] for co in coords]
+            # Add small negative Z offset to push surface slightly behind outline
+            coords = [(co[0], co[1], co[2] - 0.001) for co in coords]
             indices = ((0, 1, 2), (0, 2, 3))
             batch = batch_for_shader(shader, "TRIS", {"pos": coords}, indices=indices)
             batch.draw(shader)