DtOsgRenderer.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/DtSceneRoot.h>
#include <vrvOsg/DtOsgGlTextureListener.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <vrvCore/DtRenderer.h>

#include <osg/ref_ptr>
#include <osg/Group>

#include <vector>
#include <string>
#include <unordered_map>

namespace osg
{
   class Group;
   class Node;
   class Camera;
   class Operation;
   class TextureObjectManager;
}

namespace osgUtil
{
   class RenderBin;
}

namespace osgViewer
{
   class Viewer;
   class CompositeViewer;
   class View;
   class ViewerBase;
}

namespace osgShadow
{
   class ShadowedScene;
}

namespace osgEarth
{
   class MapNode;
}

namespace makVrv
{
   class DtStatsSet;
   class DtChannel;
   class DtGlDebugger;
   class DtOsgChannel;
   class DtEffectManager;
   class DtOsgWindowManager;
   class DtOsgProfilerOverlay;
   class DtOsgPerformanceStatsOverlay;
   class DtFastMatrixTransform;
   class DtSceneGraph;
   class DtOsgGlobalShaderComponent;
   class DtOsgCullVisitor;
   class DtShadowSettingsObject;
   class DtTaxiwaySignManager;
   class DtRunwayMarkingManager;
   class DtGLFontManager;
   class DtLightIndicatorManager;
   class DtGpuArena;
   class DtImGuiLoaderStatsData;
   class DtImguiHelper;
   class DtMultiViewData;
   enum class DtModelSetId;
   

   class DT_DLL_VRVOSG DtOsgRenderer : public DtRenderer
   {
   public:
      friend class DtSceneGraph;
      friend class DtOsgRendererCreator;
      friend class DtSceneGraphTreeLogic;

      //Render bin definitions.
      const static int SKY_RENDERBIN = -10;
      const static int DEFAULT_RENDERBIN = 0;
      const static int DEPTH_ONLY_RENDERBIN = 5;
      const static int OCEAN_RENDERBIN = 6;
      const static int LIGHTPOINT_RENDERBIN = 7;
      const static int CLOUD_RENDERBIN = 8;
      const static int DEFAULT_TRANSPARENT_RENDERBIN = 10; // this has to be 10 otherwise everything goes south, the rest are more flexible
      const static int COCKPIT_RENDERBIN = 25;

      //Render bin names
      static const std::string AlphaToCoverageBin;
      static const std::string SkyBin;
      static const std::string DepthOnlyBin;
      static const std::string OceanBin;
      static const std::string LightPointBin;
      static const std::string CloudBin;
      static const std::string CockpitBin;

      static DtOsgRenderer* findInstance(DtDe& de);

      virtual ~DtOsgRenderer();

      virtual void createManagers() override;

      virtual void cleanup() override;

      virtual void update();

      virtual void render();

      virtual bool viewExists() const;

      virtual void resetSceneGraph();

      virtual void removeChannelRoot(DtChannel* channel);

      virtual bool isSceneRootEmpty(const DtSceneRoot& sr);

      virtual void addNodeToRoot(osg::Node* node, const DtSceneRoot& sr, bool createOnAccess = true);

      virtual void addSceneRootToRoot(const DtSceneRoot& childRoot, const DtSceneRoot& parentRoot, bool createOnAccess = true);

      virtual bool removeNodeFromRoot(osg::Node* node, const DtSceneRoot& sr);

      virtual void removeSceneRootFromRoot(const DtSceneRoot& childRoot, const DtSceneRoot& parentRoot);

      virtual void traverseRoot(osg::NodeVisitor& nv, const DtSceneRoot& sr);

      virtual void setSceneRootNodeMask(const DtSceneRoot& sr,
         osg::Node::NodeMask nodemask);

      virtual osg::Node::NodeMask sceneRootNodeMask(const DtSceneRoot& sr);

      virtual osg::BoundingSphere sceneRootBound(const DtSceneRoot& sr);

      virtual osg::BoundingSphere sceneRootListBound(const DtSceneRootList& srList);

      virtual void addChannelToModelSetRoot(DtModelSetId modelSetId,
         DtChannel* channel);

      virtual void removeChannelFromModelSetRoot(DtModelSetId modelSetId,
         DtChannel* channel);

      virtual void addChannelToVisualizerRoot(DtModelSetId modelSetId,
         int visualizerType, DtChannel* channel);

      virtual void removeChannelFromVisualizerRoot(DtModelSetId modelSetId,
         int visualizerType, DtChannel* channel);

      virtual void setSceneDataToRenderRoot(osgViewer::View& view);

      virtual void addSceneToCamera(osg::Camera* camera);

      virtual void addSceneRootToNode(const DtSceneRoot& sr,
         osg::Group* node, bool createOnAccess = true);

      virtual osg::Group* findSceneRootChildByName(const DtSceneRoot& parent,
         const std::string& rootName, bool subString = false);

      virtual bool matchesSceneRoot(const DtSceneRoot& sr, osg::Group* group);

      virtual void releaseResources()
      {
         releaseResources(0);
      }

      virtual void releaseResources(osg::State* state);

      void setRootNode(osg::Group*, bool copyChildrenFromOldRoot);

      void resetRoot();

      void registerPagedLODs(osg::Node* node);

      void clearPagedLODs();

      virtual void setWireframeRendering(bool enabled);

      virtual void setDdsFlip(bool flip);

      virtual bool wireframeRendering() const;

      virtual void setShadowState(bool enabled);

      virtual bool shadowsEnabled() const;

      // ! Get global multiview vr mode
      virtual bool multiViewVrEnabled() const;

      // ! Set global multiview vr mode, doesn't actually enable it, just indicates it is enabled
      virtual void setMultiViewVrEnabled(bool enabled);

      // ! Get reference to  multiview data for specific camera
      // ! PPP: TO DO MULTI. This function is *not* thread safe
      virtual DtMultiViewData& getOrCreateMultiViewData(const osg::Camera* camera);

      // ! Clear all multiview data
      void clearMultiViewData();

      void setTerrainScalingEnabled(bool enabled);

      void setTerrainScaleFactor(double scaleFactor);

      virtual bool makeContextCurrent();

      virtual DtFontManagerInterface& fontManager();
      virtual const DtFontManagerInterface& fontManager() const;

      DtEffectManager& effectManager();
      const DtEffectManager& effectManager() const;

      boost::signalslib::signal< void(DtModelSetId modelSet, int visualType) > signal_visualizerRootAdded;
      boost::signalslib::signal< void(DtChannel*) > signal_channelRootAdded;

      boost::signalslib::signal< void(bool active) > signal_treeProfilingChanged;
      boost::signalslib::signal< void(bool active) > signal_diguyProfilingChanged;
      boost::signalslib::signal< void(bool active) > signal_sensorProfilingChanged;
      boost::signalslib::signal< void(bool active) > signal_sensorDebuggingChanged;

      boost::signalslib::signal< void() > signal_shadowsRemoved;

      boost::signalslib::signal<void(DtOsgCullVisitor* cullVisitor)> signal_preCull;

      virtual void debugDrawBox(const osg::Vec3& center, const osg::Vec3& extents);

      virtual void debugDrawBox(const osg::Vec3& center, const osg::Vec3& extents, const osg::Quat& orientation);

      virtual void setChannelShadowState(DtOsgChannel* osgChannel, bool enable);

      virtual bool channelShadowSettings(DtOsgChannel* osgChannel, DtShadowSettingsObject** shadowSettingObject, bool* isPlanView) const;

      osg::StateSet* sgRenderRootStateSet();

      // structure to expedite culling. We need to clear any memory
      // that this structure caches to decrement reference count of 
      // StateSets (and hence drawables, textures, etc) when scene
      // changes completely (e.g. on post processor turned off/on)
      // so that memory can be reclaimed
      // This helper function accomplishes that
      void clearStateGraphForAllChannels(void);

      virtual void preCull(DtOsgCullVisitor* cullVisitor);

      virtual void addParallelThreadCullJob(osg::Operation * opp);

      virtual void removeParallelThreadCullJob(osg::Operation* opp);

      virtual void launchPreCullTasks(DtOsgCullVisitor* cv);

      virtual int alphaToCoverageRenderBin();

      virtual void setNewProfilerState(int value);
      virtual int newProfilerState();

      virtual bool isLightBin(osg::RenderInfo& renderInfo);

      virtual bool isDepthBin(osg::RenderInfo& renderInfo);

      virtual bool isShadowPass(osg::RenderInfo& renderInfo);

      virtual bool addDebuggerReference();

      virtual void removeDebuggerReference();

   public:
      //@ {
      static DtSceneRoot renderRoot();
      static DtSceneRoot environmentRoot(); 
      static DtSceneRoot terrainRoot();
      static DtSceneRoot minimapTerrainRoot();
      static DtSceneRoot minimapFallbackTerrainRoot();
      static DtSceneRoot propRoot();
      static DtSceneRoot intersectOnlyPropRoot();
      static DtSceneRoot oceanRoot();
      static DtSceneRoot intersectOnlyRoot(DtModelSetId modelSet)
      {
         return DtSceneRoot(DtSceneRoot::IntersectOnlyModelSetSpecific, modelSet);
      }
      static DtSceneRoot normalizedOverlayRoot();
      static DtSceneRoot modelSetRoot(DtModelSetId modelSet)
      {
         return DtSceneRoot(modelSet);
      }
      static DtSceneRoot visualizerTypeRoot(DtModelSetId modelSet, int visualizerType)
      {
         return DtSceneRoot(modelSet, visualizerType);
      }
      static DtSceneRoot channelRoot(DtModelSetId modelSet, DtChannel* channel)
      {
         return DtSceneRoot(modelSet, channel);
      }
      //@ }

      static const std::string& shadowedSceneName(void)
      {
          return theShadowedSceneName;
      }


      osg::Group* sgRenderRoot();

      osg::Group* sgEnvironmentRoot();

      osg::Group* sgPropsRoot();

      osg::Group* sgIntersectoOnlyPropsRoot();

      osg::Group* sgTerrainRoot();

      osg::Group* sgScaledTerrainRoot();

      osg::Group* sgScaledPropsRoot();

      osg::Group* sgMinimapTerrainRoot();

      osg::Group* sgMinimapFallbackTerrainRoot(bool createOnAccess);

      osg::Group* sgNormalizedOverlayRoot();

      osg::Group* sgStatic3dDebugRoot();

      osg::Group* sgOceanRoot();
      
      virtual osg::Group* modelSetSpecificShadowRoot(DtModelSetId modelSet);
      
      virtual osgShadow::ShadowedScene*
          modelSetSpecificShadowScene(DtModelSetId modelSet);

      osg::Group* sgIntersectOnlyRoot(DtModelSetId modelSet);

      virtual osgViewer::ViewerBase& viewer();

      virtual void gpuArenaDeleted();

      virtual const DtGpuArena* gpuArena() const;

      virtual DtGpuArena* gpuArena();

      virtual DtImGuiLoaderStatsData* imGuiLoaderStatsData();
      
      virtual DtImguiHelper* imGuiHelper();



      virtual void addIntStat(const std::string& name, int value);
      virtual void addFloatStat(const std::string& name, float value);

      virtual void addIntStat(const std::string& subsystem, const std::string& name, int value);
      virtual void addFloatStat(const std::string& subsystem, const std::string& name, float value);

      virtual unsigned int numActiveThreads() const;

      void advanceTime();

      static const DtOsgGlTextureListener& osgGlTextureListener(void);
   protected:

      virtual void moveRootToShadowRoot(const DtSceneRoot& targetRoot,
         osg::Group* shadowRoot, osg::Group* modelSetRoot);


      DtOsgRenderer(DtDe& de);

      DtOsgRenderer() = delete;
      DtOsgRenderer(const DtOsgRenderer& rhs) = delete;
      DtOsgRenderer& operator=(const DtOsgRenderer& rhs) = delete;


      osg::Group* sgModelSetRoot(DtModelSetId modelSet);

      osg::Group* sgVisualizerRoot(DtModelSetId modelSet, int visualizerType,
         bool createOnAccess = true);

      osg::Group* sgChannelRoot(DtModelSetId modelSet,
         DtChannel* channel, bool createOnAccess = true);

      void slot_onViewCreated();

      void slot_onViewToBeDestroyed();

      void slot_onWireframeModeChanged(bool mode);

      void slot_onDdsFlipChanged(bool flip);

      void slot_onShadowStateChanged(bool shadowMode);

      void slot_onTerrainScalingEnabledChanged(bool enabled);

      void slot_onTerrainScaleFactorChanged(double scaleFactor);

      void slot_onCoordinateSystemChanged(const std::string& coordinateSystemType);

      void updateSceneGraph();

      void clearEmptyWindows();

      void performPerRenderChannelOperations();

      virtual void removeShadows();

      virtual void createShadowRoots();

      virtual bool exportTerrainAndProps(const std::string&);

      virtual osg::Group* createModelSetRoot(DtModelSetId modelSet);
      virtual osg::Group* createVisualizerRoot(DtModelSetId modelSet,
         int visualizer);

      virtual osg::Group* createChannelRoot(DtModelSetId modelSet, DtChannel*);

      virtual osgShadow::ShadowedScene*
         createModelSetSpecificShadowRootAndScene(DtModelSetId modelSet);

      virtual void updateTerrainScaling();

      virtual void initAerodromeManagers();
      virtual void updateAerodrome();

      // replace currentChild in all its parents with newChild
      void swapChildren(osg::Node* currentChild, osg::Node* newChild);

      void postInitialize();

      virtual void slot_reloadShader();

      void setupAtcVirtualProgram();

      virtual void processBackgroundLoaderIcoTasksIfNecessary(void);

      virtual int numDatabasePagerThreads(osgViewer::CompositeViewer& viewer) const;

      virtual bool isNahimicServiceRunning() const;

      virtual bool isNsightRunning(void) const;

      virtual DtGpuArena* createGpuArena();

      virtual void freeOpenglDebugger();

   protected:
      DtSceneGraph* mySceneGraph;

      DtGLFontManager*  myFontManager;
      DtEffectManager* myEffectManager;

      DtOsgWindowManager* myOsgWindowManager;

      bool myAtLeastOneChannelAcceptsExternalInput;

      osg::ref_ptr<osgViewer::Viewer> myDefaultViewer;

      // This the top of the render graph
      osg::ref_ptr<osg::Group> myRenderRoot;

      osg::ref_ptr<osg::Group> myDebugRoot;

      osg::ref_ptr<osg::Group> myNormalizedOverlayRoot;

      osg::ref_ptr<osg::Group> myStatic3dDebugRoot;

      osg::ref_ptr<osg::Geode> myDebugBox;

      osg::ref_ptr<osg::Group> myComponentSystemRoot;

      // This goes directly below the root, and sets the environment (such as sky)
      osg::ref_ptr<osg::Group> myEnvironmentRoot;

      // attached under each modelset root except the minimap modelset root, terrains are placed here
      osg::ref_ptr<osg::Group> myTerrainRoot;

      // attached under each minimap modelset root, minimap terrains are placed here
      osg::ref_ptr<osg::Group> myMinimapTerrainRoot;

      // attached under each minimap terrain root, terrain/props/ocean root is placed her for when
      // a minimap terrain patch isn't included in a terrain definition
      osg::ref_ptr<osg::Group> myMinimapFallbackTerrainRoot;

      // attached under each modelset root,  props are placed here
      osg::ref_ptr<osg::Group> myPropsRoot;

      //root for props that should only be intersected and not rendered (indirected)
      osg::ref_ptr<osg::Group> myIntersectOnlyPropsRoot;

      // root for triton
      osg::ref_ptr<osg::Group> myOceanRoot;

      // when terrain scaling is enabled, this is placed above the
      // terrain root
      osg::ref_ptr<DtFastMatrixTransform> myScaledTerrainRoot;

      // when terrain scaling is enabled, this is placed above the
      // props root
      osg::ref_ptr<DtFastMatrixTransform> myScaledPropsRoot;

      osg::Matrix myScaleMatrix;

      // shadows and visual type roots are done one per model set
      typedef std::unordered_map<DtModelSetId, osg::ref_ptr<osg::Group> > RootMap;
      typedef std::unordered_map<DtModelSetId, osg::ref_ptr<osgShadow::ShadowedScene> > ShadowedSceneMap;

      typedef int VisualizerType;

      // There is one group for each model set, which is either an osg::Group
      // or a DtChannelSpecificGroup
      typedef std::unordered_map < DtModelSetId, osg::ref_ptr<osg::Group> >
         ModelSetRootMap;

      typedef std::unordered_map < VisualizerType, osg::ref_ptr<osg::Group> >
         VisualizerTypeRootMap;

      typedef std::unordered_map < DtModelSetId, VisualizerTypeRootMap >
         ModelSetVisualizerTypeRootMap;


      // This is a map of the model set  roots.  CWhen a channel uses a model set 
      // (or more correctly, when a channel's observer uses a model set) the
      // channel subscribes to the appropriate one of these
      ModelSetRootMap myModelSetMap;

      //Map to roots that are intersect only on a per model set basis
      ModelSetRootMap myIntersectOnlyRootMap;


      // Under each model set root is a root for each visualizer type.  This map
      // provides another map, by model set, of the roots for each visual type
      ModelSetVisualizerTypeRootMap myVisualizerRootMap;

      // This is a map of channel roots by model set.  Each channel root is a unique
      typedef std::unordered_map < DtChannel*, ModelSetRootMap >
         ChannelRootMap;

      ChannelRootMap myChannelRootMap;
      ShadowedSceneMap myShadowedSceneMap;
      RootMap myShadowRootMap;

      osg::ref_ptr<osgUtil::RenderBin> myAlphaToCoverageBin;
      osg::ref_ptr<osgUtil::RenderBin> mySkyBin;
      osg::ref_ptr<osgUtil::RenderBin> myDepthOnlyBin;
      osg::ref_ptr<osgUtil::RenderBin> myOceanBin;
      osg::ref_ptr<osgUtil::RenderBin> myLightPointBin;
      osg::ref_ptr<osgUtil::RenderBin> myCloudBin;
      osg::ref_ptr<osgUtil::RenderBin> myCockpitBin;

      bool myWireframeOn;
      bool myShadowsEnabled;

      bool myMultiViewVrEnabled;
      std::map<const osg::Camera*, DtMultiViewData*> myMultiViewData;

      DtTaxiwaySignManager* myTaxiwaySignManager;
      DtRunwayMarkingManager* myRunwayMarkingManager;
      DtLightIndicatorManager* myLightIndicatorManager;

      double myTerrainScaleFactor;
      bool myTerrainScaleFactorChanged;
      bool myTerrainScalingEnabled;
      bool myTerrainScalingEnabledChanged;
      bool myResourcesReleased;
      
      int myAlphaToCoverageRenderBin;
      int myNewProfilerState;

      DtGpuArena* myGpuArena;
      bool myReAddGpuArena;

      bool myInitializedInRender;
      unsigned int myActiveThreads;

      DtGlDebugger* myOpenglDebugger;

 protected:
      static DtSceneRoot theRenderRoot;
      static DtSceneRoot theEnvironmentRoot;
      static DtSceneRoot theTerrainRoot;
      static DtSceneRoot theMinimapTerrainRoot;
      static DtSceneRoot theMinimapFallbackTerrainRoot;
      static DtSceneRoot thePropRoot;
      static DtSceneRoot theOceanRoot;
      static DtSceneRoot theIntersectOnlyPropRoot;
      static DtSceneRoot theNormalizedOverlayRoot;
      
      static std::string theShadowedSceneName;

      DtImguiHelper* myImGuiHelper;

      osg::ref_ptr<DtOsgGlobalShaderComponent> myGlobalShaderComponent;

      typedef osg::ref_ptr<osg::Operation> OperationRef;
      typedef std::vector<OperationRef> OperationVector;

      OperationVector myParallelCullJobs;

      boost::signalslib::connection myPostInitalizeConnection;

      static bool theOsgTextureTrackingInitialized;

   protected:
      static DtOsgGlTextureListener theOsgGlTextureListener;
   };

   class DT_DLL_VRVOSG DtOsgRendererCreator : public DtRendererCreator
   {
   public:

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