made darkplaces compile successfully with g++ to test for errors C doesn't care about...
[xonotic/darkplaces.git] / wad.c
diff --git a/wad.c b/wad.c
index 1a5ab0a..eda0e4c 100644 (file)
--- a/wad.c
+++ b/wad.c
@@ -8,7 +8,7 @@ of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 See the GNU General Public License for more details.
 
@@ -17,16 +17,16 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 */
-// wad.c
+
 
 #include "quakedef.h"
+#include "image.h"
+#include "wad.h"
 
-int                    wad_numlumps;
-lumpinfo_t     *wad_lumps;
-byte           *wad_base;
 
 void SwapPic (qpic_t *pic);
 
+
 /*
 ==================
 W_CleanupName
@@ -38,109 +38,81 @@ Space padding is so names can be printed nicely in tables.
 Can safely be performed in place.
 ==================
 */
-void W_CleanupName (char *in, char *out)
+static void W_CleanupName (const char *in, char *out)
 {
        int             i;
        int             c;
-       
+
        for (i=0 ; i<16 ; i++ )
        {
                c = in[i];
                if (!c)
                        break;
-                       
+
                if (c >= 'A' && c <= 'Z')
                        c += ('a' - 'A');
                out[i] = c;
        }
-       
+
        for ( ; i< 16 ; i++ )
                out[i] = 0;
 }
 
+void *W_GetLumpName(const char *name)
+{
+       int i;
+       lumpinfo_t *lump;
+       char clean[16];
+       wadinfo_t *header;
+       int infotableofs;
+       void *temp;
+       static int wad_loaded = false;
+       static int wad_numlumps = 0;
+       static lumpinfo_t *wad_lumps = NULL;
+       static qbyte *wad_base = NULL;
 
+       W_CleanupName (name, clean);
 
-/*
-====================
-W_LoadWadFile
-====================
-*/
-void W_LoadWadFile (char *filename)
-{
-       lumpinfo_t              *lump_p;
-       wadinfo_t               *header;
-       unsigned                i;
-       int                             infotableofs;
-       
-       wad_base = COM_LoadHunkFile (filename, false);
-       if (!wad_base)
-               Sys_Error ("W_LoadWadFile: couldn't load %s", filename);
-
-       header = (wadinfo_t *)wad_base;
-       
-       if (header->identification[0] != 'W'
-       || header->identification[1] != 'A'
-       || header->identification[2] != 'D'
-       || header->identification[3] != '2')
-               Sys_Error ("Wad file %s doesn't have WAD2 id\n",filename);
-               
-       wad_numlumps = LittleLong(header->numlumps);
-       infotableofs = LittleLong(header->infotableofs);
-       wad_lumps = (lumpinfo_t *)(wad_base + infotableofs);
-       
-       for (i=0, lump_p = wad_lumps ; i<wad_numlumps ; i++,lump_p++)
+       if (!wad_loaded)
        {
-               lump_p->filepos = LittleLong(lump_p->filepos);
-               lump_p->size = LittleLong(lump_p->size);
-               W_CleanupName (lump_p->name, lump_p->name);
-               if (lump_p->type == TYP_QPIC)
-                       SwapPic ( (qpic_t *)(wad_base + lump_p->filepos));
-       }
-}
+               wad_loaded = true;
+               if ((temp = FS_LoadFile ("gfx.wad", tempmempool, false)))
+               {
+                       if (memcmp(temp, "WAD2", 4))
+                               Con_Print("gfx.wad doesn't have WAD2 id\n");
+                       else
+                       {
+                               wad_base = (qbyte *)Mem_Alloc(cl_mempool, fs_filesize);
 
+                               memcpy(wad_base, temp, fs_filesize);
+                               Mem_Free(temp);
 
-/*
-=============
-W_GetLumpinfo
-=============
-*/
-lumpinfo_t     *W_GetLumpinfo (char *name)
-{
-       int             i;
-       lumpinfo_t      *lump_p;
-       char    clean[16];
-       
-       W_CleanupName (name, clean);
-       
-       for (lump_p=wad_lumps, i=0 ; i<wad_numlumps ; i++,lump_p++)
-       {
-               if (!strcmp(clean, lump_p->name))
-                       return lump_p;
+                               header = (wadinfo_t *)wad_base;
+                               wad_numlumps = LittleLong(header->numlumps);
+                               infotableofs = LittleLong(header->infotableofs);
+                               wad_lumps = (lumpinfo_t *)(wad_base + infotableofs);
+
+                               for (i=0, lump = wad_lumps ; i<wad_numlumps ; i++,lump++)
+                               {
+                                       lump->filepos = LittleLong(lump->filepos);
+                                       lump->size = LittleLong(lump->size);
+                                       W_CleanupName (lump->name, lump->name);
+                                       if (lump->type == TYP_QPIC)
+                                               SwapPic ( (qpic_t *)(wad_base + lump->filepos));
+                               }
+                       }
+               }
        }
-       
-       Sys_Error ("W_GetLumpinfo: %s not found", name);
-       return NULL;
-}
 
-void *W_GetLumpName (char *name)
-{
-       lumpinfo_t      *lump;
-       
-       lump = W_GetLumpinfo (name);
-       
-       return (void *)(wad_base + lump->filepos);
-}
+       for (lump = wad_lumps, i = 0;i < wad_numlumps;i++, lump++)
+               if (!strcmp(clean, lump->name))
+                       return (void *)(wad_base + lump->filepos);
 
-void *W_GetLumpNum (int num)
-{
-       lumpinfo_t      *lump;
-       
-       if (num < 0 || num > wad_numlumps)
-               Sys_Error ("W_GetLumpNum: bad number: %i", num);
-               
-       lump = wad_lumps + num;
-       
-       return (void *)(wad_base + lump->filepos);
+       if (wad_base)
+               Con_DPrintf("W_GetLumpByName(\"%s\"): couldn't find file in gfx.wad\n", name);
+       else
+               Con_DPrintf("W_GetLumpByName(\"%s\"): couldn't load gfx.wad\n", name);
+       return NULL;
 }
 
 /*
@@ -154,7 +126,7 @@ automatic byte swapping
 void SwapPic (qpic_t *pic)
 {
        pic->width = LittleLong(pic->width);
-       pic->height = LittleLong(pic->height);  
+       pic->height = LittleLong(pic->height);
 }
 
 // LordHavoc: added alternate WAD2/WAD3 system for HalfLife texture wads
@@ -162,12 +134,12 @@ void SwapPic (qpic_t *pic)
 typedef struct
 {
        char name[16];
-       QFile *file;
+       qfile_t *file;
        int position;
        int size;
 } texwadlump_t;
 
-texwadlump_t   texwadlump[TEXWAD_MAXIMAGES];
+static texwadlump_t texwadlump[TEXWAD_MAXIMAGES];
 
 /*
 ====================
@@ -178,39 +150,36 @@ void W_LoadTextureWadFile (char *filename, int complain)
 {
        lumpinfo_t              *lumps, *lump_p;
        wadinfo_t               header;
-       unsigned                i, j;
+       int                             i, j;
        int                             infotableofs;
-       QFile                   *file;
+       qfile_t                 *file;
        int                             numlumps;
-       
-       COM_FOpenFile (filename, &file, false, true);
+
+       file = FS_Open (filename, "rb", false, false);
        if (!file)
        {
                if (complain)
-                       Con_Printf ("W_LoadTextureWadFile: couldn't find %s", filename);
+                       Con_Printf("W_LoadTextureWadFile: couldn't find %s\n", filename);
                return;
        }
 
-       if (Qread(file, &header, sizeof(wadinfo_t)) != sizeof(wadinfo_t))
-       {Con_Printf ("W_LoadTextureWadFile: unable to read wad header");return;}
-       
-       if(header.identification[0] != 'W'
-       || header.identification[1] != 'A'
-       || header.identification[2] != 'D'
-       || header.identification[3] != '3')
-       {Con_Printf ("W_LoadTextureWadFile: Wad file %s doesn't have WAD3 id\n",filename);return;}
+       if (FS_Read(file, &header, sizeof(wadinfo_t)) != sizeof(wadinfo_t))
+       {Con_Print("W_LoadTextureWadFile: unable to read wad header\n");return;}
+
+       if(memcmp(header.identification, "WAD3", 4))
+       {Con_Printf("W_LoadTextureWadFile: Wad file %s doesn't have WAD3 id\n",filename);return;}
 
        numlumps = LittleLong(header.numlumps);
        if (numlumps < 1 || numlumps > TEXWAD_MAXIMAGES)
-       {Con_Printf ("W_LoadTextureWadFile: invalid number of lumps (%i)\n", numlumps);return;}
+       {Con_Printf("W_LoadTextureWadFile: invalid number of lumps (%i)\n", numlumps);return;}
        infotableofs = LittleLong(header.infotableofs);
-       if (Qseek(file, infotableofs, SEEK_SET))
-       {Con_Printf ("W_LoadTextureWadFile: unable to seek to lump table");return;}
-       if (!(lumps = qmalloc(sizeof(lumpinfo_t)*numlumps)))
-       {Con_Printf ("W_LoadTextureWadFile: unable to allocate temporary memory for lump table");return;}
+       if (FS_Seek (file, infotableofs, SEEK_SET))
+       {Con_Print("W_LoadTextureWadFile: unable to seek to lump table\n");return;}
+       if (!(lumps = (lumpinfo_t *)Mem_Alloc(tempmempool, sizeof(lumpinfo_t)*numlumps)))
+       {Con_Print("W_LoadTextureWadFile: unable to allocate temporary memory for lump table\n");return;}
 
-       if (Qread(file, lumps, sizeof(lumpinfo_t) * numlumps) != sizeof(lumpinfo_t) * numlumps)
-       {Con_Printf ("W_LoadTextureWadFile: unable to read lump table");return;}
+       if (FS_Read(file, lumps, sizeof(lumpinfo_t) * numlumps) != (fs_offset_t)sizeof(lumpinfo_t) * numlumps)
+       {Con_Print("W_LoadTextureWadFile: unable to read lump table\n");return;}
 
        for (i=0, lump_p = lumps ; i<numlumps ; i++,lump_p++)
        {
@@ -232,79 +201,23 @@ void W_LoadTextureWadFile (char *filename, int complain)
                texwadlump[j].position = LittleLong(lump_p->filepos);
                texwadlump[j].size = LittleLong(lump_p->disksize);
        }
-       qfree(lumps);
+       Mem_Free(lumps);
        // leaves the file open
 }
 
-/*
-byte hlpalette[768] =
-{
-       0x00,0x00,0x00,0x0F,0x0F,0x0F,0x1F,0x1F,0x1F,0x2F,0x2F,0x2F,0x3F,0x3F,0x3F,0x4B,
-       0x4B,0x4B,0x5B,0x5B,0x5B,0x6B,0x6B,0x6B,0x7B,0x7B,0x7B,0x8B,0x8B,0x8B,0x9B,0x9B,
-       0x9B,0xAB,0xAB,0xAB,0xBB,0xBB,0xBB,0xCB,0xCB,0xCB,0xDB,0xDB,0xDB,0xEB,0xEB,0xEB,
-       0x0F,0x0B,0x07,0x17,0x0F,0x0B,0x1F,0x17,0x0B,0x27,0x1B,0x0F,0x2F,0x23,0x13,0x37,
-       0x2B,0x17,0x3F,0x2F,0x17,0x4B,0x37,0x1B,0x53,0x3B,0x1B,0x5B,0x43,0x1F,0x63,0x4B,
-       0x1F,0x6B,0x53,0x1F,0x73,0x57,0x1F,0x7B,0x5F,0x23,0x83,0x67,0x23,0x8F,0x6F,0x23,
-       0x0B,0x0B,0x0F,0x13,0x13,0x1B,0x1B,0x1B,0x27,0x27,0x27,0x33,0x2F,0x2F,0x3F,0x37,
-       0x37,0x4B,0x3F,0x3F,0x57,0x47,0x47,0x67,0x4F,0x4F,0x73,0x5B,0x5B,0x7F,0x63,0x63,
-       0x8B,0x6B,0x6B,0x97,0x73,0x73,0xA3,0x7B,0x7B,0xAF,0x83,0x83,0xBB,0x8B,0x8B,0xCB,
-       0x00,0x00,0x00,0x07,0x07,0x00,0x0B,0x0B,0x00,0x13,0x13,0x00,0x1B,0x1B,0x00,0x23,
-       0x23,0x00,0x2B,0x2B,0x07,0x2F,0x2F,0x07,0x37,0x37,0x07,0x3F,0x3F,0x07,0x47,0x47,
-       0x07,0x4B,0x4B,0x0B,0x53,0x53,0x0B,0x5B,0x5B,0x0B,0x63,0x63,0x0B,0x6B,0x6B,0x0F,
-       0x07,0x00,0x00,0x0F,0x00,0x00,0x17,0x00,0x00,0x1F,0x00,0x00,0x27,0x00,0x00,0x2F,
-       0x00,0x00,0x37,0x00,0x00,0x3F,0x00,0x00,0x47,0x00,0x00,0x4F,0x00,0x00,0x57,0x00,
-       0x00,0x5F,0x00,0x00,0x67,0x00,0x00,0x6F,0x00,0x00,0x77,0x00,0x00,0x7F,0x00,0x00,
-       0x13,0x13,0x00,0x1B,0x1B,0x00,0x23,0x23,0x00,0x2F,0x2B,0x00,0x37,0x2F,0x00,0x43,
-       0x37,0x00,0x4B,0x3B,0x07,0x57,0x43,0x07,0x5F,0x47,0x07,0x6B,0x4B,0x0B,0x77,0x53,
-       0x0F,0x83,0x57,0x13,0x8B,0x5B,0x13,0x97,0x5F,0x1B,0xA3,0x63,0x1F,0xAF,0x67,0x23,
-       0x23,0x13,0x07,0x2F,0x17,0x0B,0x3B,0x1F,0x0F,0x4B,0x23,0x13,0x57,0x2B,0x17,0x63,
-       0x2F,0x1F,0x73,0x37,0x23,0x7F,0x3B,0x2B,0x8F,0x43,0x33,0x9F,0x4F,0x33,0xAF,0x63,
-       0x2F,0xBF,0x77,0x2F,0xCF,0x8F,0x2B,0xDF,0xAB,0x27,0xEF,0xCB,0x1F,0xFF,0xF3,0x1B,
-       0x0B,0x07,0x00,0x1B,0x13,0x00,0x2B,0x23,0x0F,0x37,0x2B,0x13,0x47,0x33,0x1B,0x53,
-       0x37,0x23,0x63,0x3F,0x2B,0x6F,0x47,0x33,0x7F,0x53,0x3F,0x8B,0x5F,0x47,0x9B,0x6B,
-       0x53,0xA7,0x7B,0x5F,0xB7,0x87,0x6B,0xC3,0x93,0x7B,0xD3,0xA3,0x8B,0xE3,0xB3,0x97,
-       0xAB,0x8B,0xA3,0x9F,0x7F,0x97,0x93,0x73,0x87,0x8B,0x67,0x7B,0x7F,0x5B,0x6F,0x77,
-       0x53,0x63,0x6B,0x4B,0x57,0x5F,0x3F,0x4B,0x57,0x37,0x43,0x4B,0x2F,0x37,0x43,0x27,
-       0x2F,0x37,0x1F,0x23,0x2B,0x17,0x1B,0x23,0x13,0x13,0x17,0x0B,0x0B,0x0F,0x07,0x07,
-       0xBB,0x73,0x9F,0xAF,0x6B,0x8F,0xA3,0x5F,0x83,0x97,0x57,0x77,0x8B,0x4F,0x6B,0x7F,
-       0x4B,0x5F,0x73,0x43,0x53,0x6B,0x3B,0x4B,0x5F,0x33,0x3F,0x53,0x2B,0x37,0x47,0x23,
-       0x2B,0x3B,0x1F,0x23,0x2F,0x17,0x1B,0x23,0x13,0x13,0x17,0x0B,0x0B,0x0F,0x07,0x07,
-       0xDB,0xC3,0xBB,0xCB,0xB3,0xA7,0xBF,0xA3,0x9B,0xAF,0x97,0x8B,0xA3,0x87,0x7B,0x97,
-       0x7B,0x6F,0x87,0x6F,0x5F,0x7B,0x63,0x53,0x6B,0x57,0x47,0x5F,0x4B,0x3B,0x53,0x3F,
-       0x33,0x43,0x33,0x27,0x37,0x2B,0x1F,0x27,0x1F,0x17,0x1B,0x13,0x0F,0x0F,0x0B,0x07,
-       0x6F,0x83,0x7B,0x67,0x7B,0x6F,0x5F,0x73,0x67,0x57,0x6B,0x5F,0x4F,0x63,0x57,0x47,
-       0x5B,0x4F,0x3F,0x53,0x47,0x37,0x4B,0x3F,0x2F,0x43,0x37,0x2B,0x3B,0x2F,0x23,0x33,
-       0x27,0x1F,0x2B,0x1F,0x17,0x23,0x17,0x0F,0x1B,0x13,0x0B,0x13,0x0B,0x07,0x0B,0x07,
-       0xFF,0xF3,0x1B,0xEF,0xDF,0x17,0xDB,0xCB,0x13,0xCB,0xB7,0x0F,0xBB,0xA7,0x0F,0xAB,
-       0x97,0x0B,0x9B,0x83,0x07,0x8B,0x73,0x07,0x7B,0x63,0x07,0x6B,0x53,0x00,0x5B,0x47,
-       0x00,0x4B,0x37,0x00,0x3B,0x2B,0x00,0x2B,0x1F,0x00,0x1B,0x0F,0x00,0x0B,0x07,0x00,
-       0x00,0x00,0xFF,0x0B,0x0B,0xEF,0x13,0x13,0xDF,0x1B,0x1B,0xCF,0x23,0x23,0xBF,0x2B,
-       0x2B,0xAF,0x2F,0x2F,0x9F,0x2F,0x2F,0x8F,0x2F,0x2F,0x7F,0x2F,0x2F,0x6F,0x2F,0x2F,
-       0x5F,0x2B,0x2B,0x4F,0x23,0x23,0x3F,0x1B,0x1B,0x2F,0x13,0x13,0x1F,0x0B,0x0B,0x0F,
-       0x2B,0x00,0x00,0x3B,0x00,0x00,0x4B,0x07,0x00,0x5F,0x07,0x00,0x6F,0x0F,0x00,0x7F,
-       0x17,0x07,0x93,0x1F,0x07,0xA3,0x27,0x0B,0xB7,0x33,0x0F,0xC3,0x4B,0x1B,0xCF,0x63,
-       0x2B,0xDB,0x7F,0x3B,0xE3,0x97,0x4F,0xE7,0xAB,0x5F,0xEF,0xBF,0x77,0xF7,0xD3,0x8B,
-       0xA7,0x7B,0x3B,0xB7,0x9B,0x37,0xC7,0xC3,0x37,0xE7,0xE3,0x57,0x00,0xFF,0x00,0xAB,
-       0xE7,0xFF,0xD7,0xFF,0xFF,0x67,0x00,0x00,0x8B,0x00,0x00,0xB3,0x00,0x00,0xD7,0x00,
-       0x00,0xFF,0x00,0x00,0xFF,0xF3,0x93,0xFF,0xF7,0xC7,0xFF,0xFF,0xFF,0x9F,0x5B,0x53,
-};
-*/
 
-byte *W_ConvertWAD3Texture(miptex_t *tex)
+qbyte *W_ConvertWAD3Texture(miptex_t *tex)
 {
-       byte *in, *data, *out, *pal;
-//     int palsize;
+       qbyte *in, *data, *out, *pal;
        int d, p;
-       in = (byte *)((int) tex + tex->offsets[0]);
-       data = out = qmalloc(tex->width * tex->height * 4);
+
+       in = (qbyte *)tex + tex->offsets[0];
+       data = out = (qbyte *)Mem_Alloc(tempmempool, tex->width * tex->height * 4);
        if (!data)
                return NULL;
        image_width = tex->width;
        image_height = tex->height;
        pal = in + (((image_width * image_height) * 85) >> 6);
-//     palsize = pal[1] * 0x100 + pal[0];
-//     if (palsize >= 256)
-//             palsize = 256;
        pal += 2;
        for (d = 0;d < image_width * image_height;d++)
        {
@@ -324,16 +237,14 @@ byte *W_ConvertWAD3Texture(miptex_t *tex)
        return data;
 }
 
-byte *W_GetTexture(char *name)
+qbyte *W_GetTexture(char *name)
 {
-//     int i, c, datasize;
-//     short colorcount;
-//     byte pal[256][3], *indata, *outdata, *data;
        char texname[17];
        int i, j;
-       QFile *file;
+       qfile_t *file;
        miptex_t *tex;
-       byte *data;
+       qbyte *data;
+
        texname[16] = 0;
        W_CleanupName (name, texname);
        for (i = 0;i < TEXWAD_MAXIMAGES;i++)
@@ -343,77 +254,22 @@ byte *W_GetTexture(char *name)
                        if (!strcmp(texname, texwadlump[i].name)) // found it
                        {
                                file = texwadlump[i].file;
-                               if (Qseek(file, texwadlump[i].position, SEEK_SET))
-                               {Con_Printf("W_GetTexture: corrupt WAD3 file");return NULL;}
+                               if (FS_Seek(file, texwadlump[i].position, SEEK_SET))
+                               {Con_Print("W_GetTexture: corrupt WAD3 file\n");return NULL;}
 
-                               tex = qmalloc(texwadlump[i].size);
+                               tex = (miptex_t *)Mem_Alloc(tempmempool, texwadlump[i].size);
                                if (!tex)
                                        return NULL;
-                               if (Qread(file, tex, texwadlump[i].size) < texwadlump[i].size)
-                               {Con_Printf("W_GetTexture: corrupt WAD3 file");return NULL;}
+                               if (FS_Read(file, tex, texwadlump[i].size) < texwadlump[i].size)
+                               {Con_Print("W_GetTexture: corrupt WAD3 file\n");return NULL;}
 
                                tex->width = LittleLong(tex->width);
                                tex->height = LittleLong(tex->height);
                                for (j = 0;j < MIPLEVELS;j++)
                                        tex->offsets[j] = LittleLong(tex->offsets[j]);
                                data = W_ConvertWAD3Texture(tex);
-                               qfree(tex);
+                               Mem_Free(tex);
                                return data;
-                               /*
-                               image_width = LittleLong(t.width);
-                               image_height = LittleLong(t.height);
-                               if (matchwidth && image_width != matchwidth)
-                                       continue;
-                               if (matchheight && image_height != matchheight)
-                                       continue;
-                               if (image_width & 15 || image_height & 15)
-                               {Con_Printf("W_GetTexture: corrupt WAD3 file");return NULL;}
-                               // allocate space for expanded image,
-                               // and load incoming image into upper area (overwritten as it expands)
-                               if (!(data = outdata = qmalloc(image_width*image_height*4)))
-                               {Con_Printf("W_GetTexture: out of memory");return NULL;}
-                               indata = outdata + image_width*image_height*3;
-                               datasize = image_width*image_height*85/64;
-                               // read the image data
-                               if (Qseek(file, texwadlump[i].position + sizeof(t), SEEK_SET))
-                               {Con_Printf("W_GetTexture: corrupt WAD3 file");return NULL;}
-                               if (Qread(file, indata, image_width*image_height) != image_width*image_height)
-                               {Con_Printf("W_GetTexture: corrupt WAD3 file");return NULL;}
-                               // read the number of colors used (always 256)
-                               if (Qseek(file, texwadlump[i].position + sizeof(t) + datasize, SEEK_SET))
-                               {Con_Printf("W_GetTexture: corrupt WAD3 file");return NULL;}
-                               if (Qread(file, &colorcount, 2) != 2)
-                               {Con_Printf("W_GetTexture: corrupt WAD3 file");return NULL;}
-                               if (texwadlump[i].size > (datasize + sizeof(t)))
-                               {
-                                       colorcount = LittleShort(colorcount);
-                                       // sanity checking
-                                       if (colorcount < 0) colorcount = 0;
-                                       if (colorcount > 256) colorcount = 256;
-                                       // read the palette
-       //                              Qseek(file, texwadlump[i].position + sizeof(t) + datasize + 2, SEEK_SET);
-                                       if (Qread(file, &pal, 3 * colorcount) != 3 * colorcount)
-                                       {Con_Printf("W_GetTexture: corrupt WAD3 file");return NULL;}
-                               }
-                               else
-                                       memcpy(&pal, hlpalette, 768);
-                               // expand the image to 32bit RGBA
-                               for (i = 0;i < image_width*image_height;i++)
-                               {
-                                       c = *indata++;
-                                       if (name[0] == '{' && c == 255)
-                                               outdata[0] = outdata[1] = outdata[2] = outdata[3] = 0;
-                                       else
-                                       {
-                                               outdata[0] = pal[c][0];
-                                               outdata[1] = pal[c][1];
-                                               outdata[2] = pal[c][2];
-                                               outdata[3] = 255;
-                                       }
-                                       outdata += 4;
-                               }
-                               return data;
-                               */
                        }
                }
                else
@@ -422,3 +278,4 @@ byte *W_GetTexture(char *name)
        image_width = image_height = 0;
        return NULL;
 }
+