wip collision handler rework

Author: viblo

.readthedocs.yaml

@@ -12,17 +12,17 @@ build:
 
 # Build documentation in the docs/ directory with Sphinx
 sphinx:
-   configuration: docs/src/conf.py
+  configuration: docs/src/conf.py
 
 # Optionally build your docs in additional formats such as PDF
 formats:
-   - pdf
+  - pdf
 
 # Optionally set the version of Python and requirements required to build your docs
 python:
-   install:
-   - requirements: docs/requirements.txt
+  install:
+    - requirements: docs/requirements.txt
 
 # Do not include the Chipmunk2D submodule. It it not needed for docs.
 submodules:
-   exclude: all
+  exclude: all

benchmarks/pymunk-collision-callback.py

@@ -8,7 +8,7 @@
 b = pymunk.Body(1,10)
 c = pymunk.Circle(b, 5)
 s.add(b, c)
-h = s.add_global_collision_handler()
+h = s.add_collision_handler(None, None)
 def f(arb, s, data):
     return False
 h.pre_solve = f

pymunk/space.py

@@ -42,10 +42,10 @@ def __getitem__(self, key: Union[None, int, tuple[int, int]]) -> CollisionHandle
         if key in self._handlers:
             return self._handlers[key]
         if key == None:
-            self._handlers[None] = self.space.add_global_collision_handler()
+            self._handlers[None] = self.space.add_collision_handler(None, None)
             return self._handlers[None]
         elif isinstance(key, int):
-            self._handlers[key] = self.space.add_wildcard_collision_handler(key)
+            self._handlers[key] = self.space.add_collision_handler(key, None)
             return self._handlers[key]
         elif isinstance(key, tuple):
             assert isinstance(key, tuple)
@@ -626,11 +626,13 @@ def collision_handlers(
         return self.collision_handlers
 
     def add_collision_handler(
-        self, collision_type_a: int, collision_type_b: int
+        self, collision_type_a: Optional[int], collision_type_b: Optional[int]
     ) -> CollisionHandler:
         """Return the :py:class:`CollisionHandler` for collisions between
         objects of type collision_type_a and collision_type_b.
 
+        Use None to indicate any collision_type.
+
         Fill the desired collision callback functions, for details see the
         :py:class:`CollisionHandler` object.
 
@@ -645,65 +647,34 @@ def add_collision_handler(
 
         :rtype: :py:class:`CollisionHandler`
         """
-        key = min(collision_type_a, collision_type_b), max(
-            collision_type_a, collision_type_b
-        )
+        # key = min(collision_type_a, collision_type_b), max(
+        #     collision_type_a, collision_type_b
+        # )
+
+        if collision_type_a == None and collision_type_b != None:
+            collision_type_b, collision_type_a = collision_type_a, collision_type_b
+
+        key = collision_type_a, collision_type_b
         if key in self._handlers:
             return self._handlers[key]
 
+        # if collision_type_a == None and collision_type_b == None:
+        #     return self.add_global_collision_handler()
+        # CP_WILDCARD_COLLISION_TYPE
+        wildcard = int(ffi.cast("uintptr_t", ~0))
+        if collision_type_a == None:
+            collision_type_a = wildcard
+
+        if collision_type_b == None:
+            collision_type_b = wildcard
+
         h = cp.cpSpaceAddCollisionHandler(
             self._space, collision_type_a, collision_type_b
         )
         ch = CollisionHandler(h, self)
         self._handlers[key] = ch
         return ch
 
-    def add_wildcard_collision_handler(self, collision_type_a: int) -> CollisionHandler:
-        """Add a wildcard collision handler for given collision type.
-
-        This handler will be used any time an object with this type collides
-        with another object, regardless of its type. A good example is a
-        projectile that should be destroyed the first time it hits anything.
-        There may be a specific collision handler and two wildcard handlers.
-        It's up to the specific handler to decide if and when to call the
-        wildcard handlers and what to do with their return values.
-
-        When a new wildcard handler is created, the callbacks will all be
-        set to builtin callbacks that perform the default behavior. (accept
-        all collisions in :py:func:`~CollisionHandler.begin` and
-        :py:func:`~CollisionHandler.pre_solve`, or do nothing for
-        :py:func:`~CollisionHandler.post_solve` and
-        :py:func:`~CollisionHandler.separate`.
-
-        :param int collision_type_a: Collision type
-        :rtype: :py:class:`CollisionHandler`
-        """
-
-        if collision_type_a in self._handlers:
-            return self._handlers[collision_type_a]
-
-        h = cp.cpSpaceAddWildcardHandler(self._space, collision_type_a)
-        ch = CollisionHandler(h, self)
-        self._handlers[collision_type_a] = ch
-        return ch
-
-    def add_global_collision_handler(self) -> CollisionHandler:
-        """Return a reference to the default collision handler or that is
-        used to process all collisions that don't have a more specific
-        handler.
-
-        The default behavior for each of the callbacks is to call
-        the wildcard handlers, ANDing their return values together if
-        applicable.
-        """
-        if None in self._handlers:
-            return self._handlers[None]
-
-        _h = cp.cpSpaceAddGlobalCollisionHandler(self._space)
-        h = CollisionHandler(_h, self)
-        self._handlers[None] = h
-        return h
-
     def add_post_step_callback(
         self,
         callback_function: Callable[
@@ -917,7 +888,7 @@ def bb_query(self, bb: "BB", shape_filter: ShapeFilter) -> list[Shape]:
         The filter is applied to the query and follows the same rules as the
         collision detection.
 
-            Sensor shapes are included in the result
+        Sensor shapes are included in the result
 
         :param bb: Bounding box
         :param shape_filter: Shape filter
@@ -938,7 +909,7 @@ def bb_query(self, bb: "BB", shape_filter: ShapeFilter) -> list[Shape]:
     def shape_query(self, shape: Shape) -> list[ShapeQueryInfo]:
         """Query a space for any shapes overlapping the given shape
 
-            Sensor shapes are included in the result
+        Sensor shapes are included in the result
 
         :param shape: Shape to query with
         :type shape: :py:class:`Circle`, :py:class:`Poly` or :py:class:`Segment`
@@ -1081,11 +1052,11 @@ def __setstate__(self, state: _State) -> None:
             elif k == "_handlers":
                 for k2, hd in v:
                     if k2 == None:
-                        h = self.add_global_collision_handler()
+                        h = self.add_collision_handler(None, None)
                     elif isinstance(k2, tuple):
                         h = self.add_collision_handler(k2[0], k2[1])
                     else:
-                        h = self.add_wildcard_collision_handler(k2)
+                        h = self.add_collision_handler(k2, None)
                     if "_begin" in hd:
                         h.begin = hd["_begin"]
                     if "_pre_solve" in hd:

pymunk/tests/test_arbiter.py

@@ -107,7 +107,7 @@ def testContactPointSet(self) -> None:
 
         def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             # check inital values
-            ps: p.ContactPointSet = arb.contact_point_set
+            ps = arb.contact_point_set
             self.assertEqual(len(ps.points), 1)
             self.assertAlmostEqual(ps.normal.x, 0.8574929257)
             self.assertAlmostEqual(ps.normal.y, 0.5144957554)
@@ -141,7 +141,7 @@ def f() -> None:
 
             self.assertRaises(Exception, f)
 
-        s.add_global_collision_handler().pre_solve = pre_solve
+        s.add_collision_handler(2, 1).pre_solve = pre_solve
 
         s.step(0.1)
 
@@ -191,14 +191,17 @@ def testTotalKE(self) -> None:
         c2.friction = 0.8
 
         s.add(b1, c1, b2, c2)
+        r = {}
 
         def post_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
-            self.assertAlmostEqual(arb.total_ke, 43.438914027)
+            r["ke"] = arb.total_ke
 
         s.add_collision_handler(1, 2).post_solve = post_solve
 
         s.step(0.1)
 
+        self.assertAlmostEqual(r["ke"], 43.438914027)
+
     def testIsFirstContact(self) -> None:
         s = p.Space()
         s.gravity = 0, -100
@@ -237,18 +240,23 @@ def testNormal(self) -> None:
         b1 = p.Body(1, 30)
         b1.position = 5, 10
         c1 = p.Circle(b1, 10)
+        c1.collision_type = 1
         c2 = p.Circle(s.static_body, 10)
+        c2.collision_type = 2
 
         s.add(b1, c1, c2)
+        r = {}
 
         def pre_solve1(arb: p.Arbiter, space: p.Space, data: Any) -> None:
-            self.assertAlmostEqual(arb.normal.x, 0.44721359)
-            self.assertAlmostEqual(arb.normal.y, 0.89442719)
+            r["n"] = Vec2d(*arb.normal)
 
-        s.add_global_collision_handler().pre_solve = pre_solve1
+        s.add_collision_handler(1, 2).pre_solve = pre_solve1
 
         s.step(0.1)
 
+        self.assertAlmostEqual(r["n"].x, -0.44721359)
+        self.assertAlmostEqual(r["n"].y, -0.89442719)
+
     def testIsRemoval(self) -> None:
         s = p.Space()
         s.gravity = 0, -100

pymunk/tests/test_shape.py

@@ -301,7 +301,7 @@ def testSegmentSegmentCollision(self) -> None:
         def begin(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.num_of_begins += 1
 
-        s.add_global_collision_handler().begin = begin
+        s.add_collision_handler(None, None).begin = begin
         s.step(0.1)
 
         self.assertEqual(1, self.num_of_begins)