eukara/ngunix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
ngunix/renderer/d_sprite.c

1548 lines
39 KiB
C
Raw Blame History

/*
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 the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
// d_sprite.c: software top-level rasterization driver module for drawing
// spritesy
#include "globaldef.h"
#include "d_local.h"
static int sprite_height;
static int minindex, maxindex;
static sspan_t *sprite_spans;
extern particle_t *currentparticle;
extern flare_t *currentflare;
extern byte additiveshade[16384];
#if !id386
// yeah,we sitll have the asm codes still used in there :)
#endif
extern byte *host_colormap_nofb;
extern byte gelmap[256];
extern pixel_t addTable[256][256]; // Additive Blending
extern pixel_t mulTable[256][256]; // Color Mod!
extern pixel_t transTable[256][256];
//extern pixel_t alphaTable[256][256];
extern cvar_t *r_filter;
extern byte menumap[256][16]; // haha hack
// =!=!=!=!=!=!=!=
// ASMME (or extern the blending mode stuff to a new function)
// =!=!=!=!=!=!=!=
float alfer;
float scaalx;
float scaaly;
int flared; // draw through edges
int flarespan; // the span we need to know before we determine
int pacolor;
float lensreflection = 1; // hack
//#define DITHERALPHATEST
/*
=====================
D_SpriteDrawSpans_C
=====================
*/
void D_SpriteDrawSpans_C (sspan_t *pspan)
{
int count, spancount, izistep;
int izi;
byte *pbase, *pdest;
fixed16_t s, t, snext, tnext, sstep, tstep;
float sdivz, tdivz, zi, z, du, dv, spancountminus1;
float sdivz8stepu, tdivz8stepu, zi8stepu;
byte btemp;
short *pz;
int forg;
sstep = 0; // keep compiler happy
tstep = 0; // ditto
pbase = cacheblock;
sdivz8stepu = d_sdivzstepu * 8;
tdivz8stepu = d_tdivzstepu * 8;
zi8stepu = d_zistepu * 8;
// we count on FP exceptions being turned off to avoid range problems
izistep = (int)(d_zistepu * 0x8000 * 0x10000);
do
{
pdest = (byte *)d_viewbuffer + (screenwidth * pspan->v) + pspan->u;
pz = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u;
count = pspan->count;
if (count <= 0)
goto NextSpan;
// calculate the initial s/z, t/z, 1/z, s, and t and clamp
du = (float)pspan->u;
dv = (float)pspan->v;
sdivz = d_sdivzorigin+ dv*d_sdivzstepv + du*d_sdivzstepu;
tdivz = d_tdivzorigin+ dv*d_tdivzstepv + du*d_tdivzstepu;
zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
// we count on FP exceptions being turned off to avoid range problems
izi = (int)(zi * 0x8000 * 0x10000);
s = (int)(sdivz * z) + sadjust;
if (s > bbextents)
s = bbextents;
else if (s < 0)
s = 0;
t = (int)(tdivz * z) + tadjust;
if (t > bbextentt)
t = bbextentt;
else if (t < 0)
t = 0;
do
{
// calculate s and t at the far end of the span
if (count >= 8)
spancount = 8;
else
spancount = count;
count -= spancount;
if (count)
{
// calculate s/z, t/z, zi->fixed s and t at far end of span,
// calculate s and t steps across span by shifting
sdivz += sdivz8stepu;
tdivz += tdivz8stepu;
zi += zi8stepu;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
snext = (int)(sdivz * z) + sadjust;
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0 steps from
// from causing overstepping & running off the
// edge of the texture
tnext = (int)(tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 8)
tnext = 8; // guard against round-off error on <0 steps
sstep = (snext - s) >> 3;
tstep = (tnext - t) >> 3;
}
else
{
// calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
// can't step off polygon), clamp, calculate s and t steps across
// span by division, biasing steps low so we don't run off the
// texture
spancountminus1 = (float)(spancount - 1);
sdivz += d_sdivzstepu * spancountminus1;
tdivz += d_tdivzstepu * spancountminus1;
zi += d_zistepu * spancountminus1;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
snext = (int)(sdivz * z) + sadjust;
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0 steps from
// from causing overstepping & running off the
// edge of the texture
tnext = (int)(tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 8)
tnext = 8; // guard against round-off error on <0 steps
if (spancount > 1)
{
sstep = (snext - s) / (spancount - 1);
tstep = (tnext - t) / (spancount - 1);
}
}
if (foguse){ forg = (float)z / 1024; if (forg > 32762) forg = 32762; } // leilei - fog
do
{
btemp = *(pbase + (s >> 16) + (t >> 16) * cachewidth);
if (foguse)
btemp = host_fogmap[btemp + (forg >> fogrange & 0xFF00)];
if (btemp != 255)
{
*pdest = btemp;
*pz = izi >> 16;
}
izi += izistep;
pdest++;
pz++;
s += sstep;
t += tstep;
} while (--spancount > 0);
s = snext;
t = tnext;
} while (count > 0);
NextSpan:
pspan++;
} while (pspan->count != DS_SPAN_LIST_END);
}
extern cvar_t *temp2;
extern cvar_t *temp3;
void D_SpriteDrawSpans_Blend_C (sspan_t *pspan, int blendmode)
{
int count, spancount, izistep;
int izi;
byte *pbase, *pdest;
fixed16_t s, t, snext, tnext, sstep, tstep;
float sdivz, tdivz, zi, z, du, dv, spancountminus1;
float sdivz8stepu, tdivz8stepu, zi8stepu;
byte btemp;
short *pz;
int addlpha, dalpha;
int forg;
#ifdef DITHERALPHATEST
int ehh, heh; // leilei - dithered alpha fade
#endif
dalpha = 8192 * (alfer * -1) + 16384;
sstep = 0; // keep compiler happy
tstep = 0; // ditto
pbase = cacheblock;
sdivz8stepu = d_sdivzstepu * 8;
tdivz8stepu = d_tdivzstepu * 8;
zi8stepu = d_zistepu * 8;
// we count on FP exceptions being turned off to avoid range problems
izistep = (int)(d_zistepu * 0x8000 * 0x10000);
#ifdef DITHERALPHATEST
ehh = 256;
#endif
do
{
pdest = (byte *)d_viewbuffer + (screenwidth * pspan->v) + pspan->u;
pz = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u;
count = pspan->count;
if (count <= 0)
goto NextSpan;
// calculate the initial s/z, t/z, 1/z, s, and t and clamp
du = (float)pspan->u;
dv = (float)pspan->v;
sdivz = d_sdivzorigin+ dv*d_sdivzstepv + du*d_sdivzstepu;
tdivz = d_tdivzorigin+ dv*d_tdivzstepv + du*d_tdivzstepu;
zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
// we count on FP exceptions being turned off to avoid range problems
izi = (int)(zi * 0x8000 * 0x10000);
s = (int)(sdivz * z) + sadjust;
if (s > bbextents)
s = bbextents;
else if (s < 0)
s = 0;
t = (int)(tdivz * z) + tadjust;
if (t > bbextentt)
t = bbextentt;
else if (t < 0)
t = 0;
do
{
// calculate s and t at the far end of the span
if (count >= 8){
spancount = 8;
}
else
spancount = count;
count -= spancount;
if (count)
{
// calculate s/z, t/z, zi->fixed s and t at far end of span,
// calculate s and t steps across span by shifting
sdivz += sdivz8stepu;
tdivz += tdivz8stepu;
zi += zi8stepu;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
snext = (int)(sdivz * z) + sadjust;
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0 steps from
// from causing overstepping & running off the
// edge of the texture
tnext = (int)(tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 8)
tnext = 8; // guard against round-off error on <0 steps
sstep = (snext - s) >> 3;
tstep = (tnext - t) >> 3;
#ifdef DITHERALPHATEST
ehh = 256;
#endif
}
else
{
// calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
// can't step off polygon), clamp, calculate s and t steps across
// span by division, biasing steps low so we don't run off the
// texture
spancountminus1 = (float)(spancount - 1);
sdivz += d_sdivzstepu * spancountminus1;
tdivz += d_tdivzstepu * spancountminus1;
zi += d_zistepu * spancountminus1;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
snext = (int)(sdivz * z) + sadjust;
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0 steps from
// from causing overstepping & running off the
// edge of the texture
tnext = (int)(tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 8)
tnext = 8; // guard against round-off error on <0 steps
#ifdef DITHERALPHATEST
ehh = -256;
#endif
if (spancount > 1)
{
sstep = (snext - s) / (spancount - 1);
tstep = (tnext - t) / (spancount - 1);
}
}
if (foguse){ forg = (float)z / 1024; if (forg > 32762) forg = 32762; } // leilei - fog
do
{
btemp = *(pbase + (s >> 16) + (t >> 16) * cachewidth);
#ifdef DITHERALPHATEST
ehh *= -1;
addlpha = dalpha + ehh;
if (addlpha < 0)
addlpha = 0; // don't overgo it
#else
addlpha = dalpha;
#endif
// -------------------------------------------------
// Big FAT BLENDING ROUTINES Begin
// -------------------------------------------------
if (btemp != 255)
{
if (blendmode == 3)
btemp = pacolor;
if (flared){
btemp = mulTable[btemp][pacolor];
// btemp = menumap[btemp][3];
if (reflectpass) {
if (alfer < 1)
*pdest = addTable[host_colormap[btemp + (addlpha & 0xFF00)]][*pdest];
else
*pdest = addTable[btemp][*pdest];
*pz = izi >> 16;
}
else{
if (alfer < 1)
*pdest = addTable[*pdest][host_colormap[btemp + (addlpha & 0xFF00)]];
else
*pdest = addTable[btemp][*pdest];
*pz = izi >> 16;
}
}
else if (*pz <= (izi >> 16))
{
//*pdest = btemp;
if (blendmode == 1){
if (alfer < 1)
*pdest = addTable[host_colormap[btemp + (addlpha & 0xFF00)]][*pdest];
else
*pdest = addTable[btemp][*pdest];
}
// Variable Alpha Blend
else if (blendmode == 10){
btemp = btemp;
if (addlpha > 10900){
// off.
}
else if (addlpha > 10000){
*pdest = transTable[btemp][*pdest];
}
else if (addlpha > 8700){
*pdest = transTable[*pdest][btemp];
}
else
*pdest = btemp;
}
else if (blendmode == 8){
btemp = mulTable[btemp][pacolor];
if (alfer < 1)
*pdest = addTable[host_colormap[btemp + (addlpha & 0xFF00)]][*pdest];
else
*pdest = addTable[btemp][*pdest];
}
else if (blendmode == 4){
*pdest = menumap[*pdest][btemp];
}
else if (blendmode == 6){
if (foguse)
*pdest = host_fogmap[mulTable[btemp][*pdest] + (forg >> fogrange & 0xFF00)];
else
*pdest = mulTable[btemp][*pdest];
}
else
{
*pdest = btemp;
*pz = izi >> 16;
}
}
// -------------------------------------------------
// Big FAT BLENDING ROUTINES End
// -------------------------------------------------
}
izi += izistep;
pdest++;
pz++;
s += sstep;
t += tstep;
} while (--spancount > 0);
s = snext;
t = tnext;
} while (count > 0);
NextSpan:
pspan++;
} while (pspan->count != DS_SPAN_LIST_END);
}
extern int kernel[2][2][2];
void D_SpriteDrawSpans_C_Filter (sspan_t *pspan)
{
int count, spancount, izistep;
int izi;
byte *pbase, *pdest;
fixed16_t s, t, snext, tnext, sstep, tstep;
float sdivz, tdivz, zi, z, du, dv, spancountminus1;
float sdivz8stepu, tdivz8stepu, zi8stepu;
byte btemp;
short *pz;
int addlpha;
int forg;
addlpha = 8192 * (alfer * -1) + 16384;
sstep = 0; // keep compiler happy
tstep = 0; // ditto
pbase = cacheblock;
sdivz8stepu = d_sdivzstepu * 8;
tdivz8stepu = d_tdivzstepu * 8;
zi8stepu = d_zistepu * 8;
// we count on FP exceptions being turned off to avoid range problems
izistep = (int)(d_zistepu * 0x8000 * 0x10000);
do
{
pdest = (byte *)d_viewbuffer + (screenwidth * pspan->v) + pspan->u;
pz = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u;
count = pspan->count;
if (count <= 0)
goto NextSpan;
// calculate the initial s/z, t/z, 1/z, s, and t and clamp
du = (float)pspan->u;
dv = (float)pspan->v;
sdivz = d_sdivzorigin+ dv*d_sdivzstepv + du*d_sdivzstepu;
tdivz = d_tdivzorigin+ dv*d_tdivzstepv + du*d_tdivzstepu;
zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
// we count on FP exceptions being turned off to avoid range problems
izi = (int)(zi * 0x8000 * 0x10000);
s = (int)(sdivz * z) + sadjust;
if (s > bbextents)
s = bbextents;
else if (s < 0)
s = 0;
t = (int)(tdivz * z) + tadjust;
if (t > bbextentt)
t = bbextentt;
else if (t < 0)
t = 0;
do
{
// calculate s and t at the far end of the span
if (count >= 8)
spancount = 8;
else
spancount = count;
count -= spancount;
if (count)
{
// calculate s/z, t/z, zi->fixed s and t at far end of span,
// calculate s and t steps across span by shifting
sdivz += sdivz8stepu;
tdivz += tdivz8stepu;
zi += zi8stepu;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
snext = (int)(sdivz * z) + sadjust;
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0 steps from
// from causing overstepping & running off the
// edge of the texture
tnext = (int)(tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 8)
tnext = 8; // guard against round-off error on <0 steps
sstep = (snext - s) >> 3;
tstep = (tnext - t) >> 3;
}
else
{
// calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
// can't step off polygon), clamp, calculate s and t steps across
// span by division, biasing steps low so we don't run off the
// texture
spancountminus1 = (float)(spancount - 1);
sdivz += d_sdivzstepu * spancountminus1;
tdivz += d_tdivzstepu * spancountminus1;
zi += d_zistepu * spancountminus1;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
snext = (int)(sdivz * z) + sadjust;
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0 steps from
// from causing overstepping & running off the
// edge of the texture
tnext = (int)(tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 8)
tnext = 8; // guard against round-off error on <0 steps
if (spancount > 1)
{
sstep = (snext - s) / (spancount - 1);
tstep = (tnext - t) / (spancount - 1);
}
}
if (foguse){ forg = (float)z / 1024; if (forg > 32762) forg = 32762; } // leilei - fog
do
{
int idiths = s;
int iditht = t;
int X = (pspan->u + spancount) & 1;
int Y = (pspan->v)&1;
//Using the kernel
idiths += kernel[X][Y][0];
iditht += kernel[X][Y][1];
idiths = idiths >> 16;
idiths = idiths ? idiths -1 : idiths;
iditht = iditht >> 16;
iditht = iditht ? iditht -1 : iditht;
btemp = *(pbase + + idiths + iditht * cachewidth);
if (*pz <= (izi >> 16))
if (btemp != 255)
{
if (foguse)
*pdest = host_fogmap[btemp + (forg >> fogrange & 0xFF00)];
else
*pdest = btemp;
*pz = izi >> 16;
}
izi += izistep;
pdest++;
pz++;
s += sstep;
t += tstep;
} while (--spancount > 0);
s = snext;
t = tnext;
} while (count > 0);
NextSpan:
pspan++;
} while (pspan->count != DS_SPAN_LIST_END);
}
void D_SpriteDrawSpans_Blend_C_Filter (sspan_t *pspan, int blendmode)
{
int count, spancount, izistep;
int izi;
byte *pbase, *pdest;
fixed16_t s, t, snext, tnext, sstep, tstep;
float sdivz, tdivz, zi, z, du, dv, spancountminus1;
float sdivz8stepu, tdivz8stepu, zi8stepu;
byte btemp;
byte ctemp;
short *pz;
int forg;
int addlpha;
addlpha = 8192 * (alfer * -1) + 16384;
sstep = 0; // keep compiler happy
tstep = 0; // ditto
pbase = cacheblock;
sdivz8stepu = d_sdivzstepu * 8;
tdivz8stepu = d_tdivzstepu * 8;
zi8stepu = d_zistepu * 8;
// we count on FP exceptions being turned off to avoid range problems
izistep = (int)(d_zistepu * 0x8000 * 0x10000);
do
{
pdest = (byte *)d_viewbuffer + (screenwidth * pspan->v) + pspan->u;
pz = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u;
count = pspan->count;
if (count <= 0)
goto NextSpan;
// calculate the initial s/z, t/z, 1/z, s, and t and clamp
du = (float)pspan->u;
dv = (float)pspan->v;
sdivz = d_sdivzorigin+ dv*d_sdivzstepv + du*d_sdivzstepu;
tdivz = d_tdivzorigin+ dv*d_tdivzstepv + du*d_tdivzstepu;
zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
// we count on FP exceptions being turned off to avoid range problems
izi = (int)(zi * 0x8000 * 0x10000);
s = (int)(sdivz * z) + sadjust;
if (s > bbextents)
s = bbextents;
else if (s < 0)
s = 0;
t = (int)(tdivz * z) + tadjust;
if (t > bbextentt)
t = bbextentt;
else if (t < 0)
t = 0;
if (foguse){ forg = (float)z / 1024; if (forg > 32762) forg = 32762; } // leilei - fog
do
{
// calculate s and t at the far end of the span
if (count >= 8)
spancount = 8;
else
spancount = count;
count -= spancount;
if (count)
{
// calculate s/z, t/z, zi->fixed s and t at far end of span,
// calculate s and t steps across span by shifting
sdivz += sdivz8stepu;
tdivz += tdivz8stepu;
zi += zi8stepu;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
snext = (int)(sdivz * z) + sadjust;
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0 steps from
// from causing overstepping & running off the
// edge of the texture
tnext = (int)(tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 8)
tnext = 8; // guard against round-off error on <0 steps
sstep = (snext - s) >> 3;
tstep = (tnext - t) >> 3;
}
else
{
// calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
// can't step off polygon), clamp, calculate s and t steps across
// span by division, biasing steps low so we don't run off the
// texture
spancountminus1 = (float)(spancount - 1);
sdivz += d_sdivzstepu * spancountminus1;
tdivz += d_tdivzstepu * spancountminus1;
zi += d_zistepu * spancountminus1;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
snext = (int)(sdivz * z) + sadjust;
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0 steps from
// from causing overstepping & running off the
// edge of the texture
tnext = (int)(tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 8)
tnext = 8; // guard against round-off error on <0 steps
if (spancount > 1)
{
sstep = (snext - s) / (spancount - 1);
tstep = (tnext - t) / (spancount - 1);
}
}
do
{
int idiths = s;
int iditht = t;
int X = (pspan->u + spancount) & 1;
int Y = (pspan->v)&1;
//Using the kernel
idiths += kernel[X][Y][0];
iditht += kernel[X][Y][1];
idiths = idiths >> 16;
idiths = idiths ? idiths -1 : idiths;
iditht = iditht >> 16;
iditht = iditht ? iditht -1 : iditht;
btemp = *(pbase + + idiths + iditht * cachewidth);
// btemp = *(pbase + (s >> 16) + (t >> 16) * cachewidth);
// -------------------------------------------------
// Big FAT BLENDING ROUTINES Begin
// -------------------------------------------------
if (btemp != 255)
{
if (blendmode == 3)
btemp = pacolor;
if (flared){
btemp = mulTable[btemp][pacolor];
//*btemp = menumap[*btemp][color];
if (reflectpass) {
if (alfer < 1)
*pdest = addTable[host_colormap[btemp + (addlpha & 0xFF00)]][*pdest];
else
*pdest = addTable[btemp][*pdest];
*pz = izi >> 16;
}
else{
if (alfer < 1)
*pdest = addTable[host_colormap[btemp + (addlpha & 0xFF00)]][*pdest];
else
*pdest = addTable[btemp][*pdest];
*pz = izi >> 16;
}
}
else if (*pz <= (izi >> 16))
{
//*pdest = btemp;
if (blendmode == 1){
if (alfer < 1)
*pdest = addTable[host_colormap[btemp + (addlpha & 0xFF00)]][*pdest];
else
*pdest = addTable[btemp][*pdest];
}
// Variable Alpha Blend
else if (blendmode == 10){
btemp = btemp;
if (addlpha > 10900){
// off.
}
else if (addlpha > 10000){
*pdest = transTable[btemp][*pdest];
}
else if (addlpha > 8700){
*pdest = transTable[*pdest][btemp];
}
else
*pdest = btemp;
}
else if (blendmode == 8){
btemp = mulTable[btemp][pacolor];
if (alfer < 1)
*pdest = addTable[host_colormap[btemp + (addlpha & 0xFF00)]][*pdest];
else
*pdest = addTable[btemp][*pdest];
}
else if (blendmode == 4){
*pdest = menumap[*pdest][btemp];
}
else if (blendmode == 6){
if (foguse)
*pdest = host_fogmap[mulTable[btemp][*pdest] + (forg >> fogrange & 0xFF00)];
else
*pdest = mulTable[btemp][*pdest];
}
else
{
*pdest = btemp;
*pz = izi >> 16;
}
}
// -------------------------------------------------
// Big FAT BLENDING ROUTINES End
// -------------------------------------------------
}
izi += izistep;
pdest++;
pz++;
s += sstep;
t += tstep;
} while (--spancount > 0);
s = snext;
t = tnext;
} while (count > 0);
NextSpan:
pspan++;
} while (pspan->count != DS_SPAN_LIST_END);
}
void D_SpriteDrawSpans_Censor (sspan_t *pspan)
{
int count, spancount, izistep;
int izi;
byte *pbase, *pdest;
fixed16_t s, t, snext, tnext, sstep, tstep;
float sdivz, tdivz, zi, z, du, dv, spancountminus1;
float sdivz8stepu, tdivz8stepu, zi8stepu;
byte btemp;
short *pz;
int forg;
int censwidth = 8;
sstep = 0; // keep compiler happy
tstep = 0; // ditto
pbase = cacheblock;
sdivz8stepu = d_sdivzstepu * 8;
tdivz8stepu = d_tdivzstepu * 8;
zi8stepu = d_zistepu * 8;
// we count on FP exceptions being turned off to avoid range problems
izistep = (int)(d_zistepu * 0x8000 * 0x10000);
do
{
pdest = (byte *)d_viewbuffer + (screenwidth * pspan->v) + pspan->u;
pz = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u;
count = pspan->count;
if (count <= 0)
goto NextSpan;
// calculate the initial s/z, t/z, 1/z, s, and t and clamp
du = (float)pspan->u;
dv = (float)pspan->v;
sdivz = d_sdivzorigin+ dv*d_sdivzstepv + du*d_sdivzstepu;
tdivz = d_tdivzorigin+ dv*d_tdivzstepv + du*d_tdivzstepu;
zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
// we count on FP exceptions being turned off to avoid range problems
izi = (int)(zi * 0x8000 * 0x10000);
s = (int)(sdivz * z) + sadjust;
if (s > bbextents)
s = bbextents;
else if (s < 0)
s = 0;
t = (int)(tdivz * z) + tadjust;
if (t > bbextentt)
t = bbextentt;
else if (t < 0)
t = 0;
do
{
// calculate s and t at the far end of the span
if (count >= 8)
spancount = 8;
else
spancount = count;
count -= spancount;
if (count)
{
// calculate s/z, t/z, zi->fixed s and t at far end of span,
// calculate s and t steps across span by shifting
sdivz += sdivz8stepu;
tdivz += tdivz8stepu;
zi += zi8stepu;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
snext = (int)(sdivz * z) + sadjust;
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0 steps from
// from causing overstepping & running off the
// edge of the texture
tnext = (int)(tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 8)
tnext = 8; // guard against round-off error on <0 steps
sstep = (snext - s) >> 3;
tstep = (tnext - t) >> 3;
}
else
{
// calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
// can't step off polygon), clamp, calculate s and t steps across
// span by division, biasing steps low so we don't run off the
// texture
spancountminus1 = (float)(spancount - 1);
sdivz += d_sdivzstepu * spancountminus1;
tdivz += d_tdivzstepu * spancountminus1;
zi += d_zistepu * spancountminus1;
z = (float)0x10000 / zi; // prescale to 16.16 fixed-point
snext = (int)(sdivz * z) + sadjust;
if (snext > bbextents)
snext = bbextents;
else if (snext < 8)
snext = 8; // prevent round-off error on <0 steps from
// from causing overstepping & running off the
// edge of the texture
tnext = (int)(tdivz * z) + tadjust;
if (tnext > bbextentt)
tnext = bbextentt;
else if (tnext < 8)
tnext = 8; // guard against round-off error on <0 steps
if (spancount > 1)
{
sstep = (snext - s) / (spancount - 1);
tstep = (tnext - t) / (spancount - 1);
}
}
do
{
btemp = (pdest[spancount]);
if (btemp != 255)
{
*pdest = btemp;
*pz = izi >> 16;
}
izi += izistep;
pdest++;
pz++;
s += sstep;
t += tstep;
} while (--spancount > 0);
s = snext;
t = tnext;
} while (count > 0);
NextSpan:
pspan++;
} while (pspan->count != DS_SPAN_LIST_END);
}
/*
=====================
D_SpriteScanLeftEdge
=====================
*/
void D_SpriteScanLeftEdge (void)
{
int i, v, itop, ibottom, lmaxindex;
emitpoint_t *pvert, *pnext;
sspan_t *pspan;
float du, dv, vtop, vbottom, slope;
fixed16_t u, u_step;
pspan = sprite_spans;
i = minindex;
if (i == 0)
i = r_spritedesc.nump;
lmaxindex = maxindex;
if (lmaxindex == 0)
lmaxindex = r_spritedesc.nump;
vtop = ceil (r_spritedesc.pverts[i].v);
do
{
pvert = &r_spritedesc.pverts[i];
pnext = pvert - 1;
vbottom = ceil (pnext->v);
if (vtop < vbottom)
{
du = pnext->u - pvert->u;
dv = pnext->v - pvert->v;
slope = du / dv;
u_step = (int)(slope * 0x10000);
// adjust u to ceil the integer portion
u = (int)((pvert->u + (slope * (vtop - pvert->v))) * 0x10000) +
(0x10000 - 1);
itop = (int)vtop;
ibottom = (int)vbottom;
for (v=itop ; v<ibottom ; v++)
{
pspan->u = u >> 16;
pspan->v = v;
u += u_step;
pspan++;
}
}
vtop = vbottom;
i--;
if (i == 0)
i = r_spritedesc.nump;
} while (i != lmaxindex);
}
/*
=====================
D_SpriteScanRightEdge
=====================
*/
void D_SpriteScanRightEdge (void)
{
int i, v, itop, ibottom;
emitpoint_t *pvert, *pnext;
sspan_t *pspan;
float du, dv, vtop, vbottom, slope, uvert, unext, vvert, vnext;
fixed16_t u, u_step;
pspan = sprite_spans;
i = minindex;
vvert = r_spritedesc.pverts[i].v;
if (vvert < r_refdef.fvrecty_adj)
vvert = r_refdef.fvrecty_adj;
if (vvert > r_refdef.fvrectbottom_adj)
vvert = r_refdef.fvrectbottom_adj;
vtop = ceil (vvert);
do
{
pvert = &r_spritedesc.pverts[i];
pnext = pvert + 1;
vnext = pnext->v;
if (vnext < r_refdef.fvrecty_adj)
vnext = r_refdef.fvrecty_adj;
if (vnext > r_refdef.fvrectbottom_adj)
vnext = r_refdef.fvrectbottom_adj;
vbottom = ceil (vnext);
if (vtop < vbottom)
{
uvert = pvert->u;
if (uvert < r_refdef.fvrectx_adj)
uvert = r_refdef.fvrectx_adj;
if (uvert > r_refdef.fvrectright_adj)
uvert = r_refdef.fvrectright_adj;
unext = pnext->u;
if (unext < r_refdef.fvrectx_adj)
unext = r_refdef.fvrectx_adj;
if (unext > r_refdef.fvrectright_adj)
unext = r_refdef.fvrectright_adj;
du = unext - uvert;
dv = vnext - vvert;
slope = du / dv;
u_step = (int)(slope * 0x10000);
// adjust u to ceil the integer portion
u = (int)((uvert + (slope * (vtop - vvert))) * 0x10000) +
(0x10000 - 1);
itop = (int)vtop;
ibottom = (int)vbottom;
for (v=itop ; v<ibottom ; v++)
{
pspan->count = (u >> 16) - pspan->u;
u += u_step;
pspan++;
}
}
vtop = vbottom;
vvert = vnext;
i++;
if (i == r_spritedesc.nump)
i = 0;
} while (i != maxindex);
pspan->count = DS_SPAN_LIST_END; // mark the end of the span list
}
extern cvar_t *temp2;
extern cvar_t *temp3;
/*
=====================
D_SpriteCalculateGradients
=====================
*/
void D_SpriteCalculateGradients (void)
{
vec3_t p_normal, p_saxis, p_taxis, p_temp1, p_temp2;
float distinv;
float scel, scely;
int xcanter, ycanter;
TransformVector (r_spritedesc.vpn, p_normal);
TransformVector (r_spritedesc.vright, p_saxis);
TransformVector (r_spritedesc.vup, p_taxis);
VectorInverse (p_taxis);
distinv = 1.0 / (-DotProduct (modelorg, r_spritedesc.vpn));
//lensreflection = -2;
// lame
xcanter = vid.width - xcenter;
ycanter = vid.height - ycenter;
//if (currentparticle){
scel = scaalx;
scely = scaaly;
//scel = currententity->scale;
if (scaalx > 665)
scel = scaalx -= 665; // leilei - flare hack
// if (reflectpass)
// scely *= 4; // leilei - try to make the water flares long
// Manoel Kasimier - QC Scale - begin
p_saxis[0] /= scel;
p_saxis[1] /= scel;
p_saxis[2] /= scel;
p_taxis[0] /= scely;
p_taxis[1] /= scely;
p_taxis[2] /= scely;
d_sdivzstepu = p_saxis[0] * xscaleinv;
d_tdivzstepu = p_taxis[0] * xscaleinv;
d_sdivzstepv = -p_saxis[1] * yscaleinv;
d_tdivzstepv = -p_taxis[1] * yscaleinv;
d_zistepu = p_normal[0] * xscaleinv * distinv;
d_zistepv = -p_normal[1] * yscaleinv * distinv;
d_sdivzorigin = p_saxis[2] - xcenter * d_sdivzstepu -
ycenter * d_sdivzstepv;
d_tdivzorigin = p_taxis[2] - xcenter * d_tdivzstepu -
ycenter * d_tdivzstepv;
d_ziorigin = p_normal[2] * distinv - xcenter * d_zistepu -
ycenter * d_zistepv;
//d_sdivzorigin *= lensreflection;
TransformVector (modelorg, p_temp1);
// leilei - lens flare reflections (if it even works :/ )
//p_temp1[0] *= lensreflection;
//p_temp1[1] *= lensreflection;
sadjust = ((fixed16_t)(DotProduct (p_temp1, p_saxis) * 0x10000 + 0.5)) -
(-(cachewidth >> 1) << 16);
tadjust = ((fixed16_t)(DotProduct (p_temp1, p_taxis) * 0x10000 + 0.5)) -
(-(sprite_height >> 1) << 16);
// -1 (-epsilon) so we never wander off the edge of the texture
bbextents = (cachewidth << 16) - 1;
bbextentt = (sprite_height << 16) - 1;
}
extern cvar_t *temp2;
/*
=====================
D_DrawSprite
=====================
*/
void D_DrawSprite (int isthisaparticle)
{
int i, nump;
float ymin, ymax;
int isfading;
int bypass;
emitpoint_t *pverts;
sspan_t spans[MAXHEIGHT+1];
sprite_spans = spans;
if (!isthisaparticle){
// scaalx = currententity->scale;
// scaaly = currententity->scale;
scaalx = 1; // no qc scale yet
scaaly = 1; // no qc scale yet
}
else if (isthisaparticle == 2) // it's a flare
{
scaalx = currentflare->scale;
scaaly = currentflare->scaley;
}
else // ok it is a particle
{
scaalx = currentparticle->scale;
scaaly = currentparticle->scaley;
if (currentparticle->alphavel)
isfading = 1;
else
isfading = 0;
}
// find the top and bottom vertices, and make sure there's at least one scan to
// draw
ymin = 999999.9;
ymax = -999999.9;
pverts = r_spritedesc.pverts;
for (i=0 ; i<r_spritedesc.nump ; i++)
{
if (pverts->v < ymin)
{
ymin = pverts->v;
minindex = i;
}
if (pverts->v > ymax)
{
ymax = pverts->v;
maxindex = i;
}
pverts++;
}
ymin = ceil (ymin);
ymax = ceil (ymax);
if (ymin >= ymax)
return; // doesn't cross any scans at all
cachewidth = r_spritedesc.pspriteframe->width;
sprite_height = r_spritedesc.pspriteframe->height;
cacheblock = (byte *)&r_spritedesc.pspriteframe->pixels[0];
// copy the first vertex to the last vertex, so we don't have to deal with
// wrapping
nump = r_spritedesc.nump;
pverts = r_spritedesc.pverts;
pverts[nump] = pverts[0];
/*
if(currentparticle->sprtype == 15){ flared = 1; currentparticle->sprtype = 5; lensreflection = -3.5;}
else if(currentparticle->sprtype == 16){ flared = 1; currentparticle->sprtype = 5; lensreflection = -2;}
else if(currentparticle->sprtype == 17){ flared = 1; currentparticle->sprtype = 5; lensreflection = -1.5;}
else if(currentparticle->sprtype == 18){ flared = 1; currentparticle->sprtype = 5; lensreflection = -1.1;}
else if(currentparticle->sprtype == 19){ flared = 1; currentparticle->sprtype = 5; lensreflection = -0.7;}
else if(currentparticle->sprtype == 20){ flared = 1; currentparticle->sprtype = 5; lensreflection = -0.3;}
else if(currentparticle->sprtype == 21){ flared = 1; currentparticle->sprtype = 5; lensreflection = 1.2;}
else if(currentparticle->sprtype == 22){ flared = 1; currentparticle->sprtype = 5; lensreflection = 1.7;}
else if(currentparticle->sprtype == 23){ flared = 1; currentparticle->sprtype = 5; lensreflection = 2;}
else
*/
lensreflection = 3;
//if (flared)
// currentflare->lensreflection = lensreflection;
D_SpriteCalculateGradients ();
// :(
D_SpriteScanLeftEdge ();
D_SpriteScanRightEdge ();
if (isthisaparticle){
if (isthisaparticle == 2){
alfer = currentflare->alpha;
pacolor = currentflare->color;
}
else if (isthisaparticle){
alfer = currentparticle->alpha;
pacolor = currentparticle->color;
}
if (flared && alfer < 0.08f)
return; // try not to draw totally faded flares.
if (alfer < 0.01f && !isfading)
alfer = 1;
if (alfer < 0.005f && isfading)
return;
if (isthisaparticle == 2){
if (r_filter->value)
D_SpriteDrawSpans_Blend_C_Filter (sprite_spans, 5);
else
D_SpriteDrawSpans_Blend_C (sprite_spans, 5);
return;
}
// only do one type for flares
if (r_filter->value){
if (currentparticle->blend == 1) // additeev
D_SpriteDrawSpans_Blend_C_Filter (sprite_spans, 1);
else if (currentparticle->blend == 4) // gelmapped
D_SpriteDrawSpans_Blend_C_Filter (sprite_spans, 4);
else if (currentparticle->blend == 5) // additive glow flare
D_SpriteDrawSpans_Blend_C_Filter (sprite_spans, 5);
else if (currentparticle->blend == 6) // multiplicatev
D_SpriteDrawSpans_Blend_C_Filter (sprite_spans, 6);
else if (currentparticle->blend == 8) // additive bt colorable like flare
D_SpriteDrawSpans_Blend_C_Filter (sprite_spans, 8);
else if (currentparticle->blend == 9) // alpha bt colorable like flare
D_SpriteDrawSpans_Blend_C_Filter (sprite_spans, 9);
else if (currentparticle->blend == 10) // alpha
D_SpriteDrawSpans_Blend_C_Filter (sprite_spans, 10);
else if (currentparticle->blend == 3) // particle color only
D_SpriteDrawSpans_Blend_C_Filter (sprite_spans, 3);
else if (alfer < 1)
D_SpriteDrawSpans_Blend_C_Filter (sprite_spans, 2);
else
D_SpriteDrawSpans_C_Filter (sprite_spans);
}
else
{
if (currentparticle->blend == 1)
D_SpriteDrawSpans_Blend_C (sprite_spans, 1);
else if (currentparticle->blend == 4) // gelmapped
D_SpriteDrawSpans_Blend_C (sprite_spans, 4);
else if (currentparticle->blend == 3)
D_SpriteDrawSpans_Blend_C (sprite_spans, 3);
else if (currentparticle->blend == 5)
D_SpriteDrawSpans_Blend_C (sprite_spans, 5);
else if (currentparticle->blend == 6)
D_SpriteDrawSpans_Blend_C (sprite_spans, 6);
else if (currentparticle->blend == 8) // additive bt colorable like flare
D_SpriteDrawSpans_Blend_C (sprite_spans, 8);
else if (currentparticle->blend == 9) // alpha bt colorable like flare
D_SpriteDrawSpans_Blend_C (sprite_spans, 9);
else if (currentparticle->blend == 10) // alpha
D_SpriteDrawSpans_Blend_C (sprite_spans, 10);
else if (alfer < 1)
D_SpriteDrawSpans_Blend_C (sprite_spans, 2);
else
#if !id386
D_SpriteDrawSpans_C (sprite_spans);
#else
D_SpriteDrawSpans (sprite_spans);
#endif
}
//return;
}
else
{
flared = 0; // no it is not a flare. also these frys are not ok.
alfer = currententity->alpha;
if (alfer < 0.01f)
alfer = 1;
else
alfer = 0;
if (r_filter->value){
if (currententity->effects & EF_ADDITIVE)
D_SpriteDrawSpans_Blend_C_Filter (sprite_spans, 1);
else if (alfer < 1)
D_SpriteDrawSpans_Blend_C_Filter (sprite_spans, 1);
else
D_SpriteDrawSpans_C_Filter (sprite_spans);
}
else
{
if (currententity->effects & EF_ADDITIVE)
D_SpriteDrawSpans_Blend_C (sprite_spans, 1);
else if (alfer < 1)
D_SpriteDrawSpans_Blend_C (sprite_spans, 1);
else
#if !id386
D_SpriteDrawSpans_C (sprite_spans);
#else
D_SpriteDrawSpans (sprite_spans);
#endif
}
}
}
Reference in a new issue View git blame Copy permalink