Use debug_timer on lights.

[tabakrolletjie.git] / tabakrolletjie / lights.py

diff --git a/tabakrolletjie/lights.py b/tabakrolletjie/lights.py
index ef84879c1cee2790e9d5a8f82acc21e64f153bec..7620c480915c1e8b5bc2226ba1ec64028a7631f9 100644 (file)
--- a/tabakrolletjie/lights.py
+++ b/tabakrolletjie/lights.py
@@ -4,9 +4,9 @@
 import pymunk
 import pymunk.pygame_util
 import pygame.draw
-import pygame.locals as pgl
 
 from .constants import SCREEN_SIZE, LIGHT_CATEGORY
+from .utils import debug_timer
 
 LIGHT_FILTER = pymunk.ShapeFilter(
     mask=pymunk.ShapeFilter.ALL_MASKS ^ LIGHT_CATEGORY,
@@ -20,16 +20,18 @@ def screen_rays(pos):
     """
     w, h = SCREEN_SIZE
     left, right, bottom, top = 0, w, 0, h
-    for y in range(h):
+    step = 1
+    for y in range(0, h, step):
         yield pymunk.Vec2d(left, y)
-    for x in range(w):
+    for x in range(0, w, step):
         yield pymunk.Vec2d(x, top)
-    for y in range(top, -1, -1):
+    for y in range(top, -1, -step):
         yield pymunk.Vec2d(right, y)
-    for x in range(right, -1, -1):
+    for x in range(right, -1, -step):
         yield pymunk.Vec2d(x, bottom)
 
 
+@debug_timer("lights.calculate_ray_polys")
 def calculate_ray_polys(space, body, position):
     position = pymunk.Vec2d(position)
     vertices = [position]
@@ -47,33 +49,30 @@ def calculate_ray_polys(space, body, position):
                 new_poly = pymunk.Poly(body, vertices[:-1])
                 vertices = [position, vertices[-1]]
                 ray_polys.append(new_poly)
+            else:
+                vertices = trial_poly.get_vertices() + [point]
     if len(vertices) > 2:
         ray_polys.append(pymunk.Poly(body, vertices))
-    print "NUM POLYS: ", len(ray_polys)
     return ray_polys
 
 
 class BaseLight(object):
     """ Common light functionality. """
 
+    COLOURS = {
+        "red": (255, 0, 0),
+        "green": (0, 255, 0),
+        "blue": (0, 255, 255),
+        "yellow": (255, 255, 0),
+        "white": (255, 255, 255),
+    }
+
     def __init__(self, colour, position):
+        self.on = True
         self.body = pymunk.Body(0, 0, pymunk.body.Body.STATIC)
         self.colour = colour
         self.position = position
 
-    def add(self, space):
-        if self.body.space is not None:
-            space.remove(self.body, *self.body.shapes)
-        shapes = self.shapes_for_ray_polys(
-            calculate_ray_polys(space, self.body, self.position))
-        for shape in shapes:
-            shape.filter = LIGHT_FILTER
-        space.add(self.body, *shapes)
-
-    def shapes_for_ray_polys(self, space):
-        raise NotImplementedError(
-            "Lights should implement .determine_ray_polys.")
-
     @classmethod
     def load(cls, config):
         kw = config.copy()
@@ -83,36 +82,51 @@ class BaseLight(object):
             if c.__name__.lower() == light_type]
         return light_class(**kw)
 
-
-class SpotLight(BaseLight):
-    def __init__(
-            self, colour="white", position=None, direction=90.0, spread=45.0):
-        super(SpotLight, self).__init__(colour, position)
-        self.direction = direction
-        self.spread = spread
-        self.i = 0
+    def add(self, space):
+        if self.body.space is not None:
+            space.remove(self.body, *self.body.shapes)
+        shapes = self.shapes_for_ray_polys(
+            calculate_ray_polys(space, self.body, self.position))
+        for shape in shapes:
+            shape.filter = LIGHT_FILTER
+        space.add(self.body, *shapes)
 
     def shapes_for_ray_polys(self, ray_polys):
-        x, y = self.position
-        return ray_polys #+ [
-        #    pymunk.Poly(self.body, [self.position, [x + 50, y], [x, y + 50]])]
+        return ray_polys
+
+    def toggle(self):
+        self.on = not self.on
 
-    def render(self, surface):
+    def render_light(self, surface):
+        if not self.on:
+            return
         subsurface = surface.copy()
-        pygame.draw.circle(
-            surface, (255, 255, 0),
-            pymunk.pygame_util.to_pygame(self.position, surface), 5)
+        light_colour = self.COLOURS[self.colour]
         for shape in self.body.shapes:
             pygame_poly = [
                 pymunk.pygame_util.to_pygame(v, surface) for v in
                 shape.get_vertices()]
             pygame.draw.polygon(
-                subsurface, (200, 200, 200), pygame_poly, 0)
+                subsurface, light_colour, pygame_poly, 0)
             pygame.draw.aalines(
-                subsurface, (200, 200, 200), True, pygame_poly, 1)
-        subsurface.set_alpha(200)
+                subsurface, light_colour, True, pygame_poly, 1)
+        subsurface.set_alpha(50)
         surface.blit(subsurface, (0, 0), None)
 
+    def render_fittings(self, surface):
+        pygame.draw.circle(
+            surface, (255, 255, 0),
+            pymunk.pygame_util.to_pygame(self.position, surface), 5)
+
+
+class SpotLight(BaseLight):
+    def __init__(
+            self, colour="white", position=None, direction=90.0, spread=45.0):
+        super(SpotLight, self).__init__(colour, position)
+        self.direction = direction
+        self.spread = spread
+        self.i = 0
+
 
 class Lamp(BaseLight):
     def __init__(self, colour="white", position=None, radius=100.0):