X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fvideo%2Fdrawing_context.cpp;h=faa95ddf58486b97cdf06b202aeeb6289eba98c6;hb=6492679a300bff2c17505c5d9bc9d333eeba384d;hp=48b9c9776b856e2a51da0cce7e8656b03dfccea4;hpb=efc61e9d05b077f13a76982590fb0bd6a9d8dc61;p=supertux.git

diff --git a/src/video/drawing_context.cpp b/src/video/drawing_context.cpp
index 48b9c9776..faa95ddf5 100644
--- a/src/video/drawing_context.cpp
+++ b/src/video/drawing_context.cpp
@@ -1,12 +1,10 @@
-//  $Id: drawing_context.cpp 2334 2005-04-04 16:26:14Z grumbel $
+//  SuperTux
+//  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
 //
-//  SuperTux -  A Jump'n Run
-//  Copyright (C) 2004 Matthias Braun <matze@braunis.de
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 2
-//  of the License, or (at your option) any later version.
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
 //
 //  This program is distributed in the hope that it will be useful,
 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -14,375 +12,429 @@
 //  GNU General Public License for more details.
 //
 //  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-#include <config.h>
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "video/drawing_context.hpp"
 
 #include <algorithm>
-#include <cassert>
-#include <iostream>
-#include <SDL_image.h>
-#include <GL/gl.h>
-#include <GL/glu.h>
-
-#include "drawing_context.hpp"
-#include "surface.hpp"
-#include "font.hpp"
-#include "main.hpp"
-#include "gameconfig.hpp"
-#include "glutil.hpp"
-#include "texture.hpp"
-
-#define LIGHTMAP_DIV 4
-
-static inline int next_po2(int val)
+#include <config.h>
+
+#include "math/sizef.hpp"
+#include "supertux/gameconfig.hpp"
+#include "supertux/globals.hpp"
+#include "util/obstackpp.hpp"
+#include "video/drawing_request.hpp"
+#include "video/lightmap.hpp"
+#include "video/renderer.hpp"
+#include "video/surface.hpp"
+#include "video/texture.hpp"
+#include "video/texture_manager.hpp"
+#include "video/video_system.hpp"
+
+DrawingContext::DrawingContext(VideoSystem& video_system_) :
+  video_system(video_system_),
+  transformstack(),
+  transform(),
+  blend_stack(),
+  blend_mode(),
+  drawing_requests(),
+  lightmap_requests(),
+  requests(),
+  ambient_color(1.0f, 1.0f, 1.0f, 1.0f),
+  target(NORMAL),
+  target_stack(),
+  obst(),
+  screenshot_requested(false)
 {
-  int result = 1;
-  while(result < val)
-    result *= 2;
-  
-  return result;
+  requests = &drawing_requests;
+  obstack_init(&obst);
 }
 
-DrawingContext::DrawingContext()
+DrawingContext::~DrawingContext()
 {
-  screen = SDL_GetVideoSurface();
-
-  lightmap_width = screen->w / LIGHTMAP_DIV;
-  lightmap_height = screen->h / LIGHTMAP_DIV;
-  int width = next_po2(lightmap_width);
-  int height = next_po2(lightmap_height);
-
-  lightmap.reset(new Texture(width, height, GL_RGB));
-
-  lightmap_uv_right = static_cast<float>(lightmap_width) / static_cast<float>(width);
-  lightmap_uv_bottom = static_cast<float>(lightmap_height) / static_cast<float>(height);
+  clear_drawing_requests(lightmap_requests);
+  clear_drawing_requests(drawing_requests);
 
-  requests = &drawing_requests;
+  obstack_free(&obst, NULL);
 }
 
-DrawingContext::~DrawingContext()
+void
+DrawingContext::clear_drawing_requests(DrawingRequests& requests_)
 {
+  for(auto& request : requests_)
+  {
+    if (request->request_data)
+    {
+      request->request_data->~DrawingRequestData();
+    }
+    request->~DrawingRequest();
+  }
+  requests_.clear();
 }
 
 void
-DrawingContext::draw_surface(const Surface* surface, const Vector& position,
-    int layer)
+DrawingContext::draw_surface(SurfacePtr surface, const Vector& position,
+                             float angle, const Color& color, const Blend& blend,
+                             int layer)
 {
   assert(surface != 0);
-  
-  DrawingRequest request;
 
-  request.type = SURFACE;
-  request.pos = transform.apply(position);
+  DrawingRequest* request = new(obst) DrawingRequest();
 
-  if(request.pos.x >= SCREEN_WIDTH || request.pos.y >= SCREEN_HEIGHT
-      || request.pos.x + surface->w < 0 || request.pos.y + surface->h < 0)
+  request->target = target;
+  request->type = SURFACE;
+  request->pos = transform.apply(position);
+
+  if(request->pos.x >= SCREEN_WIDTH || request->pos.y >= SCREEN_HEIGHT
+     || request->pos.x + surface->get_width() < 0
+     || request->pos.y + surface->get_height() < 0)
     return;
 
-  request.layer = layer;
-  request.drawing_effect = transform.drawing_effect;
-  request.zoom = transform.zoom;
-  request.alpha = transform.alpha;
-  request.request_data = const_cast<Surface*> (surface);  
+  request->layer = layer;
+  request->drawing_effect = transform.drawing_effect;
+  request->alpha = transform.alpha;
+  request->angle = angle;
+  request->color = color;
+  request->blend = blend;
+
+  SurfaceRequest* surfacerequest = new(obst) SurfaceRequest();
+  surfacerequest->surface = surface.get();
+  request->request_data = surfacerequest;
 
   requests->push_back(request);
 }
 
 void
-DrawingContext::draw_surface_part(const Surface* surface, const Vector& source,
-    const Vector& size, const Vector& dest, int layer)
+DrawingContext::draw_surface(SurfacePtr surface, const Vector& position,
+                             int layer)
+{
+  draw_surface(surface, position, 0.0f, Color(1.0f, 1.0f, 1.0f), Blend(), layer);
+}
+
+void
+DrawingContext::draw_surface_part(SurfacePtr surface,
+                                  const Rectf& srcrect, const Rectf& dstrect,
+                                  int layer)
 {
   assert(surface != 0);
 
-  DrawingRequest request;
-
-  request.type = SURFACE_PART;
-  request.pos = transform.apply(dest);
-  request.layer = layer;
-  request.drawing_effect = transform.drawing_effect;
-  request.alpha = transform.alpha;
-  
-  SurfacePartRequest* surfacepartrequest = new SurfacePartRequest();
-  surfacepartrequest->size = size;
-  surfacepartrequest->source = source;
-  surfacepartrequest->surface = surface;
-
-  // clip on screen borders
-  if(request.pos.x < 0) {
-    surfacepartrequest->size.x += request.pos.x;
-    if(surfacepartrequest->size.x <= 0)
-      return;
-    surfacepartrequest->source.x -= request.pos.x;
-    request.pos.x = 0;
-  }
-  if(request.pos.y < 0) {
-    surfacepartrequest->size.y += request.pos.y;
-    if(surfacepartrequest->size.y <= 0)
-      return;
-    surfacepartrequest->source.y -= request.pos.y;
-    request.pos.y = 0;
-  }
-  request.request_data = surfacepartrequest;
+  DrawingRequest* request = new(obst) DrawingRequest();
+
+  request->target = target;
+  request->type = SURFACE_PART;
+  request->pos = transform.apply(dstrect.p1);
+  request->layer = layer;
+  request->drawing_effect = transform.drawing_effect;
+  request->alpha = transform.alpha;
+
+  SurfacePartRequest* surfacepartrequest = new(obst) SurfacePartRequest();
+  surfacepartrequest->srcrect = srcrect;
+  surfacepartrequest->dstsize = dstrect.get_size();
+  surfacepartrequest->surface = surface.get();
+
+  request->request_data = surfacepartrequest;
 
   requests->push_back(request);
 }
 
 void
-DrawingContext::draw_text(const Font* font, const std::string& text,
-    const Vector& position, FontAlignment alignment, int layer)
+DrawingContext::draw_text(FontPtr font, const std::string& text,
+                          const Vector& position, FontAlignment alignment, int layer, Color color)
 {
-  DrawingRequest request;
-
-  request.type = TEXT;
-  request.pos = transform.apply(position);
-  request.layer = layer;
-  request.drawing_effect = transform.drawing_effect;
-  request.zoom = transform.zoom;
-  request.alpha = transform.alpha;
-
-  TextRequest* textrequest = new TextRequest;
-  textrequest->font = font;
+  DrawingRequest* request = new(obst) DrawingRequest();
+
+  request->target = target;
+  request->type = TEXT;
+  request->pos = transform.apply(position);
+  request->layer = layer;
+  request->drawing_effect = transform.drawing_effect;
+  request->alpha = transform.alpha;
+  request->color = color;
+
+  TextRequest* textrequest = new(obst) TextRequest();
+  textrequest->font = font.get();
   textrequest->text = text;
   textrequest->alignment = alignment;
-  request.request_data = textrequest;
+  request->request_data = textrequest;
 
   requests->push_back(request);
 }
 
 void
-DrawingContext::draw_center_text(const Font* font, const std::string& text,
-    const Vector& position, int layer)
+DrawingContext::draw_center_text(FontPtr font, const std::string& text,
+                                 const Vector& position, int layer, Color color)
 {
   draw_text(font, text, Vector(position.x + SCREEN_WIDTH/2, position.y),
-      CENTER_ALLIGN, layer);
+            ALIGN_CENTER, layer, color);
 }
 
 void
-DrawingContext::draw_gradient(Color top, Color bottom, int layer)
+DrawingContext::draw_gradient(const Color& top, const Color& bottom, int layer)
 {
-  DrawingRequest request;
+  DrawingRequest* request = new(obst) DrawingRequest();
 
-  request.type = GRADIENT;
-  request.pos = Vector(0,0);
-  request.layer = layer;
+  request->target = target;
+  request->type = GRADIENT;
+  request->pos = Vector(0,0);
+  request->layer = layer;
 
-  request.drawing_effect = transform.drawing_effect;
-  request.zoom = transform.zoom;
-  request.alpha = transform.alpha;
+  request->drawing_effect = transform.drawing_effect;
+  request->alpha = transform.alpha;
 
-  GradientRequest* gradientrequest = new GradientRequest;
+  GradientRequest* gradientrequest = new(obst) GradientRequest();
   gradientrequest->top = top;
   gradientrequest->bottom = bottom;
-  request.request_data = gradientrequest;
+  request->request_data = gradientrequest;
 
   requests->push_back(request);
 }
 
 void
 DrawingContext::draw_filled_rect(const Vector& topleft, const Vector& size,
-        Color color, int layer)
+                                 const Color& color, int layer)
 {
-  DrawingRequest request;
+  DrawingRequest* request = new(obst) DrawingRequest();
 
-  request.type = FILLRECT;
-  request.pos = transform.apply(topleft);
-  request.layer = layer;
+  request->target = target;
+  request->type = FILLRECT;
+  request->pos = transform.apply(topleft);
+  request->layer = layer;
 
-  request.drawing_effect = transform.drawing_effect;
-  request.zoom = transform.zoom;
-  request.alpha = transform.alpha;                    
+  request->drawing_effect = transform.drawing_effect;
+  request->alpha = transform.alpha;
 
-  FillRectRequest* fillrectrequest = new FillRectRequest;
+  FillRectRequest* fillrectrequest = new(obst) FillRectRequest();
   fillrectrequest->size = size;
   fillrectrequest->color = color;
-  fillrectrequest->color.alpha
-      = (int) ((float) fillrectrequest->color.alpha 
-              * ((float) transform.alpha / 255.0));
-  request.request_data = fillrectrequest;
+  fillrectrequest->color.alpha = color.alpha * transform.alpha;
+  fillrectrequest->radius = 0.0f;
+  request->request_data = fillrectrequest;
 
   requests->push_back(request);
 }
 
 void
-DrawingContext::draw_surface_part(DrawingRequest& request)
+DrawingContext::draw_filled_rect(const Rectf& rect, const Color& color,
+                                 int layer)
 {
-  SurfacePartRequest* surfacepartrequest
-    = (SurfacePartRequest*) request.request_data;
-
-  surfacepartrequest->surface->impl->draw_part(
-      surfacepartrequest->source.x, surfacepartrequest->source.y,
-      request.pos.x, request.pos.y,
-      surfacepartrequest->size.x, surfacepartrequest->size.y, request.alpha,
-      request.drawing_effect);
-
-  delete surfacepartrequest;
+  draw_filled_rect(rect, color, 0.0f, layer);
 }
 
 void
-DrawingContext::draw_gradient(DrawingRequest& request)
+DrawingContext::draw_filled_rect(const Rectf& rect, const Color& color, float radius, int layer)
 {
-  GradientRequest* gradientrequest = (GradientRequest*) request.request_data;
-  const Color& top = gradientrequest->top;
-  const Color& bottom = gradientrequest->bottom;
-  
-  glBegin(GL_QUADS);
-  glColor3ub(top.red, top.green, top.blue);
-  glVertex2f(0, 0);
-  glVertex2f(SCREEN_WIDTH, 0);
-  glColor3ub(bottom.red, bottom.green, bottom.blue);
-  glVertex2f(SCREEN_WIDTH, SCREEN_HEIGHT);
-  glVertex2f(0, SCREEN_HEIGHT);
-  glEnd();
-
-  delete gradientrequest;
+  DrawingRequest* request = new(obst) DrawingRequest();
+
+  request->target = target;
+  request->type   = FILLRECT;
+  request->pos    = transform.apply(rect.p1);
+  request->layer  = layer;
+
+  request->drawing_effect = transform.drawing_effect;
+  request->alpha = transform.alpha;
+
+  FillRectRequest* fillrectrequest = new(obst) FillRectRequest;
+  fillrectrequest->size = Vector(rect.get_width(), rect.get_height());
+  fillrectrequest->color = color;
+  fillrectrequest->color.alpha = color.alpha * transform.alpha;
+  fillrectrequest->radius = radius;
+  request->request_data = fillrectrequest;
+
+  requests->push_back(request);
 }
 
 void
-DrawingContext::draw_text(DrawingRequest& request)
+DrawingContext::draw_inverse_ellipse(const Vector& pos, const Vector& size, const Color& color, int layer)
 {
-  TextRequest* textrequest = (TextRequest*) request.request_data;
+  DrawingRequest* request = new(obst) DrawingRequest();
+
+  request->target = target;
+  request->type   = INVERSEELLIPSE;
+  request->pos    = transform.apply(pos);
+  request->layer  = layer;
+
+  request->drawing_effect = transform.drawing_effect;
+  request->alpha = transform.alpha;
+
+  InverseEllipseRequest* ellipse = new(obst)InverseEllipseRequest;
 
-  textrequest->font->draw(textrequest->text, request.pos,
-      textrequest->alignment, request.drawing_effect, request.alpha);
+  ellipse->color        = color;
+  ellipse->color.alpha  = color.alpha * transform.alpha;
+  ellipse->size         = size;
+  request->request_data = ellipse;
 
-  delete textrequest;
+  requests->push_back(request);
+}
+
+Rectf
+DrawingContext::get_cliprect() const
+{
+  return Rectf(get_translation().x, get_translation().y,
+               get_translation().x + SCREEN_WIDTH,
+               get_translation().y + SCREEN_HEIGHT);
 }
 
 void
-DrawingContext::draw_filled_rect(DrawingRequest& request)
+DrawingContext::get_light(const Vector& position, Color* color)
 {
-  FillRectRequest* fillrectrequest = (FillRectRequest*) request.request_data;
-
-  float x = request.pos.x;
-  float y = request.pos.y;
-  float w = fillrectrequest->size.x;
-  float h = fillrectrequest->size.y;
-
-  glEnable(GL_BLEND);
-  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-  glColor4ub(fillrectrequest->color.red, fillrectrequest->color.green,
-             fillrectrequest->color.blue, fillrectrequest->color.alpha);
-  
-  glBegin(GL_POLYGON);
-  glVertex2f(x, y);
-  glVertex2f(x+w, y);
-  glVertex2f(x+w, y+h);
-  glVertex2f(x, y+h);
-  glEnd();
-  glDisable(GL_BLEND);
-
-  delete fillrectrequest;
+  if( ambient_color.red == 1.0f && ambient_color.green == 1.0f
+      && ambient_color.blue  == 1.0f ) {
+    *color = Color( 1.0f, 1.0f, 1.0f);
+    return;
+  }
+
+  DrawingRequest* request = new(obst) DrawingRequest();
+  request->target = target;
+  request->type = GETLIGHT;
+  request->pos = transform.apply(position);
+
+  //There is no light offscreen.
+  if(request->pos.x >= SCREEN_WIDTH || request->pos.y >= SCREEN_HEIGHT
+     || request->pos.x < 0 || request->pos.y < 0){
+    *color = Color( 0, 0, 0);
+    return;
+  }
+
+  request->layer = LAYER_GUI; //make sure all get_light requests are handled last.
+  GetLightRequest* getlightrequest = new(obst) GetLightRequest();
+  getlightrequest->color_ptr = color;
+  request->request_data = getlightrequest;
+  lightmap_requests.push_back(request);
 }
 
 void
 DrawingContext::do_drawing()
 {
-#ifdef DEBUG
   assert(transformstack.empty());
   assert(target_stack.empty());
-#endif
   transformstack.clear();
   target_stack.clear();
 
-  bool use_lightmap = lightmap_requests.size() != 0;
-  
+  //Use Lightmap if ambient color is not white.
+  bool use_lightmap = ( ambient_color.red != 1.0f ||
+                        ambient_color.green != 1.0f ||
+                        ambient_color.blue != 1.0f );
+
   // PART1: create lightmap
   if(use_lightmap) {
-    glViewport(0, screen->h - lightmap_height, lightmap_width, lightmap_height);
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();               
-    glOrtho(0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, -1.0, 1.0);
-    glMatrixMode(GL_MODELVIEW);
-    glLoadIdentity();
-
-    glClearColor(1, 1, 1, 1);
-    glClear(GL_COLOR_BUFFER_BIT);
+    Lightmap& lightmap = video_system.get_lightmap();
+
+    lightmap.start_draw(ambient_color);
     handle_drawing_requests(lightmap_requests);
-    lightmap_requests.clear();
-  
-    glDisable(GL_BLEND);
-    glEnable(GL_TEXTURE_2D);
-    glBindTexture(GL_TEXTURE_2D, lightmap->handle);
-    glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, screen->h - lightmap_height, lightmap_width, lightmap_height);
-
-    glViewport(0, 0, screen->w, screen->h);
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();               
-    glOrtho(0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, -1.0, 1.0);
-    glMatrixMode(GL_MODELVIEW);    
-    glLoadIdentity();
+    lightmap.end_draw();
+
+    DrawingRequest* request = new(obst) DrawingRequest();
+    request->target = NORMAL;
+    request->type = DRAW_LIGHTMAP;
+    request->layer = LAYER_HUD - 1;
+    drawing_requests.push_back(request);
   }
 
-  //glClear(GL_COLOR_BUFFER_BIT);
+  Renderer& renderer = video_system.get_renderer();
+  renderer.start_draw();
   handle_drawing_requests(drawing_requests);
-  drawing_requests.clear();
-
-  if(use_lightmap) {
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_DST_COLOR, GL_ZERO);
-    //glDisable(GL_BLEND);
-    //glColor4f((float) rand() / (float) RAND_MAX, .22, .88, 1.0f);
-
-    glEnable(GL_TEXTURE_2D);
-    glDisable(GL_DEPTH_TEST);
-    glDisable(GL_CULL_FACE);
-    glDisable(GL_ALPHA_TEST);    
-
-    glBindTexture(GL_TEXTURE_2D, lightmap->handle);
-    glBegin(GL_QUADS);
+  renderer.end_draw();
 
-    glTexCoord2f(0, lightmap_uv_bottom);
-    glVertex2f(0, 0);
+  clear_drawing_requests(lightmap_requests);
+  clear_drawing_requests(drawing_requests);
 
-    glTexCoord2f(lightmap_uv_right, lightmap_uv_bottom);
-    glVertex2f(SCREEN_WIDTH, 0);
+  obstack_free(&obst, NULL);
+  obstack_init(&obst);
 
-    glTexCoord2f(lightmap_uv_right, 0);
-    glVertex2f(SCREEN_WIDTH, SCREEN_HEIGHT);
-
-    glTexCoord2f(0, 0);
-    glVertex2f(0, SCREEN_HEIGHT);
-    
-    glEnd();
+  // if a screenshot was requested, take one
+  if (screenshot_requested) {
+    renderer.do_take_screenshot();
+    screenshot_requested = false;
   }
 
-  assert_gl("drawing");
-
-  SDL_GL_SwapBuffers();
+  renderer.flip();
 }
 
+class RequestPtrCompare
+{
+public:
+  bool operator()(const DrawingRequest* r1, const DrawingRequest* r2) const
+  {
+    return *r1 < *r2;
+  }
+};
+
 void
-DrawingContext::handle_drawing_requests(DrawingRequests& requests)
+DrawingContext::handle_drawing_requests(DrawingRequests& requests_)
 {
-  std::stable_sort(requests.begin(), requests.end());
-  
-  for(DrawingRequests::iterator i = requests.begin();
-      i != requests.end(); ++i) {
-    switch(i->type) {
-      case SURFACE:
-      {
-        const Surface* surface = (const Surface*) i->request_data;
-
-        if(i->zoom != 1.0)
-          surface->impl->draw_stretched(i->pos.x * i->zoom, i->pos.y * i->zoom,
-                         (int)(surface->w * i->zoom), (int)(surface->h * i->zoom),
-                         i->alpha, i->drawing_effect);
-        else
-          surface->impl->draw(i->pos.x, i->pos.y, i->alpha, i->drawing_effect);
-        break;
-      }
-      case SURFACE_PART:
-        draw_surface_part(*i);
-        break;
-      case GRADIENT:
-        draw_gradient(*i);
+  std::stable_sort(requests_.begin(), requests_.end(), RequestPtrCompare());
+
+  Renderer& renderer = video_system.get_renderer();
+  Lightmap& lightmap = video_system.get_lightmap();
+
+  DrawingRequests::const_iterator i;
+  for(i = requests_.begin(); i != requests_.end(); ++i) {
+    const DrawingRequest& request = **i;
+
+    switch(request.target) {
+      case NORMAL:
+        switch(request.type) {
+          case SURFACE:
+            renderer.draw_surface(request);
+            break;
+          case SURFACE_PART:
+            renderer.draw_surface_part(request);
+            break;
+          case GRADIENT:
+            renderer.draw_gradient(request);
+            break;
+          case TEXT:
+          {
+            const TextRequest* textrequest = static_cast<TextRequest*>(request.request_data);
+            textrequest->font->draw(&renderer, textrequest->text, request.pos,
+                                    textrequest->alignment, request.drawing_effect, request.color, request.alpha);
+          }
+          break;
+          case FILLRECT:
+            renderer.draw_filled_rect(request);
+            break;
+          case INVERSEELLIPSE:
+            renderer.draw_inverse_ellipse(request);
+            break;
+          case DRAW_LIGHTMAP:
+            lightmap.do_draw();
+            break;
+          case GETLIGHT:
+            lightmap.get_light(request);
+            break;
+        }
         break;
-      case TEXT:
-        draw_text(*i);
-        break;
-      case FILLRECT:
-        draw_filled_rect(*i);
+      case LIGHTMAP:
+        switch(request.type) {
+          case SURFACE:
+            lightmap.draw_surface(request);
+            break;
+          case SURFACE_PART:
+            lightmap.draw_surface_part(request);
+            break;
+          case GRADIENT:
+            lightmap.draw_gradient(request);
+            break;
+          case TEXT:
+          {
+            const TextRequest* textrequest = static_cast<TextRequest*>(request.request_data);
+            textrequest->font->draw(&renderer, textrequest->text, request.pos,
+                                    textrequest->alignment, request.drawing_effect, request.color, request.alpha);
+          }
+          break;
+          case FILLRECT:
+            lightmap.draw_filled_rect(request);
+            break;
+          case INVERSEELLIPSE:
+            assert(!"InverseEllipse doesn't make sense on the lightmap");
+            break;
+          case DRAW_LIGHTMAP:
+            lightmap.do_draw();
+            break;
+          case GETLIGHT:
+            lightmap.get_light(request);
+            break;
+        }
         break;
     }
   }
@@ -404,30 +456,24 @@ DrawingContext::pop_transform()
 }
 
 void
-DrawingContext::set_drawing_effect(uint32_t effect)
+DrawingContext::set_drawing_effect(DrawingEffect effect)
 {
   transform.drawing_effect = effect;
 }
 
-uint32_t
+DrawingEffect
 DrawingContext::get_drawing_effect() const
 {
   return transform.drawing_effect;
 }
 
 void
-DrawingContext::set_zooming(float zoom)
-{
-  transform.zoom = zoom;
-}
-
-void
-DrawingContext::set_alpha(uint8_t alpha)
+DrawingContext::set_alpha(float alpha)
 {
   transform.alpha = alpha;
 }
 
-uint8_t
+float
 DrawingContext::get_alpha() const
 {
   return transform.alpha;
@@ -447,12 +493,27 @@ DrawingContext::pop_target()
 }
 
 void
-DrawingContext::set_target(Target target)
+DrawingContext::set_target(Target target_)
 {
-  this->target = target;
-  if(target == LIGHTMAP)
+  this->target = target_;
+  if(target_ == LIGHTMAP) {
     requests = &lightmap_requests;
-  else
+  } else {
+    assert(target_ == NORMAL);
     requests = &drawing_requests;
+  }
+}
+
+void
+DrawingContext::set_ambient_color( Color new_color )
+{
+  ambient_color = new_color;
+}
+
+void
+DrawingContext::take_screenshot()
+{
+  screenshot_requested = true;
 }
 
+/* EOF */