DtSpeedTreeForest.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2022 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 <tbb/mutex.h>

namespace makOsgSpeedTree
{
   class TreeInstance;
   struct TreeInstanceDescriptor;
}

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

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

   public:
      //Destructor
      virtual ~DtSpeedTreeForest();

   protected:

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

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

   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; }

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

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

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

      osg::ref_ptr<makOsgSpeedTree::Forest>& makSpeedTreeForest();
     
      virtual void preCullSetup(osg::ref_ptr<makOsgSpeedTree::Forest> forest, osg::Camera* camera);

   protected:

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

      // 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:
      void connectSignals(void);

      osg::Vec3f computeWindDirection(float fDirection);

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

      bool preUpdateCallback(osg::ref_ptr<makOsgSpeedTree::Forest> forest);

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

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

      virtual DtModelDefinition* findModelDefinition(
         const std::string& modelDef);

      bool createTree(DtTreeRecord& record);

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

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

   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 bool theEnableAsyncUpdate;

   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;
      DtEnvironmentInfo& myEnvInfo;

      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;
 
      osg::GLExtensions * myExt;
      bool myReceiveShadows;

      // 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;

      bool myShouldUpdateThisFrame;

      unsigned int myRestoreVisibilityNodeMask;
   }; 

   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);
   };
}