DtDynamicTerrainParser.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2018 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 

 
#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtArticulatedModelParser.h>
#include <vrvOsg/DtDynamicTerrainSwitchNode.h>
#include <vrvOsg/DtDynamicTerrainStateManipulatorFactory.h>

#include <vrvCore/DtDynamicTerrainWorld.h>

#include <vlutil/vlString.h>

#include <osg/Matrixd>
#include <osg/Group>
#include <boost/unordered_map.hpp>

#include <vector>
#include <stack>
#include <boost/thread/mutex.hpp>

namespace osgSim
{
   class MultiSwitch;
}

namespace osg
{
   class sequence;
}

namespace makVrv 
{ 
   class DtDe;
   class DtDynamicTerrainSequenceNode;

   class DT_DLL_VRVOSG DtDynamicTerrainParser : public DtArticulatedModelParser
   { 
   public:

      typedef std::vector< osg::Matrixd > StateTransformList;

      typedef std::vector< DynamicTerrain::NodePathHash > StateIndexList;

      typedef std::vector<osg::ref_ptr< DtDynamicTerrainSwitchNode> > TerrainSwitchList;

      DtDynamicTerrainParser(DtDe& de, bool addInstances = true);

      DtDynamicTerrainParser(DtDe& de, DtDynamicTerrainWorld& world, DtModelSemanticsMapper& modelSematicsMapper, bool addInstances = true);

   private:
      DtDynamicTerrainParser();

   public:
      virtual ~DtDynamicTerrainParser();

      virtual DtDynamicTerrainWorld::FeatureHandle parse(
         makVrv::DtDynamicTerrainStateManipulatorFactory& manipulatorFactory,
         osg::Node& node,
         const osg::Matrix& matrix = osg::Matrix::identity());

      virtual DtDynamicTerrainWorld::FeatureHandle parse(
         osg::Node& node,
         const osg::Matrix& matrix = osg::Matrix::identity());

      DtDynamicTerrainWorld::FeatureHandle featureHandle() const { return myFeatureHandles; }

      static std::string parserFormat();
      
      virtual void apply( osg::Group& group );
      virtual void apply( osgSim::MultiSwitch& multiswitch );
      virtual void apply( DtDynamicTerrainSwitchNode& terrainSwitch );
      virtual void apply( osg::Sequence& sequence );
      virtual void apply( DtDynamicTerrainSequenceNode& terrainSequence );

      const StateTransformList& stateTransforms() const;
      void addStateTransform(const osg::Matrixd& mat );

      const TerrainSwitchList& terrainSwitches() const;
      void addTerrainSwitch( DtDynamicTerrainSwitchNode* tSwitch );

      const StateIndexList& stateIndices() const;
      void addStateIndex(  DynamicTerrain::NodePathHash index );

   protected:
      virtual void runVisitor(osg::Node&, const osg::Matrix&);

      virtual bool parseSwitchNames( const std::string& desc, 
         osgSim::MultiSwitch& multiswitch, std::list<DtString>& stateNames );

      virtual void parseSwitchValues( const osg::Node& node,  std::list<DtString>& valueNames );

      virtual void parseValueListString( const std::string& valueList, std::list<DtString>& valueNames );

      virtual void pushSwitch( DtDynamicTerrainSwitchNode* switchNode );
      virtual void popSwitch();
      virtual DtDynamicTerrainSwitchNode* findCurrentSwitch() const;
      
      virtual void pushSwitchIndex( DynamicTerrain::NodePathHash index );
      virtual void popSwitchIndex();
      virtual DynamicTerrain::NodePathHash findCurrentSwitchIndex() const;

      virtual void pushSwitchChildCount( int child );
      virtual void popSwitchChildCount();
      virtual int findCurrentSwitchChildCount() const;
      virtual void incrementSwitchChildCount();
      virtual void decrementSwitchChildCount();

   protected:

      DtDynamicTerrainWorld& myWorld;

      StateTransformList myStateTransformList;
      StateIndexList myStateIndexList;
      TerrainSwitchList myTerrainSwitchList;
      std::stack<std::string> myStateNames;
      std::stack<osg::ref_ptr<DtDynamicTerrainSwitchNode> > myCurrentSwitchStack;
      std::stack<DynamicTerrain::NodePathHash> myCurrentSwitchIndexStack;
      std::stack<int> myCurrentSwitchChildCountStack;

      // maps node's hash to it's parents hash
      typedef boost::unordered_map<DynamicTerrain::NodePathHash, DynamicTerrain::NodePathHash> ParentHashMap;
      ParentHashMap myParentHashMap;

      DtDynamicTerrainWorld::FeatureHandle myFeatureHandles;

      static boost::mutex theParserMutex;

      bool myAddInstances;
   }; 

   class DT_DLL_VRVOSG DtDynamicTerrainParserCreator : public PrModelParserCreator
   {
   public:

      static void registerCreator(DtDe& de);
      
      DtDynamicTerrainParserCreator();

      virtual ~DtDynamicTerrainParserCreator();

      virtual DtModelParser* create(DtDe& de);
   };
  
}