DtSpeedTreeForest.h

Go to the documentation of this file.

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


#pragma once

#include <vrvSt/vrvSt.h>
#include <vrvCore/DtForestObject.h>
#include <osg/ref_ptr>
#include <osg/PositionAttitudeTransform>
#include <osg/Geode>
#include <osg/BoundingBox>

#include <vrvCore/DtTreeRecord.h>

#include <OsgST_Forest.h>

#include <boost/unordered_map.hpp>



namespace makOsgSpeedTree
{
   class TreeInstance;
   struct TreeInstanceDescriptor;
}

namespace makVrv 
{ 
   class DtAgentUpdateResolverInterface;
   class DtSpeedTreeModelInstance;
   class DtSpeedTreeCore;
   class DtOsgCullVisitorParameters;

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

      virtual ~DtSpeedTreeForest();

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

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

   protected:

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

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

      osg::Vec3f computeWindDirection(float fDirection);

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

      bool preUpdateCallback(osg::ref_ptr<makOsgSpeedTree::Forest> forest, 
         osg::RenderInfo& renderInfo);
      bool preRenderCallback(osg::ref_ptr<makOsgSpeedTree::Forest> forest, 
         osg::RenderInfo& renderInfo);
      void postUpdateCallback(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);
      void initTreeDesc(makOsgSpeedTree::TreeInstanceDescriptor& desc, 
         DtTreeRecord& record, bool setupTopoFrame=true);
      void applyModelDefParameters(makOsgSpeedTree::TreeInstanceDescriptor& desc, 
         DtTreeRecord& record);

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

      static bool isCameraOrthographic(DtOsgCullVisitorParameters* params);

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

   protected:
      
      static const float myCellSize;

   protected:

      makOsgSpeedTree::TreeInstanceDescriptor myScratchTreeInstanceDesc;
      makOsgSpeedTree::TreeInstanceDescriptorCollection 
         myScratchTreeInstanceDescCollection;
      makOsgSpeedTree::TreeInstanceCollection myScratchInstanceCollection;
      
      typedef std::map<std::string, ModelDefParams> MapModelDefToSTFileName;
      MapModelDefToSTFileName myMapModelDefToSTFileName;

      int myPreviousTU;

      //keeps track of the current state of vrvVisualOverride so the 
      //programBoundCallback can apply it to the uniform
      osg::Camera* myCamera;

      std::map<int, bool> myShaderBoundMap;

      float myHighDetail3dDistance;
      float myLowDetail3dDistance;

      float myBillboardStartDistance;
      float myBillboardEndDistance;

      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 boost::unordered_map<DtUniqueID, 
         makOsgSpeedTree::TreeInstanceCollection> MapCellsToTrees;
      MapCellsToTrees myMapCellsToTrees;

      typedef boost::unordered_map<DtUniqueID, makOsgSpeedTree::TreeInstance*> 
         MapTreeIDToTree;
      MapTreeIDToTree myMapTreeIDtoTree;
      
      unsigned int myLastShaderHash;
   }; 

   class DT_DLL_VRVST DtSpeedTreeForestSignaler : public DtVirtualBaseClass
   {
   public:
      static DtSpeedTreeForestSignaler& instance(DtDe&);

      ~DtSpeedTreeForestSignaler();

      boost::signal<void (DtSpeedTreeForest&)> signal_forestCreated;

      boost::signal<void (DtSpeedTreeForest&)> signal_forestToBeDestroyed;

   protected:
      DtSpeedTreeForestSignaler();

   private: 
      DtSpeedTreeForestSignaler(const DtSpeedTreeForestSignaler&);
      DtSpeedTreeForestSignaler& operator=(const DtSpeedTreeForestSignaler&);
   };

   class DT_DLL_VRVST DtSpeedTreeForestCreator : public DtForestCreator
   {
   public:
      DtSpeedTreeForestCreator(){}
      virtual DtForestObject* create(DtDe& de, DtUniqueID id);
      virtual DtForestObject* create(DtDe& de, DtUniqueID id, 
         const std::string& strVisManagerType);

   private:

   };
}