DtDynamicTerrainSwitchNode.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtMultiReferencedNodeContainer.h>

#include <vlutil/vlString.h>

#include <osg/Group>
#include <osg/Sequence>

#include <boost/unordered_map.hpp>
#include <vrvUtil/signalslib.h>
#include <list>

// Add to VRL eventually
#if defined(__rhentws8__) || defined(__rhentws9__)
namespace MAKBoost_1_84 {} namespace boost = MAKBoost_1_84; namespace MAKBoost_1_84
#else
namespace boost
#endif
{
   template <> struct hash<DtString> {
      size_t operator()(DtString const& v) const {
         boost::hash<std::string> string_hash;
         return string_hash(std::string(v.c_str()));
      }
   };
}

namespace osg
{
   class NodeVisitor;
}

namespace makVrv 
{
   class DtDynamicTerrainSequenceNode;

   class DT_DLL_VRVOSG DtSwitchInstanceState
   {
   public:
      DtSwitchInstanceState();
      unsigned int mySwitchState;
   };

   class DT_DLL_VRVOSG DtDynamicTerrainSwitchNode 
      : public osg::Group
      , public DtMultiReferencedNodeContainer<DtSwitchInstanceState>
   {
   public:

      typedef std::list<DtString> StateNameList;

      typedef std::list<DtString> ValueNameList;

      typedef boost::unordered_map<DtString, int> ValueChildMap;

   public:

      DtDynamicTerrainSwitchNode();

      DtDynamicTerrainSwitchNode(const DtDynamicTerrainSwitchNode&,
         const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);

      virtual ~DtDynamicTerrainSwitchNode();

      virtual const char* className() const { return "DtDynamicTerrainSwitchNode"; }

      virtual void setState( DynamicTerrain::NodePathHash hashIndex, int state );

      virtual void setState( DynamicTerrain::NodePathHash hashIndex, const std::string& valueName );

      virtual void setState( int state );

      virtual void setState( const std::string& valueName );

      virtual int numStates() const;

      virtual void setStateNames(const StateNameList& stateNames );

      virtual void setPositionInModelCoordinates(osg::Vec3d pos);

      virtual osg::Vec3d positionInModelCoordinates() const;

      virtual const StateNameList& stateNames() const;

      virtual void addValues( int state, const ValueNameList& valueNames );

      virtual void addSequence( DtDynamicTerrainSequenceNode* sequence, 
         DynamicTerrain::NodePathHash seqIndex, DynamicTerrain::NodePathHash switchIndex, int childCount );

      virtual const ValueChildMap& valueToChildMap() const;

      boost::signalslib::signal<void(DtDynamicTerrainSwitchNode*, DynamicTerrain::NodePathHash, int)> signal_setSwitch;

      virtual const osg::BoundingSphere& originalBounds() const;
   
      virtual void setOriginalBounds(const osg::BoundingSphere& bounds);

      // Healthy (default) child metadata captured at parse time.
      // The parser will determine the first active child (or other heuristic)
      // when transforming an osgSim::MultiSwitch and record its child index
      // and that child's local-space center so later passes can compute an
      // accurate world-space center without recomputing or relying on the
      // potentially inflated union bound center.
      void setHealthyChildInfo(int idx, const osg::Vec3d& localCenter);
      int healthyChildIndex() const;
      const osg::Vec3d& healthyChildLocalCenter() const;

   protected:

      virtual void traverse(osg::NodeVisitor& nv);

      virtual void setStateBindable( DynamicTerrain::NodePathHash hashIndex, int state );

   protected:

      // Each instance of a sequence has a hash index and the switch child it
      // is associated with
      struct SequenceDescriptor
      {
         osg::ref_ptr<DtDynamicTerrainSequenceNode> mySequence;
         DynamicTerrain::NodePathHash mySeqIndex;
         int mySwitchChild;
      };

      // This is a list of SequenceDescriptors, since a switch might have multiples attached
      typedef std::list<SequenceDescriptor> SequenceInstanceList;

      // SwitchToSequenceMap defines a map from switch reference to a sequence instance list for sequence
      // references associated with that switch reference
      typedef boost::unordered_map< DynamicTerrain::NodePathHash, SequenceInstanceList> SwitchToSequenceMap;

      // The map from switch reference to sequence references
      SwitchToSequenceMap mySwitchToSequenceMap;

      // All the names discovered for this switch when parsed.  Only the first is currently used
      StateNameList myStateNames;

      // The map from value names to the states/children they correspond to
      ValueChildMap myValueToChildMap;
      
      osg::BoundingSphere myOriginalbounds;

      osg::Vec3d myPosInModelCoords;

      int myHealthyChildIndex;
      osg::Vec3d myHealthyChildLocalCenter;
   };
}