mirror of
https://github.com/OpenSourcedGames/Hexen.git
synced 2026-09-22 12:30:58 +02:00
initial import
This commit is contained in:
Alex Bevilacqua
@@ -0,0 +1,596 @@
|
||||
|
||||
//**************************************************************************
|
||||
//**
|
||||
//** w_wad.c : Heretic 2 : Raven Software, Corp.
|
||||
//**
|
||||
//** $RCSfile: w_wad.c,v $
|
||||
//** $Revision: 1.6 $
|
||||
//** $Date: 95/10/06 20:56:47 $
|
||||
//** $Author: cjr $
|
||||
//**
|
||||
//**************************************************************************
|
||||
|
||||
// HEADER FILES ------------------------------------------------------------
|
||||
|
||||
#ifdef NeXT
|
||||
#include <libc.h>
|
||||
#include <ctype.h>
|
||||
#else
|
||||
#include <malloc.h>
|
||||
#include <io.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/stat.h>
|
||||
#endif
|
||||
#include "h2def.h"
|
||||
|
||||
// MACROS ------------------------------------------------------------------
|
||||
|
||||
#ifdef NeXT
|
||||
// NeXT doesn't need a binary flag in open call
|
||||
#define O_BINARY 0
|
||||
#define strcmpi strcasecmp
|
||||
#endif
|
||||
|
||||
// TYPES -------------------------------------------------------------------
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char identification[4];
|
||||
int numlumps;
|
||||
int infotableofs;
|
||||
} wadinfo_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int filepos;
|
||||
int size;
|
||||
char name[8];
|
||||
} filelump_t;
|
||||
|
||||
// EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
|
||||
|
||||
// PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
|
||||
|
||||
// PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
|
||||
|
||||
// EXTERNAL DATA DECLARATIONS ----------------------------------------------
|
||||
|
||||
// PUBLIC DATA DEFINITIONS -------------------------------------------------
|
||||
|
||||
lumpinfo_t *lumpinfo;
|
||||
int numlumps;
|
||||
void **lumpcache;
|
||||
|
||||
// PRIVATE DATA DEFINITIONS ------------------------------------------------
|
||||
|
||||
static lumpinfo_t *PrimaryLumpInfo;
|
||||
static int PrimaryNumLumps;
|
||||
static void **PrimaryLumpCache;
|
||||
static lumpinfo_t *AuxiliaryLumpInfo;
|
||||
static int AuxiliaryNumLumps;
|
||||
static void **AuxiliaryLumpCache;
|
||||
static int AuxiliaryHandle = 0;
|
||||
boolean AuxiliaryOpened = false;
|
||||
|
||||
// CODE --------------------------------------------------------------------
|
||||
|
||||
#ifdef NeXT
|
||||
//==========================================================================
|
||||
//
|
||||
// strupr
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
void strupr(char *s)
|
||||
{
|
||||
while(*s)
|
||||
*s++ = toupper(*s);
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// filelength
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
int filelength(int handle)
|
||||
{
|
||||
struct stat fileinfo;
|
||||
|
||||
if(fstat(handle, &fileinfo) == -1)
|
||||
{
|
||||
I_Error("Error fstating");
|
||||
}
|
||||
return fileinfo.st_size;
|
||||
}
|
||||
#endif
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_AddFile
|
||||
//
|
||||
// Files with a .wad extension are wadlink files with multiple lumps,
|
||||
// other files are single lumps with the base filename for the lump name.
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
void W_AddFile(char *filename)
|
||||
{
|
||||
wadinfo_t header;
|
||||
lumpinfo_t *lump_p;
|
||||
unsigned i;
|
||||
int handle, length;
|
||||
int startlump;
|
||||
filelump_t *fileinfo, singleinfo;
|
||||
filelump_t *freeFileInfo;
|
||||
|
||||
if((handle = open(filename, O_RDONLY|O_BINARY)) == -1)
|
||||
{ // Didn't find file
|
||||
return;
|
||||
}
|
||||
startlump = numlumps;
|
||||
if(strcmpi(filename+strlen(filename)-3, "wad"))
|
||||
{ // Single lump file
|
||||
fileinfo = &singleinfo;
|
||||
freeFileInfo = NULL;
|
||||
singleinfo.filepos = 0;
|
||||
singleinfo.size = LONG(filelength(handle));
|
||||
M_ExtractFileBase(filename, singleinfo.name);
|
||||
numlumps++;
|
||||
}
|
||||
else
|
||||
{ // WAD file
|
||||
read(handle, &header, sizeof(header));
|
||||
if(strncmp(header.identification, "IWAD", 4))
|
||||
{
|
||||
if(strncmp(header.identification, "PWAD", 4))
|
||||
{ // Bad file id
|
||||
I_Error("Wad file %s doesn't have IWAD or PWAD id\n",
|
||||
filename);
|
||||
}
|
||||
}
|
||||
header.numlumps = LONG(header.numlumps);
|
||||
header.infotableofs = LONG(header.infotableofs);
|
||||
length = header.numlumps*sizeof(filelump_t);
|
||||
// fileinfo = alloca(length);
|
||||
if(!(fileinfo = malloc(length)))
|
||||
{
|
||||
I_Error("W_AddFile: fileinfo malloc failed\n");
|
||||
}
|
||||
freeFileInfo = fileinfo;
|
||||
lseek(handle, header.infotableofs, SEEK_SET);
|
||||
read(handle, fileinfo, length);
|
||||
numlumps += header.numlumps;
|
||||
}
|
||||
|
||||
// Fill in lumpinfo
|
||||
lumpinfo = realloc(lumpinfo, numlumps*sizeof(lumpinfo_t));
|
||||
if(!lumpinfo)
|
||||
{
|
||||
I_Error("Couldn't realloc lumpinfo");
|
||||
}
|
||||
lump_p = &lumpinfo[startlump];
|
||||
for(i = startlump; i < numlumps; i++, lump_p++, fileinfo++)
|
||||
{
|
||||
lump_p->handle = handle;
|
||||
lump_p->position = LONG(fileinfo->filepos);
|
||||
lump_p->size = LONG(fileinfo->size);
|
||||
strncpy(lump_p->name, fileinfo->name, 8);
|
||||
}
|
||||
if(freeFileInfo)
|
||||
{
|
||||
free(freeFileInfo);
|
||||
}
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_InitMultipleFiles
|
||||
//
|
||||
// Pass a null terminated list of files to use. All files are optional,
|
||||
// but at least one file must be found. Lump names can appear multiple
|
||||
// times. The name searcher looks backwards, so a later file can
|
||||
// override an earlier one.
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
void W_InitMultipleFiles(char **filenames)
|
||||
{
|
||||
int size;
|
||||
|
||||
// Open all the files, load headers, and count lumps
|
||||
numlumps = 0;
|
||||
lumpinfo = malloc(1); // Will be realloced as lumps are added
|
||||
|
||||
for(; *filenames; filenames++)
|
||||
{
|
||||
W_AddFile(*filenames);
|
||||
}
|
||||
if(!numlumps)
|
||||
{
|
||||
I_Error("W_InitMultipleFiles: no files found");
|
||||
}
|
||||
|
||||
// Set up caching
|
||||
size = numlumps*sizeof(*lumpcache);
|
||||
lumpcache = malloc(size);
|
||||
if(!lumpcache)
|
||||
{
|
||||
I_Error("Couldn't allocate lumpcache");
|
||||
}
|
||||
memset(lumpcache, 0, size);
|
||||
|
||||
PrimaryLumpInfo = lumpinfo;
|
||||
PrimaryLumpCache = lumpcache;
|
||||
PrimaryNumLumps = numlumps;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_InitFile
|
||||
//
|
||||
// Initialize the primary from a single file.
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
void W_InitFile(char *filename)
|
||||
{
|
||||
char *names[2];
|
||||
|
||||
names[0] = filename;
|
||||
names[1] = NULL;
|
||||
W_InitMultipleFiles(names);
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_OpenAuxiliary
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
void W_OpenAuxiliary(char *filename)
|
||||
{
|
||||
int i;
|
||||
int size;
|
||||
wadinfo_t header;
|
||||
int handle;
|
||||
int length;
|
||||
filelump_t *fileinfo;
|
||||
filelump_t *sourceLump;
|
||||
lumpinfo_t *destLump;
|
||||
|
||||
if(AuxiliaryOpened)
|
||||
{
|
||||
W_CloseAuxiliary();
|
||||
}
|
||||
if((handle = open(filename, O_RDONLY|O_BINARY)) == -1)
|
||||
{
|
||||
I_Error("W_OpenAuxiliary: %s not found.", filename);
|
||||
return;
|
||||
}
|
||||
AuxiliaryHandle = handle;
|
||||
read(handle, &header, sizeof(header));
|
||||
if(strncmp(header.identification, "IWAD", 4))
|
||||
{
|
||||
if(strncmp(header.identification, "PWAD", 4))
|
||||
{ // Bad file id
|
||||
I_Error("Wad file %s doesn't have IWAD or PWAD id\n",
|
||||
filename);
|
||||
}
|
||||
}
|
||||
header.numlumps = LONG(header.numlumps);
|
||||
header.infotableofs = LONG(header.infotableofs);
|
||||
length = header.numlumps*sizeof(filelump_t);
|
||||
fileinfo = Z_Malloc(length, PU_STATIC, 0);
|
||||
lseek(handle, header.infotableofs, SEEK_SET);
|
||||
read(handle, fileinfo, length);
|
||||
numlumps = header.numlumps;
|
||||
|
||||
// Init the auxiliary lumpinfo array
|
||||
lumpinfo = Z_Malloc(numlumps*sizeof(lumpinfo_t), PU_STATIC, 0);
|
||||
sourceLump = fileinfo;
|
||||
destLump = lumpinfo;
|
||||
for(i = 0; i < numlumps; i++, destLump++, sourceLump++)
|
||||
{
|
||||
destLump->handle = handle;
|
||||
destLump->position = LONG(sourceLump->filepos);
|
||||
destLump->size = LONG(sourceLump->size);
|
||||
strncpy(destLump->name, sourceLump->name, 8);
|
||||
}
|
||||
Z_Free(fileinfo);
|
||||
|
||||
// Allocate the auxiliary lumpcache array
|
||||
size = numlumps*sizeof(*lumpcache);
|
||||
lumpcache = Z_Malloc(size, PU_STATIC, 0);
|
||||
memset(lumpcache, 0, size);
|
||||
|
||||
AuxiliaryLumpInfo = lumpinfo;
|
||||
AuxiliaryLumpCache = lumpcache;
|
||||
AuxiliaryNumLumps = numlumps;
|
||||
AuxiliaryOpened = true;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_CloseAuxiliary
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
void W_CloseAuxiliary(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
if(AuxiliaryOpened)
|
||||
{
|
||||
W_UseAuxiliary();
|
||||
for(i = 0; i < numlumps; i++)
|
||||
{
|
||||
if(lumpcache[i])
|
||||
{
|
||||
Z_Free(lumpcache[i]);
|
||||
}
|
||||
}
|
||||
Z_Free(AuxiliaryLumpInfo);
|
||||
Z_Free(AuxiliaryLumpCache);
|
||||
W_CloseAuxiliaryFile();
|
||||
AuxiliaryOpened = false;
|
||||
}
|
||||
W_UsePrimary();
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_CloseAuxiliaryFile
|
||||
//
|
||||
// WARNING: W_CloseAuxiliary() must be called before any further
|
||||
// auxiliary lump processing.
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
void W_CloseAuxiliaryFile(void)
|
||||
{
|
||||
if(AuxiliaryHandle)
|
||||
{
|
||||
close(AuxiliaryHandle);
|
||||
AuxiliaryHandle = 0;
|
||||
}
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_UsePrimary
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
void W_UsePrimary(void)
|
||||
{
|
||||
lumpinfo = PrimaryLumpInfo;
|
||||
numlumps = PrimaryNumLumps;
|
||||
lumpcache = PrimaryLumpCache;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_UseAuxiliary
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
void W_UseAuxiliary(void)
|
||||
{
|
||||
if(AuxiliaryOpened == false)
|
||||
{
|
||||
I_Error("W_UseAuxiliary: WAD not opened.");
|
||||
}
|
||||
lumpinfo = AuxiliaryLumpInfo;
|
||||
numlumps = AuxiliaryNumLumps;
|
||||
lumpcache = AuxiliaryLumpCache;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_NumLumps
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
int W_NumLumps(void)
|
||||
{
|
||||
return numlumps;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_CheckNumForName
|
||||
//
|
||||
// Returns -1 if name not found.
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
int W_CheckNumForName(char *name)
|
||||
{
|
||||
char name8[9];
|
||||
int v1, v2;
|
||||
lumpinfo_t *lump_p;
|
||||
|
||||
// Make the name into two integers for easy compares
|
||||
strncpy(name8, name, 8);
|
||||
name8[8] = 0; // in case the name was a full 8 chars
|
||||
strupr(name8); // case insensitive
|
||||
v1 = *(int *)name8;
|
||||
v2 = *(int *)&name8[4];
|
||||
|
||||
// Scan backwards so patch lump files take precedence
|
||||
lump_p = lumpinfo+numlumps;
|
||||
while(lump_p-- != lumpinfo)
|
||||
{
|
||||
if(*(int *)lump_p->name == v1 && *(int *)&lump_p->name[4] == v2)
|
||||
{
|
||||
return lump_p-lumpinfo;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_GetNumForName
|
||||
//
|
||||
// Calls W_CheckNumForName, but bombs out if not found.
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
int W_GetNumForName (char *name)
|
||||
{
|
||||
int i;
|
||||
|
||||
i = W_CheckNumForName(name);
|
||||
if(i != -1)
|
||||
{
|
||||
return i;
|
||||
}
|
||||
I_Error("W_GetNumForName: %s not found!", name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_LumpLength
|
||||
//
|
||||
// Returns the buffer size needed to load the given lump.
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
int W_LumpLength(int lump)
|
||||
{
|
||||
if(lump >= numlumps)
|
||||
{
|
||||
I_Error("W_LumpLength: %i >= numlumps", lump);
|
||||
}
|
||||
return lumpinfo[lump].size;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_ReadLump
|
||||
//
|
||||
// Loads the lump into the given buffer, which must be >= W_LumpLength().
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
void W_ReadLump(int lump, void *dest)
|
||||
{
|
||||
int c;
|
||||
lumpinfo_t *l;
|
||||
|
||||
if(lump >= numlumps)
|
||||
{
|
||||
I_Error("W_ReadLump: %i >= numlumps", lump);
|
||||
}
|
||||
l = lumpinfo+lump;
|
||||
//I_BeginRead();
|
||||
lseek(l->handle, l->position, SEEK_SET);
|
||||
c = read(l->handle, dest, l->size);
|
||||
if(c < l->size)
|
||||
{
|
||||
I_Error("W_ReadLump: only read %i of %i on lump %i",
|
||||
c, l->size, lump);
|
||||
}
|
||||
//I_EndRead();
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_CacheLumpNum
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
void *W_CacheLumpNum(int lump, int tag)
|
||||
{
|
||||
byte *ptr;
|
||||
|
||||
if((unsigned)lump >= numlumps)
|
||||
{
|
||||
I_Error("W_CacheLumpNum: %i >= numlumps", lump);
|
||||
}
|
||||
if(!lumpcache[lump])
|
||||
{ // Need to read the lump in
|
||||
ptr = Z_Malloc(W_LumpLength(lump), tag, &lumpcache[lump]);
|
||||
W_ReadLump(lump, lumpcache[lump]);
|
||||
}
|
||||
else
|
||||
{
|
||||
Z_ChangeTag(lumpcache[lump], tag);
|
||||
}
|
||||
return lumpcache[lump];
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_CacheLumpName
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
void *W_CacheLumpName(char *name, int tag)
|
||||
{
|
||||
return W_CacheLumpNum(W_GetNumForName(name), tag);
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// W_Profile
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
// Ripped out for Heretic
|
||||
/*
|
||||
int info[2500][10];
|
||||
int profilecount;
|
||||
|
||||
void W_Profile (void)
|
||||
{
|
||||
int i;
|
||||
memblock_t *block;
|
||||
void *ptr;
|
||||
char ch;
|
||||
FILE *f;
|
||||
int j;
|
||||
char name[9];
|
||||
|
||||
|
||||
for (i=0 ; i<numlumps ; i++)
|
||||
{
|
||||
ptr = lumpcache[i];
|
||||
if (!ptr)
|
||||
{
|
||||
ch = ' ';
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
block = (memblock_t *) ( (byte *)ptr - sizeof(memblock_t));
|
||||
if (block->tag < PU_PURGELEVEL)
|
||||
ch = 'S';
|
||||
else
|
||||
ch = 'P';
|
||||
}
|
||||
info[i][profilecount] = ch;
|
||||
}
|
||||
profilecount++;
|
||||
|
||||
f = fopen ("waddump.txt","w");
|
||||
name[8] = 0;
|
||||
for (i=0 ; i<numlumps ; i++)
|
||||
{
|
||||
memcpy (name,lumpinfo[i].name,8);
|
||||
for (j=0 ; j<8 ; j++)
|
||||
if (!name[j])
|
||||
break;
|
||||
for ( ; j<8 ; j++)
|
||||
name[j] = ' ';
|
||||
fprintf (f,"%s ",name);
|
||||
for (j=0 ; j<profilecount ; j++)
|
||||
fprintf (f," %c",info[i][j]);
|
||||
fprintf (f,"\n");
|
||||
}
|
||||
fclose (f);
|
||||
}
|
||||
*/
|
||||
Reference in New Issue
Block a user