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.              *
 *                                                                           *
\*===========================================================================*/

/*===========================================================================*\
 *                                                                           *
 *   $Revision$                                                       *
 *   $Author$                                                      *
 *   $Date$                   *
 *                                                                           *
\*===========================================================================*/



//=============================================================================
//
//  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 <vector>
#include <string>
#include <algorithm>
#include <iostream>
#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 =========================================================


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

  PICK_FRONT_EDGE,
  PICK_FRONT_VERTEX,

  PICK_SPLINE
};


#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 */, 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
//=============================================================================