wad.c File Reference

#include "quakedef.h"
#include "image.h"
#include "wad.h"

Include dependency graph for wad.c:

Go to the source code of this file.

Data Structures
struct	mwad_t
struct	wadstate_t

Functions
static void	W_CleanupName (const char *in, char *out)
unsigned char *	W_ConvertWAD3TextureBGRA (sizebuf_t *sb)
unsigned char *	W_GetLumpName (const char *name, fs_offset_t *returnfilesize)
unsigned char *	W_GetTextureBGRA (char *name)
void	W_LoadTextureWadFile (char *filename, int complain)
static void	W_SwapLumps (int numlumps, lumpinfo_t *lumps)
void	W_UnloadAll (void)

Variables
static wadstate_t	wad

Function Documentation

W_CleanupName()

static void W_CleanupName ( const char * in, char * out )

static

Definition at line 55 of file wad.c.

{
    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;
}

References i.

Referenced by W_GetLumpName(), W_GetTextureBGRA(), and W_SwapLumps().

W_ConvertWAD3TextureBGRA()

unsigned char * W_ConvertWAD3TextureBGRA

(

sizebuf_t *

sb

)

Definition at line 226 of file wad.c.

{
    unsigned char *in, *data, *out, *pal;
    int d, p;
    unsigned char name[16];
    unsigned int mipoffset[4];
 
    MSG_BeginReading(sb);
    MSG_ReadBytes(sb, 16, name);
    image_width = MSG_ReadLittleLong(sb);
    image_height = MSG_ReadLittleLong(sb);
    mipoffset[0] = MSG_ReadLittleLong(sb);
    mipoffset[1] = MSG_ReadLittleLong(sb); // should be mipoffset[0] + image_width*image_height
    mipoffset[2] = MSG_ReadLittleLong(sb); // should be mipoffset[1] + image_width*image_height/4
    mipoffset[3] = MSG_ReadLittleLong(sb); // should be mipoffset[2] + image_width*image_height/16
    pal = sb->data + mipoffset[3] + (image_width / 8 * image_height / 8) + 2;
 
    // bail if any data looks wrong
    if (image_width < 0
     || image_width > 4096
     || image_height < 0
     || image_height > 4096
     || mipoffset[0] != 40
     || mipoffset[1] != mipoffset[0] + image_width * image_height
     || mipoffset[2] != mipoffset[1] + image_width / 2 * image_height / 2
     || mipoffset[3] != mipoffset[2] + image_width / 4 * image_height / 4
     || (unsigned int)sb->cursize < (mipoffset[3] + image_width / 8 * image_height / 8 + 2 + 768))
        return NULL;
 
    in = (unsigned char *)sb->data + mipoffset[0];
    data = out = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
    if (!data)
        return NULL;
    for (d = 0;d < image_width * image_height;d++)
    {
        p = *in++;
        if (name[0] == '{' && p == 255)
            out[0] = out[1] = out[2] = out[3] = 0;
        else
        {
            p *= 3;
            out[2] = pal[p];
            out[1] = pal[p+1];
            out[0] = pal[p+2];
            out[3] = 255;
        }
        out += 4;
    }
    return data;
}

References sizebuf_t::cursize, data, sizebuf_t::data, image_height, image_width, Mem_Alloc, MSG_BeginReading(), MSG_ReadBytes(), MSG_ReadLittleLong(), name, NULL, and tempmempool.

Referenced by Mod_Q1BSP_LoadTextures(), and W_GetTextureBGRA().

W_GetLumpName()

unsigned char * W_GetLumpName	(	const char *	name,
		fs_offset_t *	returnfilesize )

Definition at line 114 of file wad.c.

{
    int i;
    fs_offset_t filesize;
    lumpinfo_t *lump;
    char clean[16];
    wadinfo_t *header;
    int infotableofs;
 
    W_CleanupName (name, clean);
 
    if (!wad.gfx_base)
    {
        if ((wad.gfx_base = FS_LoadFile ("gfx.wad", cls.permanentmempool, false, &filesize)))
        {
            if (memcmp(wad.gfx_base, "WAD2", 4))
            {
                Con_Print("gfx.wad doesn't have WAD2 id\n");
                Mem_Free(wad.gfx_base);
                wad.gfx_base = NULL;
            }
            else
            {
                header = (wadinfo_t *)wad.gfx_base;
                wad.gfx.numlumps = LittleLong(header->numlumps);
                infotableofs = LittleLong(header->infotableofs);
                wad.gfx.lumps = (lumpinfo_t *)(wad.gfx_base + infotableofs);
 
                // byteswap the gfx.wad lumps in place
                W_SwapLumps(wad.gfx.numlumps, wad.gfx.lumps);
            }
        }
    }
 
    for (lump = wad.gfx.lumps, i = 0;i < wad.gfx.numlumps;i++, lump++)
    {
        if (!strcmp(clean, lump->name))
        {
            if (returnfilesize)
                *returnfilesize = lump->size;
            return (wad.gfx_base + lump->filepos);
        }
    }
    return NULL;
}

References cls, Con_Print(), lumpinfo_t::filepos, FS_LoadFile(), wadstate_t::gfx, wadstate_t::gfx_base, i, wadinfo_t::infotableofs, LittleLong, mwad_t::lumps, Mem_Free, lumpinfo_t::name, name, NULL, mwad_t::numlumps, wadinfo_t::numlumps, client_static_t::permanentmempool, lumpinfo_t::size, W_CleanupName(), W_SwapLumps(), and wad.

Referenced by Image_GetStockPicSize(), and loadimagepixelsbgra().

W_GetTextureBGRA()

unsigned char * W_GetTextureBGRA

(

char *

name

)

Definition at line 277 of file wad.c.

{
    unsigned int i, k;
    sizebuf_t sb;
    unsigned char *data;
    mwad_t *w;
    char texname[17];
    size_t range;
 
    texname[16] = 0;
    W_CleanupName(name, texname);
    if (!wad.hlwads.mempool)
        Mem_ExpandableArray_NewArray(&wad.hlwads, cls.permanentmempool, sizeof(mwad_t), 16);
    range = Mem_ExpandableArray_IndexRange(&wad.hlwads);
    for (k = 0;k < range;k++)
    {
        w = (mwad_t *)Mem_ExpandableArray_RecordAtIndex(&wad.hlwads, k);
        if (!w)
            continue;
        for (i = 0;i < (unsigned int)w->numlumps;i++)
        {
            if (!strcmp(texname, w->lumps[i].name)) // found it
            {
                if (FS_Seek(w->file, w->lumps[i].filepos, SEEK_SET))
                {Con_Print("W_GetTexture: corrupt WAD3 file\n");return NULL;}
 
                MSG_InitReadBuffer(&sb, (unsigned char *)Mem_Alloc(tempmempool, w->lumps[i].disksize), w->lumps[i].disksize);
                if (!sb.data)
                    return NULL;
                if (FS_Read(w->file, sb.data, w->lumps[i].size) < w->lumps[i].disksize)
                {Con_Print("W_GetTexture: corrupt WAD3 file\n");return NULL;}
 
                data = W_ConvertWAD3TextureBGRA(&sb);
                Mem_Free(sb.data);
                return data;
            }
        }
    }
    image_width = image_height = 0;
    return NULL;
}

References cls, Con_Print(), data, sizebuf_t::data, FS_Read(), FS_Seek(), wadstate_t::hlwads, i, image_height, image_width, int(), Mem_Alloc, Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_NewArray(), Mem_ExpandableArray_RecordAtIndex(), Mem_Free, memexpandablearray_t::mempool, MSG_InitReadBuffer(), name, NULL, client_static_t::permanentmempool, tempmempool, w, W_CleanupName(), W_ConvertWAD3TextureBGRA(), and wad.

Referenced by Mod_Q1BSP_LoadTextures().

W_LoadTextureWadFile()

void W_LoadTextureWadFile	(	char *	filename,
		int	complain )

Definition at line 165 of file wad.c.

{
    wadinfo_t       header;
    int             infotableofs;
    qfile_t         *file;
    int             numlumps;
    mwad_t          *w;
 
    file = FS_OpenVirtualFile(filename, false);
    if (!file)
    {
        if (complain)
            Con_Printf(CON_ERROR "W_LoadTextureWadFile: couldn't find %s\n", filename);
        return;
    }
 
    if (FS_Read(file, &header, sizeof(wadinfo_t)) != sizeof(wadinfo_t))
    {Con_Print(CON_ERROR "W_LoadTextureWadFile: unable to read wad header\n");FS_Close(file);file = NULL;return;}
 
    if(memcmp(header.identification, "WAD3", 4))
    {Con_Printf(CON_ERROR "W_LoadTextureWadFile: Wad file %s doesn't have WAD3 id\n",filename);FS_Close(file);file = NULL;return;}
 
    numlumps = LittleLong(header.numlumps);
    if (numlumps < 1 || numlumps > 65536)
    {Con_Printf(CON_ERROR "W_LoadTextureWadFile: invalid number of lumps (%i)\n", numlumps);FS_Close(file);file = NULL;return;}
    infotableofs = LittleLong(header.infotableofs);
    if (FS_Seek (file, infotableofs, SEEK_SET))
    {Con_Print(CON_ERROR "W_LoadTextureWadFile: unable to seek to lump table\n");FS_Close(file);file = NULL;return;}
 
    if (!wad.hlwads.mempool)
        Mem_ExpandableArray_NewArray(&wad.hlwads, cls.permanentmempool, sizeof(mwad_t), 16);
    w = (mwad_t *) Mem_ExpandableArray_AllocRecord(&wad.hlwads);
    w->file = file;
    w->numlumps = numlumps;
    w->lumps = (lumpinfo_t *) Mem_Alloc(cls.permanentmempool, w->numlumps * sizeof(lumpinfo_t));
 
    if (!w->lumps)
    {
        Con_Print(CON_ERROR "W_LoadTextureWadFile: unable to allocate temporary memory for lump table\n");
        FS_Close(w->file);
        w->file = NULL;
        w->numlumps = 0;
        return;
    }
 
    if (FS_Read(file, w->lumps, sizeof(lumpinfo_t) * w->numlumps) != (fs_offset_t)sizeof(lumpinfo_t) * numlumps)
    {
        Con_Print(CON_ERROR "W_LoadTextureWadFile: unable to read lump table\n");
        FS_Close(w->file);
        w->file = NULL;
        w->numlumps = 0;
        Mem_Free(w->lumps);
        w->lumps = NULL;
        return;
    }
 
    W_SwapLumps(w->numlumps, w->lumps);
 
    // leaves the file open
}

References cls, CON_ERROR, Con_Print(), Con_Printf(), FS_Close(), FS_OpenVirtualFile(), FS_Read(), FS_Seek(), wadstate_t::hlwads, wadinfo_t::identification, wadinfo_t::infotableofs, LittleLong, Mem_Alloc, Mem_ExpandableArray_AllocRecord(), Mem_ExpandableArray_NewArray(), Mem_Free, memexpandablearray_t::mempool, NULL, wadinfo_t::numlumps, client_static_t::permanentmempool, w, W_SwapLumps(), and wad.

Referenced by Mod_Q1BSP_ParseWadsFromEntityLump().

W_SwapLumps()

static void W_SwapLumps ( int numlumps, lumpinfo_t * lumps )

static

Definition at line 75 of file wad.c.

{
    int i;
    for (i = 0;i < numlumps;i++)
    {
        lumps[i].filepos = LittleLong(lumps[i].filepos);
        lumps[i].disksize = LittleLong(lumps[i].disksize);
        lumps[i].size = LittleLong(lumps[i].size);
        W_CleanupName(lumps[i].name, lumps[i].name);
    }
}

References lumpinfo_t::disksize, lumpinfo_t::filepos, i, LittleLong, name, lumpinfo_t::size, size, and W_CleanupName().

Referenced by W_GetLumpName(), and W_LoadTextureWadFile().

W_UnloadAll()

void W_UnloadAll

(

void

)

Definition at line 87 of file wad.c.

{
    unsigned int i;
    mwad_t *w;
    // free gfx.wad if it is loaded
    if (wad.gfx_base)
        Mem_Free(wad.gfx_base);
    wad.gfx_base = NULL;
    // close all hlwad files and free their lumps data
    for (i = 0;i < Mem_ExpandableArray_IndexRange(&wad.hlwads);i++)
    {
        w = (mwad_t *) Mem_ExpandableArray_RecordAtIndex(&wad.hlwads, i);
        if (!w)
            continue;
        if (w->file)
            FS_Close(w->file);
        w->file = NULL;
        if (w->lumps)
            Mem_Free(w->lumps);
        w->lumps = NULL;
    }
    // free the hlwads array
    Mem_ExpandableArray_FreeArray(&wad.hlwads);
    // clear all state
    memset(&wad, 0, sizeof(wad));
}

References FS_Close(), wadstate_t::gfx_base, wadstate_t::hlwads, i, Mem_ExpandableArray_FreeArray(), Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), Mem_Free, NULL, w, and wad.

Referenced by FS_Rescan().

Variable Documentation

wad

wadstate_t wad

static

Definition at line 42 of file wad.c.

Referenced by W_GetLumpName(), W_GetTextureBGRA(), W_LoadTextureWadFile(), and W_UnloadAll().