/*
Copyright (C) 1997-2001 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.

*/
// r_edge.c

#include "r_local.h"

edge_t *auxedges;
edge_t *r_edges, *edge_p, *edge_max;

surf_t *surfaces, *surface_p, *surf_max;

// surfaces are generated in back to front order by the bsp, so if a surf
// pointer is greater than another one, it should be drawn in front
// surfaces[1] is the background, and is used as the active surface stack

edge_t       *newedges[MAXHEIGHT];
edge_t       *removeedges[MAXHEIGHT];

espan_t      *span_p, *max_span_p;

int          r_currentkey;

int          current_iv;

int          edge_head_u_shift20, edge_tail_u_shift20;

static void  (*pdrawfunc)( void );

edge_t       edge_head;
edge_t       edge_tail;

edge_t       edge_aftertail;
edge_t       edge_sentinel;

static float fv;

static int   miplevel;

float        scale_for_mip;

// FIXME: should go away
extern void R_RotateBmodel( void );
extern void R_TransformFrustum( void );



void R_GenerateSpans( void );
void R_GenerateSpansBackward( void );

void R_LeadingEdge( edge_t *edge );
void R_LeadingEdgeBackwards( edge_t *edge );
void R_TrailingEdge( surf_t *surf, edge_t *edge );


/*
===============================================================================

EDGE SCANNING

===============================================================================
*/

/*
==============
R_BeginEdgeFrame
==============
*/
void R_BeginEdgeFrame( void )
{
	int v;

	edge_p = r_edges;
	edge_max = &r_edges[r_numallocatededges];

	surface_p = &surfaces[2]; // background is surface 1,
	//  surface 0 is a dummy
	surfaces[1].spans = NULL; // no background spans yet
	surfaces[1].flags = 0;    // SURF_DRAWBACKGROUND;

// put the background behind everything in the world
	if( sw_draworder.value )
	{
		pdrawfunc = R_GenerateSpansBackward;
		surfaces[1].key = 0;
		r_currentkey = 1;
	}
	else
	{
		pdrawfunc = R_GenerateSpans;
		surfaces[1].key = 0x7FFfFFFF;
		r_currentkey = 0;
	}

// FIXME: set with memset
	for( v = RI.vrect.y; v < RI.vrectbottom; v++ )
	{
		newedges[v] = removeedges[v] = NULL;
	}
}

/*
==============
R_InsertNewEdges

Adds the edges in the linked list edgestoadd, adding them to the edges in the
linked list edgelist.  edgestoadd is assumed to be sorted on u, and non-empty (this is actually newedges[v]).  edgelist is assumed to be sorted on u, with a
sentinel at the end (actually, this is the active edge table starting at
edge_head.next).
==============
*/
static void R_InsertNewEdges( edge_t *edgestoadd, edge_t *edgelist )
{
	edge_t *next_edge;

	do
	{
		next_edge = edgestoadd->next;
edgesearch:
		if( !edgelist )
		{
			//	gEngfuncs.Con_Printf("NULL edgelist!\n");
			// return;
		}
		if( edgelist->u >= edgestoadd->u )
			goto addedge;
		edgelist = edgelist->next;
		if( edgelist->u >= edgestoadd->u )
			goto addedge;
		edgelist = edgelist->next;
		if( edgelist->u >= edgestoadd->u )
			goto addedge;
		edgelist = edgelist->next;
		if( edgelist->u >= edgestoadd->u )
			goto addedge;
		edgelist = edgelist->next;
		goto edgesearch;

		// insert edgestoadd before edgelist
addedge:
		edgestoadd->next = edgelist;
		edgestoadd->prev = edgelist->prev;
		edgelist->prev->next = edgestoadd;
		edgelist->prev = edgestoadd;
	}
	while(( edgestoadd = next_edge ) != NULL );
}

/*
==============
R_RemoveEdges
==============
*/
static void R_RemoveEdges( edge_t *pedge )
{

	do
	{
		pedge->next->prev = pedge->prev;
		pedge->prev->next = pedge->next;
	}
	while(( pedge = pedge->nextremove ) != NULL );
}

/*
==============
R_StepActiveU
==============
*/
static void R_StepActiveU( edge_t *pedge )
{
	edge_t *pnext_edge, *pwedge;

	while( 1 )
	{
nextedge:
		pedge->u += pedge->u_step;
		if( pedge->u < pedge->prev->u )
			goto pushback;
		pedge = pedge->next;

		pedge->u += pedge->u_step;
		if( pedge->u < pedge->prev->u )
			goto pushback;
		pedge = pedge->next;

		pedge->u += pedge->u_step;
		if( pedge->u < pedge->prev->u )
			goto pushback;
		pedge = pedge->next;

		pedge->u += pedge->u_step;
		if( pedge->u < pedge->prev->u )
			goto pushback;
		pedge = pedge->next;

		goto nextedge;

pushback:
		if( pedge == &edge_aftertail )
			return;

		// push it back to keep it sorted
		pnext_edge = pedge->next;

		// pull the edge out of the edge list
		pedge->next->prev = pedge->prev;
		pedge->prev->next = pedge->next;

		// find out where the edge goes in the edge list
		pwedge = pedge->prev->prev;
		//	if( !pwedge )
		//	return;

		while( pwedge->u > pedge->u )
		{
			pwedge = pwedge->prev;
			// if( !pwedge )
			// return;
		}

		// put the edge back into the edge list
		pedge->next = pwedge->next;
		pedge->prev = pwedge;
		pedge->next->prev = pedge;
		pwedge->next = pedge;

		pedge = pnext_edge;
		if( pedge == &edge_tail )
			return;
	}
}

/*
==============
R_CleanupSpan
==============
*/
static void R_CleanupSpan( void )
{
	surf_t  *surf;
	int     iu;
	espan_t *span;

// now that we've reached the right edge of the screen, we're done with any
// unfinished surfaces, so emit a span for whatever's on top
	surf = surfaces[1].next;
	iu = edge_tail_u_shift20;
	if( iu > surf->last_u )
	{
		span = span_p++;
		span->u = surf->last_u;
		span->count = iu - span->u;
		span->v = current_iv;
		span->pnext = surf->spans;
		surf->spans = span;
	}

// reset spanstate for all surfaces in the surface stack
	do
	{
		surf->spanstate = 0;
		surf = surf->next;
	}
	while( surf != &surfaces[1] );
}


/*
==============
R_LeadingEdgeBackwards
==============
*/
void R_LeadingEdgeBackwards( edge_t *edge )
{
	espan_t *span;
	surf_t  *surf, *surf2;
	int     iu;

// it's adding a new surface in, so find the correct place
	surf = &surfaces[edge->surfs[1]];

// don't start a span if this is an inverted span, with the end
// edge preceding the start edge (that is, we've already seen the
// end edge)
	if( ++surf->spanstate == 1 )
	{
		surf2 = surfaces[1].next;

		if( surf->key > surf2->key )
			goto newtop;

		// if it's two surfaces on the same plane, the one that's already
		// active is in front, so keep going unless it's a bmodel
		if( surf->insubmodel && ( surf->key == surf2->key ))
		{
			// must be two bmodels in the same leaf; don't care, because they'll
			// never be farthest anyway
			goto newtop;
		}

continue_search:

		do
		{
			surf2 = surf2->next;
		}
		while( surf->key < surf2->key );

		if( surf->key == surf2->key )
		{
			// if it's two surfaces on the same plane, the one that's already
			// active is in front, so keep going unless it's a bmodel
			if( !surf->insubmodel )
				goto continue_search;

			// must be two bmodels in the same leaf; don't care which is really
			// in front, because they'll never be farthest anyway
		}

		goto gotposition;

newtop:
		// emit a span (obscures current top)
		iu = edge->u >> 20;

		if( iu > surf2->last_u )
		{
			span = span_p++;
			span->u = surf2->last_u;
			span->count = iu - span->u;
			span->v = current_iv;
			span->pnext = surf2->spans;
			surf2->spans = span;
		}

		// set last_u on the new span
		surf->last_u = iu;

gotposition:
		// insert before surf2
		surf->next = surf2;
		surf->prev = surf2->prev;
		surf2->prev->next = surf;
		surf2->prev = surf;
	}
}


/*
==============
R_TrailingEdge
==============
*/
void R_TrailingEdge( surf_t *surf, edge_t *edge )
{
	espan_t *span;
	int     iu;

// don't generate a span if this is an inverted span, with the end
// edge preceding the start edge (that is, we haven't seen the
// start edge yet)
	if( --surf->spanstate == 0 )
	{
		if( surf == surfaces[1].next )
		{
			// emit a span (current top going away)
			iu = edge->u >> 20;
			if( iu > surf->last_u )
			{
				span = span_p++;
				span->u = surf->last_u;
				span->count = iu - span->u;
				span->v = current_iv;
				span->pnext = surf->spans;
				surf->spans = span;
			}

			// set last_u on the surface below
			surf->next->last_u = iu;
		}

		surf->prev->next = surf->next;
		surf->next->prev = surf->prev;
	}
}

/*
==============
R_LeadingEdge
==============
*/
void R_LeadingEdge( edge_t *edge )
{
	espan_t *span;
	surf_t  *surf, *surf2;
	int     iu;
	float   fu, newzi, testzi, newzitop, newzibottom;

	if( edge->surfs[1] )
	{
		// it's adding a new surface in, so find the correct place
		surf = &surfaces[edge->surfs[1]];

		// don't start a span if this is an inverted span, with the end
		// edge preceding the start edge (that is, we've already seen the
		// end edge)
		if( ++surf->spanstate == 1 )
		{
			surf2 = surfaces[1].next;

			if( surf->key < surf2->key )
				goto newtop;

			// if it's two surfaces on the same plane, the one that's already
			// active is in front, so keep going unless it's a bmodel
			if( surf->insubmodel && ( surf->key == surf2->key ))
			{
				// must be two bmodels in the same leaf; sort on 1/z
				fu = (float)( edge->u - 0xFFFFF ) * ( 1.0f / 0x100000 );
				newzi = surf->d_ziorigin + fv * surf->d_zistepv
					+ fu * surf->d_zistepu;
				newzibottom = newzi * 0.99f;

				testzi = surf2->d_ziorigin + fv * surf2->d_zistepv
					 + fu * surf2->d_zistepu;

				if( newzibottom >= testzi )
				{
					goto newtop;
				}

				newzitop = newzi * 1.01f;
				if( newzitop >= testzi )
				{
					if( surf->d_zistepu >= surf2->d_zistepu )
					{
						goto newtop;
					}
				}
			}

continue_search:

			do
			{
				surf2 = surf2->next;
			}
			while( surf->key > surf2->key );

			if( surf->key == surf2->key )
			{
				// if it's two surfaces on the same plane, the one that's already
				// active is in front, so keep going unless it's a bmodel
				if( !surf->insubmodel )
					goto continue_search;

				// must be two bmodels in the same leaf; sort on 1/z
				fu = (float)( edge->u - 0xFFFFF ) * ( 1.0f / 0x100000 );
				newzi = surf->d_ziorigin + fv * surf->d_zistepv
					+ fu * surf->d_zistepu;
				newzibottom = newzi * 0.99f;

				testzi = surf2->d_ziorigin + fv * surf2->d_zistepv
					 + fu * surf2->d_zistepu;

				if( newzibottom >= testzi )
				{
					goto gotposition;
				}

				newzitop = newzi * 1.01f;
				if( newzitop >= testzi )
				{
					if( surf->d_zistepu >= surf2->d_zistepu )
					{
						goto gotposition;
					}
				}

				goto continue_search;
			}

			goto gotposition;

newtop:
			// emit a span (obscures current top)
			iu = edge->u >> 20;

			if( iu > surf2->last_u )
			{
				span = span_p++;
				span->u = surf2->last_u;
				span->count = iu - span->u;
				span->v = current_iv;
				span->pnext = surf2->spans;
				surf2->spans = span;
			}

			// set last_u on the new span
			surf->last_u = iu;

gotposition:
			// insert before surf2
			surf->next = surf2;
			surf->prev = surf2->prev;
			surf2->prev->next = surf;
			surf2->prev = surf;
		}
	}
}


/*
==============
R_GenerateSpans
==============
*/
void R_GenerateSpans( void )
{
	edge_t *edge;
	surf_t *surf;

// clear active surfaces to just the background surface
	surfaces[1].next = surfaces[1].prev = &surfaces[1];
	surfaces[1].last_u = edge_head_u_shift20;

// generate spans
	for( edge = edge_head.next; edge != &edge_tail; edge = edge->next )
	{
		if( edge->surfs[0] )
		{
			// it has a left surface, so a surface is going away for this span
			surf = &surfaces[edge->surfs[0]];

			R_TrailingEdge( surf, edge );

			if( !edge->surfs[1] )
				continue;
		}

		R_LeadingEdge( edge );
	}

	R_CleanupSpan();
}

/*
==============
R_GenerateSpansBackward
==============
*/
void R_GenerateSpansBackward( void )
{
	edge_t *edge;

// clear active surfaces to just the background surface
	surfaces[1].next = surfaces[1].prev = &surfaces[1];
	surfaces[1].last_u = edge_head_u_shift20;

// generate spans
	for( edge = edge_head.next; edge != &edge_tail; edge = edge->next )
	{
		if( edge->surfs[0] )
			R_TrailingEdge( &surfaces[edge->surfs[0]], edge );

		if( edge->surfs[1] )
			R_LeadingEdgeBackwards( edge );
	}

	R_CleanupSpan();
}


/*
==============
R_ScanEdges

Input:
newedges[] array
	this has links to edges, which have links to surfaces

Output:
Each surface has a linked list of its visible spans
==============
*/
void R_ScanEdges( void )
{
	int     iv, bottom;
	byte    basespans[MAXSPANS * sizeof( espan_t ) + CACHE_SIZE];
	espan_t *basespan_p;
	surf_t  *s;

	basespan_p = (espan_t *)
		     ((uintptr_t)( basespans + CACHE_SIZE - 1 ) & ~( CACHE_SIZE - 1 ));
	max_span_p = &basespan_p[MAXSPANS - RI.vrect.width];

	span_p = basespan_p;

// clear active edges to just the background edges around the whole screen
// FIXME: most of this only needs to be set up once
	edge_head.u = RI.vrect.x << 20;
	edge_head_u_shift20 = edge_head.u >> 20;
	edge_head.u_step = 0;
	edge_head.prev = NULL;
	edge_head.next = &edge_tail;
	edge_head.surfs[0] = 0;
	edge_head.surfs[1] = 1;

	edge_tail.u = ( RI.vrectright << 20 ) + 0xFFFFF; // (r_refdef.vrectright << 20) + 0xFFFFF;
	edge_tail_u_shift20 = edge_tail.u >> 20;
	edge_tail.u_step = 0;
	edge_tail.prev = &edge_head;
	edge_tail.next = &edge_aftertail;
	edge_tail.surfs[0] = 1;
	edge_tail.surfs[1] = 0;

	edge_aftertail.u = -1; // force a move
	edge_aftertail.u_step = 0;
	edge_aftertail.next = &edge_sentinel;
	edge_aftertail.prev = &edge_tail;

// FIXME: do we need this now that we clamp x in r_draw.c?
	edge_sentinel.u = 2000 << 20; // make sure nothing sorts past this
	edge_sentinel.prev = &edge_aftertail;

//
// process all scan lines
//
	bottom = RI.vrectbottom - 1;

	for( iv = 0; iv < bottom; iv++ )
	{
		current_iv = iv;
		fv = (float)iv;

		// mark that the head (background start) span is pre-included
		surfaces[1].spanstate = 1;

		if( newedges[iv] )
		{
			R_InsertNewEdges( newedges[iv], edge_head.next );
		}
		( *pdrawfunc )();

		// flush the span list if we can't be sure we have enough spans left for
		// the next scan
		if( span_p > max_span_p )
		{
			D_DrawSurfaces();

			// clear the surface span pointers
			for( s = &surfaces[1]; s < surface_p; s++ )
				s->spans = NULL;

			span_p = basespan_p;
		}
		if( removeedges[iv] )
			R_RemoveEdges( removeedges[iv] );

		if( edge_head.next != &edge_tail )
			R_StepActiveU( edge_head.next );
	}

// do the last scan (no need to step or sort or remove on the last scan)

	current_iv = iv;
	fv = (float)iv;

// mark that the head (background start) span is pre-included
	surfaces[1].spanstate = 1;

	if( newedges[iv] )
		R_InsertNewEdges( newedges[iv], edge_head.next );

	( *pdrawfunc )();

// draw whatever's left in the span list
	D_DrawSurfaces();
}


/*
=========================================================================

SURFACE FILLING

=========================================================================
*/

msurface_t  *pface;
surfcache_t *pcurrentcache;
vec3_t      transformed_modelorg;
vec3_t      world_transformed_modelorg;
vec3_t      local_modelorg;

/*
=============
D_MipLevelForScale
=============
*/
static int D_MipLevelForScale( float scale )
{
	int lmiplevel;

	if( scale >= d_scalemip[0] )
		lmiplevel = 0;
	else if( scale >= d_scalemip[1] )
		lmiplevel = 1;
	else if( scale >= d_scalemip[2] )
		lmiplevel = 2;
	else
		lmiplevel = 3;

	if( lmiplevel < d_minmip )
		lmiplevel = d_minmip;

	return lmiplevel;
}


/*
==============
D_FlatFillSurface

Simple single color fill with no texture mapping
==============
*/
static void D_FlatFillSurface( surf_t *surf, int color )
{
	espan_t *span;
	pixel_t *pdest;
	int     u, u2;

	for( span = surf->spans; span; span = span->pnext )
	{
		pdest = d_viewbuffer + r_screenwidth * span->v;
		u = span->u;
		u2 = span->u + span->count - 1;
		for( ; u <= u2; u++ )
			pdest[u] = color;
	}
}


/*
==============
D_CalcGradients
==============
*/
static void D_CalcGradients( msurface_t *pface )
{
	mplane_t *pplane;
	float    mipscale;
	vec3_t   p_temp1;
	vec3_t   p_saxis, p_taxis;
	float    t;

	pplane = pface->plane;

	mipscale = 1.0f / (float)( 1 << miplevel );


	if( pface->texinfo->flags & TEX_WORLD_LUXELS )
	{
		TransformVector( pface->texinfo->vecs[0], p_saxis );
		TransformVector( pface->texinfo->vecs[1], p_taxis );
	}
	else
	{
		TransformVector( pface->info->lmvecs[0], p_saxis );
		TransformVector( pface->info->lmvecs[1], p_taxis );
	}

	t = xscaleinv * mipscale;
	d_sdivzstepu = p_saxis[0] * t;
	d_tdivzstepu = p_taxis[0] * t;

	t = yscaleinv * mipscale;
	d_sdivzstepv = -p_saxis[1] * t;
	d_tdivzstepv = -p_taxis[1] * t;

	d_sdivzorigin = p_saxis[2] * mipscale - xcenter * d_sdivzstepu
			- ycenter * d_sdivzstepv;
	d_tdivzorigin = p_taxis[2] * mipscale - xcenter * d_tdivzstepu
			- ycenter * d_tdivzstepv;

	VectorScale( transformed_modelorg, mipscale, p_temp1 );

	t = 0x10000 * mipscale;
	if( pface->texinfo->flags & TEX_WORLD_LUXELS )
	{
		sadjust = ((fixed16_t)( DotProduct( p_temp1, p_saxis ) * 0x10000 + 0.5f ))
			  - (( pface->texturemins[0] << 16 ) >> miplevel )
			  + pface->texinfo->vecs[0][3] * t;
		tadjust = ((fixed16_t)( DotProduct( p_temp1, p_taxis ) * 0x10000 + 0.5f ))
			  - (( pface->texturemins[1] << 16 ) >> miplevel )
			  + pface->texinfo->vecs[1][3] * t;
	}
	else
	{
		sadjust = ((fixed16_t)( DotProduct( p_temp1, p_saxis ) * 0x10000 + 0.5f ))
			  - (( pface->info->lightmapmins[0] << 16 ) >> miplevel )
			  + pface->info->lmvecs[0][3] * t;
		tadjust = ((fixed16_t)( DotProduct( p_temp1, p_taxis ) * 0x10000 + 0.5f ))
			  - (( pface->info->lightmapmins[1] << 16 ) >> miplevel )
			  + pface->info->lmvecs[1][3] * t;
	}
	// PGM - changing flow speed for non-warping textures.
	if( pface->flags & SURF_CONVEYOR )
	{

		if( pface->flags & SURF_DRAWTURB )
			sadjust += 0x10000 * ( -128 * (( gp_cl->time * 0.25f ) - (int)( gp_cl->time * 0.25f )));
		else
			sadjust += 0x10000 * ( -128 * (( gp_cl->time * 0.77f ) - (int)( gp_cl->time * 0.77f )));
		bbextents = (( pface->extents[0] << 16 ) >> miplevel ) - 1;
	}
	else
		bbextents = (( pface->info->lightextents[0] << 16 ) >> miplevel ) - 1;
	bbextentt = (( pface->info->lightextents[1] << 16 ) >> miplevel ) - 1;

	if( pface->texinfo->flags & TEX_WORLD_LUXELS )
	{
		bbextents = (( pface->extents[0] << 16 ) >> miplevel ) - 1;
		bbextentt = (( pface->extents[1] << 16 ) >> miplevel ) - 1;
	}
}


/*
==============
D_BackgroundSurf

The grey background filler seen when there is a hole in the map
==============
*/
static void D_BackgroundSurf( surf_t *s )
{
// set up a gradient for the background surface that places it
// effectively at infinity distance from the viewpoint
	d_zistepu = 0;
	d_zistepv = 0;
	d_ziorigin = -0.9;

	D_FlatFillSurface( s, (int)sw_clearcolor.value & 0xFFFF );
	D_DrawZSpans( s->spans );
}

/*
=================
D_TurbulentSurf
=================
*/
static void D_TurbulentSurf( surf_t *s )
{
	d_zistepu = s->d_zistepu;
	d_zistepv = s->d_zistepv;
	d_ziorigin = s->d_ziorigin;

	pface = s->msurf;
	miplevel = 0;
	cacheblock = R_GetTexture( pface->texinfo->texture->gl_texturenum )->pixels[0];
	cachewidth = 64;

	if( s->insubmodel )
	{
		// FIXME: we don't want to do all this for every polygon!
		// TODO: store once at start of frame
		RI.currententity = s->entity; // FIXME: make this passed in to
		// R_RotateBmodel ()
		VectorSubtract( RI.vieworg, RI.currententity->origin,
				local_modelorg );
		TransformVector( local_modelorg, transformed_modelorg );

		R_RotateBmodel(); // FIXME: don't mess with the frustum,
		// make entity passed in
	}

	D_CalcGradients( pface );

// ============
// PGM
	// textures that aren't warping are just flowing. Use NonTurbulent8 instead
	if( !( pface->flags & SURF_DRAWTURB ))
		NonTurbulent8( s->spans );
	else
		Turbulent8( s->spans );
// PGM
// ============

	D_DrawZSpans( s->spans );

	if( s->insubmodel )
	{
		//
		// restore the old drawing state
		// FIXME: we don't want to do this every time!
		// TODO: speed up
		//
		RI.currententity = NULL; // &r_worldentity;
		VectorCopy( world_transformed_modelorg,
			    transformed_modelorg );
		VectorCopy( RI.base_vpn, RI.vforward );
		VectorCopy( RI.base_vup, RI.vup );
		VectorCopy( RI.base_vright, RI.vright );
		R_TransformFrustum();
	}
}

qboolean alphaspans;
/*
==============
D_SolidSurf

Normal surface cached, texture mapped surface
==============
*/
static void D_AlphaSurf( surf_t *s )
{
	int alpha;

	d_zistepu = s->d_zistepu;
	d_zistepv = s->d_zistepv;
	d_ziorigin = s->d_ziorigin;
	if( s->flags & SURF_DRAWSKY )
		return;
	if( !s->insubmodel )// wtf? how it is possible?
		return;

// FIXME: we don't want to do all this for every polygon!
// TODO: store once at start of frame
	RI.currententity = s->entity; // FIXME: make this passed in to
	// R_RotateBmodel ()
	VectorSubtract( RI.vieworg, RI.currententity->origin, local_modelorg );
	TransformVector( local_modelorg, transformed_modelorg );

	R_RotateBmodel(); // FIXME: don't mess with the frustum,
	// make entity passed in


	pface = s->msurf;


	if( !pface )
		return;

	if( pface->flags & SURF_CONVEYOR )
		miplevel = 1;
	else
		miplevel = 0;

	alpha = RI.currententity->curstate.renderamt * 7 / 255;
	if( alpha <= 0 && RI.currententity->curstate.renderamt > 0 )
		alpha = 1;

	if( s->flags & SURF_DRAWTURB )
	{
		cacheblock = R_GetTexture( pface->texinfo->texture->gl_texturenum )->pixels[0];
		cachewidth = 64;
		D_CalcGradients( pface );
		TurbulentZ8( s->spans, alpha );
	}
	else
	{
		// FIXME: make this passed in to D_CacheSurface
		pcurrentcache = D_CacheSurface( pface, miplevel );

		cacheblock = (pixel_t *)pcurrentcache->data;
		cachewidth = pcurrentcache->width;

		D_CalcGradients( pface );



		if( RI.currententity->curstate.rendermode == kRenderTransAlpha )
			D_AlphaSpans16( s->spans );
		else if( RI.currententity->curstate.rendermode == kRenderTransAdd )
			D_AddSpans16( s->spans );
		else
			D_BlendSpans16( s->spans, alpha );
	}

	VectorCopy( world_transformed_modelorg,
		    transformed_modelorg );
	VectorCopy( RI.base_vpn, RI.vforward );
	VectorCopy( RI.base_vup, RI.vup );
	VectorCopy( RI.base_vright, RI.vright );
	R_TransformFrustum();
}


/*
==============
D_SolidSurf

Normal surface cached, texture mapped surface
==============
*/
static void D_SolidSurf( surf_t *s )
{
	d_zistepu = s->d_zistepu;
	d_zistepv = s->d_zistepv;
	d_ziorigin = s->d_ziorigin;
	if( s->flags & SURF_DRAWSKY )
		return;
	if( s->flags & SURF_DRAWTURB )
		return;

	if( s->insubmodel )
	{
		// FIXME: we don't want to do all this for every polygon!
		// TODO: store once at start of frame
		RI.currententity = s->entity; // FIXME: make this passed in to
		// R_RotateBmodel ()
		VectorSubtract( RI.vieworg, RI.currententity->origin, local_modelorg );
		TransformVector( local_modelorg, transformed_modelorg );

		R_RotateBmodel(); // FIXME: don't mess with the frustum,
		// make entity passed in
		// setup dlight transform
		if( s->msurf && s->msurf->dlightframe == tr.framecount )
		{
			Matrix4x4_CreateFromEntity( RI.objectMatrix, RI.currententity->angles, RI.currententity->origin, 1 );
			tr.modelviewIdentity = false;
		}
	}
	else
	{
		if( alphaspans )
			return;
		RI.currententity = CL_GetEntityByIndex( 0 ); // r_worldentity;
		tr.modelviewIdentity = true;
	}

	pface = s->msurf;


	if( !pface )
		return;

	if( pface->flags & SURF_CONVEYOR )
		miplevel = 1;
	else
		miplevel = D_MipLevelForScale( s->nearzi * scale_for_mip );
	while( 1 << miplevel > gEngfuncs.Mod_SampleSizeForFace( pface ))
		miplevel--;

	// FIXME: make this passed in to D_CacheSurface
	pcurrentcache = D_CacheSurface( pface, miplevel );

	cacheblock = (pixel_t *)pcurrentcache->data;
	cachewidth = pcurrentcache->width;

	D_CalcGradients( pface );

	D_DrawSpans16( s->spans );

	D_DrawZSpans( s->spans );

	if( s->insubmodel )
	{
		//
		// restore the old drawing state
		// FIXME: we don't want to do this every time!
		// TODO: speed up
		//
		VectorCopy( world_transformed_modelorg,
			    transformed_modelorg );
		VectorCopy( RI.base_vpn, RI.vforward );
		VectorCopy( RI.base_vup, RI.vup );
		VectorCopy( RI.base_vright, RI.vright );
		R_TransformFrustum();
		RI.currententity = NULL; // &r_worldentity;
	}
}

/*
=============
D_DrawflatSurfaces

To allow developers to see the polygon carving of the world
=============
*/
static void D_DrawflatSurfaces( void )
{
	surf_t *s;

	for( s = &surfaces[1]; s < surface_p; s++ )
	{
		if( !s->spans )
			continue;

		d_zistepu = s->d_zistepu;
		d_zistepv = s->d_zistepv;
		d_ziorigin = s->d_ziorigin;

		// make a stable color for each surface by taking the low
		// bits of the msurface pointer
		D_FlatFillSurface( s, (uintptr_t)s->msurf & 0xFFFF );
		D_DrawZSpans( s->spans );
	}
}

/*
==============
D_DrawSurfaces

Rasterize all the span lists.  Guaranteed zero overdraw.
May be called more than once a frame if the surf list overflows (higher res)
==============
*/
void D_DrawSurfaces( void )
{
	surf_t *s;

//	currententity = NULL;	//&r_worldentity;
	VectorSubtract( RI.vieworg, vec3_origin, tr.modelorg );
	TransformVector( tr.modelorg, transformed_modelorg );
	VectorCopy( transformed_modelorg, world_transformed_modelorg );

	if( !sw_drawflat.value )
	{
		for( s = &surfaces[1]; s < surface_p; s++ )
		{
			if( !s->spans )
				continue;

			if( alphaspans )
				D_AlphaSurf( s );
			else if( s->flags & SURF_DRAWSKY )
				D_BackgroundSurf( s );
			else if( s->flags & SURF_DRAWTURB )
				D_TurbulentSurf( s );
			else
				D_SolidSurf( s );
		}
	}
	else
		D_DrawflatSurfaces();

	// RI.currententity = NULL;	//&r_worldentity;
	VectorSubtract( RI.vieworg, vec3_origin, tr.modelorg );
	R_TransformFrustum();
}