RoomLoader.h

Go to the documentation of this file.

#ifndef _ROOM_LOADER_H
#define _ROOM_LOADER_H

#include "Tool.h"
#include "Geometry.h"

namespace APRoomEdit {

    // tool to load room from xml
    class RoomLoader : public Tool {
        public:
            RoomLoader(std::string f) {filename = f; type=LOADER; useEG=true;}
            virtual ~RoomLoader() {}

            virtual bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *pParametersNode) {
                if (findXMLNode(pParametersNode, "FileName")) {
                    ReaderWriter::getStringValue(filename, pParametersNode, "FileName");
                    name = filename;
                    if (findXMLNode(pParametersNode, "UseEmbeddedGeometry")) {
                        useEG = ReaderWriter::getBoolValue(pParametersNode, "UseEmbeddedGeometry");
                    }
                }
                else
                    return false;
                return true;
            }

            virtual void init(osgUtil::LineSegmentIntersector::Intersection* intersection,
                WG_Wall* curWall,
                WG_Point* curPoint,
                PointType type,
                vrecko::EnvironmentObject* pEOOwner,
                std::vector<osg::ref_ptr<WG_Wall> >* walls,
                std::vector<osg::ref_ptr<WG_Point> >* points,
                osg::Geode* pOSGGeode,
                osg::Vec3Array* pOSGVertexArray) {

                    //verify if given file exists
                    std::ifstream file(filename.c_str());
                    if(!file) {
                        logger.errorLog("RoomEdit Plugin: ERROR in loading scene - file: '%s' doesn't exists", filename.c_str());
                        return;
                    }

                    file.close();

                    // Notify user
                    vrecko::logger.noticeLog("RoomEdit Plugin: Loading model from %s", filename.c_str());
                    std::vector<osg::ref_ptr<WG_Point> > tempPoints;

                    // Create XML parser and parse the input file
                    XercesDOMParser* Parser = new XercesDOMParser();
                    const char* F;
                    F = (filename.c_str());
                    Parser->parse(F);
                    XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* Document = Parser->getDocument();

                    // Get root
                    XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* RootNode = Document->getDocumentElement();

                    //XMLCh tempStr[100];


                    XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* wallGeometryNode = findXMLNode(RootNode, "WallGeometry");


                    int id;
                    osg::Vec2 position;
                    float height = RE_DEFAULT_HEIGHT;
                    WG_Point* tempPoint;
                    XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* pointsNodes = findXMLNode(RootNode, "Points");
                    int pointSize = ReaderWriter::getIntValue(pointsNodes, "PointsCount");
                    tempPoints.resize(pointSize);

                    // Go through all Points
                    for (int i = 1; i < pointSize+1; i++) {
                        XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* pointNode = pointsNodes->getChildNodes()->item(i);
                        id = ReaderWriter::getIntValue(pointNode, "Id");
                        height = ReaderWriter::getFloatValue(pointNode, "Height");
                        ReaderWriter::getVec2Value(position, pointNode, "Position");

                        std::cout << id << ": " << height << ", " << position.x() << ", " << position.y() << std::endl;

                        tempPoint = new WG_Point(position, height);
                        tempPoint->setId(id);
                        tempPoints[id] = tempPoint;
                    }


                    XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* wallsNodes = findXMLNode(RootNode, "Walls");
                    int wallSize = ReaderWriter::getIntValue(wallsNodes, "WallsCount");

                    if (wallSize) {
                        points->clear();
                        for (unsigned int a=0; a<tempPoints.size(); a++)
                            points->push_back(tempPoints.at(a));
                        tempPoints.clear();
                    }
                    else {
                        vrecko::logger.warningLog("No walls included. Model will not be changed.");
                        tempPoints.clear();
                        return;
                    }

                    walls->clear();

                    int qId, rId;
                    WG_Wall* tempWall;
                    osg::Vec3 tempVec3;
                    osg::Vec2 tempVec2;
                    // Go through all Points
                    for (int j = 1; j < wallSize+1; j++) {
                        XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* wallNode = wallsNodes->getChildNodes()->item(j);
                        XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* qNode = findXMLNode(wallNode, "QPoint");
                        XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* rNode = findXMLNode(wallNode, "RPoint");
                        qId = ReaderWriter::getIntValue(qNode, "Id");
                        rId = ReaderWriter::getIntValue(rNode, "Id");

                        cout<< "loaded ids "<< j <<": " << qId << ", " << rId << endl;

                        tempWall = new WG_Wall(points->at(qId).get(), points->at(rId).get(), false);

                        ReaderWriter::getVec3Value(tempVec3, qNode, "Color");
                        tempWall->setColor(tempVec3, WG_Q_POINT);

                        ReaderWriter::getVec3Value(tempVec3, rNode, "Color");
                        tempWall->setColor(tempVec3, WG_R_POINT);

                        if (useEG) {
                            ReaderWriter::getVec3Value(tempVec3, qNode, "tCWV");
                            tempWall->getVertices(WG_Q_POINT)->setTopCWVertex(tempVec3);

                            ReaderWriter::getVec3Value(tempVec3, qNode, "tCCWV");
                            tempWall->getVertices(WG_Q_POINT)->setTopCCWVertex(tempVec3);

                            ReaderWriter::getVec3Value(tempVec3, qNode, "bCWV");
                            tempWall->getVertices(WG_Q_POINT)->setBottomCWVertex(tempVec3);

                            ReaderWriter::getVec3Value(tempVec3, qNode, "bCCWV");
                            tempWall->getVertices(WG_Q_POINT)->setBottomCCWVertex(tempVec3);

                            ReaderWriter::getVec2Value(tempVec2, qNode, "nCWV");
                            tempWall->getVertices(WG_Q_POINT)->setNormalCWVertex(tempVec2);

                            ReaderWriter::getVec2Value(tempVec2, qNode, "nCCWV");
                            tempWall->getVertices(WG_Q_POINT)->setNormalCCWVertex(tempVec2);

                            ReaderWriter::getVec3Value(tempVec3, rNode, "tCWV");
                            tempWall->getVertices(WG_R_POINT)->setTopCWVertex(tempVec3);

                            ReaderWriter::getVec3Value(tempVec3, rNode, "tCCWV");
                            tempWall->getVertices(WG_R_POINT)->setTopCCWVertex(tempVec3);

                            ReaderWriter::getVec3Value(tempVec3, rNode, "bCWV");
                            tempWall->getVertices(WG_R_POINT)->setBottomCWVertex(tempVec3);

                            ReaderWriter::getVec3Value(tempVec3, rNode, "bCCWV");
                            tempWall->getVertices(WG_R_POINT)->setBottomCCWVertex(tempVec3);

                            ReaderWriter::getVec2Value(tempVec2, rNode, "nCWV");
                            tempWall->getVertices(WG_R_POINT)->setNormalCWVertex(tempVec2);

                            ReaderWriter::getVec2Value(tempVec2, rNode, "nCCWV");
                            tempWall->getVertices(WG_R_POINT)->setNormalCCWVertex(tempVec2);

                            ReaderWriter::getVec3Value(tempVec3, wallNode, "topNormal");
                            tempWall->setTopNormal(tempVec3);

                            ReaderWriter::getVec3Value(tempVec3, wallNode, "bottomNormal");
                            tempWall->setBottomNormal(tempVec3);

                            ReaderWriter::getVec3Value(tempVec3, wallNode, "qrNormal");
                            tempWall->setFaceNormal(tempVec3, WG_Q_POINT);

                            ReaderWriter::getVec3Value(tempVec3, wallNode, "rqNormal");
                            tempWall->setFaceNormal(tempVec3, WG_R_POINT);
                        }


                        walls->push_back(tempWall);
                    }

                    if (useEG)
                        for (unsigned int k=0; k<walls->size(); k++) {
                            walls->at(k)->setFlag(RE_WALL_DRAWN);
                        }
                    else
                        for (unsigned int k=0; k<walls->size(); k++) {
                            if (!(walls->at(k)->getFlag() & RE_WALL_DRAWN)) {
                                walls->at(k)->computeAttrVertices();
                            }
                        }

                    delete Parser;

                    setDirty(true);
            }

        private:
            std::string filename;
            bool useEG;
    };

}

#endif