DtSpeedTreeForest.h

Go to the documentation of this file.

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


#pragma once

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

#include <vrvCore/DtTreeRecord.h>
#include <vrvCore/DtConcurrencyViewerMacros.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 DtEnvironmentInfo;
   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);

      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_useGlobalAmbientChanged(bool enabled);

      virtual void slot_useGlobalDiffuseChanged(bool enabled);

      virtual void slot_perPixelLightingEnabledChanged(bool enabled);

      virtual void slot_planarReflectionsShowSpeedTreesChanged(bool enabled);

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

      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 bool isReflectionCamera(osg::Camera *camera);

      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;

      osg::Camera* myCamera;

      DtSignalConnectionManager myConnections;

      boost::unordered_map<int, bool> myShaderBoundMap;
      boost::unordered_map<int, int> myAlphaThresholdBlockLoc;

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

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

      unsigned int myLastShaderHash;

      bool myReloadShaders;

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

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

      DtCVSpan * myRenderSpan;
      DtCVMarkerSeries * myMarkerSeries;
     osg::GLExtensions * myExt;
      bool myReceiveShadows;
   }; 

   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:

   };
}