void R_Init (void)
{
// CPhipps - R_DrawColumn isn't constant anymore, so must
// initialise in code
// current column draw function
lprintf(LO_INFO, "\nR_LoadTrigTables: ");
R_LoadTrigTables();
lprintf(LO_INFO, "\nR_InitData: ");
R_InitData();
R_SetViewSize(screenblocks);
lprintf(LO_INFO, "\nR_Init: R_InitPlanes ");
R_InitPlanes();
lprintf(LO_INFO, "R_InitLightTables ");
R_InitLightTables();
lprintf(LO_INFO, "R_InitSkyMap ");
R_InitSkyMap();
lprintf(LO_INFO, "R_InitTranslationsTables ");
R_InitTranslationTables();
lprintf(LO_INFO, "R_InitPatches ");
R_InitPatches();
}
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)
{
const lumpinfo_t* info = W_GetLumpInfoByNum(names_lump);
wadfile_info_t *wf = M_CBufGet(&resource_files_buf, info->wadfile);
if (wf == NULL) {
I_Error(
"R_InitTextures: Bad wadfile for %s (%d)\n", info->name, info->wadfile
);
}
lprintf(LO_INFO,
"\nR_InitTextures: The file %s seems to be incompatible with \"%s\".\n",
wf->name,
(doomverstr ? doomverstr : "DOOM"));
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;
}
}