quakeforge/libs/video/renderer/sw32/sw32_rsurf.c
Bill Currie a05210d864 [video] Get 16 and 32 bit sw32 mostly working in x11
Lighting on alias models seems to be borked, and skies are borked in
both sw renderers (seems to be nothing to do with this commit, though).
2021-07-11 00:09:41 +09:00

897 lines
23 KiB
C

/*
sw32_rsurf.c
surface-related refresh code
Copyright (C) 1996-1997 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:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#define NH_DEFINE
#include "namehack.h"
#include "QF/entity.h"
#include "QF/render.h"
#include "QF/sys.h"
#include "compat.h"
#include "r_internal.h"
#include "vid_sw.h"
drawsurf_t sw32_r_drawsurf;
static int lightleft, blocksize, sourcetstep;
static int lightright, lightleftstep, lightrightstep, blockdivshift;
static unsigned int blockdivmask;
static byte *prowdestbase;
static byte *psource;
static int surfrowbytes;
static int *r_lightptr;
static int r_stepback;
static int r_lightwidth;
static int r_numhblocks, r_numvblocks;
static byte *r_source, *r_sourcemax;
static void R_DrawSurfaceBlock8_mip0 (void);
static void R_DrawSurfaceBlock8_mip1 (void);
static void R_DrawSurfaceBlock8_mip2 (void);
static void R_DrawSurfaceBlock8_mip3 (void);
static void R_DrawSurfaceBlock16_mip0 (void);
static void R_DrawSurfaceBlock16_mip1 (void);
static void R_DrawSurfaceBlock16_mip2 (void);
static void R_DrawSurfaceBlock16_mip3 (void);
static void R_DrawSurfaceBlock32_mip0 (void);
static void R_DrawSurfaceBlock32_mip1 (void);
static void R_DrawSurfaceBlock32_mip2 (void);
static void R_DrawSurfaceBlock32_mip3 (void);
static void (*surfmiptable8[4]) (void) = {
R_DrawSurfaceBlock8_mip0,
R_DrawSurfaceBlock8_mip1,
R_DrawSurfaceBlock8_mip2,
R_DrawSurfaceBlock8_mip3
};
static void (*surfmiptable16[4]) (void) = {
R_DrawSurfaceBlock16_mip0,
R_DrawSurfaceBlock16_mip1,
R_DrawSurfaceBlock16_mip2,
R_DrawSurfaceBlock16_mip3
};
static void (*surfmiptable32[4]) (void) = {
R_DrawSurfaceBlock32_mip0,
R_DrawSurfaceBlock32_mip1,
R_DrawSurfaceBlock32_mip2,
R_DrawSurfaceBlock32_mip3
};
static int blocklights[34 * 34]; //FIXME make dynamic
static void
R_AddDynamicLights (void)
{
msurface_t *surf;
unsigned int lnum;
int sd, td;
float dist, rad, minlight;
vec3_t impact, local, lightorigin;
vec4f_t entorigin = { 0, 0, 0, 1 };
int s, t;
int i;
int smax, tmax;
mtexinfo_t *tex;
surf = sw32_r_drawsurf.surf;
smax = (surf->extents[0] >> 4) + 1;
tmax = (surf->extents[1] >> 4) + 1;
tex = surf->texinfo;
if (currententity->transform) {
//FIXME give world entity a transform
entorigin = Transform_GetWorldPosition (currententity->transform);
}
for (lnum = 0; lnum < r_maxdlights; lnum++) {
if (!(surf->dlightbits[lnum / 32] & (1 << (lnum % 32))))
continue; // not lit by this light
VectorSubtract (r_dlights[lnum].origin, entorigin, lightorigin);
rad = r_dlights[lnum].radius;
dist = DotProduct (lightorigin, surf->plane->normal) -
surf->plane->dist;
rad -= fabs (dist);
minlight = r_dlights[lnum].minlight;
if (rad < minlight)
continue;
minlight = rad - minlight;
for (i = 0; i < 3; i++)
impact[i] = lightorigin[i] - surf->plane->normal[i] * dist;
local[0] = DotProduct (impact, tex->vecs[0]) + tex->vecs[0][3];
local[1] = DotProduct (impact, tex->vecs[1]) + tex->vecs[1][3];
local[0] -= surf->texturemins[0];
local[1] -= surf->texturemins[1];
for (t = 0; t < tmax; t++) {
td = local[1] - t * 16;
if (td < 0)
td = -td;
for (s = 0; s < smax; s++) {
sd = local[0] - s * 16;
if (sd < 0)
sd = -sd;
if (sd > td)
dist = sd + (td >> 1);
else
dist = td + (sd >> 1);
if (dist < minlight)
blocklights[t * smax + s] += (rad - dist) * 256;
}
}
}
}
/*
R_BuildLightMap
Combine and scale multiple lightmaps into the 8.8 format in blocklights
*/
static void
R_BuildLightMap (void)
{
int smax, tmax;
int t;
int i, size;
byte *lightmap;
unsigned int scale;
int maps;
msurface_t *surf;
surf = sw32_r_drawsurf.surf;
smax = (surf->extents[0] >> 4) + 1;
tmax = (surf->extents[1] >> 4) + 1;
size = smax * tmax;
lightmap = surf->samples;
if (!r_worldentity.renderer.model->brush.lightdata) {
for (i = 0; i < size; i++)
blocklights[i] = 0;
return;
}
// clear to ambient
for (i = 0; i < size; i++)
blocklights[i] = r_refdef.ambientlight << 8;
// add all the lightmaps
if (lightmap)
for (maps = 0; maps < MAXLIGHTMAPS && surf->styles[maps] != 255; maps++) {
scale = sw32_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 ();
/*
* JohnnyonFlame:
* 32 and 16bpp modes uses the positive lighting, unlike 8bpp
*/
switch (sw32_ctx->pixbytes) {
case 1:
// bound, invert, and shift
for (i = 0; i < size; i++) {
t = (255 * 256 - blocklights[i]) >> (8 - VID_CBITS);
if (t < (1 << 6))
t = (1 << 6);
blocklights[i] = t;
}
break;
default:
// LordHavoc: changed to positive (not inverse) lighting
for (i = 0; i < size; i++) {
t = bound(256, blocklights[i] >> (8 - VID_CBITS),
256 * (VID_GRADES - 1));
blocklights[i] = t;
}
break;
}
}
void
sw32_R_DrawSurface (void)
{
byte *basetptr;
int smax, tmax, twidth;
int u;
int soffset, basetoffset, texwidth;
int horzblockstep;
byte *pcolumndest;
void (*pblockdrawer) (void);
texture_t *mt;
// calculate the lightings
R_BuildLightMap ();
surfrowbytes = sw32_r_drawsurf.rowbytes;
mt = sw32_r_drawsurf.texture;
r_source = (byte *) mt + mt->offsets[sw32_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 >> sw32_r_drawsurf.surfmip;
blocksize = 16 >> sw32_r_drawsurf.surfmip;
blockdivshift = 4 - sw32_r_drawsurf.surfmip;
blockdivmask = (1 << blockdivshift) - 1;
r_lightwidth = (sw32_r_drawsurf.surf->extents[0] >> 4) + 1;
r_numhblocks = sw32_r_drawsurf.surfwidth >> blockdivshift;
r_numvblocks = sw32_r_drawsurf.surfheight >> blockdivshift;
//==============================
smax = mt->width >> sw32_r_drawsurf.surfmip;
twidth = texwidth;
tmax = mt->height >> sw32_r_drawsurf.surfmip;
sourcetstep = texwidth;
r_stepback = tmax * twidth;
soffset = sw32_r_drawsurf.surf->texturemins[0];
basetoffset = sw32_r_drawsurf.surf->texturemins[1];
switch (sw32_ctx->pixbytes) {
case 1:
pblockdrawer = surfmiptable8[sw32_r_drawsurf.surfmip];
break;
case 2:
pblockdrawer = surfmiptable16[sw32_r_drawsurf.surfmip];
break;
case 4:
pblockdrawer = surfmiptable32[sw32_r_drawsurf.surfmip];
break;
default:
Sys_Error("R_DrawSurface: unsupported r_pixbytes %i", sw32_ctx->pixbytes);
pblockdrawer = NULL;
}
horzblockstep = blocksize * sw32_ctx->pixbytes;
r_sourcemax = r_source + (tmax * smax);
// << 16 components are to guarantee positive values for %
basetptr = r_source + (((basetoffset >> sw32_r_drawsurf.surfmip) +
(tmax << 16)) % tmax) * twidth;
soffset = (((soffset >> sw32_r_drawsurf.surfmip) + (smax << 16)) % smax);
pcolumndest = (byte *) sw32_r_drawsurf.surfdat;
for (u = 0; u < r_numhblocks; u++) {
r_lightptr = blocklights + u;
prowdestbase = pcolumndest;
psource = basetptr + soffset;
(*pblockdrawer) ();
soffset = soffset + blocksize;
if (soffset >= smax)
soffset = 0;
pcolumndest += horzblockstep;
}
}
//=============================================================================
static void
R_DrawSurfaceBlock8_mip0 (void)
{
int v, i, b, lightstep, light;
unsigned char pix, *prowdest;
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++) {
lightstep = (lightleft - lightright) >> 4;
light = lightright;
for (b = 15; b >= 0; b--) {
pix = psource[b];
prowdest[b] = vid.colormap8[(light & 0xFF00) + pix];
light += lightstep;
}
psource += sourcetstep;
lightright += lightrightstep;
lightleft += lightleftstep;
prowdest += surfrowbytes;
}
if (psource >= r_sourcemax)
psource -= r_stepback;
}
}
static void
R_DrawSurfaceBlock8_mip1 (void)
{
int v, i, b, lightstep, light;
unsigned char pix, *prowdest;
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++) {
lightstep = (lightleft - lightright) >> 3;
light = lightright;
for (b = 7; b >= 0; b--) {
pix = psource[b];
prowdest[b] = vid.colormap8[(light & 0xFF00) + pix];
light += lightstep;
}
psource += sourcetstep;
lightright += lightrightstep;
lightleft += lightleftstep;
prowdest += surfrowbytes;
}
if (psource >= r_sourcemax)
psource -= r_stepback;
}
}
static void
R_DrawSurfaceBlock8_mip2 (void)
{
int v, i, b, lightstep, light;
unsigned char pix, *prowdest;
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++) {
lightstep = (lightleft - lightright) >> 2;
light = lightright;
for (b = 3; b >= 0; b--) {
pix = psource[b];
prowdest[b] = vid.colormap8[(light & 0xFF00) + pix];
light += lightstep;
}
psource += sourcetstep;
lightright += lightrightstep;
lightleft += lightleftstep;
prowdest += surfrowbytes;
}
if (psource >= r_sourcemax)
psource -= r_stepback;
}
}
static void
R_DrawSurfaceBlock8_mip3 (void)
{
int v, i, b, lightstep, light;
unsigned char pix, *prowdest;
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++) {
lightstep = (lightleft - lightright) >> 1;
light = lightright;
for (b = 1; b >= 0; b--) {
pix = psource[b];
prowdest[b] = vid.colormap8[(light & 0xFF00) + pix];
light += lightstep;
}
psource += sourcetstep;
lightright += lightrightstep;
lightleft += lightleftstep;
prowdest += surfrowbytes;
}
if (psource >= r_sourcemax)
psource -= r_stepback;
}
}
static void
R_DrawSurfaceBlock16_mip0 (void)
{
int k, v;
int lightstep, light;
unsigned short *prowdest;
prowdest = (unsigned short *) prowdestbase;
for (v = 0; v < r_numvblocks; v++)
{
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 (k = 0; k < 16; k++)
{
light = lightleft;
lightstep = (lightright - lightleft) >> 4;
prowdest[0] = vid.colormap16[(light & 0xFF00) + psource[0]];
light += lightstep;
prowdest[1] = vid.colormap16[(light & 0xFF00) + psource[1]];
light += lightstep;
prowdest[2] = vid.colormap16[(light & 0xFF00) + psource[2]];
light += lightstep;
prowdest[3] = vid.colormap16[(light & 0xFF00) + psource[3]];
light += lightstep;
prowdest[4] = vid.colormap16[(light & 0xFF00) + psource[4]];
light += lightstep;
prowdest[5] = vid.colormap16[(light & 0xFF00) + psource[5]];
light += lightstep;
prowdest[6] = vid.colormap16[(light & 0xFF00) + psource[6]];
light += lightstep;
prowdest[7] = vid.colormap16[(light & 0xFF00) + psource[7]];
light += lightstep;
prowdest[8] = vid.colormap16[(light & 0xFF00) + psource[8]];
light += lightstep;
prowdest[9] = vid.colormap16[(light & 0xFF00) + psource[9]];
light += lightstep;
prowdest[10] = vid.colormap16[(light & 0xFF00) + psource[10]];
light += lightstep;
prowdest[11] = vid.colormap16[(light & 0xFF00) + psource[11]];
light += lightstep;
prowdest[12] = vid.colormap16[(light & 0xFF00) + psource[12]];
light += lightstep;
prowdest[13] = vid.colormap16[(light & 0xFF00) + psource[13]];
light += lightstep;
prowdest[14] = vid.colormap16[(light & 0xFF00) + psource[14]];
light += lightstep;
prowdest[15] = vid.colormap16[(light & 0xFF00) + psource[15]];
psource += sourcetstep;
lightright += lightrightstep;
lightleft += lightleftstep;
prowdest += (surfrowbytes >> 1);
}
if (psource >= r_sourcemax)
psource -= r_stepback;
}
}
static void
R_DrawSurfaceBlock16_mip1 (void)
{
int k, v;
int lightstep, light;
unsigned short *prowdest;
prowdest = (unsigned short *) prowdestbase;
for (v = 0; v < r_numvblocks; v++)
{
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 (k = 0; k < 8; k++)
{
light = lightleft;
lightstep = (lightright - lightleft) >> 3;
prowdest[0] = vid.colormap16[(light & 0xFF00) + psource[0]];
light += lightstep;
prowdest[1] = vid.colormap16[(light & 0xFF00) + psource[1]];
light += lightstep;
prowdest[2] = vid.colormap16[(light & 0xFF00) + psource[2]];
light += lightstep;
prowdest[3] = vid.colormap16[(light & 0xFF00) + psource[3]];
light += lightstep;
prowdest[4] = vid.colormap16[(light & 0xFF00) + psource[4]];
light += lightstep;
prowdest[5] = vid.colormap16[(light & 0xFF00) + psource[5]];
light += lightstep;
prowdest[6] = vid.colormap16[(light & 0xFF00) + psource[6]];
light += lightstep;
prowdest[7] = vid.colormap16[(light & 0xFF00) + psource[7]];
psource += sourcetstep;
lightright += lightrightstep;
lightleft += lightleftstep;
prowdest += (surfrowbytes >> 1);
}
if (psource >= r_sourcemax)
psource -= r_stepback;
}
}
static void
R_DrawSurfaceBlock16_mip2 (void)
{
int k, v;
int lightstep, light;
unsigned short *prowdest;
prowdest = (unsigned short *) prowdestbase;
for (v = 0; v < r_numvblocks; v++)
{
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 (k = 0; k < 4; k++)
{
light = lightleft;
lightstep = (lightright - lightleft) >> 2;
prowdest[0] = vid.colormap16[(light & 0xFF00) + psource[0]];
light += lightstep;
prowdest[1] = vid.colormap16[(light & 0xFF00) + psource[1]];
light += lightstep;
prowdest[2] = vid.colormap16[(light & 0xFF00) + psource[2]];
light += lightstep;
prowdest[3] = vid.colormap16[(light & 0xFF00) + psource[3]];
psource += sourcetstep;
lightright += lightrightstep;
lightleft += lightleftstep;
prowdest += (surfrowbytes >> 1);
}
if (psource >= r_sourcemax)
psource -= r_stepback;
}
}
static void
R_DrawSurfaceBlock16_mip3 (void)
{
int v;
unsigned short *prowdest;
prowdest = (unsigned short *) prowdestbase;
for (v = 0; v < r_numvblocks; v++)
{
lightleft = r_lightptr[0];
lightright = r_lightptr[1];
r_lightptr += r_lightwidth;
lightleftstep = (r_lightptr[0] - lightleft) >> 1;
lightrightstep = (r_lightptr[1] - lightright) >> 1;
prowdest[0] = vid.colormap16[(lightleft & 0xFF00) + psource[0]];
prowdest[1] = vid.colormap16[(((lightleft + lightright) >> 1) &
0xFF00) + psource[1]];
psource += sourcetstep;
lightright += lightrightstep;
lightleft += lightleftstep;
prowdest += (surfrowbytes >> 1);
prowdest[0] = vid.colormap16[(lightleft & 0xFF00) + psource[0]];
prowdest[1] = vid.colormap16[(((lightleft + lightright) >> 1) &
0xFF00) + psource[1]];
psource += sourcetstep;
prowdest += (surfrowbytes >> 1);
if (psource >= r_sourcemax)
psource -= r_stepback;
}
}
static void
R_DrawSurfaceBlock32_mip0 (void)
{
int k, v;
int lightstep, light;
unsigned int *prowdest;
prowdest = (unsigned int *) prowdestbase;
for (v = 0; v < r_numvblocks; v++)
{
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 (k = 0; k < 16; k++)
{
light = lightleft;
lightstep = (lightright - lightleft) >> 4;
prowdest[0] = vid.colormap32[(light & 0xFF00) + psource[0]];
light += lightstep;
prowdest[1] = vid.colormap32[(light & 0xFF00) + psource[1]];
light += lightstep;
prowdest[2] = vid.colormap32[(light & 0xFF00) + psource[2]];
light += lightstep;
prowdest[3] = vid.colormap32[(light & 0xFF00) + psource[3]];
light += lightstep;
prowdest[4] = vid.colormap32[(light & 0xFF00) + psource[4]];
light += lightstep;
prowdest[5] = vid.colormap32[(light & 0xFF00) + psource[5]];
light += lightstep;
prowdest[6] = vid.colormap32[(light & 0xFF00) + psource[6]];
light += lightstep;
prowdest[7] = vid.colormap32[(light & 0xFF00) + psource[7]];
light += lightstep;
prowdest[8] = vid.colormap32[(light & 0xFF00) + psource[8]];
light += lightstep;
prowdest[9] = vid.colormap32[(light & 0xFF00) + psource[9]];
light += lightstep;
prowdest[10] = vid.colormap32[(light & 0xFF00) + psource[10]];
light += lightstep;
prowdest[11] = vid.colormap32[(light & 0xFF00) + psource[11]];
light += lightstep;
prowdest[12] = vid.colormap32[(light & 0xFF00) + psource[12]];
light += lightstep;
prowdest[13] = vid.colormap32[(light & 0xFF00) + psource[13]];
light += lightstep;
prowdest[14] = vid.colormap32[(light & 0xFF00) + psource[14]];
light += lightstep;
prowdest[15] = vid.colormap32[(light & 0xFF00) + psource[15]];
psource += sourcetstep;
lightright += lightrightstep;
lightleft += lightleftstep;
prowdest += (surfrowbytes >> 2);
}
if (psource >= r_sourcemax)
psource -= r_stepback;
}
}
static void
R_DrawSurfaceBlock32_mip1 (void)
{
int k, v;
int lightstep, light;
unsigned int *prowdest;
prowdest = (unsigned int *) prowdestbase;
for (v = 0; v < r_numvblocks; v++)
{
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 (k = 0; k < 8; k++)
{
light = lightleft;
lightstep = (lightright - lightleft) >> 3;
prowdest[0] = vid.colormap32[(light & 0xFF00) + psource[0]];
light += lightstep;
prowdest[1] = vid.colormap32[(light & 0xFF00) + psource[1]];
light += lightstep;
prowdest[2] = vid.colormap32[(light & 0xFF00) + psource[2]];
light += lightstep;
prowdest[3] = vid.colormap32[(light & 0xFF00) + psource[3]];
light += lightstep;
prowdest[4] = vid.colormap32[(light & 0xFF00) + psource[4]];
light += lightstep;
prowdest[5] = vid.colormap32[(light & 0xFF00) + psource[5]];
light += lightstep;
prowdest[6] = vid.colormap32[(light & 0xFF00) + psource[6]];
light += lightstep;
prowdest[7] = vid.colormap32[(light & 0xFF00) + psource[7]];
psource += sourcetstep;
lightright += lightrightstep;
lightleft += lightleftstep;
prowdest += (surfrowbytes >> 2);
}
if (psource >= r_sourcemax)
psource -= r_stepback;
}
}
static void
R_DrawSurfaceBlock32_mip2 (void)
{
int k, v;
int lightstep, light;
unsigned int *prowdest;
prowdest = (unsigned int *) prowdestbase;
for (v = 0; v < r_numvblocks; v++)
{
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 (k = 0; k < 4; k++)
{
light = lightleft;
lightstep = (lightright - lightleft) >> 2;
prowdest[0] = vid.colormap32[(light & 0xFF00) + psource[0]];
light += lightstep;
prowdest[1] = vid.colormap32[(light & 0xFF00) + psource[1]];
light += lightstep;
prowdest[2] = vid.colormap32[(light & 0xFF00) + psource[2]];
light += lightstep;
prowdest[3] = vid.colormap32[(light & 0xFF00) + psource[3]];
psource += sourcetstep;
lightright += lightrightstep;
lightleft += lightleftstep;
prowdest += (surfrowbytes >> 2);
}
if (psource >= r_sourcemax)
psource -= r_stepback;
}
}
static void
R_DrawSurfaceBlock32_mip3 (void)
{
int v;
unsigned int *prowdest;
prowdest = (unsigned int *) prowdestbase;
for (v = 0; v < r_numvblocks; v++)
{
lightleft = r_lightptr[0];
lightright = r_lightptr[1];
r_lightptr += r_lightwidth;
lightleftstep = (r_lightptr[0] - lightleft) >> 1;
lightrightstep = (r_lightptr[1] - lightright) >> 1;
prowdest[0] = vid.colormap32[(lightleft & 0xFF00) + psource[0]];
prowdest[1] = vid.colormap32[(((lightleft + lightright) >> 1) &
0xFF00) + psource[1]];
psource += sourcetstep;
lightright += lightrightstep;
lightleft += lightleftstep;
prowdest += (surfrowbytes >> 2);
prowdest[0] = vid.colormap32[(lightleft & 0xFF00) + psource[0]];
prowdest[1] = vid.colormap32[(((lightleft + lightright) >> 1) &
0xFF00) + psource[1]];
psource += sourcetstep;
lightright += lightrightstep;
lightleft += lightleftstep;
prowdest += (surfrowbytes >> 2);
if (psource >= r_sourcemax)
psource -= r_stepback;
}
}
/*
void
R_DrawSurfaceBlock32 (void)
{
int k, v;
int lightstep, light;
unsigned int *prowdest;
prowdest = prowdestbase;
for (v = 0; v < r_numvblocks; v++) {
lightleft = r_lightptr[0];
lightright = r_lightptr[1];
r_lightptr += r_lightwidth;
lightleftstep = (r_lightptr[0] - lightleft) >> blockdivshift;
lightrightstep = (r_lightptr[1] - lightright) >> blockdivshift;
for (k = 0; k < blocksize; k++) {
int b;
lightstep = (lightright - lightleft) >> blockdivshift;
light = lightleft;
for (b = 0;b < blocksize;b++, light += lightstep)
prowdest[b] = vid.colormap32[(light & 0xFF00) + psource[b]];
psource += sourcetstep;
lightright += lightrightstep;
lightleft += lightleftstep;
prowdest += (surfrowbytes >> 2);
}
if (psource >= r_sourcemax)
psource -= r_stepback;
}
}
*/