mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-12-18 16:42:07 +00:00
729 lines
18 KiB
C
729 lines
18 KiB
C
/*
|
|
d_sprite.c
|
|
|
|
software top-level rasterization driver module for drawing sprites
|
|
|
|
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
|
|
|
|
*/
|
|
static const char rcsid[] =
|
|
"$Id$";
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#include "QF/render.h"
|
|
#include "QF/sys.h"
|
|
|
|
#include "compat.h"
|
|
#include "d_local.h"
|
|
|
|
static int sprite_height;
|
|
static int minindex, maxindex;
|
|
static sspan_t *sprite_spans;
|
|
|
|
|
|
|
|
void
|
|
D_SpriteDrawSpans (sspan_t *pspan)
|
|
{
|
|
switch(r_pixbytes) {
|
|
case 1:
|
|
{
|
|
int count, spancount, izistep;
|
|
int izi;
|
|
byte *pbase;
|
|
byte *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;
|
|
|
|
sstep = 0; // keep compiler happy
|
|
tstep = 0; // ditto
|
|
|
|
pbase = (byte *) cacheblock;
|
|
|
|
sdivz8stepu = d_sdivzstepu * 8;
|
|
tdivz8stepu = d_tdivzstepu * 8;
|
|
zi8stepu = d_zistepu * 8 * 65536.0f;
|
|
|
|
// 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 NextSpan1;
|
|
|
|
// 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) * 65536.0f;
|
|
z = d_zitable[(int) zi];
|
|
// we count on FP exceptions being turned off to avoid range
|
|
// problems
|
|
|
|
izi = (int) (zi * 0x8000);
|
|
|
|
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 = d_zitable[(int) zi];
|
|
|
|
snext = (int) (sdivz * z) + sadjust;
|
|
if (snext > bbextents)
|
|
snext = bbextents;
|
|
else if (snext < 8)
|
|
snext = 8; // prevent round-off error on <0
|
|
// steps from causing overstepping
|
|
// & running off the texture's edge
|
|
|
|
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 * 65536.0f * spancountminus1;
|
|
z = d_zitable[(int) zi];
|
|
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 = pbase[(s >> 16) + (t >> 16) * cachewidth];
|
|
if (btemp != TRANSPARENT_COLOR) {
|
|
if (*pz <= (izi >> 16)) {
|
|
*pz = izi >> 16;
|
|
*pdest = btemp;
|
|
}
|
|
}
|
|
|
|
izi += izistep;
|
|
pdest++;
|
|
pz++;
|
|
s += sstep;
|
|
t += tstep;
|
|
} while (--spancount > 0);
|
|
|
|
s = snext;
|
|
t = tnext;
|
|
|
|
} while (count > 0);
|
|
|
|
NextSpan1:
|
|
pspan++;
|
|
|
|
} while (pspan->count != DS_SPAN_LIST_END);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
int count, spancount, izistep;
|
|
int izi;
|
|
byte *pbase;
|
|
short *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;
|
|
|
|
sstep = 0; // keep compiler happy
|
|
tstep = 0; // ditto
|
|
|
|
pbase = (byte *) cacheblock;
|
|
|
|
sdivz8stepu = d_sdivzstepu * 8;
|
|
tdivz8stepu = d_tdivzstepu * 8;
|
|
zi8stepu = d_zistepu * 8 * 65536;
|
|
|
|
// we count on FP exceptions being turned off to avoid range problems
|
|
izistep = (int) (d_zistepu * 0x8000 * 0x10000);
|
|
|
|
do {
|
|
pdest = (short *) d_viewbuffer + screenwidth * pspan->v + pspan->u;
|
|
pz = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u;
|
|
|
|
count = pspan->count;
|
|
|
|
if (count <= 0)
|
|
goto NextSpan2;
|
|
|
|
// 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) * 65536.0f;
|
|
z = d_zitable[(int) zi];
|
|
// we count on FP exceptions being turned off to avoid range
|
|
// problems
|
|
izi = (int) (zi * 0x8000);
|
|
|
|
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 = d_zitable[(int) zi];
|
|
|
|
snext = (int) (sdivz * z) + sadjust;
|
|
if (snext > bbextents)
|
|
snext = bbextents;
|
|
else if (snext < 8)
|
|
snext = 8; // prevent round-off error on <0
|
|
// steps from causing overstepping
|
|
// & running off the texture's edge
|
|
|
|
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 * 65536.0f * spancountminus1;
|
|
z = d_zitable[(int) zi];
|
|
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 = pbase[(s >> 16) + (t >> 16) * cachewidth];
|
|
if (btemp != TRANSPARENT_COLOR) {
|
|
if (*pz <= (izi >> 16)) {
|
|
*pz = izi >> 16;
|
|
*pdest = d_8to16table[btemp];
|
|
}
|
|
}
|
|
|
|
izi += izistep;
|
|
pdest++;
|
|
pz++;
|
|
s += sstep;
|
|
t += tstep;
|
|
} while (--spancount > 0);
|
|
|
|
s = snext;
|
|
t = tnext;
|
|
|
|
} while (count > 0);
|
|
|
|
NextSpan2:
|
|
pspan++;
|
|
|
|
} while (pspan->count != DS_SPAN_LIST_END);
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
{
|
|
int count, spancount, izistep;
|
|
int izi;
|
|
byte *pbase;
|
|
int *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;
|
|
|
|
sstep = 0; // keep compiler happy
|
|
tstep = 0; // ditto
|
|
|
|
pbase = (byte *) cacheblock;
|
|
|
|
sdivz8stepu = d_sdivzstepu * 8;
|
|
tdivz8stepu = d_tdivzstepu * 8;
|
|
zi8stepu = d_zistepu * 8 * 65536;
|
|
|
|
// we count on FP exceptions being turned off to avoid range problems
|
|
izistep = (int) (d_zistepu * 0x8000 * 0x10000);
|
|
|
|
do {
|
|
pdest = (int *) d_viewbuffer + screenwidth * pspan->v + pspan->u;
|
|
pz = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u;
|
|
|
|
count = pspan->count;
|
|
|
|
if (count <= 0)
|
|
goto NextSpan4;
|
|
|
|
// 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) * 65536.0f;
|
|
z = d_zitable[(int) zi];
|
|
// we count on FP exceptions being turned off to avoid range
|
|
// problems
|
|
izi = (int) (zi * 0x8000);
|
|
|
|
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 = d_zitable[(int) zi];
|
|
|
|
snext = (int) (sdivz * z) + sadjust;
|
|
if (snext > bbextents)
|
|
snext = bbextents;
|
|
else if (snext < 8)
|
|
snext = 8; // prevent round-off error on <0
|
|
// steps from causing overstepping
|
|
// & running off the texture's edge
|
|
|
|
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 * 65536.0f * spancountminus1;
|
|
z = d_zitable[(int) zi];
|
|
snext = (int) (sdivz * z) + sadjust;
|
|
if (snext > bbextents)
|
|
snext = bbextents;
|
|
else if (snext < 8)
|
|
snext = 8; // prevent round-off error on <0
|
|
// steps fromcausing overstepping
|
|
// & running off the texture's edge
|
|
|
|
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 = pbase[(s >> 16) + (t >> 16) * cachewidth];
|
|
if (btemp != TRANSPARENT_COLOR) {
|
|
if (*pz <= (izi >> 16)) {
|
|
*pz = izi >> 16;
|
|
*pdest = d_8to24table[btemp];
|
|
}
|
|
}
|
|
|
|
izi += izistep;
|
|
pdest++;
|
|
pz++;
|
|
s += sstep;
|
|
t += tstep;
|
|
} while (--spancount > 0);
|
|
|
|
s = snext;
|
|
t = tnext;
|
|
|
|
} while (count > 0);
|
|
|
|
NextSpan4:
|
|
pspan++;
|
|
|
|
} while (pspan->count != DS_SPAN_LIST_END);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
Sys_Error("D_SpriteDrawSpans: unsupported r_pixbytes %i",
|
|
r_pixbytes);
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
void
|
|
D_SpriteCalculateGradients (void)
|
|
{
|
|
vec3_t p_normal, p_saxis, p_taxis, p_temp1;
|
|
float distinv;
|
|
|
|
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));
|
|
distinv = min (distinv, 1.0);
|
|
|
|
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;
|
|
|
|
TransformVector (modelorg, p_temp1);
|
|
|
|
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;
|
|
}
|
|
|
|
void
|
|
D_DrawSprite (void)
|
|
{
|
|
int i, nump;
|
|
float ymin, ymax;
|
|
emitpoint_t *pverts;
|
|
sspan_t spans[MAXHEIGHT + 1];
|
|
|
|
sprite_spans = spans;
|
|
|
|
// 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 = &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];
|
|
|
|
D_SpriteCalculateGradients ();
|
|
D_SpriteScanLeftEdge ();
|
|
D_SpriteScanRightEdge ();
|
|
D_SpriteDrawSpans (sprite_spans);
|
|
}
|