Quake-2

r_surf.c (14181B)

---

 /*
 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;
 }