Quake!

This ports id Software's Quake to run on the SDL plugin runtime. The
source code originated from id under the GPLv2 license. I used
https://github.com/ahefner/sdlquake as the base of my port.

Performance is, unsurprisingly, not on par with what you're probably
used to on PC. I average about 10FPS on ipod6g, but it's still
playable.

Sound works well enough, but in-game music is not supported. I've
written ARM assembly routines for the inner sound loop. Make sure you
turn the "brightness" all the way down, or colors will look funky.

To run, extract Quake's data files to /.rockbox/quake. Have fun!

Change-Id: I4285036e967d7f0722802d43cf2096c808ca5799

1 files changed, 753 insertions, 0 deletions

diff --git a/apps/plugins/sdl/progs/quake/r_alias.c b/apps/plugins/sdl/progs/quake/r_alias.c
new file mode 100644
index 0000000000..86074199bc
--- /dev/null
+++ b/apps/plugins/sdl/progs/quake/r_alias.c
@@ -0,0 +1,753 @@
+/*
+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 ();
+}
+