/*
 * r_alias.c -- routines for setting up to draw alias models
 * $Id: r_alias.c,v 1.21 2008-04-22 13:06:10 sezero Exp $
 *
 * Copyright (C) 1996-1997  Id Software, Inc.
 * Copyright (C) 1997-1998  Raven Software Corp.
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "quakedef.h"
#include "r_local.h"
#include "d_local.h"	// FIXME: shouldn't be needed (is needed for patch
			//	  right now, but that should move)

#define LIGHT_MIN	5	// lowest light value we'll allow, to avoid the
				// need for inner-loop light clamping

mtriangle_t		*ptriangles;
affinetridesc_t		r_affinetridesc;

void			*acolormap;	// FIXME: should go away
trivertx_t		*r_apverts;

// TODO: these probably will go away with optimized rasterization
newmdl_t		*pmdl;		//JFM: new model fmt
vec3_t			r_plightvec;
int			r_ambientlight;
float			r_shadelight;
aliashdr_t		*paliashdr;
finalvert_t		*pfinalverts;
auxvert_t		*pauxverts;
static float		ziscale;
static qmodel_t		*pmodel;

static vec3_t		alias_forward, alias_right, alias_up;

static maliasskindesc_t	*pskindesc;

int			r_amodels_drawn;
int			r_anumverts;

float			aliastransform[3][4];

typedef struct {
	int	index0;
	int	index1;
} aedge_t;

static aedge_t	aedges[12] =
{
	{0, 1}, {1, 2}, {2, 3}, {3, 0},
	{4, 5}, {5, 6}, {6, 7}, {7, 4},
	{0, 5}, {1, 4}, {2, 7}, {3, 6}
};

#define NUMVERTEXNORMALS	162

float	r_avertexnormals[NUMVERTEXNORMALS][3] =
{
#include "anorms.h"
};


#if !id386
static void R_AliasTransformAndProjectFinalVerts (finalvert_t *fv, stvert_t *pstverts);
#endif
static void R_AliasSetUpTransform (int trivial_accept);
static void R_AliasTransformVector (vec3_t in, vec3_t out);
static void R_AliasTransformFinalVert (finalvert_t *fv, auxvert_t *av, trivertx_t *pverts);


/*
================
R_AliasCheckBBox
================
*/
qboolean R_AliasCheckBBox (void)
{
	int			i, flags, frame, numv;
	aliashdr_t		*pahdr;
	float			zi, basepts[8][3], v0, v1, frac;
	finalvert_t		*pv0, *pv1, viewpts[16];
	auxvert_t		*pa0, *pa1, viewaux[16];
	maliasframedesc_t	*pframedesc;
	qboolean		zclipped, zfullyclipped;
	unsigned int		anyclip, allclip;
	int			minz;

// expand, rotate, and translate points into worldspace

	currententity->trivial_accept = 0;
	pmodel = currententity->model;
	pahdr = (aliashdr_t *) Mod_Extradata (pmodel);
	pmdl = (newmdl_t*)((byte *)pahdr + pahdr->model);

	R_AliasSetUpTransform (0);

// construct the base bounding box for this frame
	frame = currententity->frame;
// TODO: don't repeat this check when drawing?
	if ((frame >= pmdl->numframes) || (frame < 0))
	{
		Con_DPrintf ("No such frame %d %s\n", frame, pmodel->name);
		frame = 0;
	}

	pframedesc = &pahdr->frames[frame];

// x worldspace coordinates
	basepts[0][0] =
		basepts[1][0] =
		basepts[2][0] =
		basepts[3][0] =
			(float)pframedesc->bboxmin.v[0];
	basepts[4][0] =
		basepts[5][0] =
		basepts[6][0] =
		basepts[7][0] =
			(float)pframedesc->bboxmax.v[0];

// y worldspace coordinates
	basepts[0][1] =
		basepts[3][1] =
		basepts[5][1] =
		basepts[6][1] =
			(float)pframedesc->bboxmin.v[1];
	basepts[1][1] =
		basepts[2][1] =
		basepts[4][1] =
		basepts[7][1] =
			(float)pframedesc->bboxmax.v[1];

// z worldspace coordinates
	basepts[0][2] =
		basepts[1][2] =
		basepts[4][2] =
		basepts[5][2] =
			(float)pframedesc->bboxmin.v[2];
	basepts[2][2] =
		basepts[3][2] =
		basepts[6][2] =
		basepts[7][2] =
			(float)pframedesc->bboxmax.v[2];

	zclipped = false;
	zfullyclipped = true;

	minz = 9999;
	for (i = 0 ; i < 8 ; i++)
	{
		R_AliasTransformVector (&basepts[i][0], &viewaux[i].fv[0]);

		if (viewaux[i].fv[2] < ALIAS_Z_CLIP_PLANE)
		{
		// we must clip points that are closer than the near clip plane
			viewpts[i].flags = ALIAS_Z_CLIP;
			zclipped = true;
		}
		else
		{
			if (viewaux[i].fv[2] < minz)
				minz = viewaux[i].fv[2];
			viewpts[i].flags = 0;
			zfullyclipped = false;
		}
	}

	if (zfullyclipped)
	{
		return false;	// everything was near-z-clipped
	}

	numv = 8;

	if (zclipped)
	{
	// organize points by edges, use edges to get new points
	// (possible trivial reject)
		for (i = 0 ; i < 12 ; i++)
		{
		// edge endpoints
			pv0 = &viewpts[aedges[i].index0];
			pv1 = &viewpts[aedges[i].index1];
			pa0 = &viewaux[aedges[i].index0];
			pa1 = &viewaux[aedges[i].index1];

		// if one end is clipped and the other isn't, make a new point
			if (pv0->flags ^ pv1->flags)
			{
				frac = (ALIAS_Z_CLIP_PLANE - pa0->fv[2]) / (pa1->fv[2] - pa0->fv[2]);
				viewaux[numv].fv[0] = pa0->fv[0] + (pa1->fv[0] - pa0->fv[0]) * frac;
				viewaux[numv].fv[1] = pa0->fv[1] + (pa1->fv[1] - pa0->fv[1]) * frac;
				viewaux[numv].fv[2] = ALIAS_Z_CLIP_PLANE;
				viewpts[numv].flags = 0;
				numv++;
			}
		}
	}

// project the vertices that remain after clipping
	anyclip = 0;
	allclip = ALIAS_XY_CLIP_MASK;

// TODO: probably should do this loop in ASM, especially if we use floats
	for (i = 0 ; i < numv ; i++)
	{
	// we don't need to bother with vertices that were z-clipped
		if (viewpts[i].flags & ALIAS_Z_CLIP)
			continue;

		zi = 1.0 / viewaux[i].fv[2];

	// FIXME: do with chop mode in ASM, or convert to float
		v0 = (viewaux[i].fv[0] * xscale * zi) + xcenter;
		v1 = (viewaux[i].fv[1] * yscale * zi) + ycenter;

		flags = 0;

		if (v0 < r_refdef.fvrectx)
			flags |= ALIAS_LEFT_CLIP;
		if (v1 < r_refdef.fvrecty)
			flags |= ALIAS_TOP_CLIP;
		if (v0 > r_refdef.fvrectright)
			flags |= ALIAS_RIGHT_CLIP;
		if (v1 > r_refdef.fvrectbottom)
			flags |= ALIAS_BOTTOM_CLIP;

		anyclip |= flags;
		allclip &= flags;
	}

	if (allclip)
		return false;	// trivial reject off one side

	currententity->trivial_accept = !anyclip & !zclipped;

	if (currententity->trivial_accept)
	{
		if (minz > (r_aliastransition + (pmdl->size * r_resfudge)))
		{
			currententity->trivial_accept |= 2;
		}
	}

	return true;
}


/*
================
R_AliasTransformVector
================
*/
static void R_AliasTransformVector (vec3_t in, vec3_t out)
{
	out[0] = DotProduct(in, aliastransform[0]) + aliastransform[0][3];
	out[1] = DotProduct(in, aliastransform[1]) + aliastransform[1][3];
	out[2] = DotProduct(in, aliastransform[2]) + aliastransform[2][3];
}


/*
================
R_AliasPreparePoints

General clipped case
================
*/
static void R_AliasPreparePoints (void)
{
	int			i;
	stvert_t	*pstverts;
	finalvert_t	*fv;
	auxvert_t	*av;
	mtriangle_t	*ptri;
	finalvert_t	*pfv[3];

	pstverts = (stvert_t *)((byte *)paliashdr + paliashdr->stverts);
	r_anumverts = pmdl->numverts;
	fv = pfinalverts;
	av = pauxverts;

	for (i = 0 ; i < r_anumverts ; i++, fv++, av++, r_apverts++)
	{
		fv->flags = 0;
		R_AliasTransformFinalVert (fv, av, r_apverts);
		if (av->fv[2] < ALIAS_Z_CLIP_PLANE)
			fv->flags |= ALIAS_Z_CLIP;
		else
		{
			R_AliasProjectFinalVert (fv, av);

			if (fv->v[0] < r_refdef.aliasvrect.x)
				fv->flags |= ALIAS_LEFT_CLIP;
			if (fv->v[1] < r_refdef.aliasvrect.y)
				fv->flags |= ALIAS_TOP_CLIP;
			if (fv->v[0] > r_refdef.aliasvrectright)
				fv->flags |= ALIAS_RIGHT_CLIP;
			if (fv->v[1] > r_refdef.aliasvrectbottom)
				fv->flags |= ALIAS_BOTTOM_CLIP;
		}
	}

//
// clip and draw all triangles
//
	r_affinetridesc.numtriangles = 1;

	ptri = (mtriangle_t *)((byte *)paliashdr + paliashdr->triangles);
	for (i = 0 ; i < pmdl->numtris ; i++, ptri++)
	{
		pfv[0] = &pfinalverts[ptri->vertindex[0]];
		pfv[1] = &pfinalverts[ptri->vertindex[1]];
		pfv[2] = &pfinalverts[ptri->vertindex[2]];

		if ( pfv[0]->flags & pfv[1]->flags & pfv[2]->flags & (ALIAS_XY_CLIP_MASK | ALIAS_Z_CLIP) )
			continue;		// completely clipped

		//jfm: fill in the triangles s and t into the finalvert
		pfv[0]->v[2] = pstverts[ptri->stindex[0]].s;
		pfv[0]->v[3] = pstverts[ptri->stindex[0]].t;
		pfv[0]->flags |= pstverts[ptri->stindex[0]].onseam;

		pfv[1]->v[2] = pstverts[ptri->stindex[1]].s;
		pfv[1]->v[3] = pstverts[ptri->stindex[1]].t;
		pfv[1]->flags |= pstverts[ptri->stindex[1]].onseam;

		pfv[2]->v[2] = pstverts[ptri->stindex[2]].s;
		pfv[2]->v[3] = pstverts[ptri->stindex[2]].t;
		pfv[2]->flags |= pstverts[ptri->stindex[2]].onseam;

		if ( ! ( (pfv[0]->flags | pfv[1]->flags | pfv[2]->flags) & (ALIAS_XY_CLIP_MASK | ALIAS_Z_CLIP) ) )
		{	// totally unclipped
			r_affinetridesc.pfinalverts = pfinalverts;
			r_affinetridesc.ptriangles = ptri;

			if ((currententity->model->flags & EF_SPECIAL_TRANS))
				D_PolysetDrawT5 ();
			else if (currententity->drawflags & DRF_TRANSLUCENT)
				D_PolysetDrawT ();
			else if ((currententity->model->flags & EF_TRANSPARENT))
				D_PolysetDrawT2 ();
			else if ((currententity->model->flags & EF_HOLEY))
				D_PolysetDrawT3 ();
			else
				D_PolysetDraw ();
		}
		else
		{	// partially clipped
			R_AliasClipTriangle (ptri);
		}
	}
}


/*
================
R_AliasSetUpTransform
================
*/
static void R_AliasSetUpTransform (int trivial_accept)
{
	int			i;
	float		rotationmatrix[3][4], t2matrix[3][4];
	static float	tmatrix[3][4];
	static float	viewmatrix[3][4];
	vec3_t		angles;
	float		entScale;
	float		xyfact = 1.0, zfact = 1.0; // avoid compiler warning
	float		forward;
	float		yaw, pitch;

// TODO: should really be stored with the entity instead of being reconstructed
// TODO: should use a look-up table
// TODO: could cache lazily, stored in the entity

	if (currententity->model->flags & EF_FACE_VIEW)
	{
		VectorSubtract(currententity->origin,r_origin,angles);
		VectorSubtract(r_origin,currententity->origin,angles);
		VectorNormalize(angles);

		if (angles[1] == 0 && angles[0] == 0)
		{
			yaw = 0;
			if (angles[2] > 0)
				pitch = 90;
			else
				pitch = 270;
		}
		else
		{
			yaw = (int) (atan2(angles[1], angles[0]) * 180 / M_PI);
			if (yaw < 0)
				yaw += 360;

			forward = sqrt (angles[0]*angles[0] + angles[1]*angles[1]);
			pitch = (int) (atan2(angles[2], forward) * 180 / M_PI);
			if (pitch < 0)
				pitch += 360;
		}

		angles[0] = -pitch;
		angles[1] = yaw;
//		angles[2] = 0;
		angles[2] = currententity->angles[ROLL];
	}
	else
	{
		angles[ROLL] = currententity->angles[ROLL];
		angles[PITCH] = -currententity->angles[PITCH];
		if (currententity->model->flags & EF_ROTATE)
		{
			angles[YAW] = anglemod( (currententity->origin[0] + currententity->origin[1])*0.8
						+ (108*cl.time) );
		}
		else
		{
			angles[YAW] = currententity->angles[YAW];
		}
	}

	// For clientside rotation stuff
	angles[0] += currententity->angleAdd[0];
	angles[1] += currententity->angleAdd[1];
	angles[2] += currententity->angleAdd[2];

	AngleVectors (angles, alias_forward, alias_right, alias_up);

	if (currententity->scale != 0 && currententity->scale != 100)
	{
		entScale = (float)currententity->scale/100.0;
		switch (currententity->drawflags & SCALE_TYPE_MASKIN)
		{
		case SCALE_TYPE_UNIFORM:
			tmatrix[0][0] = pmdl->scale[0]*entScale;
			tmatrix[1][1] = pmdl->scale[1]*entScale;
			tmatrix[2][2] = pmdl->scale[2]*entScale;
			xyfact = zfact = (entScale-1.0)*127.95;
			break;
		case SCALE_TYPE_XYONLY:
			tmatrix[0][0] = pmdl->scale[0]*entScale;
			tmatrix[1][1] = pmdl->scale[1]*entScale;
			tmatrix[2][2] = pmdl->scale[2];
			xyfact = (entScale-1.0)*127.95;
			zfact = 1.0;
			break;
		case SCALE_TYPE_ZONLY:
			tmatrix[0][0] = pmdl->scale[0];
			tmatrix[1][1] = pmdl->scale[1];
			tmatrix[2][2] = pmdl->scale[2]*entScale;
			xyfact = 1.0;
			zfact = (entScale-1.0)*127.95;
			break;
		}
		switch (currententity->drawflags & SCALE_ORIGIN_MASKIN)
		{
		case SCALE_ORIGIN_CENTER:
			tmatrix[0][3] = pmdl->scale_origin[0]-pmdl->scale[0]*xyfact;
			tmatrix[1][3] = pmdl->scale_origin[1]-pmdl->scale[1]*xyfact;
			tmatrix[2][3] = pmdl->scale_origin[2]-pmdl->scale[2]*zfact;
			break;
		case SCALE_ORIGIN_BOTTOM:
			tmatrix[0][3] = pmdl->scale_origin[0]-pmdl->scale[0]*xyfact;
			tmatrix[1][3] = pmdl->scale_origin[1]-pmdl->scale[1]*xyfact;
			tmatrix[2][3] = pmdl->scale_origin[2];
			break;
		case SCALE_ORIGIN_TOP:
			tmatrix[0][3] = pmdl->scale_origin[0]-pmdl->scale[0]*xyfact;
			tmatrix[1][3] = pmdl->scale_origin[1]-pmdl->scale[1]*xyfact;
			tmatrix[2][3] = pmdl->scale_origin[2]-pmdl->scale[2]*zfact*2.0;
			break;
		}
	}
	else
	{
		tmatrix[0][0] = pmdl->scale[0];
		tmatrix[1][1] = pmdl->scale[1];
		tmatrix[2][2] = pmdl->scale[2];
		tmatrix[0][3] = pmdl->scale_origin[0];
		tmatrix[1][3] = pmdl->scale_origin[1];
		tmatrix[2][3] = pmdl->scale_origin[2];
	}

	if (currententity->model->flags & EF_ROTATE)
	{
		// Floating motion
		tmatrix[2][3] += sin(currententity->origin[0]
					+ currententity->origin[1]
					+ (cl.time*3)) * 5.5;
	}

// TODO: can do this with simple matrix rearrangement

	for (i = 0 ; i < 3 ; i++)
	{
		t2matrix[i][0] = alias_forward[i];
		t2matrix[i][1] = -alias_right[i];
		t2matrix[i][2] = alias_up[i];
	}

	t2matrix[0][3] = -modelorg[0];
	t2matrix[1][3] = -modelorg[1];
	t2matrix[2][3] = -modelorg[2];

// FIXME: can do more efficiently than full concatenation
	R_ConcatTransforms (t2matrix, tmatrix, rotationmatrix);

// TODO: should be global, set when vright, etc., set
	VectorCopy (vright, viewmatrix[0]);
	VectorCopy (vup, viewmatrix[1]);
	VectorInverse (viewmatrix[1]);
	VectorCopy (vpn, viewmatrix[2]);

//	viewmatrix[0][3] = 0;
//	viewmatrix[1][3] = 0;
//	viewmatrix[2][3] = 0;

	R_ConcatTransforms (viewmatrix, rotationmatrix, aliastransform);

// do the scaling up of x and y to screen coordinates as part of the transform
// for the unclipped case (it would mess up clipping in the clipped case).
// Also scale down z, so 1/z is scaled 31 bits for free, and scale down x and y
// correspondingly so the projected x and y come out right
// FIXME: make this work for clipped case too?
	if (trivial_accept)
	{
		for (i = 0 ; i < 4 ; i++)
		{
			aliastransform[0][i] *= aliasxscale * (1.0 / ((float)0x8000 * 0x10000));
			aliastransform[1][i] *= aliasyscale * (1.0 / ((float)0x8000 * 0x10000));
			aliastransform[2][i] *= 1.0 / ((float)0x8000 * 0x10000);
		}
	}
}


/*
================
R_AliasTransformFinalVert
================
*/
static void R_AliasTransformFinalVert (finalvert_t *fv, auxvert_t *av, trivertx_t *pverts)
{
	int		temp;
	float	lightcos, *plightnormal;

	av->fv[0] = DotProduct(pverts->v, aliastransform[0]) + aliastransform[0][3];
	av->fv[1] = DotProduct(pverts->v, aliastransform[1]) + aliastransform[1][3];
	av->fv[2] = DotProduct(pverts->v, aliastransform[2]) + aliastransform[2][3];

// lighting
	plightnormal = r_avertexnormals[pverts->lightnormalindex];
	lightcos = DotProduct (plightnormal, r_plightvec);
	temp = r_ambientlight;

	if (lightcos < 0)
	{
		temp += (int)(r_shadelight * lightcos);

	// clamp; because we limited the minimum ambient and shading light, we
	// don't have to clamp low light, just bright
		if (temp < 0)
			temp = 0;
	}

	fv->v[4] = temp;
}


#if	!id386

/*
================
R_AliasTransformAndProjectFinalVerts
================
*/
static void R_AliasTransformAndProjectFinalVerts (finalvert_t *fv, stvert_t *pstverts)
{
	int			i, temp;
	float		lightcos, *plightnormal, zi;
	trivertx_t	*pverts;

	pverts = r_apverts;

	for (i = 0 ; i < r_anumverts ; i++, fv++, pverts++, pstverts++)
	{
	// transform and project
		zi = 1.0 / (DotProduct(pverts->v, aliastransform[2]) +
						aliastransform[2][3]);

	// x, y, and z are scaled down by 1/2**31 in the transform, so 1/z is
	// scaled up by 1/2**31, and the scaling cancels out for x and y in the
	// projection
		fv->v[5] = zi;

		fv->v[0] = ((DotProduct(pverts->v, aliastransform[0]) +
				aliastransform[0][3]) * zi) + aliasxcenter;
		fv->v[1] = ((DotProduct(pverts->v, aliastransform[1]) +
				aliastransform[1][3]) * zi) + aliasycenter;

		fv->v[2] = pstverts->s;
		fv->v[3] = pstverts->t;
		fv->flags = pstverts->onseam;

	// lighting
		plightnormal = r_avertexnormals[pverts->lightnormalindex];
		lightcos = DotProduct (plightnormal, r_plightvec);
		temp = r_ambientlight;

		if (lightcos < 0)
		{
			temp += (int)(r_shadelight * lightcos);

		// clamp; because we limited the minimum ambient and shading
		// light, we don't have to clamp low light, just bright
			if (temp < 0)
				temp = 0;
		}

		fv->v[4] = temp;
	}
}

#endif


/*
================
R_AliasProjectFinalVert
================
*/
void R_AliasProjectFinalVert (finalvert_t *fv, auxvert_t *av)
{
	float	zi;

// project points
	zi = 1.0 / av->fv[2];

	fv->v[5] = zi * ziscale;

	fv->v[0] = (av->fv[0] * aliasxscale * zi) + aliasxcenter;
	fv->v[1] = (av->fv[1] * aliasyscale * zi) + aliasycenter;
}


/*
================
R_AliasPrepareUnclippedPoints
================
*/
void R_AliasPrepareUnclippedPoints (void)
{
	stvert_t	*pstverts;
	finalvert_t	*fv;
	mtriangle_t	*ptri;
	int	i;

	pstverts = (stvert_t *)((byte *)paliashdr + paliashdr->stverts);
	r_anumverts = pmdl->numverts;
// FIXME: just use pfinalverts directly?
	fv = pfinalverts;

	R_AliasTransformAndProjectFinalVerts (fv, pstverts);

	r_affinetridesc.pfinalverts = pfinalverts;
	r_affinetridesc.ptriangles = (mtriangle_t *)
					((byte *)paliashdr + paliashdr->triangles);
	r_affinetridesc.numtriangles = 1;//pmdl->numtris;

	ptri = (mtriangle_t *)((byte *)paliashdr + paliashdr->triangles);
	for (i = 0 ; i < pmdl->numtris ; i++, ptri++)
	{
		finalvert_t	*pfv[3];

		pfv[0] = &pfinalverts[ptri->vertindex[0]];
		pfv[1] = &pfinalverts[ptri->vertindex[1]];
		pfv[2] = &pfinalverts[ptri->vertindex[2]];

		//jfm: fill in the triangles s and t into the finalvert
		pfv[0]->v[2] = pstverts[ptri->stindex[0]].s;
		pfv[0]->v[3] = pstverts[ptri->stindex[0]].t;
		pfv[0]->flags = pstverts[ptri->stindex[0]].onseam;

		pfv[1]->v[2] = pstverts[ptri->stindex[1]].s;
		pfv[1]->v[3] = pstverts[ptri->stindex[1]].t;
		pfv[1]->flags = pstverts[ptri->stindex[1]].onseam;

		pfv[2]->v[2] = pstverts[ptri->stindex[2]].s;
		pfv[2]->v[3] = pstverts[ptri->stindex[2]].t;
		pfv[2]->flags = pstverts[ptri->stindex[2]].onseam;

		r_affinetridesc.ptriangles = ptri;

		if (r_affinetridesc.drawtype)
		{
			if ((currententity->model->flags & EF_SPECIAL_TRANS))
			{
				D_PolysetDrawFinalVertsT5 (pfv[0],pfv[1],pfv[2]);
				D_PolysetDrawT5 ();
			}
			else if (currententity->drawflags & DRF_TRANSLUCENT)
			{
				D_PolysetDrawFinalVertsT (pfv[0],pfv[1],pfv[2]);
				D_PolysetDrawT ();
			}
			else if ((currententity->model->flags & EF_TRANSPARENT))
			{
				D_PolysetDrawFinalVertsT2 (pfv[0],pfv[1],pfv[2]);
				D_PolysetDrawT2 ();
			}
			else if ((currententity->model->flags & EF_HOLEY))
			{
				D_PolysetDrawFinalVertsT3 (pfv[0],pfv[1],pfv[2]);
				D_PolysetDrawT3 ();
			}
			else
			{
				D_PolysetDrawFinalVerts (pfv[0],pfv[1],pfv[2]);
				D_PolysetDraw ();
			}
		}
		else
		{
			if ((currententity->model->flags & EF_SPECIAL_TRANS))
				D_PolysetDrawT5 ();
			else if (currententity->drawflags & DRF_TRANSLUCENT)
				D_PolysetDrawT ();
			else if ((currententity->model->flags & EF_TRANSPARENT))
				D_PolysetDrawT2 ();
			else if ((currententity->model->flags & EF_HOLEY))
				D_PolysetDrawT3 ();
			else
				D_PolysetDraw ();
		}
	}
}

/*
===============
R_AliasSetupSkin
===============
*/
static void R_AliasSetupSkin (void)
{
	int			i, numskins, skinnum;
	int			a_skinwidth;
	maliasskingroup_t	*paliasskingroup;
	float			*pskinintervals, fullskininterval;
	float			skintargettime, skintime;
	qpic_t			*stonepic;
	char			temp[40];

	skinnum = currententity->skinnum;
	if (skinnum >= 100)
		skinnum = 0;

	if ((skinnum >= pmdl->numskins) || (skinnum < 0))
	{
		Con_DPrintf ("%s: no such skin # %d\n", __thisfunc__, skinnum);
		skinnum = 0;
	}

	if ( (currententity->model->flags & EF_MIP_MAP) &&
			(currententity->model->flags & EF_MIP_MAP_FAR) &&
			skinnum+1 < pmdl->numskins )
		skinnum++;

	pskindesc = ((maliasskindesc_t *)((byte *)paliashdr + paliashdr->skindesc)) + skinnum;
	a_skinwidth = pmdl->skinwidth;

	if (pskindesc->type == ALIAS_SKIN_GROUP)
	{
		paliasskingroup = (maliasskingroup_t *)((byte *)paliashdr + pskindesc->skin);
		pskinintervals = (float *)((byte *)paliashdr + paliasskingroup->intervals);
		numskins = paliasskingroup->numskins;
		fullskininterval = pskinintervals[numskins-1];

		skintime = cl.time + currententity->syncbase;

	// when loading in Mod_LoadAliasSkinGroup, we guaranteed all interval
	// values are positive, so we don't have to worry about division by 0
		skintargettime = skintime -
				((int)(skintime / fullskininterval)) * fullskininterval;

		for (i = 0 ; i < (numskins-1) ; i++)
		{
			if (pskinintervals[i] > skintargettime)
				break;
		}

		pskindesc = &paliasskingroup->skindescs[i];
	}

	if (currententity->skinnum >= 100)
	{
		sprintf(temp,"gfx/skin%d.lmp",currententity->skinnum);
		stonepic = Draw_CachePic(temp);

		r_affinetridesc.pskindesc = pskindesc;
		r_affinetridesc.pskin = stonepic->data;
		r_affinetridesc.skinwidth = stonepic->width;
		r_affinetridesc.seamfixupX16 =  (stonepic->width >> 1) << 16;
		r_affinetridesc.skinheight = stonepic->height;
	}
	else
	{
		r_affinetridesc.pskindesc = pskindesc;
		r_affinetridesc.pskin = (void *)((byte *)paliashdr + pskindesc->skin);
		r_affinetridesc.skinwidth = a_skinwidth;
		r_affinetridesc.seamfixupX16 =  (a_skinwidth >> 1) << 16;
		r_affinetridesc.skinheight = pmdl->skinheight;
	}

/* rjr how to handle this???
	if (currententity->scoreboard)
	{
		byte	*base;

		if (!currententity->scoreboard->skin)
			Skin_Find (currententity->scoreboard);
		base = Skin_Cache (currententity->scoreboard->skin);
		if (base)
		{
			r_affinetridesc.pskin = base;
			r_affinetridesc.skinwidth = 320;
			r_affinetridesc.skinheight = 200;
		}
	}
*/
}

/*
================
R_AliasSetupLighting
================
*/
static void R_AliasSetupLighting (alight_t *plighting)
{

// guarantee that no vertex will ever be lit below LIGHT_MIN, so we don't have
// to clamp off the bottom
	r_ambientlight = plighting->ambientlight;

	if (r_ambientlight < LIGHT_MIN)
		r_ambientlight = LIGHT_MIN;

	r_ambientlight = (255 - r_ambientlight) << VID_CBITS;

	if (r_ambientlight < LIGHT_MIN)
		r_ambientlight = LIGHT_MIN;

	r_shadelight = plighting->shadelight;

	if (r_shadelight < 0)
		r_shadelight = 0;

	r_shadelight *= VID_GRADES;

// rotate the lighting vector into the model's frame of reference
	r_plightvec[0] = DotProduct (plighting->plightvec, alias_forward);
	r_plightvec[1] = -DotProduct (plighting->plightvec, alias_right);
	r_plightvec[2] = DotProduct (plighting->plightvec, alias_up);
}

/*
=================
R_AliasSetupFrame

set r_apverts
=================
*/
static void R_AliasSetupFrame (void)
{
	int		i, frame, numframes;
	maliasgroup_t	*paliasgroup;
	float		*pintervals, fullinterval, targettime, time;

	frame = currententity->frame;
	if ((frame >= pmdl->numframes) || (frame < 0))
	{
		Con_DPrintf ("%s: no such frame %d %s\n", __thisfunc__, frame, currententity->model->name);
		frame = 0;
	}

	if (paliashdr->frames[frame].type == ALIAS_SINGLE)
	{
		r_apverts = (trivertx_t *)
				((byte *)paliashdr + paliashdr->frames[frame].frame);
		return;
	}

	paliasgroup = (maliasgroup_t *)
				((byte *)paliashdr + paliashdr->frames[frame].frame);
	pintervals = (float *)((byte *)paliashdr + paliasgroup->intervals);
	numframes = paliasgroup->numframes;
	fullinterval = pintervals[numframes-1];

	time = cl.time + currententity->syncbase;

//
// when loading in Mod_LoadAliasGroup, we guaranteed all interval values
// are positive, so we don't have to worry about division by 0
//
	targettime = time - ((int)(time / fullinterval)) * fullinterval;

	for (i = 0 ; i < (numframes-1) ; i++)
	{
		if (pintervals[i] > targettime)
			break;
	}

	r_apverts = (trivertx_t *)
			((byte *)paliashdr + paliasgroup->frames[i].frame);
}


/*
================
R_AliasDrawModel
================
*/
void R_AliasDrawModel (alight_t *plighting)
{
	int		mls;
	int		i, j;
	byte		*dest, *source, *sourceA;
	auxvert_t	auxverts[MAXALIASVERTS];
	finalvert_t	finalverts[MAXALIASVERTS + ((CACHE_SIZE - 1) / sizeof(finalvert_t)) + 1];
	char		client_team[16], this_team[16];
//	qboolean	OnTeam = false;
	byte		ColorShade, *ColorMap, *OldColorMap;

	r_amodels_drawn++;

// cache align
	pfinalverts = (finalvert_t *)
			(((intptr_t)&finalverts[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
	pauxverts = &auxverts[0];

	paliashdr = (aliashdr_t *)Mod_Extradata (currententity->model);
	pmdl = (newmdl_t *)((byte *)paliashdr + paliashdr->model);

	R_AliasSetupSkin ();
	R_AliasSetUpTransform (currententity->trivial_accept);

	mls = currententity->drawflags & MLS_MASKIN;
	if (currententity->model->flags & EF_ROTATE)
	{
		plighting->ambientlight =
		plighting->shadelight =
			60 + 34 + sin(currententity->origin[0] + currententity->origin[1] + (cl.time*3.8))*34;
		R_AliasSetupLighting (plighting);
		r_plightvec[0] = r_plightvec[1] = r_plightvec[2] = 0;
	}
	else if (mls == MLS_ABSLIGHT)
	{
		plighting->ambientlight =
		plighting->shadelight =
					currententity->abslight;
		R_AliasSetupLighting (plighting);
		r_plightvec[0] = r_plightvec[1] = r_plightvec[2] = 0;
	}
	else if (mls != MLS_NONE)
	{
		// Use a model light style (25-30)
		plighting->ambientlight =
		plighting->shadelight =
					d_lightstylevalue[24+mls]/2;
		R_AliasSetupLighting (plighting);
	}
	else
		R_AliasSetupLighting (plighting);

	R_AliasSetupFrame ();

	if (!currententity->colormap)
		Sys_Error ("%s: !currententity->colormap", __thisfunc__);

	r_affinetridesc.drawtype =
		(currententity->trivial_accept == 3) && r_recursiveaffinetriangles;

	ColorShade = currententity->colorshade;
	ColorMap = currententity->sourcecolormap;
	OldColorMap = currententity->colormap;

	i = currententity->scoreboard - cl.players;
	if (i >= 0 && i < MAX_CLIENTS)
	{
		if (plighting->ambientlight + plighting->shadelight > 75 ||
				(cl_siege && cl.players[cl.playernum].siege_team == cl.players[i].siege_team))
			cl.players[i].shownames_off = false;
		else
			cl.players[i].shownames_off = true;

		if (cl_siege &&
				cl.players[cl.playernum].playerclass == CLASS_DWARF &&
				currententity->skinnum == 101)
		{	//invisible player to dwarf
		//	OnTeam = true;
			ColorShade = 141;
			cl.players[i].shownames_off = false;
		}
		else if (cl_siege &&
				cl.players[cl.playernum].playerclass == CLASS_DWARF &&
				plighting->ambientlight + plighting->shadelight < 151)
		{
		//	OnTeam = true;
			ColorShade = 138 + (int)((plighting->ambientlight + plighting->shadelight) / 30);
			if (currententity->sourcecolormap)
				ColorMap = currententity->sourcecolormap;
			else
				ColorMap = vid.colormap;

			currententity->colormap = globalcolormap;
			cl.players[i].shownames_off = false;
		}
		else
		{
			q_strlcpy (client_team, Info_ValueForKey(cl.players[cl.playernum].userinfo, "team"), sizeof(client_team));
			if (client_team[0])
			{
				q_strlcpy (this_team, Info_ValueForKey(cl.players[i].userinfo, "team"), sizeof(this_team));
				if (q_strcasecmp(client_team, this_team) == 0)
				{
				//	OnTeam = true;
					ColorShade = r_teamcolor.value;
					if (currententity->sourcecolormap)
						ColorMap = currententity->sourcecolormap;
					else
						ColorMap = vid.colormap;

					currententity->colormap = globalcolormap;
				}
			}
		}
	}

	acolormap = currententity->colormap;

	if (r_affinetridesc.drawtype)
	{
		D_PolysetUpdateTables ();	// FIXME: precalc...
	}
	else
	{
#if	id386
		if (currententity->model->flags & EF_SPECIAL_TRANS)
			D_Aff8PatchT5 (currententity->colormap);
		else if (currententity->drawflags & DRF_TRANSLUCENT)
			D_Aff8PatchT (currententity->colormap);
		else if (currententity->model->flags & EF_TRANSPARENT)
			D_Aff8PatchT2 (currententity->colormap);
		else if (currententity->model->flags & EF_HOLEY)
			D_Aff8PatchT3 (currententity->colormap);
		else
			D_Aff8Patch (currententity->colormap);
#endif
	}

	if ( ColorShade &&
		(ColorShade != lastglobalcolor ||
		 ColorMap != lastsourcecolormap))
	{
		lastglobalcolor = ColorShade;
		lastsourcecolormap = ColorMap;

		dest = globalcolormap;
		source = ColorMap;
		sourceA = transTable + (((int)lastglobalcolor)*256);

		for (i = 0 ; i < VID_GRADES ; i++)
		{
			for (j = 0 ; j < 256 ; j++, dest++, source++)
			{
				*dest = sourceA[*source];
			}
		}
	}

	if (currententity != &cl.viewent)
		ziscale = (float)0x8000 * (float)0x10000;
	else
		ziscale = (float)0x8000 * (float)0x10000 * 3.0;

	if (currententity->trivial_accept)
		R_AliasPrepareUnclippedPoints ();
	else
		R_AliasPreparePoints ();

	currententity->colormap = OldColorMap;
}

