DrawMesh.hh

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *      Copyright (C) 2001-2011 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: 15046 $                                                       *
*   $LastChangedBy: lim $                                                *
*   $Date: 2012-07-16 15:30:37 +0200 (Mo, 16 Jul 2012) $                     *
*                                                                            *
\*===========================================================================*/



//=============================================================================
//
//  CLASS DrawMeshT
//
//=============================================================================


#ifndef ACG_DRAW_MESH_HH
#define ACG_DRAW_MESH_HH


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

#include <vector>
#include <list>
#include <OpenMesh/Core/Utils/Property.hh>
#include <OpenMesh/Core/IO/MeshIO.hh>

#include <ACG/Config/ACGDefines.hh>

#include <ACG/GL/GLState.hh>

#include <ACG/GL/IRenderer.hh>

//== FORWARDDECLARATIONS ======================================================


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

namespace ACG {

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


template <class Mesh>
class DrawMeshT
{
private:

#pragma pack(push, 1)

  struct Vertex
  {
    Vertex();

    float pos[3]; 
    float tex[2]; 
    float n[3];   
//    float tan[4]; /*!< tangent vector + parity */

    unsigned int vcol; 
    unsigned int fcol; 
    int equals(const Vertex& r);
  };

  struct VertexC
  {
    unsigned short pos[3];
    unsigned short u, v;
    unsigned int n;
//    unsigned int tan;

    unsigned int vcol;
    unsigned int fcol;
  };
#pragma pack(pop)

  struct Subset
  {
    int  materialID;
    unsigned long startIndex;
    unsigned long numTris;
  };

  enum REBUILD_TYPE {REBUILD_NONE = 0, REBUILD_FULL = 1, REBUILD_GEOMETRY = 2, REBUILD_TOPOLOGY = 4, REBUILD_TEXTURES = 5};


public:

  DrawMeshT(Mesh& _mesh);
  virtual ~DrawMeshT();

  void disableColors()      {colorMode_ = 0;}
  void usePerVertexColors() {colorMode_ = 1;}
  void usePerFaceColors()   {colorMode_ = 2;}

  void setFlatShading()     {flatMode_ = 1;}
  void setSmoothShading()   {flatMode_ = 0;}

  void usePerVertexTexcoords()     {textureMode_ = 0;}
  void usePerHalfedgeTexcoords()   {textureMode_ = 1;}
  void usePerVertexNormals()   {halfedgeNormalMode_ = 0;}
  void usePerHalfedgeNormals()   {halfedgeNormalMode_ = 1;}

  void bindBuffers();

  void bindBuffersToRenderObject(RenderObject* _obj);

  void unbindBuffers();

  void draw(std::map< int, GLuint>* _textureMap);

  void addTriRenderObjects(IRenderer* _renderer, const RenderObject* _baseObj, std::map< int, GLuint>* _textureMap);

  void drawLines();

  void addLineRenderObjects(IRenderer* _renderer, const RenderObject* _baseObj);


  void drawVertices();

  void addPointRenderObjects(IRenderer* _renderer, const RenderObject* _baseObj);


  unsigned int getNumTris() const {return numTris_;}
  unsigned int getNumVerts() const {return numVerts_;}
  unsigned int getNumSubsets() const {return numSubsets_;}


  unsigned int getMemoryUsage(bool _printReport = false);

  // The updateX functions give a hint on what to update.
  //  may perform a full rebuild internally!

  void updateTopology() {rebuild_ |= REBUILD_TOPOLOGY;}

  void updateGeometry() {rebuild_ |= REBUILD_GEOMETRY;}

  void updateTextures() {rebuild_ |= REBUILD_TEXTURES;}

  void updateFull() {rebuild_ |= REBUILD_FULL;}

  unsigned int getNumTextures();

  void setTextureIndexPropertyName( std::string _indexPropertyName );

  const std::string& getTextureIndexPropertyName() const { return textureIndexPropertyName_; };

  void setPerFaceTextureCoordinatePropertyName( std::string _perFaceTextureCoordinatePropertyName );

  int perFaceTextureCoordinateAvailable();

  int perFaceTextureIndexAvailable();

private:
  // processing pipeline:

  void rebuild();


  unsigned int convertToTriangleMesh(unsigned int* _dstIndexBuf, unsigned int _maxFaceVertexCount);

  void createBigVertexBuf(Vertex* _dstVertexBuf, unsigned int* _dstVertexMap, const unsigned int* _indexBuf);

  void readVertex(Vertex*                       _pDst,
                  typename Mesh::VertexHandle   _vh,
                  typename Mesh::HalfedgeHandle _hh,
                  typename Mesh::FaceHandle     _fh);

  void removeIsolatedVerts();

  unsigned int weldVertices(Vertex*             _dstVertexBuf,
                            const Vertex*       _srcVertexBuf,
                            unsigned int*       _dstIndexBuf,
                            unsigned int*       _dstVertexMap,
                            const unsigned int* _srcVertexMap,
                            std::list< std::pair<unsigned int, unsigned int> >& _duplicatesMap);

  void sortTrisByMaterial(unsigned int* _dstIndexBuf, const unsigned int* _srcIndexBuf);

  void optimizeTris(unsigned int* _dstIndexBuf, unsigned int* _srcIndexBuf);

  void optimizeVerts(Vertex*             _dstVertexBuf,
                     const Vertex*       _srcVertexBuf,
                     unsigned int*       _inOutIndexBuf,
                     const unsigned int* _srcVertexMap);


  void createVBO();

  void createIBO();

  void createVertexDeclarations();

public:
  // color picking

  void updatePickingVertices(ACG::GLState& _state , uint _offset = 0);

  ACG::Vec4uc * pickVertexColorBuffer(){
    if ( !pickVertColBuf_.empty() )
      return &(pickVertColBuf_)[0];
    else {
      std::cerr << "Illegal request to pickVertexColorBuffer when buffer is empty!" << std::endl;
      return 0;
    }
  };

  ACG::Vec3f * pickVertexBuffer(){
    if ( !pickVertBuf_.empty() )
      return &(pickVertBuf_)[0];
    else {
      std::cerr << "Illegal request to pickVertexBuffer when buffer is empty!" << std::endl;
      return 0;
    }
  };

private:

  std::vector< ACG::Vec3f > pickVertBuf_;
  std::vector< ACG::Vec4uc > pickVertColBuf_;



public:

  void updatePickingEdges(ACG::GLState& _state , uint _offset = 0 );

  ACG::Vec4uc * pickEdgeColorBuffer(){
    if ( !pickEdgeBuf_.empty() )
      return &(pickEdgeBuf_)[0];
    else {
      std::cerr << "Illegal request to pickEdgeColorBuffer when buffer is empty!" << std::endl;
      return 0;
    }
  }

private:

  std::vector< ACG::Vec4uc > pickEdgeBuf_;



public:

  void updatePickingFaces(ACG::GLState& _state );

  ACG::Vec4uc * pickFaceColorBuffer(){
    if ( !pickFaceColBuf_.empty() )
      return &(pickFaceColBuf_)[0];
    else {
      std::cerr << "Illegal request to pickFaceColorBuffer when buffer is empty!" << std::endl;
      return 0;
    }
  }

  ACG::Vec3f * pickFaceVertexBuffer(){
    if ( !pickFaceVertexBuf_.empty() )
      return &(pickFaceVertexBuf_)[0];
    else {
      std::cerr << "Illegal request to pickFaceVertexBuffer when buffer is empty!" << std::endl;
      return 0;
    }
  }

private:

  std::vector< ACG::Vec3f > pickFaceVertexBuf_;
  std::vector< ACG::Vec4uc > pickFaceColBuf_;


public:
  void updatePickingAny(ACG::GLState& _state );

  ACG::Vec4uc * pickAnyFaceColorBuffer(){
    if ( !pickAnyFaceColBuf_.empty() )
      return &(pickAnyFaceColBuf_)[0];
    else {
      std::cerr << "Illegal request to pickAnyFaceColorBuffer when buffer is empty!" << std::endl;
      return 0;
    }
  }

  ACG::Vec4uc * pickAnyEdgeColorBuffer(){
    if ( !pickAnyEdgeColBuf_.empty() )
      return &(pickAnyEdgeColBuf_)[0];
    else {
      std::cerr << "Illegal request to pickAnyEdgeColorBuffer when buffer is empty!" << std::endl;
      return 0;
    }
  }

  ACG::Vec4uc * pickAnyVertexColorBuffer(){
    if ( !pickAnyVertexColBuf_.empty() )
      return &(pickAnyVertexColBuf_)[0];
    else {
      std::cerr << "Illegal request to pickAnyVertexColorBuffer when buffer is empty!" << std::endl;
      return 0;
    }
  }

private:

  std::vector< ACG::Vec4uc > pickAnyFaceColBuf_;
  std::vector< ACG::Vec4uc > pickAnyEdgeColBuf_;
  std::vector< ACG::Vec4uc > pickAnyVertexColBuf_;


private:

  // small helper functions

  unsigned int countTris(unsigned int* _pOutMaxPolyVerts = 0);

  int getTextureIDofTri(unsigned int _tri);

private:

  Mesh& mesh_;

  unsigned int numTris_, numVerts_;

  unsigned int* indices_;

  Vertex* vertices_;

  unsigned int rebuild_;

  unsigned int prevNumFaces_,prevNumVerts_;


  // per material/texture subsets
  unsigned int numSubsets_;
  Subset* subsets_;

  GLuint vbo_,
         ibo_;

  GLuint lineIBO_;

  GLenum indexType_;

  int colorMode_;
  int flatMode_;

  int bVBOinFlatMode_;

  int textureMode_;

  int bVBOinHalfedgeTexMode_;

  int halfedgeNormalMode_;

  int bVBOinHalfedgeNormalMode_;


  unsigned int* triToFaceMap_;

  unsigned int* vertexMap_;

  unsigned int* invVertexMap_;


  VertexDeclaration* vertexDeclVCol_;

  VertexDeclaration* vertexDeclFCol_;

  VertexDeclaration* vertexDeclEdgeCol_;

  VertexDeclaration* vertexDeclHalfedgeCol_;

  VertexDeclaration* vertexDeclHalfedgePos_;


  //========================================================================
  // internal processing
  // temporal buffer allocations to avoid memory requests while updating
  //========================================================================

  unsigned int* indicesTmp_;
  Vertex* verticesTmp_;

  //========================================================================
  // texture handling
  //========================================================================

  std::string textureIndexPropertyName_;

  std::string perFaceTextureCoordinatePropertyName_;


public:
  //========================================================================
  // per edge buffers

  void invalidatePerEdgeBuffers() {updatePerEdgeBuffers_ = 1;}

  void updatePerEdgeBuffers();

  ACG::Vec3f* perEdgeVertexBuffer();

  ACG::Vec4f* perEdgeColorBuffer();

  void invalidatePerHalfedgeBuffers() {updatePerHalfedgeBuffers_ = 1;}

  void updatePerHalfedgeBuffers();

  ACG::Vec3f* perHalfedgeVertexBuffer();

  ACG::Vec4f* perHalfedgeColorBuffer();


  void updateEdgeHalfedgeVertexDeclarations();


  const VertexDeclaration* getEdgeColoredVertexDeclaration() const {return vertexDeclEdgeCol_;}

  const VertexDeclaration* getHalfedgeVertexDeclaration() const {return vertexDeclHalfedgePos_;}

  const VertexDeclaration* getHalfedgeColoredVertexDeclaration() const {return vertexDeclHalfedgeCol_;}


private:
  int updatePerEdgeBuffers_;
  std::vector<ACG::Vec3f> perEdgeVertexBuf_;
  std::vector<ACG::Vec4f> perEdgeColorBuf_;

  int updatePerHalfedgeBuffers_;
  std::vector<ACG::Vec3f> perHalfedgeVertexBuf_;
  std::vector<ACG::Vec4f> perHalfedgeColorBuf_;

  typename Mesh::Point halfedge_point(const typename Mesh::HalfedgeHandle _heh);

};



//=============================================================================
} // namespace ACG
//=============================================================================
#if defined(INCLUDE_TEMPLATES) && !defined(ACG_DRAW_MESH_C)
#define ACG_DRAW_MESH_TEMPLATES
#include "DrawMesh.cc"
#endif
//=============================================================================
#endif // ACG_DRAW_MESH_HH defined
//=============================================================================