wad.h File Reference

#include <stdint.h>

Include dependency graph for wad.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	lumpinfo_t
struct	qpic_t
struct	wadinfo_t

Macros
#define	CMP_LZSS   1
#define	CMP_NONE   0
#define	TYP_LABEL   1
#define	TYP_LUMPY   64
#define	TYP_MIPTEX   68
#define	TYP_NONE   0
#define	TYP_PALETTE   64
#define	TYP_QPIC   66
#define	TYP_QTEX   65
#define	TYP_SOUND   67

Functions
unsigned char *	W_ConvertWAD3TextureBGRA (struct sizebuf_s *sb)
unsigned char *	W_GetLumpName (const char *name, int64_t *returnfilesize)
unsigned char *	W_GetTextureBGRA (char *name)
void	W_LoadTextureWadFile (char *filename, int complain)
void	W_UnloadAll (void)

Macro Definition Documentation

CMP_LZSS

#define CMP_LZSS   1

Definition at line 33 of file wad.h.

CMP_NONE

#define CMP_NONE   0

Definition at line 32 of file wad.h.

TYP_LABEL

#define TYP_LABEL   1

Definition at line 36 of file wad.h.

TYP_LUMPY

#define TYP_LUMPY   64

Definition at line 38 of file wad.h.

TYP_MIPTEX

#define TYP_MIPTEX   68

Definition at line 43 of file wad.h.

TYP_NONE

#define TYP_NONE   0

Definition at line 35 of file wad.h.

TYP_PALETTE

#define TYP_PALETTE   64

Definition at line 39 of file wad.h.

TYP_QPIC

#define TYP_QPIC   66

Definition at line 41 of file wad.h.

TYP_QTEX

#define TYP_QTEX   65

Definition at line 40 of file wad.h.

TYP_SOUND

#define TYP_SOUND   67

Definition at line 42 of file wad.h.

Function Documentation

W_ConvertWAD3TextureBGRA()

unsigned char * W_ConvertWAD3TextureBGRA

(

struct sizebuf_s *

sb

)

W_GetLumpName()

unsigned char * W_GetLumpName	(	const char *	name,
		int64_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(), wadinfo_t::infotableofs, LittleLong, Mem_Free, lumpinfo_t::name, name, NULL, wadinfo_t::numlumps, 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(), image_height, image_width, int(), Mem_Alloc, Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_NewArray(), Mem_ExpandableArray_RecordAtIndex(), Mem_Free, MSG_InitReadBuffer(), name, NULL, 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(), wadinfo_t::identification, wadinfo_t::infotableofs, LittleLong, Mem_Alloc, Mem_ExpandableArray_AllocRecord(), Mem_ExpandableArray_NewArray(), Mem_Free, NULL, wadinfo_t::numlumps, w, W_SwapLumps(), and wad.

Referenced by Mod_Q1BSP_ParseWadsFromEntityLump().

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(), Mem_ExpandableArray_FreeArray(), Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), Mem_Free, NULL, w, and wad.

Referenced by FS_Rescan().