aselib.cpp

Go to the documentation of this file.

 
/*
Copyright (C) 1999-2007 id Software, Inc. and contributors.
For a list of contributors, see the accompanying CONTRIBUTORS file.
 
This file is part of GtkRadiant.
 
GtkRadiant 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.
 
GtkRadiant 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 GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/
 
#include "aselib.h"
#include "../bsp.h"
#include "shared.h"
 
#define MAX_ASE_MATERIALS           32
#define MAX_ASE_OBJECTS             64
#define MAX_ASE_ANIMATIONS          32
#define MAX_ASE_ANIMATION_FRAMES    512
 
#define VERBOSE(x) { if (ase.verbose) { Com_Printf x; } }
 
typedef struct {
    float x, y, z;
    float nx, ny, nz;
    float s, t;
} aseVertex_t;
 
typedef struct {
    float s, t;
} aseTVertex_t;
 
typedef int aseFace_t[3];
 
typedef struct {
    int numFaces;
    int numVertexes;
    int numTVertexes;
 
    int timeValue;
 
    aseVertex_t* vertexes;
    aseTVertex_t* tvertexes;
    aseFace_t* faces, *tfaces;
 
    int currentFace, currentVertex;
} aseMesh_t;
 
typedef struct {
    int numFrames;
    aseMesh_t frames[MAX_ASE_ANIMATION_FRAMES];
 
    int currentFrame;
} aseMeshAnimation_t;
 
typedef struct {
    char name[MAX_QPATH];
} aseMaterial_t;

typedef struct {
    char name[MAX_QPATH];
 
    int materialRef;
    int numAnimations;
 
    aseMeshAnimation_t anim;
} aseGeomObject_t;
 
typedef struct {
    int numMaterials;
    aseMaterial_t materials[MAX_ASE_MATERIALS];
    aseGeomObject_t objects[MAX_ASE_OBJECTS];
 
    char* buffer;
    char* curpos;
    int len;
 
    int currentObject;
    bool verbose;
} ase_t;
 
static char s_token[1024];
static ase_t ase;
 
static void ASE_Process(void);
static void ASE_FreeGeomObject(int ndx);
 
void ASE_Load (const char* filename, bool verbose)
{
    ScopedFile file;
    FS_OpenFile(filename, &file, FILE_READ);
    if (!file)
        Sys_Error("File not found '%s'", filename);
 
    OBJZERO(ase);
 
    ase.verbose = verbose;
    ase.len = FS_FileLength(&file);
 
    ase.curpos = ase.buffer = Mem_AllocTypeN(char, ase.len);
    if (!ase.curpos)
        Sys_Error("Could not allocate memory for ase loading");
 
    Verb_Printf(VERB_EXTRA, "Processing '%s'\n", filename);
 
    if (FS_Read(ase.buffer, ase.len, &file) != 1) {
        Sys_Error("fread() != -1 for '%s'", filename);
    }
 
    ASE_Process();
}
 
void ASE_Free (void)
{
    for (int i = 0; i < ase.currentObject; i++)
        ASE_FreeGeomObject(i);
}
 
int ASE_GetNumSurfaces (void)
{
    return ase.currentObject;
}
 
const char* ASE_GetSurfaceName (int which)
{
    aseGeomObject_t* pObject = &ase.objects[which];
 
    if (!pObject->anim.numFrames)
        return 0;
 
    return pObject->name;
}

polyset_t* ASE_GetSurfaceAnimation (int whichSurface)
{
    aseGeomObject_t* pObject = &ase.objects[whichSurface];
    polyset_t* psets;
    int numFramesInAnimation;
    int i, f;
 
    if (!pObject->anim.numFrames)
        return 0;
 
    numFramesInAnimation = pObject->anim.numFrames;
 
    psets = Mem_AllocTypeN(polyset_t, numFramesInAnimation);
 
    for (f = 0, i = 0; i < numFramesInAnimation; i++) {
        int t;
        aseMesh_t* pMesh = &pObject->anim.frames[i];
        polyset_t* ps = &psets[f];
 
        strcpy(ps->name, pObject->name);
        strcpy(ps->materialname, ase.materials[pObject->materialRef].name);
 
        ps->triangles = Mem_AllocTypeN(triangle_t, pObject->anim.frames[i].numFaces);
        ps->numtriangles = pObject->anim.frames[i].numFaces;
 
        for (t = 0; t < pObject->anim.frames[i].numFaces; t++) {
            for (int k = 0; k < 3; k++) {
                triangle_t* tri = &ps->triangles[t];
                const int vIdx = pMesh->faces[t][k];
                aseVertex_t* v = &pMesh->vertexes[vIdx];
                VectorSet(tri->verts[k], v->x, v->y, v->z);
 
                if (pMesh->tvertexes && pMesh->tfaces) {
                    aseTVertex_t* tv = &pMesh->tvertexes[pMesh->tfaces[t][k]];
                    Vector2Set(tri->texcoords[k], tv->s, tv->t);
                }
            }
        }
 
        f++;
    }
 
    return psets;
}
 
static void ASE_FreeGeomObject (int ndx)
{
    aseGeomObject_t* pObject = &ase.objects[ndx];
 
    for (int i = 0; i < pObject->anim.numFrames; i++) {
        Mem_Free(pObject->anim.frames[i].vertexes);
        Mem_Free(pObject->anim.frames[i].tvertexes);
        Mem_Free(pObject->anim.frames[i].faces);
        Mem_Free(pObject->anim.frames[i].tfaces);
    }
 
    OBJZERO(*pObject);
}
 
static aseMesh_t* ASE_GetCurrentMesh (void)
{
    aseGeomObject_t* pObject;
 
    if (ase.currentObject >= MAX_ASE_OBJECTS)
        Sys_Error("Too many GEOMOBJECTs");
 
    pObject = &ase.objects[ase.currentObject];
 
    if (pObject->anim.currentFrame >= MAX_ASE_ANIMATION_FRAMES)
        Sys_Error("Too many MESHes");
 
    return &pObject->anim.frames[pObject->anim.currentFrame];
}
 
static inline int CharIsTokenDelimiter (int ch)
{
    if (ch <= ' ')
        return 1;
    return 0;
}
 
static int ASE_GetToken (bool restOfLine)
{
    int i = 0;
 
    if (ase.buffer == 0)
        return 0;
 
    if ((ase.curpos - ase.buffer) == ase.len)
        return 0;
 
    /* skip over crap */
    while (ase.curpos - ase.buffer < ase.len && *ase.curpos <= ' ') {
        ase.curpos++;
    }
 
    while ((ase.curpos - ase.buffer) < ase.len) {
        s_token[i] = *ase.curpos;
 
        ase.curpos++;
        i++;
 
        if ((CharIsTokenDelimiter(s_token[i - 1]) && !restOfLine) ||
            (s_token[i - 1] == '\n' || s_token[i - 1] == '\r')) {
            s_token[i - 1] = 0;
            break;
        }
    }
 
    s_token[i] = 0;
 
    return 1;
}
 
static void ASE_ParseBracedBlock (void (*parser)(const char* token))
{
    int indent = 0;
 
    while (ASE_GetToken(false)) {
        if (Q_streq(s_token, "{")) {
            indent++;
        } else if (Q_streq(s_token, "}")) {
            --indent;
            if (indent == 0)
                break;
            else if (indent < 0)
                Sys_Error("Unexpected '}'");
        } else {
            if (parser)
                parser(s_token);
        }
    }
}
 
static void ASE_SkipEnclosingBraces (void)
{
    int indent = 0;
 
    while (ASE_GetToken(false)) {
        if (Q_streq(s_token, "{")) {
            indent++;
        } else if (Q_streq(s_token, "}")) {
            indent--;
            if (indent == 0)
                break;
            else if (indent < 0)
                Sys_Error("Unexpected '}'");
        }
    }
}
 
static void ASE_SkipRestOfLine (void)
{
    ASE_GetToken(true);
}
 
static void ASE_KeyMAP_DIFFUSE (const char* token)
{
    if (Q_streq(token, "*BITMAP")) {
        const char* bitmap;
        size_t len;
 
        ASE_GetToken(false);
 
        /* skip the " */
        bitmap = &s_token[1];
        len = strlen(bitmap) - 1;
        s_token[len] = '\0';
 
        Com_StripExtension(bitmap, ase.materials[ase.numMaterials].name, MAX_QPATH);
        Verb_Printf(VERB_EXTRA, "ase material name: \'%s\'\n", ase.materials[ase.numMaterials].name);
    }
}
 
static void ASE_KeyMATERIAL (const char* token)
{
    if (Q_streq(token, "*MAP_DIFFUSE"))
        ASE_ParseBracedBlock(ASE_KeyMAP_DIFFUSE);
}
 
static void ASE_KeyMATERIAL_LIST (const char* token)
{
    if (Q_streq(token, "*MATERIAL_COUNT")) {
        ASE_GetToken(false);
        VERBOSE(("..num materials: %s\n", s_token));
        if (atoi(s_token) > MAX_ASE_MATERIALS) {
            Sys_Error("Too many materials!");
        }
        ase.numMaterials = 0;
    } else if (Q_streq(token, "*MATERIAL")) {
        VERBOSE(("..material %d ", ase.numMaterials));
        ASE_ParseBracedBlock(ASE_KeyMATERIAL);
        ase.numMaterials++;
    }
}
 
static void ASE_KeyMESH_VERTEX_LIST (const char* token)
{
    aseMesh_t* pMesh = ASE_GetCurrentMesh();
 
    if (Q_streq(token, "*MESH_VERTEX")) {
        ASE_GetToken(false);        /* skip number */
 
        ASE_GetToken(false);
        pMesh->vertexes[pMesh->currentVertex].y = atof(s_token);
 
        ASE_GetToken(false);
        pMesh->vertexes[pMesh->currentVertex].x = -atof(s_token);
 
        ASE_GetToken(false);
        pMesh->vertexes[pMesh->currentVertex].z = atof(s_token);
 
        pMesh->currentVertex++;
 
        if (pMesh->currentVertex > pMesh->numVertexes)
            Sys_Error("pMesh->currentVertex >= pMesh->numVertexes");
    } else
        Sys_Error("Unknown token '%s' while parsing MESH_VERTEX_LIST", token);
}
 
static void ASE_KeyMESH_FACE_LIST (const char* token)
{
    aseMesh_t* pMesh = ASE_GetCurrentMesh();
 
    if (Q_streq(token, "*MESH_FACE")) {
        ASE_GetToken(false);    /* skip face number */
 
        ASE_GetToken(false);    /* skip label */
        ASE_GetToken(false);    /* first vertex */
        pMesh->faces[pMesh->currentFace][0] = atoi(s_token);
 
        ASE_GetToken(false);    /* skip label */
        ASE_GetToken(false);    /* second vertex */
        pMesh->faces[pMesh->currentFace][2] = atoi(s_token);
 
        ASE_GetToken(false);    /* skip label */
        ASE_GetToken(false);    /* third vertex */
        pMesh->faces[pMesh->currentFace][1] = atoi(s_token);
 
        ASE_GetToken(true);
 
#if 0
        if ((p = strstr(s_token, "*MESH_MTLID")) != 0) {
            p += strlen("*MESH_MTLID") + 1;
            mtlID = atoi(p);
        } else {
            Sys_Error("No *MESH_MTLID found for face!");
        }
#endif
 
        pMesh->currentFace++;
    } else
        Sys_Error("Unknown token '%s' while parsing MESH_FACE_LIST", token);
}
 
static void ASE_KeyTFACE_LIST (const char* token)
{
    aseMesh_t* pMesh = ASE_GetCurrentMesh();
 
    if (Q_streq(token, "*MESH_TFACE")) {
        int a, b, c;
        aseFace_t* f;
 
        ASE_GetToken(false);
 
        ASE_GetToken(false);
        a = atoi(s_token);
        ASE_GetToken(false);
        c = atoi(s_token);
        ASE_GetToken(false);
        b = atoi(s_token);
 
        f = &pMesh->tfaces[pMesh->currentFace];
        *f[0] = a;
        *f[1] = b;
        *f[2] = c;
 
        pMesh->currentFace++;
    } else
        Sys_Error("Unknown token '%s' in MESH_TFACE", token);
}
 
static void ASE_KeyMESH_TVERTLIST (const char* token)
{
    aseMesh_t* pMesh = ASE_GetCurrentMesh();
 
    if (Q_streq(token, "*MESH_TVERT")) {
        char u[80], v[80], w[80];
 
        ASE_GetToken(false);
 
        ASE_GetToken(false);
        strcpy(u, s_token);
 
        ASE_GetToken(false);
        strcpy(v, s_token);
 
        ASE_GetToken(false);
        strcpy(w, s_token);
 
        pMesh->tvertexes[pMesh->currentVertex].s = atof(u);
        pMesh->tvertexes[pMesh->currentVertex].t = 1.0f - atof(v);
 
        pMesh->currentVertex++;
 
        if (pMesh->currentVertex > pMesh->numTVertexes) {
            Sys_Error("pMesh->currentVertex > pMesh->numTVertexes");
        }
    } else
        Sys_Error("Unknown token '%s' while parsing MESH_TVERTLIST", token);
}
 
static void ASE_KeyMESH (const char* token)
{
    aseMesh_t* pMesh = ASE_GetCurrentMesh();
 
    if (Q_streq(token, "*TIMEVALUE")) {
        ASE_GetToken(false);
 
        pMesh->timeValue = atoi(s_token);
        VERBOSE((".....timevalue: %d\n", pMesh->timeValue));
    } else if (Q_streq(token, "*MESH_NUMVERTEX")) {
        ASE_GetToken(false);
 
        pMesh->numVertexes = atoi(s_token);
        VERBOSE((".....TIMEVALUE: %d\n", pMesh->timeValue));
        VERBOSE((".....num vertexes: %d\n", pMesh->numVertexes));
    } else if (Q_streq(token, "*MESH_NUMFACES")) {
        ASE_GetToken(false);
 
        pMesh->numFaces = atoi(s_token);
        VERBOSE((".....num faces: %d\n", pMesh->numFaces));
    } else if (Q_streq(token, "*MESH_NUMTVFACES")) {
        ASE_GetToken(false);
 
        if (atoi(s_token) != pMesh->numFaces)
            Sys_Error("MESH_NUMTVFACES != MESH_NUMFACES");
    } else if (Q_streq(token, "*MESH_NUMTVERTEX")) {
        ASE_GetToken(false);
 
        pMesh->numTVertexes = atoi(s_token);
        VERBOSE((".....num tvertexes: %d\n", pMesh->numTVertexes));
    } else if (Q_streq(token, "*MESH_VERTEX_LIST")) {
        pMesh->vertexes = Mem_AllocTypeN(aseVertex_t, pMesh->numVertexes);
        pMesh->currentVertex = 0;
        VERBOSE((".....parsing MESH_VERTEX_LIST\n"));
        ASE_ParseBracedBlock(ASE_KeyMESH_VERTEX_LIST);
    } else if (Q_streq(token, "*MESH_TVERTLIST")) {
        pMesh->currentVertex = 0;
        pMesh->tvertexes = Mem_AllocTypeN(aseTVertex_t, pMesh->numTVertexes);
        VERBOSE((".....parsing MESH_TVERTLIST\n"));
        ASE_ParseBracedBlock(ASE_KeyMESH_TVERTLIST);
    } else if (Q_streq(token, "*MESH_FACE_LIST")) {
        pMesh->faces = Mem_AllocTypeN(aseFace_t, pMesh->numFaces);
        pMesh->currentFace = 0;
        VERBOSE((".....parsing MESH_FACE_LIST\n"));
        ASE_ParseBracedBlock(ASE_KeyMESH_FACE_LIST);
    } else if (Q_streq(token, "*MESH_TFACELIST")) {
        pMesh->tfaces = Mem_AllocTypeN(aseFace_t, pMesh->numFaces);
        pMesh->currentFace = 0;
        VERBOSE((".....parsing MESH_TFACE_LIST\n"));
        ASE_ParseBracedBlock(ASE_KeyTFACE_LIST);
    } else if (Q_streq(token, "*MESH_NORMALS")) {
        ASE_ParseBracedBlock(0);
    }
}
 
static void ASE_KeyGEOMOBJECT (const char* token)
{
    if (Q_streq(token, "*NODE_NAME")) {
        char* name = ase.objects[ase.currentObject].name;
 
        ASE_GetToken(true);
        VERBOSE((" %s\n", s_token));
        strcpy(ase.objects[ase.currentObject].name, s_token + 1);
        if (strchr(ase.objects[ase.currentObject].name, '"'))
            *strchr(ase.objects[ase.currentObject].name, '"') = 0;
 
        if (strstr(name, "tag") == name) {
            while (strchr(name, '_') != strrchr(name, '_')) {
                *strrchr(name, '_') = 0;
            }
            while (strrchr(name, ' ')) {
                *strrchr(name, ' ') = 0;
            }
        }
    } else if (Q_streq(token, "*NODE_PARENT")) {
        ASE_SkipRestOfLine();
    }
    /* ignore unused data blocks */
    else if (Q_streq(token, "*NODE_TM") || Q_streq(token, "*TM_ANIMATION")) {
        ASE_ParseBracedBlock(0);
    }
    /* ignore regular meshes that aren't part of animation */
    else if (Q_streq(token, "*MESH")) {
#if 0
        if (strstr(ase.objects[ase.currentObject].name, "tag_") == ase.objects[ase.currentObject].name) {
            s_forceStaticMesh = true;
            ASE_ParseBracedBlock(ASE_KeyMESH);
            s_forceStaticMesh = false;
        }
#endif
        ASE_ParseBracedBlock(ASE_KeyMESH);
        if (++ase.objects[ase.currentObject].anim.currentFrame == MAX_ASE_ANIMATION_FRAMES) {
            Sys_Error("Too many animation frames");
        }
        ase.objects[ase.currentObject].anim.numFrames = ase.objects[ase.currentObject].anim.currentFrame;
        ase.objects[ase.currentObject].numAnimations++;
#if 0
        /* ignore meshes that aren't part of animations if this object isn't a a tag */
        else {
            ASE_ParseBracedBlock(0);
        }
#endif
    }
    /* according to spec these are obsolete */
    else if (Q_streq(token, "*MATERIAL_REF")) {
        ASE_GetToken(false);
 
        ase.objects[ase.currentObject].materialRef = atoi(s_token);
    }
    /* ignore sequences of animation frames */
    else if (Q_streq(token, "*MESH_ANIMATION")) {
        ASE_SkipEnclosingBraces();
    }
    /* skip unused info */
    else if (Q_streq(token, "*PROP_MOTIONBLUR") || Q_streq(token, "*PROP_CASTSHADOW") || Q_streq(token, "*PROP_RECVSHADOW")) {
        ASE_SkipRestOfLine();
    }
}
 
static void ConcatenateObjects (aseGeomObject_t* pObjA, aseGeomObject_t* pObjB)
{
}
 
static void CollapseObjects (void)
{
    int numObjects = ase.currentObject;
 
    for (int i = 0; i < numObjects; i++) {
        int j;
 
        /* skip tags */
        if (strstr(ase.objects[i].name, "tag") == ase.objects[i].name)
            continue;
 
        if (!ase.objects[i].numAnimations)
            continue;
 
        for (j = i + 1; j < numObjects; j++) {
            if (strstr(ase.objects[j].name, "tag") == ase.objects[j].name)
                continue;
 
            if (ase.objects[i].materialRef == ase.objects[j].materialRef)
                if (ase.objects[j].numAnimations)
                    ConcatenateObjects(&ase.objects[i], &ase.objects[j]);
        }
    }
}
 
static void ASE_Process (void)
{
    while (ASE_GetToken(false)) {
        if (Q_streq(s_token, "*3DSMAX_ASCIIEXPORT") || Q_streq(s_token, "*COMMENT")) {
            ASE_SkipRestOfLine();
        } else if (Q_streq(s_token, "*SCENE"))
            ASE_SkipEnclosingBraces();
        else if (Q_streq(s_token, "*MATERIAL_LIST")) {
            VERBOSE(("MATERIAL_LIST\n"));
 
            ASE_ParseBracedBlock(ASE_KeyMATERIAL_LIST);
        } else if (Q_streq(s_token, "*GEOMOBJECT")) {
            VERBOSE(("GEOMOBJECT"));
 
            ASE_ParseBracedBlock(ASE_KeyGEOMOBJECT);
 
            if (strstr(ase.objects[ase.currentObject].name, "Bip") ||
                strstr(ase.objects[ase.currentObject].name, "ignore_")) {
                ASE_FreeGeomObject(ase.currentObject);
                VERBOSE(("(discarding BIP/ignore object)\n"));
            } else {
                if (++ase.currentObject == MAX_ASE_OBJECTS) {
                    Sys_Error("Too many GEOMOBJECTs");
                }
            }
        } else if (s_token[0]) {
            Com_Printf("Unknown token '%s'\n", s_token);
        }
    }
 
    if (!ase.currentObject)
        Sys_Error("No animation data!");
 
    CollapseObjects();
}