DtSpeedTreeForest.h

Go to the documentation of this file.

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


#pragma once

#include <vrvSt/vrvSt.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtConcurrencyViewerMacros.h>
#include <vrvCore/DtTreeRecord.h>
#include <vrvCore/DtForestObject.h>
#include <osg/ref_ptr>
#include <osg/PositionAttitudeTransform>
#include <osg/Geode>
#include <osg/BoundingBox>

#include <OsgST_Forest.h>

#include <unordered_set>
#include <unordered_map>

#include <tbb/mutex.h>

namespace makOsgSpeedTree
{
   class TreeInstance;
   struct TreeInstanceDescriptor;
}

namespace makVrv
{
   class DtAgentUpdateResolverInterface;
   class DtSpeedTreeModelInstance;
   class DtSpeedTreeCore;
   class DtOsgCullVisitor;
   class DtOsgCullVisitorParameters;
   class DtGlDebugGroup;
   class DtCoordinateConverter;
   class DtOsgRenderer;
   class DtSkyObjectManager;

   class DT_DLL_VRVST DtSpeedTreeForest : public DtForestObject
   {
      friend class DtSpeedTreeForestClassesCreator;
      friend class DtSpeedTreeForestObjectCreator;

   public:
      //Destructor
      virtual ~DtSpeedTreeForest();

      DtSpeedTreeForest() = delete;

      DtSpeedTreeForest(const DtSpeedTreeForest& other) = delete;
      
      DtSpeedTreeForest& operator=(const DtSpeedTreeForest& other) = delete;

   public:
      virtual void setVisible(bool isVisible);

      virtual void addUniqueTree(DtTreeRecord& record);
      virtual void removeTree(DtUniqueID record);
      virtual void removeAllTrees();

      virtual DtUniqueID addUniqueTreesToUniqueCell(DtVectorTreeRecords& records);
      virtual void removeAllUniqueTreesAndUniqueCell(DtUniqueID cellID);

      virtual void setTreeClippingPlane(float fFar);
      virtual void getTreeClippingPlane(float& fFar);

      virtual void setTree3DLodDistances(float fNear, float fFar);
      virtual void getTree3DLodDistances(float& fNear, float& fFar);

      virtual void setTreeBillboardDistances(float fStart, float fEnd);
      virtual void getTreeBillboardDistances(float& fStart, float& fEnd);

      virtual void setBillboardFadeOutRange(float fRange);
      virtual void getBillboardFadeOutRange(float& fRange);

      virtual void enableBillboardRendering(bool enable);
      virtual bool isBillboardRenderingEnabled() const;

      virtual void enable3DTreeRendering(bool enable);
      virtual bool is3DTreeRenderingEnabled() const;

      virtual void enableReceiveShadows(bool enable);
      virtual bool isReceiveShadowsEnabled() const { return myReceiveShadows; }

      virtual void setBoundingBox(const osg::BoundingBox& box);
      virtual const osg::BoundingBox& getBoundingBox(void) const;

      virtual osg::ref_ptr<osg::Node> getRootNode(void);

      virtual void programBoundCallback(osg::ref_ptr<makOsgSpeedTree::Forest> pForest,
         const makOsgSpeedTree::TreeType* pTreeType, uint32 programID);

      virtual void slot_reloadShaders();

      virtual void slot_treeProfilingChanged(bool active);

      virtual void slot_useGlobalAmbientChanged(bool enabled);

      virtual void slot_useGlobalDiffuseChanged(bool enabled);

      virtual void slot_perPixelLightingEnabledChanged(bool enabled);

      virtual void slot_planarReflectionsShowSpeedTreesChanged(bool enabled);

      virtual void processUnitialized();

      virtual bool initialized();

      virtual tbb::mutex& mergeDrawMutex();

      virtual tbb::mutex& mergeUpdateMutex();

      virtual osg::ref_ptr<makOsgSpeedTree::Forest>& makSpeedTreeForest();
   protected:
      // The tree scale from the .earth file and the terrain patch
      // are applied in DtStreamedSpeedTreeThread::handleRequest
      // However, the user could also set the model definition
      // scale. Store model def scale when we store the ST file name
      // so we can multiply it into the record.scale().
      struct ModelDefParams
      {
         std::string strSRTFileName;
         float modelDefScale;
      };

   protected:
      DtSpeedTreeForest(DtDe& de, DtUniqueID id);
      DtSpeedTreeForest(DtDe& de, DtUniqueID id, const std::string& strVisManagerType);

   protected:
      void init(const std::string& strVisManagerType);

      virtual void connectSignals(void);

      virtual osg::Vec3f computeWindDirection(float fDirection);

      virtual void setWindStrength(float fStrength);
      virtual void setWindDirection(float fDirection);

      virtual void preCull(DtOsgCullVisitor* cullVisitor);

      virtual void preCullSetup(osg::Camera* osgCamera);

      virtual bool preUpdateCallback(osg::ref_ptr<makOsgSpeedTree::Forest> forest,
       osg::ref_ptr<osg::Camera> osgCamera);

      virtual bool preRenderCallback(osg::ref_ptr<makOsgSpeedTree::Forest> forest,
         osg::RenderInfo& renderInfo);
      virtual void postRenderCallback(osg::ref_ptr<makOsgSpeedTree::Forest> forest,
         osg::RenderInfo& renderInfo);
      virtual void provideTimeCallback(osg::ref_ptr<makOsgSpeedTree::Forest> forest,
         double& fTime);

      virtual void pushGraphicsState(osg::RenderInfo& renderInfo);
      virtual void popGraphicsState(osg::RenderInfo& renderInfo);

      virtual bool createTree(DtTreeRecord& record);

      virtual void initTreeDesc(makOsgSpeedTree::TreeInstanceDescriptor& desc,
         DtTreeRecord& record, const DtVector& up, DtCoordinateConverter* converter);
      virtual void initTreeDesc(makOsgSpeedTree::TreeInstanceDescriptor& desc,
         DtTreeRecord& record, DtCoordinateConverter* converter, bool setupTopoFrame = true);
      virtual void applyModelDefParameters(makOsgSpeedTree::TreeInstanceDescriptor& desc,
         DtTreeRecord& record);

      virtual const bool bindLightingAttributes(const osg::Node* node,
         const uint32 programID, DtOsgRenderer* osgRenderer,
         const std::string& searchNodeName);

      virtual void enablePlanarReflections(bool enable);

   protected:
      static DtOsgCullVisitorParameters* getCullParameters(
         osg::RenderInfo& renderInfo);

      static bool isCameraOrthographic(DtOsgCullVisitorParameters* params);

      static bool isReflectionCamera(osg::Camera* camera);

      static float getZoomFactor(DtOsgCullVisitorParameters* params, DtDe& de);

   protected:

      static const float myCellSize;

      //Static members used by imgui to keep track of the ImGui state.
      static unsigned int theLastImGuiFrameNumber;

      // Static member variables for keeping track of whether shaders have already been
      // reloaded this frame by another forest
      static unsigned int DtSpeedTreeForest::theLastFrameShadersReloaded;

   protected:
      makOsgSpeedTree::TreeInstanceDescriptor myScratchTreeInstanceDesc;
      makOsgSpeedTree::TreeInstanceDescriptorCollection
         myScratchTreeInstanceDescCollection;
      makOsgSpeedTree::TreeInstanceCollection myScratchInstanceCollection;

      typedef std::map<std::string, ModelDefParams> MapModelDefToSTFileName;
      MapModelDefToSTFileName myMapModelDefToSTFileName;

      int myPreviousTU;

      osg::Camera* myCamera;

      DtSignalConnectionManager myConnections;

      std::unordered_map<int, bool> myShaderBoundMap;

      float myFarPlane;

      osg::ref_ptr<osg::Group> myRoot;
      osg::ref_ptr<osg::PositionAttitudeTransform> myPat;
      osg::ref_ptr<makOsgSpeedTree::Forest> myForest;
      osg::BoundingBox myBoundingBox;
      DtSpeedTreeCore& myCore;

      typedef std::unordered_map<DtUniqueID,
         makOsgSpeedTree::TreeInstanceCollection> MapCellsToTrees;
      MapCellsToTrees myMapCellsToTrees;

      typedef std::unordered_map<DtUniqueID, makOsgSpeedTree::TreeInstance*>
         MapTreeIDToTree;
      MapTreeIDToTree myMapTreeIDtoTree;

      unsigned int myLastShaderHash;

      bool myReloadShaders;

      const std::string mySpeedTreeDefaultUserFuncsVertexShader;
      const std::string mySpeedTreeDefaultUserFuncsPixelShader;

      const std::string mySpeedTreeMultiViewUserFuncsVertexShader;

      osg::ref_ptr<osg::Uniform> myProjectionMatrixInverseUniform;

      // REMOVE POST UBO CHANGE:
      osg::ref_ptr<osg::Uniform> myNormalMatrixUniform;

      bool myReceiveShadows;

      bool myShouldUpdateForCamera;

      // Couple mutexes to avoid thread safety issues. 
      // The merge draw mutex should be moved down into the vis manager but this 
      // was the safer and lower risk option at the moment.
      tbb::mutex myForestMergeDrawMutex;
      tbb::mutex myForestAddRemoveMutex;
      tbb::mutex myForestMergeUpdateMutex;

      DtCoordinateConverter* myMainThreadConverter;
      DtCoordinateConverter* myMergeBackgroundConverter;

      unsigned int myRestoreVisibilityNodeMask;

      DtSkyObjectManager& mySkyObjectManager;
   };

   class DT_DLL_VRVST DtSpeedTreeForestObjectCreator : public DtForestObjectCreator
   {
   public:
      DtSpeedTreeForestObjectCreator();

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

   public:
      virtual DtForestObject* create(DtDe& de, DtUniqueID id);

      virtual DtForestObject* create(DtDe& de, DtUniqueID id, const std::string& strVisManagerType);
   };
}