quake/src/WinQuake/d_sprite.cpp - platform/external/quake - Git at Google

 /*
 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
 // sprites

 #include "quakedef.h"
 #include "d_local.h"

 static int		sprite_height;
 static int		minindex, maxindex;
 static sspan_t	*sprite_spans;

 #if	!id386

 /*
 =====================
 D_SpriteDrawSpans
 =====================
 */
 void D_SpriteDrawSpans (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;

 	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 = *(pbase + (s >> 16) + (t >> 16) * cachewidth);
 				if (btemp != 255)
 				{
 					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);

 NextSpan:
 		pspan++;

 	} while (pspan->count != DS_SPAN_LIST_END);
 }

 #endif


 /*
 =====================
 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
 }


 /*
 =====================
 D_SpriteCalculateGradients
 =====================
 */
 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));

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


 /*
 =====================
 D_DrawSprite
 =====================
 */
 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 = (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];

 	D_SpriteCalculateGradients ();
 	D_SpriteScanLeftEdge ();
 	D_SpriteScanRightEdge ();
 	D_SpriteDrawSpans (sprite_spans);
 }
	/*
	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
	// sprites

	#include "quakedef.h"
	#include "d_local.h"

	static int sprite_height;
	static int minindex, maxindex;
	static sspan_t *sprite_spans;

	#if !id386

	/*
	=====================
	D_SpriteDrawSpans
	=====================
	*/
	void D_SpriteDrawSpans (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;

	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 + dvd_sdivzstepv + dud_sdivzstepu;
	tdivz = d_tdivzorigin + dvd_tdivzstepv + dud_tdivzstepu;
	zi = d_ziorigin + dvd_zistepv + dud_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 = (pbase + (s >> 16) + (t >> 16) cachewidth);
	if (btemp != 255)
	{
	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);

	NextSpan:
	pspan++;

	} while (pspan->count != DS_SPAN_LIST_END);
	}

	#endif


	/*
	=====================
	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
	}


	/*
	=====================
	D_SpriteCalculateGradients
	=====================
	*/
	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));

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


	/*
	=====================
	D_DrawSprite
	=====================
	*/
	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 = (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];

	D_SpriteCalculateGradients ();
	D_SpriteScanLeftEdge ();
	D_SpriteScanRightEdge ();
	D_SpriteDrawSpans (sprite_spans);
	}