source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjModel.h @ 1526

#ifndef NAUTILUS_ADJMODEL_INCLUDED // -*- C++ -*-
#define NAUTILUS_ADJMODEL_INCLUDED

/************************************************************************

  Adjacency model representation.
  $Id: AdjModel.h,v 1.7 1997/07/18 15:27:38 garland Exp $

  Adapted from:
     mlab: (Id: polymodel.h,v 1.13 1997/02/06 16:30:11 garland Exp)
  via
     simplif: (Id: polymodel.h,v 1.1 1997/02/11 15:21:29 garland Exp)

 ************************************************************************/

#include "AdjPrims.h"
#include <gfx/SMF/smf.h>
#include <vector>

namespace simplif
{
        class Model : public SMF_Model
        {
                protected:
                        
                        vert_buffer vertices;
                        edge_buffer edges;
                        face_buffer faces;
                        vec3_buffer normals; // SUS
                        vec2_buffer texcoords;

                private:

                        void maybeFixFace(Face *);

                public:
                        
                        Model()
                        {
                                validVertCount = 0;
                                validEdgeCount = 0;
                                validFaceCount = 0;
                        }

                        ~Model()
                        {
                                for (int i=0; i<vertices.length(); i++)
                                {
                                        delete vertices[i];
                                }

                                for (int i=0; i<edges.length(); i++)
                                {
                                        delete edges[i];
                                }

                                for (int i=0; i<faces.length(); i++)
                                {
                                        delete faces[i];
                                }
                        }

                        Bounds bounds;

                        int validVertCount;
                        int validEdgeCount;
                        int validFaceCount;

                        //
                        // Basic model accessor functions
                        //
                        simplif::Vertex *vertex(int i) { return vertices(i); }
                        simplif::Vec3 & normal(int i){ return normals(i); }
                        simplif::Vec2 & texcoord(int i){ return texcoords(i); }
                        simplif::Edge *edge(int i) { return edges(i); }
                        simplif::Face *face(int i) { return faces(i); }

                        int vertCount() { return vertices.length(); }
                        int normCount() { return normals.length();  }
                        int texcoordCount() { return texcoords.length();  }
                        int edgeCount() { return edges.length();    }
                        int faceCount() { return faces.length();    }

                        vert_buffer& allVertices() { return vertices; }
                        edge_buffer& allEdges()    { return edges;    }
                        face_buffer& allFaces()    { return faces;    }

                        //
                        // Simplification primitives
                        //
                        Vertex   *newVertex(real x=0.0, real y=0.0, real z=0.0);
                        Edge     *newEdge(Vertex *,Vertex *);
                        Face *newFace(Vertex *, Vertex *, Vertex *);

                        void killVertex(Vertex *);
                        void killEdge(Edge *);
                        void killFace(Face *);

                        void reshapeVertex(Vertex *, real, real, real);
                        void remapVertex(Vertex *from, Vertex *to);

                        void contract(Vertex *v1, Vertex *v2, const Vec3& to,
                                        face_buffer& changed);

                        void contract(Vertex *v1, 
                                        const vert_buffer& others,
                                        const Vec3& to,
                                        face_buffer& changed);

                        //
                        // Simplification convenience procedures
                        //
                        void removeDegeneracy(face_buffer& changed);
                        void contractionRegion(Vertex *v1, Vertex *v2, face_buffer& changed);
                        void contractionRegion(Vertex *v1,
                                        const vert_buffer& vertices,
                                        face_buffer& changed);

                        //
                        // SMF reader functions
                        //
                        int in_Vertex(const Vec3&);
                        int in_Normal(const Vec3&);
                        int in_TexCoord(const Vec2&);

                        int in_Face(int v1, int v2, int v3, 
                                                                        int n1, int n2, int n3,
                                                                        int t1, int t2, int t3);

                        int miin_Face(int v1, int v2, int v3);

                        /*      #ifdef SUPPORT_VCOLOR
                                        int in_VColor(const Vec3&);
#endif
#ifdef SUPPORT_FCOLOR
int in_FColor(const Vec3&);
#endif
*/
                        //
                        // Some random functions that are mostly temporary
                        //

                        Vec3 synthesizeNormal(Vertex *);
        };
}

// NAUTILUS_ADJMODEL_INCLUDED
#endif