2001-08-25 02:47:11 +00:00
|
|
|
/*
|
|
|
|
sw32_ralias.c
|
|
|
|
|
|
|
|
routines for setting up to draw alias models
|
|
|
|
|
|
|
|
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:
|
|
|
|
|
|
|
|
Free Software Foundation, Inc.
|
|
|
|
59 Temple Place - Suite 330
|
|
|
|
Boston, MA 02111-1307, USA
|
|
|
|
|
|
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
2021-07-10 15:09:41 +00:00
|
|
|
#include <stdlib.h>
|
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
#define NH_DEFINE
|
|
|
|
#include "namehack.h"
|
2003-01-15 15:31:36 +00:00
|
|
|
|
2003-09-04 18:59:39 +00:00
|
|
|
#include "QF/image.h"
|
2001-08-25 02:47:11 +00:00
|
|
|
#include "QF/render.h"
|
|
|
|
#include "QF/skin.h"
|
|
|
|
#include "QF/sys.h"
|
|
|
|
|
2021-07-24 05:19:52 +00:00
|
|
|
#include "QF/scene/entity.h"
|
|
|
|
|
2001-08-25 02:47:11 +00:00
|
|
|
#include "d_ifacea.h"
|
2012-02-14 08:28:09 +00:00
|
|
|
#include "r_internal.h"
|
2021-07-10 15:09:41 +00:00
|
|
|
#include "vid_sw.h"
|
2002-01-05 17:56:33 +00:00
|
|
|
|
2001-08-28 22:46:02 +00:00
|
|
|
#define LIGHT_MIN 5 // lowest light value we'll allow, to
|
2001-08-25 02:47:11 +00:00
|
|
|
// avoid the need for inner-loop light
|
|
|
|
// clamping
|
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
affinetridesc_t sw32_r_affinetridesc;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
void *sw32_acolormap; // FIXME: should go away
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
trivertx_t *sw32_r_apverts;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
// TODO: these probably will go away with optimized rasterization
|
2012-02-18 05:34:14 +00:00
|
|
|
static mdl_t *pmdl;
|
2012-02-22 07:32:34 +00:00
|
|
|
vec3_t sw32_r_plightvec;
|
|
|
|
int sw32_r_ambientlight;
|
|
|
|
float sw32_r_shadelight;
|
2012-02-18 05:34:14 +00:00
|
|
|
static aliashdr_t *paliashdr;
|
2012-02-22 07:32:34 +00:00
|
|
|
finalvert_t *sw32_pfinalverts;
|
|
|
|
auxvert_t *sw32_pauxverts;
|
2012-05-20 05:23:41 +00:00
|
|
|
float sw32_ziscale;
|
2001-08-25 02:47:11 +00:00
|
|
|
static model_t *pmodel;
|
|
|
|
|
|
|
|
static vec3_t alias_forward, alias_right, alias_up;
|
|
|
|
|
|
|
|
static maliasskindesc_t *pskindesc;
|
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
int sw32_r_amodels_drawn;
|
2012-02-21 05:10:20 +00:00
|
|
|
static int a_skinwidth;
|
2012-02-18 05:34:14 +00:00
|
|
|
static int r_anumverts;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2012-07-14 22:30:17 +00:00
|
|
|
float sw32_aliastransform[3][4];
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
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}
|
|
|
|
};
|
|
|
|
|
|
|
|
qboolean
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_R_AliasCheckBBox (void)
|
2001-08-25 02:47:11 +00:00
|
|
|
{
|
|
|
|
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 int anyclip, allclip;
|
|
|
|
int minz;
|
|
|
|
|
|
|
|
// expand, rotate, and translate points into worldspace
|
2021-03-09 14:52:40 +00:00
|
|
|
currententity->visibility.trivial_accept = 0;
|
|
|
|
pmodel = currententity->renderer.model;
|
2012-01-17 02:44:28 +00:00
|
|
|
if (!(pahdr = pmodel->aliashdr))
|
|
|
|
pahdr = Cache_Get (&pmodel->cache);
|
2001-08-25 02:47:11 +00:00
|
|
|
pmdl = (mdl_t *) ((byte *) pahdr + pahdr->model);
|
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_R_AliasSetUpTransform (0);
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
// construct the base bounding box for this frame
|
2021-03-09 14:52:40 +00:00
|
|
|
frame = currententity->animation.frame;
|
2001-08-25 02:47:11 +00:00
|
|
|
// TODO: don't repeat this check when drawing?
|
|
|
|
if ((frame >= pmdl->numframes) || (frame < 0)) {
|
2021-03-29 10:58:00 +00:00
|
|
|
Sys_MaskPrintf (SYS_dev, "No such frame %d %s\n", frame, pmodel->path);
|
2001-08-25 02:47:11 +00:00
|
|
|
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++) {
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_R_AliasTransformVector (&basepts[i][0], &viewaux[i].fv[0]);
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
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) {
|
2012-01-17 02:44:28 +00:00
|
|
|
if (!pmodel->aliashdr)
|
|
|
|
Cache_Release (&pmodel->cache);
|
2001-08-25 02:47:11 +00:00
|
|
|
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
|
2012-02-22 07:32:34 +00:00
|
|
|
v0 = (viewaux[i].fv[0] * sw32_xscale * zi) + sw32_xcenter;
|
|
|
|
v1 = (viewaux[i].fv[1] * sw32_yscale * zi) + sw32_ycenter;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2001-08-31 12:22:45 +00:00
|
|
|
if (allclip) {
|
2012-01-17 02:44:28 +00:00
|
|
|
if (!pmodel->aliashdr)
|
|
|
|
Cache_Release (&pmodel->cache);
|
2001-08-25 02:47:11 +00:00
|
|
|
return false; // trivial reject off one side
|
2001-08-31 12:22:45 +00:00
|
|
|
}
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2021-03-09 14:52:40 +00:00
|
|
|
currententity->visibility.trivial_accept = !anyclip & !zclipped;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2021-03-09 14:52:40 +00:00
|
|
|
if (currententity->visibility.trivial_accept) {
|
2012-02-22 07:32:34 +00:00
|
|
|
if (minz > (sw32_r_aliastransition + (pmdl->size * sw32_r_resfudge))) {
|
2021-03-09 14:52:40 +00:00
|
|
|
currententity->visibility.trivial_accept |= 2;
|
2001-08-25 02:47:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-17 02:44:28 +00:00
|
|
|
if (!pmodel->aliashdr)
|
|
|
|
Cache_Release (&pmodel->cache);
|
2001-08-25 02:47:11 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2001-08-28 22:46:02 +00:00
|
|
|
|
2001-08-25 02:47:11 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_R_AliasTransformVector (vec3_t in, vec3_t out)
|
2001-08-25 02:47:11 +00:00
|
|
|
{
|
2012-05-18 14:31:14 +00:00
|
|
|
out[0] = DotProduct (in, sw32_aliastransform[0])
|
|
|
|
+ sw32_aliastransform[0][3];
|
|
|
|
out[1] = DotProduct (in, sw32_aliastransform[1])
|
|
|
|
+ sw32_aliastransform[1][3];
|
|
|
|
out[2] = DotProduct (in, sw32_aliastransform[2])
|
|
|
|
+ sw32_aliastransform[2][3];
|
2001-08-25 02:47:11 +00:00
|
|
|
}
|
|
|
|
|
2001-08-28 22:46:02 +00:00
|
|
|
|
2012-05-18 14:31:14 +00:00
|
|
|
void
|
|
|
|
sw32_R_AliasClipAndProjectFinalVert (finalvert_t *fv, auxvert_t *av)
|
2002-01-05 20:00:50 +00:00
|
|
|
{
|
|
|
|
if (av->fv[2] < ALIAS_Z_CLIP_PLANE) {
|
|
|
|
fv->flags |= ALIAS_Z_CLIP;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_R_AliasProjectFinalVert (fv, av);
|
2002-01-05 20:00:50 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2003-01-06 18:28:13 +00:00
|
|
|
static void
|
2012-05-17 12:33:22 +00:00
|
|
|
R_AliasTransformFinalVert16 (auxvert_t *av, trivertx_t *pverts)
|
2002-01-05 20:00:50 +00:00
|
|
|
{
|
|
|
|
trivertx_t * pextra;
|
|
|
|
float vextra[3];
|
|
|
|
|
|
|
|
pextra = pverts + pmdl->numverts;
|
|
|
|
vextra[0] = pverts->v[0] + pextra->v[0] / (float)256;
|
|
|
|
vextra[1] = pverts->v[1] + pextra->v[1] / (float)256;
|
|
|
|
vextra[2] = pverts->v[2] + pextra->v[2] / (float)256;
|
2012-05-18 14:31:14 +00:00
|
|
|
av->fv[0] = DotProduct (vextra, sw32_aliastransform[0]) +
|
|
|
|
sw32_aliastransform[0][3];
|
|
|
|
av->fv[1] = DotProduct (vextra, sw32_aliastransform[1]) +
|
|
|
|
sw32_aliastransform[1][3];
|
|
|
|
av->fv[2] = DotProduct (vextra, sw32_aliastransform[2]) +
|
|
|
|
sw32_aliastransform[2][3];
|
2002-01-05 20:00:50 +00:00
|
|
|
}
|
|
|
|
|
2003-01-06 18:28:13 +00:00
|
|
|
static void
|
2012-05-17 12:33:22 +00:00
|
|
|
R_AliasTransformFinalVert8 (auxvert_t *av, trivertx_t *pverts)
|
2002-01-05 20:00:50 +00:00
|
|
|
{
|
2012-05-18 14:31:14 +00:00
|
|
|
av->fv[0] = DotProduct (pverts->v, sw32_aliastransform[0]) +
|
|
|
|
sw32_aliastransform[0][3];
|
|
|
|
av->fv[1] = DotProduct (pverts->v, sw32_aliastransform[1]) +
|
|
|
|
sw32_aliastransform[1][3];
|
|
|
|
av->fv[2] = DotProduct (pverts->v, sw32_aliastransform[2]) +
|
|
|
|
sw32_aliastransform[2][3];
|
2002-01-05 20:00:50 +00:00
|
|
|
}
|
|
|
|
|
2001-08-25 02:47:11 +00:00
|
|
|
/*
|
|
|
|
R_AliasPreparePoints
|
|
|
|
|
|
|
|
General clipped case
|
|
|
|
*/
|
2003-01-06 18:28:13 +00:00
|
|
|
static void
|
2001-08-25 02:47:11 +00:00
|
|
|
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;
|
2012-02-22 07:32:34 +00:00
|
|
|
av = sw32_pauxverts;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2004-02-08 02:49:38 +00:00
|
|
|
if (pmdl->ident == HEADER_MDL16) {
|
2012-02-22 07:32:34 +00:00
|
|
|
for (i = 0; i < r_anumverts; i++, fv++, av++, sw32_r_apverts++,
|
2002-01-05 20:00:50 +00:00
|
|
|
pstverts++) {
|
2012-05-17 12:33:22 +00:00
|
|
|
R_AliasTransformFinalVert16 (av, sw32_r_apverts);
|
|
|
|
sw32_R_AliasTransformFinalVert (fv, sw32_r_apverts, pstverts);
|
2002-01-05 20:00:50 +00:00
|
|
|
R_AliasClipAndProjectFinalVert (fv, av);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2012-02-22 07:32:34 +00:00
|
|
|
for (i = 0; i < r_anumverts; i++, fv++, av++, sw32_r_apverts++,
|
2002-01-05 20:00:50 +00:00
|
|
|
pstverts++) {
|
2012-05-17 12:33:22 +00:00
|
|
|
R_AliasTransformFinalVert8 (av, sw32_r_apverts);
|
|
|
|
sw32_R_AliasTransformFinalVert (fv, sw32_r_apverts, pstverts);
|
2002-01-05 20:00:50 +00:00
|
|
|
R_AliasClipAndProjectFinalVert (fv, av);
|
2001-08-25 02:47:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// clip and draw all triangles
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_r_affinetridesc.numtriangles = 1;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
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
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_r_affinetridesc.pfinalverts = pfinalverts;
|
|
|
|
sw32_r_affinetridesc.ptriangles = ptri;
|
|
|
|
sw32_D_PolysetDraw ();
|
2001-08-25 02:47:11 +00:00
|
|
|
} else { // partially clipped
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_R_AliasClipTriangle (ptri);
|
2001-08-25 02:47:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-08-28 22:46:02 +00:00
|
|
|
|
2001-08-25 02:47:11 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_R_AliasSetUpTransform (int trivial_accept)
|
2001-08-25 02:47:11 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
float rotationmatrix[3][4], t2matrix[3][4];
|
|
|
|
static float tmatrix[3][4];
|
|
|
|
static float viewmatrix[3][4];
|
|
|
|
|
2021-03-09 14:52:40 +00:00
|
|
|
mat4f_t mat;
|
|
|
|
Transform_GetWorldMatrix (currententity->transform, mat);
|
|
|
|
VectorCopy (mat[0], alias_forward);
|
|
|
|
VectorNegate (mat[1], alias_right);
|
|
|
|
VectorCopy (mat[2], alias_up);
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
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]);
|
2007-03-10 12:00:59 +00:00
|
|
|
VectorNegate (viewmatrix[1], viewmatrix[1]);
|
2001-08-25 02:47:11 +00:00
|
|
|
VectorCopy (vpn, viewmatrix[2]);
|
|
|
|
|
|
|
|
// viewmatrix[0][3] = 0;
|
|
|
|
// viewmatrix[1][3] = 0;
|
|
|
|
// viewmatrix[2][3] = 0;
|
|
|
|
|
2012-05-18 14:31:14 +00:00
|
|
|
R_ConcatTransforms (viewmatrix, rotationmatrix, sw32_aliastransform);
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
// 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++) {
|
2012-05-18 14:31:14 +00:00
|
|
|
sw32_aliastransform[0][i] *= sw32_aliasxscale *
|
2001-08-25 02:47:11 +00:00
|
|
|
(1.0 / ((float) 0x8000 * 0x10000));
|
2012-05-18 14:31:14 +00:00
|
|
|
sw32_aliastransform[1][i] *= sw32_aliasyscale *
|
2001-08-25 02:47:11 +00:00
|
|
|
(1.0 / ((float) 0x8000 * 0x10000));
|
2012-05-18 14:31:14 +00:00
|
|
|
sw32_aliastransform[2][i] *= 1.0 / ((float) 0x8000 * 0x10000);
|
2001-08-25 02:47:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-01-05 20:00:50 +00:00
|
|
|
/*
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_R_AliasTransformFinalVert
|
2001-08-28 22:46:02 +00:00
|
|
|
|
2002-01-05 20:00:50 +00:00
|
|
|
now this function just copies the texture coordinates and calculates lighting
|
|
|
|
actual 3D transform is done by R_AliasTransformFinalVert8/16 functions above
|
|
|
|
*/
|
2001-08-25 02:47:11 +00:00
|
|
|
void
|
2012-05-17 12:33:22 +00:00
|
|
|
sw32_R_AliasTransformFinalVert (finalvert_t *fv, trivertx_t *pverts,
|
|
|
|
stvert_t *pstverts)
|
2001-08-25 02:47:11 +00:00
|
|
|
{
|
|
|
|
int temp;
|
|
|
|
float lightcos, *plightnormal;
|
|
|
|
|
|
|
|
fv->v[2] = pstverts->s;
|
|
|
|
fv->v[3] = pstverts->t;
|
|
|
|
|
|
|
|
fv->flags = pstverts->onseam;
|
|
|
|
|
|
|
|
// lighting
|
|
|
|
// LordHavoc: flipped lightcos so it is + for bright, not -
|
|
|
|
plightnormal = r_avertexnormals[pverts->lightnormalindex];
|
2012-02-22 07:32:34 +00:00
|
|
|
lightcos = -DotProduct (plightnormal, sw32_r_plightvec);
|
|
|
|
temp = sw32_r_ambientlight;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
if (lightcos > 0) {
|
2012-02-22 07:32:34 +00:00
|
|
|
temp += (int) (sw32_r_shadelight * lightcos);
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_R_AliasTransformAndProjectFinalVerts (finalvert_t *fv, stvert_t *pstverts)
|
2001-08-25 02:47:11 +00:00
|
|
|
{
|
|
|
|
int i, temp;
|
|
|
|
float lightcos, *plightnormal, zi;
|
|
|
|
trivertx_t *pverts;
|
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
pverts = sw32_r_apverts;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
for (i = 0; i < r_anumverts; i++, fv++, pverts++, pstverts++) {
|
|
|
|
// transform and project
|
2012-05-18 14:31:14 +00:00
|
|
|
zi = 1.0 / (DotProduct (pverts->v, sw32_aliastransform[2]) +
|
|
|
|
sw32_aliastransform[2][3]);
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
// 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;
|
|
|
|
|
2012-05-18 14:31:14 +00:00
|
|
|
fv->v[0] = ((DotProduct (pverts->v, sw32_aliastransform[0]) +
|
|
|
|
sw32_aliastransform[0][3]) * zi) + sw32_aliasxcenter;
|
|
|
|
fv->v[1] = ((DotProduct (pverts->v, sw32_aliastransform[1]) +
|
|
|
|
sw32_aliastransform[1][3]) * zi) + sw32_aliasycenter;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
fv->v[2] = pstverts->s;
|
|
|
|
fv->v[3] = pstverts->t;
|
|
|
|
fv->flags = pstverts->onseam;
|
|
|
|
|
|
|
|
// lighting
|
|
|
|
// LordHavoc: flipped lightcos so it is + for bright, not -
|
|
|
|
plightnormal = r_avertexnormals[pverts->lightnormalindex];
|
2012-02-22 07:32:34 +00:00
|
|
|
lightcos = -DotProduct (plightnormal, sw32_r_plightvec);
|
|
|
|
temp = sw32_r_ambientlight;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
if (lightcos > 0) {
|
2012-02-22 07:32:34 +00:00
|
|
|
temp += (int) (sw32_r_shadelight * lightcos);
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_R_AliasProjectFinalVert (finalvert_t *fv, auxvert_t *av)
|
2001-08-25 02:47:11 +00:00
|
|
|
{
|
|
|
|
float zi;
|
|
|
|
|
|
|
|
// project points
|
|
|
|
zi = 1.0 / av->fv[2];
|
|
|
|
|
2012-05-18 14:31:14 +00:00
|
|
|
fv->v[5] = zi * sw32_ziscale;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
fv->v[0] = (av->fv[0] * sw32_aliasxscale * zi) + sw32_aliasxcenter;
|
|
|
|
fv->v[1] = (av->fv[1] * sw32_aliasyscale * zi) + sw32_aliasycenter;
|
2001-08-25 02:47:11 +00:00
|
|
|
}
|
|
|
|
|
2001-08-28 22:46:02 +00:00
|
|
|
|
2003-01-06 18:28:13 +00:00
|
|
|
static void
|
2001-08-25 02:47:11 +00:00
|
|
|
R_AliasPrepareUnclippedPoints (void)
|
|
|
|
{
|
|
|
|
stvert_t *pstverts;
|
|
|
|
|
|
|
|
pstverts = (stvert_t *) ((byte *) paliashdr + paliashdr->stverts);
|
|
|
|
r_anumverts = pmdl->numverts;
|
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_R_AliasTransformAndProjectFinalVerts (pfinalverts, pstverts);
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_r_affinetridesc.pfinalverts = pfinalverts;
|
|
|
|
sw32_r_affinetridesc.ptriangles = (mtriangle_t *)
|
2001-08-25 02:47:11 +00:00
|
|
|
((byte *) paliashdr + paliashdr->triangles);
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_r_affinetridesc.numtriangles = pmdl->numtris;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_D_PolysetDraw ();
|
2001-08-25 02:47:11 +00:00
|
|
|
}
|
|
|
|
|
2001-08-28 22:46:02 +00:00
|
|
|
|
2003-01-06 18:28:13 +00:00
|
|
|
static void
|
2021-07-22 06:39:28 +00:00
|
|
|
R_AliasSetupSkin (entity_t *ent)
|
2001-08-25 02:47:11 +00:00
|
|
|
{
|
|
|
|
int skinnum;
|
|
|
|
|
2021-07-22 06:39:28 +00:00
|
|
|
skinnum = ent->renderer.skinnum;
|
2001-08-25 02:47:11 +00:00
|
|
|
if ((skinnum >= pmdl->numskins) || (skinnum < 0)) {
|
2021-03-29 10:58:00 +00:00
|
|
|
Sys_MaskPrintf (SYS_dev, "R_AliasSetupSkin: no such skin # %d\n",
|
2010-11-23 05:09:30 +00:00
|
|
|
skinnum);
|
2001-08-25 02:47:11 +00:00
|
|
|
skinnum = 0;
|
|
|
|
}
|
|
|
|
|
2021-07-22 06:39:28 +00:00
|
|
|
pskindesc = R_AliasGetSkindesc (&ent->animation, skinnum, paliashdr);
|
2001-08-25 02:47:11 +00:00
|
|
|
a_skinwidth = pmdl->skinwidth;
|
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_r_affinetridesc.pskin = (void *) ((byte *) paliashdr + pskindesc->skin);
|
|
|
|
sw32_r_affinetridesc.skinwidth = a_skinwidth;
|
|
|
|
sw32_r_affinetridesc.seamfixupX16 = (a_skinwidth >> 1) << 16;
|
|
|
|
sw32_r_affinetridesc.skinheight = pmdl->skinheight;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_acolormap = vid.colormap8;
|
2021-07-22 06:39:28 +00:00
|
|
|
if (ent->renderer.skin) {
|
2001-08-25 02:47:11 +00:00
|
|
|
tex_t *base;
|
|
|
|
|
2021-07-22 06:39:28 +00:00
|
|
|
base = ent->renderer.skin->texels;
|
2001-08-25 02:47:11 +00:00
|
|
|
if (base) {
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_r_affinetridesc.pskin = base->data;
|
|
|
|
sw32_r_affinetridesc.skinwidth = base->width;
|
|
|
|
sw32_r_affinetridesc.skinheight = base->height;
|
2001-08-25 02:47:11 +00:00
|
|
|
}
|
2021-07-22 06:39:28 +00:00
|
|
|
sw32_acolormap = ent->renderer.skin->colormap;
|
2001-08-25 02:47:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-01-06 18:28:13 +00:00
|
|
|
static void
|
2001-08-25 02:47:11 +00:00
|
|
|
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
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_r_ambientlight = plighting->ambientlight;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
if (sw32_r_ambientlight < LIGHT_MIN)
|
|
|
|
sw32_r_ambientlight = LIGHT_MIN;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_r_ambientlight = (/*255 -*/ sw32_r_ambientlight) << VID_CBITS;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
// if (sw32_r_ambientlight < LIGHT_MIN)
|
|
|
|
// sw32_r_ambientlight = LIGHT_MIN;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_r_shadelight = plighting->shadelight;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
if (sw32_r_shadelight < 0)
|
|
|
|
sw32_r_shadelight = 0;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_r_shadelight *= VID_GRADES;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
|
|
|
// rotate the lighting vector into the model's frame of reference
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_r_plightvec[0] = DotProduct (plighting->plightvec, alias_forward);
|
|
|
|
sw32_r_plightvec[1] = -DotProduct (plighting->plightvec, alias_right);
|
|
|
|
sw32_r_plightvec[2] = DotProduct (plighting->plightvec, alias_up);
|
2001-08-25 02:47:11 +00:00
|
|
|
}
|
|
|
|
|
2001-08-28 22:46:02 +00:00
|
|
|
|
2001-08-25 02:47:11 +00:00
|
|
|
/*
|
|
|
|
R_AliasSetupFrame
|
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
set sw32_r_apverts
|
2001-08-25 02:47:11 +00:00
|
|
|
*/
|
2003-01-06 18:28:13 +00:00
|
|
|
static void
|
2021-07-22 06:39:28 +00:00
|
|
|
R_AliasSetupFrame (entity_t *ent)
|
2001-08-25 02:47:11 +00:00
|
|
|
{
|
2012-01-02 08:47:22 +00:00
|
|
|
maliasframedesc_t *frame;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2021-07-22 06:39:28 +00:00
|
|
|
frame = R_AliasGetFramedesc (&ent->animation, paliashdr);
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_r_apverts = (trivertx_t *) ((byte *) paliashdr + frame->frame);
|
2001-08-25 02:47:11 +00:00
|
|
|
}
|
|
|
|
|
2001-08-28 22:46:02 +00:00
|
|
|
|
2001-08-25 02:47:11 +00:00
|
|
|
void
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_R_AliasDrawModel (alight_t *plighting)
|
2001-08-25 02:47:11 +00:00
|
|
|
{
|
2021-07-22 06:39:28 +00:00
|
|
|
entity_t *ent = currententity;
|
2002-01-07 16:43:47 +00:00
|
|
|
int size;
|
|
|
|
finalvert_t *finalverts;
|
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_r_amodels_drawn++;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2021-07-22 06:39:28 +00:00
|
|
|
if (!(paliashdr = ent->renderer.model->aliashdr))
|
|
|
|
paliashdr = Cache_Get (&ent->renderer.model->cache);
|
2002-01-05 17:56:33 +00:00
|
|
|
pmdl = (mdl_t *) ((byte *) paliashdr + paliashdr->model);
|
|
|
|
|
2002-01-07 16:43:47 +00:00
|
|
|
size = (CACHE_SIZE - 1)
|
|
|
|
+ sizeof (finalvert_t) * (pmdl->numverts + 1)
|
|
|
|
+ sizeof (auxvert_t) * pmdl->numverts;
|
|
|
|
finalverts = (finalvert_t *) Hunk_TempAlloc (size);
|
|
|
|
if (!finalverts)
|
|
|
|
Sys_Error ("R_AliasDrawModel: out of memory");
|
2002-01-05 17:56:33 +00:00
|
|
|
|
2001-08-25 02:47:11 +00:00
|
|
|
// cache align
|
|
|
|
pfinalverts = (finalvert_t *)
|
2007-04-11 22:03:36 +00:00
|
|
|
(((intptr_t) &finalverts[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_pauxverts = (auxvert_t *) &pfinalverts[pmdl->numverts + 1];
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2021-07-22 06:39:28 +00:00
|
|
|
R_AliasSetupSkin (ent);
|
|
|
|
sw32_R_AliasSetUpTransform (ent->visibility.trivial_accept);
|
2001-08-25 02:47:11 +00:00
|
|
|
R_AliasSetupLighting (plighting);
|
2021-07-22 06:39:28 +00:00
|
|
|
R_AliasSetupFrame (ent);
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2012-02-22 07:32:34 +00:00
|
|
|
if (!sw32_acolormap)
|
|
|
|
sw32_acolormap = vid.colormap8;
|
2021-07-10 15:09:41 +00:00
|
|
|
if (sw32_acolormap == &vid.colormap8 && sw32_ctx->pixbytes != 1)
|
2001-08-25 02:47:11 +00:00
|
|
|
{
|
2021-07-10 15:09:41 +00:00
|
|
|
if (sw32_ctx->pixbytes == 2)
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_acolormap = vid.colormap16;
|
2021-07-10 15:09:41 +00:00
|
|
|
else if (sw32_ctx->pixbytes == 4)
|
2012-02-22 07:32:34 +00:00
|
|
|
sw32_acolormap = vid.colormap32;
|
2001-08-25 02:47:11 +00:00
|
|
|
else
|
2002-05-14 06:12:29 +00:00
|
|
|
Sys_Error("R_AliasDrawmodel: unsupported r_pixbytes %i",
|
2021-07-10 15:09:41 +00:00
|
|
|
sw32_ctx->pixbytes);
|
2001-08-25 02:47:11 +00:00
|
|
|
}
|
|
|
|
|
2021-07-22 06:39:28 +00:00
|
|
|
if (ent != vr_data.view_model)
|
2012-05-18 14:31:14 +00:00
|
|
|
sw32_ziscale = (float) 0x8000 *(float) 0x10000;
|
2001-08-25 02:47:11 +00:00
|
|
|
else
|
2012-05-18 14:31:14 +00:00
|
|
|
sw32_ziscale = (float) 0x8000 *(float) 0x10000 *3.0;
|
2001-08-25 02:47:11 +00:00
|
|
|
|
2021-07-22 06:39:28 +00:00
|
|
|
if (ent->visibility.trivial_accept) {
|
2001-08-25 02:47:11 +00:00
|
|
|
R_AliasPrepareUnclippedPoints ();
|
2021-03-09 14:52:40 +00:00
|
|
|
} else {
|
2001-08-25 02:47:11 +00:00
|
|
|
R_AliasPreparePoints ();
|
2021-03-09 14:52:40 +00:00
|
|
|
}
|
2001-08-31 12:22:45 +00:00
|
|
|
|
2021-07-22 06:39:28 +00:00
|
|
|
if (!ent->renderer.model->aliashdr) {
|
|
|
|
Cache_Release (&ent->renderer.model->cache);
|
2021-03-09 14:52:40 +00:00
|
|
|
}
|
2001-08-25 02:47:11 +00:00
|
|
|
}
|