BaseNode.hh

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
 *                                                                           *
\*===========================================================================*/
 
 
 
 
 
//=============================================================================
//
//  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"
#include "PickTarget.hh"
 
// Qt
//#include <qgl.h>
#include <QMouseEvent>
 
// stdc++
#include <vector>
#include <string>
#include <ACG/Scenegraph/DrawModes.hh>
#include <ACG/GL/RenderObject.hh>
 
//== NAMESPACES ===============================================================
 
 
namespace ACG {
 
class IRenderer;
 
namespace SceneGraph {
 
// prototype declaration to avoid include-loop
class Material;
 
 
//== CLASS DEFINITION =========================================================
 
 
#define ACG_CLASSNAME(_className) \
 virtual const std::string& className() const override { \
  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 */, const DrawModes::DrawMode& /*_drawMode*/ ) {}
 
  virtual void enter(IRenderer* /*_renderer*/, GLState& _state, const DrawModes::DrawMode& _drawMode) {
      enter(_state, _drawMode);
  }
 
  virtual void draw(GLState& /* _state */, const DrawModes::DrawMode& /* _drawMode */)  {}
 
  virtual void getRenderObjects(IRenderer* _renderer, GLState&  _state , const DrawModes::DrawMode&  _drawMode , const Material* _mat)  {}
 
  virtual void leave(GLState& /* _state */, const DrawModes::DrawMode& /* _drawMode */) {}
 
  virtual void leave(IRenderer* /*_renderer*/, GLState& _state, const DrawModes::DrawMode& _drawMode) {
      leave(_state, _drawMode);
  }
 
  virtual void enterPick(GLState& _state , PickTarget _target, const DrawModes::DrawMode& _drawMode );
  
  virtual void pick(GLState& /* _state */, PickTarget /* _target */ ) {}
 
  virtual void leavePick(GLState& _state, PickTarget _target, const DrawModes::DrawMode& _drawMode );
  
  void enablePicking(bool _enable) { pickingEnabled_ = _enable; };
  
  bool pickingEnabled() { return pickingEnabled_; };
  
  virtual void mouseEvent(GLState& /* _state */, QMouseEvent* /* _event */ ) {}
 
  void setDirty (bool _dirty = true) { dirty_ = _dirty; }
 
  bool isDirty () const { return dirty_; }
 
 
  // --- iterators ---
 
  typedef std::vector<BaseNode*>::const_iterator ConstChildIter;
  typedef std::vector<BaseNode*>::iterator ChildIter;
 
  typedef std::vector<BaseNode*>::const_reverse_iterator ConstChildRIter;
  typedef std::vector<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); 
  }
 
  size_t 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_; }
 
  const BaseNode* parent() const { 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;  
 
 
  //===========================================================================
  //===========================================================================
 
public:
 
  void setRenderObjectShaders(const std::string& _vertexShaderFile, const std::string& _geometryShaderFile, const std::string& _fragmentShaderFile, bool _relativePaths = true, DrawModes::DrawModePrimitive _primitiveType = DrawModes::PRIMITIVE_POLYGON);
 
  void setRenderObjectShaders(const std::string& _vertexShaderFile, const std::string& _tessControlShaderFile, const std::string& _tessEvalShaderFile, const std::string& _geometryShaderFile, const std::string& _fragmentShaderFile, bool _relativePaths = true, DrawModes::DrawModePrimitive _primitiveType = DrawModes::PRIMITIVE_POLYGON);
 
 
  void setRenderObjectUniformPool(const GLSL::UniformPool* _pool) {uniformPool_ = _pool;}
 
  const GLSL::UniformPool* getRenderObjectUniformPool() {return uniformPool_;}
 
  void setRenderObjectTexture(int _samplerSlot, GLuint _texId, GLenum _texType = GL_TEXTURE_2D);
 
 
  void setRenderObjectModifier(RenderObjectModifier* _modifier) {renderModifier_ = _modifier;}
 
  RenderObjectModifier* getRenderObjectModifier() {return  renderModifier_;}
 
 
 
  void applyRenderObjectSettings(DrawModes::DrawModePrimitive _primitive, RenderObject* _obj) const;
 
private:
 
  MultipassBitMask multipassStatus_;
  
  MultipassBitMask multipassNode_;
 
private:
 
  BaseNode(const BaseNode&);
 
  void operator=(const BaseNode&);
 
  
  BaseNode* parent_;
 
  std::string name_;
 
  StatusMode status_;
  
  std::vector<BaseNode*> children_;
 
  static unsigned int last_id_used__;
 
  unsigned int id_;
 
  DrawModes::DrawMode drawMode_;
  
  bool pickingEnabled_;
 
  bool dirty_;
 
  unsigned int traverseMode_;
 
 
  // settings for shader-based rendering with render-objects
private:
 
  struct ShaderSet 
  {
    // shader filenames
 
    std::string vs_;
 
    std::string tcs_;
 
    std::string tes_;
 
    std::string gs_;
 
    std::string fs_;
    
    bool relativePaths_;
  };
  
  std::map<DrawModes::DrawModePrimitive, ShaderSet> shaderSettings_;
 
  std::map<int, RenderObject::Texture> textureSettings_;
 
  const GLSL::UniformPool* uniformPool_;
 
  RenderObjectModifier* renderModifier_;
};
 
 
//=============================================================================
} // namespace SceneGraph
} // namespace ACG
//=============================================================================
#endif // ACG_BASE_NODE_HH defined
//=============================================================================