/*
	d_scan.c

	Portable C scan-level rasterization code, all pixel depths.

	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

	$Id$
*/

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include "QF/qendian.h"
#include "QF/render.h"
#include "QF/sys.h"

#include "compat.h"
#include "d_local.h"
#include "r_local.h"

byte       *r_turb_pbase;
void       *r_turb_pdest;
fixed16_t   r_turb_s, r_turb_t, r_turb_sstep, r_turb_tstep;
int        *r_turb_turb;
int         r_turb_spancount;

void        D_DrawTurbulentSpan (void);

extern float d_zitable[65536];


/*
	D_WarpScreen

	this performs a slight compression of the screen at the same time as
	the sine warp, to keep the edges from wrapping
*/
void
D_WarpScreen (void)
{
	switch(r_pixbytes) {
	case 1:
	{
		int         w, h;
		int         u, v;
		byte       *dest;
		int        *turb;
		int        *col;
		byte      **row;
		byte       *rowptr[1024];
		int         column[1280];
		float       wratio, hratio;

		w = r_refdef.vrect.width;
		h = r_refdef.vrect.height;

		wratio = w / (float) scr_vrect.width;
		hratio = h / (float) scr_vrect.height;

		for (v = 0; v < scr_vrect.height + AMP2 * 2; v++) {
			rowptr[v] = (byte *) d_viewbuffer + (r_refdef.vrect.y *
												 screenwidth) +
				(screenwidth * (int) ((float) v * hratio * h /
									  (h + AMP2 * 2)));
		}

		for (u = 0; u < scr_vrect.width + AMP2 * 2; u++) {
			column[u] = r_refdef.vrect.x +
				(int) ((float) u * wratio * w / (w + AMP2 * 2));
		}

		turb = intsintable + ((int) (r_realtime * SPEED) & (CYCLE - 1));
		dest = (byte *) (vid.buffer + scr_vrect.y * vid.rowbytes +
						 scr_vrect.x);

		for (v = 0; v < scr_vrect.height; v++, dest += vid.rowbytes) {
			col = &column[turb[v]];
			row = &rowptr[v];
			for (u = 0; u < scr_vrect.width; u += 4) {
				dest[u + 0] = row[turb[u + 0]][col[u + 0]];
				dest[u + 1] = row[turb[u + 1]][col[u + 1]];
				dest[u + 2] = row[turb[u + 2]][col[u + 2]];
				dest[u + 3] = row[turb[u + 3]][col[u + 3]];
			}
		}
	}
	break;
	case 2:
	{
		int         w, h;
		int         u, v;
		short      *dest;
		int        *turb;
		int        *col;
		short     **row;
		short      *rowptr[1024];
		int         column[1280];
		float       wratio, hratio;

		w = r_refdef.vrect.width;
		h = r_refdef.vrect.height;

		wratio = w / (float) scr_vrect.width;
		hratio = h / (float) scr_vrect.height;

		for (v = 0; v < scr_vrect.height + AMP2 * 2; v++) {
			rowptr[v] = (short *) d_viewbuffer +
				(r_refdef.vrect.y * screenwidth) +
				(screenwidth * (int) ((float) v * hratio * h /
									  (h + AMP2 * 2)));
		}

		for (u = 0; u < scr_vrect.width + AMP2 * 2; u++) {
			column[u] = r_refdef.vrect.x +
				(int) ((float) u * wratio * w / (w + AMP2 * 2));
		}

		turb = intsintable + ((int) (r_realtime * SPEED) & (CYCLE - 1));
		dest = (short *) vid.buffer + scr_vrect.y * (vid.rowbytes >> 1) +
			scr_vrect.x;

		for (v = 0; v < scr_vrect.height; v++, dest += (vid.rowbytes >> 1)) {
			col = &column[turb[v]];
			row = &rowptr[v];
			for (u = 0; u < scr_vrect.width; u += 4) {
				dest[u + 0] = row[turb[u + 0]][col[u + 0]];
				dest[u + 1] = row[turb[u + 1]][col[u + 1]];
				dest[u + 2] = row[turb[u + 2]][col[u + 2]];
				dest[u + 3] = row[turb[u + 3]][col[u + 3]];
			}
		}
	}
	break;
	case 4:
	{
		int         w, h;
		int         u, v;
		int        *dest;
		int        *turb;
		int        *col;
		int       **row;
		int        *rowptr[1024];
		int         column[1280];
		float       wratio, hratio;

		w = r_refdef.vrect.width;
		h = r_refdef.vrect.height;

		wratio = w / (float) scr_vrect.width;
		hratio = h / (float) scr_vrect.height;

		for (v = 0; v < scr_vrect.height + AMP2 * 2; v++) {
			rowptr[v] = (int *) d_viewbuffer +
				(r_refdef.vrect.y * screenwidth) +
				(screenwidth * (int) ((float) v * hratio * h /
									  (h + AMP2 * 2)));
		}

		for (u = 0; u < scr_vrect.width + AMP2 * 2; u++) {
			column[u] = r_refdef.vrect.x +
				(int) ((float) u * wratio * w / (w + AMP2 * 2));
		}

		turb = intsintable + ((int) (r_realtime * SPEED) & (CYCLE - 1));
		dest = (int *) vid.buffer + scr_vrect.y * (vid.rowbytes >> 2) +
			scr_vrect.x;

		for (v = 0; v < scr_vrect.height; v++, dest += (vid.rowbytes >> 2)) {
			col = &column[turb[v]];
			row = &rowptr[v];
			for (u = 0; u < scr_vrect.width; u += 4) {
				dest[u + 0] = row[turb[u + 0]][col[u + 0]];
				dest[u + 1] = row[turb[u + 1]][col[u + 1]];
				dest[u + 2] = row[turb[u + 2]][col[u + 2]];
				dest[u + 3] = row[turb[u + 3]][col[u + 3]];
			}
		}
	}
	break;
	default:
		Sys_Error("D_WarpScreen: unsupported r_pixbytes %i\n", r_pixbytes);
	}
}

void
D_DrawTurbulentSpan (void)
{
	int         sturb, tturb;

	switch (r_pixbytes) {
	case 1:
	{
		byte *pdest = (byte *) r_turb_pdest;
		do {
			sturb =	((r_turb_s + r_turb_turb[(r_turb_t >> 16) &
											 (CYCLE - 1)]) >> 16) &	63;
			tturb = ((r_turb_t + r_turb_turb[(r_turb_s >> 16) &
											 (CYCLE - 1)]) >> 16) & 63;
			*pdest++ = r_turb_pbase[(tturb << 6) + sturb];
			r_turb_s += r_turb_sstep;
			r_turb_t += r_turb_tstep;
		} while (--r_turb_spancount > 0);
		r_turb_pdest = (byte *)pdest;
	}
	break;
	case 2:
	{
		short *pdest = (short *) r_turb_pdest;
		do {
			sturb = ((r_turb_s + r_turb_turb[(r_turb_t >> 16) &
											 (CYCLE - 1)]) >> 16) & 63;
			tturb = ((r_turb_t + r_turb_turb[(r_turb_s >> 16) &
											 (CYCLE - 1)]) >> 16) & 63;
			*pdest++ = d_8to16table[r_turb_pbase[(tturb << 6) + sturb]];
			r_turb_s += r_turb_sstep;
			r_turb_t += r_turb_tstep;
		} while (--r_turb_spancount > 0);
		r_turb_pdest = (byte *)pdest;
	}
	break;
	case 4:
	{
		int *pdest = (int *) r_turb_pdest;
		do {
			sturb = ((r_turb_s + r_turb_turb[(r_turb_t >> 16) &
											 (CYCLE - 1)]) >> 16) & 63;
				tturb = ((r_turb_t + r_turb_turb[(r_turb_s >> 16) &
												 (CYCLE - 1)]) >> 16) & 63;
				*pdest++ = d_8to24table[r_turb_pbase[(tturb << 6) + sturb]];
				r_turb_s += r_turb_sstep;
				r_turb_t += r_turb_tstep;
			} while (--r_turb_spancount > 0);
			r_turb_pdest = (byte *)pdest;
		}
		break;
	default:
		Sys_Error("D_DrawTurbulentSpan: unsupported r_pixbytes %i\n",
				  r_pixbytes);
	}
}

void
Turbulent (espan_t *pspan)
{
	int         count;
	fixed16_t   snext, tnext;
	float       sdivz, tdivz, zi, z, du, dv, spancountminus1;
	float       sdivz16stepu, tdivz16stepu, zi16stepu;

	r_turb_turb = sintable + ((int) (r_realtime * SPEED) & (CYCLE - 1));

	r_turb_sstep = 0;					// keep compiler happy
	r_turb_tstep = 0;					// ditto

	r_turb_pbase = (byte *) cacheblock;

	sdivz16stepu = d_sdivzstepu * 16;
	tdivz16stepu = d_tdivzstepu * 16;
	zi16stepu = d_zistepu * 16 * 65536;

	do {
		r_turb_pdest = (byte *) d_viewbuffer + ((screenwidth * pspan->v) +
												pspan->u) * r_pixbytes;

		count = pspan->count;

		// 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];

		r_turb_s = (int) (sdivz * z) + sadjust;
		if (r_turb_s > bbextents)
			r_turb_s = bbextents;
		else if (r_turb_s < 0)
			r_turb_s = 0;

		r_turb_t = (int) (tdivz * z) + tadjust;
		if (r_turb_t > bbextentt)
			r_turb_t = bbextentt;
		else if (r_turb_t < 0)
			r_turb_t = 0;

		do {
			// calculate s and t at the far end of the span
			if (count >= 16)
				r_turb_spancount = 16;
			else
				r_turb_spancount = count;

			count -= r_turb_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 += sdivz16stepu;
				tdivz += tdivz16stepu;
				zi += zi16stepu;
				z = d_zitable[(int) zi];

				snext = (int) (sdivz * z) + sadjust;
				if (snext > bbextents)
					snext = bbextents;
				else if (snext < 16)
					snext = 16;			// 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 < 16)
					tnext = 16;			// guard against round-off error on
										// <0 steps

				r_turb_sstep = (snext - r_turb_s) >> 4;
				r_turb_tstep = (tnext - r_turb_t) >> 4;
			} 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) (r_turb_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 < 16)
					snext = 16;			// prevent round-off error on <0 steps
										// from causing overstepping & running
										// off the edge of the texture

				tnext = (int) (tdivz * z) + tadjust;
				if (tnext > bbextentt)
					tnext = bbextentt;
				else if (tnext < 16)
					tnext = 16;			// guard against round-off error on
										// <0 steps

				if (r_turb_spancount > 1) {
					r_turb_sstep = (snext - r_turb_s) / (r_turb_spancount - 1);
					r_turb_tstep = (tnext - r_turb_t) / (r_turb_spancount - 1);
				}
			}

			r_turb_s = r_turb_s & ((CYCLE << 16) - 1);
			r_turb_t = r_turb_t & ((CYCLE << 16) - 1);

			D_DrawTurbulentSpan ();

			r_turb_s = snext;
			r_turb_t = tnext;

		} while (count > 0);

	} while ((pspan = pspan->pnext) != NULL);
}

void
D_DrawSpans (espan_t *pspan)
{
	switch(r_pixbytes) {
	case 1:
	{
		byte       *pbase = (byte *) cacheblock, *pdest;
		int         count;
		fixed16_t   s, t, snext, tnext, sstep, tstep;
		float       sdivz, tdivz, zi, z, du, dv;
		float       sdivz8stepu, tdivz8stepu, zi8stepu;

		sstep = 0;							// keep compiler happy
		tstep = 0;							// ditto

		sdivz8stepu = d_sdivzstepu * 8;
		tdivz8stepu = d_tdivzstepu * 8;
		zi8stepu = d_zistepu * 8 * 65536;

		do {
			pdest = (byte *) d_viewbuffer + (screenwidth * pspan->v) +
				pspan->u;

			count = pspan->count;

			// 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];

			s = (int) (sdivz * z) + sadjust;
			s = bound(0, s, bbextents);
			t = (int) (tdivz * z) + tadjust;
			t = bound(0, t, bbextentt);

			while(count >= 8) {
				count -= 8;
				// 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];

				// prevent round-off error on <0 steps from from causing
				// overstepping & running off the edge of the texture
				snext = (int) (sdivz * z) + sadjust;
				snext = bound(8, snext, bbextents);
				tnext = (int) (tdivz * z) + tadjust;
				tnext = bound(8, tnext, bbextentt);

				sstep = (snext - s) >> 3;
				tstep = (tnext - t) >> 3;

				pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;t += tstep;
				pdest[1] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[2] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[3] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[4] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[5] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[6] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[7] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s = snext;
				t = tnext;
				pdest += 8;
			}
			if (count)
			{
				// 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
				//countminus1 = (float) (count - 1);
				sdivz += d_sdivzstepu * count; //minus1;
				tdivz += d_tdivzstepu * count; //minus1;
				zi += d_zistepu * 65536.0f * count; //minus1;
				z = d_zitable[(int) zi];

				// prevent round-off error on <0 steps from from causing
				// overstepping & running off the edge of the texture
				snext = (int) (sdivz * z) + sadjust;
				snext = bound(count, snext, bbextents);
				tnext = (int) (tdivz * z) + tadjust;
				tnext = bound(count, tnext, bbextentt);

				if (count > 1) {
					sstep = (snext - s) / count; //(count - 1);
					tstep = (tnext - t) / count; //(count - 1);

					if (count & 4)
					{
						pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest[1] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest[2] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest[3] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest += 4;
					}
					if (count & 2)
					{
						pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest[1] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest += 2;
					}
					if (count & 1)
						pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
					s += sstep;
					t += tstep;
				}
				else
				{
					pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
					s += sstep;
					t += tstep;
				}
			}
		} while ((pspan = pspan->pnext) != NULL);
	}
	break;
	case 2:
	{
		short      *pbase = (short *) cacheblock, *pdest;
		int         count;
		fixed16_t   s, t, snext, tnext, sstep, tstep;
		float       sdivz, tdivz, zi, z, du, dv;
		float       sdivz8stepu, tdivz8stepu, zi8stepu;

		sstep = 0;							// keep compiler happy
		tstep = 0;							// ditto

		sdivz8stepu = d_sdivzstepu * 8;
		tdivz8stepu = d_tdivzstepu * 8;
		zi8stepu = d_zistepu * 8 * 65536;

		do {
			pdest = (short *) d_viewbuffer + (screenwidth * pspan->v) +
				pspan->u;

			count = pspan->count;

			// 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];

			s = (int) (sdivz * z) + sadjust;
			s = bound(0, s, bbextents);
			t = (int) (tdivz * z) + tadjust;
			t = bound(0, t, bbextentt);

			while(count >= 8) {
				count -= 8;
				// 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];

				// prevent round-off error on <0 steps from from causing
				// overstepping & running off the edge of the texture
				snext = (int) (sdivz * z) + sadjust;
				snext = bound(8, snext, bbextents);
				tnext = (int) (tdivz * z) + tadjust;
				tnext = bound(8, tnext, bbextentt);

				sstep = (snext - s) >> 3;
				tstep = (tnext - t) >> 3;

				pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[1] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[2] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[3] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[4] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[5] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[6] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[7] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s = snext;t = tnext;
				pdest += 8;
			}
			if (count)
			{
				// 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
				//countminus1 = (float) (count - 1);
				sdivz += d_sdivzstepu * count; //minus1;
				tdivz += d_tdivzstepu * count; //minus1;
				zi += d_zistepu * 65536.0f * count; //minus1;
				z = d_zitable[(int) zi];

				// prevent round-off error on <0 steps from from causing
				// overstepping & running off the edge of the texture
				snext = (int) (sdivz * z) + sadjust;
				snext = bound(count, snext, bbextents);
				tnext = (int) (tdivz * z) + tadjust;
				tnext = bound(count, tnext, bbextentt);

				if (count > 1) {
					sstep = (snext - s) / count; //(count - 1);
					tstep = (tnext - t) / count; //(count - 1);

					if (count & 4)
					{
						pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest[1] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest[2] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest[3] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;t += tstep;
						pdest += 4;
					}
					if (count & 2)
					{
						pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest[1] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest += 2;
					}
					if (count & 1)
						pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
					s += sstep;
					t += tstep;
				}
				else
				{
					pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
					s += sstep;
					t += tstep;
				}
			}
		} while ((pspan = pspan->pnext) != NULL);
	}
	break;
	case 4:
	{
		int        *pbase = (int *) cacheblock, *pdest;
		int         count;
		fixed16_t   s, t, snext, tnext, sstep, tstep;
		float       sdivz, tdivz, zi, z, du, dv;
		float       sdivz8stepu, tdivz8stepu, zi8stepu;

		sstep = 0;							// keep compiler happy
		tstep = 0;							// ditto

		sdivz8stepu = d_sdivzstepu * 8;
		tdivz8stepu = d_tdivzstepu * 8;
		zi8stepu = d_zistepu * 8 * 65536;

		do {
			pdest = (int *) d_viewbuffer + (screenwidth * pspan->v) + pspan->u;

			count = pspan->count;

			// 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];

			s = (int) (sdivz * z) + sadjust;
			s = bound(0, s, bbextents);
			t = (int) (tdivz * z) + tadjust;
			t = bound(0, t, bbextentt);

			while(count >= 8) {
				count -= 8;
				// 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];

				// prevent round-off error on <0 steps from from causing
				// overstepping & running off the edge of the texture
				snext = (int) (sdivz * z) + sadjust;
				snext = bound(8, snext, bbextents);
				tnext = (int) (tdivz * z) + tadjust;
				tnext = bound(8, tnext, bbextentt);

				sstep = (snext - s) >> 3;
				tstep = (tnext - t) >> 3;

				pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[1] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[2] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[3] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[4] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[5] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[6] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s += sstep;
				t += tstep;
				pdest[7] = pbase[(t >> 16) * cachewidth + (s >> 16)];
				s = snext;
				t = tnext;
				pdest += 8;
			}
			if (count)
			{
				// 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
				//countminus1 = (float) (count - 1);
				sdivz += d_sdivzstepu * count; //minus1;
				tdivz += d_tdivzstepu * count; //minus1;
				zi += d_zistepu * 65536.0f * count; //minus1;
				z = d_zitable[(int) zi];

				// prevent round-off error on <0 steps from from causing
				// overstepping & running off the edge of the texture
				snext = (int) (sdivz * z) + sadjust;
				snext = bound(count, snext, bbextents);
				tnext = (int) (tdivz * z) + tadjust;
				tnext = bound(count, tnext, bbextentt);

				if (count > 1) {
					sstep = (snext - s) / count; //(count - 1);
					tstep = (tnext - t) / count; //(count - 1);

					if (count & 4)
					{
						pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest[1] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest[2] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest[3] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest += 4;
					}
					if (count & 2)
					{
						pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest[1] = pbase[(t >> 16) * cachewidth + (s >> 16)];
						s += sstep;
						t += tstep;
						pdest += 2;
					}
					if (count & 1)
						pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
					s += sstep;
					t += tstep;
				}
				else
				{
					pdest[0] = pbase[(t >> 16) * cachewidth + (s >> 16)];
					s += sstep;
					t += tstep;
				}
			}
		} while ((pspan = pspan->pnext) != NULL);
	}
	break;
	default:
		Sys_Error("D_DrawSpans: unsupported r_pixbytes %i\n", r_pixbytes);
	}
}

void
D_DrawZSpans (espan_t *pspan)
{
	int         count, doublecount, izistep;
	int         izi;
	short      *pdest;
	unsigned int ltemp;
	double      zi;
	float       du, dv;

	// FIXME: check for clamping/range problems
	// we count on FP exceptions being turned off to avoid range problems
	izistep = (int) (d_zistepu * 0x8000 * 0x10000);

	do {
		pdest = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u;

		count = pspan->count;

		// calculate the initial 1/z
		du = (float) pspan->u;
		dv = (float) pspan->v;

		zi = d_ziorigin + dv * d_zistepv + du * d_zistepu;
		// we count on FP exceptions being turned off to avoid range problems
		izi = (int) (zi * 0x8000 * 0x10000);

		// LordHavoc: added big endian case, the old code is not correct on
		// big-endian (results in swapped depth pairs), and is tuned more for
		// x86, PowerPC compilers can probably do a good job with raw loop
		// unrolling if it is even necessary...
		if (bigendien)
		{
			do
			{
				*pdest++ = (short) (izi >> 16);
				izi += izistep;
			}
			while(--count);
		}
		else
		{
			if ((long) pdest & 0x02) {
				*pdest++ = (short) (izi >> 16);
				izi += izistep;
				count--;
			}

			if ((doublecount = count >> 1) > 0) {
				do {
					ltemp = izi >> 16;
					izi += izistep;
					ltemp |= izi & 0xFFFF0000;
					izi += izistep;
					*(int *) pdest = ltemp;
					pdest += 2;
				} while (--doublecount > 0);
			}

			if (count & 1)
				*pdest = (short) (izi >> 16);
		}
	} while ((pspan = pspan->pnext) != NULL);
}