Merge branch 'master' of ctpug.org.za:tabakrolletjie

diff --combined tabakrolletjie/lights.py
index d20ab3570663ba1132345d1f093aea8b9b7985ce,2ab02b6e91061469ce58c81af4deaeb2c5bcf58b..2952da5c86680eada28d63130e425bf017179e87
--- 1/tabakrolletjie/lights.py
--- 2/tabakrolletjie/lights.py
+++ b/tabakrolletjie/lights.py
@@@ -38,6 -38,11 +38,11 @@@ class LightManager(object)
          for light in self._lights:
              light.add(self._space)
  
+     def add_light(self, cfg):
+         light = BaseLight.load(cfg)
+         self._lights.append(light)
+         light.add(self._space)
+ 
      def toggle_nearest(self, *args, **kw):
          light = self.nearest(*args, **kw)
          if light:
@@@ -96,34 -101,27 +101,34 @@@ class BaseLight(object)
          "white": (255, 255, 255),
      }
  
 +    # defaults
 +    RAY_MANAGER = RayPolyManager
      FITTING_IMG = None
-     FITTING_RADIUS = 10.0
++    FITTING_RADIUS = 24.0
  
      # cached surfaces
      _surface_cache = {}
  
      def __init__(
 -            self, colour, position, intensity=1.0,
 -            radius_limits=(None, None), angle_limits=None):
 +            self, colour, position, intensity=1.0, radius_limits=None,
 +            angle_limits=None):
          self.colour = colour
 -        self.position = pymunk.Vec2d(position)
          self.on = True
          self.intensity = intensity
 -        self.radius_limits = radius_limits
 -        self.angle_limits = angle_limits
          self.body = pymunk.Body(0, 0, pymunk.body.Body.STATIC)
 -        self.fitting = pymunk.Circle(self.body, 24.0, self.position)
 -        self.fitting.filter = FITTINGS_FILTER
          self.body.light = self
 -        self.ray_manager = RayPolyManager(self.body, LIGHT_FILTER)
 +        self.ray_manager = self.RAY_MANAGER(
 +            self.body, position, ray_filter=LIGHT_FILTER,
 +            radius_limits=radius_limits, angle_limits=angle_limits)
 +        self.fitting = pymunk.Circle(
 +            self.body, self.FITTING_RADIUS, self.ray_manager.position)
 +        self.fitting.filter = FITTINGS_FILTER
          self._image = None
  
 +    @property
 +    def position(self):
 +        return self.ray_manager.position
 +
      @classmethod
      def load(cls, config):
          kw = config.copy()
@@@ -136,25 -134,31 +141,25 @@@
      def add(self, space):
          if self.body.space is not None:
              space.remove(self.body, *self.body.shapes)
 -        self.ray_manager.generate_rays(space, self.position)
 -        self.ray_manager.set_angle_limits(self.angle_limits)
 -        ray_shapes = self.ray_manager.polys()
 -        space.add(self.body, self.fitting, *ray_shapes)
 -
 -    def shapes_for_ray_polys(self, ray_polys):
 -        return ray_polys
 +        space.add(self.body, self.fitting)
 +        self.ray_manager.set_space(space)
 +        self.ray_manager.update_shapes()
  
      def toggle(self):
          self.on = not self.on
  
 -    def _cached_surfaces(self, surface):
 -        radius_mask = self._surface_cache.get('radius_mask')
 -        if radius_mask is None:
 -            radius_mask = self._surface_cache['radius_mask'] = (
 -                pygame.surface.Surface(
 -                    surface.get_size(), pgl.SWSURFACE)).convert_alpha()
 -
 -        ray_mask = self._surface_cache.get('ray_mask')
 -        if ray_mask is None:
 -            ray_mask = self._surface_cache['ray_mask'] = (
 -                pygame.surface.Surface(
 -                    surface.get_size(), pgl.SWSURFACE)).convert_alpha()
 +    def _cached_surface(self, name, surface):
 +        surf = self._surface_cache.get(name)
 +        if surf is None:
 +            surf = self._surface_cache[name] = pygame.surface.Surface(
 +                surface.get_size(), pgl.SWSURFACE
 +            ).convert_alpha()
 +        return surf
  
 -        return radius_mask, ray_mask
 +    def light_colour(self):
 +        light_colour = self.COLOURS[self.colour]
 +        intensity = int(255 * self.intensity)
 +        return light_colour + (intensity,)
  
      def render_light(self, surface):
          if not self.on:
@@@ -162,17 -166,20 +167,17 @@@
  
          dt = DetailedTimer("render_light")
          dt.start()
 -        dt.show("%s, %s" % (self.ray_manager._start, self.ray_manager._end))
 -
 -        max_radius = self.radius_limits[1] or 50.0
 -        min_radius = self.radius_limits[0] or 0
  
 -        rw = max_radius * 2
 -        rx, ry = pymunk.pygame_util.to_pygame(self.position, surface)
 -        dest_rect = pygame.rect.Rect(rx, ry, rw, rw)
 -        dest_rect.move_ip(- max_radius, - max_radius)
 +        max_radius = self.ray_manager.max_radius
 +        min_radius = self.ray_manager.min_radius
 +        dest_rect = self.ray_manager.pygame_rect(surface)
  
          white, black = (255, 255, 255, 255), (0, 0, 0, 0)
 +        light_colour = self.light_colour()
  
 -        radius_mask, ray_mask = self._cached_surfaces(surface)
 +        radius_mask = self._cached_surface('radius_mask', surface)
          radius_mask.set_clip(dest_rect)
 +        ray_mask = self._cached_surface('ray_mask', surface)
          ray_mask.set_clip(dest_rect)
  
          ray_mask.fill(black)
@@@ -181,8 -188,12 +186,8 @@@
              pygame.draw.polygon(ray_mask, white, pygame_poly, 1)
          dt.lap("ray mask rendered")
  
 -        light_colour = self.COLOURS[self.colour]
 -        intensity = int(255 * self.intensity)
 -        light_colour = light_colour + (intensity,)
 -
          radius_mask.fill(black)
 -        centre = pymunk.pygame_util.to_pygame(self.position, surface)
 +        centre = self.ray_manager.pygame_position(surface)
          pygame.draw.circle(
              radius_mask, light_colour, centre, int(max_radius), 0)
          pygame.draw.circle(
@@@ -200,13 -211,13 +205,13 @@@
          if self._image is None:
              fitting_colour = self.COLOURS[self.colour]
              self._image = loader.load_image(
-                 "64", self.FITTING_IMG,
+                 "48", self.FITTING_IMG,
                  transform=Multiply(colour=fitting_colour))
          return self._image
  
      def render_fitting(self, surface):
 -        rx, ry = pymunk.pygame_util.to_pygame(self.position, surface)
 +        rx, ry = self.ray_manager.pygame_position(surface)
-         surface.blit(self.get_image(), (rx - 32, ry - 32), None, 0)
+         surface.blit(self.get_image(), (rx - 24, ry - 24), None, 0)
  
      def tick(self):
          pass
@@@ -232,5 -243,8 +237,5 @@@ class SpotLight(BaseLight)
  
      def tick(self):
          if self.angular_velocity:
 -            start, end = self.angle_limits
 -            start = (start + self.angular_velocity) % 360.0
 -            end = (end + self.angular_velocity) % 360.0
 -            self.angle_limits = (start, end)
 -            self.ray_manager.set_angle_limits(self.angle_limits)
 +            self.ray_manager.rotate_degrees(self.angular_velocity)
 +            self.ray_manager.update_shapes()