SceneOpenSceneGraph.hh

#ifndef __SceneOpenSceneGraph_hh__
#define __SceneOpenSceneGraph_hh__

#include <bias_config.h>

#include <GLviewer/Scenes/SceneBase.hh>
#include <Gui/biasgl.h>
#ifdef WIN32
#undef GL_VERSION_2_1
#endif
#include <osg/Timer>
#include <osg/ShapeDrawable>
#include <osgViewer/Viewer>
#include <osgDB/ReadFile>
#include <Base/Math/Vector3.hh>
#include <GLviewer/Scenes/NodeInfo.hh>
#include <string>

#include <osgAnimation/BasicAnimationManager>
#include <osgAnimation/Animation>


namespace BIAS
{

  class MyBasicAnimationManager : public osgAnimation::BasicAnimationManager{

  public:
    MyBasicAnimationManager() : BasicAnimationManager(){
      timer = 0.0;
      counter = 0;
    }
    ~MyBasicAnimationManager(){}

    void operator()(osg::Node* node, osg::NodeVisitor* nv){
      if (nv && nv->getVisitorType() == osg::NodeVisitor::UPDATE_VISITOR)
      {
          if (needToLink())
          {
              /** manager need to link, it means that an animation has been added
                  so we need to relink all item animated with all animations.
                  We apply the linker visitor on the manager node to affect
                  all its children.
                  But it should not be done here, it should be done in the
                  update of AnimationManager
              */
              link(node);
          }
          //const osg::FrameStamp* fs = nv->getFrameStamp();
          update(timer);

          //std::cout << "Update animation: " << counter++ << ", time: " << timer << std::endl;
      }
      traverse(node,nv);
    }

    void NextFrame(){
      timer += 0.04;
    }

    void playAnimation(osgAnimation::Animation* pAnimation, int priority = 0, float weight = 1.0)
    {
      _lastUpdate = 0.0;
      timer = 0.0;
      osgAnimation::BasicAnimationManager::playAnimation(pAnimation,priority,weight);
    }

  protected:
    double timer;
    int counter;


  };

  /** \class SceneOpenSceneGraph
      \brief Implements narrow access to OpenSceneGraph.
      \author woelk 09/2007
      \ingroup g_glviewer*/
  class BIASGLviewer_EXPORT SceneOpenSceneGraph : public SceneBase
  {
  public:
    SceneOpenSceneGraph(bool redirect = true);

    virtual ~SceneOpenSceneGraph();

    /** Initializes OpenSG tree for scene appendance.
      \return -1 if gl context was not available.
      \return 0 if initialization was successful or was skipped.
      \attention only successful if gl context is available.
      \attention Initialization is skipped if already done.
     */
    int Init();

    /** \brief deletes internal pointers
        \author woelk 04/2006 */
    void Reset();

    /** \brief Append an OSG subtree to the constructed root tree. */
    void AppendSubTree(osg::ref_ptr<osg::Node>& childNode);

    /** \brief Append an OSG subtree to the constructed root tree
        with switch node. WARNING: @param switchNode is updated from the 
        input node to the now prepended switch node. So that the user has
        a reference to the complete scene branch*/
    int AppendSubTreeSwitch(osg::ref_ptr<osg::Node>& switchNode,
                            eNodeType NodeType = eNT_Default);

    /**
     * \brief Loads contents from file into scene graph.
     * \param optimize: unused at the moment, only for compatibility with OpenSG
     *  */
    int AppendSubTreeFromFile(const std::string& fileName,
                              osg::ref_ptr<osg::Node>& childNode,
                              bool optimize = false);

    int AppendSubTreeFromFile(const std::string& fileName)
    { osg::ref_ptr<osg::Node> dummy;
     return AppendSubTreeFromFile(fileName, dummy); }

    /** \brief Loads contents from 2D image file into scene graph. */
    int AppendSubTreeFromImageFile(const std::string& fileName,
                   const double& width_mm,
                   osg::ref_ptr<osg::Node>& imageNode);

    /** \brief Saves contents beginning at node into a file. */
    bool SaveSubTree(osg::Node *node, const std::string &fileName);

    /** \brief removes the subtree and the parents except the globalroot
        of a given node  */
    void RemoveSubTreeAndParents(osg::Node* Node);

    void RemoveSubTree(osg::ref_ptr<osg::Node>& childNode);
    void RemoveSubTree(osg::Node* childNode);

    /** \brief Removes the camera as a beacon for the lights and sets
     *  a fixed position for Point Light or fixed direction
     *  for Directional Light */
    void SetFixedPointLight(bool on,BIAS::Vector3<double> posPointLight);
    void SetFixedDirectionalLight(bool on,BIAS::Vector3<double> dirDirectionalLight);

    /** \brief Toggles the headlight. Initial headlight state is on. */
    void HeadlightSwitch(bool on=true);
    /** \brief Toggle the light visible switch */
    inline void LightRepresentationVisibleSwitch()
    { lightRepresentationVisible_ = !lightRepresentationVisible_;
      UpdateLightRepresentation_(); };

    /** \brief Returns center of bounding box around the whole scene.
     * \attention only works after Init() was called. */
    BIAS::Vector3<double> GetBoundingBoxCenter();

    /** Returns  bounding box around the whole scene.
     * \attention only works after Init() was called.
     * \param min[out]: minimum bounding box value
     * \param max[out]: maximum bounding box value */
    virtual void GetBoundingBox(BIAS::Vector3<double> & min,
                                BIAS::Vector3<double> & max);

    void MakeTransparent(const double transparency);

    inline void MakeOpaque() { MakeTransparent(0.0); };

    bool RightMouseDoubleClicked(int x, int y);

    //enable automatical animation
    void SetAnimate(const bool animate);
    
    /**
     * \brief setanimationtime() calls draw.
     * this may not be the desired behaviour in certain cases.
     * therefore a "CallDraw" flag has been added. */
    void SetAnimationTime(const double current_time,bool CallDraw=true);

    void MakeRootShadowNode(osg::ref_ptr<osg::LightSource> lightSource);


    /** \brief returns ref_ptr to root of tree
        \author grauel */
    osg::ref_ptr<osg::Node> GetSceneRoot();
    TreeDescr GetTreeDescr();
    
    /**
      @brief sets node visbility in guis like treectrlopensgwx
      @ATTENTION this changes only the nodeinfomap and has
      no effect on the rendering of the node.
      if you want to toggle the rendering of nodes use
      open scene graph methods e.g. node switches.
    */
    void SetNodeVisible(osg::Node* node, const bool visible);
    void SetNodeOccluder(osg::Node* node, const bool state);
    void SetNodeMarkerID(osg::Node* node, const unsigned long long &id);
    const NodeInfoMap &GetNodeInfoMapRef() 
    { return NodeInfoMap_;}

    bool Save(std::string filename);
    bool Load(std::string filename);
    void Clear();
    bool IsEditableNode(osg::Node* node);

    /** @brief adds a rectangular mirror surface into the scene
     *  @param ul,..,lr upper left and lower right corners of the mirror
     *  @param mirrortexture filename for texture (color) of the mirror glass,
     *         if the file cannot be opened, white texture is used.
     *
     *  This function adds a mirror into the scene, specified by its four
     *  corners. However, in the texture of the mirror, you can reduce the
     *  mirror area by setting alpha values to zero. The color values of the
     *  mirror are mixed with the reflection.
     *  Mirror works only when stencil buffer is available.
     */
    void AddMirror(const BIAS::Vector3<double>& ul,
                   const BIAS::Vector3<double>& ur,
                   const BIAS::Vector3<double>& ll,
                   const BIAS::Vector3<double>& lr,
                   const std::string &mirrortexture, bool cutUpperHalf=false);
    void AddParticles();
    osg::Node* createMirroredScene(osg::Node* model,
                                   const BIAS::Vector3<double>& ul,
                                   const BIAS::Vector3<double>& ur,
                                   const BIAS::Vector3<double>& ll,
                                   const BIAS::Vector3<double>& lr,
                                   const std::string &mirrortexture, bool cutUpperHalf);

    void SetClearMask(int clearMask) {
      clearMask_ = clearMask;
      sceneView_->getCamera()->setClearMask(clearMask_);
    }

    void UpdateTraversal(){
      sceneView_->updateTraversal();
      sceneView_->renderingTraversals();
      if (sceneView_.valid()) sceneView_->frame();
    }

    void StartOpenSceneGraphAnimation(){
      if(hasOpenSceneGraphAnimation_){
        osgAnimation::AnimationList animlst = animationManager_.getAnimationList();
        std::cout << animlst[0]->getStartTime() << std::endl;
        animationManager_.playAnimation(animlst[0]);
        std::cout << "after: " << animlst[0]->getStartTime() << std::endl;
      }
    }

    void StopOpenSceneGraphAnimation(){
      if(hasOpenSceneGraphAnimation_){
        osgAnimation::AnimationList animlst = animationManager_.getAnimationList();
        animationManager_.stopAnimation(animlst[0]);
      }
    }

    bool OpenSceneGraphAnimationIsPlaying(){
      osgAnimation::AnimationList animlst = animationManager_.getAnimationList();
      return animationManager_.isPlaying(animlst[0]);
    }

    void OpenSceneGraphAnimationNextFrame(){
      animationManager_.NextFrame();
    }

   protected:
    bool hasOpenSceneGraphAnimation_;
    bool initialized_;
    osg::ref_ptr<osgViewer::Viewer> sceneView_;
    osg::observer_ptr<osgViewer::GraphicsWindow> embedWindow_;
    osg::ref_ptr<osg::Group> rootTree_;
    osg::ref_ptr<osg::MatrixTransform> lightTransform_;
    osg::ref_ptr<osg::Switch> lightRepresentationSwitch_;
    osg::ref_ptr<osg::Geode> lightRepresentationGeode_;
    osg::ref_ptr<osg::Light> light_;
    osg::Timer timer_;
    osg::Timer_t startTick_;
    osg::ref_ptr<osg::FrameStamp> frameStamp_;
    double timeOffset_; ///< Time offset because of time "pauses"
    double lastPauseTime_; ///< Time when the animation was paused for the last time
    int frameNumber_;

    bool headlight_;
    bool lightRepresentationVisible_;
    bool animate_;

    MyBasicAnimationManager animationManager_;
    double animTime_;

    virtual void Draw();

    void UpdateLightRepresentation_();
    void DisableZWriteForTransparentNodes_();
    void CreateStandardNodes_();

    std::string NodePtr2IDString_(osg::Node* node);
    NodeInfoMap NodeInfoMap_; //stores additional infos
                              //per node such as visbility
                              //in the gui e.g. in the
                              //treectrlopensgwx
     //void MergeTransforms_(osg::Node *node);

    int clearMask_;

  };

  struct AnimationManagerFinder : public osg::NodeVisitor
  {
      osg::ref_ptr<osgAnimation::BasicAnimationManager> _am;
      AnimationManagerFinder() : osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN) {}
      void apply(osg::Node& node) {
          if (_am.valid())
              return;
          if (node.getUpdateCallback()) {
              osgAnimation::AnimationManagerBase* b = dynamic_cast<osgAnimation::AnimationManagerBase*>(node.getUpdateCallback());
              if (b) {
                  _am = new osgAnimation::BasicAnimationManager(*b);
                  return;
              }
          }
          traverse(node);
      }
  };





}//end of namespace

#endif // __SceneOpenSceneGraph_hh__