include/vrvOsg/DtOsgRenderer.h

Go to the documentation of this file.

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

#pragma once
 
#include <vrvOsg/vrvOsg.h>
#include <vrvCore/DtRenderer.h>
#include <vrvCore/DtDe.h>

#include <osg/ref_ptr>
#include <osgUtil/RenderBin>
#include <osgViewer/Viewer>
#include <vector>

#include <boost/unordered_map.hpp>
#include <boost/signals.hpp>

namespace osg
{
   class Group;
   class Node;
}

namespace makOsgShadowFX
{
   class DtShadowEffect;
}

namespace makVrv 
{
   class DtStatsSet;
   class DtChannel;
   class DtEffectManager;
   class DtFontManager;
   class DtOsgWindowManager;
   class DtOsgPerformanceStatsOverlay;
   class DtFastMatrixTransform;
 
   class DT_DLL_VRVOSG DtOsgRenderer : public DtRenderer
   {
   public:

      enum RootDomain
      {
         RenderSystem,
         Environment,
         Terrain,
         Prop,
         ModelSetSpecific,
         VisualizerTypeSpecific     
      };

      class SceneRoot
      {
      public:
         SceneRoot() {}
         SceneRoot(RootDomain domain) 
            : myDomain(domain) 
         {}
         SceneRoot(int modelSet)
            : myDomain(ModelSetSpecific)
         { 
            myParameter.modelSetId = modelSet; 
         }
         SceneRoot(int modelSet, int visualizerType)
            : myDomain(VisualizerTypeSpecific)
         {
            myParameter.modelSetId = modelSet;
            myParameter.visualizerType = visualizerType;
         }

         bool operator==(SceneRoot rhs) const
         {
            if ( myDomain == ModelSetSpecific )
            {
               return myDomain == rhs.myDomain && 
                  myParameter.modelSetId == rhs.myParameter.modelSetId;
            }
            if ( myDomain == VisualizerTypeSpecific )
            {
               return myDomain == rhs.myDomain && 
                  myParameter.modelSetId == rhs.myParameter.modelSetId &&
                  myParameter.visualizerType == rhs.myParameter.visualizerType;
            }
            return myDomain == rhs.myDomain;
         }

         RootDomain myDomain;
         struct
         {    
            int modelSetId;
            int visualizerType;        
         } myParameter;
      };
     
      typedef std::vector<SceneRoot> RootList;

   public:

      friend class DtOsgRendererCreator;
      friend class DtSceneGraphTreeLogic;

      //Render bin definitions.
      const static int SKY_RENDERBIN    = -10;
      const static int CLOUDS_RENDERBIN = 9;
      const static int COCKPIT_RENDERBIN    = 25;

      static DtOsgRenderer* findInstance(DtDe& de);

      virtual ~DtOsgRenderer();

      virtual void update();      
      
      virtual void render();

      virtual void resetSceneGraph();

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

      virtual void removeNodeFromRoot(osg::Node* node, SceneRoot sr);

      virtual void traverseRoot(osg::NodeVisitor& nv, SceneRoot sr);  
  
      virtual void setSceneRootNodeMask(SceneRoot sr, 
         osg::Node::NodeMask nodemask);

      virtual osg::Node::NodeMask sceneRootNodeMask(SceneRoot sr);

      virtual osg::BoundingSphere sceneRootBound(SceneRoot sr);

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

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

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

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

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

       virtual osg::Group* findSceneRootChildByName( SceneRoot parent, 
          const std::string& rootName );




      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 setPerformanceStatsOverlayEnabled(bool show);

      virtual bool performanceStatsOverlayEnabled() const;

      virtual void setWireframeRendering(bool enabled);

      virtual void setDdsFlip(bool flip);

      virtual bool wireframeRendering() const;

      virtual void setShadowState(bool enabled, int quality, bool entity, 
                                 bool prop, bool terrain);

      //@ {
      virtual bool shadowsEnabled() const;
      virtual int shadowQuality() const;
      virtual bool entityShadowsEnabled() const;
      virtual bool propShadowsEnabled() const;
      virtual bool terrainShadowsEnabled() const;   
      //@ }

      void setTerrainScalingEnabled( bool enabled );

      void setTerrainScaleFactor( double scaleFactor );

      virtual bool makeContextCurrent();

      DtFontManager& fontManager();
      const DtFontManager& fontManager() const;

      DtEffectManager& effectManager();
      const DtEffectManager& effectManager() const;
      
      boost::signal< void ( int modelSet, int visualType ) > signal_visualizerRootAdded;
         
   public:
      //@ {
      static SceneRoot renderRoot() { return theRenderRoot; }
      static SceneRoot environmentRoot() { return theEnvironmentRoot; };
      static SceneRoot terrainRoot() { return theTerrainRoot; }   
      static SceneRoot propRoot() { return thePropRoot; }   
      static SceneRoot modelSetRoot(int modelSet) 
         { return SceneRoot(modelSet); }
      static SceneRoot visualizerTypeRoot(int modelSet, int visualizerType) 
         { return SceneRoot(modelSet, visualizerType); }
      //@ }

   protected:
      virtual void onActiveStatsOverlayChanged(DtStatsSet* activeStats);

      DtOsgRenderer(DtDe& de);
      
      osg::Group* sgRenderRoot();
      
      osg::Group* sgEnvironmentRoot();

      osg::Group* sgPropsRoot();

      osg::Group* sgTerrainRoot();

      osg::Group* sgScaledTerrainRoot();

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

      void slot_onViewCreated();

      void slot_onViewToBeDestroyed();

      void slot_onWireframeModeChanged(bool mode);

      void slot_onDdsFlipChanged(bool flip);

      virtual void slot_onPerformanceOverlayOnChanged(bool mode);

      void slot_onShadowStateChanged(bool shadowMode, int shadowQual,
         bool entityMode, bool propMode, bool terrainMode);

      void slot_onTerrainScalingEnabledChanged( bool enabled );

      void slot_onTerrainScaleFactorChanged( double scaleFactor );
 
      void slot_onCoordinateSystemChanged(const std::string& coordinateSystemType);

      void advanceTime();

      void updateSceneGraph();

      void clearEmptyWindows();

      virtual void removeShadows();

      virtual void createShadowRoots();

      virtual bool exportTerrainAndProps(const std::string&);
      
      virtual osg::Group* createModelSetRoot( int modelSet );
      virtual osg::Group* createVisualizerRoot( int modelSet, 
         int visualizer );
      
      virtual makOsgShadowFX::DtShadowEffect* 
         createModelSetSpecificShadowRootAndEffect( int modelSet );
      virtual osg::Group* modelSetSpecificShadowRoot( int modelSet );
      virtual makOsgShadowFX::DtShadowEffect* 
         modelSetSpecificShadowEffect( int modelSet );

      virtual void updateTerrainScaling();

      // Used internally by the other scene root using functions to find the
      // correct root for adding/removing children, Getting child counts, etc.
      virtual osg::Group* getContainerRoot(SceneRoot root, bool createOnAccess);

      // Container roots may have other roots over them for doing transforms, etc.
      // This gets the topmost root associated with that scene root, useful for
      // traversal, nodeMask setting/getting, etc.
      virtual osg::Group* getActiveRoot(SceneRoot root);

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

      DtFontManager*  myFontManager;
      DtEffectManager* myEffectManager;

      DtOsgWindowManager* myOsgWindowManager;

      osg::ref_ptr<osgViewer::Viewer> myDefaultViewer;
      
      // This the top of the render graph
      osg::ref_ptr<osg::Group> myRenderRoot;
    
      // This goes directly below the root, and sets the environment (such as sky)
      osg::ref_ptr<osg::Group> myEnvironmentRoot;
   
      // attached under each modelset root, terrains are placed here
      osg::ref_ptr<osg::Group> myTerrainRoot;
   
      // attached under each modelset root,  props are placed here
      osg::ref_ptr<osg::Group> myPropsRoot;
      
      // 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 boost::unordered_map<int, osg::ref_ptr<osg::Group> > RootMap;
      typedef boost::unordered_map<int, 
         osg::ref_ptr<makOsgShadowFX::DtShadowEffect> > ShadowEffectMap;
      
      typedef int ModelSet;
      typedef int VisualizerType;

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

      typedef boost::unordered_map<VisualizerType, osg::ref_ptr<osg::Group> > 
         VisualizerTypeRootMap;
      
      typedef boost::unordered_map<ModelSet, 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;
      
      // 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;
      
      ShadowEffectMap myShadowEffectMap;
      RootMap myShadowRootMap;
      
      osg::ref_ptr<osgUtil::RenderBin> myCloudBin;
      osg::ref_ptr<osgUtil::RenderBin> mySkyBin;
      osg::ref_ptr<osgUtil::RenderBin> myCockpitBin;
      
      bool myWireframeOn;
      bool myShadowsEnabled;
      int myShadowQuality;
      bool myEntityShadowMode;
      bool myPropShadowMode;
      bool myTerrainShadowMode;

      DtOsgPerformanceStatsOverlay* myPerformanceStatsOverlay;

      double myTerrainScaleFactor;
      bool myTerrainScaleFactorChanged;
      bool myTerrainScalingEnabled;
      bool myTerrainScalingEnabledChanged;

   protected:
      static SceneRoot theRenderRoot; 
      static SceneRoot theEnvironmentRoot; 
      static SceneRoot theTerrainRoot; 
      static SceneRoot thePropRoot; 
   };

   class DT_DLL_VRVOSG DtOsgRendererCreator : public DtRendererCreator
   {
   public:

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

}