wip benchmarks

Author: viblo

benchmarks/chipmunk.py

@@ -22,12 +22,24 @@
 """
 
 
-class FallingSquares:
-    def __init__(self, space, size):
-        space.gravity = 0, 10
-        space.static_body.position = 0, 10
-        ground = pymunk.Poly.create_box(space.static_body, (200, 20))
-        space.add(ground)
+class Benchmark:
+    def __init__(self):
+        self.space = pymunk.Space()
+        self.space.gravity = 0, 10
+
+    def update(self, dt):
+        self.space.step(dt)
+
+    def draw(self, draw_options):
+        self.space.debug_draw(draw_options)
+
+
+class FallingSquares(Benchmark):
+    def __init__(self, size):
+        super().__init__()
+        self.space.static_body.position = 0, 10
+        ground = pymunk.Poly.create_box(self.space.static_body, (200, 20))
+        self.space.add(ground)
 
         for i in range(15):
             a = 0.5 + i / 15 * 2.5
@@ -37,15 +49,15 @@ def __init__(self, space, size):
 
                 p = pymunk.Poly.create_box(b, (a, a))
                 p.density = 5
-                space.add(b, p)
+                self.space.add(b, p)
 
 
-class FallingCircles:
-    def __init__(self, space, size):
-        space.gravity = 0, 10
-        space.static_body.position = 0, 10
-        ground = pymunk.Poly.create_box(space.static_body, (200, 20))
-        space.add(ground)
+class FallingCircles(Benchmark):
+    def __init__(self, size):
+        super().__init__()
+        self.space.static_body.position = 0, 10
+        ground = pymunk.Poly.create_box(self.space.static_body, (200, 20))
+        self.space.add(ground)
 
         for i in range(15):
             a = 0.5 + i / 15 * 2.5
@@ -54,11 +66,13 @@ def __init__(self, space, size):
                 b.position = i * 7 + j * 0.25 - 60, -2 * a * (size - j)
                 c = pymunk.Circle(b, a / 2)
                 c.density = 5
-                space.add(b, c)
+                self.space.add(b, c)
 
 
-class SlowExplosion:
-    def __init__(self, space, size):
+class SlowExplosion(Benchmark):
+    def __init__(self, size):
+        super().__init__()
+        self.space.gravity = 0, 0
 
         for i in range(size):
             b = pymunk.Body()
@@ -69,14 +83,14 @@ def __init__(self, space, size):
             y = math.sin(s * 30) * (s * 30 + 5)
             b.position = pymunk.Vec2d(x, y)
             b.velocity = 0.2 * b.position
-            space.add(b, c)
+            self.space.add(b, c)
 
 
-class MildN2:
-    def __init__(self, space, size):
-        space.gravity = 0, 10
-        ground = pymunk.Segment(space.static_body, (-50, 0), (50, 0), 1)
-        space.add(ground)
+class MildN2(Benchmark):
+    def __init__(self, size):
+        super().__init__()
+        ground = pymunk.Segment(self.space.static_body, (-50, 0), (50, 0), 1)
+        self.space.add(ground)
 
         # table
         for i in range(size):
@@ -98,7 +112,7 @@ def __init__(self, space, size):
             top.density = 2
             left.density = 2
 
-            space.add(top, left, right, b)
+            self.space.add(top, left, right, b)
 
         # triangle
         for i in range(size):
@@ -110,12 +124,12 @@ def __init__(self, space, size):
             right = pymunk.Poly(b, [(2, 0), (-1, -2), (0, -4)])
             right.density = 3
 
-            space.add(b, left, right)
+            self.space.add(b, left, right)
 
 
-class N2:
-    def __init__(self, space, size):
-        space.gravity = 0, 10
+class N2(Benchmark):
+    def __init__(self, size):
+        super().__init__()
         # ground = pymunk.Segment(space.static_body, (-50, 0), (50, 0), 1)
         # space.add(ground)
 
@@ -124,7 +138,72 @@ def __init__(self, space, size):
             b.position = (i * 0.01, -i * 0.01)
             c = pymunk.Circle(b, 1)
             c.density = 1
-            space.add(b, c)
+            self.space.add(b, c)
+
+
+class Diagonal(Benchmark):
+    def __init__(self, size):
+        super().__init__()
+
+        a = 0.5
+        N = size
+        M = size / 2
+        position = pymunk.Vec2d(0, 0)
+        for j in range(int(M)):
+            position = pymunk.Vec2d(-N * a * 3, position.y)
+
+            for i in range(N):
+                b = pymunk.Body(body_type=pymunk.Body.STATIC)
+                # (float hx, float hy, const b2Vec2 &center, float angle)
+
+                b.position = position
+                b.angle = math.pi / 4
+                s = pymunk.Poly.create_box(b, (a, ((3 * j + 1) * a)))
+                self.space.add(b, s)
+                position = position + ((8 * a), 0)
+            position = position - (0, 8 * a)
+
+        for i in range(3000):
+            b = pymunk.Body()
+            b.position = (i / 15) * 2 - 75, -(i % 15 * 2) - 50
+
+            c = pymunk.Circle(b, 0.5)
+            c.density = 1
+
+            self.space.add(b, c)
+
+
+class Tumbler(Benchmark):
+    def __init__(self, size):
+        super().__init__()
+
+        self.m_count = 0
+        self.e_count = size
+
+        b = pymunk.Body()
+        b.position = 0, 10
+        s1 = pymunk.Segment(b, (-10, 10), (10, 10), 0.5)
+        s2 = pymunk.Segment(b, (10, 10), (10, -10), 0.5)
+        s3 = pymunk.Segment(b, (10, -10), (-10, -10), 0.5)
+        s4 = pymunk.Segment(b, (-10, -10), (-10, 10), 0.5)
+        s1.density = 5
+        s2.density = 5
+        s3.density = 5
+        s4.density = 5
+
+        j1 = pymunk.constraints.SimpleMotor(self.space.static_body, b, 1)
+        j2 = pymunk.constraints.PinJoint(self.space.static_body, b, (0, 0), (0, 0))
+        self.space.add(b, s1, s2, s3, s4, j1, j2)
+
+    def update(self, dt):
+        super().update(dt)
+        if self.m_count < self.e_count:
+            b = pymunk.Body()
+            b.position = 0, 10
+            s = pymunk.Poly.create_box(b, (0.125, 0.125))
+            s.density = 1
+            self.space.add(b, s)
+            self.m_count += 1
 
 
 tests = [SlowExplosion, FallingSquares]
@@ -135,12 +214,17 @@ def __init__(self, space, size):
 space = pymunk.Space()
 
 draw_options = pymunk.pygame_util.DrawOptions(screen)
+draw_options.flags = draw_options.DRAW_SHAPES
+
 # FallingSquares(space, 200)
 # FallingCircles(space, 200)
 # MildN2(space, 50)
-N2(space, 500)
+# N2(space, 500)
+# Diagonal(space, 100)
 # SlowExplosion(space, 5000)
 
+sim = Tumbler(1000)
+
 translation = pymunk.Transform()
 scaling = 2
 
@@ -165,11 +249,11 @@ def __init__(self, space, size):
 
     fps = 60.0
     dt = 1.0 / fps
-    space.step(dt)
+    sim.update(dt)
     steps += 1
 
     screen.fill(pygame.Color("white"))
-    space.debug_draw(draw_options)
+    sim.draw(draw_options)
     pygame.display.flip()
 
     clock.tick(fps)