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.              *
*                                                                            *
\*===========================================================================*/

/*===========================================================================*\
*                                                                            *
*   $Revision$                                                       *
*   $LastChangedBy$                                                 *
*   $Date$                    *
*                                                                            *
\*===========================================================================*/

#ifndef VOLUME_MESH_BUFFER_MANAGER_HH
#define VOLUME_MESH_BUFFER_MANAGER_HH

#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>

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;

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

    class Plane {
    public:
        Plane(const ACG::Vec3d& _p, const ACG::Vec3d& _n, const ACG::Vec3d& _x, const ACG::Vec3d& _y) :
            position(_p), normal(_n), xdirection(_x), ydirection(_y) {
        }

        // position
        ACG::Vec3d position;
        // normal
        ACG::Vec3d normal;
        // xdirection scaled by 1.0/width -> [0,1] is inrange
        ACG::Vec3d xdirection;
        // ydirection scaled by 1.0/height -> [0,1] is inrange
        ACG::Vec3d ydirection;
    };

    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 typename VolumeMeshBufferManager<VolumeMesh>::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 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<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.cc"
#endif
//=============================================================================

#endif // VOLUME_MESH_BUFFER_MANAGER_HH