DtSceneGraphTreeLogic.h

Go to the documentation of this file.

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

#pragma once

#include <vrvOsgQt/vrvOsgQt.h>

#if !defined(Q_MOC_RUN)
#include <vrvCore/DtSubjectObserver.h>
#endif

#include <osg/observer_ptr>
#include <osg/Node>
#include <osg/ShapeDrawable>

#include <QtWidgets/QAction>

#if !defined(Q_MOC_RUN)
#include <tbb/task.h>
#endif

#include <vector>

namespace osg
{
   class Node;
   class Drawable;
   class Geode;
}

class QIcon;
class QMenu;
class QTreeWidgetItem;

namespace makVrv
{

   class DtDe;
   class DtSceneGraphTreeWidgetInterface;
   class DtSceneGraphTreeLogic;

   class DT_DLL_VRVOSGQT ExpansionFunctor
   {
   public:
      virtual bool shouldExpandTo(const osg::Node* node);
   };

   //custom actions for context menu
   class DT_DLL_VRVOSGQT DtDrawBoundsAction : public QAction, public ExpansionFunctor
   {
      Q_OBJECT
   public:
      DtDrawBoundsAction(QObject* parent);
      virtual ~DtDrawBoundsAction();

   public:
      virtual void removeVolume();
      virtual void setNode(const osg::Node* node);
      virtual bool isNodeWithBV(const osg::Node* node);

      virtual void setAABoundingBoxMode();

   public slots:

      void slot_triggered(bool);

   private:
      osg::observer_ptr<const osg::Node> myNode;
      osg::observer_ptr<const osg::Node> myBVAttachedNode;
      osg::observer_ptr<osg::ShapeDrawable> myBoundingVolumeDrawable;
      osg::ref_ptr< osg::Image > myImage;
      osg::ref_ptr< osg::Texture > myTexture;
      bool myAABoundingBoxMode;
   };

   //custom actions for context menu
   class DT_DLL_VRVOSGQT DtRefreshNodeAction : public QAction
   {
      Q_OBJECT
   public:
      DtRefreshNodeAction(QObject* parent, DtSceneGraphTreeLogic* tree);
      virtual ~DtRefreshNodeAction();
      virtual void setNode(const osg::Node* node, QTreeWidgetItem* item);
      virtual bool shouldExpandTo(const osg::Node* node);

      public slots:
      void slot_triggered(bool);

   private:
      osg::observer_ptr<const osg::Node> myNode;
      DtSceneGraphTreeLogic* myTree;
      QTreeWidgetItem* myItem;

   };

   class DT_DLL_VRVOSGQT DtColorSubTreeAction : public QAction
   {
      Q_OBJECT
   public:
      DtColorSubTreeAction(QObject* parent);

      virtual ~DtColorSubTreeAction();

   public:
      
      virtual void setNode(osg::Node* node);
      
      virtual osg::Node* colorizedNode();

   public slots:

      virtual void slot_triggered(bool);

   protected:
      virtual void unColorizeNode();
      virtual void colorizeNode();

   protected:
      osg::observer_ptr<osg::Node> myContextMenuNode;
      osg::observer_ptr<osg::Node> myColorizedNode;
   };

   //custom actions for context menu
   class DT_DLL_VRVOSGQT DtExpandItemAction : public QAction, public ExpansionFunctor
   {
      Q_OBJECT
   public:
      DtExpandItemAction(QObject* parent, DtSceneGraphTreeLogic* tree);
      virtual ~DtExpandItemAction();
      virtual void setNode(const osg::Node* node, QTreeWidgetItem* item);
      virtual bool shouldExpandTo(const osg::Node* node);
      virtual void recursiveVisit(QTreeWidgetItem* item);

      public slots:
      void slot_triggered(bool);

   protected:
      osg::observer_ptr<const osg::Node> myNode;
      DtSceneGraphTreeLogic* myTree;
      QTreeWidgetItem* myItem;
   };

   class DT_DLL_VRVOSGQT DtExpandAllAction : public DtExpandItemAction
   {
      Q_OBJECT
   public:
      DtExpandAllAction(QObject* parent, DtSceneGraphTreeLogic* tree);
      virtual bool shouldExpandTo(const osg::Node* node) { return true; };

   };

   class DT_DLL_VRVOSGQT DtExpandToOQNAction : public DtExpandItemAction
   {
      Q_OBJECT
   public:
      DtExpandToOQNAction(QObject* parent, DtSceneGraphTreeLogic* tree);

      virtual bool shouldExpandTo(const osg::Node* node);

   };

   class DT_DLL_VRVOSGQT DtExpandToGeometryAction : public DtExpandItemAction
   {
   public:
      DtExpandToGeometryAction(QObject* parent, DtSceneGraphTreeLogic* tree) :DtExpandItemAction(parent, tree) 
      {
         //Do Nothing
      }
      virtual bool shouldExpandTo(const osg::Node* node);
   };

   class DT_DLL_VRVOSGQT DtExpandToLightsAction : public DtExpandItemAction
   {
   public:
      DtExpandToLightsAction(QObject* parent, DtSceneGraphTreeLogic* tree) :DtExpandItemAction(parent, tree) 
      {
         //Do Nothing
      }
      virtual bool shouldExpandTo(const osg::Node* node);
   };

   class DT_DLL_VRVOSGQT DtSearchSceneGraphAction
   {
      public:
         DtSearchSceneGraphAction(DtSceneGraphTreeLogic* tree);
         virtual ~DtSearchSceneGraphAction();

         virtual QTreeWidgetItem* getPreviousNode(const std::string& query);

         virtual QTreeWidgetItem* getNextNode(const std::string& query);

         virtual void setSearchQuery(const std::string& query);

         virtual void search(QTreeWidgetItem* node);

         virtual void reset();

         virtual size_t getCurrentIndex();

         virtual bool hasResults(const std::string& query);

         virtual size_t getTotalResults(const std::string& query);

      private:
         size_t myCurrentIndex;
         std::string mySearchQuery;
         std::vector<QTreeWidgetItem*> mySearchResults;

         DtSceneGraphTreeLogic* myTree;
   };

   class DT_DLL_VRVOSGQT DtSceneGraphTreeLogic
   {
   public:
      typedef osg::observer_ptr<const osg::Node> NodeObsPtr;
      typedef std::map<QTreeWidgetItem*, NodeObsPtr> WidgetToNodeMap;
   
   public:
   
      enum SceneGraphRoot
      {
         RenderSystem,
         WindowChannelConfig,
         Environment,
         Terrain,
         Props,
         ScaledTerrainRoot,
         ScaledPropsRoot,
         ModelSetRoot,
         Overlays
      };

   protected:

      DtSceneGraphTreeLogic(DtDe& de, DtSceneGraphTreeWidgetInterface* iface);

      virtual void init();

      friend class DtSceneGraphTreeLogicCreator;

   public:
      virtual ~DtSceneGraphTreeLogic();

   private:
      DtSceneGraphTreeLogic(const DtSceneGraphTreeLogic &other);
      DtSceneGraphTreeLogic &operator=(const DtSceneGraphTreeLogic &other);

   public:

      virtual void onDeactivate();

      virtual void clearAndTraverse();

      virtual void clearAndTraverse(int domain, int subdomain);

      virtual bool iterateNode(QTreeWidgetItem* pParent, const osg::Node* pNode, bool bDrawIcon = true);

      virtual void buildContextMenu(QMenu* menu, QTreeWidgetItem* item);

      virtual void setVisualizeNodeBounds(bool enable);

      virtual void setVisualizeLods(bool enable);

      virtual void onSelectTreeItem(QTreeWidgetItem* item);

      NodeObsPtr  getNode(QTreeWidgetItem* item);

      virtual void displayPrevious(const std::string& query);
      virtual void displayNext(const std::string& query);
      virtual std::string getSearchStatusText(const std::string& query);

      virtual void resetSearchAction();

      virtual void computeFormattedNodeMaskText(unsigned int mask, QString& nodeMaskText);

   protected:

      virtual bool nodePathHasCameraParent(const osg::NodePath& nodePath) const;

      virtual const osg::Matrix computeNodeBoundsWorldMatrix(const osg::Node* node) const;

      virtual void visualizeNode(const osg::Node* node);

      virtual void visualizeLods(const osg::Node* node, const osg::Matrix& localToWorldMatrix,
         const float boundsRadius);

      virtual void visualizeLod(const osg::LOD* lod, unsigned int lodIndex,
         const osg::Matrix& localToWorldMatrix, const float boundsRadius,
         const float brightness);

      virtual void removeVisulizationForNodeBounds();

      virtual void removeVisulizationForLods();

   private:

      DtSceneGraphTreeLogic();
      const QIcon & getNodeIcon(const osg::Node* pNode);
      const QIcon & getDrawableIcon(const osg::Drawable* drawable);

   protected:

      DtDe& myDe;
      DtSceneGraphTreeWidgetInterface* myWidgetInterface;

      WidgetToNodeMap myWidgetToNodeMap;
      DtDrawBoundsAction* myShowBoundsAction;
      DtDrawBoundsAction* myShowAABBoxAction;
      DtColorSubTreeAction* myColorSubTreeAction;
      DtRefreshNodeAction* myRefreshAction;
      DtExpandAllAction* myExpandAllAction;
      DtExpandToGeometryAction* myExpandGeometryAction;
      DtExpandToLightsAction* myExpandLightNodesAction;
      DtSearchSceneGraphAction* mySearchAction;
      QIcon mySunIcon;
      QIcon mySkyIcon;
      QIcon myFolderIcon;
      QIcon myGeodeIcon;
      QIcon myGeometryIcon;
      QIcon myEmptyIcon;
      QIcon myCloudsIcon;

      bool myVisualizeNodeBounds;
      bool myVisualizeLods;
      unsigned int myVisualizeLodsCount;
   };

   class DT_DLL_VRVOSGQT DtSceneGraphTreeLogicCreator : public DtVirtualBaseClass
   {
   public:
      // CTOR
      DtSceneGraphTreeLogicCreator(DtDe& de);

      virtual ~DtSceneGraphTreeLogicCreator();

   private:
      DtSceneGraphTreeLogicCreator(const DtSceneGraphTreeLogicCreator &other);
      DtSceneGraphTreeLogicCreator &operator=(const DtSceneGraphTreeLogicCreator &other);

   public:
      static DtSceneGraphTreeLogicCreator& instance(DtDe& de);

      static void registerInstance(DtDe& de,
         DtSceneGraphTreeLogicCreator* instance);

      virtual DtSceneGraphTreeLogic* create(DtSceneGraphTreeWidgetInterface* iface);
   protected:
      DtDe& myDe;
   };
}