WallGeometry.h

Go to the documentation of this file.

#ifndef _WALL_GEOMETRY_H
#define _WALL_GEOMETRY_H

#include <vrecko/ReaderWriter.h>

#include <vrecko/Ability.h>
#include <vrecko/Scene.h>
#include <vrecko/EnvironmentObject.h>
#include <vrecko/Logger.h>

#include <helpers/XercesXMLUtils.h>
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/sax/HandlerBase.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/PlatformUtils.hpp>

#include <osgDB/ReadFile>

#include <osg/Geometry>
#include <osg/Geode>
#include <osg/StateSet>
#include <osg/Material>
#include <osg/CullFace>
#include <osg/LightModel>
#include <vrecko/Scene.h>

#include <sstream>
#include <vector>
#include <set>
#include <map>

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

using namespace vrecko;
using namespace vrecko;
using namespace WGeometry;

namespace APRoomEdit {

class WallGeometry: public Ability {
    private:
        // pointer to parent enviroment object
        EnvironmentObject* pEOOwner;

        // pointer to a geode of the room
        osg::Geode* pOSGGeode;

        // pointer to vertex array
        osg::Vec3Array* pOSGVertexArray;

        // source filename
        string filename;

        // array of walls to be drawn
        std::vector<osg::ref_ptr<WG_Wall> > walls;

        // array of points
        std::vector<osg::ref_ptr<WG_Point> > points;

        // key is the lowest index of the quad value is wall or point that contains the quad
        // the index is returned by the LineSegmentIntersection.indexList.at(0)
        std::map<unsigned int, WG_Wall*> wallMap;
        std::map<unsigned int, WG_Point*> pointMap;

        bool dirty;

        // info for tools
        WG_Wall* selectedWall;
        WG_Point* selectedPoint;
        PointType selectedType;

        // creates additional quads if there are two walls connected to the point
        void setCorner(WG_Point* P, WG_Wall* wall, WG_Vertices* vertices, PointType type, PointType opType,
                       osg::Vec3& TCWV, osg::Vec3& TCCWV, osg::Vec3& BCWV, osg::Vec3& BCCWV);

    public:
        // constructor
        WallGeometry();

        // destructor
        virtual ~WallGeometry();

        // called as the first initialization method, before loadXMLParameters
        virtual void preInitialize();

        // called as the last initialization method, after loadXMLParameters
        virtual void postInitialize();

        // loads XML parameters from given node
        virtual bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *pParametersNode);

        inline osg::Geode* getGeode() { return pOSGGeode; }

        void createDefaultRoom();

        void setDirty() { dirty = true; }

        void draw();

        WG_Wall* getWall(osgUtil::LineSegmentIntersector::Intersection* intersection) {
            unsigned int index = intersection->indexList.at(0);
            return (wallMap.find(index) != wallMap.end() ? wallMap[index] : NULL);
        }

        WG_Point* getPoint(osgUtil::LineSegmentIntersector::Intersection* intersection) {
            unsigned int index = intersection->indexList.at(0);
            WG_Wall* wall = getWall(intersection);
            WG_Point* point = NULL;
            osg::Vec2 vectorQ, vectorR;
            if (wall != NULL) {
                vectorQ = osg::Vec2(intersection->getLocalIntersectPoint().x(), intersection->getLocalIntersectPoint().z()) - wall->getPoint(WG_Q_POINT)->getPosition();
                vectorR = osg::Vec2(intersection->getLocalIntersectPoint().x(), intersection->getLocalIntersectPoint().z()) - wall->getPoint(WG_R_POINT)->getPosition();
                point = (vectorQ.length() < vectorR.length() ? wall->getPoint(WG_Q_POINT) : wall->getPoint(WG_R_POINT));
            }
            else
                point = (pointMap.find(index) != pointMap.end() ? pointMap[index] : NULL);

            return point;
        }

        void activateTool(Tool* tool, osgUtil::LineSegmentIntersector::Intersection* intersection) {
            if ((tool == NULL) || (tool->getType() == NONE))
                return;

            selectedWall = getWall(intersection);
            selectedPoint = getPoint(intersection);

            if (selectedWall != NULL) {
                osg::Vec2 tempVector = osg::Vec2(intersection->getLocalIntersectPoint().x(), intersection->getLocalIntersectPoint().z());

                WG_Point* tempPoint = selectedWall->getPoint(WG_Q_POINT);
                tempVector = tempVector - tempPoint->getPosition();

                float angle = WG_Geometry::getAngle(tempVector);
                angle = angle - selectedWall->getAngle(WG_Q_POINT);
                if (angle < 0)
                    angle += 360.0f;

                selectedType = (angle > 180 ? WG_R_POINT : WG_Q_POINT);
            }

            tool->init(intersection, selectedWall, selectedPoint, selectedType, pEOOwner, &walls, &points, pOSGGeode, pOSGVertexArray);

            if (tool->isDirty()) {
                setDirty();
                tool->setDirty(false);
            }
        }


        void deactivateTool(Tool* tool, osgUtil::LineSegmentIntersector::Intersection* intersection) {
            if ((tool == NULL) || (tool->getType() == NONE))
                return;

            tool->terminate(intersection, selectedWall, selectedPoint, selectedType, pEOOwner, &walls, &points, pOSGGeode, pOSGVertexArray);

            if (tool->isDirty()) {
                setDirty();
                tool->setDirty(false);
            }
        }

        void updateTool(Tool* tool, osgUtil::LineSegmentIntersector::Intersection* intersection, osg::Vec3 movingVector) {
            if ((tool == NULL) || (tool->getType() == NONE))
                return;

            tool->update(intersection, selectedWall, selectedPoint, selectedType, pEOOwner, &walls, &points, pOSGGeode, pOSGVertexArray, movingVector);

            if (tool->isDirty()) {
                setDirty();
                tool->setDirty(false);
            }
        }
};

}

#endif