r_surf.c File Reference

#include "r_local.h"

Go to the source code of this file.

Functions
void	R_DrawSurfaceBlock8_mip0 (void)
void	R_DrawSurfaceBlock8_mip1 (void)
void	R_DrawSurfaceBlock8_mip2 (void)
void	R_DrawSurfaceBlock8_mip3 (void)
void	R_BuildLightMap (void)
image_t *	R_TextureAnimation (mtexinfo_t *tex)
void	R_DrawSurface (void)
void	R_InitCaches (void)
void	D_FlushCaches (void)
surfcache_t *	D_SCAlloc (int width, int size)
void	D_SCDump (void)
int	MaskForNum (int num)
int	D_log2 (int num)
surfcache_t *	D_CacheSurface (msurface_t *surface, int miplevel)

Variables
drawsurf_t	r_drawsurf
int	lightleft
int	sourcesstep
int	blocksize
int	sourcetstep
int	lightdelta
int	lightdeltastep
int	lightright
int	lightleftstep
int	lightrightstep
int	blockdivshift
unsigned	blockdivmask
void *	prowdestbase
unsigned char *	pbasesource
int	surfrowbytes
unsigned *	r_lightptr
int	r_stepback
int	r_lightwidth
int	r_numhblocks
int	r_numvblocks
unsigned char *	r_source
unsigned char *	r_sourcemax
static void(*	surfmiptable [4])(void)
unsigned	blocklights [1024]
float	surfscale
qboolean	r_cache_thrash
int	sc_size
surfcache_t *	sc_rover
surfcache_t *	sc_base

Function Documentation

D_CacheSurface()

surfcache_t* D_CacheSurface	(	msurface_t *	surface,
		int	miplevel
	)

Definition at line 575 of file r_surf.c.

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

Referenced by D_SolidSurf(), and R_BuildPolygonFromSurface().

D_FlushCaches()

void D_FlushCaches

(

void

)

Definition at line 418 of file r_surf.c.

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

Referenced by R_BeginRegistration(), R_InitGraphics(), R_SetupFrame(), and R_Shutdown().

D_log2()

int D_log2

(

int

num

)

Definition at line 557 of file r_surf.c.

{
    int     c;
    
    c = 0;
    
    while (num>>=1)
        c++;
    return c;
}

D_SCAlloc()

surfcache_t* D_SCAlloc	(	int	width,
		int	size
	)

Definition at line 442 of file r_surf.c.

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

Referenced by D_CacheSurface().

D_SCDump()

void D_SCDump

(

void

)

Definition at line 528 of file r_surf.c.

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

MaskForNum()

int MaskForNum

(

int

num

)

Definition at line 544 of file r_surf.c.

{
    if (num==128)
        return 127;
    if (num==64)
        return 63;
    if (num==32)
        return 31;
    if (num==16)
        return 15;
    return 255;
}

R_BuildLightMap()

void R_BuildLightMap

(

void

)

Definition at line 384 of file r_light.c.

{
    int         smax, tmax;
    int         t;
    int         i, size;
    byte        *lightmap;
    unsigned    scale;
    int         maps;
    msurface_t  *surf;
 
    surf = r_drawsurf.surf;
 
    smax = (surf->extents[0]>>4)+1;
    tmax = (surf->extents[1]>>4)+1;
    size = smax*tmax;
 
    if (r_fullbright->value || !r_worldmodel->lightdata)
    {
        for (i=0 ; i<size ; i++)
            blocklights[i] = 0;
        return;
    }
 
// clear to no light
    for (i=0 ; i<size ; i++)
        blocklights[i] = 0;
 
 
// add all the lightmaps
    lightmap = surf->samples;
    if (lightmap)
        for (maps = 0 ; maps < MAXLIGHTMAPS && surf->styles[maps] != 255 ;
             maps++)
        {
            scale = r_drawsurf.lightadj[maps];  // 8.8 fraction     
            for (i=0 ; i<size ; i++)
                blocklights[i] += lightmap[i] * scale;
            lightmap += size;   // skip to next lightmap
        }
 
// add all the dynamic lights
    if (surf->dlightframe == r_framecount)
        R_AddDynamicLights ();
 
// bound, invert, and shift
    for (i=0 ; i<size ; i++)
    {
        t = (int)blocklights[i];
        if (t < 0)
            t = 0;
        t = (255*256 - t) >> (8 - VID_CBITS);
 
        if (t < (1 << 6))
            t = (1 << 6);
 
        blocklights[i] = t;
    }
}

Referenced by D_CacheSurface().

R_DrawSurface()

void R_DrawSurface

(

void

)

Definition at line 90 of file r_surf.c.

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

Referenced by D_CacheSurface().

R_DrawSurfaceBlock8_mip0()

void R_DrawSurfaceBlock8_mip0

(

void

)

Definition at line 173 of file r_surf.c.

{
    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

)

Definition at line 223 of file r_surf.c.

{
    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

)

Definition at line 273 of file r_surf.c.

{
    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

)

Definition at line 323 of file r_surf.c.

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

R_InitCaches()

void R_InitCaches

(

void

)

Definition at line 379 of file r_surf.c.

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

Referenced by R_InitGraphics().

R_TextureAnimation()

image_t* R_TextureAnimation

(

mtexinfo_t *

tex

)

Definition at line 67 of file r_surf.c.

{
    int     c;
 
    if (!tex->next)
        return tex->image;
 
    c = currententity->frame % tex->numframes;
    while (c)
    {
        tex = tex->next;
        c--;
    }
 
    return tex->image;
}

Referenced by D_CacheSurface().

Variable Documentation

blockdivmask

unsigned blockdivmask

Definition at line 29 of file r_surf.c.

Referenced by R_DrawSurface().

blockdivshift

int blockdivshift

Definition at line 28 of file r_surf.c.

Referenced by R_DrawSurface().

blocklights

unsigned blocklights[1024]

Definition at line 277 of file r_light.c.

Referenced by R_AddDynamicLights(), R_BuildLightMap(), and R_DrawSurface().

blocksize

int blocksize

Definition at line 26 of file r_surf.c.

Referenced by R_DrawSurface().

lightdelta

int lightdelta

Definition at line 27 of file r_surf.c.

lightdeltastep

int lightdeltastep

Definition at line 27 of file r_surf.c.

lightleft

int lightleft

Definition at line 26 of file r_surf.c.

Referenced by R_DrawSurfaceBlock8_mip0(), R_DrawSurfaceBlock8_mip1(), R_DrawSurfaceBlock8_mip2(), and R_DrawSurfaceBlock8_mip3().

lightleftstep

int lightleftstep

Definition at line 28 of file r_surf.c.

Referenced by R_DrawSurfaceBlock8_mip0(), R_DrawSurfaceBlock8_mip1(), R_DrawSurfaceBlock8_mip2(), and R_DrawSurfaceBlock8_mip3().

lightright

int lightright

Definition at line 28 of file r_surf.c.

Referenced by R_DrawSurfaceBlock8_mip0(), R_DrawSurfaceBlock8_mip1(), R_DrawSurfaceBlock8_mip2(), and R_DrawSurfaceBlock8_mip3().

lightrightstep

int lightrightstep

Definition at line 28 of file r_surf.c.

Referenced by R_DrawSurfaceBlock8_mip0(), R_DrawSurfaceBlock8_mip1(), R_DrawSurfaceBlock8_mip2(), and R_DrawSurfaceBlock8_mip3().

pbasesource

unsigned char* pbasesource

Definition at line 31 of file r_surf.c.

Referenced by R_DrawSurface(), R_DrawSurfaceBlock8_mip0(), R_DrawSurfaceBlock8_mip1(), R_DrawSurfaceBlock8_mip2(), and R_DrawSurfaceBlock8_mip3().

prowdestbase

void* prowdestbase

Definition at line 30 of file r_surf.c.

Referenced by R_DrawSurface(), R_DrawSurfaceBlock8_mip0(), R_DrawSurfaceBlock8_mip1(), R_DrawSurfaceBlock8_mip2(), and R_DrawSurfaceBlock8_mip3().

r_cache_thrash

qboolean r_cache_thrash

Definition at line 55 of file r_surf.c.

Referenced by D_SCAlloc().

r_drawsurf

drawsurf_t r_drawsurf

Definition at line 24 of file r_surf.c.

Referenced by D_CacheSurface(), R_AddDynamicLights(), R_BuildLightMap(), and R_DrawSurface().

r_lightptr

unsigned* r_lightptr

Definition at line 33 of file r_surf.c.

Referenced by R_DrawSurface(), R_DrawSurfaceBlock8_mip0(), R_DrawSurfaceBlock8_mip1(), R_DrawSurfaceBlock8_mip2(), and R_DrawSurfaceBlock8_mip3().

r_lightwidth

int r_lightwidth

Definition at line 35 of file r_surf.c.

Referenced by R_DrawSurface(), R_DrawSurfaceBlock8_mip0(), R_DrawSurfaceBlock8_mip1(), R_DrawSurfaceBlock8_mip2(), and R_DrawSurfaceBlock8_mip3().

r_numhblocks

int r_numhblocks

Definition at line 36 of file r_surf.c.

Referenced by R_DrawSurface().

r_numvblocks

int r_numvblocks

Definition at line 36 of file r_surf.c.

Referenced by R_DrawSurface(), R_DrawSurfaceBlock8_mip0(), R_DrawSurfaceBlock8_mip1(), R_DrawSurfaceBlock8_mip2(), and R_DrawSurfaceBlock8_mip3().

r_source

unsigned char* r_source

Definition at line 37 of file r_surf.c.

Referenced by R_DrawSurface().

r_sourcemax

unsigned char * r_sourcemax

Definition at line 37 of file r_surf.c.

Referenced by R_DrawSurface(), R_DrawSurfaceBlock8_mip0(), R_DrawSurfaceBlock8_mip1(), R_DrawSurfaceBlock8_mip2(), and R_DrawSurfaceBlock8_mip3().

r_stepback

int r_stepback

Definition at line 34 of file r_surf.c.

Referenced by R_DrawSurface(), R_DrawSurfaceBlock8_mip0(), R_DrawSurfaceBlock8_mip1(), R_DrawSurfaceBlock8_mip2(), and R_DrawSurfaceBlock8_mip3().

sc_base

surfcache_t * sc_base

Definition at line 58 of file r_surf.c.

Referenced by D_FlushCaches(), D_SCAlloc(), D_SCDump(), and R_InitCaches().

sc_rover

surfcache_t* sc_rover

Definition at line 58 of file r_surf.c.

Referenced by D_FlushCaches(), D_SCAlloc(), D_SCDump(), R_InitCaches(), and R_SetupFrame().

sc_size

int sc_size

Definition at line 57 of file r_surf.c.

Referenced by D_FlushCaches(), D_SCAlloc(), and R_InitCaches().

sourcesstep

int sourcesstep

Definition at line 26 of file r_surf.c.

sourcetstep

int sourcetstep

Definition at line 26 of file r_surf.c.

Referenced by R_DrawSurface(), R_DrawSurfaceBlock8_mip0(), R_DrawSurfaceBlock8_mip1(), R_DrawSurfaceBlock8_mip2(), and R_DrawSurfaceBlock8_mip3().

surfmiptable

void(* surfmiptable[4])(void)

static

Initial value:

= {
    R_DrawSurfaceBlock8_mip0,
    R_DrawSurfaceBlock8_mip1,
    R_DrawSurfaceBlock8_mip2,
    R_DrawSurfaceBlock8_mip3
}

Definition at line 44 of file r_surf.c.

Referenced by R_DrawSurface().

surfrowbytes

int surfrowbytes

Definition at line 32 of file r_surf.c.

Referenced by R_DrawSurface(), R_DrawSurfaceBlock8_mip0(), R_DrawSurfaceBlock8_mip1(), R_DrawSurfaceBlock8_mip2(), and R_DrawSurfaceBlock8_mip3().

surfscale

float surfscale

Definition at line 54 of file r_surf.c.

Referenced by D_CacheSurface().