Subversion Repositories gelsvn

#include <iostream>
#include "Util/Timer.h"
#include "Util/Parse.h"
#include "Util/XmlParser.h"
#include "HMesh/Manifold.h"
#include "build_manifold.h"
#include "x3d_load.h"

using namespace CGLA;
using namespace Util;
using namespace std;
using namespace HMesh;

namespace HMesh
{
                namespace
                {
                                vector<int> faces;
                                vector<int> indices;
                                vector<Vec3f> vertices;

                                void coord_index_to_face_vec(const vector<int>& coord_index, 
                                                                                                                                                 vector<int>& faces,
                                                                                                                                                 vector<int>& indices)
                                {
                                                Face face;
                                                size_t k=0;
                                                for(size_t i=0;i<coord_index.size();i++) 
                                                {
                                                                int idx = coord_index[i];
                                                                if (idx==-1) 
                                                                {
                                                                                faces.push_back(k);
                                                                                k=0;
                                                                }
                                                                else
                                                                {
                                                                                indices.push_back(idx);
                                                                                ++k;
                                                                }
                                                }
                                }

                }
        
    void handle_X3D(XmlElement& elem)
    {
      elem.process_elements();
    }

    void handle_Scene(XmlElement& elem)
    {
      elem.process_elements();
    }

    void handle_Transform(XmlElement& elem)
    {
      elem.process_elements();
    }

    void handle_Shape(XmlElement& elem)
    {
      cout << "Found shape" << endl;
      elem.process_elements();
                        cout << "Shape ends" << endl;                           
    }

    void handle_IndexedFaceSet(XmlElement& elem)
    {
                        vector<int> coord_index;
                        parse(elem.atts["coordIndex"].c_str(), coord_index);
                        coord_index_to_face_vec(coord_index, faces, indices);
    }

    void handle_Coordinate(XmlElement& elem)
    {
                  parse(elem.atts["point"].c_str(), vertices);
    }

                int find_last_of(const std::string& F, const std::string& C)
                {
                                size_t pos = F.find_last_of(C);
                                if (pos == string::npos) 
                                                return -1;
                                return pos;
                }

                bool x3d_load(const std::string& filename, Manifold& mani) 
                {
                                faces.clear();
                                indices.clear();
                                vertices.clear();

                                Timer tim;
                                tim.start();

                                std::string baseurl;
                                int idx = s_max(find_last_of(filename, "\\"), 
                                                                                                find_last_of(filename, "/"));

                                if(idx != -1)
                                                baseurl = std::string(filename.substr(0, idx+1));

        XmlDoc x3d_doc(filename.c_str());
        x3d_doc.add_handler("X3D", handle_X3D);
        x3d_doc.add_handler("Scene", handle_Scene);
        x3d_doc.add_handler("Shape", handle_Shape);
        x3d_doc.add_handler("Transform", handle_Transform);
        x3d_doc.add_handler("IndexedFaceSet", handle_IndexedFaceSet);
        x3d_doc.add_handler("Coordinate", handle_Coordinate);
        x3d_doc.process_elements();

                                build_manifold(mani, vertices.size(), &vertices[0], faces.size(),
                                                                                         &faces[0], &indices[0]);

                                cout << " Loading took " << tim.get_secs() << endl;
                                return false;
                }
}