DtIndirectSwitchManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>
#include <vrvOsg/DtMultiReferencedNodeContainer.h>
#include <vrvOsg/DtIndirectSwitchInfo.h>
#include <vrvOsg/DtIndirectManager.h>

#include <vrvCore/DtVirtualBaseClassCreator.h>

#include <vrvGraphicsUtils/DtReusableMemoryVector.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>

#include <osgSim/MultiSwitch>
#include <osg/Node>
#include <osg/ref_ptr>
#include <osg/observer_ptr>
#include <osg/Switch>

#include <list>
#include <deque>

namespace osg
{
   class Group;
   class Node;
   class Sequence;
   class RenderInfo;
   class FrameStamp;
}

namespace osgSim
{
   class MultiSwitch;
}

namespace makVrv
{
   struct PerGeomInstance;
   class DtInstanceContainer;
   class DtDynamicTerrainSwitchNode;
   class DtSwitchInstanceState;
   class DtDe;
   class DtGlBuffer;

   class DtIndirectSwitchManager;

   typedef DtVirtualBaseClassCreator<DtIndirectSwitchManager, DtInstanceContainer&> DtIndirectSwitchManagerCreator;

   template <>
   inline const char* creatorTypeName<DtIndirectSwitchManager>(void) { return "DtIndirectSwitchManagerCreator"; }

   class DT_DLL_VRVOSG DtIndirectSwitchManager : public DtIndirectManager
   {
   public:

      typedef osg::observer_ptr<osg::Node> NodeObserverPtr;
      typedef std::pair<NodeObserverPtr, DtIndirectSwitchInfo> NodeSwitchInfoPair;
      typedef std::deque<NodeSwitchInfoPair> DequeNodeSwitchInfoPairs;
      typedef std::vector<DequeNodeSwitchInfoPairs> DequeNodeSwitchInfoPairsArray;

      typedef std::vector<DtIndirectSwitchInfo> VectorIndirectSwitchInfos;
      typedef std::map<int, VectorIndirectSwitchInfos> MapIntToVectorIndirectSwitchInfos;
      typedef std::map<NodeObserverPtr, MapIntToVectorIndirectSwitchInfos > MapNodeToMapIntToVectorIndirectSwitchInfos;

   public:
      friend DtIndirectSwitchManagerCreator;

      virtual ~DtIndirectSwitchManager();
   protected:
      DtIndirectSwitchManager(DtDe& de, DtInstanceContainer& container);

   private:
      DtIndirectSwitchManager() = delete;
      DtIndirectSwitchManager(const DtIndirectSwitchManager& other) = delete;
      DtIndirectSwitchManager& operator=(const DtIndirectSwitchManager& other) = delete;

   public:
      virtual void addSwitchPaths(int perGeomInstanceIndex, int size, const DequeNodeSwitchInfoPairs& parentSwitchPaths, const DequeNodeSwitchInfoPairsArray& switchPaths, const osg::NodePath& parentNodePath, int instanceId);

      virtual void slot_setSwitchDynamicTerrainSwitchNode(DtDynamicTerrainSwitchNode* switchNode, DynamicTerrain::NodePathHash nodePathHash, int childIdx);

      virtual void update(const osg::FrameStamp* frameStamp);

      virtual void processSwitches(void);

      virtual void releaseGLObjects(osg::State* state) const;

      virtual const DtGlBuffer* gpuSwitchStateBuffer(void) const;

      virtual void removeMultiSwitchNode(osg::Node* node);

   protected:

      virtual void addSwitchPath(int perGeomInstanceIndex, const DequeNodeSwitchInfoPairs& parentSwitchPaths, const DequeNodeSwitchInfoPairs& switchPath, const osg::NodePath& parentNodePath, int instanceId);

      virtual void addSwitch(NodeSwitchInfoPair& switchChildPair, int bitMaskId, int perGeomInstanceIndex, const osg::NodePath& parentNodePath, int uniqueId);

      virtual bool checkSwitchChildActive(osg::ref_ptr<osg::Node> nodeRefPtr, int childIndex, DynamicTerrain::NodePathHash pathHash);

      virtual void updateSwitches(void);

      virtual void updateMultiSwitches(void);

      virtual void updateSequences(const osg::FrameStamp* frameStamp);

      virtual void updateSwitchStateBufferIfNecessary(void);

      virtual void deleteBuffers(void);

      virtual void tearDownBuffers(void) const;

      virtual void updateSwitch(const DtIndirectSwitchInfo& info, bool isSwitchChildActive);

      virtual void addSequence(osg::Sequence* sequence, int instanceId);

   protected:

      MapNodeToMapIntToVectorIndirectSwitchInfos myMapNodeToVectorIndirectSwitchInfos;

      std::set<DtDynamicTerrainSwitchNode*> mySetDynamicTerrainSwitchNodes;

      // These are the 'master' sequences
      typedef std::map<osg::Sequence*, unsigned int> MapSequenceToValue;
      MapSequenceToValue myMapSequenceToValue;

      // These are the 'master' switches
      typedef std::map<osg::Switch*, osg::Switch::ValueList> MapSwitchToValueList;
      MapSwitchToValueList myMapSwitchToValueList;

      // These are the 'master' multi-switches
      typedef std::map<osgSim::MultiSwitch*, osgSim::MultiSwitch::ValueList> MapMultiSwitchToValueList;
      MapMultiSwitchToValueList myMapMultiSwitchToValueList;


      DtSignalConnectionManager myConnections;
      mutable bool myMutableSwitchesDirty;

      struct SwitchesOffBitMaskInvalidator
      {
         void operator()(int& info);
      };

      //which parent switches of this geometry are turned off 
      //(so if this is 0 then all switches are turned on and the geometry should be visible)
      typedef DtReusableMemoryVector<int, SwitchesOffBitMaskInvalidator> VectorSwitchesOffBitMask;
      VectorSwitchesOffBitMask myVectorSwitchesOffBitMask;

      DtGlBuffer* myGpuSwitchStateBuffer;

      // This group node is set as a parent node to all registered multiswitch
      // nodes. This is needed for tracking because the DtDynamicTerrainParser
      // can swap out a regular osgSim::MultiSwitch with a DtDynamicTerrainSwitchNode
      // and this DtIndirectSwitchManager has no way of knowing that.
      // By using this parent node, we can track when that happens and remove the
      // osgSim::MultiSwitch from tracking in this manager.
      osg::ref_ptr<osg::Group> myMultiSwitchTrackingNode;
   };



   // The DtIndirectMultiSwitchTrackingNode is used to track a replacement of
   // a osgSim::MultiSwitch node from DtDynamicTerrainParser.
   // This is used by DtIndirectSwitchManager.
   // This group node is set as a parent node to all registered multiswitch
   // nodes. This is needed for tracking because the DtDynamicTerrainParser
   // can swap out a regular osgSim::MultiSwitch with a DtDynamicTerrainSwitchNode
   // and DtIndirectSwitchManager has no way of knowing that.
   // By using this parent node, we can track when that happens and remove the
   // osgSim::MultiSwitch from tracking in the DtIndirectSwitchManager.
   class DT_DLL_VRVOSG DtIndirectMultiSwitchTrackingNode
      : public osg::Group
   {
   public:

      META_Node(vrvOsg, DtIndirectMultiSwitchTrackingNode);

   public:

      friend class DtIndirectMultiSwitchTrackingNodeCreator;

      DtIndirectMultiSwitchTrackingNode(
         const DtIndirectMultiSwitchTrackingNode & rhs, const osg::CopyOp& copyop);

      virtual ~DtIndirectMultiSwitchTrackingNode();

      bool replaceChild(osg::Node *origNode, osg::Node *newNode) override;

   protected:

      DtIndirectMultiSwitchTrackingNode();

      virtual void setManager(DtIndirectSwitchManager* manager);

   protected:

      DtIndirectSwitchManager* myIndirectSwitchManager;
   };

   class DT_DLL_VRVOSG DtIndirectMultiSwitchTrackingNodeCreator : public DtVirtualBaseClass
   {
   public:

      static DtIndirectMultiSwitchTrackingNodeCreator& instance(DtDe& de);

      static void registerInstance(DtDe& de,
            DtIndirectMultiSwitchTrackingNodeCreator* anInstance);

      virtual DtIndirectMultiSwitchTrackingNode* create(DtIndirectSwitchManager* manager);
   };
}