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

#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