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.

*/

// r_alias.c: routines for setting up to draw alias models

#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

mdl_t				*pmdl;

vec3_t				r_plightvec;

int					r_ambientlight;

float				r_shadelight;

aliashdr_t			*paliashdr;

finalvert_t			*pfinalverts;

auxvert_t			*pauxverts;

static float		ziscale;

static model_t		*pmodel;

static vec3_t		alias_forward, alias_right, alias_up;

static maliasskindesc_t	*pskindesc;

int				r_amodels_drawn;

int				a_skinwidth;

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"

};

void R_AliasTransformAndProjectFinalVerts (finalvert_t *fv,

	stvert_t *pstverts);

void R_AliasSetUpTransform (int trivial_accept);

void R_AliasTransformVector (vec3_t in, vec3_t out);

void R_AliasTransformFinalVert (finalvert_t *fv, auxvert_t *av,

	trivertx_t *pverts, stvert_t *pstverts);

void R_AliasProjectFinalVert (finalvert_t *fv, auxvert_t *av);

/*

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

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			anyclip, allclip;

	int					minz;

// expand, rotate, and translate points into worldspace

	currententity->trivial_accept = 0;

	pmodel = currententity->model;

	pahdr = Mod_Extradata (pmodel);

	pmdl = (mdl_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

	{

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

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

*/

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

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

*/

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_AliasTransformFinalVert (fv, av, r_apverts, pstverts);

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

		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;

			D_PolysetDraw ();

		}

		else

		{	// partially clipped

			R_AliasClipTriangle (ptri);

		}

	}

}

/*

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

R_AliasSetUpTransform

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

*/

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;

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

	angles[ROLL] = currententity->angles[ROLL];

	angles[PITCH] = -currententity->angles[PITCH];

	angles[YAW] = currententity->angles[YAW];

	AngleVectors (angles, alias_forward, alias_right, alias_up);

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

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

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

*/

void R_AliasTransformFinalVert (finalvert_t *fv, auxvert_t *av,

	trivertx_t *pverts, stvert_t *pstverts)

{

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

	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;

}

#if	!id386

/*

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

R_AliasTransformAndProjectFinalVerts

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

*/

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

	{

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

	pstverts = (stvert_t *)((byte *)paliashdr + paliashdr->stverts);

	r_anumverts = pmdl->numverts;

// FIXME: just use pfinalverts directly?

	fv = pfinalverts;

	R_AliasTransformAndProjectFinalVerts (fv, pstverts);

	if (r_affinetridesc.drawtype)

		D_PolysetDrawFinalVerts (fv, r_anumverts);

	r_affinetridesc.pfinalverts = pfinalverts;

	r_affinetridesc.ptriangles = (mtriangle_t *)

			((byte *)paliashdr + paliashdr->triangles);

	r_affinetridesc.numtriangles = pmdl->numtris;

	D_PolysetDraw ();

}

/*

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

R_AliasSetupSkin

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

*/

void R_AliasSetupSkin (void)

{

	int					skinnum;

	int					i, numskins;

	maliasskingroup_t	*paliasskingroup;

	float				*pskinintervals, fullskininterval;

	float				skintargettime, skintime;

	skinnum = currententity->skinnum;

	if ((skinnum >= pmdl->numskins) || (skinnum < 0))

	{

		Con_DPrintf ("R_AliasSetupSkin: no such skin # %d\n", skinnum);

		skinnum = 0;

	}

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

	}

	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;

}

/*

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

R_AliasSetupLighting

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

*/

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

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

*/

void R_AliasSetupFrame (void)

{

	int				frame;

	int				i, numframes;

	maliasgroup_t	*paliasgroup;

	float			*pintervals, fullinterval, targettime, time;

	frame = currententity->frame;

	if ((frame >= pmdl->numframes) || (frame < 0))

	{

		Con_DPrintf ("R_AliasSetupFrame: no such frame %d\n", frame);

		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)

{

	finalvert_t		finalverts[MAXALIASVERTS +

						((CACHE_SIZE - 1) / sizeof(finalvert_t)) + 1];

	auxvert_t		auxverts[MAXALIASVERTS];

	r_amodels_drawn++;

// cache align

	pfinalverts = (finalvert_t *)

			(((long)&finalverts[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));

	pauxverts = &auxverts[0];

	paliashdr = (aliashdr_t *)Mod_Extradata (currententity->model);

	pmdl = (mdl_t *)((byte *)paliashdr + paliashdr->model);

	R_AliasSetupSkin ();

	R_AliasSetUpTransform (currententity->trivial_accept);

	R_AliasSetupLighting (plighting);

	R_AliasSetupFrame ();

	if (!currententity->colormap)

		Sys_Error ("R_AliasDrawModel: !currententity->colormap");

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

			r_recursiveaffinetriangles;

	if (r_affinetridesc.drawtype)

	{

		D_PolysetUpdateTables ();		// FIXME: precalc...

	}

	else

	{

#if	id386

		D_Aff8Patch (currententity->colormap);

#endif

	}

	acolormap = currententity->colormap;

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

}