lib/video/drawing_context.cpp

   1 //  $Id$
   2 //
   3 //  SuperTux -  A Jump'n Run
   4 //  Copyright (C) 2004 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
  21 #include <algorithm>
  22 #include <cassert>
  23 #include <iostream>
  24
  25 #include "../video/drawing_context.h"
  26 #include "../video/surface.h"
  27 #include "../app/globals.h"
  28 #include "../video/font.h"
  29
  30 using namespace SuperTux;
  31
  32 DrawingContext::DrawingContext()
  33 {
  34 }
  35
  36 DrawingContext::~DrawingContext()
  37 {
  38 }
  39
  40 void
  41 DrawingContext::draw_surface(const Surface* surface, const Vector& position,
  42     int layer, Uint32 drawing_effect)
  43 {
  44   assert(surface != 0);
  45
  46   DrawingRequest request;
  47
  48   request.type = SURFACE;
  49   request.pos = transform.apply(position);
  50
  51   if(request.pos.x >= screen->w || request.pos.y >= screen->h
  52       || request.pos.x + surface->w < 0 || request.pos.y + surface->h < 0)
  53     return;
  54
  55   request.layer = layer;
  56   request.drawing_effect = transform.drawing_effect | drawing_effect;
  57   request.zoom = transform.zoom;
  58   request.alpha = transform.alpha;
  59   request.request_data = const_cast<Surface*> (surface);
  60
  61   drawingrequests.push_back(request);
  62 }
  63
  64 void
  65 DrawingContext::draw_surface_part(const Surface* surface, const Vector& source,
  66     const Vector& size, const Vector& dest, int layer, Uint32 drawing_effect)
  67 {
  68   assert(surface != 0);
  69
  70   DrawingRequest request;
  71
  72   request.type = SURFACE_PART;
  73   request.pos = transform.apply(dest);
  74   request.layer = layer;
  75   request.drawing_effect = transform.drawing_effect | drawing_effect;
  76   request.alpha = transform.alpha;
  77
  78   SurfacePartRequest* surfacepartrequest = new SurfacePartRequest();
  79   surfacepartrequest->size = size;
  80   surfacepartrequest->source = source;
  81   surfacepartrequest->surface = surface;
  82   request.request_data = surfacepartrequest;
  83
  84   drawingrequests.push_back(request);
  85 }
  86
  87 void
  88 DrawingContext::draw_text(Font* font, const std::string& text,
  89     const Vector& position, int allignment, int layer,
  90     Uint32 drawing_effect)
  91 {
  92   DrawingRequest request;
  93
  94   request.type = TEXT;
  95   request.pos = transform.apply(position);
  96   request.layer = layer;
  97   request.drawing_effect = transform.drawing_effect | drawing_effect;
  98   request.zoom = transform.zoom;
  99   request.alpha = transform.alpha;
 100
 101   TextRequest* textrequest = new TextRequest;
 102   textrequest->font = font;
 103   textrequest->text = text;
 104   textrequest->allignment = allignment;
 105   request.request_data = textrequest;
 106
 107   drawingrequests.push_back(request);
 108 }
 109
 110 void
 111 DrawingContext::draw_center_text(Font* font, const std::string& text,
 112     const Vector& position, int layer, Uint32 drawing_effect)
 113 {
 114 draw_text(font, text, Vector(position.x + screen->w/2, position.y),
 115           CENTER_ALLIGN, layer, drawing_effect);
 116 }
 117
 118 void
 119 DrawingContext::draw_gradient(Color top, Color bottom, int layer)
 120 {
 121   DrawingRequest request;
 122
 123   request.type = GRADIENT;
 124   request.pos = Vector(0,0);
 125   request.layer = layer;
 126
 127   request.drawing_effect = transform.drawing_effect;
 128   request.zoom = transform.zoom;
 129   request.alpha = transform.alpha;
 130
 131   GradientRequest* gradientrequest = new GradientRequest;
 132   gradientrequest->top = top;
 133   gradientrequest->bottom = bottom;
 134   request.request_data = gradientrequest;
 135
 136   drawingrequests.push_back(request);
 137 }
 138
 139 void
 140 DrawingContext::draw_filled_rect(const Vector& topleft, const Vector& size,
 141         Color color, int layer)
 142 {
 143   DrawingRequest request;
 144
 145   request.type = FILLRECT;
 146   request.pos = transform.apply(topleft);
 147   request.layer = layer;
 148
 149   request.drawing_effect = transform.drawing_effect;
 150   request.zoom = transform.zoom;
 151   request.alpha = transform.alpha;
 152
 153   FillRectRequest* fillrectrequest = new FillRectRequest;
 154   fillrectrequest->size = size;
 155   fillrectrequest->color = color;
 156   request.request_data = fillrectrequest;
 157
 158   drawingrequests.push_back(request);
 159 }
 160
 161 void
 162 DrawingContext::draw_surface_part(DrawingRequest& request)
 163 {
 164   SurfacePartRequest* surfacepartrequest
 165     = (SurfacePartRequest*) request.request_data;
 166
 167   surfacepartrequest->surface->impl->draw_part(
 168       surfacepartrequest->source.x, surfacepartrequest->source.y,
 169       request.pos.x, request.pos.y,
 170       surfacepartrequest->size.x, surfacepartrequest->size.y, request.alpha,
 171       request.drawing_effect);
 172
 173   delete surfacepartrequest;
 174 }
 175
 176 void
 177 DrawingContext::draw_gradient(DrawingRequest& request)
 178 {
 179   GradientRequest* gradientrequest = (GradientRequest*) request.request_data;
 180   const Color& top = gradientrequest->top;
 181   const Color& bottom = gradientrequest->bottom;
 182
 183 #ifndef NOOPENGL
 184   if(use_gl)
 185     {
 186       glBegin(GL_QUADS);
 187       glColor3ub(top.red, top.green, top.blue);
 188       glVertex2f(0, 0);
 189       glVertex2f(screen->w, 0);
 190       glColor3ub(bottom.red, bottom.green, bottom.blue);
 191       glVertex2f(screen->w, screen->h);
 192       glVertex2f(0, screen->h);
 193       glEnd();
 194     }
 195   else
 196   {
 197 #endif
 198     if(&top == &bottom)
 199       {
 200       fillrect(0, 0, screen->w, screen->h, top.red, top.green, top.blue);
 201       }
 202     else
 203       {
 204       float redstep = (float(bottom.red)-float(top.red)) / float(screen->h);
 205       float greenstep = (float(bottom.green)-float(top.green)) / float(screen->h);
 206       float bluestep = (float(bottom.blue) - float(top.blue)) / float(screen->h);
 207
 208       for(float y = 0; y < screen->h; y += 2)
 209         fillrect(0, (int)y, screen->w, 2,
 210             int(float(top.red) + redstep * y),
 211             int(float(top.green) + greenstep * y),
 212             int(float(top.blue) + bluestep * y), 255);
 213       }
 214 #ifndef NOOPENGL
 215
 216     }
 217 #endif
 218
 219   delete gradientrequest;
 220 }
 221
 222 void
 223 DrawingContext::draw_text(DrawingRequest& request)
 224 {
 225   TextRequest* textrequest = (TextRequest*) request.request_data;
 226
 227   textrequest->font->draw(textrequest->text, request.pos, textrequest->allignment, request.drawing_effect, request.alpha);
 228
 229   delete textrequest;
 230 }
 231
 232 void
 233 DrawingContext::draw_filled_rect(DrawingRequest& request)
 234 {
 235   FillRectRequest* fillrectrequest = (FillRectRequest*) request.request_data;
 236
 237   float x = request.pos.x;
 238   float y = request.pos.y;
 239   float w = fillrectrequest->size.x;
 240   float h = fillrectrequest->size.y;
 241
 242 #ifndef NOOPENGL
 243   if(use_gl)
 244     {
 245       glEnable(GL_BLEND);
 246       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 247       glColor4ub(fillrectrequest->color.red, fillrectrequest->color.green,
 248           fillrectrequest->color.blue, fillrectrequest->color.alpha);
 249
 250       glBegin(GL_POLYGON);
 251       glVertex2f(x, y);
 252       glVertex2f(x+w, y);
 253       glVertex2f(x+w, y+h);
 254       glVertex2f(x, y+h);
 255       glEnd();
 256       glDisable(GL_BLEND);
 257     }
 258   else
 259     {
 260 #endif
 261       SDL_Rect src, rect;
 262       SDL_Surface *temp = NULL;
 263
 264       rect.x = (int)x;
 265       rect.y = (int)y;
 266       rect.w = (int)w;
 267       rect.h = (int)h;
 268
 269       if(fillrectrequest->color.alpha != 255)
 270         {
 271           temp = SDL_CreateRGBSurface(screen->flags, rect.w, rect.h, screen->format->BitsPerPixel,
 272                                       screen->format->Rmask,
 273                                       screen->format->Gmask,
 274                                       screen->format->Bmask,
 275                                       screen->format->Amask);
 276
 277
 278           src.x = 0;
 279           src.y = 0;
 280           src.w = rect.w;
 281           src.h = rect.h;
 282
 283           SDL_FillRect(temp, &src, SDL_MapRGB(screen->format,
 284                 fillrectrequest->color.red, fillrectrequest->color.green,
 285                 fillrectrequest->color.blue));
 286
 287           SDL_SetAlpha(temp, SDL_SRCALPHA, fillrectrequest->color.alpha);
 288
 289           SDL_BlitSurface(temp,0,screen,&rect);
 290
 291           SDL_FreeSurface(temp);
 292         }
 293       else
 294         SDL_FillRect(screen, &rect, SDL_MapRGB(screen->format,
 295               fillrectrequest->color.red, fillrectrequest->color.green,
 296               fillrectrequest->color.blue));
 297
 298 #ifndef NOOPENGL
 299
 300     }
 301 #endif
 302
 303   delete fillrectrequest;
 304 }
 305
 306 void
 307 DrawingContext::do_drawing()
 308 {
 309   std::stable_sort(drawingrequests.begin(), drawingrequests.end());
 310
 311   for(DrawingRequests::iterator i = drawingrequests.begin();
 312       i != drawingrequests.end(); ++i) {
 313     switch(i->type) {
 314       case SURFACE:
 315       {
 316         const Surface* surface = (const Surface*) i->request_data;
 317
 318         if(i->zoom != 1.0)
 319           surface->impl->draw_stretched(i->pos.x * i->zoom, i->pos.y * i->zoom,
 320                          (int)(surface->w * i->zoom), (int)(surface->h * i->zoom),
 321                          i->alpha, i->drawing_effect);
 322         else
 323           surface->impl->draw(i->pos.x, i->pos.y, i->alpha, i->drawing_effect);
 324         break;
 325       }
 326       case SURFACE_PART:
 327         draw_surface_part(*i);
 328         break;
 329       case GRADIENT:
 330         draw_gradient(*i);
 331         break;
 332       case TEXT:
 333         draw_text(*i);
 334         break;
 335       case FILLRECT:
 336         draw_filled_rect(*i);
 337         break;
 338     }
 339   }
 340
 341   // update screen
 342   if(use_gl)
 343     SDL_GL_SwapBuffers();
 344   else
 345     SDL_Flip(screen);
 346
 347   drawingrequests.clear();
 348 }
 349
 350 void
 351 DrawingContext::push_transform()
 352 {
 353   transformstack.push_back(transform);
 354 }
 355
 356 void
 357 DrawingContext::pop_transform()
 358 {
 359   assert(!transformstack.empty());
 360
 361   transform = transformstack.back();
 362   transformstack.pop_back();
 363 }
 364
 365 void
 366 DrawingContext::set_drawing_effect(int effect)
 367 {
 368   transform.drawing_effect = effect;
 369 }
 370
 371 void
 372 DrawingContext::set_zooming(float zoom)
 373 {
 374   transform.zoom = zoom;
 375 }
 376
 377 void
 378 DrawingContext::set_alpha(int alpha)
 379 {
 380   transform.alpha = alpha;
 381 }