plugins/imagehl/lbmlib.cpp

   1 /*\r
   2 Copyright (C) 1999-2007 id Software, Inc. and contributors.\r
   3 For a list of contributors, see the accompanying CONTRIBUTORS file.\r
   4 \r
   5 This file is part of GtkRadiant.\r
   6 \r
   7 GtkRadiant is free software; you can redistribute it and/or modify\r
   8 it under the terms of the GNU General Public License as published by\r
   9 the Free Software Foundation; either version 2 of the License, or\r
  10 (at your option) any later version.\r
  11 \r
  12 GtkRadiant is distributed in the hope that it will be useful,\r
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  15 GNU General Public License for more details.\r
  16 \r
  17 You should have received a copy of the GNU General Public License\r
  18 along with GtkRadiant; if not, write to the Free Software\r
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\r
  20 */\r
  21 \r
  22 // lbmlib.c\r
  23 \r
  24 // by Hydra - hydra@hydras-world.com\r
  25 //\r
  26 // This module is based on the image module, but just more stripped down.\r
  27 // it still currently supports TGA file loading, even though this is not\r
  28 // required for HalfLife support (unless MD2 files use TGA's)\r
  29 //\r
  30 // use the #defines in imagehl.h to enable/disable the various formats.\r
  31 //\r
  32 // HLW = Half-Life-WAD, I don't know if the actual in data in the WAD files\r
  33 // has it's own name, so I'm just calling the individal textures .HLW files :)\r
  34 //\r
  35 // Thanks to the guys that made Wally for releasing an example WAD loader.\r
  36 // without it this would not have been possible.\r
  37 \r
  38 #include <stdlib.h>\r
  39 #include <string.h>\r
  40 #include <glib.h>\r
  41 #include "imagehl.h"\r
  42 #include "lbmlib.h"\r
  43 \r
  44 #include <stdio.h>\r
  45 \r
  46 #define Sys_Printf g_FuncTable.m_pfnSysPrintf\r
  47 #define Sys_FPrintf g_FuncTable.m_pfnSysFPrintf\r
  48 \r
  49 \r
  50 #ifdef USE_IDSP\r
  51 /*\r
  52 ============================================================================\r
  53 \r
  54 IDSP IMAGE (.spr files)\r
  55 \r
  56 Some code copied straight from the Q1 source, also used the HalfLife SDK as\r
  57 a reference.\r
  58 \r
  59 ============================================================================\r
  60 */\r
  61 \r
  62 typedef enum {ST_SYNC=0, ST_RAND } synctype_t;\r
  63 typedef enum { SPR_SINGLE=0, SPR_GROUP } spriteframetype_t;\r
  64 \r
  65 typedef struct dspriteheader_s {\r
  66         int                     ident;\r
  67         int                     version;\r
  68 } dspriteheader_t;\r
  69 \r
  70 // Quake1\r
  71 typedef struct {\r
  72         int                     type;\r
  73         float           boundingradius;\r
  74         int                     width;\r
  75         int                     height;\r
  76         int                     numframes;\r
  77         float           beamlength;\r
  78         synctype_t      synctype;\r
  79 } dspritev1_t;\r
  80 \r
  81 // Halflife\r
  82 typedef struct {\r
  83         int                     type;\r
  84         int                     texFormat;\r
  85         float           boundingradius;\r
  86         int                     width;\r
  87         int                     height;\r
  88         int                     numframes;\r
  89         float           beamlength;\r
  90         synctype_t   synctype;\r
  91 } dspritev2_t;\r
  92 \r
  93 typedef struct {\r
  94         int                     origin[2];\r
  95         int                     width;\r
  96         int                     height;\r
  97 } dspriteframe_t;\r
  98 \r
  99 typedef struct {\r
 100         short   type;\r
 101 } dspriteframetype_t;\r
 102 \r
 103 /*\r
 104 typedef struct {\r
 105   byte rgb[256][3];\r
 106 } dpalette_t;\r
 107 */\r
 108 \r
 109 #define IDSPRITEHEADER  (('P'<<24)+('S'<<16)+('D'<<8)+'I')\r
 110                                                                                                                 // little-endian "IDSP"\r
 111 \r
 112 /*\r
 113 =============\r
 114 LoadIDSP\r
 115 =============\r
 116 */\r
 117 \r
 118 static void LoadIDSP (const char *name, byte ** pic, int *width, int *height)\r
 119 {\r
 120   byte *buffer;\r
 121   byte *buf_p;\r
 122   unsigned int length;\r
 123   int columns, rows, numPixels;\r
 124   byte *pixbuf;\r
 125 \r
 126   int row, column;\r
 127   byte *bmpRGBA;\r
 128   byte *palette;\r
 129         unsigned char red, green, blue, alphabyte;\r
 130 \r
 131   dspriteheader_t *header;\r
 132         dspritev1_t                     *pinv1;\r
 133         dspritev2_t                     *pinv2;\r
 134         dspriteframetype_t      *pframetype;\r
 135         int                                     version;\r
 136         int                                     numframes;\r
 137         int                                     size;\r
 138   spriteframetype_t     frametype;\r
 139   dspriteframe_t *spriteframe;\r
 140 \r
 141   *pic = NULL;\r
 142 \r
 143   //\r
 144   // load the file\r
 145   //\r
 146   length = vfsLoadFile ((char *) name, (void **) &buffer);\r
 147   if (length == (unsigned int) -1)\r
 148     return;\r
 149 \r
 150   header = (dspriteheader_t *)buffer;\r
 151 \r
 152   if (header->ident != IDSPRITEHEADER)\r
 153   {\r
 154     Sys_Printf ("WARNING: %s has wrong header\n");\r
 155     vfsFreeFile (buffer);\r
 156     return;\r
 157   }\r
 158 \r
 159   version = header->version;\r
 160   if (version != 1 && version != 2 )\r
 161   {\r
 162     Sys_Printf ("WARNING: %s has wrong version number "\r
 163                                  "(%i should be 1 or 2)\n", name, version);\r
 164     vfsFreeFile (buffer);\r
 165     return;\r
 166   }\r
 167 \r
 168   // initialise variables depending on the sprite version.\r
 169   switch (version)\r
 170   {\r
 171     case 1:\r
 172             pinv1 = (dspritev1_t *)(header+1);\r
 173       numframes = pinv1->numframes;\r
 174       columns = pinv1->width;\r
 175       rows = pinv1->height;\r
 176         pframetype = (dspriteframetype_t *)(pinv1 + 1);\r
 177       break;\r
 178     case 2:\r
 179             pinv2 = (dspritev2_t *)(header+1);\r
 180       numframes = pinv2->numframes;\r
 181       columns = pinv2->width;\r
 182       rows = pinv2->height;\r
 183       pframetype = (dspriteframetype_t *)(pinv2 + 1);\r
 184       break;\r
 185   }\r
 186   if (numframes > 1)\r
 187     Sys_Printf ("WARNING: %s has multiple frames, only the first frame will be used.\n", name);\r
 188 \r
 189   // palette = buffer+mipdatasize+2;\r
 190   // buf_p = buffer+lpMip->offsets[0];\r
 191 \r
 192   numPixels = columns * rows;\r
 193 \r
 194   if (width)\r
 195     *width = columns;\r
 196   if (height)\r
 197     *height = rows;\r
 198 \r
 199   bmpRGBA = reinterpret_cast < unsigned char *>(g_malloc (numPixels * 4));\r
 200   *pic = bmpRGBA;\r
 201 \r
 202 #ifdef DEBUG\r
 203         frametype = spriteframetype_t(LittleLong(pframetype->type));\r
 204         if (frametype == SPR_SINGLE)\r
 205   {\r
 206     Sys_Printf("Single Frame\n");\r
 207   }\r
 208   else if (frametype == SPR_GROUP)\r
 209   {\r
 210     Sys_Printf("Group of Frames\n");\r
 211   }\r
 212   else\r
 213   {\r
 214     Sys_Printf("Bleh!\n"); // <-- we always get this, wtf!\r
 215   }\r
 216 #endif\r
 217 \r
 218   palette = (byte *)(pframetype+1);\r
 219   spriteframe = (dspriteframe_t *)(palette + (256*3) + 4); // what are those 4 extra bytes ? what's missing ?\r
 220   buf_p = (byte *)(spriteframe + 1);\r
 221 \r
 222   int temp;\r
 223 \r
 224   temp = buf_p - buffer;\r
 225 \r
 226   for (row = 0; row < rows; row++)\r
 227   {\r
 228     pixbuf = bmpRGBA + row * columns * 4;\r
 229 \r
 230     for (column = 0; column < columns; column++)\r
 231     {\r
 232       int palIndex;\r
 233 \r
 234             palIndex = *buf_p++;\r
 235 \r
 236       red = *(palette+(palIndex*3));\r
 237       green = *(palette+(palIndex*3)+1);\r
 238       blue = *(palette+(palIndex*3)+2);\r
 239 \r
 240       // HalfLife engine makes pixels that are BLUE transparent. (RGB = 0x0000FF)\r
 241       // So show them that way in the editor.\r
 242       if (blue == 0xff && red == 0x00 && green == 0x00)\r
 243       {\r
 244         alphabyte = 0xff; //FIXME: backwards? (so sprite models to render correctly)\r
 245         blue = 0x00; // don't set the resulting pixel to blue\r
 246       }\r
 247       else\r
 248       {\r
 249         alphabyte = 0x00; //FIXME: backwards? (so sprite models to render correctly)\r
 250       }\r
 251 \r
 252             *pixbuf++ = red;\r
 253             *pixbuf++ = green;\r
 254             *pixbuf++ = blue;\r
 255 \r
 256             *pixbuf++ = alphabyte;\r
 257     }\r
 258   }\r
 259 \r
 260   vfsFreeFile (buffer);\r
 261 }\r
 262 #endif\r
 263 \r
 264 #ifdef USE_HLW\r
 265 /*\r
 266 ============================================================================\r
 267 \r
 268 HLW IMAGE\r
 269 \r
 270   HalfLife WAD files contain files that look like this:\r
 271 \r
 272         Mip section\r
 273                 First mip\r
 274                         Mip header\r
 275                         First mip (width * height)\r
 276                         Second mip (width * height / 4)\r
 277                         Third mip (width * height / 16)\r
 278                         Fourth mip (width * height / 64)\r
 279                         Palette size (WORD)\r
 280                         Palette (Palette size * 3)\r
 281                         Padding (WORD)\r
 282 \r
 283 ============================================================================\r
 284 */\r
 285 \r
 286 #define GET_MIP_DATA_SIZE(WIDTH, HEIGHT) (sizeof(WAD3_MIP) + (WIDTH * HEIGHT) + (WIDTH * HEIGHT / 4) + (WIDTH * HEIGHT / 16) + (WIDTH * HEIGHT / 64))\r
 287 \r
 288 typedef struct\r
 289 {\r
 290         char            name[16];\r
 291         DWORD           width, height;\r
 292         DWORD           offsets[4];             // four mip maps stored\r
 293 } WAD3_MIP, *LPWAD3_MIP;\r
 294 \r
 295 /*\r
 296 =========================================================\r
 297 \r
 298 HLW LOADING\r
 299 \r
 300   Hydra: this code isn't bullet proof and probably won't\r
 301   like corrupt WAD files, but it works for now.\r
 302 \r
 303   TODO: make it more robust.\r
 304 =========================================================\r
 305 */\r
 306 \r
 307 /*\r
 308 =============\r
 309 LoadHLW\r
 310 =============\r
 311 */\r
 312 \r
 313 static void LoadHLW (const char *name, byte ** pic, int *width, int *height)\r
 314 {\r
 315   byte *buffer;\r
 316   byte *buf_p;\r
 317   unsigned int length;\r
 318   unsigned long mipdatasize;\r
 319   int columns, rows, numPixels;\r
 320   byte *pixbuf;\r
 321   int row, column;\r
 322   byte *bmpRGBA;\r
 323   byte *palette;\r
 324         LPWAD3_MIP              lpMip;\r
 325         unsigned char red, green, blue, alphabyte;\r
 326 \r
 327   *pic = NULL;\r
 328 \r
 329   //\r
 330   // load the file\r
 331   //\r
 332   length = vfsLoadFile ((char *) name, (void **) &buffer);\r
 333   if (length == (unsigned int) -1)\r
 334     return;\r
 335 \r
 336   lpMip = (LPWAD3_MIP)buffer;\r
 337 \r
 338   mipdatasize = GET_MIP_DATA_SIZE(lpMip->width,lpMip->height);\r
 339 \r
 340   palette = buffer+mipdatasize+2;\r
 341 \r
 342   buf_p = buffer+lpMip->offsets[0];\r
 343 \r
 344   columns = lpMip->width;\r
 345   rows = lpMip->height;\r
 346   numPixels = columns * rows;\r
 347 \r
 348   if (width)\r
 349     *width = columns;\r
 350   if (height)\r
 351     *height = rows;\r
 352 \r
 353   bmpRGBA = reinterpret_cast < unsigned char *>(g_malloc (numPixels * 4));\r
 354   *pic = bmpRGBA;\r
 355 \r
 356   for (row = 0; row < rows; row++)\r
 357   {\r
 358     pixbuf = bmpRGBA + row * columns * 4;\r
 359 \r
 360     for (column = 0; column < columns; column++)\r
 361     {\r
 362       int palIndex;\r
 363 \r
 364             palIndex = *buf_p++;\r
 365 \r
 366       red = *(palette+(palIndex*3));\r
 367       green = *(palette+(palIndex*3)+1);\r
 368       blue = *(palette+(palIndex*3)+2);\r
 369 \r
 370       // HalfLife engine makes pixels that are BLUE transparent.\r
 371       // So show them that way in the editor.\r
 372       if (blue == 0xff && red == 0x00 && green == 0x00)\r
 373       {\r
 374         alphabyte = 0x00;\r
 375         blue = 0x00; // don't set the resulting pixel to blue\r
 376       }\r
 377       else\r
 378       {\r
 379         alphabyte = 0xff;\r
 380       }\r
 381 \r
 382             *pixbuf++ = red;\r
 383             *pixbuf++ = green;\r
 384             *pixbuf++ = blue;\r
 385 \r
 386             *pixbuf++ = alphabyte;\r
 387     }\r
 388   }\r
 389 \r
 390   vfsFreeFile (buffer);\r
 391 }\r
 392 #endif\r
 393 \r
 394 #ifdef USE_MIP\r
 395 /*\r
 396 ============================================================================\r
 397 \r
 398 MIP IMAGE\r
 399 \r
 400   Quake WAD files contain miptex files that look like this:\r
 401 \r
 402         Mip section\r
 403                 First mip\r
 404                         Mip header\r
 405                         First mip (width * height)\r
 406                         Second mip (width * height / 4)\r
 407                         Third mip (width * height / 16)\r
 408                         Fourth mip (width * height / 64)\r
 409 \r
 410 ============================================================================\r
 411 */\r
 412 \r
 413 /*\r
 414 =========================================================\r
 415 \r
 416 MIP LOADING\r
 417 \r
 418   LordHavoc: this code is based on the HLW code above.\r
 419 =========================================================\r
 420 */\r
 421 \r
 422 \r
 423 static const byte quakepalette[768] =\r
 424 {\r
 425   0x00,0x00,0x00, 0x0f,0x0f,0x0f, 0x1f,0x1f,0x1f, 0x2f,0x2f,0x2f,\r
 426   0x3f,0x3f,0x3f, 0x4b,0x4b,0x4b, 0x5b,0x5b,0x5b, 0x6b,0x6b,0x6b,\r
 427   0x7b,0x7b,0x7b, 0x8b,0x8b,0x8b, 0x9b,0x9b,0x9b, 0xab,0xab,0xab,\r
 428   0xbb,0xbb,0xbb, 0xcb,0xcb,0xcb, 0xdb,0xdb,0xdb, 0xeb,0xeb,0xeb,\r
 429   0x0f,0x0b,0x07, 0x17,0x0f,0x0b, 0x1f,0x17,0x0b, 0x27,0x1b,0x0f,\r
 430   0x2f,0x23,0x13, 0x37,0x2b,0x17, 0x3f,0x2f,0x17, 0x4b,0x37,0x1b,\r
 431   0x53,0x3b,0x1b, 0x5b,0x43,0x1f, 0x63,0x4b,0x1f, 0x6b,0x53,0x1f,\r
 432   0x73,0x57,0x1f, 0x7b,0x5f,0x23, 0x83,0x67,0x23, 0x8f,0x6f,0x23,\r
 433   0x0b,0x0b,0x0f, 0x13,0x13,0x1b, 0x1b,0x1b,0x27, 0x27,0x27,0x33,\r
 434   0x2f,0x2f,0x3f, 0x37,0x37,0x4b, 0x3f,0x3f,0x57, 0x47,0x47,0x67,\r
 435   0x4f,0x4f,0x73, 0x5b,0x5b,0x7f, 0x63,0x63,0x8b, 0x6b,0x6b,0x97,\r
 436   0x73,0x73,0xa3, 0x7b,0x7b,0xaf, 0x83,0x83,0xbb, 0x8b,0x8b,0xcb,\r
 437   0x00,0x00,0x00, 0x07,0x07,0x00, 0x0b,0x0b,0x00, 0x13,0x13,0x00,\r
 438   0x1b,0x1b,0x00, 0x23,0x23,0x00, 0x2b,0x2b,0x07, 0x2f,0x2f,0x07,\r
 439   0x37,0x37,0x07, 0x3f,0x3f,0x07, 0x47,0x47,0x07, 0x4b,0x4b,0x0b,\r
 440   0x53,0x53,0x0b, 0x5b,0x5b,0x0b, 0x63,0x63,0x0b, 0x6b,0x6b,0x0f,\r
 441   0x07,0x00,0x00, 0x0f,0x00,0x00, 0x17,0x00,0x00, 0x1f,0x00,0x00,\r
 442   0x27,0x00,0x00, 0x2f,0x00,0x00, 0x37,0x00,0x00, 0x3f,0x00,0x00,\r
 443   0x47,0x00,0x00, 0x4f,0x00,0x00, 0x57,0x00,0x00, 0x5f,0x00,0x00,\r
 444   0x67,0x00,0x00, 0x6f,0x00,0x00, 0x77,0x00,0x00, 0x7f,0x00,0x00,\r
 445   0x13,0x13,0x00, 0x1b,0x1b,0x00, 0x23,0x23,0x00, 0x2f,0x2b,0x00,\r
 446   0x37,0x2f,0x00, 0x43,0x37,0x00, 0x4b,0x3b,0x07, 0x57,0x43,0x07,\r
 447   0x5f,0x47,0x07, 0x6b,0x4b,0x0b, 0x77,0x53,0x0f, 0x83,0x57,0x13,\r
 448   0x8b,0x5b,0x13, 0x97,0x5f,0x1b, 0xa3,0x63,0x1f, 0xaf,0x67,0x23,\r
 449   0x23,0x13,0x07, 0x2f,0x17,0x0b, 0x3b,0x1f,0x0f, 0x4b,0x23,0x13,\r
 450   0x57,0x2b,0x17, 0x63,0x2f,0x1f, 0x73,0x37,0x23, 0x7f,0x3b,0x2b,\r
 451   0x8f,0x43,0x33, 0x9f,0x4f,0x33, 0xaf,0x63,0x2f, 0xbf,0x77,0x2f,\r
 452   0xcf,0x8f,0x2b, 0xdf,0xab,0x27, 0xef,0xcb,0x1f, 0xff,0xf3,0x1b,\r
 453   0x0b,0x07,0x00, 0x1b,0x13,0x00, 0x2b,0x23,0x0f, 0x37,0x2b,0x13,\r
 454   0x47,0x33,0x1b, 0x53,0x37,0x23, 0x63,0x3f,0x2b, 0x6f,0x47,0x33,\r
 455   0x7f,0x53,0x3f, 0x8b,0x5f,0x47, 0x9b,0x6b,0x53, 0xa7,0x7b,0x5f,\r
 456   0xb7,0x87,0x6b, 0xc3,0x93,0x7b, 0xd3,0xa3,0x8b, 0xe3,0xb3,0x97,\r
 457   0xab,0x8b,0xa3, 0x9f,0x7f,0x97, 0x93,0x73,0x87, 0x8b,0x67,0x7b,\r
 458   0x7f,0x5b,0x6f, 0x77,0x53,0x63, 0x6b,0x4b,0x57, 0x5f,0x3f,0x4b,\r
 459   0x57,0x37,0x43, 0x4b,0x2f,0x37, 0x43,0x27,0x2f, 0x37,0x1f,0x23,\r
 460   0x2b,0x17,0x1b, 0x23,0x13,0x13, 0x17,0x0b,0x0b, 0x0f,0x07,0x07,\r
 461   0xbb,0x73,0x9f, 0xaf,0x6b,0x8f, 0xa3,0x5f,0x83, 0x97,0x57,0x77,\r
 462   0x8b,0x4f,0x6b, 0x7f,0x4b,0x5f, 0x73,0x43,0x53, 0x6b,0x3b,0x4b,\r
 463   0x5f,0x33,0x3f, 0x53,0x2b,0x37, 0x47,0x23,0x2b, 0x3b,0x1f,0x23,\r
 464   0x2f,0x17,0x1b, 0x23,0x13,0x13, 0x17,0x0b,0x0b, 0x0f,0x07,0x07,\r
 465   0xdb,0xc3,0xbb, 0xcb,0xb3,0xa7, 0xbf,0xa3,0x9b, 0xaf,0x97,0x8b,\r
 466   0xa3,0x87,0x7b, 0x97,0x7b,0x6f, 0x87,0x6f,0x5f, 0x7b,0x63,0x53,\r
 467   0x6b,0x57,0x47, 0x5f,0x4b,0x3b, 0x53,0x3f,0x33, 0x43,0x33,0x27,\r
 468   0x37,0x2b,0x1f, 0x27,0x1f,0x17, 0x1b,0x13,0x0f, 0x0f,0x0b,0x07,\r
 469   0x6f,0x83,0x7b, 0x67,0x7b,0x6f, 0x5f,0x73,0x67, 0x57,0x6b,0x5f,\r
 470   0x4f,0x63,0x57, 0x47,0x5b,0x4f, 0x3f,0x53,0x47, 0x37,0x4b,0x3f,\r
 471   0x2f,0x43,0x37, 0x2b,0x3b,0x2f, 0x23,0x33,0x27, 0x1f,0x2b,0x1f,\r
 472   0x17,0x23,0x17, 0x0f,0x1b,0x13, 0x0b,0x13,0x0b, 0x07,0x0b,0x07,\r
 473   0xff,0xf3,0x1b, 0xef,0xdf,0x17, 0xdb,0xcb,0x13, 0xcb,0xb7,0x0f,\r
 474   0xbb,0xa7,0x0f, 0xab,0x97,0x0b, 0x9b,0x83,0x07, 0x8b,0x73,0x07,\r
 475   0x7b,0x63,0x07, 0x6b,0x53,0x00, 0x5b,0x47,0x00, 0x4b,0x37,0x00,\r
 476   0x3b,0x2b,0x00, 0x2b,0x1f,0x00, 0x1b,0x0f,0x00, 0x0b,0x07,0x00,\r
 477   0x00,0x00,0xff, 0x0b,0x0b,0xef, 0x13,0x13,0xdf, 0x1b,0x1b,0xcf,\r
 478   0x23,0x23,0xbf, 0x2b,0x2b,0xaf, 0x2f,0x2f,0x9f, 0x2f,0x2f,0x8f,\r
 479   0x2f,0x2f,0x7f, 0x2f,0x2f,0x6f, 0x2f,0x2f,0x5f, 0x2b,0x2b,0x4f,\r
 480   0x23,0x23,0x3f, 0x1b,0x1b,0x2f, 0x13,0x13,0x1f, 0x0b,0x0b,0x0f,\r
 481   0x2b,0x00,0x00, 0x3b,0x00,0x00, 0x4b,0x07,0x00, 0x5f,0x07,0x00,\r
 482   0x6f,0x0f,0x00, 0x7f,0x17,0x07, 0x93,0x1f,0x07, 0xa3,0x27,0x0b,\r
 483   0xb7,0x33,0x0f, 0xc3,0x4b,0x1b, 0xcf,0x63,0x2b, 0xdb,0x7f,0x3b,\r
 484   0xe3,0x97,0x4f, 0xe7,0xab,0x5f, 0xef,0xbf,0x77, 0xf7,0xd3,0x8b,\r
 485   0xa7,0x7b,0x3b, 0xb7,0x9b,0x37, 0xc7,0xc3,0x37, 0xe7,0xe3,0x57,\r
 486   0x7f,0xbf,0xff, 0xab,0xe7,0xff, 0xd7,0xff,0xff, 0x67,0x00,0x00,\r
 487   0x8b,0x00,0x00, 0xb3,0x00,0x00, 0xd7,0x00,0x00, 0xff,0x00,0x00,\r
 488   0xff,0xf3,0x93, 0xff,0xf7,0xc7, 0xff,0xff,0xff, 0x9f,0x5b,0x53\r
 489 };\r
 490 \r
 491 /*\r
 492 =============\r
 493 LoadMIP\r
 494 =============\r
 495 */\r
 496 \r
 497 static void LoadMIP (const char *name, byte ** pic, int *width, int *height)\r
 498 {\r
 499   byte *buffer;\r
 500   byte *buf_p;\r
 501   unsigned int length, palettelength;\r
 502   unsigned long mipdatasize;\r
 503   int columns, rows, numPixels;\r
 504   byte *pixbuf;\r
 505   int i;\r
 506   byte *bmpRGBA;\r
 507   byte *loadedpalette;\r
 508   const byte *palette;\r
 509   LPWAD3_MIP            lpMip;\r
 510 \r
 511   *pic = NULL;\r
 512   loadedpalette = NULL;\r
 513 \r
 514   //\r
 515   // load the file\r
 516   //\r
 517   length = vfsLoadFile ((char *) name, (void **) &buffer);\r
 518   if (length == (unsigned int) -1)\r
 519     return;\r
 520 \r
 521   lpMip = (LPWAD3_MIP)buffer;\r
 522 \r
 523   mipdatasize = GET_MIP_DATA_SIZE(lpMip->width,lpMip->height);\r
 524 \r
 525   palettelength = vfsLoadFile ("textures/palette.lmp", (void **) &loadedpalette);\r
 526   if (palettelength == 768)\r
 527     palette = loadedpalette;\r
 528   else\r
 529   {\r
 530     loadedpalette = NULL;\r
 531     palette = quakepalette;\r
 532   }\r
 533 \r
 534   buf_p = buffer+lpMip->offsets[0];\r
 535 \r
 536   columns = lpMip->width;\r
 537   rows = lpMip->height;\r
 538   numPixels = columns * rows;\r
 539 \r
 540   if (width)\r
 541     *width = columns;\r
 542   if (height)\r
 543     *height = rows;\r
 544 \r
 545   //Sys_Printf("lpMip->width = %i, lpMip->height = %i, lpMip->offsets[0] = %i, lpMip->offsets[1] = %i, lpMip->offsets[2] = %i, lpMip->offsets[3] = %i, numPixels = %i\n", lpMip->width, lpMip->height, lpMip->offsets[0], lpMip->offsets[1], lpMip->offsets[2], lpMip->offsets[3], numPixels);\r
 546   //for (i = 0; i < sizeof(*lpMip); i++)\r
 547   //  Sys_Printf("%02x", (int) ((unsigned char *)lpMip)[i]);\r
 548 \r
 549   bmpRGBA = reinterpret_cast < unsigned char *>(g_malloc (numPixels * 4));\r
 550   *pic = bmpRGBA;\r
 551   pixbuf = bmpRGBA;\r
 552 \r
 553   for (i = 0; i < numPixels; i++)\r
 554   {\r
 555     int palIndex = *buf_p++;\r
 556     *pixbuf++ = palette[palIndex*3];\r
 557     *pixbuf++ = palette[palIndex*3+1];\r
 558     *pixbuf++ = palette[palIndex*3+2];\r
 559     *pixbuf++ = 0xff;\r
 560   }\r
 561 \r
 562   vfsFreeFile (buffer);\r
 563   if (loadedpalette != NULL)\r
 564     vfsFreeFile (loadedpalette);\r
 565 }\r
 566 #endif\r
 567 \r
 568 /*\r
 569 =================\r
 570 LoadImage\r
 571 \r
 572 Loads any of the supported image types into a cannonical\r
 573 32 bit format.\r
 574 =================\r
 575 */\r
 576 void LoadImage (const char *name, byte ** pic, int *width, int *height)\r
 577 {\r
 578   int len;\r
 579   *pic = NULL;\r
 580   *width = 0;\r
 581   *height = 0;\r
 582 \r
 583   len = strlen (name);\r
 584   if (len < 5)\r
 585   {\r
 586     return;\r
 587   }\r
 588 \r
 589 #ifdef USE_HLW\r
 590   if (*pic == NULL && !g_strcasecmp (name + len - 4, ".hlw"))\r
 591   {\r
 592     LoadHLW (name, pic, width, height);\r
 593   }\r
 594 #endif\r
 595 \r
 596 #ifdef USE_MIP\r
 597   if (*pic == NULL && !g_strcasecmp (name + len - 4, ".mip"))\r
 598   {\r
 599     LoadMIP (name, pic, width, height);\r
 600   }\r
 601 #endif\r
 602 \r
 603 #ifdef USE_IDSP\r
 604   if (*pic == NULL && !g_strcasecmp (name + len - 4, ".spr"))\r
 605   {\r
 606     LoadIDSP (name, pic, width, height);\r
 607   }\r
 608 #endif\r
 609 }\r