Mesh.h

Go to the documentation of this file.

#ifndef __MESH_H
#define __MESH_H

#include <stdlib.h>
#include <esg/Definitions.h>

/*
 * Polygonal mesh.
 *
 * ATTENTION:
 *    Since a mesh may be very complex the clone() operation is therefore
 *    not defined. When clonning, re-create mesh from original geometry instead
 *
 *    edge loops:
 *    ----------
 *
 *               right in  \            /  right out
 *                          \          /
 *                           <---------
 *                          /          \
 *               left out  /            \ left in
 */


namespace esg {

class OGSCENE_EXPORT Mesh {
public:
    // Declarations:
    struct Vert;
    struct Edge;
    struct Plane;
    struct Solid;
    
    // Definitions:
    struct MiniMax { float xmin, xmax, ymin, ymax, zmin, zmax; };
    
    struct Vert {
        int             jmeno_vrcholu;    // Name of vertex
        float           fxyz;             // Result of ax+by+cz+d=0
        int             qi;               // ?
        int             valid;            // Is this vertex valid ?
        struct Vert    *next_vertex;      // Pointer to next vertex in list
        struct Vert    *previous_vertex;  // Pointer to previous vertex in list
        float           x,y,z;            // Coordinates
        Vector3         normal;           // Normal vector

        bool hasValidNormal (void) const
        {
            if (normal.x!=0 || normal.y!=0 || normal.z!=0) return true;
            else return false;
        }
    };
    
    enum EdgeType{
      ZAKRYTA    = 1,      // Hidden
      OBRYSOVA   = 2,      // Contour
      VNITRNI    = 4,      // Inner
      ODPADOVA   = 8,      // Outher
      NULOVA     = 0x10,   // Null
      TELESOVA   = 0x20    // Solid's
    };
    
    struct Edge {
        int              jmeno_hrany;   // Name of edge
        enum   EdgeType  druh_hrany;    // Type of edge
        struct Edge     *next_edge;     // Pointer to next edge in list
        struct Edge     *previous_edge; // Pointer to previus edge in list
        struct Vert     *V1;            // Pointer to edge's first vertex
        struct Vert     *V2;            // Pointer to edge's second vertex
        struct Plane    *LeftLoop;      // Pointer to left plane
        struct Plane    *RightLoop;     // Pointer to right plane
        struct Edge     *LeftIn;        // Pointers to neibors edges
        struct Edge     *RightOut;
        struct Edge     *LeftOut;
        struct Edge     *RightIn;
    };
    
    struct Plane {
        int            jmeno_roviny;    // Name of plane
        struct Plane  *next_plane;      // Pointer to next plane in list
        struct Plane  *previous_plane;  // Pointer to previous plane in list
        struct Edge   *any_edge;        // Pointer to some edge of this plane
        float          a,b,c,d;         // a,b,c = normal vector directed out
        float          skalar;          // Scalar = a*x + b*y + c*z +d
    };
    
    struct Solid {
        int              solid_name;      // Name of solid
        struct Vert     *first_vertex;    // Pointer to first vertex in list
        struct Edge     *first_edge;      // Pointer to first edge in list
        struct Plane    *first_plane;     // Pointer to first plane in list
        struct Solid    *next_solid;      // Pointer to next solid
        struct Solid    *previous_solid;  // Pointer to previous solid
        struct MiniMax   cover;           // Cover
        Solid (int n = 0)
            : solid_name(n),
              first_vertex(NULL),
              first_edge(NULL),
              first_plane(NULL),
              next_solid(NULL),
              previous_solid(NULL) {}
    };
    
    

  protected:
    int           pocet_vrcholu;  // Number of all verteces
    int           pocet_hran;     // Number of edges
    int           pocet_rovin;    // Number of planes
    struct Solid* pSolid;         // Pointer to solid
    bool          outwardNormals; // All plane normals are outward oriented
                                  // (in contrast to random orientation)

    Vert*  pActVert;
    Edge*  pActEdge;
    Plane* pActPlane;
    Solid* pActSolid;
    
  protected:
    // Methods for manipulation with objects in solid's lists:
    void AppendVertex (Solid *S, Vert  *V);
    void AppendEdge   (Solid *S, Edge  *E);
    void AppendFace   (Solid *S, Plane *NP);
    void DeleteVertex (Solid *S, Vert  *V);
    void DeleteEdge   (Solid *S, Edge  *E);
    void DeleteFace   (Solid *S, Plane *NP);
    void MoveVertex   (Solid *S, Solid *SM, Vert  *V);
    void MoveEdge     (Solid *S, Solid *SM, Edge  *E);
    void MoveFace     (Solid *S, Solid *SM, Plane *NP);

    // Allocation of new primitive and adding to list:
    Vert   *NewVertex (Solid *S, float xp, float yp, float zp);
    Edge   *NewEdge   (Solid *S, Vert *V1p, Vert *V2p, Plane *P1p, Plane *P2p);
    Plane  *NewPlane  (Solid *S, float a1, float b1, float c1, float d1);

    // Manipulation with solids:
    void Copy_solid   (Solid *Sorigin, Solid *Scopy);
    void Delete_solid (Solid **S);
    
    // Help methods:
    int Paralel_planes (float  a,
                        float  b,
                        float  c,
                        float  ar,
                        float  br,
                        float  cr,
                        int&   same_orientation);
    
    void Vertex_Plane_position (struct Solid& S,
                                float         ar,
                                float         br,
                                float         cr,
                                float         dr,
                                int&          Pozitiv,
                                int&          Negativ);
    
    void  Orient_Edge           (Edge  *E,  Plane *F, Vert **Vin, Vert **Vout);
    Edge* Next_Edge_in_loop     (Edge  *CE, Vert **Vin, Vert **Vout);
    Edge* Previous_Edge_in_loop (Edge  *CE, Vert **Vin, Vert **Vout);
    void  ClasifyEdges          (Solid *S);
    
    // Allocation of primitives.
    // M = make, V = vertex, F = face, S = solid :
    Vert*   MV   (float xp, float yp, float zp);
    Plane*  MF   (float a1, float b1, float c1, float d1);
    Solid*  MVSF (Plane* F, Vert* V);
    void    MEV  (Solid *S, Vert* V1p, Vert* V2p, Edge** E, Plane* F);
    
    // E1 and E have shared vertex; replace E by E2:
    void ReplaceEdge (Edge* E1, Edge* E, Edge* E2);
    
    // Split edge E1 to two edges by vertex V:
    void SEMV   (Solid *S, Edge* E1, Vert* V, Edge** E2);
    void MEF    (Solid *S,Vert* V1p,Vert* V2p,Plane* F1,Plane* F2,Edge** E);
    void MEnotF (Solid *S,Vert* V1p,Vert* V2p,Plane* F1,Plane* F2,Edge** E);
    
    Vert*  Vertex_of_cut  (Vert* V1, Vert* V2);
    Plane* This_loop      (Edge* E, Vert* V);
    void   ConnectEdge    (Edge* E1, Edge* E, Edge* E2, Plane* P);
    void   KE             (Edge* E, Vert* Vin, Plane* P1,Plane* P2);
    void   SeparateSolids (Solid** NS, Solid** Odpad);
  

  
public:
    Mesh (bool n = true) {
        pocet_vrcholu = 0; pocet_hran = 0; pocet_rovin = 0;
        pSolid = NULL; outwardNormals = n;
    }
    virtual ~Mesh() { if (pSolid) Delete_solid(&pSolid); }

    virtual void rotate    (const Matrix3&);
    virtual void translate (const Vector3&);
    virtual void transform (const Matrix4&);
    virtual void scale     (float, float, float);
    
    virtual void     resetActSolid();
    virtual int      goToNextSolid();
    virtual void     resetActPlane();
    virtual Plane*   getActPlane();
    virtual int      goToNextPlane();
    virtual void     resetActEdge();
    virtual int      goToNextEdge();

    // the bool parameter desides if the edge is properly re-oriented
    // before vertex inspection. When set to true then actual plane
    // must be set.
    virtual Vertex3  getActVert1(bool); // first vertex of actual edge
    virtual Vertex3  getActVert2(bool); // second vertex of actual edge
    virtual Vertex3  getActVert();      // actual vertex
    virtual Vertex3  getActVertNormal1(bool);
    virtual Vertex3  getActVertNormal2(bool);
    virtual Vertex3  getActVertNormal();

    virtual int getActVertID1(bool);
    virtual int getActVertID2(bool);
    virtual int getActVertID();

    virtual int     getActPlaneID();
    virtual Vertex3 getActPlaneNormal() const;
    virtual Vector3 getActPlaneCentroid();
    virtual double  getActPlaneArea();
    
    virtual void resetEdgeWalkInSolid();
    virtual int  stepInEdgeWalkInSolid();

    virtual void resetVertWalkInSolid();
    virtual bool stepInVertWalkInSolid();

    virtual int numberOfVertices (void) const { return pocet_vrcholu; }
    virtual int numberOfEdges    (void) const { return pocet_hran; }

    virtual bool hasOutwardNormals (void) const { return outwardNormals; }

    virtual void turnInsideOut (void); // invert normals
}; // class Mesh

}; // namespace

#endif // __MESH_H

---