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