lib/video/screen.cpp

   1 //  $Id$
   2 //
   3 //  SuperTux -  A Jump'n Run
   4 //  Copyright (C) 2000 Bill Kendrick <bill@newbreedsoftware.com>
   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
  20 #include <config.h>
  21
  22 #include <iostream>
  23 #include <cstdio>
  24 #include <cstdlib>
  25 #include <cstring>
  26 #include <cerrno>
  27
  28 #include <unistd.h>
  29
  30 #include "SDL.h"
  31 #include "SDL_image.h"
  32
  33 #ifndef WIN32
  34 #include <sys/types.h>
  35 #include <ctype.h>
  36 #endif
  37
  38 #include "screen.h"
  39 #include "app/globals.h"
  40 #include "video/drawing_context.h"
  41 #include "math/vector.h"
  42
  43 using namespace SuperTux;
  44
  45 /* 'Stolen' from the SDL documentation.
  46  * Return the pixel value at (x, y)
  47  * NOTE: The surface must be locked before calling this!
  48  */
  49 Uint32 SuperTux::getpixel(SDL_Surface *surface, int x, int y)
  50 {
  51     int bpp = surface->format->BytesPerPixel;
  52     /* Here p is the address to the pixel we want to retrieve */
  53     Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
  54
  55     switch(bpp) {
  56     case 1:
  57         return *p;
  58
  59     case 2:
  60         return *(Uint16 *)p;
  61
  62     case 3:
  63         if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
  64             return p[0] << 16 | p[1] << 8 | p[2];
  65         else
  66             return p[0] | p[1] << 8 | p[2] << 16;
  67
  68     case 4:
  69         return *(Uint32 *)p;
  70
  71     default:
  72         return 0;       /* shouldn't happen, but avoids warnings */
  73     }
  74 }
  75
  76 /* 'Stolen' from the SDL documentation.
  77  * Set the pixel at (x, y) to the given value
  78  * NOTE: The surface must be locked before calling this!
  79  */
  80 void SuperTux::putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
  81 {
  82   int bpp = surface->format->BytesPerPixel;
  83   /* Here p is the address to the pixel we want to set */
  84   Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
  85
  86   switch(bpp)
  87     {
  88     case 1:
  89       *p = pixel;
  90       break;
  91
  92     case 2:
  93       *(Uint16 *)p = pixel;
  94       break;
  95
  96     case 3:
  97       if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
  98         {
  99           p[0] = (pixel >> 16) & 0xff;
 100           p[1] = (pixel >> 8) & 0xff;
 101           p[2] = pixel & 0xff;
 102         }
 103       else
 104         {
 105           p[0] = pixel & 0xff;
 106           p[1] = (pixel >> 8) & 0xff;
 107           p[2] = (pixel >> 16) & 0xff;
 108         }
 109       break;
 110
 111     case 4:
 112       *(Uint32 *)p = pixel;
 113       break;
 114     }
 115 }
 116
 117 /* Draw a single pixel on the screen. */
 118 void SuperTux::drawpixel(int x, int y, Uint32 pixel)
 119 {
 120   /* Lock the screen for direct access to the pixels */
 121   if ( SDL_MUSTLOCK(screen) )
 122     {
 123       if ( SDL_LockSurface(screen) < 0 )
 124         {
 125           fprintf(stderr, "Can't lock screen: %s\n", SDL_GetError());
 126           return;
 127         }
 128     }
 129
 130   if(!(x < 0 || y < 0 || x > SCREEN_WIDTH || y > SCREEN_HEIGHT))
 131     putpixel(screen, x, y, pixel);
 132
 133   if ( SDL_MUSTLOCK(screen) )
 134     {
 135       SDL_UnlockSurface(screen);
 136     }
 137   /* Update just the part of the display that we've changed */
 138   SDL_UpdateRect(screen, x, y, 1, 1);
 139 }
 140
 141 /* --- FILL A RECT --- */
 142
 143 void SuperTux::fillrect(float x, float y, float w, float h, int r, int g, int b, int a)
 144 {
 145 if(w < 0)
 146         {
 147         x += w;
 148         w = -w;
 149         }
 150 if(h < 0)
 151         {
 152         y += h;
 153         h = -h;
 154         }
 155
 156 #ifndef NOOPENGL
 157   if(use_gl)
 158     {
 159       glEnable(GL_BLEND);
 160       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 161       glColor4ub(r, g, b,a);
 162
 163       glBegin(GL_POLYGON);
 164       glVertex2f(x, y);
 165       glVertex2f(x+w, y);
 166       glVertex2f(x+w, y+h);
 167       glVertex2f(x, y+h);
 168       glEnd();
 169       glDisable(GL_BLEND);
 170     }
 171   else
 172     {
 173 #endif
 174       SDL_Rect src, rect;
 175       SDL_Surface *temp = NULL;
 176
 177       rect.x = (int)x;
 178       rect.y = (int)y;
 179       rect.w = (int)w;
 180       rect.h = (int)h;
 181
 182       if(a != 255)
 183         {
 184           temp = SDL_CreateRGBSurface(screen->flags, rect.w, rect.h, screen->format->BitsPerPixel,
 185                                       screen->format->Rmask,
 186                                       screen->format->Gmask,
 187                                       screen->format->Bmask,
 188                                       screen->format->Amask);
 189
 190
 191           src.x = 0;
 192           src.y = 0;
 193           src.w = rect.w;
 194           src.h = rect.h;
 195
 196           SDL_FillRect(temp, &src, SDL_MapRGB(screen->format, r, g, b));
 197
 198           SDL_SetAlpha(temp, SDL_SRCALPHA, a);
 199
 200           SDL_BlitSurface(temp,0,screen,&rect);
 201
 202           SDL_FreeSurface(temp);
 203         }
 204       else
 205         SDL_FillRect(screen, &rect, SDL_MapRGB(screen->format, r, g, b));
 206
 207 #ifndef NOOPENGL
 208
 209     }
 210 #endif
 211 }
 212
 213 /* Needed for line calculations */
 214 #define SGN(x) ((x)>0 ? 1 : ((x)==0 ? 0:(-1)))
 215 #define ABS(x) ((x)>0 ? (x) : (-x))
 216
 217 void SuperTux::draw_line(float x1, float y1, float x2, float y2, int r, int g, int b, int a)
 218 {
 219 #ifndef NOOPENGL
 220   if(use_gl)
 221     {
 222       glEnable(GL_BLEND);
 223       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 224       glColor4ub(r, g, b,a);
 225
 226       glBegin(GL_LINES);
 227       glVertex2f(x1, y1);
 228       glVertex2f(x2, y2);
 229       glEnd();
 230       glDisable(GL_BLEND);
 231     }
 232   else
 233     {
 234 #endif
 235       /* Basic unantialiased Bresenham line algorithm */
 236       int lg_delta, sh_delta, cycle, lg_step, sh_step;
 237       Uint32 color = SDL_MapRGBA(screen->format, r, g, b, a);
 238
 239       lg_delta = (int)(x2 - x1);
 240       sh_delta = (int)(y2 - y1);
 241       lg_step = SGN(lg_delta);
 242       lg_delta = ABS(lg_delta);
 243       sh_step = SGN(sh_delta);
 244       sh_delta = ABS(sh_delta);
 245       if (sh_delta < lg_delta)
 246         {
 247           cycle = lg_delta >> 1;
 248           while (x1 != x2)
 249             {
 250               drawpixel((int)x1, (int)y1, color);
 251               cycle += sh_delta;
 252               if (cycle > lg_delta)
 253                 {
 254                   cycle -= lg_delta;
 255                   y1 += sh_step;
 256                 }
 257               x1 += lg_step;
 258             }
 259           drawpixel((int)x1, (int)y1, color);
 260         }
 261       cycle = sh_delta >> 1;
 262       while (y1 != y2)
 263         {
 264           drawpixel((int)x1, (int)y1, color);
 265           cycle += lg_delta;
 266           if (cycle > sh_delta)
 267             {
 268               cycle -= sh_delta;
 269               x1 += lg_step;
 270             }
 271           y1 += sh_step;
 272         }
 273       drawpixel((int)x1, (int)y1, color);
 274 #ifndef NOOPENGL
 275
 276     }
 277 #endif
 278 }
 279
 280 #define LOOP_DELAY 20.0
 281
 282 void SuperTux::fadeout(int fade_time)
 283 {
 284   float alpha_inc  = 256 / (fade_time / LOOP_DELAY);
 285   float alpha = 256;
 286
 287   while(alpha > 0)
 288     {
 289     alpha -= alpha_inc;
 290     fillrect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0,0,0, (int)alpha_inc);  // left side
 291
 292     DrawingContext context; // ugly...
 293     context.do_drawing();
 294
 295     SDL_Delay(int(LOOP_DELAY));
 296     }
 297
 298   fillrect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0, 255);
 299
 300 }
 301
 302 void SuperTux::shrink_fade(const Vector& point, int fade_time)
 303 {
 304   float left_inc  = point.x / ((float)fade_time / LOOP_DELAY);
 305   float right_inc = (SCREEN_WIDTH - point.x) / ((float)fade_time / LOOP_DELAY);
 306   float up_inc    = point.y / ((float)fade_time / LOOP_DELAY);
 307   float down_inc  = (SCREEN_HEIGHT - point.y) / ((float)fade_time / LOOP_DELAY);
 308
 309   float left_cor = 0, right_cor = 0, up_cor = 0, down_cor = 0;
 310
 311   while(left_cor < point.x && right_cor < SCREEN_WIDTH - point.x &&
 312       up_cor < point.y && down_cor < SCREEN_HEIGHT - point.y)
 313   {
 314     left_cor  += left_inc;
 315     right_cor += right_inc;
 316     up_cor    += up_inc;
 317     down_cor  += down_inc;
 318
 319     fillrect(0, 0, left_cor, SCREEN_HEIGHT, 0,0,0);  // left side
 320     fillrect(SCREEN_WIDTH - right_cor, 0, right_cor, SCREEN_HEIGHT, 0,0,0);  // right side
 321     fillrect(0, 0, SCREEN_WIDTH, up_cor, 0,0,0);  // up side
 322     fillrect(0, SCREEN_HEIGHT - down_cor, SCREEN_WIDTH, down_cor+1, 0,0,0);  // down side
 323     DrawingContext context; // ugly...
 324     context.do_drawing();
 325
 326     SDL_Delay(int(LOOP_DELAY));
 327   }
 328 }
 329