521 lines
11 KiB
C
521 lines
11 KiB
C
/***
|
|
*
|
|
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
|
*
|
|
* This product contains software technology licensed from Id
|
|
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
|
* All Rights Reserved.
|
|
*
|
|
****/
|
|
|
|
|
|
#include "csg.h"
|
|
|
|
typedef struct
|
|
{
|
|
char identification[4]; // should be WAD2/WAD3
|
|
int numlumps;
|
|
int infotableofs;
|
|
} wadinfo_t;
|
|
|
|
|
|
typedef struct
|
|
{
|
|
int filepos;
|
|
int disksize;
|
|
int size; // uncompressed
|
|
char type;
|
|
char compression;
|
|
char pad1, pad2;
|
|
char name[16]; // must be null terminated
|
|
|
|
int iTexFile; // index of the wad this texture is located in
|
|
|
|
} lumpinfo_t;
|
|
|
|
int nummiptex;
|
|
lumpinfo_t miptex[MAX_MAP_TEXTURES];
|
|
|
|
int nTexLumps = 0;
|
|
lumpinfo_t *lumpinfo = NULL;
|
|
|
|
int nTexFiles = 0;
|
|
FILE *texfiles[128];
|
|
|
|
int nWadInclude;
|
|
char *pszWadInclude[128];
|
|
qboolean wadInclude[128]; // include the textures from this WAD in the BSP
|
|
|
|
void CleanupName (char *in, char *out)
|
|
{
|
|
int i;
|
|
|
|
for (i=0 ; i< 16 ; i++ )
|
|
{
|
|
if (!in[i])
|
|
break;
|
|
|
|
out[i] = toupper(in[i]);
|
|
}
|
|
|
|
for ( ; i< 16 ; i++ )
|
|
out[i] = 0;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
lump_sorters
|
|
=================
|
|
*/
|
|
|
|
int
|
|
lump_sorter_by_wad_and_name( const void *lump1, const void *lump2 )
|
|
{
|
|
lumpinfo_t *plump1 = (lumpinfo_t *)lump1;
|
|
lumpinfo_t *plump2 = (lumpinfo_t *)lump2;
|
|
if ( plump1->iTexFile == plump2->iTexFile )
|
|
return strcmp( plump1->name, plump2->name );
|
|
else
|
|
return plump1->iTexFile - plump2->iTexFile;
|
|
}
|
|
|
|
int
|
|
lump_sorter_by_name( const void *lump1, const void *lump2 )
|
|
{
|
|
lumpinfo_t *plump1 = (lumpinfo_t *)lump1;
|
|
lumpinfo_t *plump2 = (lumpinfo_t *)lump2;
|
|
return strcmp( plump1->name, plump2->name );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
TEX_InitFromWad
|
|
=================
|
|
*/
|
|
qboolean TEX_InitFromWad (char *path)
|
|
{
|
|
int i;
|
|
wadinfo_t wadinfo;
|
|
char szTmpPath[512];
|
|
char *pszWadFile;
|
|
|
|
strcpy(szTmpPath, path);
|
|
|
|
// temporary kludge so we don't have to deal with no occurances of a semicolon
|
|
// in the path name ..
|
|
if(strchr(szTmpPath, ';') == NULL)
|
|
strcat(szTmpPath, ";");
|
|
|
|
pszWadFile = strtok(szTmpPath, ";");
|
|
|
|
while(pszWadFile)
|
|
{
|
|
FILE *texfile; // temporary used in this loop
|
|
|
|
texfiles[nTexFiles] = fopen(pszWadFile, "rb");
|
|
if (!texfiles[nTexFiles])
|
|
{
|
|
// maybe this wad file has a hard code drive
|
|
if (pszWadFile[1] == ':')
|
|
{
|
|
pszWadFile += 2; // skip past the file
|
|
texfiles[nTexFiles] = fopen (pszWadFile, "rb");
|
|
}
|
|
}
|
|
|
|
|
|
if (!texfiles[nTexFiles])
|
|
{
|
|
printf ("WARNING: couldn't open %s\n", pszWadFile);
|
|
return false;
|
|
}
|
|
|
|
++nTexFiles;
|
|
|
|
// look and see if we're supposed to include the textures from this WAD in the bsp.
|
|
for (i = 0; i < nWadInclude; i++)
|
|
{
|
|
if (stricmp( pszWadInclude[i], pszWadFile ) == 0)
|
|
{
|
|
wadInclude[nTexFiles-1] = true;
|
|
}
|
|
}
|
|
|
|
// temp assignment to make things cleaner:
|
|
texfile = texfiles[nTexFiles-1];
|
|
|
|
printf ("Using WAD File: %s\n", pszWadFile);
|
|
|
|
SafeRead(texfile, &wadinfo, sizeof(wadinfo));
|
|
if (strncmp (wadinfo.identification, "WAD2", 4) &&
|
|
strncmp (wadinfo.identification, "WAD3", 4))
|
|
Error ("TEX_InitFromWad: %s isn't a wadfile",pszWadFile);
|
|
wadinfo.numlumps = LittleLong(wadinfo.numlumps);
|
|
wadinfo.infotableofs = LittleLong(wadinfo.infotableofs);
|
|
fseek (texfile, wadinfo.infotableofs, SEEK_SET);
|
|
lumpinfo = realloc(lumpinfo, (nTexLumps + wadinfo.numlumps)
|
|
* sizeof(lumpinfo_t));
|
|
|
|
for(i = 0; i < wadinfo.numlumps; i++)
|
|
{
|
|
SafeRead(texfile, &lumpinfo[nTexLumps], sizeof(lumpinfo_t) -
|
|
sizeof(int)); // iTexFile is NOT read from file
|
|
CleanupName (lumpinfo[nTexLumps].name, lumpinfo[nTexLumps].name);
|
|
lumpinfo[nTexLumps].filepos = LittleLong(lumpinfo[nTexLumps].filepos);
|
|
lumpinfo[nTexLumps].disksize = LittleLong(lumpinfo[nTexLumps].disksize);
|
|
lumpinfo[nTexLumps].iTexFile = nTexFiles-1;
|
|
|
|
++nTexLumps;
|
|
}
|
|
|
|
// next wad file
|
|
pszWadFile = strtok(NULL, ";");
|
|
}
|
|
|
|
qsort( (void *)lumpinfo, (size_t)nTexLumps, sizeof(lumpinfo[0]), lump_sorter_by_name );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
FindTexture
|
|
==================
|
|
*/
|
|
|
|
lumpinfo_t *
|
|
FindTexture (lumpinfo_t *source )
|
|
{
|
|
lumpinfo_t *found = NULL;
|
|
if ( !( found = bsearch( source, (void *)lumpinfo, (size_t)nTexLumps, sizeof(lumpinfo[0]), lump_sorter_by_name ) ) )
|
|
printf ("WARNING: texture %s not found in BSP's wad file list!\n", source->name);
|
|
|
|
return found;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
LoadLump
|
|
==================
|
|
*/
|
|
int LoadLump (lumpinfo_t *source, byte *dest, int *texsize)
|
|
{
|
|
*texsize = 0;
|
|
if ( source->filepos )
|
|
{
|
|
fseek (texfiles[source->iTexFile], source->filepos, SEEK_SET);
|
|
*texsize = source->disksize;
|
|
|
|
// Should we just load the texture header w/o the palette & bitmap?
|
|
if ( wadtextures && !wadInclude[source->iTexFile] )
|
|
{
|
|
// Just read the miptex header and zero out the data offsets.
|
|
// We will load the entire texture from the WAD at engine runtime
|
|
int i;
|
|
miptex_t *miptex = (miptex_t *)dest;
|
|
SafeRead (texfiles[source->iTexFile], dest, sizeof(miptex_t) );
|
|
for( i=0; i<MIPLEVELS; i++ )
|
|
miptex->offsets[i] = 0;
|
|
return sizeof(miptex_t);
|
|
}
|
|
else
|
|
{
|
|
// Load the entire texture here so the BSP contains the texture
|
|
SafeRead (texfiles[source->iTexFile], dest, source->disksize );
|
|
return source->disksize;
|
|
}
|
|
}
|
|
|
|
printf ("WARNING: texture %s not found in BSP's wad file list!\n", source->name);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
AddAnimatingTextures
|
|
==================
|
|
*/
|
|
void AddAnimatingTextures (void)
|
|
{
|
|
int base;
|
|
int i, j, k;
|
|
char name[32];
|
|
|
|
base = nummiptex;
|
|
|
|
for (i=0 ; i<base ; i++)
|
|
{
|
|
if (miptex[i].name[0] != '+' && miptex[i].name[0] != '-')
|
|
continue;
|
|
strcpy (name, miptex[i].name);
|
|
|
|
for (j=0 ; j<20 ; j++)
|
|
{
|
|
if (j < 10)
|
|
name[1] = '0'+j;
|
|
else
|
|
name[1] = 'A'+j-10; // alternate animation
|
|
|
|
|
|
// see if this name exists in the wadfile
|
|
for (k=0 ; k < nTexLumps; k++)
|
|
if (!strcmp(name, lumpinfo[k].name))
|
|
{
|
|
FindMiptex (name); // add to the miptex list
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( nummiptex - base )
|
|
printf ("added %i additional animating textures.\n", nummiptex - base);
|
|
}
|
|
|
|
/*
|
|
==================
|
|
WriteMiptex
|
|
==================
|
|
*/
|
|
void WriteMiptex(void)
|
|
{
|
|
int i, len, texsize, totaltexsize = 0;
|
|
byte *data;
|
|
dmiptexlump_t *l;
|
|
char *path;
|
|
char fullpath[1024];
|
|
int start;
|
|
|
|
texdatasize = 0;
|
|
|
|
path = ValueForKey (&entities[0], "_wad");
|
|
if (!path || !path[0])
|
|
{
|
|
path = ValueForKey (&entities[0], "wad");
|
|
if (!path || !path[0])
|
|
{
|
|
printf ("WARNING: no wadfile specified\n");
|
|
return;
|
|
}
|
|
}
|
|
|
|
strcpy(fullpath, path);
|
|
|
|
start = GetTickCount();
|
|
{
|
|
if (!TEX_InitFromWad (fullpath))
|
|
return;
|
|
AddAnimatingTextures ();
|
|
}
|
|
qprintf( "TEX_InitFromWad & AddAnimatingTextures elapsed time = %ldms\n", GetTickCount()-start );
|
|
|
|
start = GetTickCount();
|
|
{
|
|
for (i=0; i<nummiptex; i++ )
|
|
{
|
|
lumpinfo_t *found;
|
|
if ( found = FindTexture( miptex + i ) )
|
|
miptex[i] = *found;
|
|
else
|
|
{
|
|
miptex[i].iTexFile = miptex[i].filepos = miptex[i].disksize = 0;
|
|
}
|
|
}
|
|
}
|
|
qprintf( "FindTextures elapsed time = %ldms\n", GetTickCount()-start );
|
|
|
|
start = GetTickCount();
|
|
{
|
|
int final_miptex, i;
|
|
texinfo_t *tx = texinfo;
|
|
|
|
// Sort them FIRST by wadfile and THEN by name for most efficient loading in the engine.
|
|
qsort( (void *)miptex, (size_t)nummiptex, sizeof(miptex[0]), lump_sorter_by_wad_and_name );
|
|
|
|
// Sleazy Hack 104 Pt 2 - After sorting the miptex array, reset the texinfos to point to the right miptexs
|
|
for(i=0; i<numtexinfo; i++, tx++)
|
|
{
|
|
char *miptex_name = (char *)tx->miptex;
|
|
tx->miptex = FindMiptex( miptex_name );
|
|
|
|
// Free up the originally strdup()'ed miptex_name
|
|
free( miptex_name );
|
|
}
|
|
}
|
|
qprintf( "qsort(miptex) elapsed time = %ldms\n", GetTickCount()-start );
|
|
|
|
start = GetTickCount();
|
|
{
|
|
// Now setup to get the miptex data (or just the headers if using -wadtextures) from the wadfile
|
|
l = (dmiptexlump_t *)dtexdata;
|
|
data = (byte *)&l->dataofs[nummiptex];
|
|
l->nummiptex = nummiptex;
|
|
for (i=0 ; i<nummiptex ; i++)
|
|
{
|
|
l->dataofs[i] = data - (byte *)l;
|
|
len = LoadLump (miptex+i, data, &texsize);
|
|
if (data + len - dtexdata >= MAX_MAP_MIPTEX)
|
|
Error ("Textures exceeded MAX_MAP_MIPTEX");
|
|
if (!len)
|
|
l->dataofs[i] = -1; // didn't find the texture
|
|
else
|
|
{
|
|
totaltexsize += texsize;
|
|
if ( totaltexsize > MAX_MAP_MIPTEX )
|
|
Error("Textures exceeded MAX_MAP_MIPTEX" );
|
|
}
|
|
data += len;
|
|
}
|
|
texdatasize = data - dtexdata;
|
|
}
|
|
qprintf( "LoadLump() elapsed time = %ldms\n", GetTickCount()-start );
|
|
}
|
|
|
|
//==========================================================================
|
|
|
|
|
|
int FindMiptex (char *name)
|
|
{
|
|
int i;
|
|
|
|
ThreadLock ();
|
|
for (i=0 ; i<nummiptex ; i++)
|
|
if (!Q_strcasecmp (name, miptex[i].name))
|
|
{
|
|
ThreadUnlock ();
|
|
return i;
|
|
}
|
|
if (nummiptex == MAX_MAP_TEXTURES)
|
|
Error ("Exceeded MAX_MAP_TEXTURES");
|
|
strcpy (miptex[i].name, name);
|
|
nummiptex++;
|
|
ThreadUnlock ();
|
|
return i;
|
|
}
|
|
|
|
int TexinfoForBrushTexture (plane_t *plane, brush_texture_t *bt, vec3_t origin)
|
|
{
|
|
vec3_t vecs[2];
|
|
int sv, tv;
|
|
vec_t ang, sinv, cosv;
|
|
vec_t ns, nt;
|
|
texinfo_t tx, *tc;
|
|
int i, j, k;
|
|
|
|
memset (&tx, 0, sizeof(tx));
|
|
tx.miptex = FindMiptex (bt->name);
|
|
// Note: FindMiptex() still needs to be called here to add it to the global miptex array
|
|
|
|
// Very Sleazy Hack 104 - since the tx.miptex index will be bogus after we sort the miptex array later
|
|
// Put the string name of the miptex in this "index" until after we are done sorting it in WriteMiptex().
|
|
tx.miptex = (int)strdup(bt->name);
|
|
|
|
// set the special flag
|
|
if (bt->name[0] == '*'
|
|
|| !Q_strncasecmp (bt->name, "sky",3)
|
|
|| !Q_strncasecmp (bt->name, "clip",4)
|
|
|| !Q_strncasecmp (bt->name, "origin",6)
|
|
|| !Q_strncasecmp (bt->name, "aaatrigger",10))
|
|
tx.flags |= TEX_SPECIAL;
|
|
|
|
if (g_nMapFileVersion < 220)
|
|
{
|
|
TextureAxisFromPlane(plane, vecs[0], vecs[1]);
|
|
}
|
|
|
|
if (!bt->scale[0])
|
|
bt->scale[0] = 1;
|
|
if (!bt->scale[1])
|
|
bt->scale[1] = 1;
|
|
|
|
if (g_nMapFileVersion < 220)
|
|
{
|
|
// rotate axis
|
|
if (bt->rotate == 0)
|
|
{ sinv = 0 ; cosv = 1; }
|
|
else if (bt->rotate == 90)
|
|
{ sinv = 1 ; cosv = 0; }
|
|
else if (bt->rotate == 180)
|
|
{ sinv = 0 ; cosv = -1; }
|
|
else if (bt->rotate == 270)
|
|
{ sinv = -1 ; cosv = 0; }
|
|
else
|
|
{
|
|
ang = bt->rotate / 180 * Q_PI;
|
|
sinv = sin(ang);
|
|
cosv = cos(ang);
|
|
}
|
|
|
|
if (vecs[0][0])
|
|
sv = 0;
|
|
else if (vecs[0][1])
|
|
sv = 1;
|
|
else
|
|
sv = 2;
|
|
|
|
if (vecs[1][0])
|
|
tv = 0;
|
|
else if (vecs[1][1])
|
|
tv = 1;
|
|
else
|
|
tv = 2;
|
|
|
|
for (i=0 ; i<2 ; i++)
|
|
{
|
|
ns = cosv * vecs[i][sv] - sinv * vecs[i][tv];
|
|
nt = sinv * vecs[i][sv] + cosv * vecs[i][tv];
|
|
vecs[i][sv] = ns;
|
|
vecs[i][tv] = nt;
|
|
}
|
|
|
|
for (i=0 ; i<2 ; i++)
|
|
for (j=0 ; j<3 ; j++)
|
|
tx.vecs[i][j] = vecs[i][j] / bt->scale[i];
|
|
}
|
|
else
|
|
{
|
|
tx.vecs[0][0] = bt->UAxis[0] / bt->scale[0];
|
|
tx.vecs[0][1] = bt->UAxis[1] / bt->scale[0];
|
|
tx.vecs[0][2] = bt->UAxis[2] / bt->scale[0];
|
|
|
|
tx.vecs[1][0] = bt->VAxis[0] / bt->scale[1];
|
|
tx.vecs[1][1] = bt->VAxis[1] / bt->scale[1];
|
|
tx.vecs[1][2] = bt->VAxis[2] / bt->scale[1];
|
|
}
|
|
|
|
tx.vecs[0][3] = bt->shift[0] + DotProduct( origin, tx.vecs[0] );
|
|
tx.vecs[1][3] = bt->shift[1] + DotProduct( origin, tx.vecs[1] );
|
|
|
|
//
|
|
// find the texinfo
|
|
//
|
|
ThreadLock ();
|
|
tc = texinfo;
|
|
for (i=0 ; i<numtexinfo ; i++, tc++)
|
|
{
|
|
// Sleazy hack 104, Pt 3 - Use strcmp on names to avoid dups
|
|
if ( strcmp( (char *)(tc->miptex), (char *)(tx.miptex)) != 0 )
|
|
continue;
|
|
if (tc->flags != tx.flags)
|
|
continue;
|
|
for (j=0 ; j<2 ; j++)
|
|
{
|
|
for (k=0 ; k<4 ; k++)
|
|
{
|
|
if (tc->vecs[j][k] != tx.vecs[j][k])
|
|
goto skip;
|
|
}
|
|
}
|
|
ThreadUnlock ();
|
|
return i;
|
|
skip:;
|
|
}
|
|
if (numtexinfo == MAX_MAP_TEXINFO)
|
|
Error ("Exceeded MAX_MAP_TEXINFO");
|
|
*tc = tx;
|
|
numtexinfo++;
|
|
ThreadUnlock ();
|
|
return i;
|
|
}
|
|
|