/* | |
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 (); | |
} | |