DrawMesh.hh

#pragma once
/*===========================================================================*\
 *                                                                           *
 *                              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 DrawMeshT
//
//=============================================================================
 
//== INCLUDES =================================================================
 
#include <vector>
#include <list>
#include <OpenMesh/Core/Utils/Property.hh>
#include <OpenMesh/Core/Utils/color_cast.hh>
 
#include <OpenMesh/Core/Mesh/DefaultTriMesh.hh>
#include <OpenMesh/Core/Mesh/DefaultPolyMesh.hh>
 
#include <ACG/GL/globjects.hh>
#include <ACG/GL/GLState.hh>
#include <ACG/GL/IRenderer.hh>
#include <ACG/GL/MeshCompiler.hh>
#include <ACG/ShaderUtils/GLSLShader.hh>
 
#include <ACG/Config/ACGDefines.hh>
 
//== FORWARDDECLARATIONS ======================================================
 
 
//== NAMESPACES ===============================================================
 
namespace ACG {
 
//== CLASS DEFINITION =========================================================
 
class ACGDLLEXPORT DrawMeshBase {
    protected:
        DrawMeshBase();
        ~DrawMeshBase();
 
        void deleteIbo();
        void bindVbo();
        void bindIbo();
        void bindLineIbo();
        void bindHEVbo();
        void unbindHEVbo();
        void bindPickVertexIbo();
 
        void createIndexBuffer();
        void fillLineBuffer(size_t n_edges, void *data);
        void fillHEVBO(size_t numberOfElements_, size_t sizeOfElements_, void* data_);
        void fillVertexBuffer();
        void fillInvVertexMap(size_t n_vertices, void *data);
 
    public:
        size_t getNumTris() const { return numTris_; }
        size_t getNumVerts() const { return numVerts_; }
 
        MeshCompiler* getMeshCompiler() {return meshComp_;}
        unsigned int getNumSubsets() const {return meshComp_->getNumSubsets();}
 
        GLenum getIndexType() const {return indexType_;}
 
        GLuint pickVertexIBO_opt() {return pickVertexIBO_;} // does not work
 
 
 
    protected:
        GLuint vbo_, ibo_;
        size_t numTris_, numVerts_;
        MeshCompiler* meshComp_;
 
        GLuint lineIBO_;
        GLuint heVBO_;
        //previously bound buffer
        GLint prevVBO_;
 
        GLenum indexType_;
 
        std::vector<char> vertices_;
 
        VertexDeclaration* vertexDecl_;
 
        VertexDeclaration* vertexDeclEdgeCol_;
 
        VertexDeclaration vertexDeclEdgeNew_;
 
        VertexDeclaration* vertexDeclHalfedgeCol_;
 
        VertexDeclaration* vertexDeclHalfedgePos_;
 
        GLuint pickVertexIBO_;
 
};
 
 
template <class Mesh>
class DrawMeshT : public DrawMeshBase
{
private:
 
  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 = 8};
 
 
public:
 
  explicit 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();
 
  GLuint getVBO();
 
  GLuint getIBO();
 
  GLuint getHEVBO(){return heVBO_;}
 
  VertexDeclaration* getVertexDeclaration();
 
  unsigned int mapVertexToVBOIndex(unsigned int _v);
 
 
  void bindBuffersToRenderObject(RenderObject* _obj);
 
  void unbindBuffers();
 
  void draw(std::map< int, GLuint>* _textureMap, bool _nonindexed = false);
 
  void addTriRenderObjects(IRenderer* _renderer, const RenderObject* _baseObj, std::map< int, GLuint>* _textureMap, bool _nonindexed = false);
 
  void drawLines();
 
  void addLineRenderObjects(IRenderer* _renderer, const RenderObject* _baseObj);
 
 
  void drawVertices();
 
  void addPointRenderObjects(IRenderer* _renderer, const RenderObject* _baseObj);
 
 
 
  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();
 
 
  enum PropertySource
  {
    PROPERTY_SOURCE_VERTEX = 0,
    PROPERTY_SOURCE_HALFEDGE,
    PROPERTY_SOURCE_FACE,
  };
 
  void addVertexElement( const std::string& _propertyName, PropertySource _source = PROPERTY_SOURCE_VERTEX );
 
  bool scanVertexShaderForInput( const std::string& _vertexShaderFile );
 
private:
  // processing pipeline:
 
  void rebuild();
 
 
  void readVertex(size_t                               _vertex,
                  const typename Mesh::VertexHandle&   _vh,
                  const typename Mesh::HalfedgeHandle& _hh,
                  const typename Mesh::FaceHandle&     _fh);
 
  unsigned int getVertexColor(const typename Mesh::VertexHandle&   _vh);
 
  unsigned int getFaceColor(const typename Mesh::FaceHandle&   _fh);
 
  void updateGPUBuffers();
 
  void createVBO();
 
  void createIBO();
 
  void createVertexDeclaration();
 
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;
    }
  };
 
 
  void drawPickingVertices_opt(const GLMatrixf& _mvp, size_t _pickOffset);
 
 
  bool supportsPickingVertices_opt();
 
  void updatePickingVertices_opt(ACG::GLState& _state);
 
 
  TextureBuffer* pickVertexMap_opt(){
    if ( pickVertexMapTBO_.is_valid() )
      return &pickVertexMapTBO_;
    else {
      std::cerr << "Illegal request to pickVertexMap_opt when buffer is empty!" << std::endl;
      return 0;
    }
  }
 
 
private:
 
  std::vector< ACG::Vec3f > pickVertBuf_;
  std::vector< ACG::Vec4uc > pickVertColBuf_;
 
 
  // map from vbo vertex id to openmesh vertex id
  TextureBuffer pickVertexMapTBO_;
 
  // vertex picking shader
  GLSL::Program* pickVertexShader_;
 
 
  // selected shader picking method:
  //  0 -> use texturebuffer which maps from vbo id to openmesh vertex id
  //  1 -> draw with indexbuffer mapping from openmesh vertex id to vbo vertex
  int pickVertexMethod_;
 
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;
    }
  }
 
 
  void drawPickingEdges_opt(const GLMatrixf& _mvp, size_t _pickOffset);
 
 
  bool supportsPickingEdges_opt();
 
  void updatePickingEdges_opt(ACG::GLState& _state );
 
private:
 
  std::vector< ACG::Vec4uc > pickEdgeBuf_;
 
  // edge picking shader
  GLSL::Program* pickEdgeShader_;
 
 
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;
    }
  }
 
  void drawPickingFaces_opt(const GLMatrixf& _mvp, size_t _pickOffset);
 
 
  bool supportsPickingFaces_opt();
 
  void updatePickingFaces_opt(ACG::GLState& _state );
 
 
  TextureBuffer* pickFaceTriangleMap_opt(){
    if ( pickFaceTriToFaceMapTBO_.is_valid() )
      return &pickFaceTriToFaceMapTBO_;
    else {
      std::cerr << "Illegal request to pickFaceTriangleMap_opt when buffer is empty!" << std::endl;
      return 0;
    }
  }
 
private:
 
  // unoptimized picking buffers
  std::vector< ACG::Vec3f > pickFaceVertexBuf_;
  std::vector< ACG::Vec4uc > pickFaceColBuf_;
 
  // optimized picking with shaders: maps from triangle id in draw vbo to face id in openmesh
  TextureBuffer pickFaceTriToFaceMapTBO_;
 
  GLSL::Program* pickFaceShader_;
 
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;
    }
  }
 
  void drawPickingAny_opt(const GLMatrixf& _mvp, size_t _pickOffset);
 
  bool supportsPickingAny_opt();
 
  void updatePickingAny_opt(ACG::GLState& _state );
 
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, unsigned int* _pOutNumIndices = 0);
 
  int getTextureIDofTri(unsigned int _tri);
 
  int getTextureIDofFace(unsigned int _face);
 
  const void* getMeshPropertyType(OpenMesh::BaseProperty* _prop, GLuint* _outType, unsigned int* _outSize) const;
 
  template<class T>
  const void* testMeshPropertyTypeT(const OpenMesh::BaseProperty* _prop, unsigned int* _outSize) const;
 
 
public:
 
  void dumpObj(const char* _filename) const;
 
private:
 
  Mesh& mesh_;
 
  unsigned int* indices_;
 
  unsigned int rebuild_;
 
  size_t prevNumFaces_,prevNumVerts_;
 
 
  int colorMode_;
 
  int curVBOColorMode_;
 
  int flatMode_;
 
  int bVBOinFlatMode_;
 
  int textureMode_;
 
  int bVBOinHalfedgeTexMode_;
 
  int halfedgeNormalMode_;
 
  int bVBOinHalfedgeNormalMode_;
 
 
  unsigned int* invVertexMap_;
 
 
 
  //========================================================================
  // flexible vertex layout
  //========================================================================
 
 
  struct VertexProperty 
  {
    // get property from vertex, face or halfedge array
    PropertySource source_;
 
    std::string name_;
 
    std::string vertexShaderInputName_;
 
    VertexElement sourceType_;
 
    VertexElement destType_;
 
    const void* propDataPtr_;
 
    int declElementID_;
  };
  
  const size_t offsetPos_,
    offsetNormal_,
    offsetTexc_,
    offsetColor_;
 
  std::vector<VertexProperty> additionalElements_;
 
  //========================================================================
  // texture handling
  //========================================================================
 
  std::string textureIndexPropertyName_;
 
  std::string perFaceTextureCoordinatePropertyName_;
 
 
private:
  //========================================================================
  // write functions for flexible vertex format
 
  void writeVertexElement(void* _dstBuf, size_t _vertex, size_t _stride, size_t _elementOffset, size_t _elementSize, const void* _elementData);
 
  void writePosition(size_t _vertex, const ACG::Vec3d& _p);
 
  void writeNormal(size_t _vertex, const ACG::Vec3d& _n);
 
  void writeTexcoord(size_t _vertex, const ACG::Vec2f& _uv);
 
  void writeColor(size_t _vertex, unsigned int _color);
 
  void writeVertexProperty(size_t _vertex, const VertexElement* _elementDesc, const ACG::Vec4f& _propf);
 
  void writeVertexProperty(size_t _vertex, const VertexElement* _elementDesc, const ACG::Vec4d& _propd);
 
 
  void readVertexFromVBO(unsigned int _vertex, void* _dst);
 
 
public:
 
  //===========================================================================
  // fully expanded vbo
  //===========================================================================  
 
 
  void invalidateFullVBO();
 
  void updateFullVBO();
 
 
private:
  // fully expanded mesh vbo (not indexed)
  // this is only used for drawmodes with incompatible combinations of interpolation modes (ex. smooth gouraud lighting with flat face colors)
  GeometryBuffer vboFull_;
 
  // full vbo has been invalidated
  bool updateFullVBO_;
 
  // (colored) edges
  GeometryBuffer vboEdges_;
 
public:
  //========================================================================
  // per edge buffers
 
  void invalidatePerEdgeBuffers() {updatePerEdgeBuffers_ = 1;}
 
  void updatePerEdgeBuffers();
 
  void updatePerEdgeBuffersNew();
 
  ACG::Vec3f* perEdgeVertexBuffer();
 
  ACG::Vec4f* perEdgeColorBuffer();
 
  void invalidatePerHalfedgeBuffers() {updatePerHalfedgeBuffers_ = 1;}
 
  template<typename Mesh::Normal (DrawMeshT::*NormalLookup)(typename Mesh::FaceHandle)>
  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_;
 
  std::vector<float> perEdgeBuf_; // vertex vec3f + color vec4f
 
  int updatePerHalfedgeBuffers_;
  std::vector<ACG::Vec3f> perHalfedgeVertexBuf_;
  std::vector<ACG::Vec4f> perHalfedgeColorBuf_;
 
  template<typename Mesh::Normal (DrawMeshT::*NormalLookup)(typename Mesh::FaceHandle)>
  typename Mesh::Point halfedge_point(const typename Mesh::HalfedgeHandle _heh);
 
  inline
  typename Mesh::Normal cachedNormalLookup(typename Mesh::FaceHandle fh) {
      return mesh_.normal(fh);
  }
 
  inline
  typename Mesh::Normal computedTriMeshNormal(typename Mesh::FaceHandle fh) {
      typename Mesh::FVIter fv_iter = mesh_.fv_begin(fh);
      const typename Mesh::Point p1 = mesh_.point(*fv_iter);
      const typename Mesh::Point p2 = mesh_.point(*(++fv_iter));
      const typename Mesh::Point p3 = mesh_.point(*(++fv_iter));
      return ( p1 + p2 + p3 ) / 3.0;
  }
 
  inline
  typename Mesh::Normal computedNormal(typename Mesh::FaceHandle fh) {
      unsigned int count = 0;
      typename Mesh::Normal normal(0, 0, 0);
      for (typename Mesh::FVIter fv_it = mesh_.fv_begin(fh), fv_end = mesh_.fv_end(fh); fv_it != fv_end; ++fv_it) {
          normal += mesh_.point(*fv_it);
          ++count;
      }
      normal /= count;
      return normal;
  }
 
  typename Mesh::HalfedgeHandle mapToHalfedgeHandle(size_t _vertexId);
 
};
 
 
// defined in DrawMeshT_impl.cc:
extern template class DrawMeshT<::OpenMesh::TriMesh>;
extern template class DrawMeshT<::OpenMesh::PolyMesh>;
 
} // namespace ACG