graphics/nxsurface.cpp

   1
   2 #include <string.h>
   3 #include <stdint.h>
   4 #include "../settings.h"
   5 #include "../config.h"
   6 #include "graphics.h"
   7 #include "nxsurface.h"
   8 #include "nxsurface.fdh"
   9
  10 #ifdef CONFIG_MUTABLE_SCALE
  11         int SCALE = 3;
  12 #endif
  13
  14
  15 NXSurface::NXSurface()
  16 {
  17         fSurface = NULL;
  18         fFreeSurface = true;
  19 }
  20
  21
  22 NXSurface::NXSurface(int wd, int ht, NXFormat *format)
  23 {
  24         fSurface = NULL;
  25         AllocNew(wd, ht, format);
  26         fFreeSurface = true;
  27 }
  28
  29
  30 NXSurface::NXSurface(SDL_Surface *from_sfc, bool free_surface)
  31 {
  32         fSurface = from_sfc;
  33         fFreeSurface = free_surface;
  34 }
  35
  36 NXSurface::~NXSurface()
  37 {
  38         Free();
  39 }
  40
  41 // static function, and requires a reload of all surfaces
  42 void NXSurface::SetScale(int factor)
  43 {
  44         #ifdef CONFIG_MUTABLE_SCALE
  45                 SCALE = factor;
  46         #else
  47                 staterr("NXSurface::SetScale: CONFIG_MUTABLE_SCALE not set");
  48         #endif
  49 }
  50
  51 /*
  52 void c------------------------------() {}
  53 */
  54
  55 // allocate for an empty surface of the given size
  56 bool NXSurface::AllocNew(int wd, int ht, NXFormat *format)
  57 {
  58         Free();
  59
  60         fSurface = SDL_CreateRGBSurface(SDL_SRCCOLORKEY, wd*SCALE, ht*SCALE, \
  61                         format->BitsPerPixel, format->Rmask, format->Gmask, format->Bmask, format->Amask);
  62
  63         if (!fSurface)
  64         {
  65                 staterr("NXSurface::AllocNew: failed to allocate RGB surface");
  66                 return 1;
  67         }
  68
  69         return fSurface;
  70 }
  71
  72
  73 // load the surface from a .pbm or bitmap file
  74 bool NXSurface::LoadImage(const char *pbm_name, bool use_colorkey, int use_display_format)
  75 {
  76 SDL_Surface *image;
  77
  78         Free();
  79
  80         if (use_display_format == -1)
  81         {       // use value specified in settings
  82                 use_display_format = settings->displayformat;
  83         }
  84
  85         image = SDL_LoadBMP(pbm_name);
  86         if (!image)
  87         {
  88                 staterr("NXSurface::LoadImage: load failed of '%s'!", pbm_name);
  89                 return 1;
  90         }
  91
  92         fSurface = Scale(image, SCALE, use_colorkey, true, use_display_format);
  93         return (fSurface == NULL);
  94 }
  95
  96
  97 NXSurface *NXSurface::FromFile(const char *pbm_name, bool use_colorkey, int use_display_format)
  98 {
  99         NXSurface *sfc = new NXSurface;
 100         if (sfc->LoadImage(pbm_name, use_colorkey, use_display_format))
 101         {
 102                 delete sfc;
 103                 return NULL;
 104         }
 105
 106         return sfc;
 107 }
 108
 109
 110 /*
 111 void c------------------------------() {}
 112 */
 113
 114 // draw some or all of another surface onto this surface.
 115 void NXSurface::DrawSurface(NXSurface *src, \
 116                                                         int dstx, int dsty, int srcx, int srcy, int wd, int ht)
 117 {
 118 SDL_Rect srcrect, dstrect;
 119
 120         srcrect.x = srcx * SCALE;
 121         srcrect.y = srcy * SCALE;
 122         srcrect.w = wd * SCALE;
 123         srcrect.h = ht * SCALE;
 124
 125         dstrect.x = dstx * SCALE;
 126         dstrect.y = dsty * SCALE;
 127
 128         SDL_BlitSurface(src->fSurface, &srcrect, fSurface, &dstrect);
 129 }
 130
 131 void NXSurface::DrawSurface(NXSurface *src, int dstx, int dsty)
 132 {
 133         DrawSurface(src, dstx, dsty, 0, 0, src->Width(), src->Height());
 134 }
 135
 136 // draw the given source surface in a repeating pattern across the entire width of the surface.
 137 // x_dst: an starting X with which to offset the pattern horizontally (usually negative).
 138 // y_dst: the Y coordinate to copy to on the destination.
 139 // y_src: the Y coordinate to copy from.
 140 // height: the number of pixels tall to copy.
 141 void NXSurface::BlitPatternAcross(NXSurface *src,
 142                                                    int x_dst, int y_dst, int y_src, int height)
 143 {
 144 SDL_Rect srcrect, dstrect;
 145
 146         srcrect.x = 0;
 147         srcrect.w = src->fSurface->w;
 148         srcrect.y = (y_src * SCALE);
 149         srcrect.h = (height * SCALE);
 150
 151         int x = (x_dst * SCALE);
 152         int y = (y_dst * SCALE);
 153         int destwd = fSurface->w;
 154
 155         do
 156         {
 157                 dstrect.x = x;
 158                 dstrect.y = y;
 159
 160                 SDL_BlitSurface(src->fSurface, &srcrect, fSurface, &dstrect);
 161                 x += src->fSurface->w;
 162         }
 163         while(x < destwd);
 164 }
 165
 166
 167 /*
 168 void c------------------------------() {}
 169 */
 170
 171
 172 void NXSurface::DrawRect(int x1, int y1, int x2, int y2, uint8_t r, uint8_t g, uint8_t b)
 173 {
 174 SDL_Rect rect;
 175 uint32_t color = MapColor(r, g, b);
 176
 177         // top and bottom
 178         rect.x = x1 * SCALE;
 179         rect.y = y1 * SCALE;
 180         rect.w = ((x2 - x1) + 1) * SCALE;
 181         rect.h = SCALE;
 182         SDL_FillRect(fSurface, &rect, color);
 183
 184         rect.y = y2 * SCALE;
 185         SDL_FillRect(fSurface, &rect, color);
 186
 187         // left and right
 188         rect.y = y1 * SCALE;
 189         rect.w = SCALE;
 190         rect.h = ((y2 - y1) + 1) * SCALE;
 191         SDL_FillRect(fSurface, &rect, color);
 192
 193         rect.x = x2 * SCALE;
 194         SDL_FillRect(fSurface, &rect, color);
 195 }
 196
 197
 198 void NXSurface::FillRect(int x1, int y1, int x2, int y2, uint8_t r, uint8_t g, uint8_t b)
 199 {
 200 SDL_Rect rect;
 201
 202         rect.x = x1 * SCALE;
 203         rect.y = y1 * SCALE;
 204         rect.w = ((x2 - x1) + 1) * SCALE;
 205         rect.h = ((y2 - y1) + 1) * SCALE;
 206
 207         SDL_FillRect(fSurface, &rect, MapColor(r, g, b));
 208 }
 209
 210 void NXSurface::Clear(uint8_t r, uint8_t g, uint8_t b)
 211 {
 212         SDL_FillRect(fSurface, NULL, MapColor(r, g, b));
 213 }
 214
 215
 216 void NXSurface::DrawPixel(int x, int y, uint8_t r, uint8_t g, uint8_t b)
 217 {
 218         DrawRect(x, y, x, y, r, g, b);
 219 }
 220
 221 /*
 222 void c------------------------------() {}
 223 */
 224
 225 int NXSurface::Width()
 226 {
 227         return fSurface->w / SCALE;
 228 }
 229
 230 int NXSurface::Height()
 231 {
 232         return fSurface->h / SCALE;
 233 }
 234
 235 NXFormat *NXSurface::Format()
 236 {
 237         return fSurface->format;
 238 }
 239
 240 void NXSurface::Flip()
 241 {
 242         SDL_Flip(fSurface);
 243 }
 244
 245 /*
 246 void c------------------------------() {}
 247 */
 248
 249 void NXSurface::set_clip_rect(int x, int y, int w, int h)
 250 {
 251         NXRect rect(x * SCALE, y * SCALE, w * SCALE, h * SCALE);
 252         SDL_SetClipRect(fSurface, &rect);
 253 }
 254
 255 void NXSurface::set_clip_rect(NXRect *rect)
 256 {
 257         SDL_SetClipRect(fSurface, rect);
 258 }
 259
 260 void NXSurface::clear_clip_rect()
 261 {
 262         SDL_SetClipRect(fSurface, NULL);
 263 }
 264
 265 /*
 266 void c------------------------------() {}
 267 */
 268
 269 // internal function which scales the given SDL surface by the given factor.
 270 SDL_Surface *NXSurface::Scale(SDL_Surface *original, int factor, \
 271                 bool use_colorkey, bool free_original, bool use_display_format)
 272 {
 273 SDL_Surface *scaled;
 274
 275         if (factor == 1 && free_original)
 276         {
 277                 scaled = original;
 278         }
 279         else
 280         {
 281                 scaled = SDL_CreateRGBSurface(SDL_SRCCOLORKEY, \
 282                                                 original->w * SCALE, \
 283                                                 original->h * SCALE, \
 284                                                 original->format->BitsPerPixel, \
 285                                                 original->format->Rmask, original->format->Gmask,
 286                                                 original->format->Bmask, original->format->Amask);
 287
 288                 if (original->format->BitsPerPixel == 8)
 289                 {       // copy the palette from the old surface to the new surface
 290                         SDL_Color palette[256];
 291                         for(int i=0;i<256;i++)
 292                         {
 293                                 SDL_GetRGB(i, original->format, &palette[i].r, &palette[i].g, &palette[i].b);
 294                         }
 295
 296                         SDL_SetColors(scaled, palette, 0, 256);
 297                 }
 298
 299                 // all the .pbm files are 8bpp, so I haven't had a reason
 300                 // to write any other scalers.
 301                 switch(original->format->BitsPerPixel)
 302                 {
 303                         case 8:
 304                                 Scale8(original, scaled, factor);
 305                         break;
 306
 307                         default:
 308                                 staterr("NXSurface::Scale: unsupported bpp %d", original->format->BitsPerPixel);
 309                                 SDL_FreeSurface(scaled);
 310                         return NULL;
 311                 }
 312
 313                 // can get rid of original now if they wanted us to
 314                 if (free_original)
 315                         SDL_FreeSurface(original);
 316         }
 317
 318         // set colorkey to black if requested
 319         if (use_colorkey)
 320         {       // don't use SDL_RLEACCEL--it seems to actually make things a lot slower,
 321                 // especially on maps with motion tiles.
 322                 SDL_SetColorKey(scaled, SDL_SRCCOLORKEY, SDL_MapRGB(scaled->format, 0, 0, 0));
 323         }
 324
 325         if (use_palette)
 326         {
 327                 scaled = palette_add(scaled);
 328                 if (!scaled)
 329                         return NULL;
 330         }
 331
 332         if (use_display_format)
 333         {
 334                 SDL_Surface *ret_sfc = SDL_DisplayFormat(scaled);
 335                 SDL_FreeSurface(scaled);
 336
 337                 return ret_sfc;
 338         }
 339         else
 340         {
 341                 return scaled;
 342         }
 343 }
 344
 345 void NXSurface::Scale8(SDL_Surface *src, SDL_Surface *dst, int factor)
 346 {
 347 int x, y, i;
 348
 349         for(y=0;y<src->h;y++)
 350         {
 351                 uint8_t *srcline = (uint8_t *)src->pixels + (y * src->pitch);
 352                 uint8_t *dstline = (uint8_t *)dst->pixels + (y * factor * dst->pitch);
 353                 uint8_t *dstptr = dstline;
 354
 355                 for(x=0;x<src->w;x++)
 356                 {
 357                         for(i=0;i<factor;i++)
 358                                 *(dstptr++) = srcline[x];
 359                 }
 360
 361                 dstptr = dstline;
 362                 for(i=1;i<factor;i++)
 363                 {
 364                         dstptr += dst->pitch;
 365                         memcpy(dstptr, dstline, dst->pitch);
 366                 }
 367         }
 368 }
 369
 370 /*
 371 void c------------------------------() {}
 372 */
 373
 374 void NXSurface::EnableColorKey()
 375 {
 376         SDL_SetColorKey(fSurface, SDL_SRCCOLORKEY, SDL_MapRGB(fSurface->format, 0, 0, 0));
 377 }
 378
 379 uint32_t NXSurface::MapColor(uint8_t r, uint8_t g, uint8_t b)
 380 {
 381         return SDL_MapRGB(fSurface->format, r, g, b);
 382 }
 383
 384
 385 void NXSurface::Free()
 386 {
 387         if (fSurface)
 388         {
 389                 if (fFreeSurface)
 390                         SDL_FreeSurface(fSurface);
 391
 392                 fSurface = NULL;
 393         }
 394 }
 395
 396
 397