src/video/drawing_context.cpp

   1 //  $Id$
   2 //
   3 //  SuperTux
   4 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
   5 //
   6 //  This program is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU General Public License
   8 //  as published by the Free Software Foundation; either version 2
   9 //  of the License, or (at your option) any later version.
  10 //
  11 //  This program is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 //  GNU General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU General Public License
  17 //  along with this program; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19 #include <config.h>
  20 #include <algorithm>
  21
  22 #include "drawing_context.hpp"
  23
  24 #include "drawing_request.hpp"
  25 #include "video_systems.hpp"
  26 #include "renderer.hpp"
  27 #include "lightmap.hpp"
  28 #include "surface.hpp"
  29 #include "main.hpp"
  30 #include "gameconfig.hpp"
  31 #include "texture.hpp"
  32 #include "texture_manager.hpp"
  33 #include "obstack/obstackpp.hpp"
  34
  35 static inline int next_po2(int val)
  36 {
  37   int result = 1;
  38   while(result < val)
  39     result *= 2;
  40
  41   return result;
  42 }
  43
  44 DrawingContext::DrawingContext() :
  45   renderer(0), lightmap(0), ambient_color(1.0f, 1.0f, 1.0f, 1.0f), target(NORMAL), screenshot_requested(false)
  46 {
  47   requests = &drawing_requests;
  48   obstack_init(&obst);
  49 }
  50
  51 DrawingContext::~DrawingContext()
  52 {
  53   delete renderer;
  54   delete lightmap;
  55
  56   obstack_free(&obst, NULL);
  57 }
  58
  59 void
  60 DrawingContext::init_renderer()
  61 {
  62   delete renderer;
  63   delete lightmap;
  64
  65   renderer = new_renderer();
  66   lightmap = new_lightmap();
  67 }
  68
  69 void
  70 DrawingContext::draw_surface(const Surface* surface, const Vector& position,
  71                              float angle, const Color& color, const Blend& blend,
  72                              int layer)
  73 {
  74   assert(surface != 0);
  75
  76   DrawingRequest* request = new(obst) DrawingRequest();
  77
  78   request->target = target;
  79   request->type = SURFACE;
  80   request->pos = transform.apply(position);
  81
  82   if(request->pos.x >= SCREEN_WIDTH || request->pos.y >= SCREEN_HEIGHT
  83       || request->pos.x + surface->get_width() < 0
  84       || request->pos.y + surface->get_height() < 0)
  85     return;
  86
  87   request->layer = layer;
  88   request->drawing_effect = transform.drawing_effect;
  89   request->alpha = transform.alpha;
  90   request->angle = angle;
  91   request->color = color;
  92   request->blend = blend;
  93
  94   request->request_data = const_cast<Surface*> (surface);
  95
  96   requests->push_back(request);
  97 }
  98
  99 void
 100 DrawingContext::draw_surface(const Surface* surface, const Vector& position,
 101     int layer)
 102 {
 103   draw_surface(surface, position, 0.0f, Color(1.0f, 1.0f, 1.0f), Blend(), layer);
 104 }
 105
 106 void
 107 DrawingContext::draw_surface_part(const Surface* surface, const Vector& source,
 108     const Vector& size, const Vector& dest, int layer)
 109 {
 110   assert(surface != 0);
 111
 112   DrawingRequest* request = new(obst) DrawingRequest();
 113
 114   request->target = target;
 115   request->type = SURFACE_PART;
 116   request->pos = transform.apply(dest);
 117   request->layer = layer;
 118   request->drawing_effect = transform.drawing_effect;
 119   request->alpha = transform.alpha;
 120
 121   SurfacePartRequest* surfacepartrequest = new(obst) SurfacePartRequest();
 122   surfacepartrequest->size = size;
 123   surfacepartrequest->source = source;
 124   surfacepartrequest->surface = surface;
 125
 126   // clip on screen borders
 127   if(request->pos.x < 0) {
 128     surfacepartrequest->size.x += request->pos.x;
 129     if(surfacepartrequest->size.x <= 0)
 130       return;
 131     surfacepartrequest->source.x -= request->pos.x;
 132     request->pos.x = 0;
 133   }
 134   if(request->pos.y < 0) {
 135     surfacepartrequest->size.y += request->pos.y;
 136     if(surfacepartrequest->size.y <= 0)
 137       return;
 138     surfacepartrequest->source.y -= request->pos.y;
 139     request->pos.y = 0;
 140   }
 141   request->request_data = surfacepartrequest;
 142
 143   requests->push_back(request);
 144 }
 145
 146 void
 147 DrawingContext::draw_text(const Font* font, const std::string& text,
 148     const Vector& position, FontAlignment alignment, int layer, Color color)
 149 {
 150   DrawingRequest* request = new(obst) DrawingRequest();
 151
 152   request->target = target;
 153   request->type = TEXT;
 154   request->pos = transform.apply(position);
 155   request->layer = layer;
 156   request->drawing_effect = transform.drawing_effect;
 157   request->alpha = transform.alpha;
 158   request->color = color;
 159
 160   TextRequest* textrequest = new(obst) TextRequest();
 161   textrequest->font = font;
 162   textrequest->text = text;
 163   textrequest->alignment = alignment;
 164   request->request_data = textrequest;
 165
 166   requests->push_back(request);
 167 }
 168
 169 void
 170 DrawingContext::draw_center_text(const Font* font, const std::string& text,
 171     const Vector& position, int layer, Color color)
 172 {
 173   draw_text(font, text, Vector(position.x + SCREEN_WIDTH/2, position.y),
 174       ALIGN_CENTER, layer, color);
 175 }
 176
 177 void
 178 DrawingContext::draw_gradient(const Color& top, const Color& bottom, int layer)
 179 {
 180   DrawingRequest* request = new(obst) DrawingRequest();
 181
 182   request->target = target;
 183   request->type = GRADIENT;
 184   request->pos = Vector(0,0);
 185   request->layer = layer;
 186
 187   request->drawing_effect = transform.drawing_effect;
 188   request->alpha = transform.alpha;
 189
 190   GradientRequest* gradientrequest = new(obst) GradientRequest();
 191   gradientrequest->top = top;
 192   gradientrequest->bottom = bottom;
 193   request->request_data = gradientrequest;
 194
 195   requests->push_back(request);
 196 }
 197
 198 void
 199 DrawingContext::draw_filled_rect(const Vector& topleft, const Vector& size,
 200                                  const Color& color, int layer)
 201 {
 202   DrawingRequest* request = new(obst) DrawingRequest();
 203
 204   request->target = target;
 205   request->type = FILLRECT;
 206   request->pos = transform.apply(topleft);
 207   request->layer = layer;
 208
 209   request->drawing_effect = transform.drawing_effect;
 210   request->alpha = transform.alpha;
 211
 212   FillRectRequest* fillrectrequest = new(obst) FillRectRequest();
 213   fillrectrequest->size = size;
 214   fillrectrequest->color = color;
 215   fillrectrequest->color.alpha = color.alpha * transform.alpha;
 216   fillrectrequest->radius = 0.0f;
 217   request->request_data = fillrectrequest;
 218
 219   requests->push_back(request);
 220 }
 221
 222 void
 223 DrawingContext::draw_filled_rect(const Rect& rect, const Color& color,
 224                                  int layer)
 225 {
 226   draw_filled_rect(rect, color, 0.0f, layer);
 227 }
 228
 229 void
 230 DrawingContext::draw_filled_rect(const Rect& rect, const Color& color, float radius, int layer)
 231 {
 232   DrawingRequest* request = new(obst) DrawingRequest();
 233
 234   request->target = target;
 235   request->type   = FILLRECT;
 236   request->pos    = transform.apply(rect.p1);
 237   request->layer  = layer;
 238
 239   request->drawing_effect = transform.drawing_effect;
 240   request->alpha = transform.alpha;
 241
 242   FillRectRequest* fillrectrequest = new(obst) FillRectRequest;
 243   fillrectrequest->size = Vector(rect.get_width(), rect.get_height());
 244   fillrectrequest->color = color;
 245   fillrectrequest->color.alpha = color.alpha * transform.alpha;
 246   fillrectrequest->radius = radius;
 247   request->request_data = fillrectrequest;
 248
 249   requests->push_back(request);
 250 }
 251
 252 void
 253 DrawingContext::draw_inverse_ellipse(const Vector& pos, const Vector& size, const Color& color, int layer)
 254 {
 255   DrawingRequest* request = new(obst) DrawingRequest();
 256
 257   request->target = target;
 258   request->type   = INVERSEELLIPSE;
 259   request->pos    = transform.apply(pos);
 260   request->layer  = layer;
 261
 262   request->drawing_effect = transform.drawing_effect;
 263   request->alpha = transform.alpha;
 264
 265   InverseEllipseRequest* ellipse = new(obst)InverseEllipseRequest;
 266
 267   ellipse->color        = color;
 268   ellipse->color.alpha  = color.alpha * transform.alpha;
 269   ellipse->size         = size;
 270   request->request_data = ellipse;
 271
 272   requests->push_back(request);
 273 }
 274
 275 void
 276 DrawingContext::get_light(const Vector& position, Color* color)
 277 {
 278   if( ambient_color.red == 1.0f && ambient_color.green == 1.0f
 279       && ambient_color.blue  == 1.0f ) {
 280     *color = Color( 1.0f, 1.0f, 1.0f);
 281     return;
 282   }
 283
 284   DrawingRequest* request = new(obst) DrawingRequest();
 285   request->target = target;
 286   request->type = GETLIGHT;
 287   request->pos = transform.apply(position);
 288
 289   //There is no light offscreen.
 290   if(request->pos.x >= SCREEN_WIDTH || request->pos.y >= SCREEN_HEIGHT
 291       || request->pos.x < 0 || request->pos.y < 0){
 292     *color = Color( 0, 0, 0);
 293     return;
 294   }
 295
 296   request->layer = LAYER_GUI; //make sure all get_light requests are handled last.
 297   GetLightRequest* getlightrequest = new(obst) GetLightRequest();
 298   getlightrequest->color_ptr = color;
 299   request->request_data = getlightrequest;
 300   lightmap_requests.push_back(request);
 301 }
 302
 303 void
 304 DrawingContext::do_drawing()
 305 {
 306 #ifdef DEBUG
 307   assert(transformstack.empty());
 308   assert(target_stack.empty());
 309 #endif
 310   transformstack.clear();
 311   target_stack.clear();
 312
 313   //Use Lightmap if ambient color is not white.
 314   bool use_lightmap = ( ambient_color.red != 1.0f   || ambient_color.green != 1.0f ||
 315                         ambient_color.blue  != 1.0f );
 316
 317   // PART1: create lightmap
 318   if(use_lightmap) {
 319     lightmap->start_draw(ambient_color);
 320     handle_drawing_requests(lightmap_requests);
 321     lightmap->end_draw();
 322
 323     DrawingRequest* request = new(obst) DrawingRequest();
 324     request->target = NORMAL;
 325     request->type = DRAW_LIGHTMAP;
 326     request->layer = LAYER_HUD - 1;
 327     drawing_requests.push_back(request);
 328   }
 329   lightmap_requests.clear();
 330
 331   handle_drawing_requests(drawing_requests);
 332   drawing_requests.clear();
 333   obstack_free(&obst, NULL);
 334   obstack_init(&obst);
 335
 336   // if a screenshot was requested, take one
 337   if (screenshot_requested) {
 338     renderer->do_take_screenshot();
 339     screenshot_requested = false;
 340   }
 341
 342   renderer->flip();
 343 }
 344
 345 class RequestPtrCompare
 346   :  public std::binary_function<const DrawingRequest*,
 347                                  const DrawingRequest*,
 348                                  bool>
 349 {
 350 public:
 351   bool operator()(const DrawingRequest* r1, const DrawingRequest* r2) const
 352   {
 353     return *r1 < *r2;
 354   }
 355 };
 356
 357 void
 358 DrawingContext::handle_drawing_requests(DrawingRequests& requests)
 359 {
 360   std::stable_sort(requests.begin(), requests.end(), RequestPtrCompare());
 361
 362   DrawingRequests::const_iterator i;
 363   for(i = requests.begin(); i != requests.end(); ++i) {
 364     const DrawingRequest& request = **i;
 365
 366     switch(request.target) {
 367       case NORMAL:
 368         switch(request.type) {
 369           case SURFACE:
 370             renderer->draw_surface(request);
 371             break;
 372           case SURFACE_PART:
 373             renderer->draw_surface_part(request);
 374             break;
 375           case GRADIENT:
 376             renderer->draw_gradient(request);
 377             break;
 378           case TEXT:
 379             {
 380               const TextRequest* textrequest = (TextRequest*) request.request_data;
 381               textrequest->font->draw(renderer, textrequest->text, request.pos,
 382                   textrequest->alignment, request.drawing_effect, request.color, request.alpha);
 383             }
 384             break;
 385           case FILLRECT:
 386             renderer->draw_filled_rect(request);
 387             break;
 388           case INVERSEELLIPSE:
 389             renderer->draw_inverse_ellipse(request);
 390             break;
 391           case DRAW_LIGHTMAP:
 392             lightmap->do_draw();
 393             break;
 394           case GETLIGHT:
 395             lightmap->get_light(request);
 396             break;
 397         }
 398         break;
 399       case LIGHTMAP:
 400         switch(request.type) {
 401           case SURFACE:
 402             lightmap->draw_surface(request);
 403             break;
 404           case SURFACE_PART:
 405             lightmap->draw_surface_part(request);
 406             break;
 407           case GRADIENT:
 408             lightmap->draw_gradient(request);
 409             break;
 410           case TEXT:
 411             {
 412               const TextRequest* textrequest = (TextRequest*) request.request_data;
 413               textrequest->font->draw(renderer, textrequest->text, request.pos,
 414                   textrequest->alignment, request.drawing_effect, request.color, request.alpha);
 415             }
 416             break;
 417           case FILLRECT:
 418             lightmap->draw_filled_rect(request);
 419             break;
 420           case INVERSEELLIPSE:
 421             assert(!"InverseEllipse doesn't make sense on the lightmap");
 422             break;
 423           case DRAW_LIGHTMAP:
 424             lightmap->do_draw();
 425             break;
 426           case GETLIGHT:
 427             lightmap->get_light(request);
 428             break;
 429         }
 430         break;
 431     }
 432   }
 433 }
 434
 435 void
 436 DrawingContext::push_transform()
 437 {
 438   transformstack.push_back(transform);
 439 }
 440
 441 void
 442 DrawingContext::pop_transform()
 443 {
 444   assert(!transformstack.empty());
 445
 446   transform = transformstack.back();
 447   transformstack.pop_back();
 448 }
 449
 450 void
 451 DrawingContext::set_drawing_effect(DrawingEffect effect)
 452 {
 453   transform.drawing_effect = effect;
 454 }
 455
 456 DrawingEffect
 457 DrawingContext::get_drawing_effect() const
 458 {
 459   return transform.drawing_effect;
 460 }
 461
 462 void
 463 DrawingContext::set_alpha(float alpha)
 464 {
 465   transform.alpha = alpha;
 466 }
 467
 468 float
 469 DrawingContext::get_alpha() const
 470 {
 471   return transform.alpha;
 472 }
 473
 474 void
 475 DrawingContext::push_target()
 476 {
 477   target_stack.push_back(target);
 478 }
 479
 480 void
 481 DrawingContext::pop_target()
 482 {
 483   set_target(target_stack.back());
 484   target_stack.pop_back();
 485 }
 486
 487 void
 488 DrawingContext::set_target(Target target)
 489 {
 490   this->target = target;
 491   if(target == LIGHTMAP) {
 492     requests = &lightmap_requests;
 493   } else {
 494     assert(target == NORMAL);
 495     requests = &drawing_requests;
 496   }
 497 }
 498
 499 void
 500 DrawingContext::set_ambient_color( Color new_color )
 501 {
 502   ambient_color = new_color;
 503 }
 504
 505 void
 506 DrawingContext::take_screenshot()
 507 {
 508   screenshot_requested = true;
 509 }
 510