BaseNode.hh

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *      Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen      *
 *                           www.openflipper.org                             *
 *                                                                           *
 *---------------------------------------------------------------------------*
 *  This file is part of OpenFlipper.                                        *
 *                                                                           *
 *  OpenFlipper is free software: you can redistribute it and/or modify      *
 *  it under the terms of the GNU Lesser General Public License as           *
 *  published by the Free Software Foundation, either version 3 of           *
 *  the License, or (at your option) any later version with the              *
 *  following exceptions:                                                    *
 *                                                                           *
 *  If other files instantiate templates or use macros                       *
 *  or inline functions from this file, or you compile this file and         *
 *  link it with other files to produce an executable, this file does        *
 *  not by itself cause the resulting executable to be covered by the        *
 *  GNU Lesser General Public License. This exception does not however       *
 *  invalidate any other reasons why the executable file might be            *
 *  covered by the GNU Lesser General Public License.                        *
 *                                                                           *
 *  OpenFlipper is distributed in the hope that it will be useful,           *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *
 *  GNU Lesser General Public License for more details.                      *
 *                                                                           *
 *  You should have received a copy of the GNU LesserGeneral Public          *
 *  License along with OpenFlipper. If not,                                  *
 *  see <http://www.gnu.org/licenses/>.                                      *
 *                                                                           *
\*===========================================================================*/

/*===========================================================================*\
 *                                                                           *
 *   $Revision: 8548 $                                                       *
 *   $Author: moebius $                                                      *
 *   $Date: 2010-02-12 14:40:13 +0100 (Fr, 12. Feb 2010) $                   *
 *                                                                           *
\*===========================================================================*/



//=============================================================================
//
//  CLASS BaseNode
//
//=============================================================================


#ifndef ACG_BASE_NODE_HH
#define ACG_BASE_NODE_HH


//== INCLUDES =================================================================

// ACG
#include "../Math/VectorT.hh"
#include "../GL/GLState.hh"
#include "../Config/ACGDefines.hh"

// Qt
//#include <qgl.h>
#include <QMouseEvent>

// stdc++
#include <list>
#include <string>
#include <algorithm>
#include <iostream>
#include <ACG/Scenegraph/DrawModes.hh>


//== NAMESPACES ===============================================================


namespace ACG {
namespace SceneGraph {


//== CLASS DEFINITION =========================================================


enum PickTarget 
{
  PICK_CELL,
  PICK_FACE,
  PICK_EDGE,
  PICK_VERTEX,
  PICK_ANYTHING,

  PICK_FRONT_EDGE,
  PICK_FRONT_VERTEX
};


#define ACG_CLASSNAME(_className) \
 virtual const std::string& className() const { \
  static std::string cname( #_className ); return cname; \
}


class ACGDLLEXPORT BaseNode 
{
public:


  BaseNode(BaseNode* _parent=0, std::string _name="<unknown>");

  BaseNode(BaseNode* _parent, BaseNode* _child, std::string _name="<unknown>");
 
  virtual ~BaseNode();

  void delete_subtree();


  // --- basic interface ---

  virtual const std::string& className() const = 0;

  virtual DrawModes::DrawMode availableDrawModes() const { return DrawModes::NONE; }

  virtual void boundingBox(Vec3d& /* _bbMin */, Vec3d& /*_bbMax*/ ) {}

  virtual void enter(GLState& /*_state */, DrawModes::DrawMode /*_drawMode*/ ) {}

  virtual void draw(GLState& /* _state */, DrawModes::DrawMode /* _drawMode */)  {}

  virtual void leave(GLState& /* _state */, DrawModes::DrawMode /* _drawMode */) {}

  virtual void enterPick(GLState& _state , PickTarget _target,
                         DrawModes::DrawMode _drawMode );
  
  virtual void pick(GLState& /* _state */, PickTarget /* _target */ ) {}

  virtual void leavePick(GLState& _state, PickTarget _target,
                         DrawModes::DrawMode _drawMode );
  
  void enablePicking(bool _enable) { pickingEnabled_ = _enable; };
  
  bool pickingEnabled() { return pickingEnabled_; };
  
  virtual void mouseEvent(GLState& /* _state */, QMouseEvent* /* _event */ ) {}


  GLenum depthFunc() const { return depth_func_; }

  void depthFunc(GLenum _func) { depth_func_ = _func; }

  void setDirty (bool _dirty = true) { dirty_ = _dirty; }

  bool isDirty () const { return dirty_; }


  // --- iterators ---

  typedef std::list<BaseNode*>::const_iterator ConstChildIter;
  typedef std::list<BaseNode*>::iterator ChildIter;

  typedef std::list<BaseNode*>::const_reverse_iterator ConstChildRIter;
  typedef std::list<BaseNode*>::reverse_iterator ChildRIter;

  ChildIter childrenBegin() { return children_.begin(); }
  ConstChildIter childrenBegin() const { return children_.begin(); }
  ChildIter childrenEnd() { return children_.end(); }
  ConstChildIter childrenEnd() const { return children_.end(); }
  
  ChildRIter childrenRBegin() { return children_.rbegin(); }
  ConstChildRIter childrenRBegin() const { return children_.rbegin(); }
  ChildRIter childrenREnd() { return children_.rend(); }
  ConstChildRIter childrenREnd() const { return children_.rend(); }




  
  // --- insert / remove ---

  void push_back(BaseNode* _node) 
  {
    if (_node)
    {
      children_.push_back(_node);
      _node->parent_=this;
    }
  }

  void remove(ChildIter _pos) 
  {
    if (_pos == childrenEnd()) return;
    //(*_pos)->parent_=0;
    children_.erase(_pos); 
  }

  unsigned int nChildren() const { return children_.size(); }

  ChildIter find(BaseNode* _node) 
  {
    ChildIter i=std::find(children_.begin(),children_.end(),_node);
    return i;
  } 


  BaseNode * find( const std::string & _name )
  {
    if ( name() == _name )
      return this;

    for ( BaseNode::ChildIter cIt = childrenBegin();
          cIt != childrenEnd(); ++cIt )
    {
      BaseNode * n = (*cIt)->find( _name );
      if ( n ) return n;
    }

    return 0;
  } 
  

  BaseNode* parent() { return parent_; }
  
  void set_parent(BaseNode* _parent);


  // --- status info ---

  
  enum StatusMode
  {
    Active = 0x1,
    HideNode  = 0x2,
    HideChildren = 0x4,
    HideSubtree  = 0x8
  };
  StatusMode status() const { return status_; }
  void set_status(StatusMode _s) { status_ = _s; }
  void hide() { set_status(HideNode); }
  void show() { set_status(Active); }
  bool visible() { return status_ == Active; }
  bool hidden() { return status_ != Active; }


  std::string name() const { return name_; }
  void name(const std::string& _name) { name_ = _name; }

  
  unsigned int id() const { return id_; }
  


  //--- draw mode ---

  DrawModes::DrawMode drawMode() const { return drawMode_; }
  void drawMode(DrawModes::DrawMode _drawMode) { drawMode_ = _drawMode; }

  //--- traverse type ---

  enum TraverseMode
  {
    NodeFirst = 0x1,
    ChildrenFirst = 0x2,
    SecondPass = 0x4
  };

  unsigned int traverseMode () const { return traverseMode_; }

  void setTraverseMode(unsigned int _mode) { traverseMode_ = _mode; }

  //===========================================================================
  //===========================================================================

public:
  
  typedef unsigned int MultipassBitMask;
  

  enum PASSES {
    NOPASS = 0,
    ALLPASSES = 1 << 0,
    PASS_1    = 1 << 1,
    PASS_2    = 1 << 2,
    PASS_3    = 1 << 3,
    PASS_4    = 1 << 4,
    PASS_5    = 1 << 5,
    PASS_6    = 1 << 6,
    PASS_7    = 1 << 7,
    PASS_8    = 1 << 8
  };
  
  MultipassBitMask multipassStatus() const {return multipassStatus_;};
  
  
  void setMultipassStatus(const MultipassBitMask _passStatus) { multipassStatus_ = _passStatus; };
  
  void multipassStatusSetActive(const unsigned int _i, bool _active);
 
  bool multipassStatusActive(const unsigned int _i) const;  
  
  
  
  MultipassBitMask multipassNode() const {return multipassNode_;};  
  
  
  
  void setMultipassNode(const MultipassBitMask _passNode) { multipassNode_ = _passNode; };  
  
  void multipassNodeSetActive(const unsigned int _i , bool _active);
  
  bool multipassNodeActive(const unsigned int _i) const;  

private:

  MultipassBitMask multipassStatus_;
  
  MultipassBitMask multipassNode_;

private:

  BaseNode(const BaseNode&);
  void operator=(const BaseNode&);

  
  BaseNode* parent_;

  std::string name_;

  StatusMode status_;
  
  std::list<BaseNode*> children_; 

  static unsigned int last_id_used__;

  unsigned int id_;

  DrawModes::DrawMode drawMode_;

  GLenum depth_func_;
  
  bool pickingEnabled_;

  bool dirty_;

  unsigned int traverseMode_;
};


//=============================================================================
} // namespace SceneGraph
} // namespace ACG
//=============================================================================
#endif // ACG_BASE_NODE_HH defined
//=============================================================================