You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
651 lines
14 KiB
651 lines
14 KiB
/* |
|
Copyright (C) 1997-2001 Id Software, Inc. |
|
|
|
This program is free software; you can redistribute it and/or |
|
modify it under the terms of the GNU General Public License |
|
as published by the Free Software Foundation; either version 2 |
|
of the License, or (at your option) any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|
|
|
See the GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program; if not, write to the Free Software |
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
|
|
|
*/ |
|
// r_surf.c: surface-related refresh code |
|
|
|
#include "r_local.h" |
|
|
|
drawsurf_t r_drawsurf; |
|
|
|
int lightleft, sourcesstep, blocksize, sourcetstep; |
|
int lightdelta, lightdeltastep; |
|
int lightright, lightleftstep, lightrightstep, blockdivshift; |
|
unsigned blockdivmask; |
|
void *prowdestbase; |
|
unsigned char *pbasesource; |
|
int surfrowbytes; // used by ASM files |
|
unsigned *r_lightptr; |
|
int r_stepback; |
|
int r_lightwidth; |
|
int r_numhblocks, r_numvblocks; |
|
unsigned char *r_source, *r_sourcemax; |
|
|
|
void R_DrawSurfaceBlock8_mip0 (void); |
|
void R_DrawSurfaceBlock8_mip1 (void); |
|
void R_DrawSurfaceBlock8_mip2 (void); |
|
void R_DrawSurfaceBlock8_mip3 (void); |
|
|
|
static void (*surfmiptable[4])(void) = { |
|
R_DrawSurfaceBlock8_mip0, |
|
R_DrawSurfaceBlock8_mip1, |
|
R_DrawSurfaceBlock8_mip2, |
|
R_DrawSurfaceBlock8_mip3 |
|
}; |
|
|
|
void R_BuildLightMap (void); |
|
extern unsigned blocklights[1024]; // allow some very large lightmaps |
|
|
|
float surfscale; |
|
qboolean r_cache_thrash; // set if surface cache is thrashing |
|
|
|
int sc_size; |
|
surfcache_t *sc_rover, *sc_base; |
|
|
|
/* |
|
=============== |
|
R_TextureAnimation |
|
|
|
Returns the proper texture for a given time and base texture |
|
=============== |
|
*/ |
|
image_t *R_TextureAnimation (mtexinfo_t *tex) |
|
{ |
|
int c; |
|
|
|
if (!tex->next) |
|
return tex->image; |
|
|
|
c = currententity->frame % tex->numframes; |
|
while (c) |
|
{ |
|
tex = tex->next; |
|
c--; |
|
} |
|
|
|
return tex->image; |
|
} |
|
|
|
|
|
/* |
|
=============== |
|
R_DrawSurface |
|
=============== |
|
*/ |
|
void R_DrawSurface (void) |
|
{ |
|
unsigned char *basetptr; |
|
int smax, tmax, twidth; |
|
int u; |
|
int soffset, basetoffset, texwidth; |
|
int horzblockstep; |
|
unsigned char *pcolumndest; |
|
void (*pblockdrawer)(void); |
|
image_t *mt; |
|
|
|
surfrowbytes = r_drawsurf.rowbytes; |
|
|
|
mt = r_drawsurf.image; |
|
|
|
r_source = mt->pixels[r_drawsurf.surfmip]; |
|
|
|
// the fractional light values should range from 0 to (VID_GRADES - 1) << 16 |
|
// from a source range of 0 - 255 |
|
|
|
texwidth = mt->width >> r_drawsurf.surfmip; |
|
|
|
blocksize = 16 >> r_drawsurf.surfmip; |
|
blockdivshift = 4 - r_drawsurf.surfmip; |
|
blockdivmask = (1 << blockdivshift) - 1; |
|
|
|
r_lightwidth = (r_drawsurf.surf->extents[0]>>4)+1; |
|
|
|
r_numhblocks = r_drawsurf.surfwidth >> blockdivshift; |
|
r_numvblocks = r_drawsurf.surfheight >> blockdivshift; |
|
|
|
//============================== |
|
|
|
pblockdrawer = surfmiptable[r_drawsurf.surfmip]; |
|
// TODO: only needs to be set when there is a display settings change |
|
horzblockstep = blocksize; |
|
|
|
smax = mt->width >> r_drawsurf.surfmip; |
|
twidth = texwidth; |
|
tmax = mt->height >> r_drawsurf.surfmip; |
|
sourcetstep = texwidth; |
|
r_stepback = tmax * twidth; |
|
|
|
r_sourcemax = r_source + (tmax * smax); |
|
|
|
soffset = r_drawsurf.surf->texturemins[0]; |
|
basetoffset = r_drawsurf.surf->texturemins[1]; |
|
|
|
// << 16 components are to guarantee positive values for % |
|
soffset = ((soffset >> r_drawsurf.surfmip) + (smax << 16)) % smax; |
|
basetptr = &r_source[((((basetoffset >> r_drawsurf.surfmip) |
|
+ (tmax << 16)) % tmax) * twidth)]; |
|
|
|
pcolumndest = r_drawsurf.surfdat; |
|
|
|
for (u=0 ; u<r_numhblocks; u++) |
|
{ |
|
r_lightptr = blocklights + u; |
|
|
|
prowdestbase = pcolumndest; |
|
|
|
pbasesource = basetptr + soffset; |
|
|
|
(*pblockdrawer)(); |
|
|
|
soffset = soffset + blocksize; |
|
if (soffset >= smax) |
|
soffset = 0; |
|
|
|
pcolumndest += horzblockstep; |
|
} |
|
} |
|
|
|
|
|
//============================================================================= |
|
|
|
#if !id386 |
|
|
|
/* |
|
================ |
|
R_DrawSurfaceBlock8_mip0 |
|
================ |
|
*/ |
|
void R_DrawSurfaceBlock8_mip0 (void) |
|
{ |
|
int v, i, b, lightstep, lighttemp, light; |
|
unsigned char pix, *psource, *prowdest; |
|
|
|
psource = pbasesource; |
|
prowdest = prowdestbase; |
|
|
|
for (v=0 ; v<r_numvblocks ; v++) |
|
{ |
|
// FIXME: make these locals? |
|
// FIXME: use delta rather than both right and left, like ASM? |
|
lightleft = r_lightptr[0]; |
|
lightright = r_lightptr[1]; |
|
r_lightptr += r_lightwidth; |
|
lightleftstep = (r_lightptr[0] - lightleft) >> 4; |
|
lightrightstep = (r_lightptr[1] - lightright) >> 4; |
|
|
|
for (i=0 ; i<16 ; i++) |
|
{ |
|
lighttemp = lightleft - lightright; |
|
lightstep = lighttemp >> 4; |
|
|
|
light = lightright; |
|
|
|
for (b=15; b>=0; b--) |
|
{ |
|
pix = psource[b]; |
|
prowdest[b] = ((unsigned char *)vid.colormap) |
|
[(light & 0xFF00) + pix]; |
|
light += lightstep; |
|
} |
|
|
|
psource += sourcetstep; |
|
lightright += lightrightstep; |
|
lightleft += lightleftstep; |
|
prowdest += surfrowbytes; |
|
} |
|
|
|
if (psource >= r_sourcemax) |
|
psource -= r_stepback; |
|
} |
|
} |
|
|
|
|
|
/* |
|
================ |
|
R_DrawSurfaceBlock8_mip1 |
|
================ |
|
*/ |
|
void R_DrawSurfaceBlock8_mip1 (void) |
|
{ |
|
int v, i, b, lightstep, lighttemp, light; |
|
unsigned char pix, *psource, *prowdest; |
|
|
|
psource = pbasesource; |
|
prowdest = prowdestbase; |
|
|
|
for (v=0 ; v<r_numvblocks ; v++) |
|
{ |
|
// FIXME: make these locals? |
|
// FIXME: use delta rather than both right and left, like ASM? |
|
lightleft = r_lightptr[0]; |
|
lightright = r_lightptr[1]; |
|
r_lightptr += r_lightwidth; |
|
lightleftstep = (r_lightptr[0] - lightleft) >> 3; |
|
lightrightstep = (r_lightptr[1] - lightright) >> 3; |
|
|
|
for (i=0 ; i<8 ; i++) |
|
{ |
|
lighttemp = lightleft - lightright; |
|
lightstep = lighttemp >> 3; |
|
|
|
light = lightright; |
|
|
|
for (b=7; b>=0; b--) |
|
{ |
|
pix = psource[b]; |
|
prowdest[b] = ((unsigned char *)vid.colormap) |
|
[(light & 0xFF00) + pix]; |
|
light += lightstep; |
|
} |
|
|
|
psource += sourcetstep; |
|
lightright += lightrightstep; |
|
lightleft += lightleftstep; |
|
prowdest += surfrowbytes; |
|
} |
|
|
|
if (psource >= r_sourcemax) |
|
psource -= r_stepback; |
|
} |
|
} |
|
|
|
|
|
/* |
|
================ |
|
R_DrawSurfaceBlock8_mip2 |
|
================ |
|
*/ |
|
void R_DrawSurfaceBlock8_mip2 (void) |
|
{ |
|
int v, i, b, lightstep, lighttemp, light; |
|
unsigned char pix, *psource, *prowdest; |
|
|
|
psource = pbasesource; |
|
prowdest = prowdestbase; |
|
|
|
for (v=0 ; v<r_numvblocks ; v++) |
|
{ |
|
// FIXME: make these locals? |
|
// FIXME: use delta rather than both right and left, like ASM? |
|
lightleft = r_lightptr[0]; |
|
lightright = r_lightptr[1]; |
|
r_lightptr += r_lightwidth; |
|
lightleftstep = (r_lightptr[0] - lightleft) >> 2; |
|
lightrightstep = (r_lightptr[1] - lightright) >> 2; |
|
|
|
for (i=0 ; i<4 ; i++) |
|
{ |
|
lighttemp = lightleft - lightright; |
|
lightstep = lighttemp >> 2; |
|
|
|
light = lightright; |
|
|
|
for (b=3; b>=0; b--) |
|
{ |
|
pix = psource[b]; |
|
prowdest[b] = ((unsigned char *)vid.colormap) |
|
[(light & 0xFF00) + pix]; |
|
light += lightstep; |
|
} |
|
|
|
psource += sourcetstep; |
|
lightright += lightrightstep; |
|
lightleft += lightleftstep; |
|
prowdest += surfrowbytes; |
|
} |
|
|
|
if (psource >= r_sourcemax) |
|
psource -= r_stepback; |
|
} |
|
} |
|
|
|
|
|
/* |
|
================ |
|
R_DrawSurfaceBlock8_mip3 |
|
================ |
|
*/ |
|
void R_DrawSurfaceBlock8_mip3 (void) |
|
{ |
|
int v, i, b, lightstep, lighttemp, light; |
|
unsigned char pix, *psource, *prowdest; |
|
|
|
psource = pbasesource; |
|
prowdest = prowdestbase; |
|
|
|
for (v=0 ; v<r_numvblocks ; v++) |
|
{ |
|
// FIXME: make these locals? |
|
// FIXME: use delta rather than both right and left, like ASM? |
|
lightleft = r_lightptr[0]; |
|
lightright = r_lightptr[1]; |
|
r_lightptr += r_lightwidth; |
|
lightleftstep = (r_lightptr[0] - lightleft) >> 1; |
|
lightrightstep = (r_lightptr[1] - lightright) >> 1; |
|
|
|
for (i=0 ; i<2 ; i++) |
|
{ |
|
lighttemp = lightleft - lightright; |
|
lightstep = lighttemp >> 1; |
|
|
|
light = lightright; |
|
|
|
for (b=1; b>=0; b--) |
|
{ |
|
pix = psource[b]; |
|
prowdest[b] = ((unsigned char *)vid.colormap) |
|
[(light & 0xFF00) + pix]; |
|
light += lightstep; |
|
} |
|
|
|
psource += sourcetstep; |
|
lightright += lightrightstep; |
|
lightleft += lightleftstep; |
|
prowdest += surfrowbytes; |
|
} |
|
|
|
if (psource >= r_sourcemax) |
|
psource -= r_stepback; |
|
} |
|
} |
|
|
|
#endif |
|
|
|
|
|
//============================================================================ |
|
|
|
|
|
/* |
|
================ |
|
R_InitCaches |
|
|
|
================ |
|
*/ |
|
void R_InitCaches (void) |
|
{ |
|
int size; |
|
int pix; |
|
|
|
// calculate size to allocate |
|
if (sw_surfcacheoverride->value) |
|
{ |
|
size = sw_surfcacheoverride->value; |
|
} |
|
else |
|
{ |
|
size = SURFCACHE_SIZE_AT_320X240; |
|
|
|
pix = vid.width*vid.height; |
|
if (pix > 64000) |
|
size += (pix-64000)*3; |
|
} |
|
|
|
// round up to page size |
|
size = (size + 8191) & ~8191; |
|
|
|
ri.Con_Printf (PRINT_ALL,"%ik surface cache\n", size/1024); |
|
|
|
sc_size = size; |
|
sc_base = (surfcache_t *)malloc(size); |
|
sc_rover = sc_base; |
|
|
|
sc_base->next = NULL; |
|
sc_base->owner = NULL; |
|
sc_base->size = sc_size; |
|
} |
|
|
|
|
|
/* |
|
================== |
|
D_FlushCaches |
|
================== |
|
*/ |
|
void D_FlushCaches (void) |
|
{ |
|
surfcache_t *c; |
|
|
|
if (!sc_base) |
|
return; |
|
|
|
for (c = sc_base ; c ; c = c->next) |
|
{ |
|
if (c->owner) |
|
*c->owner = NULL; |
|
} |
|
|
|
sc_rover = sc_base; |
|
sc_base->next = NULL; |
|
sc_base->owner = NULL; |
|
sc_base->size = sc_size; |
|
} |
|
|
|
/* |
|
================= |
|
D_SCAlloc |
|
================= |
|
*/ |
|
surfcache_t *D_SCAlloc (int width, int size) |
|
{ |
|
surfcache_t *new; |
|
qboolean wrapped_this_time; |
|
|
|
if ((width < 0) || (width > 256)) |
|
ri.Sys_Error (ERR_FATAL,"D_SCAlloc: bad cache width %d\n", width); |
|
|
|
if ((size <= 0) || (size > 0x10000)) |
|
ri.Sys_Error (ERR_FATAL,"D_SCAlloc: bad cache size %d\n", size); |
|
|
|
size = (int)&((surfcache_t *)0)->data[size]; |
|
size = (size + 3) & ~3; |
|
if (size > sc_size) |
|
ri.Sys_Error (ERR_FATAL,"D_SCAlloc: %i > cache size of %i",size, sc_size); |
|
|
|
// if there is not size bytes after the rover, reset to the start |
|
wrapped_this_time = false; |
|
|
|
if ( !sc_rover || (byte *)sc_rover - (byte *)sc_base > sc_size - size) |
|
{ |
|
if (sc_rover) |
|
{ |
|
wrapped_this_time = true; |
|
} |
|
sc_rover = sc_base; |
|
} |
|
|
|
// colect and free surfcache_t blocks until the rover block is large enough |
|
new = sc_rover; |
|
if (sc_rover->owner) |
|
*sc_rover->owner = NULL; |
|
|
|
while (new->size < size) |
|
{ |
|
// free another |
|
sc_rover = sc_rover->next; |
|
if (!sc_rover) |
|
ri.Sys_Error (ERR_FATAL,"D_SCAlloc: hit the end of memory"); |
|
if (sc_rover->owner) |
|
*sc_rover->owner = NULL; |
|
|
|
new->size += sc_rover->size; |
|
new->next = sc_rover->next; |
|
} |
|
|
|
// create a fragment out of any leftovers |
|
if (new->size - size > 256) |
|
{ |
|
sc_rover = (surfcache_t *)( (byte *)new + size); |
|
sc_rover->size = new->size - size; |
|
sc_rover->next = new->next; |
|
sc_rover->width = 0; |
|
sc_rover->owner = NULL; |
|
new->next = sc_rover; |
|
new->size = size; |
|
} |
|
else |
|
sc_rover = new->next; |
|
|
|
new->width = width; |
|
// DEBUG |
|
if (width > 0) |
|
new->height = (size - sizeof(*new) + sizeof(new->data)) / width; |
|
|
|
new->owner = NULL; // should be set properly after return |
|
|
|
if (d_roverwrapped) |
|
{ |
|
if (wrapped_this_time || (sc_rover >= d_initial_rover)) |
|
r_cache_thrash = true; |
|
} |
|
else if (wrapped_this_time) |
|
{ |
|
d_roverwrapped = true; |
|
} |
|
|
|
return new; |
|
} |
|
|
|
|
|
/* |
|
================= |
|
D_SCDump |
|
================= |
|
*/ |
|
void D_SCDump (void) |
|
{ |
|
surfcache_t *test; |
|
|
|
for (test = sc_base ; test ; test = test->next) |
|
{ |
|
if (test == sc_rover) |
|
ri.Con_Printf (PRINT_ALL,"ROVER:\n"); |
|
ri.Con_Printf (PRINT_ALL,"%p : %i bytes %i width\n",test, test->size, test->width); |
|
} |
|
} |
|
|
|
//============================================================================= |
|
|
|
// if the num is not a power of 2, assume it will not repeat |
|
|
|
int MaskForNum (int num) |
|
{ |
|
if (num==128) |
|
return 127; |
|
if (num==64) |
|
return 63; |
|
if (num==32) |
|
return 31; |
|
if (num==16) |
|
return 15; |
|
return 255; |
|
} |
|
|
|
int D_log2 (int num) |
|
{ |
|
int c; |
|
|
|
c = 0; |
|
|
|
while (num>>=1) |
|
c++; |
|
return c; |
|
} |
|
|
|
//============================================================================= |
|
|
|
/* |
|
================ |
|
D_CacheSurface |
|
================ |
|
*/ |
|
surfcache_t *D_CacheSurface (msurface_t *surface, int miplevel) |
|
{ |
|
surfcache_t *cache; |
|
|
|
// |
|
// if the surface is animating or flashing, flush the cache |
|
// |
|
r_drawsurf.image = R_TextureAnimation (surface->texinfo); |
|
r_drawsurf.lightadj[0] = r_newrefdef.lightstyles[surface->styles[0]].white*128; |
|
r_drawsurf.lightadj[1] = r_newrefdef.lightstyles[surface->styles[1]].white*128; |
|
r_drawsurf.lightadj[2] = r_newrefdef.lightstyles[surface->styles[2]].white*128; |
|
r_drawsurf.lightadj[3] = r_newrefdef.lightstyles[surface->styles[3]].white*128; |
|
|
|
// |
|
// see if the cache holds apropriate data |
|
// |
|
cache = surface->cachespots[miplevel]; |
|
|
|
if (cache && !cache->dlight && surface->dlightframe != r_framecount |
|
&& cache->image == r_drawsurf.image |
|
&& cache->lightadj[0] == r_drawsurf.lightadj[0] |
|
&& cache->lightadj[1] == r_drawsurf.lightadj[1] |
|
&& cache->lightadj[2] == r_drawsurf.lightadj[2] |
|
&& cache->lightadj[3] == r_drawsurf.lightadj[3] ) |
|
return cache; |
|
|
|
// |
|
// determine shape of surface |
|
// |
|
surfscale = 1.0 / (1<<miplevel); |
|
r_drawsurf.surfmip = miplevel; |
|
r_drawsurf.surfwidth = surface->extents[0] >> miplevel; |
|
r_drawsurf.rowbytes = r_drawsurf.surfwidth; |
|
r_drawsurf.surfheight = surface->extents[1] >> miplevel; |
|
|
|
// |
|
// allocate memory if needed |
|
// |
|
if (!cache) // if a texture just animated, don't reallocate it |
|
{ |
|
cache = D_SCAlloc (r_drawsurf.surfwidth, |
|
r_drawsurf.surfwidth * r_drawsurf.surfheight); |
|
surface->cachespots[miplevel] = cache; |
|
cache->owner = &surface->cachespots[miplevel]; |
|
cache->mipscale = surfscale; |
|
} |
|
|
|
if (surface->dlightframe == r_framecount) |
|
cache->dlight = 1; |
|
else |
|
cache->dlight = 0; |
|
|
|
r_drawsurf.surfdat = (pixel_t *)cache->data; |
|
|
|
cache->image = r_drawsurf.image; |
|
cache->lightadj[0] = r_drawsurf.lightadj[0]; |
|
cache->lightadj[1] = r_drawsurf.lightadj[1]; |
|
cache->lightadj[2] = r_drawsurf.lightadj[2]; |
|
cache->lightadj[3] = r_drawsurf.lightadj[3]; |
|
|
|
// |
|
// draw and light the surface texture |
|
// |
|
r_drawsurf.surf = surface; |
|
|
|
c_surf++; |
|
|
|
// calculate the lightings |
|
R_BuildLightMap (); |
|
|
|
// rasterize the surface into the cache |
|
R_DrawSurface (); |
|
|
|
return cache; |
|
} |
|
|
|
|
|
|