WebSVN – eduke32 – Diff – /polymer/eduke32/build/src/mdsprite.c


//------------------------------------- MD2/MD3 LIBRARY BEGINS -------------------------------------

#ifdef USE_OPENGL

#include "compat.h"
#include "build.h"
#include "glbuild.h"
#include "pragmas.h"
#include "baselayer.h"
#include "engine_priv.h"
#include "hightile.h"
#include "polymost.h"
#include "texcache.h"
#include "mdsprite.h"
#include "cache1d.h"
#include "kplib.h"
#include "common.h"

#include <math.h>
#include <float.h>

static int32_t curextra=MAXTILES;

#define MIN_CACHETIME_PRINT 10

static void QuitOnFatalError(const char *msg)
{
    if (msg)
        initprintf("%s\n", msg);
    uninitengine();
    Bexit(1);
}


static int32_t addtileP(int32_t model,int32_t tile,int32_t pallet)
{
    // tile >= 0 && tile < MAXTILES

    UNREFERENCED_PARAMETER(model);
    if (curextra==MAXTILES+EXTRATILES-1)
    {
        initprintf("warning: max EXTRATILES reached\n");
        return curextra;
    }

    if (tile2model[tile].modelid==-1)
    {
        tile2model[tile].pal=pallet;
        return tile;
    }

    if (tile2model[tile].pal==pallet)
        return tile;

    while (tile2model[tile].next!=-1)
    {
        tile=tile2model[tile].next;
        if (tile2model[tile].pal==pallet)
            return tile;
    }

    tile2model[tile].next=curextra;
    tile2model[curextra].pal=pallet;

    return curextra++;
}
int32_t Ptile2tile(int32_t tile,int32_t pallet)
{
    int32_t t=tile;
//  if(tile>=1550&&tile<=1589){initprintf("(%d, %d)\n",tile,pallet);pallet=0;}
    while ((tile=tile2model[tile].next)!=-1)
        if (tile2model[tile].pal==pallet)
            return tile;
    return t;
}

#define MODELALLOCGROUP 256
static int32_t nummodelsalloced = 0;

static int32_t maxmodelverts = 0, allocmodelverts = 0;
static int32_t maxmodeltris = 0, allocmodeltris = 0;
static vec3f_t *vertlist = NULL; //temp array to store interpolated vertices for drawing

static int32_t allocvbos = 0, curvbo = 0;
static GLuint *vertvbos = NULL;
static GLuint *indexvbos = NULL;

#ifdef POLYMER
static int32_t *tribuf = NULL;
static int32_t tribufverts = 0;
#endif

static mdmodel_t *mdload(const char *);
static void mdfree(mdmodel_t *);
int32_t globalnoeffect=0;

extern int32_t timerticspersec;

void md_freevbos()
{
    int32_t i;

    for (i=0; i<nextmodelid; i++)
        if (models[i]->mdnum == 3)
        {
            md3model_t *m = (md3model_t *)models[i];
            if (m->vbos)
            {
                //            OSD_Printf("freeing model %d vbo\n",i);
                bglDeleteBuffersARB(m->head.numsurfs, m->vbos);
                Bfree(m->vbos);
                m->vbos = NULL;
            }
        }

    if (allocvbos)
    {
        bglDeleteBuffersARB(allocvbos, indexvbos);
        bglDeleteBuffersARB(allocvbos, vertvbos);
        allocvbos = 0;
    }
}

void freeallmodels()
{
    int32_t i;

    if (models)
    {
        for (i=0; i<nextmodelid; i++) mdfree(models[i]);
        Bfree(models); models = NULL;
        nummodelsalloced = 0;
        nextmodelid = 0;
    }

    memset(tile2model,-1,sizeof(tile2model));
    curextra=MAXTILES;

    if (vertlist)
    {
        Bfree(vertlist);
        vertlist = NULL;
        allocmodelverts = maxmodelverts = 0;
        allocmodeltris = maxmodeltris = 0;
    }

    md_freevbos();
#ifdef POLYMER
    DO_FREE_AND_NULL(tribuf);
#endif
}


// Skin texture names can be aliased! This is ugly, but at least correct.
static void nullskintexids(GLuint texid)
{
    int32_t i, j;

    for (i=0; i<nextmodelid; i++)
    {
        mdmodel_t *m = models[i];

        if (m->mdnum == 2 || m->mdnum == 3)
        {
            mdskinmap_t *sk;
            md2model_t *m2 = (md2model_t *)m;

            for (j=0; j<m2->numskins*(HICEFFECTMASK+1); j++)
                if (m2->texid[j] == texid)
                    m2->texid[j] = 0;

            for (sk=m2->skinmap; sk; sk=sk->next)
                for (j=0; j<(HICEFFECTMASK+1); j++)
                    if (sk->texid[j] == texid)
                        sk->texid[j] = 0;
        }
    }
}

void clearskins()
{
    int32_t i, j;

    for (i=0; i<nextmodelid; i++)
    {
        mdmodel_t *m = models[i];

        if (m->mdnum == 1)
        {
            voxmodel_t *v = (voxmodel_t *)m;

            for (j=0; j<MAXPALOOKUPS; j++)
                if (v->texid[j])
                {
                    bglDeleteTextures(1, &v->texid[j]);
                    v->texid[j] = 0;
                }
        }
        else if (m->mdnum == 2 || m->mdnum == 3)
        {
            mdskinmap_t *sk;
            md2model_t *m2 = (md2model_t *)m;

            for (j=0; j<m2->numskins*(HICEFFECTMASK+1); j++)
                if (m2->texid[j])
                {
                    GLuint otexid = m2->texid[j];

                    bglDeleteTextures(1, &m2->texid[j]);
                    m2->texid[j] = 0;

                    nullskintexids(otexid);
                }

            for (sk=m2->skinmap; sk; sk=sk->next)
                for (j=0; j<(HICEFFECTMASK+1); j++)
                    if (sk->texid[j])
                    {
                        GLuint otexid = sk->texid[j];

                        bglDeleteTextures(1, &sk->texid[j]);
                        sk->texid[j] = 0;

                        nullskintexids(otexid);
                    }
        }
    }

    for (i=0; i<MAXVOXELS; i++)
    {
        voxmodel_t *v = voxmodels[i];
        if (!v) continue;

        for (j=0; j<MAXPALOOKUPS; j++)
            if (v->texid[j])
            {
                bglDeleteTextures(1, &v->texid[j]);
                v->texid[j] = 0;
            }
    }
}

void mdinit()
{
    memset(hudmem,0,sizeof(hudmem));
    freeallmodels();
    mdinited = 1;
}

int32_t md_loadmodel(const char *fn)
{
    mdmodel_t *vm, **ml;

    if (!mdinited) mdinit();

    if (nextmodelid >= nummodelsalloced)
    {
        ml = (mdmodel_t **)Xrealloc(models,(nummodelsalloced+MODELALLOCGROUP)*sizeof(void *));
        models = ml; nummodelsalloced += MODELALLOCGROUP;
    }

    vm = mdload(fn); if (!vm) return(-1);
    models[nextmodelid++] = vm;
    return(nextmodelid-1);
}

int32_t md_setmisc(int32_t modelid, float scale, int32_t shadeoff, float zadd, float yoffset, int32_t flags)
{
    mdmodel_t *m;

    if (!mdinited) mdinit();

    if ((uint32_t)modelid >= (uint32_t)nextmodelid) return -1;
    m = models[modelid];
    m->bscale = scale;
    m->shadeoff = shadeoff;
    m->zadd = zadd;
    m->yoffset = yoffset;
    m->flags = flags;

    return 0;
}

static int32_t framename2index(mdmodel_t *vm, const char *nam)
{
    int32_t i = 0;

    switch (vm->mdnum)
    {
    case 2:
    {
        md2model_t *m = (md2model_t *)vm;
        md2frame_t *fr;
        for (i=0; i<m->numframes; i++)
        {
            fr = (md2frame_t *)&m->frames[i*m->framebytes];
            if (!Bstrcmp(fr->name, nam)) break;
        }
    }
    break;
    case 3:
    {
        md3model_t *m = (md3model_t *)vm;
        for (i=0; i<m->numframes; i++)
            if (!Bstrcmp(m->head.frames[i].nam,nam)) break;
    }
    break;
    }
    return(i);
}

int32_t md_defineframe(int32_t modelid, const char *framename, int32_t tilenume, int32_t skinnum, float smoothduration, int32_t pal)
{
    md2model_t *m;
    int32_t i;

    if (!mdinited) mdinit();

    if ((uint32_t)modelid >= (uint32_t)nextmodelid) return(-1);
    if ((uint32_t)tilenume >= (uint32_t)MAXTILES) return(-2);
    if (!framename) return(-3);

    tilenume=addtileP(modelid,tilenume,pal);
    m = (md2model_t *)models[modelid];
    if (m->mdnum == 1)
    {
        tile2model[tilenume].modelid = modelid;
        tile2model[tilenume].framenum = tile2model[tilenume].skinnum = 0;
        return 0;
    }

    i = framename2index((mdmodel_t *)m,framename);
    if (i == m->numframes) return(-3);   // frame name invalid

    tile2model[tilenume].modelid = modelid;
    tile2model[tilenume].framenum = i;
    tile2model[tilenume].skinnum = skinnum;
    tile2model[tilenume].smoothduration = smoothduration;

    return i;
}

int32_t md_defineanimation(int32_t modelid, const char *framestart, const char *frameend, int32_t fpssc, int32_t flags)
{
    md2model_t *m;
    mdanim_t ma, *map;
    int32_t i;

    if (!mdinited) mdinit();

    if ((uint32_t)modelid >= (uint32_t)nextmodelid) return(-1);

    Bmemset(&ma, 0, sizeof(ma));
    m = (md2model_t *)models[modelid];
    if (m->mdnum < 2) return 0;

    //find index of start frame
    i = framename2index((mdmodel_t *)m,framestart);
    if (i == m->numframes) return -2;
    ma.startframe = i;

    //find index of finish frame which must trail start frame
    i = framename2index((mdmodel_t *)m,frameend);
    if (i == m->numframes) return -3;
    ma.endframe = i;

    ma.fpssc = fpssc;
    ma.flags = flags;

    map = (mdanim_t *)Xmalloc(sizeof(mdanim_t));

    Bmemcpy(map, &ma, sizeof(ma));

    map->next = m->animations;
    m->animations = map;

    return(0);
}

#if 0
// FIXME: CURRENTLY DISABLED: interpolation may access frames we consider 'unused'?
int32_t md_thinoutmodel(int32_t modelid, uint8_t *usedframebitmap)
{
    md3model_t *m;
    md3surf_t *s;
    mdanim_t *anm;
    int32_t i, surfi, sub, usedframes;
    static int16_t otonframe[1024];

    if ((uint32_t)modelid >= (uint32_t)nextmodelid) return -1;
    m = (md3model_t *)models[modelid];
    if (m->mdnum != 3) return -2;

    for (anm=m->animations; anm; anm=anm->next)
    {
        if (anm->endframe <= anm->startframe)
        {
//            initprintf("backward anim %d-%d\n", anm->startframe, anm->endframe);
            return -3;
        }

        for (i=anm->startframe; i<anm->endframe; i++)
            usedframebitmap[i>>3] |= (1<<(i&7));
    }

    sub = 0;
    for (i=0; i<m->numframes; i++)
    {
        if (!(usedframebitmap[i>>3]&(1<<(i&7))))
        {
            sub++;
            otonframe[i] = -1;
            continue;
        }

        otonframe[i] = i-sub;
    }

    usedframes = m->numframes - sub;
    if (usedframes==0 || usedframes==m->numframes)
        return usedframes;

    //// THIN OUT! ////

    for (i=0; i<m->numframes; i++)
    {
        if (otonframe[i]>=0 && otonframe[i] != i)
        {
            if (m->muladdframes)
                Bmemcpy(&m->muladdframes[2*otonframe[i]], &m->muladdframes[2*i], 2*sizeof(vec3f_t));
            Bmemcpy(&m->head.frames[otonframe[i]], &m->head.frames[i], sizeof(md3frame_t));
        }
    }

    for (surfi=0; surfi < m->head.numsurfs; surfi++)
    {
        s = &m->head.surfs[surfi];

        for (i=0; i<m->numframes; i++)
            if (otonframe[i]>=0 && otonframe[i] != i)
                Bmemcpy(&s->xyzn[otonframe[i]*s->numverts], &s->xyzn[i*s->numverts], s->numverts*sizeof(md3xyzn_t));
    }

    ////// tweak frame indices in various places

    for (anm=m->animations; anm; anm=anm->next)
    {
        if (otonframe[anm->startframe]==-1 || otonframe[anm->endframe-1]==-1)
            initprintf("md %d WTF: anm %d %d\n", modelid, anm->startframe, anm->endframe);

        anm->startframe = otonframe[anm->startframe];
        anm->endframe = otonframe[anm->endframe-1];
    }

    for (i=0; i<MAXTILES+EXTRATILES; i++)
        if (tile2model[i].modelid == modelid)
        {
            if (otonframe[tile2model[i].framenum]==-1)
                initprintf("md %d WTF: tile %d, fr %d\n", modelid, i, tile2model[i].framenum);
            tile2model[i].framenum = otonframe[tile2model[i].framenum];
        }

    ////// realloc & change "numframes" everywhere

    if (m->muladdframes)
        m->muladdframes = Xrealloc(m->muladdframes, 2*sizeof(vec3f_t)*usedframes);
    m->head.frames = Xrealloc(m->head.frames, sizeof(md3frame_t)*usedframes);

    for (surfi=0; surfi < m->head.numsurfs; surfi++)
    {
        m->head.surfs[surfi].numframes = usedframes;
        // CAN'T do that because xyzn is offset from a larger block when loaded from md3:
//        m->head.surfs[surfi].xyzn = Xrealloc(m->head.surfs[surfi].xyzn, s->numverts*usedframes*sizeof(md3xyzn_t));
    }

    m->head.numframes = usedframes;
    m->numframes = usedframes;

    ////////////
    return usedframes;
}
#endif

int32_t md_defineskin(int32_t modelid, const char *skinfn, int32_t palnum, int32_t skinnum, int32_t surfnum, float param, float specpower, float specfactor)
{
    mdskinmap_t *sk, *skl;
    md2model_t *m;

    if (!mdinited) mdinit();

    if ((uint32_t)modelid >= (uint32_t)nextmodelid) return -1;
    if (!skinfn) return -2;
    if ((unsigned)palnum >= (unsigned)MAXPALOOKUPS) return -3;

    m = (md2model_t *)models[modelid];
    if (m->mdnum < 2) return 0;
    if (m->mdnum == 2) surfnum = 0;

    skl = NULL;
    for (sk = m->skinmap; sk; skl = sk, sk = sk->next)
        if (sk->palette == (uint8_t)palnum && skinnum == sk->skinnum && surfnum == sk->surfnum)
            break;
    if (!sk)
    {
        sk = (mdskinmap_t *)Xcalloc(1,sizeof(mdskinmap_t));

        if (!skl) m->skinmap = sk;
        else skl->next = sk;
    }
    else if (sk->fn) Bfree(sk->fn);

    sk->palette = (uint8_t)palnum;
    sk->skinnum = skinnum;
    sk->surfnum = surfnum;
    sk->param = param;
    sk->specpower = specpower;
    sk->specfactor = specfactor;
    sk->fn = Xstrdup(skinfn);

    return 0;
}

int32_t md_definehud(int32_t modelid, int32_t tilex, float xadd, float yadd, float zadd, int32_t angadd, int32_t flags, int32_t fov)
{
    if (!mdinited) mdinit();

    if ((uint32_t)modelid >= (uint32_t)nextmodelid) return -1;
    if ((uint32_t)tilex >= (uint32_t)MAXTILES) return -2;

    hudmem[(flags>>2)&1][tilex].add.x = xadd;
    hudmem[(flags>>2)&1][tilex].add.y = yadd;
    hudmem[(flags>>2)&1][tilex].add.z = zadd;
    hudmem[(flags>>2)&1][tilex].angadd = ((int16_t)angadd)|2048;
    hudmem[(flags>>2)&1][tilex].flags = (int16_t)flags;
    hudmem[(flags>>2)&1][tilex].fov = (int16_t)fov;

    return 0;
}

int32_t md_undefinetile(int32_t tile)
{
    if (!mdinited) return 0;
    if ((unsigned)tile >= (unsigned)MAXTILES) return -1;

    tile2model[tile].modelid = -1;
    tile2model[tile].next=-1;
    hudmem[0][tile].angadd = 0;
    hudmem[1][tile].angadd = 0;

    return 0;
}

/* this function is problematic, it leaves NULL holes in model[]
 * (which runs from 0 to nextmodelid-1) */
int32_t md_undefinemodel(int32_t modelid)
{
    int32_t i;
    if (!mdinited) return 0;
    if ((uint32_t)modelid >= (uint32_t)nextmodelid) return -1;

    for (i=MAXTILES+EXTRATILES-1; i>=0; i--)
        if (tile2model[i].modelid == modelid)
            tile2model[i].modelid = -1;

    if (models)
    {
        mdfree(models[modelid]);
        models[modelid] = NULL;
    }

    return 0;
}

static int32_t daskinloader(int32_t filh, intptr_t *fptr, int32_t *bpl, int32_t *sizx, int32_t *sizy,
                            int32_t *osizx, int32_t *osizy, char *hasalpha, int32_t pal, char effect)
{
    int32_t picfillen, j,y,x;
    char *picfil,*cptr,al=255;
    coltype *pic;
    int32_t xsiz, ysiz, tsizx, tsizy;
    int32_t r, g, b;

    picfillen = kfilelength(filh);
    picfil = (char *)Xmalloc(picfillen+1);
    kread(filh, picfil, picfillen);

    // tsizx/y = replacement texture's natural size
    // xsiz/y = 2^x size of replacement

    kpgetdim(picfil,picfillen,&tsizx,&tsizy);
    if (tsizx == 0 || tsizy == 0) { Bfree(picfil); return -2; }

    if (!glinfo.texnpot)
    {
        for (xsiz=1; xsiz<tsizx; xsiz+=xsiz);
        for (ysiz=1; ysiz<tsizy; ysiz+=ysiz);
    }
    else
    {
        xsiz = tsizx;
        ysiz = tsizy;
    }
    *osizx = tsizx; *osizy = tsizy;
    pic = (coltype *)Xmalloc(xsiz*ysiz*sizeof(coltype));

    memset(pic,0,xsiz*ysiz*sizeof(coltype));

    if (kprender(picfil,picfillen,(intptr_t)pic,xsiz*sizeof(coltype),xsiz,ysiz))
        { Bfree(picfil); Bfree(pic); return -2; }
    Bfree(picfil);

    cptr = &britable[gammabrightness ? 0 : curbrightness][0];
    r=(glinfo.bgra)?hictinting[pal].b:hictinting[pal].r;
    g=hictinting[pal].g;
    b=(glinfo.bgra)?hictinting[pal].r:hictinting[pal].b;
    for (y=0,j=0; y<tsizy; y++,j+=xsiz)
    {
        coltype *rpptr = &pic[j], tcol;

        for (x=0; x<tsizx; x++)
        {
            tcol.b = cptr[rpptr[x].b];
            tcol.g = cptr[rpptr[x].g];
            tcol.r = cptr[rpptr[x].r];

            if (effect & HICTINT_GRAYSCALE)
            {
                tcol.g = tcol.r = tcol.b = (uint8_t)((tcol.r * GRAYSCALE_COEFF_RED) + (tcol.g * GRAYSCALE_COEFF_GREEN) +
                                                     (tcol.b * GRAYSCALE_COEFF_BLUE));
            }

            if (effect & HICTINT_INVERT)
            {
                tcol.b = 255-tcol.b;
                tcol.g = 255-tcol.g;
                tcol.r = 255-tcol.r;
            }

            if (effect & HICTINT_COLORIZE)
            {
                tcol.b = min((int32_t)(tcol.b)*b/64,255);
                tcol.g = min((int32_t)(tcol.g)*g/64,255);
                tcol.r = min((int32_t)(tcol.r)*r/64,255);
            }

            rpptr[x].b = tcol.b;
            rpptr[x].g = tcol.g;
            rpptr[x].r = tcol.r;
            al &= rpptr[x].a;
        }
    }
    if (!glinfo.bgra)
    {
        for (j=xsiz*ysiz-1; j>=0; j--)
        {
            swapchar(&pic[j].r, &pic[j].b);
        }
    }

    *sizx = xsiz;
    *sizy = ysiz;
    *bpl = xsiz;
    *fptr = (intptr_t)pic;
    *hasalpha = (al != 255);

    return 0;
}

static inline int32_t hicfxmask(int32_t pal)
{
    return globalnoeffect ? 0 : (hictinting[pal].f & HICEFFECTMASK);
}

//Note: even though it says md2model, it works for both md2model&md3model
int32_t mdloadskin(md2model_t *m, int32_t number, int32_t pal, int32_t surf)
{
    int32_t i, bpl, osizx, osizy, texfmt = GL_RGBA, intexfmt = GL_RGBA;
    char *skinfile, hasalpha, fn[BMAX_PATH];
    GLuint *texidx = NULL;
    mdskinmap_t *sk, *skzero = NULL;
    int32_t doalloc = 1, filh;
    int32_t gotcache, picfillen;
    texcacheheader cachead;

    int32_t startticks, willprint=0;
    vec2_t siz = { 0, 0 };

    if (m->mdnum == 2)
        surf = 0;

    if ((unsigned)pal >= (unsigned)MAXPALOOKUPS)
        return 0;

    i = -1;
    for (sk = m->skinmap; sk; sk = sk->next)
    {
        if (sk->palette == pal && sk->skinnum == number && sk->surfnum == surf)
        {
            skinfile = sk->fn;
            texidx = &sk->texid[hicfxmask(pal)];
            Bstrncpyz(fn, skinfile, BMAX_PATH);
            //OSD_Printf("Using exact match skin (pal=%d,skinnum=%d,surfnum=%d) %s\n",pal,number,surf,skinfile);
            break;
        }
        //If no match, give highest priority to number, then pal.. (Parkar's request, 02/27/2005)
        else if ((sk->palette ==   0) && (sk->skinnum == number) && (sk->surfnum == surf) && (i < 5)) { i = 5; skzero = sk; }
        else if ((sk->palette == pal) && (sk->skinnum ==      0) && (sk->surfnum == surf) && (i < 4)) { i = 4; skzero = sk; }
        else if ((sk->palette ==   0) && (sk->skinnum ==      0) && (sk->surfnum == surf) && (i < 3)) { i = 3; skzero = sk; }
        else if ((sk->palette ==   0) && (sk->skinnum == number) && (i < 2)) { i = 2; skzero = sk; }
        else if ((sk->palette == pal) && (sk->skinnum ==      0) && (i < 1)) { i = 1; skzero = sk; }
        else if ((sk->palette ==   0) && (sk->skinnum ==      0) && (i < 0)) { i = 0; skzero = sk; }
    }

    if (!sk)
    {
        if (pal >= (MAXPALOOKUPS - RESERVEDPALS))
            return (0);

        if (skzero)
        {
            skinfile = skzero->fn;
            texidx = &skzero->texid[hicfxmask(pal)];
            Bstrncpyz(fn, skinfile, BMAX_PATH);
            //OSD_Printf("Using def skin 0,0 as fallback, pal=%d\n", pal);
        }
        else
            return 0;
#if 0
        {
            // fall back to the model-defined texture
            if ((unsigned)number >= (unsigned)m->numskins)
                number = 0;

            // m->skinfn is undefined when md3model_t is cast to md2model_t --> crash
            skinfile = m->skinfn + number*64;
            texidx = &m->texid[number*(HICEFFECTMASK+1) + hicfxmask(pal)];
            Bstrncpyz(fn, m->basepath, BMAX_PATH);
            if ((Bstrlen(fn) + Bstrlen(skinfile)) < BMAX_PATH)
                Bstrcat(fn,skinfile);
            //OSD_Printf("Using MD2/MD3 skin (%d) %s, pal=%d\n",number,skinfile,pal);
        }
#endif
    }

    if (!skinfile[0])
        return 0;

    if (*texidx)
        return *texidx;

    // possibly fetch an already loaded multitexture :_)
    if (pal >= (MAXPALOOKUPS - RESERVEDPALS))
        for (i=0; i<nextmodelid; i++)
            for (skzero = ((md2model_t *)models[i])->skinmap; skzero; skzero = skzero->next)
                if (!Bstrcasecmp(skzero->fn, sk->fn) && skzero->texid[hicfxmask(pal)])
                {
                    int32_t f = hicfxmask(pal);

                    sk->texid[f] = skzero->texid[f];
                    return sk->texid[f];
                }

    *texidx = 0;

    if ((filh = kopen4load(fn, 0)) < 0)
    {
        OSD_Printf("Skin \"%s\" not found.\n",fn);
        skinfile[0] = 0;
        return 0;
    }


    picfillen = kfilelength(filh);
    kclose(filh);       // FIXME: shouldn't have to do this. bug in cache1d.c

    startticks = getticks();

    gotcache = texcache_readtexheader(fn, picfillen, pal<<8, hicfxmask(pal), &cachead, 1);

    if (gotcache && !texcache_loadskin(&cachead, &doalloc, texidx, &siz.x, &siz.y))
    {
        osizx = cachead.xdim;
        osizy = cachead.ydim;
        hasalpha = (cachead.flags & CACHEAD_HASALPHA) ? 1 : 0;
        if (pal < (MAXPALOOKUPS - RESERVEDPALS))
            m->usesalpha = hasalpha;
        //kclose(filh); // FIXME: uncomment when cache1d.c is fixed
    }
    else
    {
        int32_t ret;
        intptr_t fptr=0;

        gotcache = 0;   // the compressed version will be saved to disk

        if ((filh = kopen4load(fn, 0)) < 0)
            return -1;

        ret = daskinloader(filh,&fptr,&bpl,&siz.x,&siz.y,&osizx,&osizy,&hasalpha,pal,hicfxmask(pal));

        if (ret)
        {
            kclose(filh);
            OSD_Printf("Failed loading skin file \"%s\": error %d\n", fn, ret);
            if (ret==-1)
                QuitOnFatalError("OUT OF MEMORY in daskinloader!");

            skinfile[0] = 0;
            return(0);
        }
        else kclose(filh);

        willprint = 1;

        if (pal < (MAXPALOOKUPS - RESERVEDPALS))
            m->usesalpha = hasalpha;
        if ((doalloc&3)==1)
            bglGenTextures(1, texidx);

        bglBindTexture(GL_TEXTURE_2D, *texidx);

        //gluBuild2DMipmaps(GL_TEXTURE_2D,GL_RGBA,xsiz,ysiz,GL_BGRA_EXT,GL_UNSIGNED_BYTE,(char *)fptr);
        if (glinfo.texcompr && glusetexcompr)
            intexfmt = hasalpha ? GL_COMPRESSED_RGBA_ARB : GL_COMPRESSED_RGB_ARB;
        else if (!hasalpha)
            intexfmt = GL_RGB;

        if (glinfo.bgra)
            texfmt = GL_BGRA;

        uploadtexture((doalloc&1), siz, intexfmt, texfmt, (coltype *)fptr, siz, DAMETH_HI);
        Bfree((void *)fptr);
    }

    if (!m->skinloaded)
    {
        if (siz.x != osizx || siz.y != osizy)
        {
            float fx, fy;
            fx = ((float)osizx)/((float)siz.x);
            fy = ((float)osizy)/((float)siz.y);
            if (m->mdnum == 2)
            {
                int32_t *lptr;
                for (lptr=m->glcmds; (i=*lptr++);)
                    for (i=labs(i); i>0; i--,lptr+=3)
                    {
                        ((float *)lptr)[0] *= fx;
                        ((float *)lptr)[1] *= fy;
                    }
            }
            else if (m->mdnum == 3)
            {
                md3model_t *m3 = (md3model_t *)m;
                md3surf_t *s;
                int32_t surfi;
                for (surfi=0; surfi<m3->head.numsurfs; surfi++)
                {
                    s = &m3->head.surfs[surfi];
                    for (i=s->numverts-1; i>=0; i--)
                    {
                        s->uv[i].u *= fx;
                        s->uv[i].v *= fy;
                    }
                }
            }
        }
        m->skinloaded = 1+number;
    }

    bglTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,glfiltermodes[gltexfiltermode].mag);
    bglTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,glfiltermodes[gltexfiltermode].min);
#ifndef EDUKE32_GLES
    if (glinfo.maxanisotropy > 1.0)
        bglTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_ANISOTROPY_EXT,glanisotropy);
#endif
    bglTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
    bglTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);

    if (glinfo.texcompr && glusetexcompr && glusetexcache)
        if (!gotcache)
        {
            const int32_t nonpow2 = check_nonpow2(siz.x) || check_nonpow2(siz.y);

            // save off the compressed version
            cachead.quality = r_downsize;
            cachead.xdim = osizx>>cachead.quality;
            cachead.ydim = osizy>>cachead.quality;

            cachead.flags = nonpow2*CACHEAD_NONPOW2 | (hasalpha ? CACHEAD_HASALPHA : 0);

///            OSD_Printf("Caching \"%s\"\n",fn);
            texcache_writetex(fn, picfillen, pal<<8, hicfxmask(pal), &cachead);

            if (willprint)
            {
                int32_t etime = getticks()-startticks;
                if (etime>=MIN_CACHETIME_PRINT)
                    OSD_Printf("Load skin: p%d-e%d \"%s\"... cached... %d ms\n", pal, hicfxmask(pal), fn, etime);
                willprint = 0;
            }
            else
                OSD_Printf("Cached skin \"%s\"\n", fn);
        }

    if (willprint)
    {
        int32_t etime = getticks()-startticks;
        if (etime>=MIN_CACHETIME_PRINT)
            OSD_Printf("Load skin: p%d-e%d \"%s\"... %d ms\n", pal, hicfxmask(pal), fn, etime);
    }

    return(*texidx);
}

//Note: even though it says md2model, it works for both md2model&md3model
void updateanimation(md2model_t *m, const tspritetype *tspr, uint8_t lpal)
{
    const mdanim_t *anim;
    int32_t i, j, k;
    int32_t fps;

    int32_t tile, smoothdurationp;
    spritesmooth_t *smooth;
    spriteext_t *sprext;

    if (m->numframes < 2)
    {
        m->interpol = 0;
        return;
    }

    tile = Ptile2tile(tspr->picnum,lpal);
    m->cframe = m->nframe = tile2model[tile].framenum;
#ifdef DEBUGGINGAIDS
    if (m->cframe >= m->numframes)
        OSD_Printf("1: c > n\n");
#endif

    smoothdurationp = (r_animsmoothing && (tile2model[tile].smoothduration != 0));

    smooth = ((unsigned)tspr->owner < MAXSPRITES+MAXUNIQHUDID) ? &spritesmooth[tspr->owner] : NULL;
    sprext = ((unsigned)tspr->owner < MAXSPRITES+MAXUNIQHUDID) ? &spriteext[tspr->owner] : NULL;

    for (anim = m->animations; anim && anim->startframe != m->cframe; anim = anim->next)
    {
        /* do nothing */;
    }

    if (!anim)
    {
        if (!smoothdurationp || ((smooth->mdoldframe == m->cframe) && (smooth->mdcurframe == m->cframe)))
        {
            m->interpol = 0;
            return;
        }

        // assert(smoothdurationp && ((smooth->mdoldframe != m->cframe) || (smooth->mdcurframe != m->cframe)))

        if (smooth->mdoldframe != m->cframe)
        {
            if (smooth->mdsmooth == 0)
            {
                sprext->mdanimtims = mdtims;
                m->interpol = 0;
                smooth->mdsmooth = 1;
                smooth->mdcurframe = m->cframe;
            }

            if (smooth->mdcurframe != m->cframe)
            {
                sprext->mdanimtims = mdtims;
                m->interpol = 0;
                smooth->mdsmooth = 1;
                smooth->mdoldframe = smooth->mdcurframe;
                smooth->mdcurframe = m->cframe;
            }
        }
        else  // if (smooth->mdcurframe != m->cframe)
        {
            sprext->mdanimtims = mdtims;
            m->interpol = 0;
            smooth->mdsmooth = 1;
            smooth->mdoldframe = smooth->mdcurframe;
            smooth->mdcurframe = m->cframe;
        }
    }
    else if (/* anim && */ sprext->mdanimcur != anim->startframe)
    {
        //if (sprext->flags & SPREXT_NOMDANIM) OSD_Printf("SPREXT_NOMDANIM\n");
        //OSD_Printf("smooth launched ! oldanim %i new anim %i\n", sprext->mdanimcur, anim->startframe);
        sprext->mdanimcur = (int16_t)anim->startframe;
        sprext->mdanimtims = mdtims;
        m->interpol = 0;

        if (!smoothdurationp)
        {
            m->cframe = m->nframe = anim->startframe;
#ifdef DEBUGGINGAIDS
            if (m->cframe >= m->numframes)
                OSD_Printf("2: c > n\n");
#endif
            return;
        }

        m->nframe = anim->startframe;
        m->cframe = smooth->mdoldframe;
#ifdef DEBUGGINGAIDS
        if (m->cframe >= m->numframes)
            OSD_Printf("3: c > n\n");
#endif
        smooth->mdsmooth = 1;
        return;
    }

    fps = smooth->mdsmooth ? Blrintf((1.0f / (float) (tile2model[tile].smoothduration)) * 66.f) : anim->fpssc;

    i = (mdtims - sprext->mdanimtims)*((fps*timerticspersec)/120);

    if (smooth->mdsmooth)
        j = 65536;
    else
        j = ((anim->endframe+1-anim->startframe)<<16);
    // XXX: Just in case you play the game for a VERY long time...
    if (i < 0) { i = 0; sprext->mdanimtims = mdtims; }
    //compare with j*2 instead of j to ensure i stays > j-65536 for MDANIM_ONESHOT
    if (anim && (i >= j+j) && (fps) && !mdpause) //Keep mdanimtims close to mdtims to avoid the use of MOD
        sprext->mdanimtims += j/((fps*timerticspersec)/120);

    k = i;

    if (anim && (anim->flags&MDANIM_ONESHOT))
        { if (i > j-65536) i = j-65536; }
    else { if (i >= j) { i -= j; if (i >= j) i %= j; } }

    if (r_animsmoothing && smooth->mdsmooth)
    {
        m->nframe = anim ? anim->startframe : smooth->mdcurframe;
        m->cframe = smooth->mdoldframe;
#ifdef DEBUGGINGAIDS
        if (m->cframe >= m->numframes)
            OSD_Printf("4: c > n\n");
#endif
        //OSD_Printf("smoothing... cframe %i nframe %i\n", m->cframe, m->nframe);
        if (k > 65535)
        {
            sprext->mdanimtims = mdtims;
            m->interpol = 0;
            smooth->mdsmooth = 0;
            m->cframe = m->nframe; // = anim ? anim->startframe : smooth->mdcurframe;
#ifdef DEBUGGINGAIDS
            if (m->cframe >= m->numframes)
                OSD_Printf("5: c > n\n");
#endif
            smooth->mdoldframe = m->cframe;
            //OSD_Printf("smooth stopped !\n");
            return;
        }
    }
    else
    {
        m->cframe = (i>>16)+anim->startframe;
#ifdef DEBUGGINGAIDS
        if (m->cframe >= m->numframes)
            OSD_Printf("6: c > n\n");
#endif
        m->nframe = m->cframe+1;
        if (m->nframe > anim->endframe)  // VERIFY: (!(r_animsmoothing && smooth->mdsmooth)) implies (anim!=NULL) ?
            m->nframe = anim->startframe;

        smooth->mdoldframe = m->cframe;
        //OSD_Printf("not smoothing... cframe %i nframe %i\n", m->cframe, m->nframe);
    }

    m->interpol = ((float)(i&65535))/65536.f;
    //OSD_Printf("interpol %f\n", m->interpol);
}

// VBO generation and allocation
static void mdloadvbos(md3model_t *m)
{
    int32_t     i;

    m->vbos = (GLuint *)Xmalloc(m->head.numsurfs * sizeof(GLuint));
    bglGenBuffersARB(m->head.numsurfs, m->vbos);

    i = 0;
    while (i < m->head.numsurfs)
    {
        bglBindBufferARB(GL_ARRAY_BUFFER_ARB, m->vbos[i]);
        bglBufferDataARB(GL_ARRAY_BUFFER_ARB, m->head.surfs[i].numverts * sizeof(md3uv_t), m->head.surfs[i].uv, GL_STATIC_DRAW_ARB);
        i++;
    }
    bglBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
}

//--------------------------------------- MD2 LIBRARY BEGINS ---------------------------------------
static md2model_t *md2load(int32_t fil, const char *filnam)
{
    md2model_t *m;
    md3model_t *m3;
    md3surf_t *s;
    md2frame_t *f;
    md2head_t head;
    char st[BMAX_PATH];
    int32_t i, j, k;

    int32_t ournumskins, ournumglcmds;

    m = (md2model_t *)Xcalloc(1,sizeof(md2model_t));
    m->mdnum = 2; m->scale = .01f;

    kread(fil,(char *)&head,sizeof(md2head_t));
#if B_BIG_ENDIAN != 0
    head.id = B_LITTLE32(head.id);                 head.vers = B_LITTLE32(head.vers);
    head.skinxsiz = B_LITTLE32(head.skinxsiz);     head.skinysiz = B_LITTLE32(head.skinysiz);
    head.framebytes = B_LITTLE32(head.framebytes); head.numskins = B_LITTLE32(head.numskins);
    head.numverts = B_LITTLE32(head.numverts);     head.numuv = B_LITTLE32(head.numuv);
    head.numtris = B_LITTLE32(head.numtris);       head.numglcmds = B_LITTLE32(head.numglcmds);
    head.numframes = B_LITTLE32(head.numframes);   head.ofsskins = B_LITTLE32(head.ofsskins);
    head.ofsuv = B_LITTLE32(head.ofsuv);           head.ofstris = B_LITTLE32(head.ofstris);
    head.ofsframes = B_LITTLE32(head.ofsframes);   head.ofsglcmds = B_LITTLE32(head.ofsglcmds);
    head.ofseof = B_LITTLE32(head.ofseof);
#endif

    if ((head.id != IDP2_MAGIC) || (head.vers != 8)) { Bfree(m); return(0); } //"IDP2"

    ournumskins = head.numskins ? head.numskins : 1;
    ournumglcmds = head.numglcmds ? head.numglcmds : 1;

    m->numskins = head.numskins;
    m->numframes = head.numframes;
    m->numverts = head.numverts;
    m->numglcmds = head.numglcmds;
    m->framebytes = head.framebytes;

    m->frames = (char *)Xmalloc(m->numframes*m->framebytes);
    m->glcmds = (int32_t *)Xmalloc(ournumglcmds*sizeof(int32_t));
    m->tris = (md2tri_t *)Xmalloc(head.numtris*sizeof(md2tri_t));
    m->uv = (md2uv_t *)Xmalloc(head.numuv*sizeof(md2uv_t));

    klseek(fil,head.ofsframes,SEEK_SET);
    if (kread(fil,(char *)m->frames,m->numframes*m->framebytes) != m->numframes*m->framebytes)
        { Bfree(m->uv); Bfree(m->tris); Bfree(m->glcmds); Bfree(m->frames); Bfree(m); return(0); }

    if (m->numglcmds > 0)
    {
        klseek(fil,head.ofsglcmds,SEEK_SET);
        if (kread(fil,(char *)m->glcmds,m->numglcmds*sizeof(int32_t)) != (int32_t)(m->numglcmds*sizeof(int32_t)))
            { Bfree(m->uv); Bfree(m->tris); Bfree(m->glcmds); Bfree(m->frames); Bfree(m); return(0); }
    }

    klseek(fil,head.ofstris,SEEK_SET);
    if (kread(fil,(char *)m->tris,head.numtris*sizeof(md2tri_t)) != (int32_t)(head.numtris*sizeof(md2tri_t)))
        { Bfree(m->uv); Bfree(m->tris); Bfree(m->glcmds); Bfree(m->frames); Bfree(m); return(0); }

    klseek(fil,head.ofsuv,SEEK_SET);
    if (kread(fil,(char *)m->uv,head.numuv*sizeof(md2uv_t)) != (int32_t)(head.numuv*sizeof(md2uv_t)))
        { Bfree(m->uv); Bfree(m->tris); Bfree(m->glcmds); Bfree(m->frames); Bfree(m); return(0); }

#if B_BIG_ENDIAN != 0
    {
        char *f = (char *)m->frames;
        int32_t *l,j;
        md2frame_t *fr;

        for (i = m->numframes-1; i>=0; i--)
        {
            fr = (md2frame_t *)f;
            l = (int32_t *)&fr->mul;
            for (j=5; j>=0; j--) l[j] = B_LITTLE32(l[j]);
            f += m->framebytes;
        }

        for (i = m->numglcmds-1; i>=0; i--)
        {
            m->glcmds[i] = B_LITTLE32(m->glcmds[i]);
        }
        for (i = head.numtris-1; i>=0; i--)
        {
            m->tris[i].v[0] = B_LITTLE16(m->tris[i].v[0]);
            m->tris[i].v[1] = B_LITTLE16(m->tris[i].v[1]);
            m->tris[i].v[2] = B_LITTLE16(m->tris[i].v[2]);
            m->tris[i].u[0] = B_LITTLE16(m->tris[i].u[0]);
            m->tris[i].u[1] = B_LITTLE16(m->tris[i].u[1]);
            m->tris[i].u[2] = B_LITTLE16(m->tris[i].u[2]);
        }
        for (i = head.numuv-1; i>=0; i--)
        {
            m->uv[i].u = B_LITTLE16(m->uv[i].u);
            m->uv[i].v = B_LITTLE16(m->uv[i].v);
        }
    }
#endif

    Bstrcpy(st,filnam);
    for (i=strlen(st)-1; i>0; i--)
        if ((st[i] == '/') || (st[i] == '\\')) { i++; break; }
    if (i<0) i=0;
    st[i] = 0;
    m->basepath = (char *)Xmalloc(i+1);
    Bstrcpy(m->basepath, st);

    m->skinfn = (char *)Xmalloc(ournumskins*64);
    if (m->numskins > 0)
    {
        klseek(fil,head.ofsskins,SEEK_SET);
        if (kread(fil,m->skinfn,64*m->numskins) != 64*m->numskins)
            { Bfree(m->glcmds); Bfree(m->frames); Bfree(m); return(0); }
    }

    m->texid = (GLuint *)Xcalloc(ournumskins, sizeof(GLuint) * (HICEFFECTMASK+1));

    maxmodelverts = max(maxmodelverts, m->numverts);
    maxmodeltris = max(maxmodeltris, head.numtris);

    //return(m);

    // the MD2 is now loaded internally - let's begin the MD3 conversion process
    //OSD_Printf("Beginning md3 conversion.\n");
    m3 = (md3model_t *)Xcalloc(1, sizeof(md3model_t));
    m3->mdnum = 3; m3->texid = 0; m3->scale = m->scale;
    m3->head.id = IDP3_MAGIC; m3->head.vers = 15;

    m3->head.flags = 0;

    m3->head.numframes = m->numframes;
    m3->head.numtags = 0; m3->head.numsurfs = 1;
    m3->head.numskins = 0;

    m3->numskins = m3->head.numskins;
    m3->numframes = m3->head.numframes;

    m3->head.frames = (md3frame_t *)Xcalloc(m3->head.numframes, sizeof(md3frame_t));
    m3->muladdframes = (vec3f_t *)Xcalloc(m->numframes * 2, sizeof(vec3f_t));

    f = (md2frame_t *)(m->frames);

    // frames converting
    i = 0;
    while (i < m->numframes)
    {
        f = (md2frame_t *)&m->frames[i*m->framebytes];
        Bstrcpy(m3->head.frames[i].nam, f->name);
        //OSD_Printf("Copied frame %s.\n", m3->head.frames[i].nam);
        m3->muladdframes[i*2] = f->mul;
        m3->muladdframes[i*2+1] = f->add;
        i++;
    }

    m3->head.tags = NULL;

    m3->head.surfs = (md3surf_t *)Xcalloc(1, sizeof(md3surf_t));
    s = m3->head.surfs;

    // model converting
    s->id = IDP3_MAGIC; s->flags = 0;
    s->numframes = m->numframes; s->numshaders = 0;
    s->numtris = head.numtris;
    s->numverts = head.numtris * 3; // oh man talk about memory effectiveness :((((
    // MD2 is actually more accurate than MD3 in term of uv-mapping, because each triangle has a triangle counterpart on the UV-map.
    // In MD3, each vertex unique UV coordinates, meaning that you have to duplicate vertices if you need non-seamless UV-mapping.

    maxmodelverts = max(maxmodelverts, s->numverts);

    Bstrcpy(s->nam, "Dummy surface from MD2");

    s->shaders = NULL;

    s->tris = (md3tri_t *)Xcalloc(head.numtris, sizeof(md3tri_t));
    s->uv = (md3uv_t *)Xcalloc(s->numverts, sizeof(md3uv_t));
    s->xyzn = (md3xyzn_t *)Xcalloc(s->numverts * m->numframes, sizeof(md3xyzn_t));

    //memoryusage += (s->numverts * m->numframes * sizeof(md3xyzn_t));
    //OSD_Printf("Current model geometry memory usage : %i.\n", memoryusage);

    //OSD_Printf("Number of frames : %i\n", m->numframes);
    //OSD_Printf("Number of triangles : %i\n", head.numtris);
    //OSD_Printf("Number of vertices : %i\n", s->numverts);

    // triangle converting
    i = 0;
    while (i < head.numtris)
    {
        j = 0;
        //OSD_Printf("Triangle : %i\n", i);
        while (j < 3)
        {
            // triangle vertex indexes
            s->tris[i].i[j] = i*3 + j;

            // uv coords
            s->uv[i*3+j].u = (float)(m->uv[m->tris[i].u[j]].u) / (float)(head.skinxsiz);
            s->uv[i*3+j].v = (float)(m->uv[m->tris[i].u[j]].v) / (float)(head.skinysiz);

            // vertices for each frame
            k = 0;
            while (k < m->numframes)
            {
                f = (md2frame_t *)&m->frames[k*m->framebytes];
                s->xyzn[(k*s->numverts) + (i*3) + j].x = (int16_t) (((f->verts[m->tris[i].v[j]].v[0] * f->mul.x) + f->add.x) * 64.f);
                s->xyzn[(k*s->numverts) + (i*3) + j].y = (int16_t) (((f->verts[m->tris[i].v[j]].v[1] * f->mul.y) + f->add.y) * 64.f);
                s->xyzn[(k*s->numverts) + (i*3) + j].z = (int16_t) (((f->verts[m->tris[i].v[j]].v[2] * f->mul.z) + f->add.z) * 64.f);

                k++;
            }
            j++;
        }
        //OSD_Printf("End triangle.\n");
        i++;
    }
    //OSD_Printf("Finished md3 conversion.\n");

    {
        mdskinmap_t *sk;

        sk = (mdskinmap_t *)Xcalloc(1,sizeof(mdskinmap_t));
        sk->palette = 0;
        sk->skinnum = 0;
        sk->surfnum = 0;

        if (m->numskins > 0)
        {
            sk->fn = (char *)Xmalloc(strlen(m->basepath)+strlen(m->skinfn)+1);
            Bstrcpy(sk->fn, m->basepath);
            Bstrcat(sk->fn, m->skinfn);
        }
        m3->skinmap = sk;
    }

    m3->indexes = (uint16_t *)Xmalloc(sizeof(uint16_t) * s->numtris);
    m3->vindexes = (uint16_t *)Xmalloc(sizeof(uint16_t) * s->numtris * 3);
    m3->maxdepths = (float *)Xmalloc(sizeof(float) * s->numtris);

    m3->vbos = NULL;

    // die MD2 ! DIE !
    Bfree(m->texid); Bfree(m->skinfn); Bfree(m->basepath); Bfree(m->uv); Bfree(m->tris); Bfree(m->glcmds); Bfree(m->frames); Bfree(m);

    return((md2model_t *)m3);
}
//---------------------------------------- MD2 LIBRARY ENDS ----------------------------------------

// DICHOTOMIC RECURSIVE SORTING - USED BY MD3DRAW
int32_t partition(uint16_t *indexes, float *depths, int32_t f, int32_t l)
{
    int32_t up = f, down = l;
    float piv = depths[f];
    uint16_t piv2 = indexes[f];
    do
    {
        while ((depths[up] <= piv) && (up < l))
            up++;
        while ((depths[down] > piv)  && (down > f))
            down--;
        if (up < down)
        {
            swapfloat(&depths[up], &depths[down]);
            swapshort(&indexes[up], &indexes[down]);
        }
    }
    while (down > up);
    depths[f] = depths[down], depths[down] = piv;
    indexes[f] = indexes[down], indexes[down] = piv2;
    return down;
}

static inline void quicksort(uint16_t *indexes, float *depths, int32_t first, int32_t last)
{
    int32_t pivIndex;
    if (first >= last) return;
    pivIndex = partition(indexes, depths, first, last);
    if (first < (pivIndex-1)) quicksort(indexes, depths, first, (pivIndex-1));
    if ((pivIndex+1) >= last) return;
    quicksort(indexes, depths, (pivIndex+1), last);
}
// END OF QUICKSORT LIB

//--------------------------------------- MD3 LIBRARY BEGINS ---------------------------------------

static md3model_t *md3load(int32_t fil)
{
    int32_t i, surfi, ofsurf, offs[4], leng[4];
    int32_t maxtrispersurf;
    md3model_t *m;
    md3surf_t *s;

    m = (md3model_t *)Xcalloc(1,sizeof(md3model_t));
    m->mdnum = 3; m->texid = 0; m->scale = .01f;

    m->muladdframes = NULL;

    kread(fil,&m->head,SIZEOF_MD3HEAD_T);

#if B_BIG_ENDIAN != 0
    m->head.id = B_LITTLE32(m->head.id);             m->head.vers = B_LITTLE32(m->head.vers);
    m->head.flags = B_LITTLE32(m->head.flags);       m->head.numframes = B_LITTLE32(m->head.numframes);
    m->head.numtags = B_LITTLE32(m->head.numtags);   m->head.numsurfs = B_LITTLE32(m->head.numsurfs);
    m->head.numskins = B_LITTLE32(m->head.numskins); m->head.ofsframes = B_LITTLE32(m->head.ofsframes);
    m->head.ofstags = B_LITTLE32(m->head.ofstags); m->head.ofssurfs = B_LITTLE32(m->head.ofssurfs);
    m->head.eof = B_LITTLE32(m->head.eof);
#endif

    if ((m->head.id != IDP3_MAGIC) && (m->head.vers != 15)) { Bfree(m); return(0); } //"IDP3"

    m->numskins = m->head.numskins; //<- dead code?
    m->numframes = m->head.numframes;

    ofsurf = m->head.ofssurfs;

    klseek(fil,m->head.ofsframes,SEEK_SET); i = m->head.numframes*sizeof(md3frame_t);
    m->head.frames = (md3frame_t *)Xmalloc(i);
    kread(fil,m->head.frames,i);

    if (m->head.numtags == 0) m->head.tags = NULL;
    else
    {
        klseek(fil,m->head.ofstags,SEEK_SET); i = m->head.numtags*sizeof(md3tag_t);
        m->head.tags = (md3tag_t *)Xmalloc(i);
        kread(fil,m->head.tags,i);
    }

    klseek(fil,m->head.ofssurfs,SEEK_SET);
    m->head.surfs = (md3surf_t *)Xcalloc(m->head.numsurfs, sizeof(md3surf_t));
    // NOTE: We assume that NULL is represented by all-zeros.
    // surfs[0].geometry is for POLYMER_MD_PROCESS_CHECK (else: crashes).
    // surfs[i].geometry is for FREE_SURFS_GEOMETRY.
    Bassert(m->head.surfs[0].geometry == NULL);

#if B_BIG_ENDIAN != 0
    {
        int32_t j, *l;

        for (i = m->head.numframes-1; i>=0; i--)
        {
            l = (int32_t *)&m->head.frames[i].min;
            for (j=3+3+3+1-1; j>=0; j--) l[j] = B_LITTLE32(l[j]);
        }

        for (i = m->head.numtags-1; i>=0; i--)
        {
            l = (int32_t *)&m->head.tags[i].p;
            for (j=3+3+3+3-1; j>=0; j--) l[j] = B_LITTLE32(l[j]);
        }
    }
#endif

    maxtrispersurf = 0;

    for (surfi=0; surfi<m->head.numsurfs; surfi++)
    {
        s = &m->head.surfs[surfi];
        klseek(fil,ofsurf,SEEK_SET); kread(fil,s,SIZEOF_MD3SURF_T);

#if B_BIG_ENDIAN != 0
        {
            int32_t j, *l;
            s->id = B_LITTLE32(s->id);
            l = (int32_t *)&s->flags;
            for (j=1+1+1+1+1+1+1+1+1+1-1; j>=0; j--) l[j] = B_LITTLE32(l[j]);
        }
#endif

        offs[0] = ofsurf+s->ofstris;
        offs[1] = ofsurf+s->ofsshaders;
        offs[2] = ofsurf+s->ofsuv;
        offs[3] = ofsurf+s->ofsxyzn;

        leng[0] = s->numtris*sizeof(md3tri_t);
        leng[1] = s->numshaders*sizeof(md3shader_t);
        leng[2] = s->numverts*sizeof(md3uv_t);
        leng[3] = s->numframes*s->numverts*sizeof(md3xyzn_t);

        //memoryusage += (s->numverts * s->numframes * sizeof(md3xyzn_t));
        //OSD_Printf("Current model geometry memory usage : %i.\n", memoryusage);

        s->tris = (md3tri_t *)Xmalloc((leng[0] + leng[1]) + (leng[2] + leng[3]));

        s->shaders = (md3shader_t *)(((intptr_t)s->tris)+leng[0]);
        s->uv      = (md3uv_t *)(((intptr_t)s->shaders)+leng[1]);
        s->xyzn    = (md3xyzn_t *)(((intptr_t)s->uv)+leng[2]);

        klseek(fil,offs[0],SEEK_SET); kread(fil,s->tris   ,leng[0]);
        klseek(fil,offs[1],SEEK_SET); kread(fil,s->shaders,leng[1]);
        klseek(fil,offs[2],SEEK_SET); kread(fil,s->uv     ,leng[2]);
        klseek(fil,offs[3],SEEK_SET); kread(fil,s->xyzn   ,leng[3]);

#if B_BIG_ENDIAN != 0
        {
            int32_t j, *l;

            for (i=s->numtris-1; i>=0; i--)
            {
                for (j=2; j>=0; j--) s->tris[i].i[j] = B_LITTLE32(s->tris[i].i[j]);
            }
            for (i=s->numshaders-1; i>=0; i--)
            {
                s->shaders[i].i = B_LITTLE32(s->shaders[i].i);
            }
            for (i=s->numverts-1; i>=0; i--)
            {
                l = (int32_t *)&s->uv[i].u;
                l[0] = B_LITTLE32(l[0]);
                l[1] = B_LITTLE32(l[1]);
            }
            for (i=s->numframes*s->numverts-1; i>=0; i--)
            {
                s->xyzn[i].x = (int16_t)B_LITTLE16((uint16_t)s->xyzn[i].x);
                s->xyzn[i].y = (int16_t)B_LITTLE16((uint16_t)s->xyzn[i].y);
                s->xyzn[i].z = (int16_t)B_LITTLE16((uint16_t)s->xyzn[i].z);
            }
        }
#endif
        maxmodelverts = max(maxmodelverts, s->numverts);
        maxmodeltris = max(maxmodeltris, s->numtris);
        maxtrispersurf = max(maxtrispersurf, s->numtris);
        ofsurf += s->ofsend;
    }

    m->indexes = (uint16_t *)Xmalloc(sizeof(uint16_t) * maxtrispersurf);
    m->vindexes = (uint16_t *)Xmalloc(sizeof(uint16_t) * maxtrispersurf * 3);
    m->maxdepths = (float *)Xmalloc(sizeof(float) * maxtrispersurf);

    m->vbos = NULL;

    return(m);
}

static inline void  invertmatrix(float *m, float *out)
{
    float det;

    det  = (m[0] * (m[4]*m[8] - m[5] * m[7]))
         - (m[1] * (m[3]*m[8] - m[5] * m[6]))
         + (m[2] * (m[3]*m[7] - m[4] * m[6]));

    if (det == 0.0f)
    {
        Bmemset(out, 0, sizeof(float) * 9);
        out[8] = out[4] = out[0] = 1.f;
        return;
    }

    det = 1.0f / det;


Rev 5053	Rev 5075
1	//------------------------------------- MD2/MD3 LIBRARY BEGINS -------------------------------------	1	//------------------------------------- MD2/MD3 LIBRARY BEGINS -------------------------------------
2		2
3	#ifdef USE_OPENGL	3	#ifdef USE_OPENGL
4		4
5	#include "compat.h"	5	#include "compat.h"
6	#include "build.h"	6	#include "build.h"
7	#include "glbuild.h"	7	#include "glbuild.h"
8	#include "pragmas.h"	8	#include "pragmas.h"
9	#include "baselayer.h"	9	#include "baselayer.h"
10	#include "engine_priv.h"	10	#include "engine_priv.h"
11	#include "hightile.h"	11	#include "hightile.h"
12	#include "polymost.h"	12	#include "polymost.h"
13	#include "texcache.h"	13	#include "texcache.h"
14	#include "mdsprite.h"	14	#include "mdsprite.h"
15	#include "cache1d.h"	15	#include "cache1d.h"
16	#include "kplib.h"	16	#include "kplib.h"
17	#include "common.h"	17	#include "common.h"
18		18
19	#include <math.h>	19	#include <math.h>
20	#include <float.h>	20	#include <float.h>
21		21
22	static int32_t curextra=MAXTILES;	22	static int32_t curextra=MAXTILES;
23		23
24	#define MIN_CACHETIME_PRINT 10	24	#define MIN_CACHETIME_PRINT 10
25		25
26	static void QuitOnFatalError(const char *msg)	26	static void QuitOnFatalError(const char *msg)
27	{	27	{
28	if (msg)	28	if (msg)
29	initprintf("%s\n", msg);	29	initprintf("%s\n", msg);
30	uninitengine();	30	uninitengine();
31	Bexit(1);	31	Bexit(1);
32	}	32	}
33		33
34		34
35	static int32_t addtileP(int32_t model,int32_t tile,int32_t pallet)	35	static int32_t addtileP(int32_t model,int32_t tile,int32_t pallet)
36	{	36	{
37	// tile >= 0 && tile < MAXTILES	37	// tile >= 0 && tile < MAXTILES
38		38
39	UNREFERENCED_PARAMETER(model);	39	UNREFERENCED_PARAMETER(model);
40	if (curextra==MAXTILES+EXTRATILES-1)	40	if (curextra==MAXTILES+EXTRATILES-1)
41	{	41	{
42	initprintf("warning: max EXTRATILES reached\n");	42	initprintf("warning: max EXTRATILES reached\n");
43	return curextra;	43	return curextra;
44	}	44	}
45		45
46	if (tile2model[tile].modelid==-1)	46	if (tile2model[tile].modelid==-1)
47	{	47	{
48	tile2model[tile].pal=pallet;	48	tile2model[tile].pal=pallet;
49	return tile;	49	return tile;
50	}	50	}
51		51
52	if (tile2model[tile].pal==pallet)	52	if (tile2model[tile].pal==pallet)
53	return tile;	53	return tile;
54		54
55	while (tile2model[tile].next!=-1)	55	while (tile2model[tile].next!=-1)
56	{	56	{
57	tile=tile2model[tile].next;	57	tile=tile2model[tile].next;
58	if (tile2model[tile].pal==pallet)	58	if (tile2model[tile].pal==pallet)
59	return tile;	59	return tile;
60	}	60	}
61		61
62	tile2model[tile].next=curextra;	62	tile2model[tile].next=curextra;
63	tile2model[curextra].pal=pallet;	63	tile2model[curextra].pal=pallet;
64		64
65	return curextra++;	65	return curextra++;
66	}	66	}
67	int32_t Ptile2tile(int32_t tile,int32_t pallet)	67	int32_t Ptile2tile(int32_t tile,int32_t pallet)
68	{	68	{
69	int32_t t=tile;	69	int32_t t=tile;
70	// if(tile>=1550&&tile<=1589){initprintf("(%d, %d)\n",tile,pallet);pallet=0;}	70	// if(tile>=1550&&tile<=1589){initprintf("(%d, %d)\n",tile,pallet);pallet=0;}
71	while ((tile=tile2model[tile].next)!=-1)	71	while ((tile=tile2model[tile].next)!=-1)
72	if (tile2model[tile].pal==pallet)	72	if (tile2model[tile].pal==pallet)
73	return tile;	73	return tile;
74	return t;	74	return t;
75	}	75	}
76		76
77	#define MODELALLOCGROUP 256	77	#define MODELALLOCGROUP 256
78	static int32_t nummodelsalloced = 0;	78	static int32_t nummodelsalloced = 0;
79		79
80	static int32_t maxmodelverts = 0, allocmodelverts = 0;	80	static int32_t maxmodelverts = 0, allocmodelverts = 0;
81	static int32_t maxmodeltris = 0, allocmodeltris = 0;	81	static int32_t maxmodeltris = 0, allocmodeltris = 0;
82	static vec3f_t *vertlist = NULL; //temp array to store interpolated vertices for drawing	82	static vec3f_t *vertlist = NULL; //temp array to store interpolated vertices for drawing
83		83
84	static int32_t allocvbos = 0, curvbo = 0;	84	static int32_t allocvbos = 0, curvbo = 0;
85	static GLuint *vertvbos = NULL;	85	static GLuint *vertvbos = NULL;
86	static GLuint *indexvbos = NULL;	86	static GLuint *indexvbos = NULL;
87		87
88	#ifdef POLYMER	88	#ifdef POLYMER
89	static int32_t *tribuf = NULL;	89	static int32_t *tribuf = NULL;
90	static int32_t tribufverts = 0;	90	static int32_t tribufverts = 0;
91	#endif	91	#endif
92		92
93	static mdmodel_t mdload(const char );	93	static mdmodel_t mdload(const char );
94	static void mdfree(mdmodel_t *);	94	static void mdfree(mdmodel_t *);
95	int32_t globalnoeffect=0;	95	int32_t globalnoeffect=0;
96		96
97	extern int32_t timerticspersec;	97	extern int32_t timerticspersec;
98		98
99	void md_freevbos()	99	void md_freevbos()
100	{	100	{
101	int32_t i;	101	int32_t i;
102		102
103	for (i=0; i<nextmodelid; i++)	103	for (i=0; i<nextmodelid; i++)
104	if (models[i]->mdnum == 3)	104	if (models[i]->mdnum == 3)
105	{	105	{
106	md3model_t m = (md3model_t )models[i];	106	md3model_t m = (md3model_t )models[i];
107	if (m->vbos)	107	if (m->vbos)
108	{	108	{
109	// OSD_Printf("freeing model %d vbo\n",i);	109	// OSD_Printf("freeing model %d vbo\n",i);
110	bglDeleteBuffersARB(m->head.numsurfs, m->vbos);	110	bglDeleteBuffersARB(m->head.numsurfs, m->vbos);
111	Bfree(m->vbos);	111	Bfree(m->vbos);
112	m->vbos = NULL;	112	m->vbos = NULL;
113	}	113	}
114	}	114	}
115		115
116	if (allocvbos)	116	if (allocvbos)
117	{	117	{
118	bglDeleteBuffersARB(allocvbos, indexvbos);	118	bglDeleteBuffersARB(allocvbos, indexvbos);
119	bglDeleteBuffersARB(allocvbos, vertvbos);	119	bglDeleteBuffersARB(allocvbos, vertvbos);
120	allocvbos = 0;	120	allocvbos = 0;
121	}	121	}
122	}	122	}
123		123
124	void freeallmodels()	124	void freeallmodels()
125	{	125	{
126	int32_t i;	126	int32_t i;
127		127
128	if (models)	128	if (models)
129	{	129	{
130	for (i=0; i<nextmodelid; i++) mdfree(models[i]);	130	for (i=0; i<nextmodelid; i++) mdfree(models[i]);
131	Bfree(models); models = NULL;	131	Bfree(models); models = NULL;
132	nummodelsalloced = 0;	132	nummodelsalloced = 0;
133	nextmodelid = 0;	133	nextmodelid = 0;
134	}	134	}
135		135
136	memset(tile2model,-1,sizeof(tile2model));	136	memset(tile2model,-1,sizeof(tile2model));
137	curextra=MAXTILES;	137	curextra=MAXTILES;
138		138
139	if (vertlist)	139	if (vertlist)
140	{	140	{
141	Bfree(vertlist);	141	Bfree(vertlist);
142	vertlist = NULL;	142	vertlist = NULL;
143	allocmodelverts = maxmodelverts = 0;	143	allocmodelverts = maxmodelverts = 0;
144	allocmodeltris = maxmodeltris = 0;	144	allocmodeltris = maxmodeltris = 0;
145	}	145	}
146		146
147	md_freevbos();	147	md_freevbos();
148	#ifdef POLYMER	148	#ifdef POLYMER
149	DO_FREE_AND_NULL(tribuf);	149	DO_FREE_AND_NULL(tribuf);
150	#endif	150	#endif
151	}	151	}
152		152
153		153
154	// Skin texture names can be aliased! This is ugly, but at least correct.	154	// Skin texture names can be aliased! This is ugly, but at least correct.
155	static void nullskintexids(GLuint texid)	155	static void nullskintexids(GLuint texid)
156	{	156	{
157	int32_t i, j;	157	int32_t i, j;
158		158
159	for (i=0; i<nextmodelid; i++)	159	for (i=0; i<nextmodelid; i++)
160	{	160	{
161	mdmodel_t *m = models[i];	161	mdmodel_t *m = models[i];
162		162
163	if (m->mdnum == 2 \|\| m->mdnum == 3)	163	if (m->mdnum == 2 \|\| m->mdnum == 3)
164	{	164	{
165	mdskinmap_t *sk;	165	mdskinmap_t *sk;
166	md2model_t m2 = (md2model_t )m;	166	md2model_t m2 = (md2model_t )m;
167		167
168	for (j=0; j<m2->numskins*(HICEFFECTMASK+1); j++)	168	for (j=0; j<m2->numskins*(HICEFFECTMASK+1); j++)
169	if (m2->texid[j] == texid)	169	if (m2->texid[j] == texid)
170	m2->texid[j] = 0;	170	m2->texid[j] = 0;
171		171
172	for (sk=m2->skinmap; sk; sk=sk->next)	172	for (sk=m2->skinmap; sk; sk=sk->next)
173	for (j=0; j<(HICEFFECTMASK+1); j++)	173	for (j=0; j<(HICEFFECTMASK+1); j++)
174	if (sk->texid[j] == texid)	174	if (sk->texid[j] == texid)
175	sk->texid[j] = 0;	175	sk->texid[j] = 0;
176	}	176	}
177	}	177	}
178	}	178	}
179		179
180	void clearskins()	180	void clearskins()
181	{	181	{
182	int32_t i, j;	182	int32_t i, j;
183		183
184	for (i=0; i<nextmodelid; i++)	184	for (i=0; i<nextmodelid; i++)
185	{	185	{
186	mdmodel_t *m = models[i];	186	mdmodel_t *m = models[i];
187		187
188	if (m->mdnum == 1)	188	if (m->mdnum == 1)
189	{	189	{
190	voxmodel_t v = (voxmodel_t )m;	190	voxmodel_t v = (voxmodel_t )m;
191		191
192	for (j=0; j<MAXPALOOKUPS; j++)	192	for (j=0; j<MAXPALOOKUPS; j++)
193	if (v->texid[j])	193	if (v->texid[j])
194	{	194	{
195	bglDeleteTextures(1, &v->texid[j]);	195	bglDeleteTextures(1, &v->texid[j]);
196	v->texid[j] = 0;	196	v->texid[j] = 0;
197	}	197	}
198	}	198	}
199	else if (m->mdnum == 2 \|\| m->mdnum == 3)	199	else if (m->mdnum == 2 \|\| m->mdnum == 3)
200	{	200	{
201	mdskinmap_t *sk;	201	mdskinmap_t *sk;
202	md2model_t m2 = (md2model_t )m;	202	md2model_t m2 = (md2model_t )m;
203		203
204	for (j=0; j<m2->numskins*(HICEFFECTMASK+1); j++)	204	for (j=0; j<m2->numskins*(HICEFFECTMASK+1); j++)
205	if (m2->texid[j])	205	if (m2->texid[j])
206	{	206	{
207	GLuint otexid = m2->texid[j];	207	GLuint otexid = m2->texid[j];
208		208
209	bglDeleteTextures(1, &m2->texid[j]);	209	bglDeleteTextures(1, &m2->texid[j]);
210	m2->texid[j] = 0;	210	m2->texid[j] = 0;
211		211
212	nullskintexids(otexid);	212	nullskintexids(otexid);
213	}	213	}
214		214
215	for (sk=m2->skinmap; sk; sk=sk->next)	215	for (sk=m2->skinmap; sk; sk=sk->next)
216	for (j=0; j<(HICEFFECTMASK+1); j++)	216	for (j=0; j<(HICEFFECTMASK+1); j++)
217	if (sk->texid[j])	217	if (sk->texid[j])
218	{	218	{
219	GLuint otexid = sk->texid[j];	219	GLuint otexid = sk->texid[j];
220		220
221	bglDeleteTextures(1, &sk->texid[j]);	221	bglDeleteTextures(1, &sk->texid[j]);
222	sk->texid[j] = 0;	222	sk->texid[j] = 0;
223		223
224	nullskintexids(otexid);	224	nullskintexids(otexid);
225	}	225	}
226	}	226	}
227	}	227	}
228		228
229	for (i=0; i<MAXVOXELS; i++)	229	for (i=0; i<MAXVOXELS; i++)
230	{	230	{
231	voxmodel_t *v = voxmodels[i];	231	voxmodel_t *v = voxmodels[i];
232	if (!v) continue;	232	if (!v) continue;
233		233
234	for (j=0; j<MAXPALOOKUPS; j++)	234	for (j=0; j<MAXPALOOKUPS; j++)
235	if (v->texid[j])	235	if (v->texid[j])
236	{	236	{
237	bglDeleteTextures(1, &v->texid[j]);	237	bglDeleteTextures(1, &v->texid[j]);
238	v->texid[j] = 0;	238	v->texid[j] = 0;
239	}	239	}
240	}	240	}
241	}	241	}
242		242
243	void mdinit()	243	void mdinit()
244	{	244	{
245	memset(hudmem,0,sizeof(hudmem));	245	memset(hudmem,0,sizeof(hudmem));
246	freeallmodels();	246	freeallmodels();
247	mdinited = 1;	247	mdinited = 1;
248	}	248	}
249		249
250	int32_t md_loadmodel(const char *fn)	250	int32_t md_loadmodel(const char *fn)
251	{	251	{
252	mdmodel_t vm, *ml;	252	mdmodel_t vm, *ml;
253		253
254	if (!mdinited) mdinit();	254	if (!mdinited) mdinit();
255		255
256	if (nextmodelid >= nummodelsalloced)	256	if (nextmodelid >= nummodelsalloced)
257	{	257	{
258	ml = (mdmodel_t *)Xrealloc(models,(nummodelsalloced+MODELALLOCGROUP)sizeof(void *));	258	ml = (mdmodel_t *)Xrealloc(models,(nummodelsalloced+MODELALLOCGROUP)sizeof(void *));
259	models = ml; nummodelsalloced += MODELALLOCGROUP;	259	models = ml; nummodelsalloced += MODELALLOCGROUP;
260	}	260	}
261		261
262	vm = mdload(fn); if (!vm) return(-1);	262	vm = mdload(fn); if (!vm) return(-1);
263	models[nextmodelid++] = vm;	263	models[nextmodelid++] = vm;
264	return(nextmodelid-1);	264	return(nextmodelid-1);
265	}	265	}
266		266
267	int32_t md_setmisc(int32_t modelid, float scale, int32_t shadeoff, float zadd, float yoffset, int32_t flags)	267	int32_t md_setmisc(int32_t modelid, float scale, int32_t shadeoff, float zadd, float yoffset, int32_t flags)
268	{	268	{
269	mdmodel_t *m;	269	mdmodel_t *m;
270		270
271	if (!mdinited) mdinit();	271	if (!mdinited) mdinit();
272		272
273	if ((uint32_t)modelid >= (uint32_t)nextmodelid) return -1;	273	if ((uint32_t)modelid >= (uint32_t)nextmodelid) return -1;
274	m = models[modelid];	274	m = models[modelid];
275	m->bscale = scale;	275	m->bscale = scale;
276	m->shadeoff = shadeoff;	276	m->shadeoff = shadeoff;
277	m->zadd = zadd;	277	m->zadd = zadd;
278	m->yoffset = yoffset;	278	m->yoffset = yoffset;
279	m->flags = flags;	279	m->flags = flags;
280		280
281	return 0;	281	return 0;
282	}	282	}
283		283
284	static int32_t framename2index(mdmodel_t vm, const char nam)	284	static int32_t framename2index(mdmodel_t vm, const char nam)
285	{	285	{
286	int32_t i = 0;	286	int32_t i = 0;
287		287
288	switch (vm->mdnum)	288	switch (vm->mdnum)
289	{	289	{
290	case 2:	290	case 2:
291	{	291	{
292	md2model_t m = (md2model_t )vm;	292	md2model_t m = (md2model_t )vm;
293	md2frame_t *fr;	293	md2frame_t *fr;
294	for (i=0; i<m->numframes; i++)	294	for (i=0; i<m->numframes; i++)
295	{	295	{
296	fr = (md2frame_t )&m->frames[im->framebytes];	296	fr = (md2frame_t )&m->frames[im->framebytes];
297	if (!Bstrcmp(fr->name, nam)) break;	297	if (!Bstrcmp(fr->name, nam)) break;
298	}	298	}
299	}	299	}
300	break;	300	break;
301	case 3:	301	case 3:
302	{	302	{
303	md3model_t m = (md3model_t )vm;	303	md3model_t m = (md3model_t )vm;
304	for (i=0; i<m->numframes; i++)	304	for (i=0; i<m->numframes; i++)
305	if (!Bstrcmp(m->head.frames[i].nam,nam)) break;	305	if (!Bstrcmp(m->head.frames[i].nam,nam)) break;
306	}	306	}
307	break;	307	break;
308	}	308	}
309	return(i);	309	return(i);
310	}	310	}
311		311
312	int32_t md_defineframe(int32_t modelid, const char *framename, int32_t tilenume, int32_t skinnum, float smoothduration, int32_t pal)	312	int32_t md_defineframe(int32_t modelid, const char *framename, int32_t tilenume, int32_t skinnum, float smoothduration, int32_t pal)
313	{	313	{
314	md2model_t *m;	314	md2model_t *m;
315	int32_t i;	315	int32_t i;
316		316
317	if (!mdinited) mdinit();	317	if (!mdinited) mdinit();
318		318
319	if ((uint32_t)modelid >= (uint32_t)nextmodelid) return(-1);	319	if ((uint32_t)modelid >= (uint32_t)nextmodelid) return(-1);
320	if ((uint32_t)tilenume >= (uint32_t)MAXTILES) return(-2);	320	if ((uint32_t)tilenume >= (uint32_t)MAXTILES) return(-2);
321	if (!framename) return(-3);	321	if (!framename) return(-3);
322		322
323	tilenume=addtileP(modelid,tilenume,pal);	323	tilenume=addtileP(modelid,tilenume,pal);
324	m = (md2model_t *)models[modelid];	324	m = (md2model_t *)models[modelid];
325	if (m->mdnum == 1)	325	if (m->mdnum == 1)
326	{	326	{
327	tile2model[tilenume].modelid = modelid;	327	tile2model[tilenume].modelid = modelid;
328	tile2model[tilenume].framenum = tile2model[tilenume].skinnum = 0;	328	tile2model[tilenume].framenum = tile2model[tilenume].skinnum = 0;
329	return 0;	329	return 0;
330	}	330	}
331		331
332	i = framename2index((mdmodel_t *)m,framename);	332	i = framename2index((mdmodel_t *)m,framename);
333	if (i == m->numframes) return(-3); // frame name invalid	333	if (i == m->numframes) return(-3); // frame name invalid
334		334
335	tile2model[tilenume].modelid = modelid;	335	tile2model[tilenume].modelid = modelid;
336	tile2model[tilenume].framenum = i;	336	tile2model[tilenume].framenum = i;
337	tile2model[tilenume].skinnum = skinnum;	337	tile2model[tilenume].skinnum = skinnum;
338	tile2model[tilenume].smoothduration = smoothduration;	338	tile2model[tilenume].smoothduration = smoothduration;
339		339
340	return i;	340	return i;
341	}	341	}
342		342
343	int32_t md_defineanimation(int32_t modelid, const char framestart, const char frameend, int32_t fpssc, int32_t flags)	343	int32_t md_defineanimation(int32_t modelid, const char framestart, const char frameend, int32_t fpssc, int32_t flags)
344	{	344	{
345	md2model_t *m;	345	md2model_t *m;
346	mdanim_t ma, *map;	346	mdanim_t ma, *map;
347	int32_t i;	347	int32_t i;
348		348
349	if (!mdinited) mdinit();	349	if (!mdinited) mdinit();
350		350
351	if ((uint32_t)modelid >= (uint32_t)nextmodelid) return(-1);	351	if ((uint32_t)modelid >= (uint32_t)nextmodelid) return(-1);
352		352
353	Bmemset(&ma, 0, sizeof(ma));	353	Bmemset(&ma, 0, sizeof(ma));
354	m = (md2model_t *)models[modelid];	354	m = (md2model_t *)models[modelid];
355	if (m->mdnum < 2) return 0;	355	if (m->mdnum < 2) return 0;
356		356
357	//find index of start frame	357	//find index of start frame
358	i = framename2index((mdmodel_t *)m,framestart);	358	i = framename2index((mdmodel_t *)m,framestart);
359	if (i == m->numframes) return -2;	359	if (i == m->numframes) return -2;
360	ma.startframe = i;	360	ma.startframe = i;
361		361
362	//find index of finish frame which must trail start frame	362	//find index of finish frame which must trail start frame
363	i = framename2index((mdmodel_t *)m,frameend);	363	i = framename2index((mdmodel_t *)m,frameend);
364	if (i == m->numframes) return -3;	364	if (i == m->numframes) return -3;
365	ma.endframe = i;	365	ma.endframe = i;
366		366
367	ma.fpssc = fpssc;	367	ma.fpssc = fpssc;
368	ma.flags = flags;	368	ma.flags = flags;
369		369
370	map = (mdanim_t *)Xmalloc(sizeof(mdanim_t));	370	map = (mdanim_t *)Xmalloc(sizeof(mdanim_t));
371		371
372	Bmemcpy(map, &ma, sizeof(ma));	372	Bmemcpy(map, &ma, sizeof(ma));
373		373
374	map->next = m->animations;	374	map->next = m->animations;
375	m->animations = map;	375	m->animations = map;
376		376
377	return(0);	377	return(0);
378	}	378	}
379		379
380	#if 0	380	#if 0
381	// FIXME: CURRENTLY DISABLED: interpolation may access frames we consider 'unused'?	381	// FIXME: CURRENTLY DISABLED: interpolation may access frames we consider 'unused'?
382	int32_t md_thinoutmodel(int32_t modelid, uint8_t *usedframebitmap)	382	int32_t md_thinoutmodel(int32_t modelid, uint8_t *usedframebitmap)
383	{	383	{
384	md3model_t *m;	384	md3model_t *m;
385	md3surf_t *s;	385	md3surf_t *s;
386	mdanim_t *anm;	386	mdanim_t *anm;
387	int32_t i, surfi, sub, usedframes;	387	int32_t i, surfi, sub, usedframes;
388	static int16_t otonframe[1024];	388	static int16_t otonframe[1024];
389		389
390	if ((uint32_t)modelid >= (uint32_t)nextmodelid) return -1;	390	if ((uint32_t)modelid >= (uint32_t)nextmodelid) return -1;
391	m = (md3model_t *)models[modelid];	391	m = (md3model_t *)models[modelid];
392	if (m->mdnum != 3) return -2;	392	if (m->mdnum != 3) return -2;
393		393
394	for (anm=m->animations; anm; anm=anm->next)	394	for (anm=m->animations; anm; anm=anm->next)
395	{	395	{
396	if (anm->endframe <= anm->startframe)	396	if (anm->endframe <= anm->startframe)
397	{	397	{
398	// initprintf("backward anim %d-%d\n", anm->startframe, anm->endframe);	398	// initprintf("backward anim %d-%d\n", anm->startframe, anm->endframe);
399	return -3;	399	return -3;
400	}	400	}
401		401
402	for (i=anm->startframe; i<anm->endframe; i++)	402	for (i=anm->startframe; i<anm->endframe; i++)
403	usedframebitmap[i>>3] \|= (1<<(i&7));	403	usedframebitmap[i>>3] \|= (1<<(i&7));
404	}	404	}
405		405
406	sub = 0;	406	sub = 0;
407	for (i=0; i<m->numframes; i++)	407	for (i=0; i<m->numframes; i++)
408	{	408	{
409	if (!(usedframebitmap[i>>3]&(1<<(i&7))))	409	if (!(usedframebitmap[i>>3]&(1<<(i&7))))
410	{	410	{
411	sub++;	411	sub++;
412	otonframe[i] = -1;	412	otonframe[i] = -1;
413	continue;	413	continue;
414	}	414	}
415		415
416	otonframe[i] = i-sub;	416	otonframe[i] = i-sub;
417	}	417	}
418		418
419	usedframes = m->numframes - sub;	419	usedframes = m->numframes - sub;
420	if (usedframes==0 \|\| usedframes==m->numframes)	420	if (usedframes==0 \|\| usedframes==m->numframes)
421	return usedframes;	421	return usedframes;
422		422
423	//// THIN OUT! ////	423	//// THIN OUT! ////
424		424
425	for (i=0; i<m->numframes; i++)	425	for (i=0; i<m->numframes; i++)
426	{	426	{
427	if (otonframe[i]>=0 && otonframe[i] != i)	427	if (otonframe[i]>=0 && otonframe[i] != i)
428	{	428	{
429	if (m->muladdframes)	429	if (m->muladdframes)
430	Bmemcpy(&m->muladdframes[2otonframe[i]], &m->muladdframes[2i], 2*sizeof(vec3f_t));	430	Bmemcpy(&m->muladdframes[2otonframe[i]], &m->muladdframes[2i], 2*sizeof(vec3f_t));
431	Bmemcpy(&m->head.frames[otonframe[i]], &m->head.frames[i], sizeof(md3frame_t));	431	Bmemcpy(&m->head.frames[otonframe[i]], &m->head.frames[i], sizeof(md3frame_t));
432	}	432	}
433	}	433	}
434		434
435	for (surfi=0; surfi < m->head.numsurfs; surfi++)	435	for (surfi=0; surfi < m->head.numsurfs; surfi++)
436	{	436	{
437	s = &m->head.surfs[surfi];	437	s = &m->head.surfs[surfi];
438		438
439	for (i=0; i<m->numframes; i++)	439	for (i=0; i<m->numframes; i++)
440	if (otonframe[i]>=0 && otonframe[i] != i)	440	if (otonframe[i]>=0 && otonframe[i] != i)
441	Bmemcpy(&s->xyzn[otonframe[i]s->numverts], &s->xyzn[is->numverts], s->numverts*sizeof(md3xyzn_t));	441	Bmemcpy(&s->xyzn[otonframe[i]s->numverts], &s->xyzn[is->numverts], s->numverts*sizeof(md3xyzn_t));
442	}	442	}
443		443
444	////// tweak frame indices in various places	444	////// tweak frame indices in various places
445		445
446	for (anm=m->animations; anm; anm=anm->next)	446	for (anm=m->animations; anm; anm=anm->next)
447	{	447	{
448	if (otonframe[anm->startframe]==-1 \|\| otonframe[anm->endframe-1]==-1)	448	if (otonframe[anm->startframe]==-1 \|\| otonframe[anm->endframe-1]==-1)
449	initprintf("md %d WTF: anm %d %d\n", modelid, anm->startframe, anm->endframe);	449	initprintf("md %d WTF: anm %d %d\n", modelid, anm->startframe, anm->endframe);
450		450
451	anm->startframe = otonframe[anm->startframe];	451	anm->startframe = otonframe[anm->startframe];
452	anm->endframe = otonframe[anm->endframe-1];	452	anm->endframe = otonframe[anm->endframe-1];
453	}	453	}
454		454
455	for (i=0; i<MAXTILES+EXTRATILES; i++)	455	for (i=0; i<MAXTILES+EXTRATILES; i++)
456	if (tile2model[i].modelid == modelid)	456	if (tile2model[i].modelid == modelid)
457	{	457	{
458	if (otonframe[tile2model[i].framenum]==-1)	458	if (otonframe[tile2model[i].framenum]==-1)
459	initprintf("md %d WTF: tile %d, fr %d\n", modelid, i, tile2model[i].framenum);	459	initprintf("md %d WTF: tile %d, fr %d\n", modelid, i, tile2model[i].framenum);
460	tile2model[i].framenum = otonframe[tile2model[i].framenum];	460	tile2model[i].framenum = otonframe[tile2model[i].framenum];
461	}	461	}
462		462
463	////// realloc & change "numframes" everywhere	463	////// realloc & change "numframes" everywhere
464		464
465	if (m->muladdframes)	465	if (m->muladdframes)
466	m->muladdframes = Xrealloc(m->muladdframes, 2sizeof(vec3f_t)usedframes);	466	m->muladdframes = Xrealloc(m->muladdframes, 2sizeof(vec3f_t)usedframes);
467	m->head.frames = Xrealloc(m->head.frames, sizeof(md3frame_t)*usedframes);	467	m->head.frames = Xrealloc(m->head.frames, sizeof(md3frame_t)*usedframes);
468		468
469	for (surfi=0; surfi < m->head.numsurfs; surfi++)	469	for (surfi=0; surfi < m->head.numsurfs; surfi++)
470	{	470	{
471	m->head.surfs[surfi].numframes = usedframes;	471	m->head.surfs[surfi].numframes = usedframes;
472	// CAN'T do that because xyzn is offset from a larger block when loaded from md3:	472	// CAN'T do that because xyzn is offset from a larger block when loaded from md3:
473	// m->head.surfs[surfi].xyzn = Xrealloc(m->head.surfs[surfi].xyzn, s->numvertsusedframessizeof(md3xyzn_t));	473	// m->head.surfs[surfi].xyzn = Xrealloc(m->head.surfs[surfi].xyzn, s->numvertsusedframessizeof(md3xyzn_t));
474	}	474	}
475		475
476	m->head.numframes = usedframes;	476	m->head.numframes = usedframes;
477	m->numframes = usedframes;	477	m->numframes = usedframes;
478		478
479	////////////	479	////////////
480	return usedframes;	480	return usedframes;
481	}	481	}
482	#endif	482	#endif
483		483
484	int32_t md_defineskin(int32_t modelid, const char *skinfn, int32_t palnum, int32_t skinnum, int32_t surfnum, float param, float specpower, float specfactor)	484	int32_t md_defineskin(int32_t modelid, const char *skinfn, int32_t palnum, int32_t skinnum, int32_t surfnum, float param, float specpower, float specfactor)
485	{	485	{
486	mdskinmap_t sk, skl;	486	mdskinmap_t sk, skl;
487	md2model_t *m;	487	md2model_t *m;
488		488
489	if (!mdinited) mdinit();	489	if (!mdinited) mdinit();
490		490
491	if ((uint32_t)modelid >= (uint32_t)nextmodelid) return -1;	491	if ((uint32_t)modelid >= (uint32_t)nextmodelid) return -1;
492	if (!skinfn) return -2;	492	if (!skinfn) return -2;
493	if ((unsigned)palnum >= (unsigned)MAXPALOOKUPS) return -3;	493	if ((unsigned)palnum >= (unsigned)MAXPALOOKUPS) return -3;
494		494
495	m = (md2model_t *)models[modelid];	495	m = (md2model_t *)models[modelid];
496	if (m->mdnum < 2) return 0;	496	if (m->mdnum < 2) return 0;
497	if (m->mdnum == 2) surfnum = 0;	497	if (m->mdnum == 2) surfnum = 0;
498		498
499	skl = NULL;	499	skl = NULL;
500	for (sk = m->skinmap; sk; skl = sk, sk = sk->next)	500	for (sk = m->skinmap; sk; skl = sk, sk = sk->next)

Subversion Repositories eduke32

(root)/polymer/eduke32/build/src/mdsprite.c – Rev 5053 → 5075