aseloader.cpp

Go to the documentation of this file.

/*
    Sheep - A Rigid Body Dynamics Engine
    Copyright (C) 2001-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of Sheep.

    Sheep is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    Sheep is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Sheep; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "aseloader.h"  // include first
#include "common/misc/progressmonitor.h"
#include "common/misc/stringutils.h"

#include <algorithm>
#include <cctype>
#include <IL/il.h>

//#define VERBOSE

#ifdef VERBOSE
#include <iostream>
#endif  // VERBOSE

using namespace sheep;
using namespace std;

ASELoader::ASELoader() {
    m_keyword_table.Insert("BITMAP", BITMAP);
    m_keyword_table.Insert("GEOMOBJECT", GEOMOBJECT);
    m_keyword_table.Insert("MAP_DIFFUSE", MAP_DIFFUSE);
    m_keyword_table.Insert("MATERIAL", MATERIAL);
    m_keyword_table.Insert("MATERIAL_AMBIENT", MATERIAL_AMBIENT);
    m_keyword_table.Insert("MATERIAL_DIFFUSE", MATERIAL_DIFFUSE);
    m_keyword_table.Insert("MATERIAL_LIST", MATERIAL_LIST);
    m_keyword_table.Insert("MATERIAL_NAME", MATERIAL_NAME);
    m_keyword_table.Insert("MATERIAL_REF", MATERIAL_REF);
    m_keyword_table.Insert("MATERIAL_SPECULAR", MATERIAL_SPECULAR);
    m_keyword_table.Insert("MESH", MESH);
    m_keyword_table.Insert("MESH_FACE", MESH_FACE);
    m_keyword_table.Insert("MESH_FACE_LIST", MESH_FACE_LIST);
    m_keyword_table.Insert("MESH_FACENORMAL", MESH_FACENORMAL);
    m_keyword_table.Insert("MESH_MTLID", MESH_MTLID);
    m_keyword_table.Insert("MESH_NORMALS", MESH_NORMALS);
    m_keyword_table.Insert("MESH_SMOOTHING", MESH_SMOOTHING);
    m_keyword_table.Insert("MESH_TFACE", MESH_TFACE);
    m_keyword_table.Insert("MESH_TFACELIST", MESH_TFACELIST);
    m_keyword_table.Insert("MESH_TVERT", MESH_TVERT);
    m_keyword_table.Insert("MESH_TVERTLIST", MESH_TVERTLIST);
    m_keyword_table.Insert("MESH_VERTEX", MESH_VERTEX);
    m_keyword_table.Insert("MESH_VERTEX_LIST", MESH_VERTEX_LIST);
    m_keyword_table.Insert("MESH_VERTEXNORMAL", MESH_VERTEXNORMAL);
    m_keyword_table.Insert("NODE_NAME", NODE_NAME);
    m_keyword_table.Insert("SUBMATERIAL", SUBMATERIAL);
    m_keyword_table.Insert("WIREFRAME_COLOR", WIREFRAME_COLOR);
}

void ASELoader::Load(const string &filename,
                     IMeshBuilder &builder,
                     int option_mask /*= DEFAULT_CONFIGURATION_BIT*/,
                     ProgressMonitor *progmon /*= 0*/)
{
    m_path = StringUtils::GetPath(filename);

    m_geombuilder = builder.GeometryBuilder();
    m_matbuilder = builder.MaterialBuilder();

    m_option_mask = option_mask;

    m_progmon = progmon;

    m_file = fopen(filename.c_str(), "r");

    if(!m_file)
        throw FileNotFoundException(filename);

    if(m_progmon) {
        fseek(m_file, 0, SEEK_END);
        m_progmon->StartJob(0, ftell(m_file));
        fseek(m_file, 0, SEEK_SET);
    }

    m_line = 1;

    next();

    m_geomobject_index = 0;

    m_mat_key_to_mat_id.clear();
    m_mesh_data.clear();

    parse_file();

    if(m_geombuilder)
        dispatch_mesh_data();

    if(m_progmon)
        m_progmon->Done();

    fclose(m_file);
}

void ASELoader::parse_error() {
    //!\todo Close files and free resources.
    throw ParsingException(m_line);
}

void ASELoader::next() {
    int c;

    // Eat blanks.
    do {
        c = read_char();
    } while(isspace(c));

    // End of file.
    if(c == EOF)
        m_look_ahead.m_sym = END_OF_FILE;

    // Identifier.
    else if(isalpha(c) || c == '_') {
        m_look_ahead.m_sym = IDENTIFIER;
        m_look_ahead.m_val.m_str = "";

        while(isalpha(c)) {
            m_look_ahead.m_val.m_str += c;

            c = read_char();
        }

        unread_char(c);
    }

    // String.
    else if(c == '"') {
        m_look_ahead.m_sym = STRING;
        m_look_ahead.m_val.m_str = "";

        while(true) {
            c = read_char();

            if(c == '"')
                break;

            m_look_ahead.m_val.m_str += c;
        }
    }

    // Number (integer or double).
    else if(c == '+' || c == '-' || c == '.' || isdigit(c)) {
        string number;
        number = c;

        while(true) {
            c = read_char();

            if(!(isdigit(c) || c == '.'))
                break;

            number += c;
        }

        unread_char(c);

        if(number.find('.') == string::npos) {
            m_look_ahead.m_sym = INTEGER;
            m_look_ahead.m_val.m_int = atoi(number.c_str());
        } else {
            m_look_ahead.m_sym = DOUBLE;
            m_look_ahead.m_val.m_dbl = atof(number.c_str());
        }
    }

    // Keyword.
    else if(c == '*') {
        string keyword = "";

        while(true) {
            c = read_char();

            if(!(isalnum(c) || c == '_'))
                break;

            keyword += c;
        }

        unread_char(c);

        const int symbol = m_keyword_table.GetSymbol(keyword);

        m_look_ahead.m_sym = (symbol == -1) ? UNKNOWN_KEYWORD : symbol;
    }

    // Single character.
    else {
        assert(c != EOF);
        m_look_ahead.m_sym = c;
    }
}

void ASELoader::accept(int token) {
    if(look_ahead() == token)
        next();
    else parse_error();
}

string ASELoader::accept_string() {
    if(look_ahead() != STRING)
        parse_error();

    const string s = m_look_ahead.m_val.m_str;

    next();

    return s;
}

int ASELoader::accept_integer() {
    if(look_ahead() != INTEGER)
        parse_error();

    const int n = m_look_ahead.m_val.m_int;

    next();

    return n;
}

double ASELoader::accept_double() {
    double d;

    if(look_ahead() == DOUBLE)
        d = m_look_ahead.m_val.m_dbl;
    else if(look_ahead() == INTEGER)
        d = m_look_ahead.m_val.m_int;
    else {
        d = 0.0;    // keep the compiler happy
        parse_error();
    }

    next();

    return d;
}

void ASELoader::skip_compound() {
    accept('{');

    while(true) {
        const int token = look_ahead();

        if(token == '{')
            skip_compound();
        else if(token == '}')
            break;
        else next();
    }

    accept('}');
}

void ASELoader::skip_statement() {
    while(true) {
        next();

        const int token = look_ahead();

        if(token == '{') {
            skip_compound();
            break;
        } else if(token == '}')
            break;
        else if(m_keyword_table.IsKeyword(token))
            break;
    }
}

void ASELoader::parse_file() {
    while(true) {
        switch(look_ahead()) {
        case MATERIAL_LIST:
            if(m_matbuilder)
                parse_material_list();
            else skip_statement();
            break;
        case GEOMOBJECT:
            if(m_geombuilder)
                parse_geomobject();
            else skip_statement();
            ++m_geomobject_index;
            break;
        case UNKNOWN_KEYWORD:
            skip_statement();
            break;
        case END_OF_FILE:
            return;
        default:
            parse_error();
        }
    }
}

void ASELoader::parse_geomobject() {
    accept(GEOMOBJECT); // *GEOMOBJECT
    accept('{');

    m_mesh_data.push_back(new mesh_data());

    while(true) {
        switch(look_ahead()) {

        case MESH:
            parse_mesh();
            break;

        case MATERIAL_REF:
            accept(MATERIAL_REF);   // *MATERIAL_REF
            m_mesh_data.back()->m_material_index = accept_integer();
            break;

        case NODE_NAME:
            {
                accept(NODE_NAME);  // *NODE_NAME

                const string mesh_name = accept_string(); 

#ifdef VERBOSE
                cerr << "[ASELoader] Loading mesh '" << mesh_name << "'..." << endl;
#endif  // VERBOSE
            }
            break;

        case WIREFRAME_COLOR:
            accept(WIREFRAME_COLOR);    // *WIREFRAME_COLOR
            m_mesh_data.back()->m_has_wf_color = true;
            m_mesh_data.back()->m_wf_r = accept_double();
            m_mesh_data.back()->m_wf_g = accept_double();
            m_mesh_data.back()->m_wf_b = accept_double();
            break;

        case UNKNOWN_KEYWORD:
            skip_statement();
            break;

        case '}':
            accept('}');
            return;

        default:
            parse_error();

        }
    }
}

void ASELoader::parse_map_diffuse() {
    accept(MAP_DIFFUSE);    // *MAP_DIFFUSE
    accept('{');

    while(true) {
        switch(look_ahead()) {

        case BITMAP:
            {
                accept(BITMAP); // *BITMAP

                ILuint image_id;

                ilGenImages(1, &image_id);
                ilBindImage(image_id);

                const string filename = accept_string();

                if(TryLoadingImage(m_path, filename)) {
                    const int w = ilGetInteger(IL_IMAGE_WIDTH);
                    const int h = ilGetInteger(IL_IMAGE_HEIGHT);

                    unsigned char *texels = new unsigned char[w * h * 3];

                    ilCopyPixels(0, 0, 0, w, h, 1, IL_RGB, IL_UNSIGNED_BYTE, texels);

                    ilDeleteImages(1, &image_id);

                    m_matbuilder->SetTexture(w, h, texels);

                    delete [] texels;
                } else {
                    //!\todo Close files and free resources.

                    // There is no distinction between a missing texture file
                    // and an invalid texture file.
                    if(m_option_mask & STOP_ON_MISSING_FILE_BIT) {
                        m_matbuilder->EndMaterial();
                        throw FileNotFoundException(filename);
                    }

                    // Ignore invalid or missing texture file.
                }
            }
            break;

        case UNKNOWN_KEYWORD:
            skip_statement();
            break;

        case '}':
            accept('}');
            return;

        default:
            parse_error();

        }
    }
}

void ASELoader::parse_material(int material_index,
                               bool is_submaterial /*= false*/,
                               int submaterial_index /*= 0*/)
{
    accept('{');

    bool close_material = true;

    const material_key key(material_index, submaterial_index);

    if(!is_submaterial || submaterial_index != 0)
        m_mat_key_to_mat_id[key] = m_matbuilder->BeginMaterial("");

    while(true) {
        switch(look_ahead()) {

        case MAP_DIFFUSE:
            parse_map_diffuse();
            break;

        case MATERIAL_AMBIENT:
            {
                accept(MATERIAL_AMBIENT);   // *MATERIAL_AMBIENT

                const Real r = accept_double();
                const Real g = accept_double();
                const Real b = accept_double();

                m_matbuilder->SetAmbientColor(r, g, b);
            }
            break;

        case MATERIAL_DIFFUSE:
            {
                accept(MATERIAL_DIFFUSE);   // *MATERIAL_DIFFUSE

                const Real r = accept_double();
                const Real g = accept_double();
                const Real b = accept_double();

                m_matbuilder->SetDiffuseColor(r, g, b);
            }
            break;

        case MATERIAL_SPECULAR:
            {
                accept(MATERIAL_SPECULAR);  // *MATERIAL_SPECULAR

                const Real r = accept_double();
                const Real g = accept_double();
                const Real b = accept_double();

                m_matbuilder->SetSpecularColor(r, g, b);
            }
            break;

        case MATERIAL_NAME:
            {
                accept(MATERIAL_NAME);      // *MATERIAL_NAME
                const string material_name = accept_string();

#ifdef VERBOSE
                cerr << "[ASELoader] Loading material '" << material_name << "'..." << endl;
#endif  // VERBOSE
            }
            break;

        case SUBMATERIAL:
            {
                assert(!is_submaterial);    // forbid *SUBMATERIAL inside *SUBMATERIAL

                close_material = false;

                // This material has one more submaterial.
                ++m_submaterial_count[material_index];

                accept(SUBMATERIAL);    // *SUBMATERIAL
                const int submaterial_index = accept_integer();

                parse_material(
                    material_index,
                    true,
                    submaterial_index);
            }
            break;

        case UNKNOWN_KEYWORD:
            skip_statement();
            break;

        case '}':
            accept('}');
            if(close_material)
                m_matbuilder->EndMaterial();
            return;

        default:
            parse_error();
        }
    }
}

void ASELoader::parse_material_list() {
    accept(MATERIAL_LIST);  // *MATERIAL_LIST
    accept('{');

    while(true) {
        switch(look_ahead()) {
        case MATERIAL:
            {
                accept(MATERIAL);   // *MATERIAL
                const int material_index = accept_integer();
                parse_material(material_index);
            }
            break;
        case UNKNOWN_KEYWORD:
            skip_statement();
            break;
        case '}':
            accept('}');
            return;
        default:
            parse_error();
        }

        if(m_progmon) {
            m_progmon->SetJobProgress(ftell(m_file));
        }
    }
}

void ASELoader::parse_mesh() {
    accept(MESH);   // *MESH
    accept('{');

    while(true) {
        switch(look_ahead()) {
        case MESH_FACE_LIST:
            parse_mesh_face_list();
            break;
        case MESH_NORMALS:
            parse_mesh_normals();
            break;
        case MESH_TFACELIST:
            parse_mesh_tfacelist();
            break;
        case MESH_TVERTLIST:
            parse_mesh_tvertlist();
            break;
        case MESH_VERTEX_LIST:
            parse_mesh_vertex_list();
            break;
        case UNKNOWN_KEYWORD:
            skip_statement();
            break;
        case '}':
            accept('}');
            return;
        default:
            parse_error();
        }

        if(m_progmon) {
            m_progmon->SetJobProgress(ftell(m_file));
        }
    }
}

void ASELoader::parse_mesh_face_list() {
    accept(MESH_FACE_LIST); // *MESH_FACE_LIST
    accept('{');

    while(true) {
        switch(look_ahead()) {
        case MESH_FACE:
            {
                mesh_data::face f;

                for(int i = 0; i < 3; ++i) {
                    f.m_texcoord_index[i] = -1;     // no texture coordinates by default
                    f.m_normal_index[i] = -1;       // no normals by default
                }

                accept(MESH_FACE);      // *MESH_FACE
                accept(INTEGER);        // face index
                accept(':');

                for(int i = 0; i < 3; ++i) {
                    accept(IDENTIFIER); // A, B, C
                    accept(':');
                    f.m_vertex_index[i] = accept_integer();
                }

                for(int i = 0; i < 3; ++i) {
                    accept(IDENTIFIER); // AB, BC, CA
                    accept(':');
                    accept(INTEGER);    // edge visibility (0 or 1)
                }

                accept(MESH_SMOOTHING); // *MESH_SMOOTHING

                if(look_ahead() == INTEGER) {
                    f.m_sg.push_back(accept_integer()); // smooth group index

                    while(true) {
                        if(look_ahead() == ',')
                            accept(',');
                        else if(look_ahead() == MESH_MTLID)
                            break;
                        else parse_error();

                        if(look_ahead() == INTEGER)
                            f.m_sg.push_back(accept_integer()); // smooth group index
                        else if(look_ahead() == MESH_MTLID)
                            break;
                        else parse_error();
                    }
                }

                accept(MESH_MTLID);     // *MESH_MTLID
                f.m_submaterial_index = accept_integer();

                assert(f.m_submaterial_index >= 0);

                m_mesh_data.back()->m_faces.push_back(f);
            }
            break;
        case UNKNOWN_KEYWORD:
            skip_statement();
            break;
        case '}':
            accept('}');
            return;
        default:
            parse_error();
        }
    }
}

void ASELoader::parse_mesh_normals() {
    accept(MESH_NORMALS);   // *MESH_NORMALS
    accept('{');

    while(true) {
        switch(look_ahead()) {
        case MESH_FACENORMAL:
            {
                accept(MESH_FACENORMAL);        // *MESH_FACENORMAL

                const int face_index = accept_integer();
                mesh_data::face &f = m_mesh_data.back()->m_faces[face_index];

                // Skip face normal coordinates.
                accept(DOUBLE);
                accept(DOUBLE);
                accept(DOUBLE);

                for(int i = 0; i < 3; ++i) {
                    accept(MESH_VERTEXNORMAL);  // *MESH_VERTEXNORMAL
                    accept(INTEGER);            // vertex index

                    Vector3 n;

                    n.m_x = accept_double();
                    n.m_z = -accept_double();
                    n.m_y = accept_double();

                    n.Normalize();

                    f.m_normal_index[i] = m_mesh_data.back()->m_normals.size();
                    m_mesh_data.back()->m_normals.push_back(n);
                }
            }
            break;
        case UNKNOWN_KEYWORD:
            skip_statement();
            break;
        case '}':
            accept('}');
            return;
        default:
            parse_error();
        }
    }
}

void ASELoader::parse_mesh_tfacelist() {
    accept(MESH_TFACELIST); // *MESH_TFACELIST
    accept('{');

    while(true) {
        switch(look_ahead()) {
        case MESH_TFACE:
            {
                accept(MESH_TFACE); // *MESH_TFACE

                const int face_index = accept_integer();
                mesh_data::face &f = m_mesh_data.back()->m_faces[face_index];

                f.m_texcoord_index[0] = accept_integer();
                f.m_texcoord_index[1] = accept_integer();
                f.m_texcoord_index[2] = accept_integer();
            }
            break;
        case UNKNOWN_KEYWORD:
            skip_statement();
            break;
        case '}':
            accept('}');
            return;
        default:
            parse_error();
        }
    }
}

void ASELoader::parse_mesh_tvertlist() {
    accept(MESH_TVERTLIST); // *MESH_TVERTLIST
    accept('{');

    while(true) {
        switch(look_ahead()) {
        case MESH_TVERT:
            {
                accept(MESH_TVERT); // *MESH_TVERT
                accept(INTEGER);    // texture coordinate index

                Vector2 v;

                v.m_x = accept_double();
                v.m_y = -accept_double();

                // Skip W coordinate.
                accept(DOUBLE);

                m_mesh_data.back()->m_texcoords.push_back(v);
            }
            break;
        case UNKNOWN_KEYWORD:
            skip_statement();
            break;
        case '}':
            accept('}');
            return;
        default:
            parse_error();
        }
    }
}

void ASELoader::parse_mesh_vertex_list() {
    accept(MESH_VERTEX_LIST);   // *MESH_VERTEX_LIST
    accept('{');

    while(true) {
        switch(look_ahead()) {
        case MESH_VERTEX:
            {
                accept(MESH_VERTEX);    // *MESH_VERTEX
                accept(INTEGER);        // vertex index

                Vector3 v;

                v.m_x = accept_double();
                v.m_z = -accept_double();
                v.m_y = accept_double();

                m_mesh_data.back()->m_vertices.push_back(v);
            }
            break;
        case UNKNOWN_KEYWORD:
            skip_statement();
            break;
        case '}':
            accept('}');
            return;
        default:
            parse_error();
        }
    }
}

void ASELoader::dispatch_mesh_data() {
    assert(m_geombuilder);

    // For each mesh data block.
    for(mesh_data_vector::iterator i = m_mesh_data.begin(),
        ie = m_mesh_data.end(); i != ie; ++i)
    {
        mesh_data *mesh = *i;
        const int submaterial_count = m_submaterial_count[mesh->m_material_index];

        // Fix submaterial indices.
        for(vector<mesh_data::face>::iterator j = mesh->m_faces.begin(),
            je = mesh->m_faces.end(); j != je; ++j)
        {
            mesh_data::face &f = *j;

            if(submaterial_count > 0)
                f.m_submaterial_index %= submaterial_count;
            else f.m_submaterial_index = 0;
        }

        vector<int> submaterial_index_vector;

        // Gather submaterial indices.
        for(vector<mesh_data::face>::const_iterator j = mesh->m_faces.begin(),
            je = mesh->m_faces.end(); j != je; ++j)
        {
            const mesh_data::face &f = *j;
            submaterial_index_vector.push_back(f.m_submaterial_index);
        }

        // Remove duplicates from the submaterial index vector.
        sort(submaterial_index_vector.begin(), submaterial_index_vector.end());
        submaterial_index_vector.erase(
            unique(submaterial_index_vector.begin(), submaterial_index_vector.end()),
            submaterial_index_vector.end());

        for(vector<int>::const_iterator j = submaterial_index_vector.begin(),
            je = submaterial_index_vector.end(); j != je; ++j)
        {
            const int submaterial_index = *j;

            // Create a new mesh.
            m_geombuilder->BeginSubMesh("");

            if(m_matbuilder) {
                if(mesh->m_material_index == -1) {
                    // No material has been assigned to the mesh, use the wireframe color if defined.
                    if(mesh->m_has_wf_color) {
                        const IMeshBuilder::FeatureId material_id =
                            m_matbuilder->BeginMaterial("");
                        m_matbuilder->SetDiffuseColor(
                            mesh->m_wf_r, mesh->m_wf_g, mesh->m_wf_b);
                        m_matbuilder->EndMaterial();
                        m_geombuilder->SetMaterial(material_id);
                    }
                } else {
                    // Assign the right material to the mesh.
                    const material_key key(mesh->m_material_index, submaterial_index);
                    assert(m_mat_key_to_mat_id.find(key) != m_mat_key_to_mat_id.end());
                    const IMeshBuilder::FeatureId material_id = m_mat_key_to_mat_id[key];
                    m_geombuilder->SetMaterial(material_id);
                }
            }

            map<int, IMeshBuilder::FeatureId> global_vertex_id;

            for(vector<mesh_data::face>::const_iterator k = mesh->m_faces.begin(),
                ke = mesh->m_faces.end(); k != ke; ++k)
            {
                const mesh_data::face &f = *k;

                if(f.m_submaterial_index != submaterial_index)
                    continue;

                IMeshBuilder::FeatureId vertex_id[3];

                // Append face vertices to the current mesh.
                for(int i = 0; i < 3; ++i) {
                    const int vertex_index = f.m_vertex_index[i];

                    if(global_vertex_id.find(vertex_index) == global_vertex_id.end()) {
                        global_vertex_id[vertex_index] = vertex_id[i] =
                            m_geombuilder->AppendVertex(mesh->m_vertices[vertex_index]);
                    } else vertex_id[i] = global_vertex_id[vertex_index];
                }

                // Append the new face to the current mesh.
                const IMeshBuilder::FeatureId face_id = m_geombuilder->AppendFace(3, vertex_id);

                if(f.m_texcoord_index[0] != -1) {
                    IMeshBuilder::FeatureId texcoord_id[3];

                    // Append face texture coordinates to the current mesh.
                    for(int i = 0; i < 3; ++i) {
                        const int texcoord_index = f.m_texcoord_index[i];
                        texcoord_id[i] = m_geombuilder->AppendTexCoord(mesh->m_texcoords[texcoord_index]);
                    }

                    // Set texture coordinates for current face vertices.
                    m_geombuilder->SetFaceTexCoords(face_id, 3, texcoord_id);
                }

                if(f.m_normal_index[0] != -1) {
                    IMeshBuilder::FeatureId normal_id[3];

                    // Append face normals to the current mesh.
                    for(int i = 0; i < 3; ++i) {
                        const int normal_index = f.m_normal_index[i];
                        normal_id[i] = m_geombuilder->AppendNormal(mesh->m_normals[normal_index]);
                    }

                    // Set normals for current face vertices.
                    m_geombuilder->SetFaceNormals(face_id, 3, normal_id);
                }
            }

            // Close the mesh.
            m_geombuilder->EndSubMesh();
        }

        delete mesh;
    }
}

---