aseloader.h

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
*/

#ifndef SHEEP_MESHIO_ASELOADER_H
#define SHEEP_MESHIO_ASELOADER_H

#include "imeshbuilder.h"
#include "imeshloader.h"
#include "keywordtable.h"

#include <cassert>
#include <cstdio>
#include <map>
#include <string>
#include <vector>

namespace sheep {

    class ProgressMonitor;

    class ASELoader : public IMeshLoader {
    public:
        struct ExtendedLoadingException : public LoadingException {
            ExtendedLoadingException(int line) :
                m_line(line) {}

            const int m_line;   //!< The line at which the parse error occured.
        };

        //! File structure is broken.
        struct ParsingException : public ExtendedLoadingException {
            ParsingException(int line) : ExtendedLoadingException(line) {}
        };

        ASELoader();

        virtual void Load(
            const std::string &filename,
            IMeshBuilder &builder,
            int option_mask = DEFAULT_CONFIGURATION_BIT,
            ProgressMonitor *progmon = 0
        ) throw(LoadingException);

    private:
        enum symbol {
            END_OF_FILE = 256, IDENTIFIER,
            STRING, INTEGER, DOUBLE,

            //! Keywords.
            BITMAP, GEOMOBJECT, MAP_DIFFUSE, MATERIAL, MATERIAL_AMBIENT,
            MATERIAL_DIFFUSE, MATERIAL_LIST, MATERIAL_NAME, MATERIAL_REF,
            MATERIAL_SPECULAR, MESH, MESH_FACE, MESH_FACE_LIST,
            MESH_FACENORMAL, MESH_MTLID, MESH_NORMALS, MESH_SMOOTHING,
            MESH_TFACE, MESH_TFACELIST, MESH_TVERT, MESH_TVERTLIST, MESH_VERTEX,
            MESH_VERTEX_LIST, MESH_VERTEXNORMAL, NODE_NAME, SUBMATERIAL,
            WIREFRAME_COLOR,

            //! Unknown keyword.
            UNKNOWN_KEYWORD
        };

        struct look_ahead {
            int m_sym;
            struct m_val_u {
                std::string m_str;  //!< For IDENTIFIER and STRING.
                int m_int;          //!< For INTEGER.
                double m_dbl;       //!< For DOUBLE.
            } m_val;
        };

        KeywordTable m_keyword_table;

        std::string m_path;

        IMeshBuilder::IGeometryBuilder *m_geombuilder;
        IMeshBuilder::IMaterialBuilder *m_matbuilder;

        int m_option_mask;

        ProgressMonitor *m_progmon; //!< May be 0.

        FILE *m_file;
        int m_line;     //!< Current line number.
        look_ahead m_look_ahead;

        int m_geomobject_index; //!< This is used to number each *GEOMOBJECT, starting from 0.

        struct material_key {
            int m_material_index;
            int m_submaterial_index;

            material_key(int material_index, int submaterial_index) :
                m_material_index(material_index),
                m_submaterial_index(submaterial_index) {}

            bool operator<(const material_key &k) const {
                if(m_material_index < k.m_material_index)
                    return true;
                if(m_material_index > k.m_material_index)
                    return false;
                return m_submaterial_index < k.m_submaterial_index;
            }
        };

        //! Material ID for each pair (material_index, submaterial_index).
        std::map<material_key, IMeshBuilder::FeatureId> m_mat_key_to_mat_id;

        //! This map associates to each material index the number of submaterials for
        //! the corresponding material.
        std::map<int, int> m_submaterial_count;

        struct mesh_data {
            //!< Structure of a triangular face.
            struct face {
                int m_vertex_index[3];      //!< Face vertices (indices into the m_vertices vector).
                int m_texcoord_index[3];    //!< Face texture coordinates (indices into the m_texcoords vector).
                int m_normal_index[3];      //!< Face normals (indices into the m_normals vector).
                std::vector<int> m_sg;      //!< Indices of each smooth group this face belongs to.
                int m_submaterial_index;    //!< Submaterial index.
            };

            std::vector<Vector3> m_vertices;
            std::vector<Vector2> m_texcoords;
            std::vector<Vector3> m_normals;
            std::vector<face> m_faces;

            //! Value of the *MATERIAL_REF property, or -1 if this property has not been defined.
            int m_material_index;

            //! True if a color has been assigned to this mesh using the *WIREFRAME_COLOR keyword.
            bool m_has_wf_color;

            //! Color to use if the *MATERIAL_REF property was not defined and the *WIREFRAME_COLOR
            //! was defined.
            double m_wf_r, m_wf_g, m_wf_b;

            mesh_data() :
                m_material_index(-1),   // no material assigned to this mesh yet
                m_has_wf_color(false)   // no wireframe color
            {
                // Wireframe color is left undefined.
            }
        };

        typedef std::vector<mesh_data *> mesh_data_vector;

        mesh_data_vector m_mesh_data;

        void parse_error();

        int read_char();
        void unread_char(int c);
        int look_ahead() const;

        void next();

        void accept(int token);
        std::string accept_string();
        int accept_integer();
        double accept_double();

        void skip_compound();
        void skip_statement();

        void parse_file();

        void parse_geomobject();
        void parse_map_diffuse();
        void parse_material(
            int material_index,
            bool is_submaterial = false,
            int submaterial_index = 0);
        void parse_material_list();
        void parse_mesh();
        void parse_mesh_face_list();
        void parse_mesh_normals();
        void parse_mesh_tfacelist();
        void parse_mesh_tvertlist();
        void parse_mesh_vertex_list();

        void dispatch_mesh_data();
    };

#include "aseloader.inl"

}

#endif  // !SHEEP_MESHIO_ASELOADER_H

---