dc_yh = pl->bottom[x];
if (dc_yl <= dc_yh)
{
angle = (viewangle + xtoviewangle[x])>>ANGLETOSKYSHIFT;
dc_x = x;
dc_source = R_GetColumn(skytexture, angle);
colfunc ();
}
}
continue;
}
// regular flat
ds_source = W_CacheLumpNum(firstflat +
flattranslation[pl->picnum],
PU_STATIC);
planeheight = abs(pl->height-viewz);
light = (pl->lightlevel >> LIGHTSEGSHIFT)+extralight;
if (light >= LIGHTLEVELS)
light = LIGHTLEVELS-1;
if (light < 0)
light = 0;
planezlight = zlight[light];
pl->top[pl->maxx+1] = 0xff;
pl->top[pl->minx-1] = 0xff;
static inline void precache_lump(int l)
{
W_CacheLumpNum(l); W_UnlockLumpNum(l);
}
void P_LoadVertexes(int lump, int gllump)
{
byte *data, *glverts = 0;
int i, orignum, ver;
mapvertex_t *ml;
glvert2_t *glv;
vertex_t *li;
orignum = numvertexes = W_LumpLength(lump) / sizeof(mapvertex_t);
// glBSP lump given?
if(gllump >= 0)
{
glverts = W_CacheLumpNum(gllump, PU_STATIC);
// Which version?
ver = 1;
if(!strncmp(glverts, "gNd2", 4))
{
Con_Message("GL_VERT v2.0\n");
ver = 2;
}
// There are additional vertices in gllump.
numvertexes +=
(W_LumpLength(gllump) - (ver == 2 ? 4 : 0)) / (ver ==
1 ?
sizeof(mapvertex_t)
:
sizeof(glvert2_t));
}
vertexes = Z_Malloc(numvertexes * sizeof(vertex_t), PU_LEVEL, 0);
data = W_CacheLumpNum(lump, PU_STATIC);
ml = (mapvertex_t *) data;
li = vertexes;
for(i = 0; i < orignum; i++, li++, ml++)
{
li->x = SHORT(ml->x) << FRACBITS;
li->y = SHORT(ml->y) << FRACBITS;
}
Z_Free(data);
firstGLvertex = orignum;
// Also load the GL vertices.
if(glverts)
{
ml = (mapvertex_t *) glverts;
glv = (glvert2_t *) (glverts + 4);
for(i = orignum; i < numvertexes; i++, li++, ml++, glv++)
{
if(ver == 1)
{
li->x = SHORT(ml->x) << FRACBITS;
li->y = SHORT(ml->y) << FRACBITS;
}
else
{
li->x = glv->x;
li->y = glv->y;
}
}
Z_Free(glverts);
}
}
//
// P_LoadLineDefs
// Also counts secret lines for intermissions.
//
void P_LoadLineDefs (int lump)
{
byte* data;
int i;
maplinedef_t* mld;
line_t* ld;
vertex_t* v1;
vertex_t* v2;
numlines = W_LumpLength (lump) / sizeof(maplinedef_t);
lines = Z_Malloc (numlines*sizeof(line_t),PU_LEVEL,0);
memset (lines, 0, numlines*sizeof(line_t));
data = W_CacheLumpNum (lump,PU_STATIC);
mld = (maplinedef_t *)data;
ld = lines;
for (i=0 ; i<numlines ; i++, mld++, ld++)
{
ld->flags = SHORT(mld->flags);
ld->special = SHORT(mld->special);
ld->tag = SHORT(mld->tag);
v1 = ld->v1 = &vertexes[SHORT(mld->v1)];
v2 = ld->v2 = &vertexes[SHORT(mld->v2)];
ld->dx = v2->x - v1->x;
ld->dy = v2->y - v1->y;
if (!ld->dx)
ld->slopetype = ST_VERTICAL;
else if (!ld->dy)
ld->slopetype = ST_HORIZONTAL;
else
{
if (FixedDiv (ld->dy , ld->dx) > 0)
ld->slopetype = ST_POSITIVE;
else
ld->slopetype = ST_NEGATIVE;
}
if (v1->x < v2->x)
{
ld->bbox[BOXLEFT] = v1->x;
ld->bbox[BOXRIGHT] = v2->x;
}
else
{
ld->bbox[BOXLEFT] = v2->x;
ld->bbox[BOXRIGHT] = v1->x;
}
if (v1->y < v2->y)
{
ld->bbox[BOXBOTTOM] = v1->y;
ld->bbox[BOXTOP] = v2->y;
}
else
{
ld->bbox[BOXBOTTOM] = v2->y;
ld->bbox[BOXTOP] = v1->y;
}
ld->sidenum[0] = SHORT(mld->sidenum[0]);
ld->sidenum[1] = SHORT(mld->sidenum[1]);
if (ld->sidenum[0] != -1)
ld->frontsector = sides[ld->sidenum[0]].sector;
else
ld->frontsector = 0;
if (ld->sidenum[1] != -1)
ld->backsector = sides[ld->sidenum[1]].sector;
else
ld->backsector = 0;
}
Z_Free (data);
}
//rww end
void R_PrecacheLevel (void)
{
char *flatpresent;
char *texturepresent;
char *spritepresent;
int i,j,k, lump;
texture_t *texture;
thinker_t *th;
spriteframe_t *sf;
if (demoplayback)
return;
//
// precache flats
//
flatpresent = alloca(numflats);
memset (flatpresent,0,numflats);
for (i=0 ; i<numsectors ; i++)
{
flatpresent[sectors[i].floorpic] = 1;
flatpresent[sectors[i].ceilingpic] = 1;
}
flatmemory = 0;
for (i=0 ; i<numflats ; i++)
if (flatpresent[i])
{
lump = firstflat + i;
flatmemory += lumpinfo[lump].size;
W_CacheLumpNum(lump, PU_CACHE);
}
//
// precache textures
//
texturepresent = alloca(numtextures);
memset (texturepresent,0, numtextures);
for (i=0 ; i<numsides ; i++)
{
texturepresent[sides[i].toptexture] = 1;
texturepresent[sides[i].midtexture] = 1;
texturepresent[sides[i].bottomtexture] = 1;
}
texturepresent[Sky1Texture] = 1;
texturepresent[Sky2Texture] = 1;
texturememory = 0;
for (i=0 ; i<numtextures ; i++)
{
if (!texturepresent[i])
continue;
texture = textures[i];
for (j=0 ; j<texture->patchcount ; j++)
{
lump = texture->patches[j].patch;
texturememory += lumpinfo[lump].size;
W_CacheLumpNumTexture(texture, lump , PU_CACHE, -1);
}
}
//
// precache sprites
//
spritepresent = alloca(numsprites);
memset (spritepresent,0, numsprites);
for (th = thinkercap.next ; th != &thinkercap ; th=th->next)
{
if (th->function == P_MobjThinker)
spritepresent[((mobj_t *)th)->sprite] = 1;
}
spritememory = 0;
for (i=0 ; i<numsprites ; i++)
{
if (!spritepresent[i])
continue;
for (j=0 ; j<sprites[i].numframes ; j++)
{
sf = &sprites[i].spriteframes[j];
for (k=0 ; k<8 ; k++)
{
lump = firstspritelump + sf->lump[k];
spritememory += lumpinfo[lump].size;
W_CacheLumpNum(lump , PU_CACHE);
}
}
}
void R_PrecacheLevel (void)
{
char* flatpresent;
char* texturepresent;
char* spritepresent;
int i;
int j;
int k;
int lump;
texture_t* texture;
thinker_t* th;
spriteframe_t* sf;
if (demoplayback)
return;
// Precache flats.
flatpresent = alloca(numflats);
memset (flatpresent,0,numflats);
for (i=0 ; i<numsectors ; i++)
{
flatpresent[sectors[i].floorpic] = 1;
flatpresent[sectors[i].ceilingpic] = 1;
}
flatmemory = 0;
for (i=0 ; i<numflats ; i++)
{
if (flatpresent[i])
{
lump = firstflat + i;
flatmemory += lumpinfo[lump].size;
W_CacheLumpNum(lump, PU_CACHE);
}
}
// Precache textures.
texturepresent = alloca(numtextures);
memset (texturepresent,0, numtextures);
for (i=0 ; i<numsides ; i++)
{
texturepresent[sides[i].toptexture] = 1;
texturepresent[sides[i].midtexture] = 1;
texturepresent[sides[i].bottomtexture] = 1;
}
// Sky texture is always present.
// Note that F_SKY1 is the name used to
// indicate a sky floor/ceiling as a flat,
// while the sky texture is stored like
// a wall texture, with an episode dependend
// name.
texturepresent[skytexture] = 1;
texturememory = 0;
for (i=0 ; i<numtextures ; i++)
{
if (!texturepresent[i])
continue;
texture = textures[i];
for (j=0 ; j<texture->patchcount ; j++)
{
lump = texture->patches[j].patch;
texturememory += lumpinfo[lump].size;
W_CacheLumpNum(lump , PU_CACHE);
}
}
// Precache sprites.
spritepresent = alloca(numsprites);
memset (spritepresent,0, numsprites);
for (th = thinkercap.next ; th != &thinkercap ; th=th->next)
{
if (th->function.acp1 == (actionf_p1)P_MobjThinker)
spritepresent[((mobj_t *)th)->sprite] = 1;
}
spritememory = 0;
for (i=0 ; i<numsprites ; i++)
{
if (!spritepresent[i])
continue;
for (j=0 ; j<sprites[i].numframes ; j++)
{
sf = &sprites[i].spriteframes[j];
for (k=0 ; k<8 ; k++)
{
lump = firstspritelump + sf->lump[k];
spritememory += lumpinfo[lump].size;
W_CacheLumpNum(lump , PU_CACHE);
}
}
}
}
if (dc_yl <= dc_yh)
{
angle = (viewangle + xtoviewangle[x]) >> ANGLETOSKYSHIFT;
dc_x = x;
dc_source = R_GetColumn(skytexture, angle);
dc_texheight = textureheight[skytexture] >> FRACBITS;
colfunc();
}
}
continue;
}
// regular flat
lumpnum = firstflat + flattranslation[pl->picnum];
ds_source = W_CacheLumpNum(lumpnum, PU_STATIC);
planeheight = abs(pl->height - viewz);
light = (pl->lightlevel >> LIGHTSEGSHIFT) + extralight;
if (light >= LIGHTLEVELS)
{
light = LIGHTLEVELS - 1;
}
if (light < 0)
{
light = 0;
}
planezlight = zlight[light];
void HandleCommand (void)
{
int i,margin,top,bottom;
int picwidth,picheight,picmid;
switch (toupper(*++text))
{
case 'B':
picy=ParseNumber();
picx=ParseNumber();
picwidth=ParseNumber();
picheight=ParseNumber();
VWB_Bar(picx,picy,picwidth,picheight,BACKCOLOR);
RipToEOL();
break;
case ';': // comment
RipToEOL();
break;
case 'P': // ^P is start of next page, ^E is end of file
case 'E':
layoutdone = true;
text--; // back up to the '^'
break;
case 'C': // ^c<hex digit> changes text color
i = toupper(*++text);
if (i>='0' && i<='9')
FONTCOLOR = i-'0';
else if (i>='A' && i<='F')
FONTCOLOR = i-'A'+10;
FONTCOLOR *= 16;
i = toupper(*++text);
if (i>='0' && i<='9')
FONTCOLOR += i-'0';
else if (i>='A' && i<='F')
FONTCOLOR += i-'A'+10;
// text++;
break;
case '>':
px = 160;
text++;
break;
case 'L':
py=ParseNumber();
rowon = (py-TOPMARGIN)/FONTHEIGHT;
py = TOPMARGIN+rowon*FONTHEIGHT;
px=ParseNumber();
while (*text++ != '\n') // scan to end of line
;
break;
case 'T': // ^Tyyy,xxx,ppp,ttt waits ttt tics, then draws pic
TimedPicCommand ();
break;
case 'G': // ^Gyyy,xxx,ppp draws graphic
ParsePicCommand ();
Pic = (pic_t *) W_CacheLumpNum (GFX_STRT+(picnum-1), PU_CACHE);
VWB_DrawPic (picx, picy, Pic);
// VWB_DrawPic (picx & ~7, picy, Pic);
picwidth = Pic->width<<2;
picheight = Pic->height;
//
// adjust margins
//
picmid = picx + picwidth/2;
if (picmid > SCREENMID)
margin = picx-PICMARGIN; // new right margin
else
margin = picx+picwidth+PICMARGIN; // new left margin
top = (picy-TOPMARGIN)/FONTHEIGHT;
if (top<0)
top = 0;
bottom = (picy+picheight-TOPMARGIN)/FONTHEIGHT;
if (bottom>=TEXTROWS)
bottom = TEXTROWS-1;
for (i=top;i<=bottom;i++)
if (picmid > SCREENMID)
rightmargin[i] = margin;
else
leftmargin[i] = margin;
//
// adjust this line if needed
//
if (px < leftmargin[rowon])
px = leftmargin[rowon];
break;
}
}
void D_Display (void)
{
static boolean isborderstate IDATA_ATTR= false;
static boolean borderwillneedredraw IDATA_ATTR= false;
static gamestate_t oldgamestate IDATA_ATTR= -1;
boolean wipe;
boolean viewactive = false, isborder = false;
if (nodrawers) // for comparative timing / profiling
return;
// save the current screen if about to wipe
if ((wipe = gamestate != wipegamestate))
wipe_StartScreen(0, 0, SCREENWIDTH, SCREENHEIGHT);
if (gamestate != GS_LEVEL) { // Not a level
switch (oldgamestate) {
case (gamestate_t)-1:
case GS_LEVEL:
V_SetPalette(0); // cph - use default (basic) palette
default:
break;
}
switch (gamestate) {
case GS_INTERMISSION:
WI_Drawer();
break;
case GS_FINALE:
F_Drawer();
break;
case GS_DEMOSCREEN:
D_PageDrawer();
break;
default:
break;
}
} else if (gametic != basetic) { // In a level
boolean redrawborderstuff;
HU_Erase();
if (setsizeneeded) { // change the view size if needed
R_ExecuteSetViewSize();
oldgamestate = -1; // force background redraw
}
// Work out if the player view is visible, and if there is a border
viewactive = (!(automapmode & am_active) || (automapmode & am_overlay)) && !inhelpscreens;
isborder = viewactive ? (viewheight != SCREENHEIGHT) : (!inhelpscreens && (automapmode & am_active));
if (oldgamestate != GS_LEVEL) {
R_FillBackScreen (); // draw the pattern into the back screen
redrawborderstuff = isborder;
} else {
// CPhipps -
// If there is a border, and either there was no border last time,
// or the border might need refreshing, then redraw it.
redrawborderstuff = isborder && (!isborderstate || borderwillneedredraw);
// The border may need redrawing next time if the border surrounds the screen,
// and there is a menu being displayed
borderwillneedredraw = menuactive && isborder && viewactive && (viewwidth != SCREENWIDTH);
}
if (redrawborderstuff)
R_DrawViewBorder();
// Now do the drawing
if (viewactive)
R_RenderPlayerView (&players[displayplayer]);
if (automapmode & am_active)
AM_Drawer();
ST_Drawer((viewheight != SCREENHEIGHT) || ((automapmode & am_active) && !(automapmode & am_overlay)), redrawborderstuff);
R_DrawViewBorder();
HU_Drawer();
}
isborderstate = isborder;
oldgamestate = wipegamestate = gamestate;
// draw pause pic
if (paused) {
static int x;
if (!x) { // Cache results of x pos calc
int lump = W_GetNumForName("M_PAUSE");
const patch_t* p = W_CacheLumpNum(lump);
x = (320 - SHORT(p->width))/2;
W_UnlockLumpNum(lump);
}
// CPhipps - updated for new patch drawing
V_DrawNamePatch(x, (!(automapmode & am_active) || (automapmode & am_overlay))
? 4+(viewwindowy*200/SCREENHEIGHT) : 4, // cph - Must un-stretch viewwindowy
0, "M_PAUSE", CR_DEFAULT, VPT_STRETCH);
}
// menus go directly to the screen
M_Drawer(); // menu is drawn even on top of everything
D_BuildNewTiccmds();
// normal update
if (!wipe)
I_FinishUpdate (); // page flip or blit buffer
else {
// wipe update
wipe_EndScreen(0, 0, SCREENWIDTH, SCREENHEIGHT);
D_Wipe();
}
}
//
// This function loads the sound data from the WAD lump,
// for single sound.
//
void* getsfx( const char* sfxname, int* len )
{
unsigned char *sfx, *srcfx, *paddedsfx;
int i;
int size;
int paddedsize;
char name[20];
int sfxlump;
int16_t s, t, *upsamps;
// Get the sound data from the WAD, allocate lump
// in zone memory.
sprintf(name, "ds%s", sfxname);
// Now, there is a severe problem with the
// sound handling, in it is not (yet/anymore)
// gamemode aware. That means, sounds from
// DOOM II will be requested even with DOOM
// shareware.
// The sound list is wired into sounds.c,
// which sets the external variable.
// I do not do runtime patches to that
// variable. Instead, we will use a
// default sound for replacement.
if ( W_CheckNumForName(name) == -1 )
sfxlump = W_GetNumForName("dspistol");
else
sfxlump = W_GetNumForName(name);
size = W_LumpLength( sfxlump );
// Debug.
// fprintf( stderr, "." );
//fprintf( stderr, " -loading %s (lump %d, %d bytes)\n",
// sfxname, sfxlump, size );
//fflush( stderr );
sfx = (unsigned char*)W_CacheLumpNum(sfxlump);
// upsample to 16 bit x 44.1Khz (playback is 22khz stereo)
paddedsize = (size * 8);
// Allocate from zone memory.
paddedsfx = (unsigned char*)Z_Malloc( paddedsize+8, PU_STATIC, 0 );
paddedsfx += 8;
// Now copy and upsample
upsamps = (int16_t *)(paddedsfx);
srcfx = sfx + 8;
for (i = 9; i < size; i++)
{
s = (255<<5) - (*srcfx<<6);
srcfx++;
t = (255<<5) - (*srcfx<<6);
*upsamps++ = s << 2;
*upsamps++ = s << 2;
*upsamps++ = s * 3 + t;
*upsamps++ = s + 3 * t;
}
*upsamps++ = t << 2;
*upsamps++ = t << 2;
*upsamps++ = t * 3;
*upsamps++ = t;
// Remove the cached lump.
Z_Free( sfx );
// Actual data length
*len = (size - 8) * 8;
// Return allocated padded data.
return (void *) (paddedsfx);
}
void gld_BindFlat(GLTexture *gltexture)
{
const unsigned char *flat;
int i;
unsigned char *buffer;
if (gltexture==last_gltexture)
return;
last_gltexture=gltexture;
if (!gltexture)
return;
if (gltexture->textype!=GLDT_FLAT)
{
glBindTexture(GL_TEXTURE_2D, 0);
last_gltexture = NULL;
last_cm = -1;
return;
}
if (gltexture->glTexID[CR_DEFAULT]!=0)
{
glBindTexture(GL_TEXTURE_2D, gltexture->glTexID[CR_DEFAULT]);
glGetTexParameteriv(GL_TEXTURE_2D,GL_TEXTURE_RESIDENT,&i);
#ifdef _DEBUG
if (i!=GL_TRUE)
lprintf(LO_INFO, "glGetTexParam: %i\n", i);
#endif
if (i==GL_TRUE)
return;
}
flat=W_CacheLumpNum(gltexture->index);
buffer=(unsigned char*)Z_Malloc(gltexture->buffer_size,PU_STATIC,0);
if (!(gltexture->mipmap && use_mipmapping) && gl_paletted_texture)
memset(buffer,transparent_pal_index,gltexture->buffer_size);
else
memset(buffer,0,gltexture->buffer_size);
gld_AddFlatToTexture(gltexture, buffer, flat, !(gltexture->mipmap && use_mipmapping) && gl_paletted_texture);
if (gltexture->glTexID[CR_DEFAULT]==0)
glGenTextures(1,&gltexture->glTexID[CR_DEFAULT]);
glBindTexture(GL_TEXTURE_2D, gltexture->glTexID[CR_DEFAULT]);
#ifdef USE_GLU_MIPMAP
if (gltexture->mipmap && use_mipmapping)
{
gluBuild2DMipmaps(GL_TEXTURE_2D, gl_tex_format,
gltexture->buffer_width, gltexture->buffer_height,
GL_RGBA, GL_UNSIGNED_BYTE, buffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_tex_filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_mipmap_filter);
if (gl_texture_filter_anisotropic)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2.0);
}
else
#endif /* USE_GLU_MIPMAP */
{
#ifdef USE_GLU_IMAGESCALE
if ((gltexture->buffer_width!=gltexture->tex_width) ||
(gltexture->buffer_height!=gltexture->tex_height)
)
{
unsigned char *scaledbuffer;
scaledbuffer=(unsigned char*)Z_Malloc(gltexture->tex_width*gltexture->tex_height*4,PU_STATIC,0);
if (scaledbuffer)
{
gluScaleImage(GL_RGBA,
gltexture->buffer_width, gltexture->buffer_height,
GL_UNSIGNED_BYTE,buffer,
gltexture->tex_width, gltexture->tex_height,
GL_UNSIGNED_BYTE,scaledbuffer);
Z_Free(buffer);
buffer=scaledbuffer;
glTexImage2D( GL_TEXTURE_2D, 0, gl_tex_format,
gltexture->tex_width, gltexture->tex_height,
0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
}
}
else
#endif /* USE_GLU_IMAGESCALE */
{
if (gl_paletted_texture) {
gld_SetTexturePalette(GL_TEXTURE_2D);
glTexImage2D( GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT,
gltexture->buffer_width, gltexture->buffer_height,
0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, buffer);
} else {
glTexImage2D( GL_TEXTURE_2D, 0, gl_tex_format,
gltexture->buffer_width, gltexture->buffer_height,
0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
}
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_tex_filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_tex_filter);
}
Z_Free(buffer);
W_UnlockLumpNum(gltexture->index);
}
void P_SetupLevel (int map, skill_t skill)
{
int i;
static char lumpname[16];
int lumpnum;
mobj_t *mobj;
extern int cy;
M_ClearRandom ();
P_LoadingPlaque ();
D_printf ("P_SetupLevel(%i,%i)\n",map,skill);
totalkills = totalitems = totalsecret = 0;
for (i=0 ; i<MAXPLAYERS ; i++)
{
players[i].killcount = players[i].secretcount
= players[i].itemcount = 0;
}
Z_CheckHeap (mainzone);
#ifndef MARS
Z_CheckHeap (refzone);
#endif
Z_FreeTags (mainzone);
/*PrintHex (1,1,Z_FreeMemory (mainzone)); */
P_InitThinkers ();
/* */
/* look for a regular (development) map first */
/* */
lumpname[0] = 'M';
lumpname[1] = 'A';
lumpname[2] = 'P';
lumpname[3] = '0' + map/10;
lumpname[4] = '0' + map%10;
lumpname[5] = 0;
lumpnum = W_GetNumForName (lumpname);
/* note: most of this ordering is important */
P_LoadBlockMap (lumpnum+ML_BLOCKMAP);
P_LoadVertexes (lumpnum+ML_VERTEXES);
P_LoadSectors (lumpnum+ML_SECTORS);
P_LoadSideDefs (lumpnum+ML_SIDEDEFS);
P_LoadLineDefs (lumpnum+ML_LINEDEFS);
P_LoadSubsectors (lumpnum+ML_SSECTORS);
P_LoadNodes (lumpnum+ML_NODES);
P_LoadSegs (lumpnum+ML_SEGS);
#ifdef MARS
rejectmatrix = (byte *)(wadfileptr+BIGLONG(lumpinfo[lumpnum+ML_REJECT].filepos));
#else
rejectmatrix = W_CacheLumpNum (lumpnum+ML_REJECT,PU_LEVEL);
#endif
P_GroupLines ();
deathmatch_p = deathmatchstarts;
P_LoadThings (lumpnum+ML_THINGS);
/* */
/* if deathmatch, randomly spawn the active players */
/* */
if (netgame == gt_deathmatch)
{
for (i=0 ; i<MAXPLAYERS ; i++)
if (playeringame[i])
{ /* must give a player spot before deathmatchspawn */
mobj = P_SpawnMobj (deathmatchstarts[0].x<<16
,deathmatchstarts[0].y<<16,0, MT_PLAYER);
players[i].mo = mobj;
G_DeathMatchSpawnPlayer (i);
P_RemoveMobj (mobj);
}
}
/* set up world state */
P_SpawnSpecials ();
ST_InitEveryLevel ();
/*printf ("free memory: 0x%x\n", Z_FreeMemory(mainzone)); */
cy = 4;
#ifdef JAGUAR
{
extern byte *debugscreen;
D_memset (debugscreen,0,32*224);
}
#endif
iquehead = iquetail = 0;
gamepaused = false;
}
static boolean CacheSFX(sfxinfo_t *sfxinfo)
{
int lumpnum;
unsigned int lumplen;
int samplerate;
unsigned int length;
byte *data;
// need to load the sound
lumpnum = sfxinfo->lumpnum;
data = W_CacheLumpNum(lumpnum, PU_STATIC);
lumplen = W_LumpLength(lumpnum);
// Check the header, and ensure this is a valid sound
if (lumplen < 8
|| data[0] != 0x03 || data[1] != 0x00)
{
// Invalid sound
return false;
}
// 16 bit sample rate field, 32 bit length field
samplerate = (data[3] << 8) | data[2];
length = (data[7] << 24) | (data[6] << 16) | (data[5] << 8) | data[4];
// If the header specifies that the length of the sound is greater than
// the length of the lump itself, this is an invalid sound lump
// We also discard sound lumps that are less than 49 samples long,
// as this is how DMX behaves - although the actual cut-off length
// seems to vary slightly depending on the sample rate. This needs
// further investigation to better understand the correct
// behavior.
if (length > lumplen - 8 || length <= 48)
{
return false;
}
// The DMX sound library seems to skip the first 16 and last 16
// bytes of the lump - reason unknown.
data += 16;
length -= 32;
// Sample rate conversion
if (!ExpandSoundData(sfxinfo, data + 8, samplerate, length))
{
return false;
}
#ifdef DEBUG_DUMP_WAVS
{
char filename[16];
allocated_sound_t * snd;
M_snprintf(filename, sizeof(filename), "%s.wav",
DEH_String(sfxinfo->name));
snd = GetAllocatedSoundBySfxInfoAndPitch(sfxinfo, NORM_PITCH);
WriteWAV(filename, snd->chunk.abuf, snd->chunk.alen,mixer_freq);
}
#endif
// don't need the original lump any more
W_ReleaseLumpNum(lumpnum);
return true;
}
void I_sndArbitrateCards(void)
{
char tmp[160];
boolean gus, adlib, pc, sb, midi;
int i, rc, mputype, p, opltype, wait, dmxlump;
snd_MusicDevice = snd_DesiredMusicDevice;
snd_SfxDevice = snd_DesiredSfxDevice;
// check command-line parameters- overrides config file
//
if (M_CheckParm("-nosound"))
snd_MusicDevice = snd_SfxDevice = snd_none;
if (M_CheckParm("-nosfx"))
snd_SfxDevice = snd_none;
if (M_CheckParm("-nomusic"))
snd_MusicDevice = snd_none;
if (snd_MusicDevice > snd_MPU && snd_MusicDevice <= snd_MPU3)
snd_MusicDevice = snd_MPU;
if (snd_MusicDevice == snd_SB)
snd_MusicDevice = snd_Adlib;
if (snd_MusicDevice == snd_PAS)
snd_MusicDevice = snd_Adlib;
// figure out what i've got to initialize
//
gus = snd_MusicDevice == snd_GUS || snd_SfxDevice == snd_GUS;
sb = snd_SfxDevice == snd_SB || snd_MusicDevice == snd_SB;
adlib = snd_MusicDevice == snd_Adlib;
pc = snd_SfxDevice == snd_PC;
midi = snd_MusicDevice == snd_MPU;
// initialize whatever i've got
//
if (gus)
{
if (GF1_Detect())
ST_Message(" Dude. The GUS ain't responding.\n");
else
{
dmxlump = W_GetNumForName("dmxgus");
GF1_SetMap(W_CacheLumpNum(dmxlump, PU_CACHE),
lumpinfo[dmxlump].size);
}
}
if (sb)
{
if (debugmode)
{
ST_Message(" Sound cfg p=0x%x, i=%d, d=%d\n",
snd_SBport, snd_SBirq, snd_SBdma);
}
if (SB_Detect(&snd_SBport, &snd_SBirq, &snd_SBdma, 0))
{
ST_Message(" SB isn't responding at p=0x%x, i=%d, d=%d\n",
snd_SBport, snd_SBirq, snd_SBdma);
}
else
SB_SetCard(snd_SBport, snd_SBirq, snd_SBdma);
if (debugmode)
{
ST_Message(" SB_Detect returned p=0x%x, i=%d, d=%d\n",
snd_SBport, snd_SBirq, snd_SBdma);
}
}
if (adlib)
{
if (AL_Detect(&wait, 0))
{
ST_Message(" Dude. The Adlib isn't responding.\n");
}
else
{
AL_SetCard(wait, W_CacheLumpName("genmidi", PU_STATIC));
}
}
if (midi)
{
if (debugmode)
{
ST_Message(" cfg p=0x%x\n", snd_Mport);
}
if (MPU_Detect(&snd_Mport, &i))
{
ST_Message(" The MPU-401 isn't reponding @ p=0x%x.\n",
snd_Mport);
}
else
MPU_SetCard(snd_Mport);
}
}
//
// R_GenerateComposite
// Using the texture definition,
// the composite texture is created from the patches,
// and each column is cached.
//
void R_GenerateComposite (int texnum)
{
byte* block;
texture_t* texture;
texpatch_t* patch;
patch_t* realpatch;
int x;
int x1;
int x2;
int i;
column_t* patchcol;
short* collump;
unsigned short* colofs;
texture = textures[texnum];
block = Z_Malloc (texturecompositesize[texnum],
PU_STATIC,
&texturecomposite[texnum]);
collump = texturecolumnlump[texnum];
colofs = texturecolumnofs[texnum];
// Composite the columns together.
patch = texture->patches;
for (i=0 , patch = texture->patches;
i<texture->patchcount;
i++, patch++)
{
realpatch = W_CacheLumpNum (patch->patch, PU_CACHE);
x1 = patch->originx;
x2 = x1 + SHORT(realpatch->width);
if (x1<0)
x = 0;
else
x = x1;
if (x2 > texture->width)
x2 = texture->width;
for ( ; x<x2 ; x++)
{
// Column does not have multiple patches?
if (collump[x] >= 0)
continue;
patchcol = (column_t *)((byte *)realpatch
+ LONG(realpatch->columnofs[x-x1]));
R_DrawColumnInCache (patchcol,
block + colofs[x],
patch->originy,
texture->height);
}
}
// Now that the texture has been built in column cache,
// it is purgable from zone memory.
Z_ChangeTag (block, PU_CACHE);
}
void P_SetupLevel(int map, skill_t skill)
{
int i;
static char lumpname[16];
int lumpnum;
mobj_t *mobj;
extern int cy;
M_ClearRandom();
P_LoadingPlaque();
D_printf("P_SetupLevel(%i,%i)\n", map, skill);
totalkills = totalitems = totalsecret = 0;
for(i = 0; i < MAXPLAYERS; i++)
players[i].killcount = players[i].secretcount = players[i].itemcount = 0;
Z_CheckHeap(mainzone);
Z_CheckHeap(refzone);
Z_FreeTags(mainzone);
P_InitThinkers();
//
// look for a regular (development) map first
//
lumpname[0] = 'M';
lumpname[1] = 'A';
lumpname[2] = 'P';
lumpname[3] = '0' + map / 10;
lumpname[4] = '0' + map % 10;
lumpname[5] = 0;
lumpnum = W_GetNumForName(lumpname);
// note: most of this ordering is important
P_LoadBlockMap(lumpnum+ML_BLOCKMAP);
P_LoadVertexes(lumpnum+ML_VERTEXES);
P_LoadSectors(lumpnum+ML_SECTORS);
P_LoadSideDefs(lumpnum+ML_SIDEDEFS);
P_LoadLineDefs(lumpnum+ML_LINEDEFS);
P_LoadSubsectors(lumpnum+ML_SSECTORS);
P_LoadNodes(lumpnum+ML_NODES);
P_LoadSegs(lumpnum+ML_SEGS);
rejectmatrix = W_CacheLumpNum(lumpnum + ML_REJECT, PU_LEVEL);
P_GroupLines();
deathmatch_p = deathmatchstarts;
P_LoadThings(lumpnum + ML_THINGS);
//
// if deathmatch, randomly spawn the active players
//
if(netgame == gt_deathmatch)
{
for(i = 0; i < MAXPLAYERS; i++)
{
if(playeringame[i])
{
// must give a player spot before deathmatchspawn
mobj = P_SpawnMobj(deathmatchstarts[0].x << 16 ,deathmatchstarts[0].y << 16, 0, MT_PLAYER);
players[i].mo = mobj;
G_DeathMatchSpawnPlayer(i);
P_RemoveMobj(mobj);
}
}
}
// set up world state
P_SpawnSpecials();
ST_InitEveryLevel();
cy = 4;
iquehead = iquetail = 0;
gamepaused = false;
}
//
// R_GenerateLookup
//
void R_GenerateLookup (int texnum)
{
texture_t* texture;
byte* patchcount; // patchcount[texture->width]
texpatch_t* patch;
patch_t* realpatch;
int x;
int x1;
int x2;
int i;
short* collump;
unsigned short* colofs;
texture = textures[texnum];
// Composited texture not created yet.
texturecomposite[texnum] = 0;
texturecompositesize[texnum] = 0;
collump = texturecolumnlump[texnum];
colofs = texturecolumnofs[texnum];
// Now count the number of columns
// that are covered by more than one patch.
// Fill in the lump / offset, so columns
// with only a single patch are all done.
patchcount = (byte *)alloca (texture->width);
memset (patchcount, 0, texture->width);
patch = texture->patches;
for (i=0 , patch = texture->patches;
i<texture->patchcount;
i++, patch++)
{
realpatch = W_CacheLumpNum (patch->patch, PU_CACHE);
x1 = patch->originx;
x2 = x1 + SHORT(realpatch->width);
if (x1 < 0)
x = 0;
else
x = x1;
if (x2 > texture->width)
x2 = texture->width;
for ( ; x<x2 ; x++)
{
patchcount[x]++;
collump[x] = patch->patch;
colofs[x] = LONG(realpatch->columnofs[x-x1])+3;
}
}
for (x=0 ; x<texture->width ; x++)
{
if (!patchcount[x])
{
printf ("R_GenerateLookup: column without a patch (%s)\n",
texture->name);
return;
}
// I_Error ("R_GenerateLookup: column without a patch");
if (patchcount[x] > 1)
{
// Use the cached block.
collump[x] = -1;
colofs[x] = texturecompositesize[texnum];
if (texturecompositesize[texnum] > 0x10000-texture->height)
{
I_Error ("R_GenerateLookup: texture %i is >64k",
texnum);
}
texturecompositesize[texnum] += texture->height;
}
}
}
static void TextWrite (void)
{
int count;
char *ch;
int c;
int cx, cy;
patch_t *w;
memcpy(screen, W_CacheLumpNum(FinaleLumpNum, PU_CACHE),
SCREENWIDTH*SCREENHEIGHT);
if(FinaleStage == 5)
{ // Chess pic, draw the correct character graphic
if(netgame)
{
V_DrawPatch(20, 0, W_CacheLumpName("chessall", PU_CACHE));
}
else if(PlayerClass[consoleplayer])
{
V_DrawPatch(60, 0, W_CacheLumpNum(W_GetNumForName("chessc")
+PlayerClass[consoleplayer]-1, PU_CACHE));
}
}
// Draw the actual text
if(FinaleStage == 5)
{
cy = 135;
}
else
{
cy = 5;
}
cx = 20;
ch = FinaleText;
count = (FinaleCount-10)/TEXTSPEED;
if (count < 0)
{
count = 0;
}
for(; count; count--)
{
c = *ch++;
if(!c)
{
break;
}
if(c == '\n')
{
cx = 20;
cy += 9;
continue;
}
if(c < 32)
{
continue;
}
c = toupper(c);
if(c == 32)
{
cx += 5;
continue;
}
w = W_CacheLumpNum(FontABaseLump+c-33, PU_CACHE);
if(cx+w->width > SCREENWIDTH)
{
break;
}
V_DrawPatch(cx, cy, w);
cx += w->width;
}
}
void R_InitSkins (void)
{
char sndname[128];
int sndlumps[8];
char key[10];
int intname;
size_t i;
int j, k, base;
int stop;
char *def;
key[9] = 0;
for (i = 1; i < numskins; i++)
{
for (j = 0; j < 8; j++)
sndlumps[j] = -1;
base = W_CheckNumForName ("S_SKIN", skins[i].namespc);
// The player sprite has 23 frames. This means that the S_SKIN
// marker needs a minimum of 23 lumps after it (probably more).
if (base + 23 >= (int)numlumps || base == -1)
continue;
def = (char *)W_CacheLumpNum (base, PU_CACHE);
intname = 0;
// Data is stored as "key = data".
while ( (def = COM_Parse (def)) )
{
strncpy (key, com_token, 9);
def = COM_Parse (def);
if (com_token[0] != '=')
{
Printf (PRINT_HIGH, "Bad format for skin %d: %s %s", i, key, com_token);
break;
}
def = COM_Parse (def);
if (!stricmp (key, "name")) {
strncpy (skins[i].name, com_token, 16);
} else if (!stricmp (key, "sprite")) {
for (j = 3; j >= 0; j--)
com_token[j] = toupper (com_token[j]);
intname = *((int *)com_token);
} else if (!stricmp (key, "face")) {
for (j = 2; j >= 0; j--)
skins[i].face[j] = toupper (com_token[j]);
} else {
for (j = 0; j < 8; j++) {
if (!stricmp (key, skinsoundnames[j][0])) {
// Can't use W_CheckNumForName because skin sounds
// haven't been assigned a namespace yet.
for (k = base + 1; k < (int)numlumps &&
lumpinfo[k].handle == lumpinfo[base].handle; k++) {
if (!strnicmp (com_token, lumpinfo[k].name, 8)) {
//W_SetLumpNamespace (k, skins[i].namespc);
sndlumps[j] = k;
break;
}
}
if (sndlumps[j] == -1) {
// Replacement not found, try finding it in the global namespace
sndlumps[j] = W_CheckNumForName (com_token);
}
break;
}
}
//if (j == 8)
// Printf (PRINT_HIGH, "Funny info for skin %i: %s = %s\n", i, key, com_token);
}
}
if (skins[i].name[0] == 0)
sprintf (skins[i].name, "skin%d", (unsigned)i);
// Register any sounds this skin provides
for (j = 0; j < 8; j++) {
if (sndlumps[j] != -1) {
if (j > 1) {
sprintf (sndname, "player/%s/%s", skins[i].name, skinsoundnames[j][1]);
S_AddSoundLump (sndname, sndlumps[j]);
} else if (j == 1) {
int r;
for (r = 1; r <= 4; r++) {
sprintf (sndname, "player/%s/death%d", skins[i].name, r);
S_AddSoundLump (sndname, sndlumps[j]);
}
} else { // j == 0
int l, r;
for (l = 1; l <= 4; l++)
for (r = 1; r <= 2; r++) {
sprintf (sndname, "player/%s/pain%d_%d", skins[i].name, l*25, r);
S_AddSoundLump (sndname, sndlumps[j]);
}
}
}
}
// Now collect the sprite frames for this skin. If the sprite name was not
// specified, use whatever immediately follows the specifier lump.
if (intname == 0) {
intname = *(int *)(lumpinfo[base+1].name);
for (stop = base + 2; stop < (int)numlumps &&
lumpinfo[stop].handle == lumpinfo[base].handle &&
*(int *)lumpinfo[stop].name == intname; stop++)
;
} else {
stop = numlumps;
}
memset (sprtemp, -1, sizeof(sprtemp));
maxframe = -1;
for (k = base + 1;
k < stop && lumpinfo[k].handle == lumpinfo[base].handle;
k++) {
if (*(int *)lumpinfo[k].name == intname)
{
R_InstallSpriteLump (k,
lumpinfo[k].name[4] - 'A', // denis - fixme - security
lumpinfo[k].name[5] - '0',
false);
if (lumpinfo[k].name[6])
R_InstallSpriteLump (k,
lumpinfo[k].name[6] - 'A',
lumpinfo[k].name[7] - '0',
true);
//W_SetLumpNamespace (k, skins[i].namespc);
}
}
R_InstallSprite ((char *)&intname, (skins[i].sprite = (spritenum_t)(numsprites - numskins + i)));
// Now go back and check for face graphics (if necessary)
if (skins[i].face[0] == 0 || skins[i].face[1] == 0 || skins[i].face[2] == 0) {
// No face name specified, so this skin doesn't replace it
skins[i].face[0] = 0;
} else {
// Need to go through and find all face graphics for the skin
// and assign them to the skin's namespace.
for (j = 0; j < 8; j++)
strncpy (facenames[j], skins[i].face, 3);
for (k = base + 1;
k < (int)numlumps && lumpinfo[k].handle == lumpinfo[base].handle;
k++) {
for (j = 0; j < 8; j++)
if (!strncmp (facenames[j], lumpinfo[k].name, facelens[j])) {
//W_SetLumpNamespace (k, skins[i].namespc);
break;
}
}
}
}
// Grrk. May have changed sound table. Fix it.
if (numskins > 1)
S_HashSounds ();
}
static void R_InitTextures (void)
{
const maptexture_t *mtexture;
texture_t *texture;
const mappatch_t *mpatch;
texpatch_t *patch;
int i, j;
int maptex_lump[2] = {-1, -1};
const int *maptex;
const int *maptex1, *maptex2;
char name[9];
int names_lump; // cph - new wad lump handling
const char *names; // cph -
const char *name_p;// const*'s
int *patchlookup;
int nummappatches;
int offset;
int maxoff, maxoff2;
int numtextures1, numtextures2;
const int *directory;
int errors = 0;
// Load the patch names from pnames.lmp.
name[8] = 0;
names = W_CacheLumpNum(names_lump = W_GetNumForName("PNAMES"));
nummappatches = LittleLong(*((const int *)names));
name_p = names+4;
patchlookup = malloc(nummappatches*sizeof(*patchlookup)); // killough
for (i=0 ; i<nummappatches ; i++)
{
strncpy (name,name_p+i*8, 8);
patchlookup[i] = W_CheckNumForName(name);
if (patchlookup[i] == -1)
{
// killough 4/17/98:
// Some wads use sprites as wall patches, so repeat check and
// look for sprites this time, but only if there were no wall
// patches found. This is the same as allowing for both, except
// that wall patches always win over sprites, even when they
// appear first in a wad. This is a kludgy solution to the wad
// lump namespace problem.
patchlookup[i] = (W_CheckNumForName)(name, ns_sprites);
if (patchlookup[i] == -1 && devparm)
//jff 8/3/98 use logical output routine
lprintf(LO_WARN,"\nWarning: patch %.8s, index %d does not exist",name,i);
}
}
W_UnlockLumpNum(names_lump); // cph - release the lump
// Load the map texture definitions from textures.lmp.
// The data is contained in one or two lumps,
// TEXTURE1 for shareware, plus TEXTURE2 for commercial.
maptex = maptex1 = W_CacheLumpNum(maptex_lump[0] = W_GetNumForName("TEXTURE1"));
numtextures1 = LittleLong(*maptex);
maxoff = W_LumpLength(maptex_lump[0]);
directory = maptex+1;
if (W_CheckNumForName("TEXTURE2") != -1)
{
maptex2 = W_CacheLumpNum(maptex_lump[1] = W_GetNumForName("TEXTURE2"));
numtextures2 = LittleLong(*maptex2);
maxoff2 = W_LumpLength(maptex_lump[1]);
}
else
{
maptex2 = NULL;
numtextures2 = 0;
maxoff2 = 0;
}
numtextures = numtextures1 + numtextures2;
// killough 4/9/98: make column offsets 32-bit;
// clean up malloc-ing to use sizeof
textures = Z_Malloc(numtextures*sizeof*textures, PU_STATIC, 0);
textureheight = Z_Malloc(numtextures*sizeof*textureheight, PU_STATIC, 0);
for (i=0 ; i<numtextures ; i++, directory++)
{
if (i == numtextures1)
{
// Start looking in second texture file.
maptex = maptex2;
maxoff = maxoff2;
directory = maptex+1;
}
offset = LittleLong(*directory);
if (offset > maxoff)
I_Error("R_InitTextures: Bad texture directory");
mtexture = (const maptexture_t *) ( (const byte *)maptex + offset);
texture = textures[i] =
Z_Malloc(sizeof(texture_t) +
sizeof(texpatch_t)*(LittleShort(mtexture->patchcount)-1),
PU_STATIC, 0);
texture->width = LittleShort(mtexture->width);
texture->height = LittleShort(mtexture->height);
texture->patchcount = LittleShort(mtexture->patchcount);
/* Mattias Engdegård emailed me of the following explenation of
* why memcpy doesnt work on some systems:
* "I suppose it is the mad unaligned allocation
* going on (and which gcc in some way manages to cope with
* through the __attribute__ ((packed))), and which it forgets
* when optimizing memcpy (to a single word move) since it appears
* to be aligned. Technically a gcc bug, but I can't blame it when
* it's stressed with that amount of
* non-standard nonsense."
* So in short the unaligned struct confuses gcc's optimizer so
* i took the memcpy out alltogether to avoid future problems-Jess
*/
/* The above was #ifndef SPARC, but i got a mail from
* Putera Joseph F NPRI <*****@*****.**> containing:
* I had to use the memcpy function on a sparc machine. The
* other one would give me a core dump.
* cph - I find it hard to believe that sparc memcpy is broken,
* but I don't believe the pointers to memcpy have to be aligned
* either. Use fast memcpy on other machines anyway.
*/
/*
proff - I took this out, because Oli Kraus ([email protected]) told
me the memcpy produced a buserror. Since this function isn't time-
critical I'm using the for loop now.
*/
/*
#ifndef GCC
memcpy(texture->name, mtexture->name, sizeof(texture->name));
#else
*/
{
size_t j;
for(j=0;j<sizeof(texture->name);j++)
texture->name[j]=mtexture->name[j];
}
/* #endif */
mpatch = mtexture->patches;
patch = texture->patches;
for (j=0 ; j<texture->patchcount ; j++, mpatch++, patch++)
{
patch->originx = LittleShort(mpatch->originx);
patch->originy = LittleShort(mpatch->originy);
patch->patch = patchlookup[LittleShort(mpatch->patch)];
if (patch->patch == -1)
{
//jff 8/3/98 use logical output routine
lprintf(LO_ERROR,"\nR_InitTextures: Missing patch %d in texture %.8s",
LittleShort(mpatch->patch), texture->name); // killough 4/17/98
++errors;
}
}
for (j=1; j*2 <= texture->width; j<<=1)
;
texture->widthmask = j-1;
textureheight[i] = texture->height<<FRACBITS;
}
free(patchlookup); // killough
for (i=0; i<2; i++) // cph - release the TEXTUREx lumps
if (maptex_lump[i] != -1)
W_UnlockLumpNum(maptex_lump[i]);
if (errors)
I_Error("R_InitTextures: %d errors", errors);
// Precalculate whatever possible.
if (devparm) // cph - If in development mode, generate now so all errors are found at once
{
R_InitPatches(); //e6y
for (i=0 ; i<numtextures ; i++)
{
// proff - This is for the new renderer now
R_CacheTextureCompositePatchNum(i);
R_UnlockTextureCompositePatchNum(i);
}
}
if (errors)
I_Error("R_InitTextures: %d errors", errors);
// Create translation table for global animation.
// killough 4/9/98: make column offsets 32-bit;
// clean up malloc-ing to use sizeof
texturetranslation =
Z_Malloc((numtextures+1)*sizeof*texturetranslation, PU_STATIC, 0);
for (i=0 ; i<numtextures ; i++)
texturetranslation[i] = i;
// killough 1/31/98: Initialize texture hash table
for (i = 0; i<numtextures; i++)
textures[i]->index = -1;
while (--i >= 0)
{
int j = W_LumpNameHash(textures[i]->name) % (unsigned) numtextures;
textures[i]->next = textures[j]->index; // Prepend to chain
textures[j]->index = i;
}
}
//
// W_CacheLumpName
//
void *W_CacheLumpName(char *name, int tag)
{
return W_CacheLumpNum(W_GetNumForName(name), tag);
}
void R_InitTranMap(int progress)
{
int lump = W_CheckNumForName("TRANMAP");
// If a tranlucency filter map lump is present, use it
if (lump != -1) // Set a pointer to the translucency filter maps.
main_tranmap = W_CacheLumpNum(lump); // killough 4/11/98
else if (W_CheckNumForName("PLAYPAL")!=-1) // can be called before WAD loaded
{ // Compose a default transparent filter map based on PLAYPAL.
const byte *playpal = W_CacheLumpName("PLAYPAL");
byte *my_tranmap;
char fname[PATH_MAX+1];
struct {
unsigned char pct;
unsigned char playpal[256];
} cache;
FILE *cachefp = fopen(strcat(strcpy(fname, I_DoomExeDir()), "/tranmap.dat"),"rb");
main_tranmap = my_tranmap = Z_Malloc(256*256, PU_STATIC, 0); // killough 4/11/98
// Use cached translucency filter if it's available
if (!cachefp ||
fread(&cache, 1, sizeof cache, cachefp) != sizeof cache ||
cache.pct != tran_filter_pct ||
memcmp(cache.playpal, playpal, sizeof cache.playpal) ||
fread(my_tranmap, 256, 256, cachefp) != 256 ) // killough 4/11/98
{
long pal[3][256], tot[256], pal_w1[3][256];
long w1 = ((unsigned long) tran_filter_pct<<TSC)/100;
long w2 = (1l<<TSC)-w1;
if (progress)
lprintf(LO_INFO, "Tranmap build [ ]\x08\x08\x08\x08\x08\x08\x08\x08\x08");
// First, convert playpal into long int type, and transpose array,
// for fast inner-loop calculations. Precompute tot array.
{
register int i = 255;
register const unsigned char *p = playpal+255*3;
do
{
register long t,d;
pal_w1[0][i] = (pal[0][i] = t = p[0]) * w1;
d = t*t;
pal_w1[1][i] = (pal[1][i] = t = p[1]) * w1;
d += t*t;
pal_w1[2][i] = (pal[2][i] = t = p[2]) * w1;
d += t*t;
p -= 3;
tot[i] = d << (TSC-1);
}
while (--i>=0);
}
// Next, compute all entries using minimum arithmetic.
{
int i,j;
byte *tp = my_tranmap;
for (i=0;i<256;i++)
{
long r1 = pal[0][i] * w2;
long g1 = pal[1][i] * w2;
long b1 = pal[2][i] * w2;
if (!(i & 31) && progress)
//jff 8/3/98 use logical output routine
lprintf(LO_INFO,".");
for (j=0;j<256;j++,tp++)
{
register int color = 255;
register long err;
long r = pal_w1[0][j] + r1;
long g = pal_w1[1][j] + g1;
long b = pal_w1[2][j] + b1;
long best = LONG_MAX;
do
if ((err = tot[color] - pal[0][color]*r
- pal[1][color]*g - pal[2][color]*b) < best)
best = err, *tp = color;
while (--color >= 0);
}
}
}
if ((cachefp = fopen(fname,"wb")) != NULL) // write out the cached translucency map
{
cache.pct = tran_filter_pct;
memcpy(cache.playpal, playpal, 256);
fseek(cachefp, 0, SEEK_SET);
fwrite(&cache, 1, sizeof cache, cachefp);
fwrite(main_tranmap, 256, 256, cachefp);
// CPhipps - leave close for a few lines...
}
}
if (cachefp) // killough 11/98: fix filehandle leak
fclose(cachefp);
W_UnlockLumpName("PLAYPAL");
}
}
//
// P_SetupLevel
//
void
P_SetupLevel
( int episode,
int map,
int playermask,
skill_t skill)
{
int i;
char lumpname[9];
int lumpnum;
totalkills = totalitems = totalsecret = wminfo.maxfrags = 0;
wminfo.partime = 180;
for (i=0 ; i<MAXPLAYERS ; i++)
{
players[i].killcount = players[i].secretcount
= players[i].itemcount = 0;
}
// Initial height of PointOfView
// will be set by player think.
players[consoleplayer].viewz = 1;
// Make sure all sounds are stopped before Z_FreeTags.
S_Start ();
#if 0 // UNUSED
if (debugfile)
{
Z_FreeTags (PU_LEVEL, MAXINT);
Z_FileDumpHeap (debugfile);
}
else
#endif
Z_FreeTags (PU_LEVEL, PU_PURGELEVEL-1);
// UNUSED W_Profile ();
P_InitThinkers ();
// if working with a devlopment map, reload it
W_Reload ();
// find map name
if (commercial)
{
if (map<10)
sprintf (lumpname,"map0%i", map);
else
sprintf (lumpname,"map%i", map);
}
else
{
lumpname[0] = 'E';
lumpname[1] = '0' + episode;
lumpname[2] = 'M';
lumpname[3] = '0' + map;
lumpname[4] = 0;
}
lumpnum = W_GetNumForName (lumpname);
leveltime = 0;
// note: most of this ordering is important
P_LoadBlockMap (lumpnum+ML_BLOCKMAP);
P_LoadVertexes (lumpnum+ML_VERTEXES);
P_LoadSectors (lumpnum+ML_SECTORS);
P_LoadSideDefs (lumpnum+ML_SIDEDEFS);
P_LoadLineDefs (lumpnum+ML_LINEDEFS);
P_LoadSubsectors (lumpnum+ML_SSECTORS);
P_LoadNodes (lumpnum+ML_NODES);
P_LoadSegs (lumpnum+ML_SEGS);
rejectmatrix = W_CacheLumpNum (lumpnum+ML_REJECT,PU_LEVEL);
P_GroupLines ();
bodyqueslot = 0;
deathmatch_p = deathmatchstarts;
P_LoadThings (lumpnum+ML_THINGS);
// if deathmatch, randomly spawn the active players
if (deathmatch)
{
for (i=0 ; i<MAXPLAYERS ; i++)
if (playeringame[i])
{
players[i].mo = NULL;
G_DeathMatchSpawnPlayer (i);
}
}
// clear special respawning que
iquehead = iquetail = 0;
// set up world state
P_SpawnSpecials ();
// build subsector connect matrix
// UNUSED P_ConnectSubsectors ();
// preload graphics
if (precache)
R_PrecacheLevel ();
//printf ("free memory: 0x%x\n", Z_FreeMemory());
}
//==========================================================================
// SV_TextureArchiveNum
// Returns the archive number of the given flat.
// It will be written to the savegame file.
//==========================================================================
unsigned short SV_FlatArchiveNum(int flatnum)
{
return SV_SearchArchive(&flat_archive,
W_CacheLumpNum(flatnum, PU_GETNAME));
}
