DtOsgFindNodesVisitor.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtDynamicTerrainSwitchNode.h>
#include <vrvOsg/DtDynamicTerrainSequenceNode.h>

#include <vrvGraphicsUtils/DtAssert.h>

#include <vrvIndirectRendering/DtGeometrySpecification.h>
#include <vrvOsg/DtIndirectLodManager.h>

#include <osg/Switch>
#include <osg/LOD>
#include <osg/PositionAttitudeTransform>
#include <osg/NodeVisitor>
#include <osg/MatrixTransform>
#include <osgSim/MultiSwitch>
#include <osgSim/DOFTransform>

#include <vector>
#include <deque>
#include <osg/PolygonOffset>

#include <vrvOsg/DtIndirectSwitchManager.h>
#include <vrvOsg/DtIndirectPolygonOffset.h>

namespace makVrv
{

   struct DtNodePlusTraversalInfo
   {
      DtNodePlusTraversalInfo()
         : hasDofParent(false)
         , cullFaceEnabled(true)
      {
      }

      osg::ref_ptr<osg::Node> node;
      osg::Matrixd xform;
      DtIndirectLodManager::DequeIndirectLodInfos lodStack;
      osg::NodePath nodePath;
      DtIndirectSwitchManager::DequeNodeSwitchInfoPairs switchStack;
      bool hasDofParent; //for now just check to see if there is a dof node.  
      bool cullFaceEnabled;
      DtIndirectPolygonOffset polygonOffset;
   };

   template<typename T>
   struct DtOsgFindNodesVisitor : public osg::NodeVisitor
   {
      DtOsgFindNodesVisitor(osg::NodeVisitor::TraversalMode traversalMode) : osg::NodeVisitor(traversalMode) { }

      void apply(osg::Node& node)
      {
         T* result = dynamic_cast<T*>(&node);
         if (result)
            results.push_back(result);
         traverse(node);
      }

      std::vector<T*> results;
   };

   template<typename T>
   struct DtOsgFindNodesVisitorRefPtr : public osg::NodeVisitor
   {
      DtOsgFindNodesVisitorRefPtr(osg::NodeVisitor::TraversalMode traversalMode) : osg::NodeVisitor(traversalMode) { }

      void apply(osg::Node& node)
      {
         T* result = dynamic_cast<T*>(&node);
         if (result)
            results.push_back(result);
         traverse(node);
      }

      std::vector< osg::ref_ptr<T> > results;
   };

   template<typename T>
   struct DtOsgFindNodesVisitorRefPtrFlattenGraph : public osg::NodeVisitor
   {
      DtOsgFindNodesVisitorRefPtrFlattenGraph(osg::NodeVisitor::TraversalMode traversalMode, osg::Node::NodeMask gatherNodeMask = 0, const std::set< osg::Node* > &nodeIgnoreList = std::set<osg::Node*>())
         : osg::NodeVisitor(traversalMode)
         , nodeIgnoreList(nodeIgnoreList)
         , myGatherNodeMask(gatherNodeMask)
      {
         matrixStack.push_back(osg::Matrix::identity());
      }

      virtual bool isCullFaceEnabled(osg::StateSet* ss) const
      {
         bool cullFaceEnabled = (myCullFaceEnabledStack.empty() == false) ? myCullFaceEnabledStack.top() : true;
         if (ss == 0)
         {
            return cullFaceEnabled;
         }

         osg::StateAttribute::GLModeValue cullFaceModeValue = ss->getMode(GL_CULL_FACE);
         if ((cullFaceModeValue & osg::StateAttribute::INHERIT) == osg::StateAttribute::INHERIT)
         {
            return cullFaceEnabled;
         }
         else
         {
            return (cullFaceModeValue & osg::StateAttribute::ON) == osg::StateAttribute::ON;
         }
      }

      virtual DtIndirectPolygonOffset gatherPolygonOffset(osg::StateSet* ss) const
      {
         DtIndirectPolygonOffset dtPolygonOffset = (myPolygonOffsetStack.empty() == false) ? myPolygonOffsetStack.top() : DtIndirectPolygonOffset(0, 0);

         if (ss == 0)
         {
            return dtPolygonOffset;
         }

         osg::PolygonOffset* polygonOffset = dynamic_cast<osg::PolygonOffset*>(ss->getAttribute(osg::StateAttribute::POLYGONOFFSET));
         if (polygonOffset)
         {
            dtPolygonOffset = DtIndirectPolygonOffset(polygonOffset->getFactor()*polygonOffset->getFactorMultiplier(), polygonOffset->getUnits()*polygonOffset->getUnitsMultiplier());
          }
         return dtPolygonOffset;
      }

      virtual void apply(osg::Node& node)
      {
         if (nodeIgnoreList.find(&node) != nodeIgnoreList.end())
         {
            return;
         }

         bool cullFaceEnabled = isCullFaceEnabled(node.getStateSet());
         myCullFaceEnabledStack.push(cullFaceEnabled);
         DtIndirectPolygonOffset polygonOffset = gatherPolygonOffset(node.getStateSet());
         myPolygonOffsetStack.push(polygonOffset);


         T* result = dynamic_cast<T*>(&node);
         if (result)
         {
            bool processThisNode = true;

            //the myGatherNodesMask is really an inverse mask. If any bits are the 
            // same between the mask and the node mask then it is a non indirected object
            // so it should not be included in the results
            // We also need to make sure all the children are not indirected either
            if ((node.getNodeMask() & myGatherNodeMask) != 0)
            {
               processThisNode = false;
               for(unsigned int i = 0; i < result->getNumChildren(); i++)
               {
                  osg::Node* child = result->getChild(i);
                  if (child)
                  {
                     if ((child->getNodeMask() & myGatherNodeMask) == 0)
                     {
                        processThisNode = true;
                     }
                  }
               }
            }

            if (processThisNode)
            {
               DtNodePlusTraversalInfo nodeAndXForm;

               osg::Matrixd mat = matrixStack.back();

               osg::MatrixTransform* nodeAsMatrixXForm = dynamic_cast<osg::MatrixTransform*>(&node);
               if (nodeAsMatrixXForm)
               {
                  mat = nodeAsMatrixXForm->getMatrix()  * mat;
               }

               nodeAndXForm.xform = mat;
               nodeAndXForm.node = result;
               nodeAndXForm.lodStack = lodStack;
               nodeAndXForm.nodePath = getNodePath();
               nodeAndXForm.switchStack = switchStack;
               //for now dof nodes are handled outside of indirect so it is enough to know that it has a sequence as a parent.
               nodeAndXForm.hasDofParent = !dofStack.empty();

               nodeAndXForm.cullFaceEnabled = cullFaceEnabled;
               nodeAndXForm.polygonOffset = polygonOffset;

               results.push_back(nodeAndXForm);
            }
         }

         osgSim::DOFTransform* dof = dynamic_cast<osgSim::DOFTransform*>(&node);
         if (dof)
         {
            dofStack.push_back(dof);
         }

         osg::MatrixTransform* mat = dynamic_cast<osg::MatrixTransform*>(&node);
         if (mat)
         {
            matrixStack.push_back(mat->getMatrix() * matrixStack.back());
         }

         osg::PositionAttitudeTransform* pat = dynamic_cast<osg::PositionAttitudeTransform*>(&node);
         if (pat)
         {
            osg::Matrixd patMat;
            patMat.setTrans(pat->getPosition());
            patMat.setRotate(pat->getAttitude());
            patMat.makeScale(pat->getScale());
            matrixStack.push_back(patMat * matrixStack.back());
         }


         osg::Switch* osgSwitch = dynamic_cast<osg::Switch*>(&node);
         if (osgSwitch)
         {
            for (unsigned int i = 0; i < osgSwitch->getNumChildren(); ++i)
            {
               osg::Node* child = osgSwitch->getChild(i);
               if (child)
               {
                  DtIndirectSwitchManager::IndirectSwitchInfo switchInfo = {
                     0,
                     (int)i,
                     (unsigned int)switchStack.size(),
                     osg::NodePath(),
                     0
                  };
                  switchStack.push_back(DtIndirectSwitchManager::NodeSwitchInfoPair(osgSwitch, switchInfo));
                  child->accept(*this);
                  switchStack.pop_back();
               }
            }
            myCullFaceEnabledStack.pop();
            myPolygonOffsetStack.pop();
            return;
         }

         osgSim::MultiSwitch* multiSwitch = dynamic_cast<osgSim::MultiSwitch*>(&node);
         if (multiSwitch)
         {
            for (unsigned int i = 0; i < multiSwitch->getNumChildren(); ++i)
            {
               osg::Node* child = multiSwitch->getChild(i);
               if (child)
               {
                  DtIndirectSwitchManager::IndirectSwitchInfo switchInfo = {
                     0,
                     (int)i,
                     (unsigned int)switchStack.size(),
                     osg::NodePath(),
                     0
                  };
                  switchStack.push_back(DtIndirectSwitchManager::NodeSwitchInfoPair(multiSwitch, switchInfo));
                  child->accept(*this);
                  switchStack.pop_back();
               }
            }
            myCullFaceEnabledStack.pop();
            myPolygonOffsetStack.pop();
            return;
         }

         DtDynamicTerrainSwitchNode* dynamicSwitch = dynamic_cast<DtDynamicTerrainSwitchNode*>(&node);
         if (dynamicSwitch)
         {
            for (unsigned int i = 0; i < dynamicSwitch->getNumChildren(); ++i)
            {
               osg::Node* child = dynamicSwitch->getChild(i);
               if (child)
               {
                  DtIndirectSwitchManager::IndirectSwitchInfo switchInfo = {
                     0,
                     (int)i,
                     (unsigned int)switchStack.size(),
                     this->getNodePath(),
                     0
                  };
                  switchStack.push_back(DtIndirectSwitchManager::NodeSwitchInfoPair(dynamicSwitch, switchInfo));
                  child->accept(*this);
                  switchStack.pop_back();
               }
            }
            myCullFaceEnabledStack.pop();
            myPolygonOffsetStack.pop();
            return;
         }

         osg::Sequence* dynamicSequence = dynamic_cast<osg::Sequence*>(&node);
         if (dynamicSequence)
         {
            for (unsigned int i = 0; i < dynamicSequence->getNumChildren(); ++i)
            {
               osg::Node* child = dynamicSequence->getChild(i);
               if (child)
               {
                  DtIndirectSwitchManager::IndirectSwitchInfo switchInfo = {
                     0,
                     (int)i,
                     (unsigned int)switchStack.size(),
                     this->getNodePath(),
                     0
                  };
                  switchStack.push_back(DtIndirectSwitchManager::NodeSwitchInfoPair(dynamicSequence, switchInfo));
                  child->accept(*this);
                  switchStack.pop_back();
               }
            }
            myCullFaceEnabledStack.pop();
            myPolygonOffsetStack.pop();
            return;
         }

         osg::LOD* lod = dynamic_cast<osg::LOD*>(&node);
         if (lod)
         {
            for (unsigned int i = 0; i < lod->getNumChildren(); i++)
            {
               DtIndirectLodManager::IndirectLodInfo info;
               info.myCenter = lod->getCenter() * matrixStack.back();
               const osg::LOD::MinMaxPair& range = lod->getRangeList()[i];
               info.myStartRange = range.first;
               info.myEndRange = range.second;

               lodStack.push_back(info);
               lod->getChild(i)->accept(*this);
               lodStack.pop_back();
            }
         }
         else
         {
            traverse(node);
         }

         if (mat)
         {
            matrixStack.pop_back();
         }

         if (dof)
         {
            dofStack.pop_back();
         }

         myCullFaceEnabledStack.pop();
         myPolygonOffsetStack.pop();
      }

      std::vector< DtNodePlusTraversalInfo > results;
      std::set< osg::Node* > nodeIgnoreList;
      std::deque<osg::Matrixd> matrixStack;
      DtIndirectLodManager::DequeIndirectLodInfos lodStack;
      DtIndirectSwitchManager::DequeNodeSwitchInfoPairs switchStack;
      std::deque<osgSim::DOFTransform*> dofStack;
      osg::Node::NodeMask myGatherNodeMask;

      std::stack<bool> myCullFaceEnabledStack;
      std::stack<DtIndirectPolygonOffset> myPolygonOffsetStack;

   };
}