PolygonalMesh.h

Go to the documentation of this file.

#ifndef __POLYGONAL_MESH_H
#define __POLYGONAL_MESH_H

#include <esg/mesh/Mesh.h>

/*
 * Precise polygonal mesh. Precise in the sense of minimal number of vertices
 * and edges (they are shared by facets).
 * 
 * Restrictions:
 *   1) Edge loops of all facets must be oriented by the same way
 *      (e.g. all counter-clockwise, this is preffered)
 *   2) Perfect topology but very slow! - see FastSurfaceMesh
 *
 */

namespace esg {

    //class OGSCENE_EXPORT PolygonalMesh;

class OGSCENE_EXPORT PolygonalMesh : public Mesh {
protected:
     Sgi::hash_map<int,      Vert*> _vertices;
     Sgi::hash_map<long int, Edge*> _edges;

    static const unsigned MAX_LOOP; // to protect infinite cycles in code
    
protected:
    inline Mesh::Vert*  _find_vertex        (int);
           void         _store_vertex       (Mesh::Vert*);
           Vector3      _plane_normal       (const unsigned[], 
                                             unsigned, unsigned, unsigned);
           long int     _multiplex          (unsigned, unsigned);
    inline Mesh::Edge*  _find_edge          (unsigned, unsigned);
    inline void         _store_edge         (Edge*);
    inline void         _erase_edge         (unsigned, unsigned);
           Mesh::Edge*  _append_new_edge    (Mesh::Vert*,
                                             Mesh::Vert*,
                                             Mesh::Plane*);
           Mesh::Edge*  _append_fake_edge   (Mesh::Edge*, Mesh::Vert*);
           bool         _connect_edge       (Mesh::Edge*, Mesh::Plane*);
           Mesh::Edge*  _split_edge         (Edge*, Vert*);
           Mesh::Plane* _split_plane        (Plane*, Vert*, Vert*);
           bool         _get_facet_topology (Mesh::Vert **,
                                             Mesh::Edge **,
                                             unsigned,
                                             const unsigned*,
                                             const Vector3*);
    
public:
    PolygonalMesh (const Vector3 [],        /* array of vertices */
                   unsigned,                /* number of vertices or indices */
                   const unsigned vIndices[] = NULL /* indices to this array */);

    bool addFacet (const unsigned [], /* vertices */
                   const Vector3 [],  /* vertex normals (can be NULL) */
                   unsigned,          /* number of vertices */
                   const Vector3&     /* facet normal */);

    bool addFacet (const unsigned [], /* vertices */
                   const Vector3 [],  /* vertex normals (can be NULL) */
                   unsigned           /* number of vertices */);
};



}; // namespace

#endif // __POLYGONAL_MESH_H

---