DtIndirectSwitchManager.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (c) 2021 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 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 removeSwitchPaths(int instanceId);

      virtual void slot_setSwitchDynamicTerrainSwitchNode(DtDynamicTerrainSwitchNode* switchNode, DynamicTerrain::NodePathHash nodePathHash, int childIdx);
   
      virtual void slot_setSwitch(osgSim::MultiSwitch* clone, osgSim::MultiSwitch* master, int instanceId);

      virtual void slot_setSequence(osg::Sequence* clone, osg::Sequence* master, int instanceId);
      virtual void update(const osg::FrameStamp* frameStamp);

      virtual void updateActiveSequences(const osg::FrameStamp* frameStamp);
      virtual void setPureSignalBasedSwitches(bool val);

      virtual bool pureSignalBasedSwitches(void) const;

      virtual void processSwitches(void);

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

      virtual const DtGlBuffer* gpuSwitchStateBuffer(void) const;

   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 printInfo();

      virtual void updateSwitchStateBufferIfNecessary(void);

      virtual void deleteBuffers(void);

      virtual void tearDownBuffers(void) const;

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

   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;

      //Map the master to the clone or in the default case the master to the master
      struct SequenceAndValue
      {
      public:
         osg::Sequence* mySequence;
         unsigned int myValue;
      };
      typedef std::map<osg::Sequence*, SequenceAndValue > MapOfSequences;
      typedef std::map<int, MapOfSequences> MapInstanceToMapOfSequences;
      MapInstanceToMapOfSequences myActiveMapSequenceToInfo;

      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;

      bool myPureSignalBasedSwitches;
   };

}