Created new subdir: uquake. Pick your favorite U word for the meaning --
Unchained, Ultimate, Ultra, Up Yours, Underworld, Underground, Unified,
Unity, etc. You know the drill.
This takes care of the "standalone" problem with the wrong name, and the
recent snafu with multiple developers working on the same files
simultaneously...expect me (and probably others) to start locking dirs when
updates are taking place.
And yes, this update is really as large as it looks. Software only at the
moment, but I will have the makefile updated to build the GL builds as
well.
1999-12-26 13:51:52 +00:00
|
|
|
/*
|
|
|
|
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"
|
2000-01-29 18:46:26 +00:00
|
|
|
#include <mathlib.h>
|
|
|
|
#include <lib_replace.h>
|
|
|
|
#include <console.h>
|
|
|
|
#include <sys.h>
|
Created new subdir: uquake. Pick your favorite U word for the meaning --
Unchained, Ultimate, Ultra, Up Yours, Underworld, Underground, Unified,
Unity, etc. You know the drill.
This takes care of the "standalone" problem with the wrong name, and the
recent snafu with multiple developers working on the same files
simultaneously...expect me (and probably others) to start locking dirs when
updates are taking place.
And yes, this update is really as large as it looks. Software only at the
moment, but I will have the makefile updated to build the GL builds as
well.
1999-12-26 13:51:52 +00:00
|
|
|
|
|
|
|
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<nump ; i++, instep += sizeof (vec5_t) / sizeof (float))
|
|
|
|
{
|
|
|
|
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<nump ; i++, instep += sizeof (vec5_t) / sizeof (float))
|
|
|
|
{
|
|
|
|
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<nump ; 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 ();
|
|
|
|
}
|
|
|
|
|