mirror of
https://git.code.sf.net/p/quake/quakeforge-old
synced 2024-11-14 08:20:57 +00:00
c3f5581b0a
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.
753 lines
18 KiB
C
753 lines
18 KiB
C
/*
|
|
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<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
|
|
================
|
|
*/
|
|
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_anumverts ; i++, fv++, av++, r_apverts++, pstverts++)
|
|
{
|
|
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 ; 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
|
|
|
|
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<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;
|
|
|
|
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 ();
|
|
}
|
|
|