src/video/drawing_context.cpp

   1 //  SuperTux
   2 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
   3 //
   4 //  This program is free software: you can redistribute it and/or modify
   5 //  it under the terms of the GNU General Public License as published by
   6 //  the Free Software Foundation, either version 3 of the License, or
   7 //  (at your option) any later version.
   8 //
   9 //  This program is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 //  GNU General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU General Public License
  15 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "video/drawing_context.hpp"
  18
  19 #include <algorithm>
  20 #include <config.h>
  21
  22 #include "math/sizef.hpp"
  23 #include "supertux/gameconfig.hpp"
  24 #include "supertux/globals.hpp"
  25 #include "util/obstackpp.hpp"
  26 #include "video/drawing_request.hpp"
  27 #include "video/lightmap.hpp"
  28 #include "video/renderer.hpp"
  29 #include "video/surface.hpp"
  30 #include "video/texture.hpp"
  31 #include "video/texture_manager.hpp"
  32 #include "video/video_systems.hpp"
  33
  34 DrawingContext::DrawingContext(Renderer& renderer, Lightmap& lightmap) :
  35   renderer(renderer),
  36   lightmap(lightmap),
  37   transformstack(),
  38   transform(),
  39   blend_stack(),
  40   blend_mode(),
  41   drawing_requests(),
  42   lightmap_requests(),
  43   requests(),
  44   ambient_color(1.0f, 1.0f, 1.0f, 1.0f),
  45   target(NORMAL),
  46   target_stack(),
  47   obst(),
  48   screenshot_requested(false)
  49 {
  50   requests = &drawing_requests;
  51   obstack_init(&obst);
  52 }
  53
  54 DrawingContext::~DrawingContext()
  55 {
  56   clear_drawing_requests(lightmap_requests);
  57   clear_drawing_requests(drawing_requests);
  58
  59   obstack_free(&obst, NULL);
  60 }
  61
  62 void
  63 DrawingContext::clear_drawing_requests(DrawingRequests& requests)
  64 {
  65   for(auto& request : requests)
  66   {
  67     if (request->request_data)
  68     {
  69       request->request_data->~DrawingRequestData();
  70     }
  71     request->~DrawingRequest();
  72   }
  73   requests.clear();
  74 }
  75
  76 void
  77 DrawingContext::draw_surface(SurfacePtr surface, const Vector& position,
  78                              float angle, const Color& color, const Blend& blend,
  79                              int layer)
  80 {
  81   assert(surface != 0);
  82
  83   DrawingRequest* request = new(obst) DrawingRequest();
  84
  85   request->target = target;
  86   request->type = SURFACE;
  87   request->pos = transform.apply(position);
  88
  89   if(request->pos.x >= SCREEN_WIDTH || request->pos.y >= SCREEN_HEIGHT
  90      || request->pos.x + surface->get_width() < 0
  91      || request->pos.y + surface->get_height() < 0)
  92     return;
  93
  94   request->layer = layer;
  95   request->drawing_effect = transform.drawing_effect;
  96   request->alpha = transform.alpha;
  97   request->angle = angle;
  98   request->color = color;
  99   request->blend = blend;
 100
 101   SurfaceRequest* surfacerequest = new(obst) SurfaceRequest();
 102   surfacerequest->surface = surface.get();
 103   request->request_data = surfacerequest;
 104
 105   requests->push_back(request);
 106 }
 107
 108 void
 109 DrawingContext::draw_surface(SurfacePtr surface, const Vector& position,
 110                              int layer)
 111 {
 112   draw_surface(surface, position, 0.0f, Color(1.0f, 1.0f, 1.0f), Blend(), layer);
 113 }
 114
 115 void
 116 DrawingContext::draw_surface_part(SurfacePtr surface,
 117                                   const Rectf& srcrect, const Rectf& dstrect,
 118                                   int layer)
 119 {
 120   assert(surface != 0);
 121
 122   DrawingRequest* request = new(obst) DrawingRequest();
 123
 124   request->target = target;
 125   request->type = SURFACE_PART;
 126   request->pos = transform.apply(dstrect.p1);
 127   request->layer = layer;
 128   request->drawing_effect = transform.drawing_effect;
 129   request->alpha = transform.alpha;
 130
 131   SurfacePartRequest* surfacepartrequest = new(obst) SurfacePartRequest();
 132   surfacepartrequest->srcrect = srcrect;
 133   surfacepartrequest->dstsize = dstrect.get_size();
 134   surfacepartrequest->surface = surface.get();
 135
 136   request->request_data = surfacepartrequest;
 137
 138   requests->push_back(request);
 139 }
 140
 141 void
 142 DrawingContext::draw_text(FontPtr font, const std::string& text,
 143                           const Vector& position, FontAlignment alignment, int layer, Color color)
 144 {
 145   DrawingRequest* request = new(obst) DrawingRequest();
 146
 147   request->target = target;
 148   request->type = TEXT;
 149   request->pos = transform.apply(position);
 150   request->layer = layer;
 151   request->drawing_effect = transform.drawing_effect;
 152   request->alpha = transform.alpha;
 153   request->color = color;
 154
 155   TextRequest* textrequest = new(obst) TextRequest();
 156   textrequest->font = font.get();
 157   textrequest->text = text;
 158   textrequest->alignment = alignment;
 159   request->request_data = textrequest;
 160
 161   requests->push_back(request);
 162 }
 163
 164 void
 165 DrawingContext::draw_center_text(FontPtr font, const std::string& text,
 166                                  const Vector& position, int layer, Color color)
 167 {
 168   draw_text(font, text, Vector(position.x + SCREEN_WIDTH/2, position.y),
 169             ALIGN_CENTER, layer, color);
 170 }
 171
 172 void
 173 DrawingContext::draw_gradient(const Color& top, const Color& bottom, int layer)
 174 {
 175   DrawingRequest* request = new(obst) DrawingRequest();
 176
 177   request->target = target;
 178   request->type = GRADIENT;
 179   request->pos = Vector(0,0);
 180   request->layer = layer;
 181
 182   request->drawing_effect = transform.drawing_effect;
 183   request->alpha = transform.alpha;
 184
 185   GradientRequest* gradientrequest = new(obst) GradientRequest();
 186   gradientrequest->top = top;
 187   gradientrequest->bottom = bottom;
 188   request->request_data = gradientrequest;
 189
 190   requests->push_back(request);
 191 }
 192
 193 void
 194 DrawingContext::draw_filled_rect(const Vector& topleft, const Vector& size,
 195                                  const Color& color, int layer)
 196 {
 197   DrawingRequest* request = new(obst) DrawingRequest();
 198
 199   request->target = target;
 200   request->type = FILLRECT;
 201   request->pos = transform.apply(topleft);
 202   request->layer = layer;
 203
 204   request->drawing_effect = transform.drawing_effect;
 205   request->alpha = transform.alpha;
 206
 207   FillRectRequest* fillrectrequest = new(obst) FillRectRequest();
 208   fillrectrequest->size = size;
 209   fillrectrequest->color = color;
 210   fillrectrequest->color.alpha = color.alpha * transform.alpha;
 211   fillrectrequest->radius = 0.0f;
 212   request->request_data = fillrectrequest;
 213
 214   requests->push_back(request);
 215 }
 216
 217 void
 218 DrawingContext::draw_filled_rect(const Rectf& rect, const Color& color,
 219                                  int layer)
 220 {
 221   draw_filled_rect(rect, color, 0.0f, layer);
 222 }
 223
 224 void
 225 DrawingContext::draw_filled_rect(const Rectf& rect, const Color& color, float radius, int layer)
 226 {
 227   DrawingRequest* request = new(obst) DrawingRequest();
 228
 229   request->target = target;
 230   request->type   = FILLRECT;
 231   request->pos    = transform.apply(rect.p1);
 232   request->layer  = layer;
 233
 234   request->drawing_effect = transform.drawing_effect;
 235   request->alpha = transform.alpha;
 236
 237   FillRectRequest* fillrectrequest = new(obst) FillRectRequest;
 238   fillrectrequest->size = Vector(rect.get_width(), rect.get_height());
 239   fillrectrequest->color = color;
 240   fillrectrequest->color.alpha = color.alpha * transform.alpha;
 241   fillrectrequest->radius = radius;
 242   request->request_data = fillrectrequest;
 243
 244   requests->push_back(request);
 245 }
 246
 247 void
 248 DrawingContext::draw_inverse_ellipse(const Vector& pos, const Vector& size, const Color& color, int layer)
 249 {
 250   DrawingRequest* request = new(obst) DrawingRequest();
 251
 252   request->target = target;
 253   request->type   = INVERSEELLIPSE;
 254   request->pos    = transform.apply(pos);
 255   request->layer  = layer;
 256
 257   request->drawing_effect = transform.drawing_effect;
 258   request->alpha = transform.alpha;
 259
 260   InverseEllipseRequest* ellipse = new(obst)InverseEllipseRequest;
 261
 262   ellipse->color        = color;
 263   ellipse->color.alpha  = color.alpha * transform.alpha;
 264   ellipse->size         = size;
 265   request->request_data = ellipse;
 266
 267   requests->push_back(request);
 268 }
 269
 270 Rectf
 271 DrawingContext::get_cliprect() const
 272 {
 273   return Rectf(get_translation().x, get_translation().y,
 274                get_translation().x + SCREEN_WIDTH,
 275                get_translation().y + SCREEN_HEIGHT);
 276 }
 277
 278 void
 279 DrawingContext::get_light(const Vector& position, Color* color)
 280 {
 281   if( ambient_color.red == 1.0f && ambient_color.green == 1.0f
 282       && ambient_color.blue  == 1.0f ) {
 283     *color = Color( 1.0f, 1.0f, 1.0f);
 284     return;
 285   }
 286
 287   DrawingRequest* request = new(obst) DrawingRequest();
 288   request->target = target;
 289   request->type = GETLIGHT;
 290   request->pos = transform.apply(position);
 291
 292   //There is no light offscreen.
 293   if(request->pos.x >= SCREEN_WIDTH || request->pos.y >= SCREEN_HEIGHT
 294      || request->pos.x < 0 || request->pos.y < 0){
 295     *color = Color( 0, 0, 0);
 296     return;
 297   }
 298
 299   request->layer = LAYER_GUI; //make sure all get_light requests are handled last.
 300   GetLightRequest* getlightrequest = new(obst) GetLightRequest();
 301   getlightrequest->color_ptr = color;
 302   request->request_data = getlightrequest;
 303   lightmap_requests.push_back(request);
 304 }
 305
 306 void
 307 DrawingContext::do_drawing()
 308 {
 309   assert(transformstack.empty());
 310   assert(target_stack.empty());
 311   transformstack.clear();
 312   target_stack.clear();
 313
 314   //Use Lightmap if ambient color is not white.
 315   bool use_lightmap = ( ambient_color.red != 1.0f ||
 316                         ambient_color.green != 1.0f ||
 317                         ambient_color.blue != 1.0f );
 318
 319   // PART1: create lightmap
 320   if(use_lightmap) {
 321     lightmap.start_draw(ambient_color);
 322     handle_drawing_requests(lightmap_requests);
 323     lightmap.end_draw();
 324
 325     DrawingRequest* request = new(obst) DrawingRequest();
 326     request->target = NORMAL;
 327     request->type = DRAW_LIGHTMAP;
 328     request->layer = LAYER_HUD - 1;
 329     drawing_requests.push_back(request);
 330   }
 331   handle_drawing_requests(drawing_requests);
 332
 333   clear_drawing_requests(lightmap_requests);
 334   clear_drawing_requests(drawing_requests);
 335
 336   obstack_free(&obst, NULL);
 337   obstack_init(&obst);
 338
 339   // if a screenshot was requested, take one
 340   if (screenshot_requested) {
 341     renderer.do_take_screenshot();
 342     screenshot_requested = false;
 343   }
 344
 345   renderer.flip();
 346 }
 347
 348 class RequestPtrCompare
 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
 511 /* EOF */