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

#include "quakedef.h"

#include "r_local.h"

static int				clip_current;

static vec5_t			clip_verts[2][MAXWORKINGVERTS];

static int				sprite_width, sprite_height;

spritedesc_t			r_spritedesc;

/*

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

R_RotateSprite

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

*/

void R_RotateSprite (float beamlength)

{

	vec3_t	vec;

	if (beamlength == 0.0)

		return;

	VectorScale (r_spritedesc.vpn, -beamlength, vec);

	VectorAdd (r_entorigin, vec, r_entorigin);

	VectorSubtract (modelorg, vec, modelorg);

}

/*

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

R_ClipSpriteFace

Clips the winding at clip_verts[clip_current] and changes clip_current

Throws out the back side

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

*/

int R_ClipSpriteFace (int nump, clipplane_t *pclipplane)

{

	int		i, outcount;

	float	dists[MAXWORKINGVERTS+1];

	float	frac, clipdist, *pclipnormal;

	float	*in, *instep, *outstep, *vert2;

	clipdist = pclipplane->dist;

	pclipnormal = pclipplane->normal;

// calc dists

	if (clip_current)

	{

		in = clip_verts[1][0];

		outstep = clip_verts[0][0];

		clip_current = 0;

	}

	else

	{

		in = clip_verts[0][0];

		outstep = clip_verts[1][0];

		clip_current = 1;

	}

	instep = in;

	for (i=0 ; i

	{

		dists[i] = DotProduct (instep, pclipnormal) - clipdist;

	}

// handle wraparound case

	dists[nump] = dists[0];

	Q_memcpy (instep, in, sizeof (vec5_t));

// clip the winding

	instep = in;

	outcount = 0;

	for (i=0 ; i

	{

		if (dists[i] >= 0)

		{

			Q_memcpy (outstep, instep, sizeof (vec5_t));

			outstep += sizeof (vec5_t) / sizeof (float);

			outcount++;

		}

		if (dists[i] == 0 || dists[i+1] == 0)

			continue;

		if ( (dists[i] > 0) == (dists[i+1] > 0) )

			continue;

	// split it into a new vertex

		frac = dists[i] / (dists[i] - dists[i+1]);

		vert2 = instep + sizeof (vec5_t) / sizeof (float);

		outstep[0] = instep[0] + frac*(vert2[0] - instep[0]);

		outstep[1] = instep[1] + frac*(vert2[1] - instep[1]);

		outstep[2] = instep[2] + frac*(vert2[2] - instep[2]);

		outstep[3] = instep[3] + frac*(vert2[3] - instep[3]);

		outstep[4] = instep[4] + frac*(vert2[4] - instep[4]);

		outstep += sizeof (vec5_t) / sizeof (float);

		outcount++;

	}

	return outcount;

}

/*

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

R_SetupAndDrawSprite

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

*/

void R_SetupAndDrawSprite ()

{

	int			i, nump;

	float		dot, scale, *pv;

	vec5_t		*pverts;

	vec3_t		left, up, right, down, transformed, local;

	emitpoint_t	outverts[MAXWORKINGVERTS+1], *pout;

	dot = DotProduct (r_spritedesc.vpn, modelorg);

// backface cull

	if (dot >= 0)

		return;

// build the sprite poster in worldspace

	VectorScale (r_spritedesc.vright, r_spritedesc.pspriteframe->right, right);

	VectorScale (r_spritedesc.vup, r_spritedesc.pspriteframe->up, up);

	VectorScale (r_spritedesc.vright, r_spritedesc.pspriteframe->left, left);

	VectorScale (r_spritedesc.vup, r_spritedesc.pspriteframe->down, down);

	pverts = clip_verts[0];

	pverts[0][0] = r_entorigin[0] + up[0] + left[0];

	pverts[0][1] = r_entorigin[1] + up[1] + left[1];

	pverts[0][2] = r_entorigin[2] + up[2] + left[2];

	pverts[0][3] = 0;

	pverts[0][4] = 0;

	pverts[1][0] = r_entorigin[0] + up[0] + right[0];

	pverts[1][1] = r_entorigin[1] + up[1] + right[1];

	pverts[1][2] = r_entorigin[2] + up[2] + right[2];

	pverts[1][3] = sprite_width;

	pverts[1][4] = 0;

	pverts[2][0] = r_entorigin[0] + down[0] + right[0];

	pverts[2][1] = r_entorigin[1] + down[1] + right[1];

	pverts[2][2] = r_entorigin[2] + down[2] + right[2];

	pverts[2][3] = sprite_width;

	pverts[2][4] = sprite_height;

	pverts[3][0] = r_entorigin[0] + down[0] + left[0];

	pverts[3][1] = r_entorigin[1] + down[1] + left[1];

	pverts[3][2] = r_entorigin[2] + down[2] + left[2];

	pverts[3][3] = 0;

	pverts[3][4] = sprite_height;

// clip to the frustum in worldspace

	nump = 4;

	clip_current = 0;

	for (i=0 ; i<4 ; i++)

	{

		nump = R_ClipSpriteFace (nump, &view_clipplanes[i]);

		if (nump < 3)

			return;

		if (nump >= MAXWORKINGVERTS)

			Sys_Error("R_SetupAndDrawSprite: too many points");

	}

// transform vertices into viewspace and project

	pv = &clip_verts[clip_current][0][0];

	r_spritedesc.nearzi = -999999;

	for (i=0 ; i

	{

		VectorSubtract (pv, r_origin, local);

		TransformVector (local, transformed);

		if (transformed[2] < NEAR_CLIP)

			transformed[2] = NEAR_CLIP;

		pout = &outverts[i];

		pout->zi = 1.0 / transformed[2];

		if (pout->zi > r_spritedesc.nearzi)

			r_spritedesc.nearzi = pout->zi;

		pout->s = pv[3];

		pout->t = pv[4];

		scale = xscale * pout->zi;

		pout->u = (xcenter + scale * transformed[0]);

		scale = yscale * pout->zi;

		pout->v = (ycenter - scale * transformed[1]);

		pv += sizeof (vec5_t) / sizeof (*pv);

	}

// draw it

	r_spritedesc.nump = nump;

	r_spritedesc.pverts = outverts;

	D_DrawSprite ();

}

/*

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

R_GetSpriteframe

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

*/

mspriteframe_t *R_GetSpriteframe (msprite_t *psprite)

{

	mspritegroup_t	*pspritegroup;

	mspriteframe_t	*pspriteframe;

	int				i, numframes, frame;

	float			*pintervals, fullinterval, targettime, time;

	frame = currententity->frame;

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

	{

		Con_Printf ("R_DrawSprite: no such frame %d\n", frame);

		frame = 0;

	}

	if (psprite->frames[frame].type == SPR_SINGLE)

	{

		pspriteframe = psprite->frames[frame].frameptr;

	}

	else

	{

		pspritegroup = (mspritegroup_t *)psprite->frames[frame].frameptr;

		pintervals = pspritegroup->intervals;

		numframes = pspritegroup->numframes;

		fullinterval = pintervals[numframes-1];

		time = cl.time + currententity->syncbase;

	// when loading in Mod_LoadSpriteGroup, 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;

		}

		pspriteframe = pspritegroup->frames[i];

	}

	return pspriteframe;

}

/*

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

R_DrawSprite

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

*/

void R_DrawSprite (void)

{

	int				i;

	msprite_t		*psprite;

	vec3_t			tvec;

	float			dot, angle, sr, cr;

	psprite = currententity->model->cache.data;

	r_spritedesc.pspriteframe = R_GetSpriteframe (psprite);

	sprite_width = r_spritedesc.pspriteframe->width;

	sprite_height = r_spritedesc.pspriteframe->height;

// TODO: make this caller-selectable

	if (psprite->type == SPR_FACING_UPRIGHT)

	{

	// generate the sprite's axes, with vup straight up in worldspace, and

	// r_spritedesc.vright perpendicular to modelorg.

	// This will not work if the view direction is very close to straight up or

	// down, because the cross product will be between two nearly parallel

	// vectors and starts to approach an undefined state, so we don't draw if

	// the two vectors are less than 1 degree apart

		tvec[0] = -modelorg[0];

		tvec[1] = -modelorg[1];

		tvec[2] = -modelorg[2];

		VectorNormalize (tvec);

		dot = tvec[2];	// same as DotProduct (tvec, r_spritedesc.vup) because

						//  r_spritedesc.vup is 0, 0, 1

		if ((dot > 0.999848) || (dot < -0.999848))	// cos(1 degree) = 0.999848

			return;

		r_spritedesc.vup[0] = 0;

		r_spritedesc.vup[1] = 0;

		r_spritedesc.vup[2] = 1;

		r_spritedesc.vright[0] = tvec[1];

								// CrossProduct(r_spritedesc.vup, -modelorg,

		r_spritedesc.vright[1] = -tvec[0];

								//              r_spritedesc.vright)

		r_spritedesc.vright[2] = 0;

		VectorNormalize (r_spritedesc.vright);

		r_spritedesc.vpn[0] = -r_spritedesc.vright[1];

		r_spritedesc.vpn[1] = r_spritedesc.vright[0];

		r_spritedesc.vpn[2] = 0;

					// CrossProduct (r_spritedesc.vright, r_spritedesc.vup,

					//  r_spritedesc.vpn)

	}

	else if (psprite->type == SPR_VP_PARALLEL)

	{

	// generate the sprite's axes, completely parallel to the viewplane. There

	// are no problem situations, because the sprite is always in the same

	// position relative to the viewer

		for (i=0 ; i<3 ; i++)

		{

			r_spritedesc.vup[i] = vup[i];

			r_spritedesc.vright[i] = vright[i];

			r_spritedesc.vpn[i] = vpn[i];

		}

	}

	else if (psprite->type == SPR_VP_PARALLEL_UPRIGHT)

	{

	// generate the sprite's axes, with vup straight up in worldspace, and

	// r_spritedesc.vright parallel to the viewplane.

	// This will not work if the view direction is very close to straight up or

	// down, because the cross product will be between two nearly parallel

	// vectors and starts to approach an undefined state, so we don't draw if

	// the two vectors are less than 1 degree apart

		dot = vpn[2];	// same as DotProduct (vpn, r_spritedesc.vup) because

						//  r_spritedesc.vup is 0, 0, 1

		if ((dot > 0.999848) || (dot < -0.999848))	// cos(1 degree) = 0.999848

			return;

		r_spritedesc.vup[0] = 0;

		r_spritedesc.vup[1] = 0;

		r_spritedesc.vup[2] = 1;

		r_spritedesc.vright[0] = vpn[1];

										// CrossProduct (r_spritedesc.vup, vpn,

		r_spritedesc.vright[1] = -vpn[0];	//  r_spritedesc.vright)

		r_spritedesc.vright[2] = 0;

		VectorNormalize (r_spritedesc.vright);

		r_spritedesc.vpn[0] = -r_spritedesc.vright[1];

		r_spritedesc.vpn[1] = r_spritedesc.vright[0];

		r_spritedesc.vpn[2] = 0;

					// CrossProduct (r_spritedesc.vright, r_spritedesc.vup,

					//  r_spritedesc.vpn)

	}

	else if (psprite->type == SPR_ORIENTED)

	{

	// generate the sprite's axes, according to the sprite's world orientation

		AngleVectors (currententity->angles, r_spritedesc.vpn,

					  r_spritedesc.vright, r_spritedesc.vup);

	}

	else if (psprite->type == SPR_VP_PARALLEL_ORIENTED)

	{

	// generate the sprite's axes, parallel to the viewplane, but rotated in

	// that plane around the center according to the sprite entity's roll

	// angle. So vpn stays the same, but vright and vup rotate

		angle = currententity->angles[ROLL] * (M_PI*2 / 360);

		sr = sin(angle);

		cr = cos(angle);

		for (i=0 ; i<3 ; i++)

		{

			r_spritedesc.vpn[i] = vpn[i];

			r_spritedesc.vright[i] = vright[i] * cr + vup[i] * sr;

			r_spritedesc.vup[i] = vright[i] * -sr + vup[i] * cr;

		}

	}

	else

	{

		Sys_Error ("R_DrawSprite: Bad sprite type %d", psprite->type);

	}

	R_RotateSprite (psprite->beamlength);

	R_SetupAndDrawSprite ();

}