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