Xash3D FWGS engine.

1429 lines
32 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"
#include "mod_local.h"
drawsurf_t r_drawsurf;
uint lightleft, sourcesstep, blocksize, sourcetstep;
uint lightdelta, lightdeltastep;
uint lightright, lightleftstep, lightrightstep, blockdivshift;
unsigned blockdivmask;
void *prowdestbase;
pixel_t *pbasesource;
int surfrowbytes; // used by ASM files
unsigned *r_lightptr;
int r_stepback;
int r_lightwidth;
int r_numhblocks, r_numvblocks;
pixel_t *r_source, *r_sourcemax;
void R_DrawSurfaceBlock8_mip0 (void);
void R_DrawSurfaceBlock8_mip1 (void);
void R_DrawSurfaceBlock8_mip2 (void);
void R_DrawSurfaceBlock8_mip3 (void);
void R_DrawSurfaceBlock8_Generic (void);
void R_DrawSurfaceBlock8_World (void);
static float worldlux_s, worldlux_t;
static void (*surfmiptable[4])(void) = {
R_DrawSurfaceBlock8_mip0,
R_DrawSurfaceBlock8_mip1,
R_DrawSurfaceBlock8_mip2,
R_DrawSurfaceBlock8_mip3
};
//void R_BuildLightMap (void);
extern unsigned blocklights[10240]; // 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;
static int rtable[MOD_FRAMES][MOD_FRAMES];
#if 1
static void R_BuildLightMap( void );
/*
===============
R_AddDynamicLights
===============
*/
void R_AddDynamicLights( msurface_t *surf )
{
float dist, rad, minlight;
int lnum, s, t, sd, td, smax, tmax;
float sl, tl, sacc, tacc;
vec3_t impact, origin_l;
mextrasurf_t *info = surf->info;
int sample_frac = 1.0;
float sample_size;
mtexinfo_t *tex;
dlight_t *dl;
uint *bl;
// no dlighted surfaces here
//if( !R_CountSurfaceDlights( surf )) return;
sample_size = gEngfuncs.Mod_SampleSizeForFace( surf );
smax = (info->lightextents[0] / sample_size) + 1;
tmax = (info->lightextents[1] / sample_size) + 1;
tex = surf->texinfo;
if( FBitSet( tex->flags, TEX_WORLD_LUXELS ))
{
if( surf->texinfo->faceinfo )
sample_frac = surf->texinfo->faceinfo->texture_step;
else if( FBitSet( surf->texinfo->flags, TEX_EXTRA_LIGHTMAP ))
sample_frac = LM_SAMPLE_EXTRASIZE;
else sample_frac = LM_SAMPLE_SIZE;
}
for( lnum = 0; lnum < MAX_DLIGHTS; lnum++ )
{
if( !FBitSet( surf->dlightbits, BIT( lnum )))
continue; // not lit by this light
dl = gEngfuncs.GetDynamicLight( lnum );
// transform light origin to local bmodel space
if( !tr.modelviewIdentity )
Matrix4x4_VectorITransform( RI.objectMatrix, dl->origin, origin_l );
else
VectorCopy( dl->origin, origin_l );
rad = dl->radius;
dist = PlaneDiff( origin_l, surf->plane );
rad -= fabs( dist );
// rad is now the highest intensity on the plane
minlight = dl->minlight;
if( rad < minlight )
continue;
minlight = rad - minlight;
if( surf->plane->type < 3 )
{
VectorCopy( origin_l, impact );
impact[surf->plane->type] -= dist;
}
else VectorMA( origin_l, -dist, surf->plane->normal, impact );
sl = DotProduct( impact, info->lmvecs[0] ) + info->lmvecs[0][3] - info->lightmapmins[0];
tl = DotProduct( impact, info->lmvecs[1] ) + info->lmvecs[1][3] - info->lightmapmins[1];
bl = blocklights;
for( t = 0, tacc = 0; t < tmax; t++, tacc += sample_size )
{
td = (tl - tacc) * sample_frac;
if( td < 0 ) td = -td;
for( s = 0, sacc = 0; s < smax; s++, sacc += sample_size, bl += 1 )
{
sd = (sl - sacc) * sample_frac;
if( sd < 0 ) sd = -sd;
if( sd > td ) dist = sd + (td >> 1);
else dist = td + (sd >> 1);
if( dist < minlight )
{
//printf("dlight %f\n", dist);
//*(void**)0 = 0;
bl[0] += ((int)((rad - dist) * 256) * gEngfuncs.LightToTexGamma( (dl->color.r + dl->color.g + dl->color.b ) / 3) * 3) / 256;
//bl[1] += ((int)((rad - dist) * 256) * 2.5) / 256;
//bl[2] += ((int)((rad - dist) * 256) * 2.5) / 256;
}
}
}
}
}
/*
=================
R_BuildLightmap
Combine and scale multiple lightmaps into the floating
format in r_blocklights
=================
*/
static void R_BuildLightMap( void )
{
int smax, tmax;
uint *bl, scale;
int i, map, size, s, t;
int sample_size;
msurface_t *surf = r_drawsurf.surf;
mextrasurf_t *info = surf->info;
color24 *lm;
qboolean dynamic = 0;
sample_size = gEngfuncs.Mod_SampleSizeForFace( surf );
smax = ( info->lightextents[0] / sample_size ) + 1;
tmax = ( info->lightextents[1] / sample_size ) + 1;
//smax = (surf->extents[0]>>4)+1;
//tmax = (surf->extents[1]>>4)+1;
size = smax * tmax;
if( surf->flags & SURF_CONVEYOR )
{
smax = ( info->lightextents[0] * 3 / sample_size ) + 1;
size = smax * tmax;
memset( blocklights, 0xff, sizeof( uint ) * size );
return;
}
lm = surf->samples;
memset( blocklights, 0, sizeof( uint ) * size );
// add all the lightmaps
for( map = 0; map < MAXLIGHTMAPS && surf->styles[map] != 255; map++ )
{
scale = tr.lightstylevalue[surf->styles[map]];
for( i = 0, bl = blocklights; i < size; i++, bl += 1, lm++ )
{
bl[0] += gEngfuncs.LightToTexGamma( lm->r ) * scale;
bl[0] += gEngfuncs.LightToTexGamma( lm->g ) * scale;
bl[0] += gEngfuncs.LightToTexGamma( lm->b ) * scale;
//printf("test\n");
//bl[1] += gEngfuncs.LightToTexGamma( lm->g ) * scale;
//bl[2] += gEngfuncs.LightToTexGamma( lm->b ) * scale;
}
}
// add all the dynamic lights
if( surf->dlightframe == tr.framecount )
R_AddDynamicLights( surf );
// Put into texture format
//stride -= (smax << 2);
//bl = blocklights;
/*for( t = 0; t < tmax; t++, dest += stride )
{
for( s = 0; s < smax; s++ )
{
dest[0] = Q_min((bl[0] >> 7), 255 );
//dest[1] = Q_min((bl[1] >> 7), 255 );
//dest[2] = Q_min((bl[2] >> 7), 255 );
//dest[3] = 255;
bl += 3;
dest += 4;
}
}*/
// bound, invert, and shift
for (i=0 ; i<size ; i++)
{
t = (int)blocklights[i];
if (t < 0)
t = 0;
if( t > 65535 * 3 )
t = 65535 * 3;
t = t / 2048 / 3;//(255*256 - t) >> (8 - VID_CBITS);
//if (t < (1 << 6))
//t = (1 << 6);
t = t << 8;
blocklights[i] = t;
}
}
#else
/*
===============
R_BuildLightMap
Combine and scale multiple lightmaps into the 8.8 format in blocklights
===============
*/
void R_BuildLightMap (void)
{
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;
mextrasurf_t *info = surf->info;
int sample_size = gEngfuncs.Mod_SampleSizeForFace( surf );
smax = ( info->lightextents[0] / sample_size ) + 1;
tmax = ( info->lightextents[1] / sample_size ) + 1;
size = smax*tmax;
if (r_fullbright->value )
{
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*3] * 2.5; // * scale;
blocklights[i] += lightmap[i*3+1] * 2.5; // * scale;
blocklights[i] += lightmap[i*3+2] * 2.5; // * 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;
}*/
for (i=0 ; i<size ; i++)
{
t = (int)blocklights[i];
if (t < 0)
t = 0;
if( t > 767 )
t = 767;
t = t * 31 / 256/3;//(255*256 - t) >> (8 - VID_CBITS);
//if (t < (1 << 6))
//t = (1 << 6);
t = t << 8;
blocklights[i] = t;
}
}
#endif
void R_InitRandomTable( void )
{
int tu, tv;
for( tu = 0; tu < MOD_FRAMES; tu++ )
{
for( tv = 0; tv < MOD_FRAMES; tv++ )
{
rtable[tu][tv] = gEngfuncs.COM_RandomLong( 0, 0x7FFF );
}
}
gEngfuncs.COM_SetRandomSeed( 0 );
}
/*
===============
R_TextureAnim
Returns the proper texture for a given time and base texture, do not process random tiling
===============
*/
texture_t *R_TextureAnim( texture_t *b )
{
texture_t *base = b;
int count, reletive;
if( RI.currententity->curstate.frame )
{
if( base->alternate_anims )
base = base->alternate_anims;
}
if( !base->anim_total )
return base;
if( base->name[0] == '-' )
{
return b; // already tiled
}
else
{
int speed;
// Quake1 textures uses 10 frames per second
if( FBitSet( R_GetTexture( base->gl_texturenum )->flags, TF_QUAKEPAL ))
speed = 10;
else speed = 20;
reletive = (int)(gpGlobals->time * speed) % base->anim_total;
}
count = 0;
while( base->anim_min > reletive || base->anim_max <= reletive )
{
base = base->anim_next;
if( !base || ++count > MOD_FRAMES )
return b;
}
return base;
}
/*
===============
R_TextureAnimation
Returns the proper texture for a given time and surface
===============
*/
texture_t *R_TextureAnimation( msurface_t *s )
{
texture_t *base = s->texinfo->texture;
int count, reletive;
if( RI.currententity && RI.currententity->curstate.frame )
{
if( base->alternate_anims )
base = base->alternate_anims;
}
if( !base->anim_total )
return base;
if( base->name[0] == '-' )
{
int tx = (int)((s->texturemins[0] + (base->width << 16)) / base->width) % MOD_FRAMES;
int ty = (int)((s->texturemins[1] + (base->height << 16)) / base->height) % MOD_FRAMES;
reletive = rtable[tx][ty] % base->anim_total;
}
else
{
int speed;
// Quake1 textures uses 10 frames per second
if( FBitSet( R_GetTexture( base->gl_texturenum )->flags, TF_QUAKEPAL ))
speed = 10;
else speed = 20;
reletive = (int)(gpGlobals->time * speed) % base->anim_total;
}
count = 0;
while( base->anim_min > reletive || base->anim_max <= reletive )
{
base = base->anim_next;
if( !base || ++count > MOD_FRAMES )
return s->texinfo->texture;
}
return base;
}
/*
===============
R_DrawSurface
===============
*/
void R_DrawSurface (void)
{
pixel_t *basetptr;
int smax, tmax, twidth;
int u;
int soffset, basetoffset, texwidth;
int horzblockstep;
pixel_t *pcolumndest;
void (*pblockdrawer)(void);
image_t *mt;
uint sample_size, sample_bits, sample_pot;
surfrowbytes = r_drawsurf.rowbytes;
sample_size = LM_SAMPLE_SIZE_AUTO(r_drawsurf.surf);
if( sample_size == 16 )
sample_bits = 4, sample_pot = sample_size;
else
{
sample_bits = tr.sample_bits;
if( sample_bits == -1 )
{
sample_bits = 0;
for( sample_pot = 1; sample_pot < sample_size; sample_pot <<= 1, sample_bits++ );
}
else
sample_pot = 1 << sample_bits;
}
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 = sample_pot >> r_drawsurf.surfmip;
blockdivshift = sample_bits - r_drawsurf.surfmip;
blockdivmask = (1 << blockdivshift) - 1;
if( sample_size == 16 )
r_lightwidth = ( r_drawsurf.surf->info->lightextents[0]>>4)+1;
else
r_lightwidth = ( r_drawsurf.surf->info->lightextents[0] / sample_size ) + 1;
r_numhblocks = r_drawsurf.surfwidth >> blockdivshift;
r_numvblocks = r_drawsurf.surfheight >> blockdivshift;
//==============================
if( sample_size == 16 )
pblockdrawer = surfmiptable[r_drawsurf.surfmip];
else
pblockdrawer = R_DrawSurfaceBlock8_Generic;
// 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);
// glitchy and slow way to draw some lightmap
if( r_drawsurf.surf->texinfo->flags & TEX_WORLD_LUXELS )
{
worldlux_s = r_drawsurf.surf->extents[0] / r_drawsurf.surf->info->lightextents[0];
worldlux_t = r_drawsurf.surf->extents[1] / r_drawsurf.surf->info->lightextents[1];
if( worldlux_s == 0 )
worldlux_s = 1;
if( worldlux_t == 0 )
worldlux_t = 1;
soffset = r_drawsurf.surf->texturemins[0];
basetoffset = r_drawsurf.surf->texturemins[1];
//soffset = r_drawsurf.surf->info->lightmapmins[0] * worldlux_s;
//basetoffset = r_drawsurf.surf->info->lightmapmins[1] * worldlux_t;
// << 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 + (int)(u/ (worldlux_s+0.5f));
prowdestbase = pcolumndest;
pbasesource = basetptr + soffset;
R_DrawSurfaceBlock8_World();
soffset = soffset + blocksize;
if (soffset >= smax)
soffset = 0;
pcolumndest += horzblockstep;
}
return;
}
soffset = r_drawsurf.surf->info->lightmapmins[0];
basetoffset = r_drawsurf.surf->info->lightmapmins[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;
}
// test what if we have very slow cache building
//usleep(10000);
}
//=============================================================================
#if !id386
#define BLEND_LM(pix, light) vid.colormap[(pix >> 3) | ((light & 0x1f00) << 5)] | ( pix & 7 );
/*
================
R_DrawSurfaceBlock8_World
Does not draw lightmap correclty, but scale it correctly. Better than nothing
================
*/
void R_DrawSurfaceBlock8_World (void)
{
int v, i, b;
uint lightstep, lighttemp, light;
pixel_t pix, *psource, *prowdest;
int lightpos = 0;
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[(lightpos/r_lightwidth) * r_lightwidth];
lightright = r_lightptr[(lightpos/r_lightwidth) * r_lightwidth+1];
lightpos += r_lightwidth / worldlux_s;
lightleftstep = (r_lightptr[(lightpos/r_lightwidth) * r_lightwidth] - lightleft) >> (4-r_drawsurf.surfmip);
lightrightstep =(r_lightptr[(lightpos/r_lightwidth) * r_lightwidth+1] - lightright) >> (4-r_drawsurf.surfmip);
for (i=0 ; i<blocksize ; i++)
{
lighttemp = lightleft - lightright;
lightstep = lighttemp >> (4-r_drawsurf.surfmip);
light = lightright;
for (b=blocksize-1; b>=0; b--)
{
//pix = psource[(uint)(b * worldlux_s)];
pix = psource[b];
prowdest[b] = BLEND_LM(pix, light);
if( pix == TRANSPARENT_COLOR )
prowdest[b] = TRANSPARENT_COLOR;
//((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_Generic
================
*/
void R_DrawSurfaceBlock8_Generic (void)
{
int v, i, b;
uint lightstep, lighttemp, light;
pixel_t 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-r_drawsurf.surfmip);
lightrightstep = (r_lightptr[1] - lightright) >> (4-r_drawsurf.surfmip);
for (i=0 ; i<blocksize ; i++)
{
lighttemp = lightleft - lightright;
lightstep = lighttemp >> (4-r_drawsurf.surfmip);
light = lightright;
for (b=blocksize-1; b>=0; b--)
{
pix = psource[b];
prowdest[b] = BLEND_LM(pix, light);
if( pix == TRANSPARENT_COLOR )
prowdest[b] = TRANSPARENT_COLOR;
//((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_mip0
================
*/
void R_DrawSurfaceBlock8_mip0 (void)
{
int v, i, b;
uint lightstep, lighttemp, light;
pixel_t 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] = BLEND_LM(pix, light);
if( pix == TRANSPARENT_COLOR )
prowdest[b] = TRANSPARENT_COLOR;
// pix;
//((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;
uint lightstep, lighttemp, light;
pixel_t 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] = BLEND_LM(pix, light);
//((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;
uint lightstep, lighttemp, light;
pixel_t 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] = BLEND_LM(pix, light);;
//((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;
uint lightstep, lighttemp, light;
pixel_t 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] = BLEND_LM(pix, light);;
//((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 * 2;
pix = vid.width * vid.height * 2;
if (pix > 64000)
size += (pix-64000)*3;
}
// round up to page size
size = (size + 8191) & ~8191;
gEngfuncs.Con_Printf ("%s surface cache\n", Q_memprint(size));
sc_size = size;
if( sc_base )
{
D_FlushCaches( );
Mem_Free( sc_base );
}
sc_base = (surfcache_t *)Mem_Calloc(r_temppool,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 newmap, surfaces already freed
if( !tr.map_unload )
{
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))
gEngfuncs.Host_Error ("D_SCAlloc: bad cache width %d\n", width);
if ((size <= 0) || (size > 0x10000000))
gEngfuncs.Host_Error ("D_SCAlloc: bad cache size %d\n", size);
size = (int)&((surfcache_t *)0)->data[size];
size = (size + 3) & ~3;
if (size > sc_size)
gEngfuncs.Host_Error ("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)
gEngfuncs.Host_Error ("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)
gEngfuncs.Con_Printf ("ROVER:\n");
gEngfuncs.Con_Printf ("%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;
}
//=============================================================================
void R_DecalComputeBasis( msurface_t *surf, int flags, vec3_t textureSpaceBasis[3] );
void R_DrawSurfaceDecals( void )
{
msurface_t *fa = r_drawsurf.surf;
decal_t *p;
for( p = fa->pdecals; p; p = p->pnext)
{
pixel_t *dest, *source;
vec4_t textureU, textureV;
image_t *tex = R_GetTexture( p->texture );
int s1 = 0,t1 = 0, s2 = tex->width, t2 = tex->height;
unsigned int height;
unsigned int f, fstep;
int skip;
pixel_t *buffer;
qboolean transparent;
int x, y, u,v, sv, w, h;
vec3_t basis[3];
Vector4Copy( fa->texinfo->vecs[0], textureU );
Vector4Copy( fa->texinfo->vecs[1], textureV );
R_DecalComputeBasis( fa, 0, basis );
w = fabs( tex->width * DotProduct( textureU, basis[0] )) +
fabs( tex->height * DotProduct( textureU, basis[1] ));
h = fabs( tex->width * DotProduct( textureV, basis[0] )) +
fabs( tex->height * DotProduct( textureV, basis[1] ));
// project decal center into the texture space of the surface
x = DotProduct( p->position, textureU ) + textureU[3] - fa->texturemins[0] - w/2;
y = DotProduct( p->position, textureV ) + textureV[3] - fa->texturemins[1] - h/2;
x = x >> r_drawsurf.surfmip;
y = y >> r_drawsurf.surfmip;
w = w >> r_drawsurf.surfmip;
h = h >> r_drawsurf.surfmip;
if( w < 1 || h < 1 )
continue;
if( x < 0 )
{
s1 += (-x)*(s2-s1) / w;
x = 0;
}
if( x + w > r_drawsurf.surfwidth )
{
s2 -= (x + w - r_drawsurf.surfwidth) * (s2 - s1)/ w ;
w = r_drawsurf.surfwidth - x;
}
if( y + h > r_drawsurf.surfheight )
{
t2 -= (y + h - r_drawsurf.surfheight) * (t2 - t1) / h;
h = r_drawsurf.surfheight - y;
}
if( s1 < 0 )
s1 = 0;
if( t1 < 0 )
t1 = 0;
if( s2 > tex->width )
s2 = tex->width;
if( t2 > tex->height )
t2 = tex->height;
if( !tex->pixels[0] || s1 >= s2 || t1 >= t2 || !w )
continue;
if( tex->alpha_pixels )
{
buffer = tex->alpha_pixels;
transparent = true;
}
else
buffer = tex->pixels[0];
height = h;
if (y < 0)
{
skip = -y;
height += y;
y = 0;
}
else
skip = 0;
dest = ((pixel_t*)r_drawsurf.surfdat) + y * r_drawsurf.rowbytes + x;
for (v=0 ; v<height ; v++)
{
//int alpha1 = vid.alpha;
sv = (skip + v)*(t2-t1)/h + t1;
source = buffer + sv*tex->width + s1;
{
f = 0;
fstep = (s2-s1)*0x10000/w;
if( w == s2 - s1 )
fstep = 0x10000;
for (u=0 ; u<w ; u++)
{
pixel_t src = source[f>>16];
int alpha = 7;
f += fstep;
if( transparent )
{
alpha &= src >> (16 - 3);
src = src << 3;
}
if( alpha <= 0 )
continue;
if( alpha < 7) // && (vid.rendermode == kRenderTransAlpha || vid.rendermode == kRenderTransTexture ) )
{
pixel_t screen = dest[u]; // | 0xff & screen & src ;
if( screen == TRANSPARENT_COLOR )
continue;
dest[u] = BLEND_ALPHA( alpha, src, screen);
}
else
dest[u] = src;
}
}
dest += r_drawsurf.rowbytes;
}
}
}
/*
================
D_CacheSurface
================
*/
surfcache_t *D_CacheSurface (msurface_t *surface, int miplevel)
{
surfcache_t *cache;
int maps;
//
// if the surface is animating or flashing, flush the cache
//
r_drawsurf.image = R_GetTexture(R_TextureAnimation (surface)->gl_texturenum);
// does not support conveyors with world luxels now
if( surface->texinfo->flags & TEX_WORLD_LUXELS )
surface->flags &= ~SURF_CONVEYOR;
if( surface->flags & SURF_CONVEYOR)
{
if( miplevel >= 1)
{
surface->extents[0] = surface->info->lightextents[0] * LM_SAMPLE_SIZE_AUTO( r_drawsurf.surf ) * 2 ;
surface->info->lightmapmins[0] = -surface->info->lightextents[0] * LM_SAMPLE_SIZE_AUTO( r_drawsurf.surf );
}
else
{
surface->extents[0] = surface->info->lightextents[0] * LM_SAMPLE_SIZE_AUTO( r_drawsurf.surf ) ;
surface->info->lightmapmins[0] = -surface->info->lightextents[0] * LM_SAMPLE_SIZE_AUTO( r_drawsurf.surf )/2;
}
}
/// todo: port this
//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 = CACHESPOT(surface)[miplevel];
// check for lightmap modification
for( maps = 0; maps < MAXLIGHTMAPS && surface->styles[maps] != 255; maps++ )
{
if( tr.lightstylevalue[surface->styles[maps]] != surface->cached_light[maps] )
{
surface->dlightframe = tr.framecount;
}
}
if (cache && !cache->dlight && surface->dlightframe != tr.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;
if( surface->dlightframe == tr.framecount )
{
int i;
// invalidate dlight cache
for( i = 0; i < 4; i++)
{
if( CACHESPOT(surface)[i] )
CACHESPOT(surface)[i]->image = NULL;
}
}
//
// determine shape of surface
//
surfscale = 1.0 / (1<<miplevel);
r_drawsurf.surfmip = miplevel;
if( surface->flags & SURF_CONVEYOR )
r_drawsurf.surfwidth = surface->extents[0] >> miplevel;
else
r_drawsurf.surfwidth = surface->info->lightextents[0] >> miplevel;
r_drawsurf.rowbytes = r_drawsurf.surfwidth;
r_drawsurf.surfheight = surface->info->lightextents[1] >> miplevel;
// use texture space if world luxels used
if( surface->texinfo->flags & TEX_WORLD_LUXELS )
{
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 * 2);
CACHESPOT(surface)[miplevel] = cache;
cache->owner = &CACHESPOT(surface)[miplevel];
cache->mipscale = surfscale;
}
if (surface->dlightframe == tr.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];
for( maps = 0; maps < MAXLIGHTMAPS && surface->styles[maps] != 255; maps++ )
{
surface->cached_light[maps] = tr.lightstylevalue[surface->styles[maps]];
}
//
// 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 ();
R_DrawSurfaceDecals();
return cache;
}