iqm.cpp

#include "util.h"

struct triangle { uint vert[3]; triangle() {} triangle(uint v0, uint v1, uint v2) { vert[0] = v0; vert[1] = v1; vert[2] = v2; } };
vector<triangle> triangles, neighbors;

struct mesh { uint name, material; uint firstvert, numverts; uint firsttri, numtris; mesh() : name(0), material(0), firstvert(0), numverts(0), firsttri(0), numtris(0) {} };
vector<mesh> meshes;

struct anim { uint name; uint firstframe, numframes; float fps; uint flags; anim() : name(0), firstframe(0), numframes(0), fps(0), flags(0) {} };
vector<anim> anims;

struct joint { uint name; int parent; float pos[3], orient[4], scale[3]; joint() : name(0), parent(-1) { memset(pos, 0, sizeof(pos)); memset(orient, 0, sizeof(orient)); memset(scale, 0, sizeof(scale)); } };
vector<joint> joints;

struct pose { int parent; uint flags; float offset[10], scale[10]; pose() : parent(-1), flags(0) { memset(offset, 0, sizeof(offset)); memset(scale, 0, sizeof(scale)); } };
vector<pose> poses;

struct framebounds { Vec3 bbmin, bbmax; double xyradius, radius; framebounds() : bbmin(0, 0, 0), bbmax(0, 0, 0), xyradius(0), radius(0) {} };
vector<framebounds> bounds;

struct transform
{
    Vec3 pos;
    Quat orient;
    Vec3 scale;

    transform() {}
    transform(const Vec3 &pos, const Quat &orient, const Vec3 &scale = Vec3(1, 1, 1)) : pos(pos), orient(orient), scale(scale) {}
};
vector<transform> frames;

vector<char> stringdata, commentdata;

struct sharedstring
{
    uint offset;
    sharedstring() {}
    sharedstring(const char *s) : offset(stringdata.length()) { stringdata.put(s, strlen(s)+1); }
}; 

static inline bool htcmp(const char *x, const sharedstring &s)
{
    return htcmp(x, &stringdata[s.offset]);
}

static inline uint hthash(const sharedstring &s)
{
    return hthash(&stringdata[s.offset]);
}

hashtable<sharedstring, uint> stringoffsets;

uint sharestring(const char *s)
{
    if(stringdata.empty()) stringoffsets.access("", 0);
    return stringoffsets.access(s ? s : "", stringdata.length());
}

struct blendcombo
{
    int sorted;
    double weights[4];
    uchar bones[4];

    blendcombo() : sorted(0) {}

    void reset() { sorted = 0; }

    void addweight(double weight, int bone)
    {
        if(weight <= 1e-3) return;
        loopk(sorted) if(weight > weights[k])
        {
            for(int l = min(sorted-1, 2); l >= k; l--)
            {
                weights[l+1] = weights[l];
                bones[l+1] = bones[l];
            }
            weights[k] = weight;
            bones[k] = bone;
            if(sorted<4) sorted++;
            return;
        }
        if(sorted>=4) return;
        weights[sorted] = weight;
        bones[sorted] = bone;
        sorted++;
    }

    void finalize()
    {
        loopj(4-sorted) { weights[sorted+j] = 0; bones[sorted+j] = 0; }
        if(sorted <= 0) return;
        double total = 0;
        loopj(sorted) total += weights[j];
        total = 1.0/total;
        loopj(sorted) weights[j] *= total;
    }

    void serialize(uchar *vweights) const
    {
        int total = 0;
        loopk(4) total += (vweights[k] = uchar(0.5 + weights[k]*255));
        if(sorted <= 0) return;
        while(total > 255)
        {
            loopk(4) if(vweights[k] > 0 && total > 255) { vweights[k]--; total--; }
        }
        while(total < 255)
        {
            loopk(4) if(vweights[k] < 255 && total < 255) { vweights[k]++; total++; }
        }
    }

    bool operator==(const blendcombo &c) { loopi(4) if(weights[i] != c.weights[i] || bones[i] != c.bones[i]) return false; return true; }
    bool operator!=(const blendcombo &c) { loopi(4) if(weights[i] != c.weights[i] || bones[i] != c.bones[i]) return true; return false; }
};
    
static bool parseindex(char *&c, int &val)
{ 
    while(isspace(*c)) c++;
    char *end = NULL;
    int rval = strtol(c, &end, 10);
    if(c == end) return false;
    val = rval;
    c = end;
    return true;
}

static double parseattrib(char *&c, double ival = 0)
{
    while(isspace(*c)) c++;
    char *end = NULL;
    double val = strtod(c, &end);
    if(c == end) val = ival;
    else c = end;
    return val;
}

static bool maybeparseattrib(char *&c, double &result)
{
    while(isspace(*c)) c++;
    char *end = NULL;
    double val = strtod(c, &end);
    if(c == end) return false;
    c = end;
    result = val;
    return true;
}

#if 0
static bool parsename(char *&c, char *buf, int bufsize = sizeof(string))
{
    while(isspace(*c)) c++;
    char *end;
    if(*c == '"')
    {
        c++;
        end = c;
        while(*end && *end != '"') end++;
        copystring(buf, c, min(int(end-c+1), bufsize));
        if(*end == '"') end++;
    }
    else
    {
        end = c;
        while(*end && !isspace(*end)) end++;
        copystring(buf, c, min(int(end-c+1), bufsize));
    }
    if(c == end) return false;
    c = end;
    return true;
}
#endif

static char *trimname(char *&c)
{
    while(isspace(*c)) c++;
    char *start, *end;
    if(*c == '"')
    {
        c++;
        start = end = c;
        while(*end && *end != '"') end++;
        if(*end) { *end = '\0'; end++; }
    }
    else
    {
        start = end = c;
        while(*end && !isspace(*end)) end++;
        if(*end) { *end = '\0'; end++; }
    }
    c = end;
    return start;
}
 
static Vec4 parseattribs4(char *&c, const Vec4 &ival = Vec4(0, 0, 0, 0))
{
    Vec4 val;
    loopk(4) val[k] = parseattrib(c, ival[k]);
    return val;
}

static Vec3 parseattribs3(char *&c, const Vec3 &ival = Vec3(0, 0, 0))
{
    Vec3 val;
    loopk(3) val[k] = parseattrib(c, ival[k]);
    return val;
}

static blendcombo parseblends(char *&c)
{
    blendcombo b;
    int index;
    while(parseindex(c, index))
    {
        double weight = parseattrib(c, 0);
        b.addweight(weight, index);
    }
    b.finalize();
    return b;
}
        
struct ejoint
{
    const char *name;
    int parent;

    ejoint() : name(NULL), parent(-1) {}
};

struct eanim
{
    const char *name;
    int startframe, endframe;
    double fps;
    uint flags;

    eanim() : name(NULL), startframe(0), endframe(INT_MAX), fps(0), flags(0) {}
};

struct emesh
{
    const char *name, *material;
    int firsttri;
    bool used;

    emesh() : name(NULL), material(NULL), firsttri(0), used(false) {}
    emesh(const char *name, const char *material, int firsttri = 0) : name(name), material(material), firsttri(firsttri), used(false) {}
};

struct evarray
{
    string name;
    int type, format, size;

    evarray() : type(IQM_POSITION), format(IQM_FLOAT), size(3) { name[0] = '\0'; }
    evarray(int type, int format, int size, const char *initname = "") : type(type), format(format), size(size) { copystring(name, initname); }
};
    
struct esmoothgroup
{
    enum
    {
        F_USED     = 1<<0,
        F_UVSMOOTH = 1<<1
    };

    int key;
    float angle;
    int flags;

    esmoothgroup() : key(-1), angle(-1), flags(0) {}
};

struct etriangle
{
    int smoothgroup;
    uint vert[3], weld[3];

    etriangle() 
        : smoothgroup(-1) 
    {
    }
    etriangle(int v0, int v1, int v2, int smoothgroup = -1) 
        : smoothgroup(smoothgroup) 
    { 
        vert[0] = v0; 
        vert[1] = v1; 
        vert[2] = v2; 
    }
};

vector<Vec4> mpositions, epositions, etexcoords, etangents, ecolors, ecustom[10];
vector<Vec3> enormals, ebitangents;
vector<blendcombo> mblends, eblends;
vector<etriangle> etriangles;
vector<esmoothgroup> esmoothgroups;
vector<int> esmoothindexes;
vector<uchar> esmoothedges;
vector<ejoint> ejoints;
vector<transform> eposes;
vector<Matrix3x4> mjoints;
vector<int> eframes;
vector<eanim> eanims;
vector<emesh> emeshes;
vector<evarray> evarrays;
hashtable<const char *, char *> enames;

const char *getnamekey(const char *name)
{
    char **exists = enames.access(name);
    if(exists) return *exists;
    char *key = newstring(name);
    enames[key] = key;
    return key;
}

struct weldinfo
{
    int tri, vert;
    weldinfo *next;
};

void weldvert(const vector<Vec3> &norms, const Vec4 &pos, weldinfo *welds, int &numwelds, unionfind<int> &welder)
{
    welder.clear();
    int windex = 0;
    for(weldinfo *w = welds; w; w = w->next, windex++)
    {
        etriangle &wt = etriangles[w->tri];
        esmoothgroup &wg = esmoothgroups[wt.smoothgroup];
        int vindex = windex + 1;
        for(weldinfo *v = w->next; v; v = v->next, vindex++)
        {
            etriangle &vt = etriangles[v->tri];
            esmoothgroup &vg = esmoothgroups[vt.smoothgroup];
            if(wg.key != vg.key) continue;
            if(norms[w->tri].dot(norms[v->tri]) < max(wg.angle, vg.angle)) continue;
            if(((wg.flags | vg.flags) & esmoothgroup::F_UVSMOOTH) &&
               etexcoords[wt.vert[w->vert]] != etexcoords[vt.vert[v->vert]])
                continue;          
            if(esmoothindexes.length() > max(w->vert, v->vert) && esmoothindexes[w->vert] != esmoothindexes[v->vert])
                continue;
            if(esmoothedges.length())
            {
                int w0 = w->vert, w1 = (w->vert+1)%3, w2 = (w->vert+2)%3;
                const Vec4 &wp1 = epositions[wt.vert[w1]],
                           &wp2 = epositions[wt.vert[w2]];
                int v0 = v->vert, v1 = (v->vert+1)%3, v2 = (v->vert+2)%3;
                const Vec4 &vp1 = epositions[vt.vert[v1]],
                           &vp2 = epositions[vt.vert[v2]];
                int wf = esmoothedges[w->tri], vf = esmoothedges[v->tri];
                if((wp1 != vp1 || !(((wf>>w0)|(vf>>v0))&1)) &&
                   (wp1 != vp2 || !(((wf>>w0)|(vf>>v2))&1)) &&
                   (wp2 != vp1 || !(((wf>>w2)|(vf>>v0))&1)) &&
                   (wp2 != vp2 || !(((wf>>w2)|(vf>>v2))&1)))
                    continue;
            }    
            welder.unite(windex, vindex, -1);
        }
    }    
    windex = 0;
    for(weldinfo *w = welds; w; w = w->next, windex++)
    {
        etriangle &wt = etriangles[w->tri];
        wt.weld[w->vert] = welder.find(windex, -1, numwelds);
        if(wt.weld[w->vert] == uint(numwelds)) numwelds++;
    }
}

void smoothverts(bool areaweight = true)
{
    if(etriangles.empty()) return;

    if(enormals.length())
    {
        loopv(etriangles)
        {
            etriangle &t = etriangles[i];
            loopk(3) t.weld[k] = t.vert[k];
        }
        return;
    }

    if(etexcoords.empty()) loopv(esmoothgroups) esmoothgroups[i].flags &= ~esmoothgroup::F_UVSMOOTH;
    if(esmoothedges.length()) while(esmoothedges.length() < etriangles.length()) esmoothedges.add(7);

    vector<Vec3> tarea, tnorms;
    loopv(etriangles)
    {
        etriangle &t = etriangles[i];
        Vec3 v0(epositions[t.vert[0]]),
             v1(epositions[t.vert[1]]),
             v2(epositions[t.vert[2]]);
        tnorms.add(tarea.add((v2 - v0).cross(v1 - v0)).normalize());
    }

    int nextalloc = 0;
    vector<weldinfo *> allocs;
    hashtable<Vec4, weldinfo *> welds(1<<12);

    loopv(etriangles)
    {
        etriangle &t = etriangles[i];
        loopk(3)
        {
            weldinfo **next = &welds.access(epositions[t.vert[k]], NULL);
            if(! (nextalloc % 1024)) allocs.add(new weldinfo[1024]);
            weldinfo &w = allocs[nextalloc/1024][nextalloc%1024];
            nextalloc++;
            w.tri = i;
            w.vert = k;
            w.next = *next;
            *next = &w;
        }
    }

    int numwelds = 0;
    unionfind<int> welder;
    enumerate(welds, Vec4, vpos, weldinfo *, vwelds, weldvert(tnorms, vpos, vwelds, numwelds, welder));

    loopv(allocs) delete[] allocs[i];

    loopi(numwelds) enormals.add(Vec3(0, 0, 0));
    loopv(etriangles)
    {
        etriangle &t = etriangles[i];
        loopk(3) enormals[t.weld[k]]+= areaweight ? tarea[i] : tnorms[i];
    }
    loopv(enormals) if(enormals[i] != Vec3(0, 0, 0)) enormals[i] = enormals[i].normalize();
}

struct sharedvert
{
    int index, weld;

    sharedvert() {}
    sharedvert(int index, int weld) : index(index), weld(weld) {}
};

static inline bool htcmp(const sharedvert &v, const sharedvert &s)
{
    if(epositions[v.index] != epositions[s.index]) return false;
    if(etexcoords.length() && etexcoords[v.index] != etexcoords[s.index]) return false;
    if(enormals.length() && enormals[v.weld] != enormals[s.weld]) return false;
    if(eblends.length() && eblends[v.index] != eblends[s.index]) return false;
    if(ecolors.length() && ecolors[v.index] != ecolors[s.index]) return false;
    loopi(10) if(ecustom[i].length() && ecustom[i][v.index] != ecustom[i][s.index]) return false; 
    return true;
}

static inline uint hthash(const sharedvert &v)
{
    return hthash(epositions[v.index]);
}

const struct vertexarraytype
{
    const char *name;
    int code;
} vatypes[] =
{
    { "position", IQM_POSITION },
    { "texcoord", IQM_TEXCOORD },
    { "normal", IQM_NORMAL  },
    { "tangent", IQM_TANGENT },
    { "blendindexes", IQM_BLENDINDEXES },
    { "blendweights", IQM_BLENDWEIGHTS },
    { "color", IQM_COLOR },
    { "custom0", IQM_CUSTOM + 0 },
    { "custom1", IQM_CUSTOM + 1 },
    { "custom2", IQM_CUSTOM + 2 },
    { "custom3", IQM_CUSTOM + 3 },
    { "custom4", IQM_CUSTOM + 4 },
    { "custom5", IQM_CUSTOM + 5 },
    { "custom6", IQM_CUSTOM + 6 },
    { "custom7", IQM_CUSTOM + 7 },
    { "custom8", IQM_CUSTOM + 8 },
    { "custom9", IQM_CUSTOM + 9 }
};

int findvertexarraytype(const char *name)
{
    loopi(sizeof(vatypes)/sizeof(vatypes[0]))
    {
        if(!strcasecmp(vatypes[i].name, name))
            return vatypes[i].code;
    }
    return -1;
}

const struct vertexarrayformat
{
    const char *name;
    int code;
    int size;
} vaformats[] = 
{
    { "byte", IQM_BYTE, 1 },
    { "ubyte", IQM_UBYTE, 1 },
    { "short", IQM_SHORT, 2 },
    { "ushort", IQM_USHORT, 2 },
    { "int", IQM_INT, 4 },
    { "uint", IQM_UINT, 4 },
    { "half", IQM_HALF, 2 },
    { "float", IQM_FLOAT, 4 },
    { "double", IQM_DOUBLE, 8 }
};

int findvertexarrayformat(const char *name)
{
    loopi(sizeof(vaformats)/sizeof(vaformats[0]))
    {
        if(!strcasecmp(vaformats[i].name, name))
            return vaformats[i].code;
    }
    return -1;
}

struct vertexarray
{
    uint type, flags, format, size, offset;

    vertexarray(uint type, uint format, uint size, uint offset) : type(type), flags(0), format(format), size(size), offset(offset) {}

    int formatsize() const
    {
        return vaformats[format].size;
    }

    int bytesize() const
    {
        return size * vaformats[format].size;
    }
};

vector<sharedvert> vmap;
vector<vertexarray> varrays;
vector<uchar> vdata;

struct halfdata
{
    ushort val;

    halfdata(double d)
    {
        union
        {
            ullong i;
            double d;
        } conv;
        conv.d = d;
        ushort signbit = ushort((conv.i>>63)&1);
        ushort mantissa = ushort((conv.i>>(52-10))&0x3FF);
        int exponent = int((conv.i>>52)&0x7FF) - 1023 + 15;
        if(exponent <= 0)
        {
            mantissa |= 0x400;
            mantissa >>= min(1-exponent, 10+1);
            exponent = 0;
        } 
        else if(exponent >= 0x1F)
        {
            mantissa = 0;
            exponent = 0x1F;
        }
        val = (signbit<<15) | (ushort(exponent)<<10) | mantissa;
    }
};

template<> inline halfdata endianswap<halfdata>(halfdata n) { n.val = endianswap16(n.val); return n; }

template<int TYPE> static inline int remapindex(int i, const sharedvert &v) { return v.index; }
template<> inline int remapindex<IQM_NORMAL>(int i, const sharedvert &v) { return v.weld; }
template<> inline int remapindex<IQM_TANGENT>(int i, const sharedvert &v) { return i; }

template<class T, class U>
static inline void putattrib(T &out, const U &val) { out = T(val); }

template<class T, class U>
static inline void uroundattrib(T &out, const U &val, double scale) { out = T(clamp(0.5 + val*scale, 0.0, scale)); }
template<class T, class U>
static inline void sroundattrib(T &out, const U &val, double scale, double low, double high) { double n = val*scale*0.5; out = T(clamp(n < 0 ? ceil(n - 1) : floor(n), low, high)); }

template<class T, class U>
static inline void scaleattrib(T &out, const U &val) { putattrib(out, val); }
template<class U>
static inline void scaleattrib(char &out, const U &val) { sroundattrib(out, val, 255.0, -128.0, 127.0); }
template<class U>
static inline void scaleattrib(short &out, const U &val) { sroundattrib(out, val, 65535.0, -32768.0, 32767.0); }
template<class U>
static inline void scaleattrib(int &out, const U &val) { sroundattrib(out, val, 4294967295.0, -2147483648.0, 2147483647.0); }
template<class U>
static inline void scaleattrib(uchar &out, const U &val) { uroundattrib(out, val, 255.0); }
template<class U>
static inline void scaleattrib(ushort &out, const U &val) { uroundattrib(out, val, 65535.0); }
template<class U>
static inline void scaleattrib(uint &out, const U &val) { uroundattrib(out, val, 4294967295.0); }

template<int T>
static inline bool normalizedattrib() { return true; }

template<int TYPE, int FMT, class T, class U>
static inline void serializeattrib(const vertexarray &va, T *data, const U &attrib)
{
    if(normalizedattrib<TYPE>()) switch(va.size)
    {
    case 4: scaleattrib(data[3], attrib.w);
    case 3: scaleattrib(data[2], attrib.z);
    case 2: scaleattrib(data[1], attrib.y);
    case 1: scaleattrib(data[0], attrib.x);
    }
    else switch(va.size)
    {
    case 4: putattrib(data[3], attrib.w);
    case 3: putattrib(data[2], attrib.z);
    case 2: putattrib(data[1], attrib.y);
    case 1: putattrib(data[0], attrib.x);
    }
    lilswap(data, va.size);
}

template<int TYPE, int FMT, class T>
static inline void serializeattrib(const vertexarray &va, T *data, const Vec3 &attrib)
{
    if(normalizedattrib<TYPE>()) switch(va.size)
    {
    case 3: scaleattrib(data[2], attrib.z);
    case 2: scaleattrib(data[1], attrib.y);
    case 1: scaleattrib(data[0], attrib.x);
    }
    else switch(va.size)
    {
    case 3: putattrib(data[2], attrib.z);
    case 2: putattrib(data[1], attrib.y);
    case 1: putattrib(data[0], attrib.x);
    }
    lilswap(data, va.size);
}

template<int TYPE, int FMT, class T>
static inline void serializeattrib(const vertexarray &va, T *data, const blendcombo &blend)
{
    if(TYPE == IQM_BLENDINDEXES)
    {
        switch(va.size)
        {
        case 4: putattrib(data[3], blend.bones[3]);
        case 3: putattrib(data[2], blend.bones[2]);
        case 2: putattrib(data[1], blend.bones[1]);
        case 1: putattrib(data[0], blend.bones[0]);
        }
    }
    else if(FMT == IQM_UBYTE)
    {
        uchar weights[4];
        blend.serialize(weights);
        switch(va.size)
        {
        case 4: putattrib(data[3], weights[3]);
        case 3: putattrib(data[2], weights[2]);
        case 2: putattrib(data[1], weights[1]);
        case 1: putattrib(data[0], weights[0]);
        }
    }
    else    
    {
        switch(va.size)
        {
        case 4: scaleattrib(data[3], blend.weights[3]);
        case 3: scaleattrib(data[2], blend.weights[2]);
        case 2: scaleattrib(data[1], blend.weights[1]);
        case 1: scaleattrib(data[0], blend.weights[0]);
        }
    }
    lilswap(data, va.size);
}

template<int TYPE, class T>
void setupvertexarray(const vector<T> &attribs, int type, int fmt, int size)
{
    vertexarray &va = varrays.add(vertexarray(type, fmt, size, vdata.length())); 
    const char *name = "";
    loopv(evarrays) if(evarrays[i].type == (int)va.type)
    {
        evarray &info = evarrays[i];
        va.format = info.format;
        va.size = clamp(info.size, 1, 4);
        name = info.name;
        break;
    }
    uint align = max(va.formatsize(), 4);
    if(va.offset%align) { uint pad = align - va.offset%align; va.offset += pad; loopi(pad) vdata.add(0); }
    if(va.type >= IQM_CUSTOM) 
    {
        if(!name[0])
        {
            defformatstring(customname, "custom%d", va.type-IQM_CUSTOM);
            va.type = IQM_CUSTOM + sharestring(customname);
        }
        else va.type = IQM_CUSTOM + sharestring(name);
    }
    int totalsize = va.bytesize() * vmap.length();
    uchar *data = vdata.reserve(totalsize);
    vdata.advance(totalsize);
    loopv(vmap)
    {
        const T &attrib = attribs[remapindex<TYPE>(i, vmap[i])];
        switch(va.format)
        {
        case IQM_BYTE: serializeattrib<TYPE, IQM_BYTE>(va, (char *)data, attrib); break;
        case IQM_UBYTE: serializeattrib<TYPE, IQM_UBYTE>(va, (uchar *)data, attrib); break;
        case IQM_SHORT: serializeattrib<TYPE, IQM_SHORT>(va, (short *)data, attrib); break;
        case IQM_USHORT: serializeattrib<TYPE, IQM_USHORT>(va, (ushort *)data, attrib); break;
        case IQM_INT: serializeattrib<TYPE, IQM_INT>(va, (int *)data, attrib); break;
        case IQM_UINT: serializeattrib<TYPE, IQM_UINT>(va, (uint *)data, attrib); break;
        case IQM_HALF: serializeattrib<TYPE, IQM_HALF>(va, (halfdata *)data, attrib); break;
        case IQM_FLOAT: serializeattrib<TYPE, IQM_FLOAT>(va, (float *)data, attrib); break;
        case IQM_DOUBLE: serializeattrib<TYPE, IQM_DOUBLE>(va, (double *)data, attrib); break;
        }
        data += va.bytesize();
    }
}

// linear speed vertex cache optimization from Tom Forsyth

#define MAXVCACHE 32

struct triangleinfo 
{ 
    bool used;
    float score;
    uint vert[3]; 

    triangleinfo() {} 
    triangleinfo(uint v0, uint v1, uint v2) 
    { 
        vert[0] = v0; 
        vert[1] = v1; 
        vert[2] = v2; 
    } 
};

struct vertexcache : listnode<vertexcache>
{
    int index, rank;
    float score;
    int numuses;
    triangleinfo **uses;

    vertexcache() : index(-1), rank(-1), score(-1.0f), numuses(0), uses(NULL) {}

    void calcscore()
    {
        if(numuses > 0)
        {
            score = 2.0f * powf(numuses, -0.5f);
            if(rank >= 3) score += powf(1.0f - (rank - 3)/float(MAXVCACHE - 3), 1.5f);
            else if(rank >= 0) score += 0.75f;
        }
        else score = -1.0f;
    }

    void removeuse(triangleinfo *t)
    {
        loopi(numuses) if(uses[i] == t)
        {
            uses[i] = uses[--numuses];
            return;
        }
    }
};

void maketriangles(vector<triangleinfo> &tris, const vector<sharedvert> &mmap)
{
    triangleinfo **uses = new triangleinfo *[3*tris.length()];
    vertexcache *verts = new vertexcache[mmap.length()];
    list<vertexcache> vcache;

    loopv(tris)
    {
        triangleinfo &t = tris[i];
        t.used = t.vert[0] == t.vert[1] || t.vert[1] == t.vert[2] || t.vert[2] == t.vert[0];
        if(t.used) continue;
        loopk(3) verts[t.vert[k]].numuses++;
    }
    triangleinfo **curuse = uses;
    loopvrev(tris)
    {
        triangleinfo &t = tris[i];
        if(t.used) continue;
        loopk(3)
        {
            vertexcache &v = verts[t.vert[k]];
            if(!v.uses) { curuse += v.numuses; v.uses = curuse; }
            *--v.uses = &t;
        }
    }
    loopv(mmap) verts[i].calcscore();
    triangleinfo *besttri = NULL;
    float bestscore = -1e16f;
    loopv(tris)
    {
        triangleinfo &t = tris[i];
        if(t.used) continue;
        t.score = verts[t.vert[0]].score + verts[t.vert[1]].score + verts[t.vert[2]].score;
        if(t.score > bestscore) { besttri = &t; bestscore = t.score; }
    }

    //int reloads = 0, n = 0;
    while(besttri)
    {
        besttri->used = true;
        triangle &t = triangles.add();
        loopk(3) 
        {
            vertexcache &v = verts[besttri->vert[k]];
            if(v.index < 0) { v.index = vmap.length(); vmap.add(mmap[besttri->vert[k]]); }
            t.vert[k] = v.index;
            v.removeuse(besttri);
            if(v.rank >= 0) vcache.remove(&v)->rank = -1;
            //else reloads++;
            if(v.numuses <= 0) continue;
            vcache.insertfirst(&v);
            v.rank = 0;
        }
        int rank = 0;
        for(vertexcache *v = vcache.first(); v != vcache.end(); v = v->next)
        {
            v->rank = rank++;
            v->calcscore();
        }
        besttri = NULL;
        bestscore = -1e16f;
        for(vertexcache *v = vcache.first(); v != vcache.end(); v = v->next)
        {
            loopi(v->numuses)
            {
                triangleinfo &t = *v->uses[i];
                t.score = verts[t.vert[0]].score + verts[t.vert[1]].score + verts[t.vert[2]].score;
                if(t.score > bestscore) { besttri = &t; bestscore = t.score; }
            }
        }
        while(vcache.size > MAXVCACHE) vcache.removelast()->rank = -1;
        if(!besttri) loopv(tris)
        {
            triangleinfo &t = tris[i];
            if(!t.used && t.score > bestscore) { besttri = &t; bestscore = t.score; }
        }
    }
    //printf("reloads: %d, worst: %d, best: %d\n", reloads, tris.length()*3, mmap.length());
        
    delete[] uses;
    delete[] verts;
}

void calctangents(bool areaweight = true)
{
    Vec3 *tangent = new Vec3[2*vmap.length()], *bitangent = tangent+vmap.length();
    memset(tangent, 0, 2*vmap.length()*sizeof(Vec3));
    loopv(triangles)
    {
        const triangle &t = triangles[i];
        sharedvert &i0 = vmap[t.vert[0]],
                   &i1 = vmap[t.vert[1]],
                   &i2 = vmap[t.vert[2]];

        Vec3 v0(epositions[i0.index]), e1 = Vec3(epositions[i1.index]) - v0, e2 = Vec3(epositions[i2.index]) - v0;

        double u1 = etexcoords[i1.index].x - etexcoords[i0.index].x, v1 = etexcoords[i1.index].y - etexcoords[i0.index].y,
               u2 = etexcoords[i2.index].x - etexcoords[i0.index].x, v2 = etexcoords[i2.index].y - etexcoords[i0.index].y;
        Vec3 u = e2*v1 - e1*v2,
             v = e2*u1 - e1*u2;

        if(e2.cross(e1).dot(v.cross(u)) < 0) 
        { 
            u = -u; 
            v = -v; 
        }

        if(!areaweight)
        {
            u = u.normalize();
            v = v.normalize();
        }
        
        loopj(3)
        {
            tangent[t.vert[j]] += u;
            bitangent[t.vert[j]] += v;
        }
    }
    loopv(vmap)
    {
        const Vec3 &n = enormals[vmap[i].weld],
                   &t = tangent[i],
                   &bt = bitangent[i];
        etangents.add(Vec4((t - n*n.dot(t)).normalize(), n.cross(t).dot(bt) < 0 ? -1 : 1));
    }
    delete[] tangent;
}

struct neighborkey
{
    uint e0, e1;

    neighborkey() {}
    neighborkey(uint i0, uint i1)
    {
        if(epositions[i0] < epositions[i1]) { e0 = i0; e1 = i1; } 
        else { e0 = i1; e1 = i0; }
    }

    uint hash() const { return hthash(epositions[e0]) + hthash(epositions[e1]); }
    bool operator==(const neighborkey &n) const 
    { 
        return epositions[e0] == epositions[n.e0] && epositions[e1] == epositions[n.e1] &&
               (eblends.empty() || (eblends[e0] == eblends[n.e0] && eblends[e1] == eblends[n.e1])); 
    }
};

static inline uint hthash(const neighborkey &n) { return n.hash(); }
static inline bool htcmp(const neighborkey &x, const neighborkey &y) { return x == y; }

struct neighborval
{
    uint tris[2];

    neighborval() {}
    neighborval(uint i) { tris[0] = i; tris[1] = 0xFFFFFFFFU; }

    void add(uint i)
    {
        if(tris[1] != 0xFFFFFFFFU) tris[0] = tris[1] = 0xFFFFFFFFU;
        else if(tris[0] != 0xFFFFFFFFU) tris[1] = i;
    } 
    
    int opposite(uint i) const
    {
        return tris[0] == i ? tris[1] : tris[0];
    }
};

void makeneighbors()
{
    hashtable<neighborkey, neighborval> nhash;

    loopv(triangles)
    {
        triangle &t = triangles[i];
        for(int j = 0, p = 2; j < 3; p = j, j++)
        {
            neighborkey key(t.vert[p], t.vert[j]);
            neighborval *val = nhash.access(key);
            if(val) val->add(i);
            else nhash[key] = neighborval(i);
        }
    }

    loopv(triangles)
    {
        triangle &t = triangles[i];
        triangle &n = neighbors.add();
        for(int j = 0, p = 2; j < 3; p = j, j++)
            n.vert[p] = nhash[neighborkey(t.vert[p], t.vert[j])].opposite(i);
    }
}

Quat erotate(0, 0, 0, 1);
double escale = 1;
Vec3 emeshtrans(0, 0, 0);
    
void makemeshes()
{
    meshes.setsize(0);
    triangles.setsize(0);
    neighbors.setsize(0);
    vmap.setsize(0);
    varrays.setsize(0);
    vdata.setsize(0);

    hashtable<sharedvert, uint> mshare(1<<12);
    vector<sharedvert> mmap;
    vector<triangleinfo> tinfo;

    loopv(emeshes)
    {
        emesh &em1 = emeshes[i];
        if(em1.used) continue;
        for(int j = i; j < emeshes.length(); j++) 
        {
            emesh &em = emeshes[j];
            if(em.name != em1.name || em.material != em1.material) continue;
            int lasttri = emeshes.inrange(i+1) ? emeshes[i+1].firsttri : etriangles.length();
            for(int k = em.firsttri; k < lasttri; k++)
            {
                etriangle &et = etriangles[k];
                triangleinfo &t = tinfo.add();    
                loopl(3)
                {
                    sharedvert v(et.vert[l], et.weld[l]);
                    t.vert[l] = mshare.access(v, mmap.length());
                    if(!mmap.inrange(t.vert[l])) mmap.add(v);
                }
            }
            em.used = true;
        }
        if(tinfo.empty()) continue;

        mesh &m = meshes.add();
        m.name = sharestring(em1.name);
        m.material = sharestring(em1.material);
        m.firsttri = triangles.length();
        m.firstvert = vmap.length();
        maketriangles(tinfo, mmap);
        m.numtris = triangles.length() - m.firsttri;
        m.numverts = vmap.length() - m.firstvert;

        mshare.clear();
        mmap.setsize(0);
        tinfo.setsize(0);
    }

    if(triangles.length()) makeneighbors();

    if(escale != 1) loopv(epositions) epositions[i] *= escale;
    if(erotate != Quat(0, 0, 0, 1))
    {
        loopv(epositions) epositions[i].setxyz(erotate.transform(Vec3(epositions[i])));
        loopv(enormals) enormals[i] = erotate.transform(enormals[i]);
        loopv(etangents) etangents[i].setxyz(erotate.transform(Vec3(etangents[i])));
        loopv(ebitangents) ebitangents[i] = erotate.transform(ebitangents[i]);
    }
    if(emeshtrans != Vec3(0, 0, 0)) loopv(epositions) epositions[i] += emeshtrans;
    if(epositions.length()) setupvertexarray<IQM_POSITION>(epositions, IQM_POSITION, IQM_FLOAT, 3);
    if(etexcoords.length()) setupvertexarray<IQM_TEXCOORD>(etexcoords, IQM_TEXCOORD, IQM_FLOAT, 2);
    if(enormals.length()) setupvertexarray<IQM_NORMAL>(enormals, IQM_NORMAL, IQM_FLOAT, 3);
    if(etangents.length())
    {
        if(ebitangents.length() && enormals.length())
        {
            loopv(etangents) if(ebitangents.inrange(i) && enormals.inrange(i))
                etangents[i].w = enormals[i].cross(Vec3(etangents[i])).dot(ebitangents[i]) < 0 ? -1 : 1;
        }
        setupvertexarray<IQM_TANGENT>(etangents, IQM_TANGENT, IQM_FLOAT, 4);
    }    
    else if(enormals.length() && etexcoords.length())
    {
        calctangents();
        setupvertexarray<IQM_TANGENT>(etangents, IQM_TANGENT, IQM_FLOAT, 4);
    }
    if(eblends.length())
    {
        setupvertexarray<IQM_BLENDINDEXES>(eblends, IQM_BLENDINDEXES, IQM_UBYTE, 4);
        setupvertexarray<IQM_BLENDWEIGHTS>(eblends, IQM_BLENDWEIGHTS, IQM_UBYTE, 4);
    }
    if(ecolors.length()) setupvertexarray<IQM_COLOR>(ecolors, IQM_COLOR, IQM_UBYTE, 4);
    loopi(10) if(ecustom[i].length()) setupvertexarray<IQM_CUSTOM>(ecustom[i], IQM_CUSTOM + i, IQM_FLOAT, 4);

    if(epositions.length())
    {
        mpositions.setsize(0);
        mpositions.swap(epositions);
    }
    if(eblends.length())
    {
        mblends.setsize(0);
        mblends.swap(eblends);
    }
}

void makebounds(framebounds &bb, Matrix3x4 *buf, Matrix3x4 *invbase, transform *frame)
{
    loopv(ejoints)
    {
        ejoint &j = ejoints[i];
        if(j.parent >= 0) buf[i] = buf[j.parent] * Matrix3x4(frame[i].orient, frame[i].pos, frame[i].scale);
        else buf[i] = Matrix3x4(frame[i].orient, frame[i].pos, frame[i].scale);
    }
    loopv(ejoints) buf[i] *= invbase[i];
    loopv(mpositions)
    {
        const blendcombo &c = mblends[i]; 
        Matrix3x4 m(Vec4(0, 0, 0, 0), Vec4(0, 0, 0, 0), Vec4(0, 0, 0, 0));
        loopk(4) if(c.weights[k] > 0)
            m += buf[c.bones[k]] * c.weights[k];
        Vec3 p = m.transform(Vec3(mpositions[i]));
        
        if(!i) bb.bbmin = bb.bbmax = p;
        else
        {
            bb.bbmin.x = min(bb.bbmin.x, p.x);
            bb.bbmin.y = min(bb.bbmin.y, p.y);
            bb.bbmin.z = min(bb.bbmin.z, p.z);
            bb.bbmax.x = max(bb.bbmax.x, p.x);
            bb.bbmax.y = max(bb.bbmax.y, p.y);
            bb.bbmax.z = max(bb.bbmax.z, p.z);
        }
        double xyradius = p.x*p.x + p.y*p.y;
        bb.xyradius = max(bb.xyradius, xyradius);
        bb.radius = max(bb.radius, xyradius + p.z*p.z);
    }
    if(bb.xyradius > 0) bb.xyradius = sqrt(bb.xyradius);
    if(bb.radius > 0) bb.radius = sqrt(bb.radius);
}
     
void makerelativebasepose()
{
    int numbasejoints = min(ejoints.length(), eframes.length() ? eframes[0] : eposes.length());
    for(int i = numbasejoints-1; i >= 0; i--)
    {
        ejoint &ej = ejoints[i];
        if(ej.parent < 0) continue; 
        transform &parent = eposes[ej.parent], &child = eposes[i];
        child.pos = (-parent.orient).transform(child.pos - parent.pos);   
        child.orient = (-parent.orient)*child.orient;
        if(child.orient.w > 0) child.orient.flip();
    }
}

bool forcejoints = false;

void makeanims()
{
    if(escale != 1) loopv(eposes) eposes[i].pos *= escale;
    if(erotate != Quat(0, 0, 0, 1)) loopv(ejoints)
    {
        ejoint &ej = ejoints[i];
        if(ej.parent < 0) for(int j = i; j < eposes.length(); j += ejoints.length())
        {
            transform &p = eposes[j];
            p.orient = erotate * p.orient;
            p.pos = erotate.transform(p.pos);
        }
    }
    int numbasejoints = eframes.length() ? eframes[0] : eposes.length();
    if((forcejoints || meshes.length()) && joints.empty()) 
    {
        mjoints.setsize(0);
        loopv(ejoints)
        {
            ejoint &ej = ejoints[i];
            joint &j = joints.add();
            j.name = sharestring(ej.name);
            j.parent = ej.parent;
            if(i < numbasejoints) 
            {
                mjoints.add().invert(Matrix3x4(eposes[i].orient, eposes[i].pos, eposes[i].scale));
                loopk(3) j.pos[k] = eposes[i].pos[k];
                loopk(4) j.orient[k] = eposes[i].orient[k];
                loopk(3) j.scale[k] = eposes[i].scale[k];
            }
            else mjoints.add().invert(Matrix3x4(Quat(0, 0, 0, 1), Vec3(0, 0, 0), Vec3(1, 1, 1)));
            if(ej.parent >= 0) mjoints[i] *= mjoints[ej.parent];
        }
    }
    if(eanims.empty()) return;
    if(poses.empty()) loopv(ejoints)
    {
        ejoint &ej = ejoints[i];
        pose &p = poses.add();
        p.parent = ej.parent;
    }    
    if(poses.empty()) return;
    int totalframes = frames.length()/poses.length();
    Matrix3x4 *mbuf = mpositions.length() && mblends.length() && mjoints.length() ? new Matrix3x4[poses.length()] : NULL;
    loopv(eanims)
    {
        eanim &ea = eanims[i];
        anim &a = anims.add();
        a.name = sharestring(ea.name);
        a.firstframe = totalframes;
        a.numframes = 0;
        a.fps = ea.fps;
        a.flags = ea.flags;
        for(int j = ea.startframe, end = eanims.inrange(i+1) ? eanims[i+1].startframe : eframes.length(); j < end && j <= ea.endframe; j++)
        {
            int offset = eframes[j], range = (eframes.inrange(j+1) ? eframes[j+1] : eposes.length()) - offset;
            if(range <= 0) continue;
            loopk(min(range, poses.length())) frames.add(eposes[offset + k]); 
            loopk(max(poses.length() - range, 0)) frames.add(transform(Vec3(0, 0, 0), Quat(0, 0, 0, 1), Vec3(1, 1, 1)));
            if(mbuf) makebounds(bounds.add(), mbuf, mjoints.getbuf(), &frames[frames.length() - poses.length()]);
            a.numframes++;
        }
        totalframes += a.numframes;
    }
    if(mbuf) delete[] mbuf;
}

bool resetimporter(bool reuse = false)
{
    if(reuse)
    {
        ejoints.setsize(0);
        evarrays.setsize(0);

        return false;
    }

    epositions.setsize(0);
    etexcoords.setsize(0);
    etangents.setsize(0);
    ebitangents.setsize(0);
    ecolors.setsize(0);
    loopi(10) ecustom[i].setsize(0);
    eblends.setsize(0);
    etriangles.setsize(0);
    esmoothindexes.setsize(0);
    esmoothedges.setsize(0);
    esmoothgroups.setsize(0);
    esmoothgroups.add();
    ejoints.setsize(0);
    eposes.setsize(0);
    eframes.setsize(0);
    eanims.setsize(0);
    emeshes.setsize(0);
    evarrays.setsize(0);
    erotate = Quat(0, 0, 0, 1);

    return true;
}

struct filespec
{
    const char *file;
    const char *name;
    double fps;
    uint flags;
    int startframe;
    int endframe;

    filespec() { reset(); }

    void reset()
    {
        file = NULL;
        name = NULL;
        fps = 0;
        flags = 0;
        startframe = 0;
        endframe = -1;
    }
};
 
bool parseiqe(stream *f)
{
    const char *curmesh = getnamekey(""), *curmaterial = getnamekey("");
    bool needmesh = true;
    int fmoffset = 0;
    char buf[512];
    if(!f->getline(buf, sizeof(buf))) return false;
    if(!strchr(buf, '#') || strstr(buf, "# Inter-Quake Export") != strchr(buf, '#')) return false;
    while(f->getline(buf, sizeof(buf)))
    {
        char *c = buf;
        while(isspace(*c)) ++c;
        if(isalpha(c[0]) && isalnum(c[1]) && (!c[2] || isspace(c[2]))) switch(*c++)
        {
        case 'v':
            switch(*c++)
            {
            case 'p': epositions.add(parseattribs4(c, Vec4(0, 0, 0, 1))); continue;
            case 't': etexcoords.add(parseattribs4(c)); continue;
            case 'n': enormals.add(parseattribs3(c)); continue;
            case 'x':
            {
                Vec4 tangent(parseattribs3(c), 0);
                Vec3 bitangent(0, 0, 0);
                bitangent.x = parseattrib(c);
                if(maybeparseattrib(c, bitangent.y))
                {
                    bitangent.z = parseattrib(c);
                    ebitangents.add(bitangent);
                }    
                else tangent.w = bitangent.x;
                etangents.add(tangent);
                continue;
            }
            case 'b': eblends.add(parseblends(c)); continue;
            case 'c': ecolors.add(parseattribs4(c, Vec4(0, 0, 0, 1))); continue;
            case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
            {
                int n = c[-1] - '0';
                ecustom[n].add(parseattribs4(c));
                continue;
            }
            case 's':
                parseindex(c, esmoothindexes.add());
                continue;
            }
            break;
        case 'p':
        {
            transform t;
            switch(*c++)
            {
            case 'q':
                {
                    t.pos = parseattribs3(c);
                    loopk(3) t.orient[k] = parseattrib(c);
                    t.orient.restorew();
                    double w = parseattrib(c, t.orient.w);
                    if(w != t.orient.w)
                    {
                        t.orient.w = w;
                        t.orient.normalize();
//        double x2 = f.orient.x*f.orient.x, y2 = f.orient.y*f.orient.y, z2 = f.orient.z*f.orient.z, w2 = f.orient.w*f.orient.w, s2 = x2 + y2 + z2 + w2;
//        f.orient.x = keepsign(f.orient.x, sqrt(max(1.0 - (w2 + y2 + z2) / s2, 0.0)));
//        f.orient.y = keepsign(f.orient.y, sqrt(max(1.0 - (w2 + x2 + z2) / s2, 0.0)));
//        f.orient.z = keepsign(f.orient.z, sqrt(max(1.0 - (w2 + x2 + y2) / s2, 0.0)));
//        f.orient.w = keepsign(f.orient.w, sqrt(max(1.0 - (x2 + y2 + z2) / s2, 0.0)));
                    }
                    if(t.orient.w > 0) t.orient.flip();
                    t.scale = parseattribs3(c, Vec3(1, 1, 1));
                    eposes.add(t);
                    continue;
                }
            case 'm':
                {
                    t.pos = parseattribs3(c);
                    Matrix3x3 m;
                    m.a = parseattribs3(c);
                    m.b = parseattribs3(c);
                    m.c = parseattribs3(c);
                    Vec3 mscale(Vec3(m.a.x, m.b.x, m.c.x).magnitude(), Vec3(m.a.y, m.b.y, m.c.y).magnitude(), Vec3(m.a.z, m.b.z, m.c.z).magnitude());
                    // check determinant for sign of scaling
                    if(m.determinant() < 0) mscale = -mscale;
                    m.a /= mscale;
                    m.b /= mscale;
                    m.c /= mscale;
                    t.orient = Quat(m);
                    if(t.orient.w > 0) t.orient.flip();
                    t.scale = parseattribs3(c, Vec3(1, 1, 1)) * mscale;
                    eposes.add(t);
                    continue;
                }
            case 'a':
                {
                    t.pos = parseattribs3(c);
                    Vec3 rot = parseattribs3(c);
                    t.orient = Quat::fromangles(rot);
                    t.scale = parseattribs3(c, Vec3(1, 1, 1));
                    eposes.add(t);
                    continue;
                } 
            }
            break;
        }
        case 'f':
            switch(*c++)
            {
            case 'a': 
                {
                    int i1 = 0, i2 = 0, i3 = 0;
                    if(!parseindex(c, i1) || !parseindex(c, i2)) continue;
                    if(needmesh)
                    {
                        emeshes.add(emesh(curmesh, curmaterial, etriangles.length()));
                        needmesh = false;
                    }
                    if(i1 < 0) i1 = max(epositions.length() + i1, 0);
                    if(i2 < 0) i2 = max(epositions.length() + i2, 0);
                    while(parseindex(c, i3))
                    {
                        if(i3 < 0) i3 = max(epositions.length() + i3, 0);
                        esmoothgroups.last().flags |= esmoothgroup::F_USED;
                        etriangles.add(etriangle(i1, i2, i3, esmoothgroups.length()-1));
                        i2 = i3;
                    }         
                    continue;
                }
            case 'm': 
                {
                    int i1 = 0, i2 = 0, i3 = 0;
                    if(!parseindex(c, i1) || !parseindex(c, i2)) continue;
                    if(needmesh)
                    {
                        emeshes.add(emesh(curmesh, curmaterial, etriangles.length()));
                        needmesh = false;
                    }
                    i1 = i1 < 0 ? max(epositions.length() + i1, 0) : (fmoffset + i1);
                    i2 = i2 < 0 ? max(epositions.length() + i2, 0) : (fmoffset + i2);
                    while(parseindex(c, i3))
                    {
                        i3 = i3 < 0 ? max(epositions.length() + i3, 0) : (fmoffset + i3);
                        esmoothgroups.last().flags |= esmoothgroup::F_USED;
                        etriangles.add(etriangle(i1, i2, i3, esmoothgroups.length()-1));
                        i2 = i3;
                    }
                    continue;
                }
            case 's':
                {
                    int i1 = 0, i2 = 0, i3 = 0;
                    uchar flags = 0;
                    if(!parseindex(c, i1) || !parseindex(c, i2) || !parseindex(c, i3)) continue;
                    flags |= clamp(i1, 0, 1);
                    flags |= clamp(i2, 0, 1)<<1;
                    flags |= clamp(i3, 0, 1)<<2;
                    esmoothgroups.last().flags |= esmoothgroup::F_USED;
                    while(parseindex(c, i3))
                    {
                        esmoothedges.add(flags | 4);
                        flags = 1 | ((flags & 4) >> 1) | (clamp(i3, 0, 1)<<2);
                    } 
                    esmoothedges.add(flags);
                    continue;
                }
            }
            break;
        }    
        char *args = c;
        while(*args && !isspace(*args)) args++;
        if(!strncmp(c, "smoothgroup", max(int(args-c), 11)))
        {
            if(esmoothgroups.last().flags & esmoothgroup::F_USED) esmoothgroups.dup();
            parseindex(args, esmoothgroups.last().key);
        }
        else if(!strncmp(c, "smoothangle", max(int(args-c), 11)))
        {
            if(esmoothgroups.last().flags & esmoothgroup::F_USED) esmoothgroups.dup();
            double angle = parseattrib(args, 0);
            esmoothgroups.last().angle = fabs(cos(clamp(angle, -180.0, 180.0) * M_PI/180));
        }
        else if(!strncmp(c, "smoothuv", max(int(args-c), 8)))
        {
            if(esmoothgroups.last().flags & esmoothgroup::F_USED) esmoothgroups.dup();
            int val = 1;
            if(parseindex(args, val) && val <= 0) esmoothgroups.last().flags &= ~esmoothgroup::F_UVSMOOTH;
            else esmoothgroups.last().flags |= esmoothgroup::F_UVSMOOTH;
        }
        else if(!strncmp(c, "mesh", max(int(args-c), 4)))
        { 
            curmesh = getnamekey(trimname(args));
            if(emeshes.empty() || emeshes.last().name != curmesh) needmesh = true;
            fmoffset = epositions.length();

#if 0
            emesh &m = emeshes.add();
            m.firsttri = etriangles.length();
            fmoffset = epositions.length();
            parsename(args, m.name);
#endif
        }
        else if(!strncmp(c, "material", max(int(args-c), 8)))
        {
            curmaterial = getnamekey(trimname(args));
            if(emeshes.empty() || emeshes.last().material != curmaterial) needmesh = true;
//            if(emeshes.length()) parsename(c, emeshes.last().material);
        }
        else if(!strncmp(c, "joint", max(int(args-c), 5)))
        {
            ejoint &j = ejoints.add();
            j.name = getnamekey(trimname(args));
            parseindex(args, j.parent);
        }
        else if(!strncmp(c, "vertexarray", max(int(args-c), 11)))
        {
            evarray &va = evarrays.add();
            va.type = findvertexarraytype(trimname(args));
            va.format = findvertexarrayformat(trimname(args)); 
            va.size = strtol(args, &args, 10);
            copystring(va.name, trimname(args));
        }
        else if(!strncmp(c, "animation", max(int(args-c), 9)))
        {
            eanim &a = eanims.add();
            a.name = getnamekey(trimname(args));
            a.startframe = eframes.length();
            if(!eframes.length() || eframes.last() != eposes.length()) eframes.add(eposes.length());
        }
        else if(!strncmp(c, "frame", max(int(args-c), 5)))
        {
            if(eanims.length() && eframes.length() && eframes.last() != eposes.length()) eframes.add(eposes.length()); 
        }
        else if(!strncmp(c, "framerate", max(int(args-c), 9)))
        {
            if(eanims.length())
            {
                double fps = parseattrib(args);
                eanims.last().fps = max(fps, 0.0);
            }
        }
        else if(!strncmp(c, "loop", max(int(args-c), 4)))
        {
            if(eanims.length()) eanims.last().flags |= IQM_LOOP;
        }
        else if(!strncmp(c, "comment", max(int(args-c), 7)))
        {
            if(commentdata.length()) break;
            for(;;)
            {
                int len = f->read(commentdata.reserve(1024), 1024);
                commentdata.advance(len);
                if(len < 1024) { commentdata.add('\0'); break; }
            }
        }
    }

    return true;
}

bool loadiqe(const char *filename, const filespec &spec)
{
    int numfiles = 0;
    while(filename)
    {   
        const char *endfile = strchr(filename, ',');
        const char *file = endfile ? newstring(filename, endfile-filename) : filename;
        stream *f = openfile(file, "r");
        if(f)
        {
            resetimporter(numfiles > 0); 
            if(parseiqe(f)) numfiles++;
            delete f;
        }
           
        if(!endfile) break;

        delete[] file;
        filename = endfile+1; 
    } 

    if(!numfiles) return false;

    if(eanims.length() == 1)
    {
        eanim &a = eanims.last();
        if(spec.name) a.name = spec.name;
        if(spec.fps > 0) a.fps = spec.fps;
        a.flags |= spec.flags;
        if(spec.endframe >= 0) a.endframe = a.startframe + spec.endframe;
        else if(spec.endframe < -1) a.endframe = a.startframe + max(eframes.length() - a.startframe + spec.endframe + 1, 0);
        a.startframe += spec.startframe;
    }

    if(emeshes.length())
    {
        smoothverts();
        makemeshes();
    }
    makeanims();
    
    return true;
}

struct md5weight
{
    int joint;
    double bias;
    Vec3 pos;
};

struct md5vert
{
    double u, v;
    uint start, count;
};

struct md5hierarchy
{
    const char *name;
    int parent, flags, start;
};

vector<md5weight> weightinfo;
vector<md5vert> vertinfo;

void buildmd5verts()
{
    loopv(vertinfo)
    {
        md5vert &v = vertinfo[i];
        Vec3 pos(0, 0, 0);
        loopk(v.count)
        {
            md5weight &w = weightinfo[v.start+k];
            transform &j = eposes[w.joint];
            pos += (j.orient.transform(w.pos) + j.pos)*w.bias;
        }
        epositions.add(Vec4(pos, 1));
        etexcoords.add(Vec4(v.u, v.v, 0, 0));

        blendcombo &c = eblends.add();
        loopj(v.count)
        {
            md5weight &w = weightinfo[v.start+j];
            c.addweight(w.bias, w.joint);
        }
        c.finalize();
    }
}

void parsemd5mesh(stream *f, char *buf, size_t bufsize)
{
    md5weight w;
    md5vert v;
    etriangle t(0, 0, 0, 0);
    int index, firsttri = etriangles.length(), firstvert = vertinfo.length(), firstweight = weightinfo.length(), numtris = 0, numverts = 0, numweights = 0;
    emesh m;

    while(f->getline(buf, bufsize) && buf[0]!='}')
    {
        if(strstr(buf, "// meshes:"))
        {
            char *start = strchr(buf, ':')+1;
            if(*start==' ') start++;
            char *end = start + strlen(start)-1;
            while(end >= start && isspace(*end)) end--;
            end[1] = '\0';
            m.name = getnamekey(start);
        }
        else if(strstr(buf, "shader"))
        {
            char *start = strchr(buf, '"'), *end = start ? strchr(start+1, '"') : NULL;
            if(start && end)
            {
                *end = '\0';
                m.material = getnamekey(start+1);
            }
        }
        else if(sscanf(buf, " numverts %d", &numverts)==1)
        {
            numverts = max(numverts, 0);
            if(numverts)
            {
                vertinfo.reserve(numverts);
                vertinfo.advance(numverts);
            }
        }
        else if(sscanf(buf, " numtris %d", &numtris)==1)
        {
            numtris = max(numtris, 0);
            if(numtris)
            {
                etriangles.reserve(numtris);
                etriangles.advance(numtris);
            }
            m.firsttri = firsttri;
        }
        else if(sscanf(buf, " numweights %d", &numweights)==1)
        {
            numweights = max(numweights, 0);
            if(numweights)
            {
                weightinfo.reserve(numweights);
                weightinfo.advance(numweights);
            }
        }
        else if(sscanf(buf, " vert %d ( %lf %lf ) %u %u", &index, &v.u, &v.v, &v.start, &v.count)==5)
        {
            if(index>=0 && index<numverts)
            {
                v.start += firstweight;
                vertinfo[firstvert + index] = v;
            }
        }
        else if(sscanf(buf, " tri %d %u %u %u", &index, &t.vert[0], &t.vert[1], &t.vert[2])==4)
        {
            if(index>=0 && index<numtris)
            {
                loopk(3) t.vert[k] += firstvert;
                etriangles[firsttri + index] = t;
            }
        }
        else if(sscanf(buf, " weight %d %d %lf ( %lf %lf %lf ) ", &index, &w.joint, &w.bias, &w.pos.x, &w.pos.y, &w.pos.z)==6)
        {
            if(index>=0 && index<numweights) weightinfo[firstweight + index] = w;
        }
    }

    if(numtris && numverts) emeshes.add(m);
}

bool loadmd5mesh(const char *filename, const filespec &spec)
{
    stream *f = openfile(filename, "r");
    if(!f) return false;

    resetimporter();
    esmoothgroups[0].flags |= esmoothgroup::F_UVSMOOTH;

    char buf[512];
    while(f->getline(buf, sizeof(buf)))
    {
        int tmp;
        if(sscanf(buf, " MD5Version %d", &tmp)==1)
        {
            if(tmp!=10) { delete f; return false; }
        }
        else if(sscanf(buf, " numJoints %d", &tmp)==1)
        {
            if(tmp<1 || (joints.length() && tmp != joints.length())) { delete f; return false; }
        }
        else if(sscanf(buf, " numMeshes %d", &tmp)==1)
        {
            if(tmp<1) { delete f; return false; }
        }
        else if(strstr(buf, "joints {"))
        {
            ejoint j;
            transform p;
            while(f->getline(buf, sizeof(buf)) && buf[0]!='}')
            {
                char *c = buf;
                j.name = getnamekey(trimname(c));
                if(sscanf(c, " %d ( %lf %lf %lf ) ( %lf %lf %lf )",
                    &j.parent, &p.pos.x, &p.pos.y, &p.pos.z,
                    &p.orient.x, &p.orient.y, &p.orient.z)==7)
                {
                    p.orient.restorew();
                    p.scale = Vec3(1, 1, 1);
                    ejoints.add(j);
                    eposes.add(p);
                }
            }
        }
        else if(strstr(buf, "mesh {"))
        {
            parsemd5mesh(f, buf, sizeof(buf));
        }
    }

    delete f;

    buildmd5verts();
    smoothverts();
    makemeshes();
    makerelativebasepose();
    makeanims();

    return true;
}

bool loadmd5anim(const char *filename, const filespec &spec)
{
    stream *f = openfile(filename, "r");
    if(!f) return false;

    resetimporter();

    vector<md5hierarchy> hierarchy;
    vector<transform> baseframe;
    int animdatalen = 0, animframes = 0, frameoffset = eposes.length(), firstframe = eframes.length();
    double framerate = 0;
    double *animdata = NULL;
    char buf[512];
    while(f->getline(buf, sizeof(buf)))
    {
        int tmp;
        if(sscanf(buf, " MD5Version %d", &tmp)==1)
        {
            if(tmp!=10) { delete f; return false; }
        }
        else if(sscanf(buf, " numJoints %d", &tmp)==1)
        {
            if(tmp<1) { delete f; return false; }
        }
        else if(sscanf(buf, " numFrames %d", &animframes)==1)
        {
            if(animframes<1) { delete f; return false; }
        }
        else if(sscanf(buf, " frameRate %lf", &framerate)==1);
        else if(sscanf(buf, " numAnimatedComponents %d", &animdatalen)==1)
        {
            if(animdatalen>0) animdata = new double[animdatalen];
        }
        else if(strstr(buf, "bounds {"))
        {
            while(f->getline(buf, sizeof(buf)) && buf[0]!='}');
        }
        else if(strstr(buf, "hierarchy {"))
        {
            while(f->getline(buf, sizeof(buf)) && buf[0]!='}')
            {
                char *c = buf;
                md5hierarchy h;
                h.name = getnamekey(trimname(c));
                if(sscanf(c, " %d %d %d", &h.parent, &h.flags, &h.start)==3)
                    hierarchy.add(h);
            }
            if(hierarchy.empty() || (poses.length() && hierarchy.length()!=poses.length())) { delete f; return false; }
            loopv(hierarchy)
            {
                md5hierarchy &h = hierarchy[i];
                ejoint &j = ejoints.add();
                j.name = h.name;
                j.parent = h.parent;
            }
        }
        else if(strstr(buf, "baseframe {"))
        {
            while(f->getline(buf, sizeof(buf)) && buf[0]!='}')
            {
                transform j;
                if(sscanf(buf, " ( %lf %lf %lf ) ( %lf %lf %lf )", &j.pos.x, &j.pos.y, &j.pos.z, &j.orient.x, &j.orient.y, &j.orient.z)==6)
                {
                    j.orient.restorew();
                    j.scale = Vec3(1, 1, 1);
                    baseframe.add(j);
                }
            }
            if(baseframe.length()!=hierarchy.length()) { delete f; return false; }
            eposes.reserve(animframes*baseframe.length());
            eposes.advance(animframes*baseframe.length());
        }
        else if(sscanf(buf, " frame %d", &tmp)==1)
        {
            for(int numdata = 0; f->getline(buf, sizeof(buf)) && buf[0]!='}';)
            {
                for(char *src = buf, *next = src; numdata < animdatalen; numdata++, src = next)
                {
                    animdata[numdata] = strtod(src, &next);
                    if(next <= src) break;
                }
            }
            int offset = frameoffset + tmp*baseframe.length();
            eframes.add(offset);
            loopv(baseframe)
            {
                md5hierarchy &h = hierarchy[i];
                transform j = baseframe[i];
                if(h.start < animdatalen && h.flags)
                {
                    double *jdata = &animdata[h.start];
                    if(h.flags&1) j.pos.x = *jdata++;
                    if(h.flags&2) j.pos.y = *jdata++;
                    if(h.flags&4) j.pos.z = *jdata++;
                    if(h.flags&8) j.orient.x = *jdata++;
                    if(h.flags&16) j.orient.y = *jdata++;
                    if(h.flags&32) j.orient.z = *jdata++;
                    j.orient.restorew();
                }
                eposes[offset + i] = j;
            }
        }
    }

    if(animdata) delete[] animdata;
    delete f;

    eanim &a = eanims.add();
    if(spec.name) a.name = getnamekey(spec.name);
    else
    {
        string name;
        copystring(name, filename);
        char *end = strrchr(name, '.');
        if(end) *end = '\0';
        a.name = getnamekey(name);
    }
    a.startframe = firstframe;
    a.fps = spec.fps > 0 ? spec.fps : framerate;
    a.flags = spec.flags;
    if(spec.endframe >= 0) a.endframe = a.startframe + spec.endframe;
    else if(spec.endframe < -1) a.endframe = a.startframe + max(eframes.length() - a.startframe + spec.endframe + 1, 0);
    a.startframe += spec.startframe;

    makeanims();

    return true;
}

namespace smd
{

bool skipcomment(char *&curbuf)
{
    while(*curbuf && isspace(*curbuf)) curbuf++;
    switch(*curbuf)
    {
        case '#':
        case ';':
        case '\r':
        case '\n':
        case '\0':
            return true;
        case '/':
            if(curbuf[1] == '/') return true;
            break;
    }
    return false;
}

void skipsection(stream *f, char *buf, size_t bufsize)
{
    while(f->getline(buf, bufsize))
    {
        char *curbuf = buf;
        if(skipcomment(curbuf)) continue;
        if(!strncmp(curbuf, "end", 3)) break;
    }
}

void readname(char *&curbuf, char *name, size_t namesize)
{
    char *curname = name;
    while(*curbuf && isspace(*curbuf)) curbuf++;
    bool allowspace = false;
    if(*curbuf == '"') { curbuf++; allowspace = true; }
    while(*curbuf)
    {
        char c = *curbuf++;
        if(c == '"') break;
        if(isspace(c) && !allowspace) break;
        if(curname < &name[namesize-1]) *curname++ = c;
    }
    *curname = '\0';
}

void readnodes(stream *f, char *buf, size_t bufsize)
{
    while(f->getline(buf, bufsize))
    {
        char *curbuf = buf;
        if(skipcomment(curbuf)) continue;
        if(!strncmp(curbuf, "end", 3)) break;
        int id = strtol(curbuf, &curbuf, 10);
        string name;
        readname(curbuf, name, sizeof(name));
        int parent = strtol(curbuf, &curbuf, 10);
        if(id < 0 || id > 255 || parent > 255 || !name[0] || (ejoints.inrange(id) && ejoints[id].name)) continue;
        ejoint j;
        j.name = getnamekey(name);
        j.parent = parent;
        while(ejoints.length() <= id) ejoints.add();
        ejoints[id] = j;
    }
}

void readmaterial(char *&curbuf, char *mat, char *name, size_t matsize)
{
    char *curmat = mat;
    while(*curbuf && isspace(*curbuf)) curbuf++;
    char *ext = NULL;
    while(*curbuf)
    {
        char c = *curbuf++;
        if(isspace(c)) break;
        if(c == '.' && !ext) ext = curmat;
        if(curmat < &mat[matsize-1]) *curmat++ = c;
    }
    *curmat = '\0';
    if(!ext) ext = curmat;
    memcpy(name, mat, ext - mat);
    name[ext - mat] = '\0';
}

void readskeleton(stream *f, char *buf, size_t bufsize)
{
    int frame = -1, firstpose = -1;
    while(f->getline(buf, bufsize))
    {
        char *curbuf = buf;
        if(skipcomment(curbuf)) continue;
        if(sscanf(curbuf, " time %d", &frame) == 1) continue;
        else if(!strncmp(curbuf, "end", 3)) break;
        else if(frame != 0) continue;
        int bone;
        Vec3 pos, rot;
        if(sscanf(curbuf, " %d %lf %lf %lf %lf %lf %lf", &bone, &pos.x, &pos.y, &pos.z, &rot.x, &rot.y, &rot.z) != 7)
            continue;
        if(!ejoints.inrange(bone))
            continue;
        if(firstpose < 0)
        {
            firstpose = eposes.length();
            eposes.reserve(ejoints.length());
            eposes.advance(ejoints.length());
        }
        transform p(pos, Quat::fromangles(rot));
        eposes[firstpose + bone] = p;
    }
}

void readtriangles(stream *f, char *buf, size_t bufsize)
{
    emesh m;
    while(f->getline(buf, bufsize))
    {
        char *curbuf = buf;
        if(skipcomment(curbuf)) continue;
        if(!strncmp(curbuf, "end", 3)) break;
        string name, material;
        readmaterial(curbuf, material, name, sizeof(material));
        if(!m.name || strcmp(m.name, name))
        {
            if(m.name && etriangles.length() > m.firsttri) emeshes.add(m);
            m.name = getnamekey(name);
            m.material = getnamekey(material);
            m.firsttri = etriangles.length();
        }
        Vec4 *pos = epositions.reserve(3) + 2, *tc = etexcoords.reserve(3) + 2;
        Vec3 *norm = enormals.reserve(3) + 2;
        blendcombo *c = eblends.reserve(3) + 2;
        loopi(3)
        {
            char *curbuf;
            do
            {
                if(!f->getline(buf, bufsize)) goto endsection;
                curbuf = buf;
            } while(skipcomment(curbuf));
            int parent = -1, numlinks = 0, len = 0;
            if(sscanf(curbuf, " %d %lf %lf %lf %lf %lf %lf %lf %lf %d%n", &parent, &pos->x, &pos->y, &pos->z, &norm->x, &norm->y, &norm->z, &tc->x, &tc->y, &numlinks, &len) < 9) goto endsection;
            curbuf += len;
            pos->w = 1;
            tc->y = 1 - tc->y;
            tc->z = tc->w = 0;
            c->reset();
            double pweight = 0, tweight = 0;
            for(; numlinks > 0; numlinks--)
            {
                int bone = -1, len = 0;
                double weight = 0;
                if(sscanf(curbuf, " %d %lf%n", &bone, &weight, &len) < 2) break;
                curbuf += len;
                tweight += weight;
                if(bone == parent) pweight += weight;
                else c->addweight(weight, bone);
            }
            if(tweight < 1) pweight += 1 - tweight;
            if(pweight > 0) c->addweight(pweight, parent);
            c->finalize();
            --pos;
            --tc;
            --norm;
            --c;
        }
        etriangle &t = etriangles.add();
        loopi(3) t.vert[i] = epositions.length() + i;
        t.smoothgroup = 0;
        epositions.advance(3);
        enormals.advance(3);
        etexcoords.advance(3);
        eblends.advance(3);
    }
endsection:
    if(m.name && etriangles.length () > m.firsttri) emeshes.add(m);
}

int readframes(stream *f, char *buf, size_t bufsize)
{
    int frame = -1, numframes = 0, lastbone = ejoints.length(), frameoffset = eposes.length();
    while(f->getline(buf, bufsize))
    {
        char *curbuf = buf;
        if(skipcomment(curbuf)) continue;
        int nextframe = -1;
        if(sscanf(curbuf, " time %d", &nextframe) == 1)
        {
            for(; lastbone < ejoints.length(); lastbone++) eposes[frameoffset + frame*ejoints.length() + lastbone] = eposes[frameoffset + lastbone];
            if(nextframe >= numframes)
            {
                eposes.reserve(ejoints.length() * (nextframe + 1 - numframes));
                loopi(nextframe - numframes) 
                {
                    eframes.add(eposes.length());
                    eposes.put(&eposes[frameoffset], ejoints.length());
                }
                eframes.add(eposes.length());
                eposes.advance(ejoints.length());
                numframes = nextframe + 1;
            }
            frame = nextframe;
            lastbone = 0;
            continue;
        }
        else if(!strncmp(curbuf, "end", 3)) break;
        int bone;
        Vec3 pos, rot;
        if(sscanf(curbuf, " %d %lf %lf %lf %lf %lf %lf", &bone, &pos.x, &pos.y, &pos.z, &rot.x, &rot.y, &rot.z) != 7)
            continue;
        if(bone < 0 || bone >= ejoints.length())
            continue;
        for(; lastbone < bone; lastbone++) eposes[frameoffset + frame*ejoints.length() + lastbone] = eposes[frameoffset + lastbone];
        lastbone++;
        transform p(pos, Quat::fromangles(rot));
        eposes[frameoffset + frame*ejoints.length() + bone] = p;
    }
    for(; lastbone < ejoints.length(); lastbone++) eposes[frameoffset + frame*ejoints.length() + lastbone] = eposes[frameoffset + lastbone];
    return numframes;
}

}

bool loadsmd(const char *filename, const filespec &spec)
{
    stream *f = openfile(filename, "r");
    if(!f) return false;

    resetimporter();

    char buf[512];
    int version = -1, firstframe = eframes.length();
    bool hastriangles = false;
    while(f->getline(buf, sizeof(buf)))
    {
        char *curbuf = buf;
        if(smd::skipcomment(curbuf)) continue;
        if(sscanf(curbuf, " version %d", &version) == 1)
        {
            if(version != 1) { delete f; return false; }
        }
        else if(!strncmp(curbuf, "nodes", 5))
            smd::readnodes(f, buf, sizeof(buf));
        else if(!strncmp(curbuf, "triangles", 9))
        {
            smd::readtriangles(f, buf, sizeof(buf));
            hastriangles = true;
        }
        else if(!strncmp(curbuf, "skeleton", 8))
            smd::readframes(f, buf, sizeof(buf));
        else if(!strncmp(curbuf, "vertexanimation", 15))
            smd::skipsection(f, buf, sizeof(buf));
    }

    delete f;

    if(poses.length() && ejoints.length() && poses.length() != ejoints.length()) return false;

    if(hastriangles)
    {
        eframes.setsize(firstframe);
        smoothverts();
        makemeshes();
        makeanims();
    }
    else
    {
        eanim &a = eanims.add();
        if(spec.name) a.name = getnamekey(spec.name);
        else
        {
            string name;
            copystring(name, filename);
            char *end = strrchr(name, '.');
            if(end) *end = '\0';
            a.name = getnamekey(name);
        }
        a.startframe = firstframe;
        a.fps = spec.fps;
        a.flags = spec.flags;
        if(spec.endframe >= 0) a.endframe = a.startframe + spec.endframe;
        else if(spec.endframe < -1) a.endframe = a.startframe + max(eframes.length() - a.startframe + spec.endframe + 1, 0);
        a.startframe += spec.startframe;
        makeanims();
    }

    return true;
}

struct objvert { int attrib[3]; objvert() { attrib[0] = attrib[1] = attrib[2] = -1; } };
static inline uint hthash(const objvert &k) { return k.attrib[0] ^ k.attrib[1] ^ k.attrib[2]; };
static inline bool htcmp(const objvert &x, const objvert &y) { return x.attrib[0] == y.attrib[0] && x.attrib[1] == y.attrib[1] && x.attrib[2] == y.attrib[2]; }

void parseobjvert(char *s, vector<Vec3> &out)
{
    Vec3 &v = out.add(Vec3(0, 0, 0));
    while(isalpha(*s)) s++;
    loopi(3)
    {
        v[i] = strtod(s, &s);
        while(isspace(*s)) s++;
        if(!*s) break;
    }
}

bool parseobj(stream *f)
{
    vector<Vec3> attrib[3];
    char buf[512];
    hashtable<objvert, int> verthash;
    string meshname = "", matname = "";
    int curmesh = -1, smooth = 0;

    while(f->getline(buf, sizeof(buf)))
    {
        char *c = buf;
        while(isspace(*c)) c++;
        switch(*c)
        {
            case '#': continue;
            case 'v':
                if(isspace(c[1])) parseobjvert(c, attrib[0]);
                else if(c[1]=='t') parseobjvert(c, attrib[1]);
                else if(c[1]=='n') parseobjvert(c, attrib[2]);
                break;
            case 'g':
            {
                while(isalpha(*c)) c++;
                while(isspace(*c)) c++;
                char *name = c;
                size_t namelen = strlen(name);
                while(namelen > 0 && isspace(name[namelen-1])) namelen--;
                copystring(meshname, name, min(namelen+1, sizeof(meshname)));
                curmesh = -1;
                break;
            }
            case 'u':
            {
                if(strncmp(c, "usemtl", 6)) continue;
                while(isalpha(*c)) c++;
                while(isspace(*c)) c++;
                char *name = c;
                size_t namelen = strlen(name);
                while(namelen > 0 && isspace(name[namelen-1])) namelen--;
                copystring(matname, name, min(namelen+1, sizeof(matname)));
                curmesh = -1;
                break;
            }
            case 's':
            {
                if(!isspace(c[1])) continue;
                while(isalpha(*c)) c++;
                while(isspace(*c)) c++;
                int key = strtol(c, &c, 10);
                smooth = -1;
                loopv(esmoothgroups) if(esmoothgroups[i].key == key) { smooth = i; break; }
                if(smooth < 0)
                {
                    smooth = esmoothgroups.length();
                    esmoothgroups.add().key = key;
                }
                break;
            }
            case 'f':
            {
                if(curmesh < 0)
                {
                    emesh m;
                    m.name = getnamekey(meshname);
                    m.material = getnamekey(matname);
                    m.firsttri = etriangles.length();
                    curmesh = emeshes.length();
                    emeshes.add(m);
                    verthash.clear();
                }
                int v0 = -1, v1 = -1;
                while(isalpha(*c)) c++;
                for(;;)
                {
                    while(isspace(*c)) c++;
                    if(!*c) break;
                    objvert vkey;
                    loopi(3)
                    {
                        vkey.attrib[i] = strtol(c, &c, 10);
                        if(vkey.attrib[i] < 0) vkey.attrib[i] = attrib[i].length() + vkey.attrib[i];
                        else vkey.attrib[i]--;
                        if(!attrib[i].inrange(vkey.attrib[i])) vkey.attrib[i] = -1;
                        if(*c!='/') break;
                        c++;
                    }
                    int *index = verthash.access(vkey);
                    if(!index)
                    {
                        index = &verthash[vkey];
                        *index = epositions.length();
                        epositions.add(Vec4(vkey.attrib[0] < 0 ? Vec3(0, 0, 0) : attrib[0][vkey.attrib[0]].zxy(), 1));
                        if(vkey.attrib[2] >= 0) enormals.add(attrib[2][vkey.attrib[2]].zxy());
                        etexcoords.add(vkey.attrib[1] < 0 ? Vec4(0, 0, 0, 0) : Vec4(attrib[1][vkey.attrib[1]].x, 1-attrib[1][vkey.attrib[1]].y, 0, 0));
                    }
                    if(v0 < 0) v0 = *index;
                    else if(v1 < 0) v1 = *index;
                    else
                    {
                        etriangles.add(etriangle(*index, v1, v0, smooth));
                        v1 = *index;
                    }
                }
                break;
            }
        }
    }

    return true;
}

bool loadobj(const char *filename, const filespec &spec)
{
    stream *f = openfile(filename, "r");
    if(!f) return false;

    int numfiles = 0;
    while(filename)
    {
        const char *endfile = strchr(filename, ',');
        const char *file = endfile ? newstring(filename, endfile-filename) : filename;
        stream *f = openfile(file, "r");
        if(f)
        {
            if(resetimporter(numfiles > 0))
            {
                esmoothgroups[0].key = 0;
            }
            if(parseobj(f)) numfiles++;
            delete f;
        }

        if(!endfile) break;

        delete[] file;
        filename = endfile+1;
    }

    if(!numfiles) return false;

    smoothverts();
    makemeshes();

    return true;
}

namespace fbx
{
    struct token
    {
        enum { NONE, PROP, NUMBER, STRING, ARRAY, BEGIN, END, LINE };
        int type;
        union
        {
            char s[64];
            double f;
            int i;
        };

        token() : type(NONE) {} 
    };

    struct tokenizer
    {
        stream *f;
        char *pos;
        char buf[4096];

        void reset(stream *s) { f = s; pos = buf; buf[0] = '\0'; }
 
        bool parse(token &t)
        {
            for(;;)
            {
                while(isspace(*pos)) pos++;
                if(!*pos)
                {
                    bool more = f->getline(buf, sizeof(buf));
                    pos = buf;
                    if(!more) { buf[0] = '\0'; return false; }
                    t.type = token::LINE;
                    return true;
                }
                size_t slen = 0;
                switch(*pos)
                {
                    case ',':
                        pos++;
                        continue;
                    case ';':
                        pos++;
                        while(*pos) pos++;
                        continue;
                    case '{':
                        pos++;
                        t.type = token::BEGIN;
                        return true;
                    case '}':
                        pos++;
                        t.type = token::END;
                        return true;
                    case '"':
                        pos++;
                        for(; *pos && *pos != '"'; pos++) if(slen < sizeof(t.s)-1) t.s[slen++] = *pos;
                        t.s[slen] = '\0';
                        if(*pos == '"') pos++;
                        t.type = token::STRING;
                        return true;
                    case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '.': case '-': case '+':
                        t.f = strtod(pos, &pos);
                        t.type = token::NUMBER;
                        return true;
                    case '*':
                        pos++;
                        t.i = int(strtol(pos, &pos, 10));
                        t.type = token::ARRAY;
                        return true;
                    default:
                        for(; *pos && !isspace(*pos) && *pos != ':'; pos++) if(slen < sizeof(t.s)-1) t.s[slen++] = *pos;
                        t.s[slen] = '\0';
                        if(*pos == ':') pos++;
                        t.type = token::PROP;
                        return true;
                }
            }
            return false;
        }


        bool skipprop()
        {
            token t;
            while(parse(t)) switch(t.type)
            {
                case token::LINE:
                    return true;

                case token::BEGIN:
                    while(parse(t)) switch(t.type)
                    {
                        case token::PROP:
                            skipprop();
                            break;
                        case token::END:
                            return true;
                    }
                    return true;

                case token::END:
                    return false;
            }
            return false;
        }

        bool findbegin()
        {
            token t;
            while(parse(t)) switch(t.type)
            {
                case token::LINE: return false;
                case token::BEGIN: return true;
            }
            return false;
        }

        template<class T>
        bool readarray(vector<T> &vals, int size = 0)
        {
            if(!findbegin()) return false;

            if(size > 0) vals.reserve(min(size, 1<<16));
            token t;
            while(parse(t)) switch(t.type)
            {
                case token::NUMBER: if(size <= 0 || vals.length() < size) vals.add(T(t.f)); break;
                case token::END: return true;
            }
            return false;
        }
    };

    struct node
    {
        enum { GEOM = 0, MODEL, MATERIAL, LIMB, CLUSTER, SKIN, CURVE, XFORM, ANIMLAYER, ANIMSTACK };
        enum { TRANS = 0, ROT, SCALE };

        virtual int type() = 0;
        virtual ~node() {}

        virtual void process() {}
        virtual void finish() {}
    };

    struct namednode : node
    {
        string name;

        namednode() { name[0] = 0; }
    };
   
    struct geomnode;
    struct modelnode;
    struct materialnode;
    struct limbnode;
    struct clusternode;
    struct skinnode;
    struct curvenode;
    struct xformnode;
    struct animlayernode;
    struct animstacknode;

    struct geomnode : node
    {
        int mesh, firstvert, lastvert, numverts;
        modelnode *model;
        vector<int> remap;
        vector<blendcombo> blends;

        geomnode() : mesh(-1), firstvert(-1), lastvert(-1), numverts(0), model(NULL) {}
        int type() { return GEOM; } 

        void process();
        void finish();
    };

    struct modelnode : namednode
    {
        materialnode *material;
        Vec3 geomtrans, prerot, lcltrans, lclrot, lclscale;

        modelnode() : material(NULL), geomtrans(0, 0, 0), prerot(0, 0, 0), lcltrans(0, 0, 0), lclrot(0, 0, 0), lclscale(1, 1, 1) {}

        int type() { return MODEL; }
    };

    struct materialnode : namednode
    {
        int type() { return MATERIAL; }
    };

    struct limbnode : namednode
    {
        limbnode *parent;
        int index;
        Vec3 trans, rot, prerot, scale;
        clusternode *cluster;

        limbnode() : parent(NULL), index(-1), trans(0, 0, 0), rot(0, 0, 0), prerot(0, 0, 0), scale(1, 1, 1), cluster(NULL) {}

        int type() { return LIMB; }

        void process()
        { 
            if(parent) ejoints[index].parent = parent->index; 
        }

        void finish();
    };

    struct clusternode : node
    {
        skinnode *skin;
        limbnode *limb;
        vector<int> indexes;
        vector<double> weights, transform, transformlink;

        clusternode() : skin(NULL), limb(NULL) {}

        int type() { return CLUSTER; }

        void process();
    };

    struct skinnode : node
    {
        geomnode *geom;

        skinnode() : geom(NULL) {}

        int type() { return SKIN; }
    };

    struct curvenode : node
    {
        vector<double> vals;

        int type() { return CURVE; }

        bool varies() const
        {
            loopv(vals) if(vals[i] != vals[0]) return true;
            return false;
        }
    };

    struct xformnode : node
    {
        limbnode *limb;
        int xform;
        Vec3 val;
        curvenode *curves[3];

        xformnode() : limb(NULL), xform(-1), val(0, 0, 0) { curves[0] = curves[1] = curves[2] = NULL; }

        void setcurve(int i, curvenode *c)
        {
            if(c->varies()) curves[i] = c;
            else if(c->vals.length()) val[i] = c->vals[0];
        }

        int numframes()
        {
            int n = 0;
            loopi(3) if(curves[i]) { if(!n) n = curves[i]->vals.length(); else if(n != curves[i]->vals.length()) n = -1; }
            return n;
        }

        int type() { return XFORM; }
    };

    struct animlayernode : namednode
    {
        vector<xformnode *> xforms;

        int numframes()
        {
            int n = 0;
            loopv(xforms)
            {
                int xn = xforms[i]->numframes();
                if(xn) { if(!n) n = xn; else if(n != xn) n = -1; }
            }
            return n;
        }

        int type() { return ANIMLAYER; }
    };

    struct animstacknode : namednode
    {
        vector<animlayernode *> layers;
        double secs;

        animstacknode() : secs(0) {}

        int numframes()
        {
            int n;
            loopv(layers)
            {
                int ln = layers[i]->numframes();
                if(ln) { if(!n) n = ln; else if(n != ln) n = -1; }
            }
            return n;
        }
 
        int type() { return ANIMSTACK; }

        void process();
    };

    hashtable<double, node *> nodes;
    tokenizer p;

    void parsegeometry()
    {
        token t;
        if(!p.parse(t)) return;
        if(t.type != token::NUMBER) { p.skipprop(); return; }
        double id = t.f;
        if(!p.findbegin()) return;

        vector<double> verts, norms, uvs, colors;
        vector<int> polyidxs, uvidxs, coloridxs;
        while(p.parse(t)) switch(t.type)
        {
            case token::END:
                goto endgeometry;

            case token::PROP:
                if(!strcmp(t.s, "Vertices")) p.readarray(verts);
                else if(!strcmp(t.s, "PolygonVertexIndex")) p.readarray(polyidxs);
                else if(!strcmp(t.s, "LayerElementNormal"))
                {
                    if(p.findbegin())
                    {
                        while(p.parse(t)) switch(t.type)
                        {
                            case token::PROP:
                                if(!strcmp(t.s, "Normals")) p.readarray(norms);
                                else p.skipprop();
                                break;
                            case token::END:
                                goto endnormals;
                        }
                    endnormals:;
                    }
                }
                else if(!strcmp(t.s, "LayerElementUV"))
                {
                    if(p.findbegin())
                    {
                        while(p.parse(t)) switch(t.type)
                        {
                            case token::PROP:
                                if(!strcmp(t.s, "UV")) p.readarray(uvs);
                                else if(!strcmp(t.s, "UVIndex")) p.readarray(uvidxs);
                                else p.skipprop();
                                break;
                            case token::END:
                                goto enduvs;
                        }
                    enduvs:;
                    }
                }
                else if(!strcmp(t.s, "LayerElementColor"))
                {
                    if(p.findbegin())
                    {
                        while(p.parse(t)) switch(t.type)
                        {
                            case token::PROP:
                                if(!strcmp(t.s, "Colors")) p.readarray(colors);
                                else if(!strcmp(t.s, "ColorIndex")) p.readarray(coloridxs);
                                else p.skipprop();
                                break;
                            case token::END:
                                goto endcolors;
                        }
                    endcolors:;
                    }
                }
                else p.skipprop();
                break;
        }
    endgeometry:
        int poslen = epositions.length();
        geomnode *n = new geomnode;
        nodes[id] = n;
        if(polyidxs.empty()) for(int i = 0; i + 2 < verts.length(); i += 3) epositions.add(Vec4(verts[i], verts[i+1], verts[i+2], 1));
        else 
        {
            loopv(polyidxs)
            {
                int idx = polyidxs[i];
                if(idx < 0) idx = -(idx+1);
                n->remap.add(idx);
                idx *= 3;
                epositions.add(Vec4(verts[idx], verts[idx+1], verts[idx+2], 1));
            }
        }
        loopi(epositions.length() - poslen) eblends.add();
         
        emesh m;
        m.name = getnamekey("");
        m.material = getnamekey("");
        m.firsttri = etriangles.length();
        for(int i = poslen; i + 2 < epositions.length(); i += 3)
            etriangles.add(etriangle(i+1, i, i+2));
        emeshes.add(m);

        n->mesh = emeshes.length()-1;
        n->firstvert = poslen;
        n->lastvert = epositions.length();
        n->numverts = verts.length()/3;

        if(uvidxs.empty())
        {
            if(polyidxs.length() && uvs.length()/2 == verts.length()/3) loopv(polyidxs)
            {
                int idx = polyidxs[i];
                if(idx < 0) idx = -(idx+1);
                idx *= 2;
                etexcoords.add(Vec4(uvs[idx], 1-uvs[idx+1], 0, 0));
            }
            else for(int i = 0; i + 1 < uvs.length(); i += 2) etexcoords.add(Vec4(uvs[i], 1-uvs[i+1], 0, 0));
        }
        else loopv(uvidxs)
        {
            int idx = 2*uvidxs[i];
            etexcoords.add(Vec4(uvs[idx], 1-uvs[idx+1], 0, 0));
        }

        if(polyidxs.length() && norms.length() == verts.length()) loopv(polyidxs) 
        {
            int idx = polyidxs[i];
            if(idx < 0) idx = -(idx+1);
            idx *= 3;
            enormals.add(Vec3(norms[idx], norms[idx+1], norms[idx+2]));
        }
        else for(int i = 0; i + 2 < norms.length(); i += 3) enormals.add(Vec3(norms[i], norms[i+1], norms[i+2]));

        if(coloridxs.empty())
        {
            if(polyidxs.length() && colors.length()/4 == verts.length()/3) loopv(polyidxs)
            {
                int idx = polyidxs[i];
                if(idx < 0) idx = -(idx+1);
                idx *= 4;
                ecolors.add(Vec4(colors[idx], colors[idx+1], colors[idx+2], colors[idx+3]));
            }
            else for(int i = 0; i + 3 < colors.length(); i += 4) ecolors.add(Vec4(colors[i], colors[i+1], colors[i+2], colors[i+3]));
        }
        else loopv(coloridxs)
        {
            int idx = 4*coloridxs[i];
            ecolors.add(Vec4(colors[idx], colors[idx+1], colors[idx+2], colors[idx+3]));
        }
    }

    void parsemodel()
    {
        token id, name, type, t;
        if(!p.parse(id) || !p.parse(name) || !p.parse(type)) return;

        if(id.type != token::NUMBER || type.type != token::STRING || name.type != token::STRING) { p.skipprop(); return; }

        char *str = name.s;
        if(strstr(str, "Model::") == str) str += strlen("Model::");
        if(!strcmp(type.s, "Mesh"))
        {
            modelnode *n = new modelnode;
            copystring(n->name, str);
            nodes[id.f] = n;

            if(!p.findbegin()) return;
            while(p.parse(t)) switch(t.type)
            {
            case token::END: return;
            case token::PROP:
                if(!strcmp(t.s, "Properties70"))
                {
                    if(!p.findbegin()) return;
                    while(p.parse(t)) switch(t.type)
                    {
                    case token::END: goto endmeshprops;
                    case token::PROP:
                        if(!strcmp(t.s, "P"))
                        {
                            if(!p.parse(t)) return;
                            if(t.type == token::STRING)
                            {
                                if(!strcmp(t.s, "PreRotation"))
                                {
                                    loopi(3) if(!p.parse(t)) return;
                                    loopi(3) { if(!p.parse(t)) return; if(t.type != token::NUMBER) break; n->prerot[i] = t.f; }
                                }
                                else if(!strcmp(t.s, "GeometricTranslation"))
                                {
                                    loopi(3) if(!p.parse(t)) return;
                                    loopi(3) { if(!p.parse(t)) return; if(t.type != token::NUMBER) break; n->geomtrans[i] = t.f; }
                                }
                                else if(!strcmp(t.s, "Lcl Translation"))
                                {
                                    loopi(3) if(!p.parse(t)) return;
                                    loopi(3) { if(!p.parse(t)) return; if(t.type != token::NUMBER) break; n->lcltrans[i] = t.f; }
                                }
                                else if(!strcmp(t.s, "Lcl Rotation"))
                                {
                                    loopi(3) if(!p.parse(t)) return;
                                    loopi(3) { if(!p.parse(t)) return; if(t.type != token::NUMBER) break; n->lclrot[i] = t.f; }
                                }
                                else if(!strcmp(t.s, "Lcl Scaling"))
                                {
                                    loopi(3) if(!p.parse(t)) return;
                                    loopi(3) { if(!p.parse(t)) return; if(t.type != token::NUMBER) break; n->lclscale[i] = t.f; }
                                }
                            }
                        }
                        p.skipprop();
                        break;
                    }
                endmeshprops:;
                }
                p.skipprop();
                break;                
            }
        }
        else if(!strcmp(type.s, "LimbNode"))
        {
            limbnode *n = new limbnode;
            copystring(n->name, str);
            n->index = ejoints.length();
            nodes[id.f] = n;

            ejoint &j = ejoints.add();
            j.name = getnamekey(str);
            j.parent = -1;
            eposes.add(transform(Vec3(0, 0, 0), Quat(0, 0, 0, 1)));

            if(!p.findbegin()) return;            
            while(p.parse(t)) switch(t.type)
            { 
            case token::END: 
                {
                    transform &x = eposes[n->index];
                    x.pos = n->trans;
                    x.orient = Quat::fromdegrees(n->rot);
                    x.scale = n->scale;
                }
                return;
            case token::PROP:
                if(!strcmp(t.s, "Properties70"))
                {
                    if(!p.findbegin()) return;
                    while(p.parse(t)) switch(t.type)
                    {
                    case token::END: goto endlimbprops;
                    case token::PROP:
                        if(!strcmp(t.s, "P"))
                        {
                            if(!p.parse(t)) return;
                            if(t.type == token::STRING)
                            {
                                if(!strcmp(t.s, "PreRotation"))
                                {
                                    loopi(3) if(!p.parse(t)) return;
                                    loopi(3) { if(!p.parse(t)) return; if(t.type != token::NUMBER) break; n->prerot[i] = t.f; }
                                }
                                else if(!strcmp(t.s, "Lcl Translation"))
                                {
                                    loopi(3) if(!p.parse(t)) return;
                                    loopi(3) { if(!p.parse(t)) return; if(t.type != token::NUMBER) break; n->trans[i] = t.f; }
                                }
                                else if(!strcmp(t.s, "Lcl Rotation"))
                                {
                                    loopi(3) if(!p.parse(t)) return;
                                    loopi(3) { if(!p.parse(t)) return; if(t.type != token::NUMBER) break; n->rot[i] = t.f; }
                                }
                                else if(!strcmp(t.s, "Lcl Scaling"))
                                {
                                    loopi(3) if(!p.parse(t)) return;
                                    loopi(3) { if(!p.parse(t)) return; if(t.type != token::NUMBER) break; n->scale[i] = t.f; } 
                                }
                            }
                        }
                        p.skipprop();
                        break;
                    }
                endlimbprops:;
                }
                p.skipprop();
                break;
            }
        } 

        p.skipprop();
    }

    void parsematerial()
    {
        token id, name;
        if(!p.parse(id) || !p.parse(name)) return;

        if(id.type == token::NUMBER)
        {
            if(name.type == token::STRING)
            {
                char *str = name.s;
                if(strstr(str, "Material::") == str) str += strlen("Material::");
                materialnode *n = new materialnode;
                copystring(n->name, str);
                nodes[id.f] = n;
            }
        }

        p.skipprop();
    }

    void parsedeformer()
    {
        token id, name, type, t;
        if(!p.parse(id) || !p.parse(name) || !p.parse(type)) return;
        if(id.type != token::NUMBER || type.type != token::STRING || name.type != token::STRING)
        {
            p.skipprop();
            return;
        }

        if(!strcmp(type.s, "Skin"))
        {
            skinnode *n = new skinnode;
            nodes[id.f] = n;
        }
        else if(!strcmp(type.s, "Cluster"))
        {
            if(!p.findbegin()) return;

            clusternode *n = new clusternode;
            nodes[id.f] = n;
            while(p.parse(t)) switch(t.type)
            {
                case token::END: return;
                case token::PROP:
                    if(!strcmp(t.s, "Indexes")) p.readarray(n->indexes);
                    else if(!strcmp(t.s, "Weights")) p.readarray(n->weights);
                    else if(!strcmp(t.s, "Transform")) p.readarray(n->transform);
                    else if(!strcmp(t.s, "TransformLink")) p.readarray(n->transformlink);
                    else p.skipprop();
                    break;
            }
            return;
        }
        
        p.skipprop();
    }
       
    void parsecurve()
    {
        token id, t;
        if(!p.parse(id)) return;
        if(id.type != token::NUMBER) { p.skipprop(); return; }
        curvenode *n = new curvenode;
        nodes[id.f] = n;
        while(p.parse(t)) switch(t.type)
        {
            case token::END: return;
            case token::PROP:
                if(!strcmp(t.s, "KeyValueFloat")) p.readarray(n->vals);
                else p.skipprop();
                break;
        }
    }

    void parsexform()
    {
        token id, t;
        if(!p.parse(id)) return;
        if(id.type != token::NUMBER) { p.skipprop(); return; }
        if(!p.findbegin()) return;
        xformnode *n = new xformnode;
        nodes[id.f] = n;
        while(p.parse(t)) switch(t.type)
        {
            case token::END: return;
            case token::PROP:
                if(!strcmp(t.s, "Properties70"))
                {
                    if(!p.findbegin()) return;
                    while(p.parse(t)) switch(t.type)
                    {
                    case token::END: goto endprops;
                    case token::PROP:
                        if(!strcmp(t.s, "P"))
                        {
                            token name, type, val;
                            if(!p.parse(name) || !p.parse(type) || !p.parse(t) || !p.parse(t)) return;
                            if(name.type == token::STRING)
                            {
                                if(!strcmp(name.s, "d|X")) { if(p.parse(val) && val.type == token::NUMBER) n->val.x = val.f; }
                                else if(!strcmp(name.s, "d|Y")) { if(p.parse(val) && val.type == token::NUMBER) n->val.y = val.f; }
                                else if(!strcmp(name.s, "d|Z")) { if(p.parse(val) && val.type == token::NUMBER) n->val.z = val.f; }
                            } 
                        }
                        p.skipprop();
                        break;
                    }
                endprops:;
                }
                else p.skipprop();
                break;
        }
    }

    void parseanimlayer()
    {
        token id, name;
        if(!p.parse(id) || !p.parse(name)) return;
        if(id.type != token::NUMBER || name.type != token::STRING) { p.skipprop(); return; }

        char *str = name.s;
        if(strstr(str, "AnimLayer::") == str) str += strlen("AnimLayer::");
        animlayernode *n = new animlayernode;
        copystring(n->name, str);
        nodes[id.f] = n;

        p.skipprop();
    }

    #define FBX_SEC 46186158000.0

    void parseanimstack()
    {
        token id, name, t;
        if(!p.parse(id) || !p.parse(name)) return;
        if(id.type != token::NUMBER || name.type != token::STRING) { p.skipprop(); return; }

        char *str = name.s;
        if(strstr(str, "AnimStack::") == str) str += strlen("AnimStack::");
        animstacknode *n = new animstacknode;
        copystring(n->name, str);
        nodes[id.f] = n;

        if(!p.findbegin()) return;
        while(p.parse(t)) switch(t.type)
        {
            case token::END: return;
            case token::PROP:
                if(!strcmp(t.s, "Properties70"))
                {
                    if(!p.findbegin()) return;
                    while(p.parse(t)) switch(t.type)
                    {
                    case token::END: goto endprops;
                    case token::PROP:
                        if(!strcmp(t.s, "P"))
                        {
                            token name, type, val;
                            if(!p.parse(name) || !p.parse(type) || !p.parse(t) || !p.parse(t)) return;
                            if(name.type == token::STRING)
                            {
                                if(!strcmp(name.s, "LocalStop")) { if(p.parse(val) && val.type == token::NUMBER) n->secs = val.f / FBX_SEC; }
                            }
                        }
                        p.skipprop();
                        break;
                    }
                endprops:;
                }
                else p.skipprop();
                break;
        }
    }

    void parseobjects()
    {
        if(!p.findbegin()) return;

        token t;
        while(p.parse(t)) switch(t.type)
        {
            case token::END:
                return;

            case token::PROP:
                if(!strcmp(t.s, "Geometry")) parsegeometry();
                else if(!strcmp(t.s, "Model")) parsemodel();
                else if(!strcmp(t.s, "Material")) parsematerial();
                else if(!strcmp(t.s, "Deformer")) parsedeformer();
                else if(!strcmp(t.s, "AnimationCurve")) parsecurve();
                else if(!strcmp(t.s, "AnimationCurveNode")) parsexform();
                else if(!strcmp(t.s, "AnimationLayer")) parseanimlayer();
                else if(!strcmp(t.s, "AnimationStack")) parseanimstack();
                else p.skipprop();
                break;
        }
    }

    void parseconnection()
    {
        token type, from, to, prop;
        if(!p.parse(type) || !p.parse(from) || !p.parse(to)) return;
        if(type.type == token::STRING && from.type == token::NUMBER && to.type == token::NUMBER)
        {
            node *nf = nodes.find(from.f, NULL), *nt = nodes.find(to.f, NULL);
            if(!strcmp(type.s, "OO") && nf && nt)
            {
                if(nf->type() == node::GEOM && nt->type() == node::MODEL)
                    ((geomnode *)nf)->model = (modelnode *)nt;
                else if(nf->type() == node::MATERIAL && nt->type() == node::MODEL)
                    ((modelnode *)nt)->material = (materialnode *)nf;
                else if(nf->type() == node::LIMB && nt->type() == node::LIMB)
                    ((limbnode *)nf)->parent = (limbnode *)nt;
                else if(nf->type() == node::CLUSTER && nt->type() == node::SKIN)
                    ((clusternode *)nf)->skin = (skinnode *)nt;
                else if(nf->type() == node::SKIN && nt->type() == node::GEOM)
                    ((skinnode *)nf)->geom = (geomnode *)nt;
                else if(nf->type() == node::LIMB && nt->type() == node::CLUSTER)
                {
                    ((clusternode *)nt)->limb = (limbnode *)nf;
                    ((limbnode *)nf)->cluster = (clusternode *)nt;
                }
                else if(nf->type() == node::ANIMLAYER && nt->type() == node::ANIMSTACK)
                    ((animstacknode *)nt)->layers.add((animlayernode *)nf);
                else if(nf->type() == node::XFORM && nt->type() == node::ANIMLAYER)
                    ((animlayernode *)nt)->xforms.add((xformnode *)nf);
            }
            else if(!strcmp(type.s, "OP") && nf && nt && p.parse(prop) && prop.type == token::STRING)
            {
                if(nf->type() == node::CURVE && nt->type() == node::XFORM)
                {
                    if(!strcmp(prop.s, "d|X")) ((xformnode *)nt)->setcurve(0, (curvenode *)nf);
                    else if(!strcmp(prop.s, "d|Y")) ((xformnode *)nt)->setcurve(1, (curvenode *)nf);
                    else if(!strcmp(prop.s, "d|Z")) ((xformnode *)nt)->setcurve(2, (curvenode *)nf);
                }
                else if(nf->type() == node::XFORM && nt->type() == node::LIMB)
                {
                    ((xformnode *)nf)->limb = (limbnode *)nt;
                    if(!strcmp(prop.s, "Lcl Translation")) ((xformnode *)nf)->xform = xformnode::TRANS;
                    else if(!strcmp(prop.s, "Lcl Rotation")) ((xformnode *)nf)->xform = xformnode::ROT;
                    else if(!strcmp(prop.s, "Lcl Scaling")) ((xformnode *)nf)->xform = xformnode::SCALE; 
                }
            }
        } 
        p.skipprop();
    }

    void parseconnections()
    {
        if(!p.findbegin()) return;

        token t;
        while(p.parse(t)) switch(t.type)
        {
            case token::END:
                return;

            case token::PROP:
                if(!strcmp(t.s, "C")) parseconnection();
                else p.skipprop();
                break;
        }
    }

    void geomnode::process()
    {
        if(model)
        {
            emeshes[mesh].name = getnamekey(model->name);
            if(model->material) emeshes[mesh].material = getnamekey(model->material->name);
            if(model->geomtrans != Vec3(0, 0, 0)) for(int i = firstvert; i < lastvert; i++) epositions[i] += model->geomtrans;
            if(model->lclscale != Vec3(1, 1, 1))
            {
                for(int i = firstvert; i < lastvert; i++)
                {
                    epositions[i].setxyz(model->lclscale * Vec3(epositions[i]));
                }
            }
            if(model->lclrot != Vec3(0, 0, 0))
            {
                Quat lclquat = Quat::fromdegrees(model->lclrot);
                for(int i = firstvert; i < lastvert; i++)
                {
                    epositions[i].setxyz(lclquat.transform(Vec3(epositions[i])));
                    enormals[i] = lclquat.transform(enormals[i]);
                }
            }
            if(model->prerot != Vec3(0, 0, 0))
            {
                Quat prequat = Quat::fromdegrees(model->prerot);
                for(int i = firstvert; i < lastvert; i++) 
                {
                    epositions[i].setxyz(prequat.transform(Vec3(epositions[i])));
                    enormals[i] = prequat.transform(enormals[i]);
                }
            }
            if(model->lcltrans != Vec3(0, 0, 0)) for(int i = firstvert; i < lastvert; i++) epositions[i] += model->lcltrans;
        }
    }

    void clusternode::process()
    {
        if(!limb || limb->index > 255 || !skin || !skin->geom || indexes.length() != weights.length()) return;
        geomnode *g = skin->geom;
        if(g->blends.empty()) loopi(g->numverts) g->blends.add();
        loopv(indexes)
        {
            int idx = indexes[i];
            double weight = weights[i];
            g->blends[idx].addweight(weight, limb->index);
        }
    }

    void animstacknode::process()
    {
        if(layers.empty()) return;
        animlayernode *l = layers[0];
        int numframes = l->numframes();
        if(numframes < 0) return;

        eanim &a = eanims.add();
        a.name = getnamekey(name);
        a.startframe = eframes.length();
        a.fps = secs > 0 ? numframes/secs : 0;         

        transform *poses = eposes.reserve(numframes*ejoints.length());
        loopj(numframes) 
        {
            eframes.add(eposes.length());
            eposes.put(eposes.getbuf(), ejoints.length());
        }
        loopv(l->xforms)
        {
            xformnode &x = *l->xforms[i];
            if(!x.limb) continue;
            transform *dst = &poses[x.limb->index];
            loopj(numframes)
            {
                Vec3 val = x.val;
                loopk(3) if(x.curves[k]) val[k] = x.curves[k]->vals[j];
                switch(x.xform)
                {
                case xformnode::TRANS: dst->pos = val; break;
                case xformnode::ROT: dst->orient = Quat::fromdegrees(val); break;
                case xformnode::SCALE: dst->scale = val; break;
                } 
                dst += ejoints.length();
            }
        }
#if 0
        loopv(eposes)
        {
            transform &t = eposes[i];
            Matrix3x3 m(t.orient, t.scale);
            Vec3 mscale(Vec3(m.a.x, m.b.x, m.c.x).magnitude(), Vec3(m.a.y, m.b.y, m.c.y).magnitude(), Vec3(m.a.z, m.b.z, m.c.z).magnitude());
            if(m.determinant() < 0) mscale = -mscale;
            m.a /= mscale;
            m.b /= mscale;
            m.c /= mscale;
            Quat morient(m); if(morient.w > 0) morient.flip();
            t.orient = morient;
            t.scale = mscale;
        }
#endif
    }
 
    void geomnode::finish()
    {
        if(blends.empty()) return;

        loopv(blends) blends[i].finalize();
        while(eblends.length() < lastvert) eblends.add();
        if(remap.length()) loopv(remap) eblends[firstvert + i] = blends[remap[i]];
        else loopv(blends) eblends[firstvert + i] = blends[i];
    }

    void limbnode::finish()
    {
        if(prerot == Vec3(0, 0, 0)) return;
        Quat prequat = Quat::fromdegrees(prerot);
        for(int i = index; i < eposes.length(); i += ejoints.length())
            eposes[i].orient = prequat * eposes[i].orient;
    }

    bool checkversion(stream *f)
    {
        return f->getline(p.buf, sizeof(p.buf)) && strstr(p.buf, "FBX 7");
    }

    void parse(stream *f)
    {
        p.reset(f);
        token t;
        while(p.parse(t)) switch(t.type)
        {
            case token::PROP:
                if(!strcmp(t.s, "Objects")) parseobjects();
                else if(!strcmp(t.s, "Connections")) parseconnections();
                else p.skipprop();
                break;
        }
        enumerate(nodes, double, id, node *, n, { (void)id; n->process(); });
        enumerate(nodes, double, id, node *, n, { (void)id; n->finish(); });
        enumerate(nodes, double, id, node *, n, { (void)id; delete n; });
        nodes.clear();
    }
}

bool loadfbx(const char *filename, const filespec &spec)
{
    int numfiles = 0;
    while(filename)
    {
        const char *endfile = strchr(filename, ',');
        const char *file = endfile ? newstring(filename, endfile-filename) : filename;
        stream *f = openfile(file, "r");
        if(f)
        {
            if(fbx::checkversion(f)) 
            {
                resetimporter(numfiles > 0);
                numfiles++;
                fbx::parse(f);
            }
            delete f;
        }

        if(!endfile) break;

        delete[] file;
        filename = endfile+1; 
    } 

    if(!numfiles) return false;

    if(poses.length() && ejoints.length() && poses.length() != ejoints.length()) return false;

    if(eanims.length() == 1)
    {
        eanim &a = eanims.last();
        if(spec.name) a.name = spec.name;
        if(spec.fps > 0) a.fps = spec.fps;
        a.flags |= spec.flags;
        if(spec.endframe >= 0) a.endframe = a.startframe + spec.endframe;
        else if(spec.endframe < -1) a.endframe = a.startframe + max(eframes.length() - a.startframe + spec.endframe + 1, 0);
        a.startframe += spec.startframe;
    }

    erotate = Quat(M_PI/2, Vec3(1, 0, 0));

    if(emeshes.length())
    {
        smoothverts();
        makemeshes();
    }
    makeanims();

    return true;
}

int framesize = 0;
vector<ushort> animdata;

#define QUANTIZE(offset, base, scale) ushort(0.5f + (float(offset) - base) / scale)

void calcanimdata()
{
    if(frames.length()) loopv(poses)
    {
        pose &j = poses[i];
        loopk(10) { j.offset[k] = 1e16f; j.scale[k] = -1e16f; }
    }
    loopv(frames)
    {
        pose &j = poses[i%poses.length()];
        transform &f = frames[i];
        loopk(3) 
        {
            j.offset[k] = min(j.offset[k], float(f.pos[k]));
            j.scale[k] = max(j.scale[k], float(f.pos[k]));
        }
        loopk(4)
        {
            j.offset[3+k] = min(j.offset[3+k], float(f.orient[k]));
            j.scale[3+k] = max(j.scale[3+k], float(f.orient[k]));
        }
        loopk(3)
        {
            j.offset[7+k] = min(j.offset[7+k], float(f.scale[k]));
            j.scale[7+k] = max(j.scale[7+k], float(f.scale[k]));
        }
    }
    loopv(poses)
    {
        pose &j = poses[i];
        loopk(10) 
        {
            j.scale[k] -= j.offset[k];
            if(j.scale[k] >= 1e-10f) { framesize++; j.scale[k] /= 0xFFFF; j.flags |= 1<<k; } 
            else j.scale[k] = 0.0f;
        }
    }
#if 0
    int runlength = 0, blocksize = 0, blocks = 0;
    #define FLUSHVAL(val) \
        if(!blocksize || (animdata.last() == val ? runlength >= 0xFF : runlength || blocksize > 0xFF)) \
        { \
            animdata.add(0); \
            animdata.add(val); \
            blocksize = 1; \
            runlength = 0; \
            blocks++; \
        } \
        else if(animdata.last() == val) \
        { \
            animdata[animdata.length()-blocksize-1] += 0x10; \
            runlength++; \
        } \
        else \
        { \
            animdata[animdata.length()-blocksize-1]++; \
            animdata.add(val); \
            blocksize++; \
        }
    loopv(joints)
    {
        joint &j = joints[i];
        loopk(3) if(j.flags & (0x01<<k))
        {
            for(int l = i; l < frames.length(); l += poses.length())
            {
                transform &f = frames[l];
                ushort val = QUANTIZE(f.pos[k], j.offset[k], j.scale[k]);
                FLUSHVAL(val);
            }
        }
        loopk(4) if(j.flags & (0x08<<k))
        {
            for(int l = i; l < frames.length(); l += poses.length())
            {
                transform &f = frames[l];
                ushort val = QUANTIZE(f.orient[k], j.offset[3+k], j.scale[3+k]);
                FLUSHVAL(val);
            }
        }
        loopk(3) if(j.flags & (0x80<<k))
        {
            for(int l = i; l < frames.length(); l += poses.length())
            {
                transform &f = frames[l];
                ushort val = QUANTIZE(f.scale[k], j.offset[7+k], j.scale[7+k]);
                FLUSHVAL(val);
            }
        }
    }                    
    printf("%d frames of size %d/%d compressed from %d/%d to %d in %d blocks", frames.length()/poses.length(), framesize, poses.length()*9, framesize*frames.length()/poses.length(), poses.length()*9*frames.length()/poses.length(), animdata.length(), blocks);
#else
    loopv(frames)
    {
        pose &j = poses[i%poses.length()];
        transform &f = frames[i];
        loopk(3) if(j.flags & (0x01<<k)) animdata.add(QUANTIZE(f.pos[k], j.offset[k], j.scale[k]));
        loopk(4) if(j.flags & (0x08<<k)) animdata.add(QUANTIZE(f.orient[k], j.offset[3+k], j.scale[3+k]));
        loopk(3) if(j.flags & (0x80<<k)) animdata.add(QUANTIZE(f.scale[k], j.offset[7+k], j.scale[7+k]));
    }
#endif
    while(vdata.length()%4) vdata.add(0);
    while(stringdata.length()%4) stringdata.add('\0');
    while(commentdata.length()%4) commentdata.add('\0');
    while(animdata.length()%2) animdata.add(0);
}

bool writeiqm(const char *filename)
{
    stream *f = openfile(filename, "wb");
    if(!f) return false;

    iqmheader hdr;
    memset(&hdr, 0, sizeof(hdr));
    copystring(hdr.magic, IQM_MAGIC, sizeof(hdr.magic)); 
    hdr.filesize = sizeof(hdr);
    hdr.version = IQM_VERSION;
    if(stringdata.length()) hdr.ofs_text = hdr.filesize; hdr.num_text = stringdata.length(); hdr.filesize += hdr.num_text;
    hdr.num_meshes = meshes.length(); if(meshes.length()) hdr.ofs_meshes = hdr.filesize; hdr.filesize += meshes.length() * sizeof(mesh);
    uint voffset = hdr.filesize + varrays.length() * sizeof(vertexarray);
    hdr.num_vertexarrays = varrays.length(); if(varrays.length()) hdr.ofs_vertexarrays = hdr.filesize; hdr.filesize += varrays.length() * sizeof(vertexarray);
    uint valign = (8 - (hdr.filesize%8))%8;
    voffset += valign;
    hdr.filesize += valign + vdata.length();
    hdr.num_vertexes = vmap.length();
    hdr.num_triangles = triangles.length(); if(triangles.length()) hdr.ofs_triangles = hdr.filesize; hdr.filesize += triangles.length() * sizeof(triangle);
    if(neighbors.length()) hdr.ofs_adjacency = hdr.filesize; hdr.filesize += neighbors.length() * sizeof(triangle);
    hdr.num_joints = joints.length(); if(joints.length()) hdr.ofs_joints = hdr.filesize; hdr.filesize += joints.length() * sizeof(joint);
    hdr.num_poses = poses.length(); if(poses.length()) hdr.ofs_poses = hdr.filesize; hdr.filesize += poses.length() * sizeof(pose);
    hdr.num_anims = anims.length(); if(anims.length()) hdr.ofs_anims = hdr.filesize; hdr.filesize += anims.length() * sizeof(anim);
    hdr.num_frames = poses.length() ? frames.length()/poses.length() : 0; hdr.num_framechannels = framesize; 
    if(animdata.length()) hdr.ofs_frames = hdr.filesize; hdr.filesize += animdata.length() * sizeof(ushort); 
    if(bounds.length()) hdr.ofs_bounds = hdr.filesize; hdr.filesize += bounds.length() * sizeof(float[8]);
    if(commentdata.length()) hdr.ofs_comment = hdr.filesize; hdr.num_comment = commentdata.length(); hdr.filesize += hdr.num_comment;

    lilswap(&hdr.version, (sizeof(hdr) - sizeof(hdr.magic))/sizeof(uint));
    f->write(&hdr, sizeof(hdr));

    if(stringdata.length()) f->write(stringdata.getbuf(), stringdata.length());

    loopv(meshes)
    {
        mesh &m = meshes[i];
        f->putlil(m.name);
        f->putlil(m.material);
        f->putlil(m.firstvert);
        f->putlil(m.numverts);
        f->putlil(m.firsttri);
        f->putlil(m.numtris);
    }

    loopv(varrays)
    {
        vertexarray &v = varrays[i];
        f->putlil(v.type); 
        f->putlil(v.flags);
        f->putlil(v.format);
        f->putlil(v.size);
        f->putlil(voffset + v.offset);
    }

    loopi(valign) f->putchar(0);
    f->write(vdata.getbuf(), vdata.length());

    loopv(triangles)
    {
        triangle &t = triangles[i];
        loopk(3) f->putlil(t.vert[k]);
    }

    loopv(neighbors)
    {
        triangle &t = neighbors[i];
        loopk(3) f->putlil(t.vert[k]);
    }

    loopv(joints)
    {
        joint &j = joints[i];
        f->putlil(j.name);
        f->putlil(j.parent);
        loopk(3) f->putlil(float(j.pos[k]));
        loopk(4) f->putlil(float(j.orient[k]));
        loopk(3) f->putlil(float(j.scale[k]));
    }

    loopv(poses)
    {
        pose &p = poses[i];
        f->putlil(p.parent);
        f->putlil(p.flags);
        loopk(10) f->putlil(p.offset[k]);
        loopk(10) f->putlil(p.scale[k]);
    }

    loopv(anims)
    {
        anim &a = anims[i];
        f->putlil(a.name);
        f->putlil(a.firstframe);
        f->putlil(a.numframes);
        f->putlil(a.fps);
        f->putlil(a.flags);
    }

    loopv(animdata) f->putlil(animdata[i]);

    loopv(bounds)
    {
        framebounds &b = bounds[i];
        loopk(3) f->putlil(float(b.bbmin[k]));
        loopk(3) f->putlil(float(b.bbmax[k]));
        f->putlil(float(b.xyradius));
        f->putlil(float(b.radius));
    }

    if(commentdata.length()) f->write(commentdata.getbuf(), commentdata.length());

    delete f;
    return true;
}


void help(bool exitstatus = EXIT_SUCCESS)
{
    fprintf(exitstatus != EXIT_SUCCESS ? stderr : stdout,
"Usage:\n"
"\n"
"./iqm [options] output.iqm mesh.iqe anim1.iqe ... animN.iqe\n"
"./iqm [options] output.iqm mesh.md5mesh anim1.md5anim ... animN.md5anim\n"
"./iqm [options] output.iqm mesh.smd anim1.smd ... animN.smd\n"
"./iqm [options] output.iqm mesh.fbx anim1.fbx ... animN.fbx\n"
"./iqm [options] output.iqm mesh.obj\n"
"\n"
"For certain formats, IQE, OBJ, and FBX, it is possible to combine multiple mesh\n"
"files of the exact same vertex layout and skeleton by supplying them as\n"
"\"mesh1.iqe,mesh2.iqe,mesh3.iqe\", that is, a comma-separated list of the mesh\n"
"files (with no spaces) in place of the usual mesh filename.\n"
"\n"
"Options can be any of the following command-line switches:\n"
"\n"
"    -s N\n"
"    --scale N\n"
"      Sets the output scale to N (float).\n"
"\n"
"    --meshtrans Z\n"
"    --meshtrans X,Y,Z\n"
"      Translates a mesh by X,Y,Z (floats). This does not affect the skeleton.\n"
"\n"
"    -j\n"
"    --forcejoints\n"
"      Forces the exporting of joint information in animation files without\n"
"      meshes.\n"
"\n"
"Each animation file can be preceded by any combination of the following command-\n"
"line switches:\n"
"\n"
"    --name A\n"
"      Sets the name of the animation to A.\n"
"    --fps N\n"
"      Sets the FPS of the animation to N (float).\n"
"    --loop\n"
"      Sets the loop flag for the animation.\n"
"    --start N\n"
"      Sets the first frame of the animation to N (integer).\n"
"    --end N\n"
"      Sets the last frame of the animation to N (integer).\n"
"\n"
"You can supply either a mesh file, animation files, or both.\n"
"Note that if an input mesh file is supplied, it must come before the animation\n"
"files in the file list.\n"
"The output IQM file will contain the supplied mesh and any supplied animations.\n"
"If no mesh is provided,the IQM file will simply contain the supplied animations.\n"
    );
    exit(exitstatus);
}

int main(int argc, char **argv)
{
    if(argc <= 1) help(EXIT_FAILURE);

    vector<filespec> infiles;
    filespec inspec;
    const char *outfile = NULL;
    for(int i = 1; i < argc; i++)
    {
        if(argv[i][0] == '-') 
        {
            if(argv[i][1] == '-')
            {
                if(!strcasecmp(&argv[i][2], "fps")) { if(i + 1 < argc) inspec.fps = atof(argv[++i]); }
                else if(!strcasecmp(&argv[i][2], "name")) { if(i + 1 < argc) inspec.name = argv[++i]; }
                else if(!strcasecmp(&argv[i][2], "loop")) { inspec.flags |= IQM_LOOP; }
                else if(!strcasecmp(&argv[i][2], "start")) { if(i + 1 < argc) inspec.startframe = max(atoi(argv[++i]), 0); }
                else if(!strcasecmp(&argv[i][2], "end")) { if(i + 1 < argc) inspec.endframe = atoi(argv[++i]); }
                else if(!strcasecmp(&argv[i][2], "scale")) { if(i + 1 < argc) escale = clamp(atof(argv[++i]), 1e-8, 1e8); }
                else if(!strcasecmp(&argv[i][2], "help")) help();
                else if(!strcasecmp(&argv[i][2], "forcejoints")) forcejoints = true;
                else if(!strcasecmp(&argv[i][2], "meshtrans"))
                {
                    if(i + 1 < argc) switch(sscanf(argv[++i], "%lf , %lf , %lf", &emeshtrans.x, &emeshtrans.y, &emeshtrans.z))
                    {
                        case 1: emeshtrans = Vec3(0, 0, emeshtrans.x); break;
                    }
                }
            }
            else switch(argv[i][1])
            {
            case 'h':
                help();
                break;
            case 's':
                if(i + 1 < argc) escale = clamp(atof(argv[++i]), 1e-8, 1e8);
                break;
            case 'j':
                forcejoints = true;
                break;
            }
        }
        else if(!outfile) outfile = argv[i];
        else 
        {
            infiles.add(inspec).file = argv[i];
            inspec.reset();
        }
    }

    if(!outfile) fatal("no output file specified");
    else if(infiles.empty()) fatal("no input files specified");

    if(escale != 1) printf("scale: %f\n", escale);
    if(emeshtrans != Vec3(0, 0, 0)) printf("mesh translate: %f, %f, %f\n", emeshtrans.x, emeshtrans.y, emeshtrans.z);

    loopv(infiles)
    {
        const filespec &inspec = infiles[i];
        const char *infile = inspec.file, *type = strrchr(infile, '.');
        if(!type) fatal("no file type: %s", infile);
		else if(!strcasecmp(type, ".md5mesh"))
        {
			if(loadmd5mesh(infile, inspec)) conoutf("imported: %s", infile);
			else fatal("failed reading: %s", infile);
		}
		else if(!strcasecmp(type, ".md5anim"))
		{
			if(loadmd5anim(infile, inspec)) conoutf("imported: %s", infile);
			else fatal("failed reading: %s", infile);
		}
        else if(!strcasecmp(type, ".iqe"))
        {
            if(loadiqe(infile, inspec)) conoutf("imported: %s", infile);
            else fatal("failed reading: %s", infile);
        }
        else if(!strcasecmp(type, ".smd"))
        {
            if(loadsmd(infile, inspec)) conoutf("imported: %s", infile);
            else fatal("failed reading: %s", infile);
        }
        else if(!strcasecmp(type, ".fbx"))
        {
            if(loadfbx(infile, inspec)) conoutf("imported: %s", infile);
            else fatal("failed reading: %s", infile);
        }
        else if(!strcasecmp(type, ".obj"))
        {
            if(loadobj(infile, inspec)) conoutf("imported: %s", infile);
            else fatal("failed reading: %s", infile);
        }
		else fatal("unknown file type: %s", type);	 
	}

	calcanimdata();

    conoutf("");

	if(writeiqm(outfile)) conoutf("exported: %s", outfile);
	else fatal("failed writing: %s", outfile);

	return EXIT_SUCCESS;
}