DrawMesh.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 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/Utils/color_cast.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* 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_;




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

  void invalidatePerEdgeBuffers() {updatePerEdgeBuffers_ = 1;}

  void updatePerEdgeBuffers();

  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_;

  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);

};


//=============================================================================
} // namespace ACG
//=============================================================================
#if defined(INCLUDE_TEMPLATES) && !defined(ACG_DRAW_MESH_TCC)
#define ACG_DRAW_MESH_TEMPLATES
#include "DrawMeshT_impl.hh"
#endif
//=============================================================================
#endif // ACG_DRAW_MESH_HH defined
//=============================================================================