image.c

   1
   2 #include "quakedef.h"
   3
   4 int             image_width;
   5 int             image_height;
   6
   7 // note: pal must be 32bit color
   8 void Image_Copy8bitRGBA(byte *in, byte *out, int pixels, int *pal)
   9 {
  10         int *iout = (void *)out;
  11         while (pixels >= 8)
  12         {
  13                 iout[0] = pal[in[0]];
  14                 iout[1] = pal[in[1]];
  15                 iout[2] = pal[in[2]];
  16                 iout[3] = pal[in[3]];
  17                 iout[4] = pal[in[4]];
  18                 iout[5] = pal[in[5]];
  19                 iout[6] = pal[in[6]];
  20                 iout[7] = pal[in[7]];
  21                 in += 8;
  22                 iout += 8;
  23                 pixels -= 8;
  24         }
  25         if (pixels & 4)
  26         {
  27                 iout[0] = pal[in[0]];
  28                 iout[1] = pal[in[1]];
  29                 iout[2] = pal[in[2]];
  30                 iout[3] = pal[in[3]];
  31                 in += 4;
  32                 iout += 4;
  33         }
  34         if (pixels & 2)
  35         {
  36                 iout[0] = pal[in[0]];
  37                 iout[1] = pal[in[1]];
  38                 in += 2;
  39                 iout += 2;
  40         }
  41         if (pixels & 1)
  42                 iout[0] = pal[in[0]];
  43 }
  44
  45 void Image_CopyRGBAGamma(byte *in, byte *out, int pixels)
  46 {
  47         while (pixels--)
  48         {
  49                 out[0] = texgamma[in[0]];
  50                 out[1] = texgamma[in[1]];
  51                 out[2] = texgamma[in[2]];
  52                 out[3] =          in[3] ;
  53                 in += 4;
  54                 out += 4;
  55         }
  56 }
  57
  58
  59 /*
  60 =================================================================
  61
  62   PCX Loading
  63
  64 =================================================================
  65 */
  66
  67 typedef struct
  68 {
  69     char        manufacturer;
  70     char        version;
  71     char        encoding;
  72     char        bits_per_pixel;
  73     unsigned short      xmin,ymin,xmax,ymax;
  74     unsigned short      hres,vres;
  75     unsigned char       palette[48];
  76     char        reserved;
  77     char        color_planes;
  78     unsigned short      bytes_per_line;
  79     unsigned short      palette_type;
  80     char        filler[58];
  81 } pcx_t;
  82
  83 /*
  84 ============
  85 LoadPCX
  86 ============
  87 */
  88 byte* LoadPCX (byte *f, int matchwidth, int matchheight)
  89 {
  90         pcx_t   pcx;
  91         byte    *palette, *a, *b, *image_rgba, *fin, *pbuf;
  92         int             x, y, dataByte, runLength;
  93
  94         fin = f;
  95
  96         memcpy(&pcx, fin, sizeof(pcx));
  97         fin += sizeof(pcx);
  98
  99         // LordHavoc: big-endian support ported from QF newtree
 100         pcx.xmax = LittleShort (pcx.xmax);
 101         pcx.xmin = LittleShort (pcx.xmin);
 102         pcx.ymax = LittleShort (pcx.ymax);
 103         pcx.ymin = LittleShort (pcx.ymin);
 104         pcx.hres = LittleShort (pcx.hres);
 105         pcx.vres = LittleShort (pcx.vres);
 106         pcx.bytes_per_line = LittleShort (pcx.bytes_per_line);
 107         pcx.palette_type = LittleShort (pcx.palette_type);
 108
 109         if (pcx.manufacturer != 0x0a || pcx.version != 5 || pcx.encoding != 1 || pcx.bits_per_pixel != 8 || pcx.xmax > 320 || pcx.ymax > 256)
 110         {
 111                 Con_Printf ("Bad pcx file\n");
 112                 qfree(f);
 113                 return NULL;
 114         }
 115
 116         if (matchwidth && (pcx.xmax+1) != matchwidth)
 117         {
 118                 qfree(f);
 119                 return NULL;
 120         }
 121         if (matchheight && (pcx.ymax+1) != matchheight)
 122         {
 123                 qfree(f);
 124                 return NULL;
 125         }
 126
 127         image_width = pcx.xmax+1;
 128         image_height = pcx.ymax+1;
 129
 130         image_rgba = qmalloc(image_width*image_height*4);
 131         pbuf = image_rgba + image_width*image_height*3;
 132
 133         for (y = 0;y < image_height;y++)
 134         {
 135                 a = pbuf + y * image_width;
 136                 for (x = 0;x < image_width;)
 137                 {
 138                         dataByte = *fin++;
 139                         if(dataByte >= 0xC0)
 140                         {
 141                                 runLength = dataByte & 0x3F;
 142                                 dataByte = *fin++;
 143                                 if (runLength)
 144                                 {
 145                                         x += runLength;
 146                                         while(runLength--)
 147                                                 *a++ = dataByte;
 148                                 }
 149                         }
 150                         else
 151                         {
 152                                 x++;
 153                                 *a++ = dataByte;
 154                         }
 155                 }
 156         }
 157
 158         palette = fin;
 159         a = image_rgba;
 160         b = pbuf;
 161
 162         for(x = 0;x < image_width*image_height;x++)
 163         {
 164                 y = *b++ * 3;
 165                 *a++ = palette[y];
 166                 *a++ = palette[y+1];
 167                 *a++ = palette[y+2];
 168                 *a++ = 255;
 169         }
 170
 171         qfree(f);
 172         return image_rgba;
 173 }
 174
 175 /*
 176 =========================================================
 177
 178 TARGA LOADING
 179
 180 =========================================================
 181 */
 182
 183 typedef struct _TargaHeader
 184 {
 185         unsigned char   id_length, colormap_type, image_type;
 186         unsigned short  colormap_index, colormap_length;
 187         unsigned char   colormap_size;
 188         unsigned short  x_origin, y_origin, width, height;
 189         unsigned char   pixel_size, attributes;
 190 }
 191 TargaHeader;
 192
 193 TargaHeader             targa_header;
 194
 195
 196 /*
 197 =============
 198 LoadTGA
 199 =============
 200 */
 201 byte* LoadTGA (byte *f, int matchwidth, int matchheight)
 202 {
 203         int columns, rows, numPixels, row, column;
 204         byte *pixbuf, *image_rgba, *fin;
 205
 206         targa_header.id_length = f[0];
 207         targa_header.colormap_type = f[1];
 208         targa_header.image_type = f[2];
 209
 210         targa_header.colormap_index = f[3] + f[4] * 256;
 211         targa_header.colormap_length = f[5] + f[6] * 256;
 212         targa_header.colormap_size = f[7];
 213         targa_header.x_origin = f[8] + f[9] * 256;
 214         targa_header.y_origin = f[10] + f[11] * 256;
 215         targa_header.width = f[12] + f[13] * 256;
 216         targa_header.height = f[14] + f[15] * 256;
 217         if (matchwidth && targa_header.width != matchwidth)
 218                 return NULL;
 219         if (matchheight && targa_header.height != matchheight)
 220                 return NULL;
 221         targa_header.pixel_size = f[16];
 222         targa_header.attributes = f[17];
 223
 224         if (targa_header.image_type != 2 && targa_header.image_type != 10)
 225                 Host_Error ("LoadTGA: Only type 2 and 10 targa RGB images supported\n");
 226
 227         if (targa_header.colormap_type != 0     || (targa_header.pixel_size != 32 && targa_header.pixel_size != 24))
 228                 Host_Error ("LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n");
 229
 230         columns = targa_header.width;
 231         rows = targa_header.height;
 232         numPixels = columns * rows;
 233
 234         image_rgba = qmalloc(numPixels*4);
 235
 236         fin = f + 18;
 237         if (targa_header.id_length != 0)
 238                 fin += targa_header.id_length;  // skip TARGA image comment
 239
 240         if (targa_header.image_type == 2)
 241         {
 242                 // Uncompressed, RGB images
 243                 for(row = rows - 1;row >= 0;row--)
 244                 {
 245                         pixbuf = image_rgba + row*columns*4;
 246                         for(column = 0;column < columns;column++)
 247                         {
 248                                 switch (targa_header.pixel_size)
 249                                 {
 250                                 case 24:
 251                                         *pixbuf++ = fin[2];
 252                                         *pixbuf++ = fin[1];
 253                                         *pixbuf++ = fin[0];
 254                                         *pixbuf++ = 255;
 255                                         fin += 3;
 256                                         break;
 257                                 case 32:
 258                                         *pixbuf++ = fin[2];
 259                                         *pixbuf++ = fin[1];
 260                                         *pixbuf++ = fin[0];
 261                                         *pixbuf++ = fin[3];
 262                                         fin += 4;
 263                                         break;
 264                                 }
 265                         }
 266                 }
 267         }
 268         else if (targa_header.image_type==10)
 269         {
 270                 // Runlength encoded RGB images
 271                 unsigned char red = 0, green = 0, blue = 0, alphabyte = 0, packetHeader, packetSize, j;
 272                 for(row = rows - 1;row >= 0;row--)
 273                 {
 274                         pixbuf = image_rgba + row * columns * 4;
 275                         for(column = 0;column < columns;)
 276                         {
 277                                 packetHeader = *fin++;
 278                                 packetSize = 1 + (packetHeader & 0x7f);
 279                                 if (packetHeader & 0x80)
 280                                 {
 281                                         // run-length packet
 282                                         switch (targa_header.pixel_size)
 283                                         {
 284                                         case 24:
 285                                                 blue = *fin++;
 286                                                 green = *fin++;
 287                                                 red = *fin++;
 288                                                 alphabyte = 255;
 289                                                 break;
 290                                         case 32:
 291                                                 blue = *fin++;
 292                                                 green = *fin++;
 293                                                 red = *fin++;
 294                                                 alphabyte = *fin++;
 295                                                 break;
 296                                         }
 297
 298                                         for(j = 0;j < packetSize;j++)
 299                                         {
 300                                                 *pixbuf++ = red;
 301                                                 *pixbuf++ = green;
 302                                                 *pixbuf++ = blue;
 303                                                 *pixbuf++ = alphabyte;
 304                                                 column++;
 305                                                 if (column == columns)
 306                                                 {
 307                                                         // run spans across rows
 308                                                         column = 0;
 309                                                         if (row > 0)
 310                                                                 row--;
 311                                                         else
 312                                                                 goto breakOut;
 313                                                         pixbuf = image_rgba + row * columns * 4;
 314                                                 }
 315                                         }
 316                                 }
 317                                 else
 318                                 {
 319                                         // non run-length packet
 320                                         for(j = 0;j < packetSize;j++)
 321                                         {
 322                                                 switch (targa_header.pixel_size)
 323                                                 {
 324                                                 case 24:
 325                                                         *pixbuf++ = fin[2];
 326                                                         *pixbuf++ = fin[1];
 327                                                         *pixbuf++ = fin[0];
 328                                                         *pixbuf++ = 255;
 329                                                         fin += 3;
 330                                                         break;
 331                                                 case 32:
 332                                                         *pixbuf++ = fin[2];
 333                                                         *pixbuf++ = fin[1];
 334                                                         *pixbuf++ = fin[0];
 335                                                         *pixbuf++ = fin[3];
 336                                                         fin += 4;
 337                                                         break;
 338                                                 }
 339                                                 column++;
 340                                                 if (column == columns)
 341                                                 {
 342                                                         // pixel packet run spans across rows
 343                                                         column = 0;
 344                                                         if (row > 0)
 345                                                                 row--;
 346                                                         else
 347                                                                 goto breakOut;
 348                                                         pixbuf = image_rgba + row * columns * 4;
 349                                                 }
 350                                         }
 351                                 }
 352                         }
 353                         breakOut:;
 354                 }
 355         }
 356
 357         image_width = columns;
 358         image_height = rows;
 359         free(f);
 360         return image_rgba;
 361 }
 362
 363 /*
 364 ============
 365 LoadLMP
 366 ============
 367 */
 368 byte* LoadLMP (byte *f, int matchwidth, int matchheight)
 369 {
 370         byte    *image_rgba;
 371         int             width, height;
 372
 373         // parse the very complicated header *chuckle*
 374         width = LittleLong(((int *)f)[0]);
 375         height = LittleLong(((int *)f)[1]);
 376         if ((unsigned) width > 4096 || (unsigned) height > 4096)
 377         {
 378                 qfree(f);
 379                 Host_Error("LoadLMP: invalid size\n");
 380         }
 381         if (matchwidth && width != matchwidth)
 382         {
 383                 qfree(f);
 384                 return NULL;
 385         }
 386         if (matchheight && height != matchheight)
 387         {
 388                 qfree(f);
 389                 return NULL;
 390         }
 391
 392         image_rgba = qmalloc(width*height*4);
 393         Image_Copy8bitRGBA(f + 8, image_rgba, width*height, d_8to24table);
 394         image_width = width;
 395         image_height = height;
 396         qfree(f);
 397         return image_rgba;
 398 }
 399
 400 void Image_StripImageExtension (char *in, char *out)
 401 {
 402         char *end, *temp;
 403         end = in + strlen(in);
 404         if ((end - in) >= 4)
 405         {
 406                 temp = end - 4;
 407                 if (strcmp(temp, ".tga") == 0 || strcmp(temp, ".pcx") == 0 || strcmp(temp, ".lmp") == 0)
 408                         end = temp;
 409                 while (in < end)
 410                         *out++ = *in++;
 411                 *out++ = 0;
 412         }
 413         else
 414                 strcpy(out, in);
 415 }
 416
 417 byte* loadimagepixels (char* filename, qboolean complain, int matchwidth, int matchheight)
 418 {
 419         byte    *f;
 420         char    basename[256], name[256];
 421         byte    *c;
 422         Image_StripImageExtension(filename, basename); // strip .tga, .pcx and .lmp extensions to allow replacement by other types
 423         // replace *'s with #, so commandline utils don't get confused when dealing with the external files
 424         for (c = basename;*c;c++)
 425                 if (*c == '*')
 426                         *c = '#';
 427         sprintf (name, "textures/%s.tga", basename);
 428         f = COM_LoadMallocFile(name, true);
 429         if (f)
 430                 return LoadTGA (f, matchwidth, matchheight);
 431         sprintf (name, "textures/%s.pcx", basename);
 432         f = COM_LoadMallocFile(name, true);
 433         if (f)
 434                 return LoadPCX (f, matchwidth, matchheight);
 435         sprintf (name, "%s.tga", basename);
 436         f = COM_LoadMallocFile(name, true);
 437         if (f)
 438                 return LoadTGA (f, matchwidth, matchheight);
 439         sprintf (name, "%s.pcx", basename);
 440         f = COM_LoadMallocFile(name, true);
 441         if (f)
 442                 return LoadPCX (f, matchwidth, matchheight);
 443         sprintf (name, "%s.lmp", basename);
 444         f = COM_LoadMallocFile(name, true);
 445         if (f)
 446                 return LoadLMP (f, matchwidth, matchheight);
 447         if (complain)
 448                 Con_Printf ("Couldn't load %s.tga, .pcx, .lmp\n", filename);
 449         return NULL;
 450 }
 451
 452 int image_makemask (byte *in, byte *out, int size)
 453 {
 454         int             i, count;
 455         count = 0;
 456         for (i = 0;i < size;i++)
 457         {
 458                 out[0] = out[1] = out[2] = 255;
 459                 out[3] = in[3];
 460                 if (in[3] != 255)
 461                         count++;
 462                 in += 4;
 463                 out += 4;
 464         }
 465         return count;
 466 }
 467
 468 byte* loadimagepixelsmask (char* filename, qboolean complain, int matchwidth, int matchheight)
 469 {
 470         byte    *in, *data;
 471         in = data = loadimagepixels(filename, complain, matchwidth, matchheight);
 472         if (!data)
 473                 return NULL;
 474         if (image_makemask(data, data, image_width * image_height))
 475                 return data; // some transparency
 476         else
 477         {
 478                 qfree(data);
 479                 return NULL; // all opaque
 480         }
 481 }
 482
 483 rtexture_t *loadtextureimage (char* filename, int matchwidth, int matchheight, qboolean complain, qboolean mipmap, qboolean precache)
 484 {
 485         byte *data;
 486         rtexture_t *rt;
 487         if (!(data = loadimagepixels (filename, complain, matchwidth, matchheight)))
 488                 return 0;
 489         rt = R_LoadTexture (filename, image_width, image_height, data, TEXF_ALPHA | TEXF_RGBA | (mipmap ? TEXF_MIPMAP : 0) | (mipmap ? TEXF_PRECACHE : 0));
 490         qfree(data);
 491         return rt;
 492 }
 493
 494 rtexture_t *loadtextureimagemask (char* filename, int matchwidth, int matchheight, qboolean complain, qboolean mipmap, qboolean precache)
 495 {
 496         byte *data;
 497         rtexture_t *rt;
 498         if (!(data = loadimagepixelsmask (filename, complain, matchwidth, matchheight)))
 499                 return 0;
 500         rt = R_LoadTexture (filename, image_width, image_height, data, TEXF_ALPHA | TEXF_RGBA | (mipmap ? TEXF_MIPMAP : 0) | (mipmap ? TEXF_PRECACHE : 0));
 501         qfree(data);
 502         return rt;
 503 }
 504
 505 rtexture_t *image_masktex;
 506 rtexture_t *loadtextureimagewithmask (char* filename, int matchwidth, int matchheight, qboolean complain, qboolean mipmap, qboolean precache)
 507 {
 508         int count;
 509         byte *data;
 510         char *filename2;
 511         rtexture_t *rt;
 512         image_masktex = NULL;
 513         if (!(data = loadimagepixels (filename, complain, matchwidth, matchheight)))
 514                 return 0;
 515         rt = R_LoadTexture (filename, image_width, image_height, data, TEXF_ALPHA | TEXF_RGBA | (mipmap ? TEXF_MIPMAP : 0) | (mipmap ? TEXF_PRECACHE : 0));
 516         count = image_makemask(data, data, image_width * image_height);
 517         if (count)
 518         {
 519                 filename2 = qmalloc(strlen(filename) + 6);
 520                 sprintf(filename2, "%s_mask", filename);
 521                 image_masktex = R_LoadTexture (filename2, image_width, image_height, data, TEXF_ALPHA | TEXF_RGBA | (mipmap ? TEXF_MIPMAP : 0) | (mipmap ? TEXF_PRECACHE : 0));
 522                 qfree(filename2);
 523         }
 524         qfree(data);
 525         return rt;
 526 }
 527
 528 void Image_WriteTGARGB_preflipped (char *filename, int width, int height, byte *data)
 529 {
 530         byte *buffer, *in, *out, *end;
 531
 532         buffer = qmalloc(width*height*3 + 18);
 533
 534         memset (buffer, 0, 18);
 535         buffer[2] = 2;          // uncompressed type
 536         buffer[12] = (width >> 0) & 0xFF;
 537         buffer[13] = (width >> 8) & 0xFF;
 538         buffer[14] = (height >> 0) & 0xFF;
 539         buffer[15] = (height >> 8) & 0xFF;
 540         buffer[16] = 24;        // pixel size
 541
 542         // swap rgb to bgr
 543         in = data;
 544         out = buffer + 18;
 545         end = in + width*height*3;
 546         for (;in < end;in += 3)
 547         {
 548                 *out++ = in[2];
 549                 *out++ = in[1];
 550                 *out++ = in[0];
 551         }
 552         COM_WriteFile (filename, buffer, width*height*3 + 18 );
 553
 554         qfree(buffer);
 555 }
 556
 557 void Image_WriteTGARGB (char *filename, int width, int height, byte *data)
 558 {
 559         int y;
 560         byte *buffer, *in, *out, *end;
 561
 562         buffer = qmalloc(width*height*3 + 18);
 563
 564         memset (buffer, 0, 18);
 565         buffer[2] = 2;          // uncompressed type
 566         buffer[12] = (width >> 0) & 0xFF;
 567         buffer[13] = (width >> 8) & 0xFF;
 568         buffer[14] = (height >> 0) & 0xFF;
 569         buffer[15] = (height >> 8) & 0xFF;
 570         buffer[16] = 24;        // pixel size
 571
 572         // swap rgb to bgr and flip upside down
 573         out = buffer + 18;
 574         for (y = height - 1;y >= 0;y--)
 575         {
 576                 in = data + y * width * 3;
 577                 end = in + width * 3;
 578                 for (;in < end;in += 3)
 579                 {
 580                         *out++ = in[2];
 581                         *out++ = in[1];
 582                         *out++ = in[0];
 583                 }
 584         }
 585         COM_WriteFile (filename, buffer, width*height*3 + 18 );
 586
 587         qfree(buffer);
 588 }
 589
 590 void Image_WriteTGARGBA (char *filename, int width, int height, byte *data)
 591 {
 592         int y;
 593         byte *buffer, *in, *out, *end;
 594
 595         buffer = qmalloc(width*height*4 + 18);
 596
 597         memset (buffer, 0, 18);
 598         buffer[2] = 2;          // uncompressed type
 599         buffer[12] = (width >> 0) & 0xFF;
 600         buffer[13] = (width >> 8) & 0xFF;
 601         buffer[14] = (height >> 0) & 0xFF;
 602         buffer[15] = (height >> 8) & 0xFF;
 603         buffer[16] = 32;        // pixel size
 604
 605         // swap rgba to bgra and flip upside down
 606         out = buffer + 18;
 607         for (y = height - 1;y >= 0;y--)
 608         {
 609                 in = data + y * width * 4;
 610                 end = in + width * 4;
 611                 for (;in < end;in += 4)
 612                 {
 613                         *out++ = in[2];
 614                         *out++ = in[1];
 615                         *out++ = in[0];
 616                         *out++ = in[3];
 617                 }
 618         }
 619         COM_WriteFile (filename, buffer, width*height*4 + 18 );
 620
 621         qfree(buffer);
 622 }
 623
 624 qboolean Image_CheckAlpha(byte *data, int size, qboolean rgba)
 625 {
 626         byte *end;
 627         if (rgba)
 628         {
 629                 // check alpha bytes
 630                 for (end = data + size * 4, data += 3;data < end;data += 4)
 631                         if (*data < 255)
 632                                 return 1;
 633         }
 634         else
 635         {
 636                 // color 255 is transparent
 637                 for (end = data + size;data < end;data++)
 638                         if (*data == 255)
 639                                 return 1;
 640         }
 641         return 0;
 642 }