VolumeMeshBufferManager.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.              *
 *                                                                           *
\*===========================================================================*/
 
#pragma once
 
#include <ACG/GL/GLState.hh>
#include <ACG/Scenegraph/DrawModes.hh>
#include <ACG/Scenegraph/BaseNode.hh>
#include <ACG/GL/VertexDeclaration.hh>
 
#include "VolumeMeshDrawModesContainer.hh"
 
#include <OpenVolumeMesh/Attribs/StatusAttrib.hh>
#include <OpenVolumeMesh/Attribs/NormalAttrib.hh>
#include <OpenVolumeMesh/Attribs/ColorAttrib.hh>
#include <OpenVolumeMesh/Attribs/TexCoordAttrib.hh>
#include <ACG/Geometry/Types/PlaneType.hh>
 
template<class VolumeMesh>
class VolumeMeshBufferManager
{
    // typedefs for easy access
    typedef OpenVolumeMesh::VertexHandle VertexHandle;
    typedef OpenVolumeMesh::EdgeHandle EdgeHandle;
    typedef OpenVolumeMesh::HalfEdgeHandle HalfEdgeHandle;
    typedef OpenVolumeMesh::FaceHandle FaceHandle;
    typedef OpenVolumeMesh::HalfFaceHandle HalfFaceHandle;
    typedef OpenVolumeMesh::CellHandle CellHandle;
 
    typedef typename VolumeMesh::PointT Vertex;
    typedef OpenVolumeMesh::OpenVolumeMeshEdge Edge;
    typedef OpenVolumeMesh::OpenVolumeMeshFace Face;
    typedef OpenVolumeMesh::OpenVolumeMeshCell Cell;
 
    using Plane = ACG::Geometry::Plane;
 
public:
 
    enum PrimitiveMode
    {
        PM_NONE,
        PM_CELLS,
        PM_FACES,
        PM_FACES_ON_CELLS,
        PM_HALFFACES,
        PM_HALFFACES_ON_CELLS,
        PM_EDGES,
        PM_IRREGULAR_EDGES,
        PM_EDGES_ON_CELLS,
        PM_HALFEDGES,
        PM_VERTICES,
        PM_VERTICES_ON_CELLS
    };
 
    enum NormalMode
    {
        NM_NONE,
        NM_FACE,
        NM_HALFFACE,
        NM_VERTEX
    };
 
    enum ColorMode
    {
        CM_NO_COLORS,
        CM_CELL,
        CM_FACE,
        CM_HALFFACE,
        CM_EDGE,
        CM_HALFEDGE,
        CM_VERTEX,
        CM_PICK
    };
 
    enum TexCoordMode
    {
        TCM_NONE,
        TCM_SINGLE_2D
    };
 
    VolumeMeshBufferManager(const VolumeMesh &mesh_, OpenVolumeMesh::StatusAttrib& statusAttrib_,
                                                     OpenVolumeMesh::ColorAttrib<ACG::Vec4f>& colorAttrib_,
                                                     OpenVolumeMesh::NormalAttrib<VolumeMesh>& normalAttrib_,
                                                     OpenVolumeMesh::TexCoordAttrib<ACG::Vec2f>& texcoordAttrib_);
    virtual ~VolumeMeshBufferManager(){ free(); }
 
 
    void setScale(double _scale) { mScale = _scale; invalidate();}
 
    double getScale() const     { return mScale;  }
 
 
    unsigned char getStride()       { return mVertexSize; }
 
    unsigned char getColorOffset()  { return mColorOffset;  }
 
    unsigned char getNormalOffset() { return mNormalOffset; }
 
    unsigned char getTexCoordOffset() { return mTexCoordOffset; }
 
 
    const ACG::VertexDeclaration* getVertexDeclaration() { return &mVertexDeclaration; }
 
 
    GLuint getBuffer();
 
    GLuint getPickBuffer(ACG::GLState &_state, unsigned int _offset);
 
 
    void invalidate();
 
    void invalidateGeometry();
 
    void invalidateColors();
 
    void invalidateNormals();
 
    void invalidateTexCoords();
 
 
    void free();
 
 
    unsigned int getNumOfVertices();
 
 
    void setDefaultColor(ACG::Vec4f _defaultColor);
 
 
    void setOptionsFromDrawMode(ACG::SceneGraph::DrawModes::DrawMode _drawMode);
 
 
    void disableColors()            { mColorMode  = CM_NO_COLORS;     }
 
    void enablePerCellColors()      { mColorMode  = CM_CELL;     }
 
    void enablePerFaceColors()      { mColorMode  = CM_FACE;     }
 
    void enablePerHalffaceColors()  { mColorMode  = CM_HALFFACE; }
 
    void enablePerEdgeColors()      { mColorMode  = CM_EDGE;     }
 
    void enablePerHalfedgeColors()  { mColorMode  = CM_HALFEDGE; }
 
    void enablePerVertexColors()    { mColorMode  = CM_VERTEX;   }
 
    void enablePickColors()         { mColorMode  = CM_PICK;     }
 
 
    void disableNormals()           { mNormalMode = NM_NONE;     }
 
    void enablePerFaceNormals()     { mNormalMode = NM_FACE;     }
 
    void enablePerHalffaceNormals() { mNormalMode = NM_HALFFACE; }
 
    void enablePerVertexNormals()   { mNormalMode = NM_VERTEX;   }
 
 
    void disablePrimitives()              { mPrimitiveMode = PM_NONE;               }
 
    void enableCellPrimitives()           { mPrimitiveMode = PM_CELLS;              }
 
    void enableFacePrimitives()           { mPrimitiveMode = PM_FACES;              }
 
    void enableFaceOnCellPrimitives()     { mPrimitiveMode = PM_FACES_ON_CELLS;     }
 
    void enableHalffacePrimitives()       { mPrimitiveMode = PM_HALFFACES;          }
 
    void enableHalffaceOnCellPrimitives() { mPrimitiveMode = PM_HALFFACES_ON_CELLS; }
 
    void enableEdgePrimitives()           { mPrimitiveMode = PM_EDGES;              }
 
    void enableIrregularEdgePrimitives()  { mPrimitiveMode = PM_IRREGULAR_EDGES;    }
 
    void enableEdgeOnCellPrimitives()     { mPrimitiveMode = PM_EDGES_ON_CELLS;     }
 
    void enableHalfedgePrimitives()       { mPrimitiveMode = PM_HALFEDGES;          }
 
    void enableVertexPrimitives()         { mPrimitiveMode = PM_VERTICES;           }
 
    void enableVertexOnCellPrimitives()   { mPrimitiveMode = PM_VERTICES_ON_CELLS;  }
 
 
    void disableTextures()                { mTexCoordMode = TCM_NONE;       }
 
    void enableTextureSingle()            { mTexCoordMode = TCM_SINGLE_2D;  }
 
 
    bool selectionOnly()                       { return mSkipUnselected;            }
 
    void setSelectionOnly(bool _selectionOnly) { mSkipUnselected = _selectionOnly;  }
 
 
    void clearCutPlanes();
 
    void addCutPlane(const ACG::Geometry::Plane& _p);
 
    void addCutPlane(const ACG::Vec3d& _p, const ACG::Vec3d& _n, const ACG::Vec3d& _xsize, const ACG::Vec3d& _ysize);
 
 
    void setBoundaryOnly(bool _boundaryOnly) { mBoundaryOnly = _boundaryOnly; }
 
private:
    bool is_inside(const ACG::Vec3d& _p);
 
    bool is_inside(const VertexHandle& _vh);
 
    bool is_inside(const HalfEdgeHandle& _heh);
 
    bool is_inside(const EdgeHandle& _eh);
 
    bool is_inside(const HalfFaceHandle& _hfh);
 
    bool is_inside(const FaceHandle& _fh);
 
    bool is_inside(const CellHandle& _ch);
 
    void calculateCellInsideness();
 
    bool should_render(const VertexHandle& _vh);
    bool should_render(const HalfEdgeHandle& _heh);
    bool should_render(const EdgeHandle& _eh);
    bool should_render(const HalfFaceHandle& _hfh);
    bool should_render(const FaceHandle& _fh);
    bool should_render(const CellHandle& _ch);
 
 
    bool optionsChanged();
 
    void saveOptions();
 
 
    void addFloatToBuffer( float _value, unsigned char *&_buffer );
 
    void addUCharToBuffer( unsigned char _value, unsigned char *&_buffer );
 
    void addPositionToBuffer(ACG::Vec3d _position, unsigned char* _buffer , unsigned int _offset);
 
    void addColorToBuffer(ACG::Vec4uc _color, unsigned char* _buffer, unsigned int _offset);
 
    void addColorToBuffer(ACG::Vec4f _color, unsigned char* _buffer, unsigned int _offset);
 
    void addNormalToBuffer(ACG::Vec3d _normal, unsigned char *_buffer, unsigned int _offset);
 
    void addTexCoordToBuffer(ACG::Vec2f _texCoord, unsigned char* _buffer, unsigned int _offset);
 
 
    void calculateVertexDeclaration();
 
 
    void buildVertexBuffer(unsigned char* _buffer);
 
    void buildNormalBuffer(unsigned char* _buffer);
 
    void buildColorBuffer(unsigned char* _buffer);
 
    void buildTexCoordBuffer(unsigned char* _buffer);
 
    void buildPickColorBuffer(ACG::GLState &_state, unsigned int _offset, unsigned char* _buffer);
 
 
    ACG::Vec4f getValenceColorCode(unsigned int _valence, bool _inner) const;
 
 
    void countNumOfVertices();
 
 
    int getNumOfIncidentCells(OpenVolumeMesh::FaceHandle _fh);
 
    int getNumOfIncidentCells(OpenVolumeMesh::EdgeHandle _eh);
 
    int getNumOfIncidentCells(OpenVolumeMesh::VertexHandle _vh);
 
    ACG::Vec3d getCOG(OpenVolumeMesh::CellHandle _ch);
 
    void calculateCOGs();
 
    bool positionsNeedRebuild();
 
    bool colorsNeedRebuild();
 
    bool texCoordsNeedRebuild();
 
    bool normalsNeedRebuild();
 
private:
    ACG::Vec4f mDefaultColor;
 
    const VolumeMesh& mMesh;
    OpenVolumeMesh::StatusAttrib& mStatusAttrib;
    OpenVolumeMesh::ColorAttrib<ACG::Vec4f>& mColorAttrib;
    OpenVolumeMesh::NormalAttrib<VolumeMesh>& mNormalAttrib;
    OpenVolumeMesh::TexCoordAttrib<ACG::Vec2f>& mTexcoordAttrib;
 
    int mNumOfVertices;
    int mCurrentNumOfVertices;
 
    unsigned int mVertexSize;
    ACG::VertexDeclaration mVertexDeclaration;
 
    int mColorOffset;
    int mNormalOffset;
 
    double mScale;
 
    GLuint mBuffer;
 
    // local picking offset ?
    unsigned int mCurrentPickOffset;
 
    // global picking offset
    unsigned int mGlobalPickOffset;
 
    bool mInvalidated;
    bool mGeometryChanged;
    bool mNormalsChanged;
    bool mColorsChanged;
    bool mTexCoordsChanged;
 
    //draw modes
    VolumeMeshDrawModesContainer mDrawModes;
 
    //options
    PrimitiveMode mPrimitiveMode;
    NormalMode mNormalMode;
    ColorMode mColorMode;
 
    bool mSkipUnselected;
    bool mShowIrregularInnerEdges;
    bool mShowIrregularOuterValence2Edges;
    bool mSkipRegularEdges;
    bool mBoundaryOnly;
 
    PrimitiveMode mCurrentPrimitiveMode;
    NormalMode mCurrentNormalMode;
    ColorMode mCurrentColorMode;
 
    bool mCurrentSkipUnselected;
    bool mCurrentShowIrregularInnerEdges;
    bool mCurrentShowIrregularOuterValence2Edges;
    bool mCurrentSkipRegularEdges;
    bool mCurrentBoundaryOnly;
 
    unsigned char mCurrentVertexSize;
    unsigned char mCurrentNormalOffset;
    unsigned char mCurrentColorOffset;
 
    std::vector<ACG::Geometry::Plane> cut_planes_;
 
    std::vector<ACG::Vec3d> mCogs;
    bool mCogsValid;
    std::vector<bool> mCellInsideness;
    bool mCellInsidenessValid;
 
    TexCoordMode mTexCoordMode;
    TexCoordMode mCurrentTexCoordMode;
    unsigned char mTexCoordOffset;
    unsigned char mCurrentTexCoordOffset;
 
};
 
//=============================================================================
#if defined(INCLUDE_TEMPLATES) && !defined(VOLUMEMESHBUFFERMANAGERT_CC)
#include "VolumeMeshBufferManagerT_impl.hh"
#endif
//=============================================================================