#548 Some vallidation

Author: Weisl

__init__.py

@@ -13,6 +13,7 @@
     importlib.reload(rigid_body)
     importlib.reload(presets)
     importlib.reload(preferences)
+    importlib.reload(validation)
 
 
 else:
@@ -27,6 +28,7 @@
     from . import rigid_body
     from . import presets
     from . import preferences
+    from . import validation
 
 def register():
     # call the register function of the submodules.
@@ -44,8 +46,14 @@ def register():
     groups.register()
     properties.register()
 
+    # depends on collider_shapes, pyshics_materials and preferences being
+    # registered already (naming/material checks read from them)
+    validation.register()
+
 
 def unregister():
+    validation.unregister()
+
     properties.unregister()
     groups.unregister()
     # call unregister function of the submodules.

bmesh_operations/voxel_generation.py

@@ -51,14 +51,17 @@ def _clamped_voxel_size(bbox_min, bbox_max, voxel_size, padding):
 def _grid_dims_and_origin(bbox_min, bbox_max, voxel_size, padding):
     """Grid cell counts per axis, and the world position of cell (0, 0, 0).
 
-    Rounds each axis to the *nearest* whole number of cells rather than
-    always up, then centers that core region on the mesh's bbox. Any leftover
-    slack (or shortfall) from the rounding is split evenly between the two
-    sides -- so the grid hugs the source surface as closely as possible
-    instead of always growing outward to guarantee full containment.
+    `voxel_size` rarely divides the bbox evenly, so a whole number of cells
+    always has to round up to at least `ceil(size / voxel_size)` -- that part
+    can't shrink, or the surface marking below would need more cells than the
+    grid has room for. What we *can* control is where that unavoidable slack
+    goes: centering the core region on the bbox (instead of anchoring it flush
+    with bbox_min the way a naive grid would) splits it evenly between both
+    sides, so the collider hugs the source surface on both sides equally
+    instead of sitting flush on one side and bulging outward on the other.
     """
     size = bbox_max - bbox_min
-    core_cells = np.maximum(np.round(size / voxel_size).astype(int), 1)
+    core_cells = np.maximum(np.ceil(size / voxel_size).astype(int), 1)
     dims = np.minimum(core_cells + 2 * padding, MAX_GRID_AXIS_CELLS)
     slack = core_cells * voxel_size - size
     origin = bbox_min - padding * voxel_size - slack / 2
@@ -105,11 +108,11 @@ def _mark_triangle(occupancy, origin, voxel_size, threshold, v0, v1, v2, max_dep
         # "Belongs to the cell above" and "belongs to the cell below" readings
         # of the piece's span. These agree for any ordinary span; they can
         # only disagree (lo > hi) when the piece is flat exactly on a grid
-        # line along that axis -- which is guaranteed at the mesh's own
-        # bounding-box extremes, since the grid origin is defined from
-        # bbox_min in exact voxel-size steps. Marking both cells there is
-        # what pushes the whole collider outward by up to one voxel around
-        # every flat, grid-aligned face (e.g. any box-like source mesh).
+        # line along that axis -- notably whenever voxel_size divides the
+        # mesh's own bbox evenly, since the grid is then aligned so bbox_min
+        # and bbox_max land exactly on grid lines. Marking both cells there is
+        # what used to push the whole collider outward by up to one voxel
+        # around every flat, grid-aligned face (e.g. any box-like source mesh).
         lo = np.floor(rel_min + eps).astype(int)
         hi = np.ceil(rel_max - eps).astype(int) - 1
 

collider_shapes/add_bounding_primitive.py

@@ -16,6 +16,12 @@
 from ..pyshics_materials.material_functions import assign_physics_material, create_default_material, \
     set_active_physics_material, set_material
 
+# How long the viewport-navigation HUD dimming stays on after the view was
+# last seen changing (see draw_viewport_overlay). Short enough to feel
+# responsive once navigation actually stops, long enough to bridge the gap
+# between individual redraw callbacks.
+NAVIGATION_HOLD_SECONDS = 0.2
+
 
 def alignObjects(new, old):
     """Align two objects"""
@@ -110,11 +116,14 @@ def set_origin_to_center_of_mass(obj, depsgraph=None):
         print(f"Object '{obj.name}' has no vertices. Cannot calculate center of mass.")
         return
 
-    # Use numpy for faster vertex operations
-    import numpy as np
-    verts_local = np.array([v.co for v in mesh.vertices])
-    verts_world = verts_local @ obj.matrix_world
-    com = np.mean(verts_world, axis=0)
+    # Use numpy for faster vertex operations. obj.matrix_world is a 4x4
+    # mathutils.Matrix; numpy's `@` can't multiply it directly against an
+    # (N, 3) array (shape mismatch), so the rotation/scale submatrix and
+    # translation are applied explicitly instead.
+    verts_local = numpy.array([v.co for v in mesh.vertices])
+    mat_world = numpy.array(obj.matrix_world)
+    verts_world = verts_local @ mat_world[:3, :3].T + mat_world[:3, 3]
+    com = numpy.mean(verts_world, axis=0)
 
     # Calculate the offset
     offset = obj.matrix_world.inverted() @ mathutils.Vector(com)
@@ -247,6 +256,25 @@ def draw_viewport_overlay(self, context):
     """Draw 3D viewport overlay for the modal operator"""
     items = []
 
+    # Detecting "is the user currently navigating" from event types seen in
+    # modal() doesn't work reliably: an MMB orbit drag hands its MOUSEMOVE
+    # events - and usually even the terminating release - to Blender's own
+    # view3d.rotate modal operator before they ever reach this operator's
+    # modal(), so nothing observed there can tell whether a drag is still
+    # in progress. This draw callback runs on every actual repaint though,
+    # and Blender keeps repainting continuously for as long as the view is
+    # visibly changing - so comparing the region's view matrix frame to
+    # frame is a direct, reliable "is navigation actually happening" signal
+    # instead of an event-based guess.
+    region_3d = getattr(context.space_data, 'region_3d', None)
+    if region_3d is not None:
+        view_snapshot = (region_3d.view_matrix.copy(), region_3d.view_distance)
+        if self.navigation_view_snapshot is not None and view_snapshot != self.navigation_view_snapshot:
+            self.navigation_hold_until = time.time() + NAVIGATION_HOLD_SECONDS
+            self.arm_navigation_timer()
+        self.navigation_view_snapshot = view_snapshot
+    self.navigation = time.time() < self.navigation_hold_until
+
     self.valid_input_selection = True if len(self.new_colliders_list) > 0 else False
     if self.use_space:
         label = "Global/Local"
@@ -849,6 +877,43 @@ def force_redraw():
         bpy.context.space_data.overlay.show_text = not bpy.context.space_data.overlay.show_text
         pass
 
+    def arm_navigation_timer(self):
+        """Make sure poke_navigation_redraw() is scheduled. Only one timer
+        is ever in flight - it re-arms itself via its own return value for
+        as long as navigation_hold_until keeps getting pushed out, so this
+        just needs to kick it off once."""
+        if not self.navigation_timer_scheduled:
+            self.navigation_timer_scheduled = True
+            bpy.app.timers.register(self.poke_navigation_redraw, first_interval=NAVIGATION_HOLD_SECONDS)
+
+    def poke_navigation_redraw(self):
+        """bpy.app.timers callback: force a repaint once the navigation hold
+        window elapses, even if no further event ever reaches modal() or
+        draw_viewport_overlay() to notice on its own (e.g. the user stops
+        touching mouse/keyboard right after navigating, and Blender doesn't
+        repaint an idle viewport by itself).
+
+        This deliberately does NOT set self.navigation directly - it only
+        prompts a fresh repaint, and draw_viewport_overlay() re-derives the
+        real answer from the live view_matrix each time it draws. That
+        means this can never falsely clear the dimming while navigation is
+        still genuinely in progress: if the view is still changing, Blender
+        is already generating real repaints on its own, each of which
+        pushes the hold window out again before this timer's turn comes.
+        Re-arms itself via its return value, so only one timer is ever in
+        flight.
+        """
+        try:
+            remaining = self.navigation_hold_until - time.time()
+            if remaining > 0:
+                return remaining
+            self.navigation_timer_scheduled = False
+            self.navigation_area.tag_redraw()
+        except ReferenceError:
+            # operator has already finished/cancelled and its RNA was freed
+            pass
+        return None
+
     def set_collisions_wire_preview(self, mode):
         """Show wireframe for colliders"""
         if mode in ['PREVIEW', 'ALWAYS']:
@@ -1628,6 +1693,12 @@ def set_modal_state(self, cylinder_segments_active=False, displace_active=False,
         self.height_active = height_active
         self.width_active = width_active
 
+        # A keypress alone doesn't make Blender repaint the viewport (only
+        # mouse motion over the region does), so the new highlight color set
+        # above wouldn't show up until the next MOUSEMOVE. Force a repaint
+        # now so activating a parameter highlights it immediately.
+        self.force_redraw()
+
     def invoke(self, context, event):
         colSettings = context.scene.simple_collider
 
@@ -1649,6 +1720,10 @@ def invoke(self, context, event):
 
         # INITIAL STATE
         self.navigation = False
+        self.navigation_hold_until = 0.0  # grace window keeping navigation coloring on after the view last changed
+        self.navigation_timer_scheduled = False
+        self.navigation_area = context.area
+        self.navigation_view_snapshot = None  # (view_matrix, view_distance) as of the last draw call
         self.selected_objects = context.selected_objects.copy()
         self.active_obj = context.view_layer.objects.active
         self.obj_mode = context.object.mode
@@ -1787,28 +1862,21 @@ def invoke(self, context, event):
     def modal(self, context, event):
         colSettings = context.scene.simple_collider
 
-        self.navigation = False
-
         # Ignore if Alt is pressed
         if event.alt:
             self.ignore_input = True
             self.force_redraw()
             return {'RUNNING_MODAL'}
 
         if event.type in {'MIDDLEMOUSE', 'WHEELUPMOUSE', 'WHEELDOWNMOUSE'}:
-            # allow navigation
-            self.navigation = True
-
-            self.opacity_active = False
-            self.displace_active = False
-            self.decimate_active = False
-            self.cylinder_segments_active = False
-            self.remesh_active = False
-            self.height_active = False
-            self.width_active = False
-            self.sphere_segments_active = False
-            self.capsule_segments_active = False
-
+            # Whether the view is actually navigating is now detected in
+            # draw_viewport_overlay() by watching the region's view_matrix
+            # (see there for why: this handler doesn't reliably see events
+            # for the duration of an MMB orbit drag at all, since Blender's
+            # own view3d.rotate modal operator consumes them). This branch
+            # only needs to cancel any in-progress parameter drag so
+            # navigating doesn't fight with an active (S)/(D)/(A)/etc. edit.
+            self.set_modal_state()
             return {'PASS_THROUGH'}
 
         # User Input

preferences/preferences.py

@@ -383,6 +383,22 @@ def draw_vhacd_panel(self, layout, context):
                 row.prop(self, propName)
                 row.operator("wm.url_open", text="", icon='QUESTION').url = f"https://github.com/kmammou/v-hacd#{propName}"
 
+    def draw_validation_panel(self, layout):
+        """Draw the validation panel"""
+        box = layout.box()
+        row = box.row()
+        row.label(text='Checks')
+        for propName in self.props_validation_checks:
+            row = box.row()
+            row.prop(self, propName)
+
+        box = layout.box()
+        row = box.row()
+        row.label(text='Thresholds')
+        for propName in self.props_validation_thresholds:
+            row = box.row()
+            row.prop(self, propName)
+
     def draw_support_panel(self, layout, context):
         """Draw the support panel"""
         box = layout.box()
@@ -483,6 +499,9 @@ def draw(self, context):
         elif self.prefs_tabs == 'UI':
             self.draw_ui_panel(layout)
 
+        elif self.prefs_tabs == 'VALIDATION':
+            self.draw_validation_panel(layout)
+
         elif self.prefs_tabs == 'SUPPORT':
             self.draw_support_panel(layout, context)
 

preferences/prefs_properties.py

@@ -44,6 +44,7 @@ class CollisionAddonPrefsProperties():
                ('KEYMAP', "Keymap", "Change the hotkeys for tools associated with this addon."),
                ('UI', "Ui", "Settings related to the Ui and display of the addon."),
                ('VHACD', "Auto Convex", "Settings related to Auto Convex generation."),
+               ('VALIDATION', "Validation", "Settings for the collider validation checks."),
                ('SUPPORT', "Support", "Get support and help with the addon and help improve it"),
                ),
         default='SETTINGS',
@@ -464,6 +465,59 @@ class CollisionAddonPrefsProperties():
                                                                 "export pipelines that rely on the render flag",
                                                     default=True)
 
+    ###################################################################
+    # VALIDATION
+
+    validate_check_missing_collider: bpy.props.BoolProperty(name="Missing Collider",
+                                                             description="Flag render meshes that have no collider assigned",
+                                                             default=True)
+
+    validate_check_triangle_count: bpy.props.BoolProperty(name="Triangle Count",
+                                                           description="Flag colliders whose triangle count exceeds the limit below",
+                                                           default=True)
+
+    validate_check_min_dimension: bpy.props.BoolProperty(name="Collider Too Small",
+                                                         description="Flag colliders whose bounding box is smaller than the minimum dimension below",
+                                                         default=True)
+
+    validate_check_bbox_mismatch: bpy.props.BoolProperty(name="Bounding Box Mismatch",
+                                                          description="Flag colliders whose bounding box differs too much from their render mesh",
+                                                          default=True)
+
+    validate_check_naming: bpy.props.BoolProperty(name="Naming Convention",
+                                                  description="Flag colliders whose name doesn't match the configured naming convention",
+                                                  default=True)
+
+    validate_check_non_manifold: bpy.props.BoolProperty(name="Non-Manifold Geometry",
+                                                         description="Flag colliders with non-manifold (not watertight) edges",
+                                                         default=True)
+
+    validate_check_physics_material: bpy.props.BoolProperty(name="Missing Physics Material",
+                                                             description="Flag colliders with no physics material assigned",
+                                                             default=True)
+
+    validate_check_parent_hierarchy: bpy.props.BoolProperty(name="Parent Hierarchy",
+                                                             description="Flag colliders that aren't parented to a render mesh",
+                                                             default=True)
+
+    validation_max_triangle_count: bpy.props.IntProperty(name="Max Triangle Count",
+                                                         description="Maximum number of triangles allowed on a collider before it is flagged",
+                                                         default=255,
+                                                         min=1)
+
+    validation_min_dimension: bpy.props.FloatProperty(name="Min Dimension",
+                                                      description="Minimum bounding box dimension a collider can have before it is flagged as too small",
+                                                      default=0.01,
+                                                      min=0.0,
+                                                      subtype='DISTANCE')
+
+    validation_bbox_tolerance: bpy.props.FloatProperty(name="Bounding Box Tolerance",
+                                                       description="Allowed relative difference between a collider's bounding box and its render mesh's bounding box, as a fraction of the render mesh's bounding box diagonal",
+                                                       default=0.1,
+                                                       min=0.0,
+                                                       max=1.0,
+                                                       subtype='FACTOR')
+
     # DEBUG
     debug: bpy.props.BoolProperty(name="Debug Mode",
                                   description="Debug mode only used for debuging during development",
@@ -562,4 +616,21 @@ class CollisionAddonPrefsProperties():
         "my_hide",
         "wireframe_mode",
         "hide_render_on_creation",
+    ]
+
+    props_validation_checks = [
+        "validate_check_missing_collider",
+        "validate_check_triangle_count",
+        "validate_check_min_dimension",
+        "validate_check_bbox_mismatch",
+        "validate_check_naming",
+        "validate_check_non_manifold",
+        "validate_check_physics_material",
+        "validate_check_parent_hierarchy",
+    ]
+
+    props_validation_thresholds = [
+        "validation_max_triangle_count",
+        "validation_min_dimension",
+        "validation_bbox_tolerance",
     ]

tests/test_bounding_voxel.py

@@ -93,6 +93,22 @@ def test_cube_cubic_axis_aligned_grid_merges_to_single_box(self):
         self.assertEqual(len(bm.faces), 6)
         self.assertEqual(_holes(bm), [])
 
+    def test_cube_cubic_hugs_true_bbox_when_voxel_size_divides_evenly(self):
+        """Regression for #577: an evenly-dividing voxel size used to always
+        inflate the collider outward by one full voxel on every side, because
+        the mesh's own bbox faces sit exactly on a grid line. The result
+        should instead match the source cube's bbox exactly."""
+        size = 2.0
+        mesh = self._cube_mesh(size=size)
+        bm = build_voxel_bmesh(mesh, voxel_size=0.5, diagonal_fill=False)
+        self.addCleanup(bm.free)
+        coords = [v.co for v in bm.verts]
+        bbox_min = [min(c[axis] for c in coords) for axis in range(3)]
+        bbox_max = [max(c[axis] for c in coords) for axis in range(3)]
+        for axis in range(3):
+            self.assertAlmostEqual(bbox_min[axis], -size / 2, places=5)
+            self.assertAlmostEqual(bbox_max[axis], size / 2, places=5)
+
     def test_sphere_cubic_is_watertight(self):
         mesh = self._sphere_mesh()
         bm = build_voxel_bmesh(mesh, voxel_size=0.15, diagonal_fill=False)