Remove debug & validation files, leave the calling code in, but guard it with ti.static(False)

Author: gasnica

genesis/engine/solvers/rigid/constraint_solver_decomp_island.py

@@ -9,12 +9,7 @@
 import genesis.utils.array_class as array_class
 
 from .contact_island import ContactIsland
-from .rigid_debug import Debug
 from .rigid_solver_decomp_util import func_wakeup_entity_and_its_temp_island
-from .rigid_validate import (
-    validate_entity_hibernation_state_for_all_entities_in_temp_island,
-    validate_next_hibernated_entity_indices_in_entire_scene,
-)
 
 if TYPE_CHECKING:
     from genesis.engine.colliders.collider import Collider
@@ -234,8 +229,6 @@ def add_collision_constraints_and_wakeup_entities(self, i_island: int, i_b: int)
                 if is_entity_a_hibernated or is_entity_b_hibernated:
                     # wake up entities
                     any_hibernated_entity_idx = entity_idx_a if is_entity_a_hibernated else entity_idx_b
-                    temp_island_idx = self.contact_island.entity_island[any_hibernated_entity_idx, i_b]
-                    Debug.assertf(0x7AD00004, temp_island_idx == i_island)  # Temp island indices don't match
 
                     func_wakeup_entity_and_its_temp_island(
                         any_hibernated_entity_idx,
@@ -250,7 +243,7 @@ def add_collision_constraints_and_wakeup_entities(self, i_island: int, i_b: int)
                     )
 
         # after all collisions added for the island
-        if ti.static(Debug.validate):
+        if ti.static(False):  # Debug.validate
             validate_entity_hibernation_state_for_all_entities_in_temp_island(
                 i_island, i_b, self._solver.entities_state, self.contact_island, expected_hibernation_state=False
             )

genesis/engine/solvers/rigid/contact_island.py

@@ -6,16 +6,12 @@
 import genesis as gs
 import genesis.utils.geom as gu
 
-from .rigid_debug import Debug
-
 if TYPE_CHECKING:
     from genesis.engine.solvers.rigid.collider_decomp import Collider
     from genesis.engine.solvers.rigid.rigid_solver_decomp import RigidSolver
 
 INVALID_NEXT_HIBERNATED_ENTITY_IDX = -1
 
-from .rigid_validate import validate_next_hibernated_entity_indices_in_entire_scene
-
 
 @ti.data_oriented
 class ContactIsland:
@@ -139,11 +135,6 @@ def add_hiberanted_edges_to_islands(self):
             for i_e in range(n_entities):
                 next_entity_idx = self.entity_idx_to_next_entity_idx_in_hibernated_island[i_e, i_b]
                 if next_entity_idx != INVALID_NEXT_HIBERNATED_ENTITY_IDX and next_entity_idx != i_e:
-                    if ti.static(Debug.validate):
-                        island_idx_a = self.entity_island[i_e, i_b]
-                        island_idx_b = self.entity_island[next_entity_idx, i_b]
-                        Debug.assertf(0x7AD00012, island_idx_a == island_idx_b)
-
                     any_link_a = self.solver.entities_info.link_start[i_e]
                     any_link_b = self.solver.entities_info.link_start[next_entity_idx]
                     self.add_edge(any_link_a, any_link_b, i_b)
@@ -253,7 +244,7 @@ def construct_islands(self):
                     self.stack[self.n_stack[i_b], i_b] = i_v
                     self.n_stack[i_b] = self.n_stack[i_b] + 1
                     self.entity_island[i_v, i_b] = self.n_islands[i_b]
-                    if ti.static(Debug.validate):
+                    if ti.static(False):  # Debug.validate
                         if self.n_stack[i_b] > self.stack.shape[0]:
                             capacity = self.stack.shape[0]
                             print(f"Stack overflow! capacity and size: {capacity} < {self.n_stack[i_b]}")
@@ -277,7 +268,7 @@ def construct_islands(self):
                                 self.stack[self.n_stack[i_b], i_b] = next_v
                                 self.n_stack[i_b] = self.n_stack[i_b] + 1
                                 self.entity_island[next_v, i_b] = self.n_islands[i_b]
-                                if ti.static(Debug.validate):
+                                if ti.static(False):  # Debug.validate
                                     if self.n_stack[i_b] > self.stack.shape[0]:
                                         capacity = self.stack.shape[0]
                                         print(f"Stack overflow! capacity and size: {capacity} < {self.n_stack[i_b]}")

genesis/engine/solvers/rigid/rigid_debug.py

@@ -13,11 +13,6 @@
 from genesis.engine.entities import AvatarEntity, DroneEntity, RigidEntity
 from genesis.engine.entities.base_entity import Entity
 from genesis.engine.solvers.rigid.contact_island import ContactIsland
-from genesis.engine.solvers.rigid.rigid_debug import Debug
-from genesis.engine.solvers.rigid.rigid_validate import (
-    validate_entity_hibernation_state_for_all_entities_in_temp_island,
-    validate_next_hibernated_entity_indices_in_entire_scene,
-)
 from genesis.engine.states.solvers import RigidSolverState
 from genesis.options.solvers import RigidOptions
 from genesis.styles import colors, formats
@@ -4937,21 +4932,13 @@ def func_hibernate__for_all_awake_islands_either_hiberanate_or_update_aabb_sort_
         for island_idx in range(ci.n_islands[i_b]):
             was_island_hibernated = ci.island_hibernated[island_idx, i_b]
 
-            if ti.static(Debug.validate):
-                validate_entity_hibernation_state_for_all_entities_in_temp_island(
-                    island_idx, i_b, entities_state, contact_island, expected_hibernation_state=was_island_hibernated
-                )
-
             if not was_island_hibernated:
                 are_all_entities_okay_for_hibernation = True
                 entity_ref_range = ci.island_entity[island_idx, i_b]
                 for i_entity_ref_offset_ in range(entity_ref_range.n):
                     entity_ref = entity_ref_range.start + i_entity_ref_offset_
                     entity_idx = ci.entity_id[entity_ref, i_b]
 
-                    is_entity_fixed = entities_info.n_dofs[entity_idx] == 0
-                    Debug.assertf(0x7AD00005, not is_entity_fixed)  # Fixed entity should not belong to an island
-
                     # Hibernated entities already have zero dofs_state.acc/vel
                     is_entity_hibernated = entities_state.hibernated[entity_idx, i_b]
                     if is_entity_hibernated:
@@ -4997,11 +4984,6 @@ def func_hibernate__for_all_awake_islands_either_hiberanate_or_update_aabb_sort_
                         )
 
                         # store entities in the hibernated islands by daisy chaining them
-                        Debug.assertf(
-                            0x7AD00014,
-                            ci.entity_idx_to_next_entity_idx_in_hibernated_island[prev_entity_idx, i_b]
-                            == INVALID_NEXT_HIBERNATED_ENTITY_IDX,
-                        )
                         ci.entity_idx_to_next_entity_idx_in_hibernated_island[prev_entity_idx, i_b] = entity_idx
                         prev_entity_idx = entity_idx
 

genesis/engine/solvers/rigid/rigid_solver_decomp.py

@@ -3,12 +3,6 @@
 import genesis.utils.array_class as array_class
 
 from genesis.engine.solvers.rigid.contact_island import INVALID_NEXT_HIBERNATED_ENTITY_IDX
-from genesis.engine.solvers.rigid.rigid_debug import Debug
-from genesis.engine.solvers.rigid.rigid_validate import (
-    validate_temp_island_contains_both_hibernated_and_awake_entities,
-    validate_entity_hibernation_state_for_all_entities_in_temp_island,
-    validate_next_hibernated_entity_indices_in_entire_scene,
-)
 
 
 @ti.func
@@ -26,32 +20,13 @@ def func_wakeup_entity_and_its_temp_island(
     # Note: Original function handled non-hibernated & fixed entities.
     # Now, we require a properly hibernated entity to be passed in.
     island_idx = contact_island.entity_island[i_e, i_b]
-    Debug.assertf(
-        0x7AD00008, not contact_island.island_hibernated[island_idx, i_b]
-    )  # Island already expected to be marked as not hibernated
-
-    is_entity_fixed = island_idx == -1
-    Debug.assertf(0x7AD00007, not is_entity_fixed)  # Fixed entities are excluded from hibernation logic
-    Debug.assertf(0x7AD0000B, entities_state.hibernated[i_e, i_b])
-
-    if ti.static(Debug.validate):
-        validate_temp_island_contains_both_hibernated_and_awake_entities(
-            island_idx, i_b, entities_state, contact_island
-        )
 
     entity_ref_range = contact_island.island_entity[island_idx, i_b]
     for ei in range(entity_ref_range.n):
         entity_ref = entity_ref_range.start + ei
         entity_idx = contact_island.entity_id[entity_ref, i_b]
-        Debug.assertf(
-            0x7AD0000D, contact_island.entity_island[entity_idx, i_b] == island_idx
-        )  # Unexpected entity from outside of island
 
         is_entity_hibernated = entities_state.hibernated[entity_idx, i_b]
-        next_hibernated_entity_idx = contact_island.entity_idx_to_next_entity_idx_in_hibernated_island[entity_idx, i_b]
-        Debug.assertf(
-            0x7AD0000E, is_entity_hibernated == (next_hibernated_entity_idx != INVALID_NEXT_HIBERNATED_ENTITY_IDX)
-        )  # Inconsistent entity state
 
         if is_entity_hibernated:
             contact_island.entity_idx_to_next_entity_idx_in_hibernated_island[entity_idx, i_b] = (
@@ -80,10 +55,3 @@ def func_wakeup_entity_and_its_temp_island(
 
             for i_g in range(entities_info.geom_start[entity_idx], entities_info.geom_end[entity_idx]):
                 geoms_state.hibernated[i_g, i_b] = False
-
-    # contact_island.island_hibernated[island_idx, i_b] = False
-    if ti.static(Debug.validate):
-        validate_entity_hibernation_state_for_all_entities_in_temp_island(
-            island_idx, i_b, entities_state, contact_island, expected_hibernation_state=False
-        )
-        validate_next_hibernated_entity_indices_in_entire_scene(i_b, entities_state, contact_island)