MeshNode2T.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: 8723 $                                                       *
 *   $Author: wilden $                                                      *
 *   $Date: 2010-03-16 12:13:41 +0100 (Di, 16. Mär 2010) $                   *
 *                                                                           *
\*===========================================================================*/




//=============================================================================
//
//  CLASS MeshNodeT
//
//=============================================================================


#ifndef ACG_MESHNODE_HH
#define ACG_MESHNODE_HH


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



#include "BaseNode.hh"
#include <vector>
#include <ACG/Scenegraph/StripProcessorT.hh>

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


namespace ACG {
namespace SceneGraph {


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



template <class Mesh>
class MeshNodeT  : public BaseNode
{
public:
  ACG_CLASSNAME(MeshNode);

  MeshNodeT(Mesh&        _mesh,
            BaseNode*    _parent=0,
            std::string  _name="<MeshNode>" );

  virtual ~MeshNodeT();
  
  
  void update_geometry();
  
  void update_topology();  

  void update_color();
  
private:

  typedef typename Mesh::Point         Point;
  typedef typename Point::value_type   PointScalar;
  typedef typename Mesh::Normal        Normal;
  typedef typename Normal::value_type  NormalScalar;
  typedef typename Mesh::Color         Color;
  typedef typename Color::value_type   ColorScalar;
  
//===========================================================================
//===========================================================================  
  
public:
  
  const Mesh& mesh() const { return mesh_; }  
  
private:  
  Mesh& mesh_;  
  
//===========================================================================
//===========================================================================  
public:
//   void update_strips();

private:
  StripProcessorT<Mesh> stripProcessor_;

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

public:  
  
  void boundingBox(Vec3d& _bbMin, Vec3d& _bbMax);  
  
private:
  
  Vec3d bbMin_;
  
  Vec3d bbMax_;
  
//===========================================================================
//===========================================================================
  
private:
  
  GLuint vertexBuffer_;
  
  bool   vertexBufferInitialized_;  
  
  std::vector< ACG::Vec3f > vertices_;
  
//===========================================================================
//===========================================================================

public:
  bool normalsEnabled() { return enableNormals_; };
  
  void enableNormals(bool _enable) { enableNormals_ = _enable; };

private:
  
  bool enableNormals_;
  
  GLuint normalVertexBuffer_;
  
  bool normalVertexBufferInitialized_;
  
  std::vector< ACG::Vec3f > normals_;

//===========================================================================
//===========================================================================  
public:
  bool colorsEnabled() { return enableColors_; };
  
  void enableColors(bool _enable) { enableColors_ = _enable; };

private:
  
  bool enableColors_;
  
  GLuint colorVertexbuffer_;
  
  bool colorVertexBufferInitialized_;
  
  std::vector< ACG::Vec4f > colors_;
  
//===========================================================================
//===========================================================================  
public:
  bool texCoordEnabled() { return enableTexCoords_; };
  
  void enableTexCoords(bool _enable) { enableTexCoords_ = _enable; };
  
private:
  
  bool enableTexCoords_;
  
//===========================================================================
//===========================================================================    
private:
  std::vector< unsigned int > lineIndices_;
  
  GLuint lineIndexBuffer_;
  
  bool lineIndexBufferInitialized_;
  
//===========================================================================
//===========================================================================

public:
  
  void enable_arrays(unsigned int _arrays);    

private:
  
  enum ArrayType
  {
    NONE                      = 0,
    VERTEX_ARRAY              = 1,
    NORMAL_VERTEX_ARRAY       = 2,
    COLOR_VERTEX_ARRAY        = 4,
    TEXCOORD_VERTEX_ARRAY     = 8,
    LINE_INDEX_ARRAY          = 16,
    PER_EDGE_VERTEX_ARRAY     = 32,
    PER_EDGE_COLOR_ARRAY      = 64,
    PER_FACE_VERTEX_ARRAY     = 128,
    PER_FACE_NORMAL_ARRAY     = 256,
    PER_FACE_COLOR_ARRAY      = 512,
    PER_FACE_TEXCOORD_ARRAY   = 1024
  };
  
  unsigned int enabled_arrays_;
  

//===========================================================================
//===========================================================================
  
public:
  void draw(GLState& _state, DrawModes::DrawMode _drawMode);
  
private:
  // types
  enum FaceMode {  PER_VERTEX, PER_FACE };
  
  inline void draw_vertices();
  
  inline void draw_lines();
  
  void draw_faces(FaceMode _mode);
  
  ACG::SceneGraph::DrawModes::DrawMode  availableDrawModes() const;

private:
  

//===========================================================================
//===========================================================================
public:
  void pick(GLState& _state, PickTarget _target);

//===========================================================================
//===========================================================================  
  
private:

  void pick_vertices(GLState& _state, bool _front = false);
  
  bool updateVertexPickingList_;  

  unsigned int vertexPickingBaseIndex_;
  
  GLuint vertexPickingList_;
  
//===========================================================================
//=========================================================================== 


private:
  void pick_edges(GLState& _state, bool _front = false);  
  
  bool updateEdgePickingList_;
  
  unsigned int edgePickingBaseIndex_;
  
  GLuint edgePickingList_;

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


private:  
  void pick_faces(GLState& _state);
  
  bool updateFacePickingList_;
  
  unsigned int facePickingBaseIndex_;  
  
  GLuint facePickingList_;

//===========================================================================
//=========================================================================== 
  
private:  
  
  void pick_any(GLState& _state);  
  
  bool updateAnyPickingList_;
  
  unsigned int anyPickingBaseIndex_;    
  
  GLuint anyPickingList_;  
  
//===========================================================================
//=========================================================================== 
public:
  void setIndexPropertyName( std::string _indexPropertyName );
  
  
  void setHalfedgeTextcoordPropertyName( std::string _halfedgeTextcoordPropertyName );
  
  public:
    
    void setTextureMap( std::map< int, GLuint>* _map){ textureMap_ = _map; };
  
private:
  
  bool perFaceTextureIndexAvailable_;
  
  bool perFaceTextureCoordsAvailable_;
  
  std::map< int, GLuint>* textureMap_;


  
public:  
  void set_property_map( std::map< int, std::string>* _map){ };  
    
    
    

};


//=============================================================================
} // namespace SceneGraph
} // namespace ACG
//=============================================================================
#if defined(INCLUDE_TEMPLATES) && !defined(ACG_MESHNODE_C)
#define ACG_MESHNODE_TEMPLATES
#include "MeshNode2T.cc"
#endif
//=============================================================================
#endif // ACG_MESHNODE_HH defined
//=============================================================================