Subversion Repositories Kolibri OS

/*

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_scan.c

//

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

#include "quakedef.h"

#include "r_local.h"

#include "d_local.h"

unsigned char	*r_turb_pbase, *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_DrawTurbulent8Span (void);

/*

=============

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)

{

	int		w, h;

	int		u,v;

	byte	*dest;

	int		*turb;

	int		*col;

	byte	**row;

	byte	*rowptr[MAXHEIGHT+(AMP2*2)];

	int		column[MAXWIDTH+(AMP2*2)];

	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

	{

		rowptr[v] = d_viewbuffer + (r_refdef.vrect.y * screenwidth) +

				 (screenwidth * (int)((float)v * hratio * h / (h + AMP2 * 2)));

	}

	for (u=0 ; u

	{

		column[u] = r_refdef.vrect.x +

				(int)((float)u * wratio * w / (w + AMP2 * 2));

	}

	turb = intsintable + ((int)(cl.time*SPEED)&(CYCLE-1));

	dest = vid.buffer + scr_vrect.y * vid.rowbytes + scr_vrect.x;

	for (v=0 ; v

	{

		col = &column[turb[v]];

		row = &rowptr[v];

		for (u=0 ; u

		{

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

		}

	}

}

#if	!id386

/*

=============

D_DrawTurbulent8Span

=============

*/

void D_DrawTurbulent8Span (void)

{

	int		sturb, tturb;

	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;

		*r_turb_pdest++ = *(r_turb_pbase + (tturb<<6) + sturb);

		r_turb_s += r_turb_sstep;

		r_turb_t += r_turb_tstep;

	} while (--r_turb_spancount > 0);

}

#endif	// !id386

/*

=============

Turbulent8

=============

*/

void Turbulent8 (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)(cl.time*SPEED)&(CYCLE-1));

	r_turb_sstep = 0;	// keep compiler happy

	r_turb_tstep = 0;	// ditto

	r_turb_pbase = (unsigned char *)cacheblock;

	sdivz16stepu = d_sdivzstepu * 16;

	tdivz16stepu = d_tdivzstepu * 16;

	zi16stepu = d_zistepu * 16;

	do

	{

		r_turb_pdest = (unsigned char *)((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;

		z = (float)0x10000 / zi;	// prescale to 16.16 fixed-point

		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 = (float)0x10000 / zi;	// prescale to 16.16 fixed-point

				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 * spancountminus1;

				z = (float)0x10000 / zi;	// prescale to 16.16 fixed-point

				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

				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_DrawTurbulent8Span ();

			r_turb_s = snext;

			r_turb_t = tnext;

		} while (count > 0);

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

}

#if	!id386

/*

=============

D_DrawSpans8

=============

*/

void D_DrawSpans8 (espan_t *pspan)

{

	int				count, spancount;

	unsigned char	*pbase, *pdest;

	fixed16_t		s, t, snext, tnext, sstep, tstep;

	float			sdivz, tdivz, zi, z, du, dv, spancountminus1;

	float			sdivz8stepu, tdivz8stepu, zi8stepu;

	sstep = 0;	// keep compiler happy

	tstep = 0;	// ditto

	pbase = (unsigned char *)cacheblock;

	sdivz8stepu = d_sdivzstepu * 8;

	tdivz8stepu = d_tdivzstepu * 8;

	zi8stepu = d_zistepu * 8;

	do

	{

		pdest = (unsigned char *)((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;

		z = (float)0x10000 / zi;	// prescale to 16.16 fixed-point

		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

			{

				*pdest++ = *(pbase + (s >> 16) + (t >> 16) * cachewidth);

				s += sstep;

				t += tstep;

			} while (--spancount > 0);

			s = snext;

			t = tnext;

		} while (count > 0);

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

}

#endif

#if	!id386

/*

=============

D_DrawZSpans

=============

*/

void D_DrawZSpans (espan_t *pspan)

{

	int				count, doublecount, izistep;

	int				izi;

	short			*pdest;

	unsigned		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);

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

}

#endif