plugins/imagehl/lbmlib.cpp

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