IEModel.h

Go to the documentation of this file.

// BC  6/6/2005  \Master120\Include\IEModel.h

#define __IEMODEL_H

#ifndef __VECTOR2_H
#include "Vector2.h"
#endif
#ifndef __VECTOR_H
#include "Vector.h"
#endif
#ifndef __HASHARRA_H
#include "HashArra.h"
#endif
#ifndef __MAPLIMIT_H
#include "MapLimit.h"
#endif
#ifndef __EXPORTS_H
#include "Exports.h"
#endif
#ifndef __OLDATTR_H
#include "OldAttr.h"
#endif

#define SIGN(x) ((x) >= 0 ? 1 : -1)
#define IEVERSION 3

class HPatch;

class IEMap 
{
public:
   char    m_filename[256];
   WORD    m_width, m_height;

   IEMap &operator = ( const IEMap &other ) {
      strcpy(m_filename, other.m_filename);
      m_width = other.m_width;
      m_height = other.m_height;
      return *this;
   }
   
   int operator == ( const IEMap &other ) const 
   { 
      return !strcmp(m_filename, other.m_filename);
   }
};

class IEMapNode 
{
public:
   enum { COLORMAP,             TRANSPARENCYMAP,  BUMPMAP,      SPECULARSIZEMAP, DIFFUSEMAP,
          MIRRORMAP,            AMBIANCEMAP,      COOKIECUTMAP, DISPLACEMENTMAP, FRACTALMAP,
          SPECULARINTENSITYMAP, NEXTMAPFACTORMAP, OTHERMAP,     NORMALMAP/*,       TANGENTMAP*/ };

   LONG    m_mapid;
   float   m_percent;
   Vector2 m_repeat;
   Vector2 m_uv[4];

   union { 
      DWORD  m_flags;
      struct {
         DWORD m_kind         : 4,
               m_isseamless   : 1,
               m_isgroupdecal : 1;
      };
   };

   IEMapNode() {
      m_repeat.Set(1.0f,1.0f);
      m_percent = 1.0f;
      m_flags = 0L;
      m_kind = COLORMAP;
   }

   IEMapNode &operator = ( const IEMapNode &other ) {
      m_mapid = other.m_mapid;
      m_repeat = other.m_repeat;
      m_percent = other.m_percent;
      m_flags = other.m_flags;
      m_uv[0] = other.m_uv[0];
      m_uv[1] = other.m_uv[1];
      m_uv[2] = other.m_uv[2];
      m_uv[3] = other.m_uv[3];
      return *this;
   }
};

class IEPatchMapNode : public IEMapNode
{
public:
   Vector2 m_controluv[8]; // 8 corner control vertices
/*    *01*
      2**3
      4**5
      *67*
*/

   IEPatchMapNode &operator = ( const IEPatchMapNode &other ) {
      *((IEMapNode *)this) = other;
      m_controluv[0]  = other.m_controluv[0];
      m_controluv[1]  = other.m_controluv[1];
      m_controluv[2]  = other.m_controluv[2];
      m_controluv[3]  = other.m_controluv[3];
      m_controluv[4]  = other.m_controluv[4];
      m_controluv[5]  = other.m_controluv[5];
      m_controluv[6]  = other.m_controluv[6];
      m_controluv[7]  = other.m_controluv[7];
      return *this;
   }
};

class IEPoly 
{
public:
   HashArray<IEMapNode *, IEMapNode *>m_mapnodearray;
   LONG       m_attrid;
   LONG       m_vertexid[4];
   LONG       m_normalid[4];
   HPatch    *m_origpatch;
   
   IEPoly()
   {
      Init();
   }
   IEPoly(HPatch *patch) { 
      m_mapnodearray.SetGranularity(5);
      m_attrid = -1;
      m_origpatch = patch;
   }
   virtual ~IEPoly() {
      for (int i=0;i < m_mapnodearray.GetSize(); i++) {
         IEMapNode *mapnode = m_mapnodearray.ElementAt(i);
         delete mapnode;
      }
   }

   void Init()
   {
      m_mapnodearray.SetGranularity(5);
      m_attrid = -1;
      for (int i=0; i<4; i++) {
         m_vertexid[i] = 0;
         m_normalid[i] = 0;
      }
      m_origpatch = NULL;
   }
   IEPoly &operator = ( const IEPoly &other )
   {
      m_mapnodearray.SetSize( other.m_mapnodearray.GetSize());
      for (int i=0; i<m_mapnodearray.GetSize(); i++)
         m_mapnodearray[i] = other.m_mapnodearray[i];
      SetVerts(other.m_vertexid[0], other.m_vertexid[1], other.m_vertexid[2], other.m_vertexid[3]);
      m_normalid[0] = other.m_normalid[0];
      m_normalid[1] = other.m_normalid[1];
      m_normalid[2] = other.m_normalid[2];
      m_normalid[3] = other.m_normalid[3];
      m_origpatch = other.m_origpatch;
      return *this;
   }
   void SetVerts( int v0, int v1, int v2 )
   {
      m_vertexid[0] = v0;
      m_vertexid[1] = v1;
      m_vertexid[2] = v2;
      m_vertexid[3] = v2;
   }
   void SetVerts( int v0, int v1, int v2, int v3 )
   {
      m_vertexid[0] = v0;
      m_vertexid[1] = v1;
      m_vertexid[2] = v2;
      m_vertexid[3] = v3;
   }
   BOOL IsTri() { return m_vertexid[0] == m_vertexid[3]; }
   BOOL IsQuad() { return !IsTri(); }
};

class IEEdge 
{
public:
   LONG m_vertexid[2];

   LONG m_numfaces;         // the number of faces sharing the edge (1 or 2)                           numFaces
   LONG m_polyid[2];        // the faces sharing the edge                                              f[2]
   LONG m_polyvertexnum[2]; // the index in the faces sharing the edge (0, 1, or 2)                    fe[2]
   LONG m_thirdvertex[2];   // the third vertex of the faces sharing the edge ( assuming triangles )   tv[2]

   IEEdge()
   {
   }
   IEEdge(int id1, int id2) {
      m_vertexid[0] = id1;
      m_vertexid[1] = id2;
   }
   IEEdge &operator = ( const IEEdge &other )
   {
      m_vertexid[0] = other.m_vertexid[0];
      m_vertexid[1] = other.m_vertexid[1];
      m_numfaces = other.m_numfaces;
      m_polyid[0] = other.m_polyid[0];
      m_polyid[1] = other.m_polyid[1];
      m_polyvertexnum[0] = other.m_polyvertexnum[0];
      m_polyvertexnum[1] = other.m_polyvertexnum[1];
      m_thirdvertex[0] = other.m_thirdvertex[0];
      m_thirdvertex[1] = other.m_thirdvertex[1];
      return *this;
   }
};

// edge0 m_vertexid[0] - m_vertexid[1]
// edge1 m_vertexid[1] - m_vertexid[2] 
// edge2 m_vertexid[2] - m_vertexid[3]
// edge3 m_vertexid[3] - m_vertexid[0]

class IEPatch
{
public:
   HashArray<IEPatchMapNode *, IEPatchMapNode *>m_mapnodearray;
   LONG  m_attrid;
   LONG  m_vertexid[4];
   LONG  m_controlvertexid[12];
   HPatch *m_origpatch;
   union {
      DWORD      m_flags;
      struct {
         DWORD   m_edge0isdiscontinuous : 1, // used to average normals rather than compute, hides anomolies (Caused by 5 point patches)
                 m_edge1isdiscontinuous : 1, // used to average normals rather than compute, hides anomolies (Caused by 5 point patches)
                 m_edge2isdiscontinuous : 1, // used to average normals rather than compute, hides anomolies (Caused by 5 point patches)
                 m_edge3isdiscontinuous : 1, // used to average normals rather than compute, hides anomolies (Caused by 5 point patches)
                 m_is3point             : 1; // m_vertexid[0] == m_vertexis[3]
      };
   };
   
   IEPatch(HPatch *patch) { 
      m_mapnodearray.SetGranularity(5); 
      m_attrid = -1;
      m_origpatch = patch;
      m_flags = 0L;
   }
   
   virtual ~IEPatch() {
      for (int i=0;i < m_mapnodearray.GetSize(); i++) {
         IEMapNode *mapnode = m_mapnodearray.ElementAt(i);
         delete mapnode;
      }
   }
};

class IEBone 
{
public:
   IEBone *m_child, *m_sibling;
   char   m_name[256];
 
 // useful only for duplicating the bone arrangment for another package or your own IK
 // not needed for motion if using .MOT
   Vector m_pivotpos, m_endpos, m_rollpos;
   HashArray<LONG, LONG> m_vertexidarray;
   
   IEBone() {
      m_child = m_sibling = NULL;
   }
};

class HashNode 
{
public:
   HashNode *m_next;
   int       m_id;
   LONG      m_key;
};

class VectorCollection 
{
private:
   HashArray<HashNode *, HashNode *> m_hasharray;
public:
   HashArray<Vector, Vector &> m_array;

   VectorCollection() {
      m_array.SetGranularity(1000);
//      m_hasharray.SetSize(1999);  // rather than here, now done lazily in VectorCollection::Add(). This way models that don't use Add won't have the space wasted on vertexes & normals
   }   
   
   virtual ~VectorCollection();
   
   Vector *GetArray() { return m_array.GetArray(); }
   Vector  GetAt(int index) const { return m_array.GetAt(index); }
   int     GetSize() const { return m_array.GetSize(); }
   void    SetSize( int newsize, int growby = -1 ) { m_array.SetSize(newsize, growby); } 
   Vector &ElementAt(int index) { return m_array.ElementAt(index); }
   int Add(Vector &vector, LONG key=-1);
   int LookUp(const Vector &vector, LONG key=-1);
   int LookUpHashKey(Vector &vector);
   int GetHashKey(LONG key);
   int GetHashKey(const Vector &vector);
   void Empty();
   Vector  operator [] ( int index ) const { return m_array.GetAt(index); }
   Vector &operator [](int index) { return m_array.ElementAt(index); }

   void Shrink() {
      m_array.FreeExtra();
   }
};

inline void VectorCollection::Empty()
{
   int i, count = m_hasharray.GetSize();
   for (i=0; i < count; i++) {
      HashNode *nodehead = m_hasharray[i];
      if (nodehead) {
         HashNode *next;
         for (HashNode *node = nodehead; node; node=next) {
            next = node->m_next;
            delete node;
         }
         m_hasharray[i] = NULL;
      }
   }
   m_array.SetSize(0);
}

inline VectorCollection::~VectorCollection()
{
   Empty();
}

inline int VectorCollection::GetHashKey(LONG key)
{
   return ((int)/*(void*)*/(LONG)key) >> 4;
}

inline int VectorCollection::GetHashKey(const Vector &vector)
{
   double x = (int)(vector.x * 1000.0f + SIGN(vector.x) * .5f)/1000.0*12.3;
   double y = (int)(vector.y * 1000.0f + SIGN(vector.y) * .5f)/1000.0*23.4;
   double z = (int)(vector.z * 1000.0f + SIGN(vector.z) * .5f)/1000.0*34.5;
   return (int) (pow(x*x + y*y + z*z, 0.5 ) * 9.87);  
}

inline int VectorCollection::LookUp(const Vector &vector, LONG key)
{
   int hashkey;
   if (key == -1)
      hashkey = GetHashKey(vector);
   else
      hashkey = GetHashKey(key);

   int index = hashkey%m_hasharray.GetSize();   
   HashNode *nodehead = m_hasharray.GetAt(index);
   for (HashNode *node = nodehead; node; node=node->m_next) {
      if (key != -1 && node->m_key != -1) {
         if (node->m_key == key)
            return node->m_id;
         continue;
      }
      const Vector &match = m_array.GetAt(node->m_id);
      Vector diff = match-vector;
      if (fabs(diff.x) < 1.e-3 &&
       fabs(diff.y) < 1.e-3 &&
       fabs(diff.z) < 1.e-3)
         return node->m_id;
   }
   return -1;
}

inline int VectorCollection::LookUpHashKey(Vector &vector)
{
   int i, count = m_hasharray.GetSize();
   for (i = 0; i < count; i++) {
      HashNode *nodehead = m_hasharray.GetAt(i);
      if (nodehead) {
         for (HashNode *node = nodehead; node; node=node->m_next) {
            const Vector &match = m_array.GetAt(node->m_id);
            Vector diff = match-vector;
            if (fabs(diff.x) < 1.e-3 &&
               fabs(diff.y) < 1.e-3 &&
               fabs(diff.z) < 1.e-3)
               return node->m_key;
         }
      }
   }
   return -1;
}

inline int VectorCollection::Add(Vector &vector, LONG key)
{
   if (m_hasharray.GetSize()==0)
      m_hasharray.SetSize(1999);
   int hashkey;
   if (key == -1)
      hashkey = GetHashKey(vector);
   else
      hashkey = GetHashKey(key);

   int index = hashkey%m_hasharray.GetSize();   
   HashNode *nodehead = m_hasharray.GetAt(index);
   for (HashNode *node = nodehead; node; node=node->m_next) {
      if (key != -1 && node->m_key != -1) {
         if (node->m_key == key)
            return node->m_id;
         continue;
      }
      const Vector &match = m_array.GetAt(node->m_id);
      Vector diff = match-vector;
      if (fabs(diff.x) < 1.e-3 &&
       fabs(diff.y) < 1.e-3 &&
       fabs(diff.z) < 1.e-3)
         return node->m_id;
   }
// doesn't exist yet
   int newid = m_array.Add(vector);
   HashNode *newnode = new HashNode;
   newnode->m_id = newid;
   newnode->m_key = key;
   newnode->m_next = nodehead;
   m_hasharray.SetAt(index, newnode);
   return newid;
}

//*************************** Unique Data Collection *****************************

template <class TYPE, class ARG_TYPE>
class UDCollection 
{
private:
   HashArray <LONG, LONG> m_keyarray;
public:
   HashArray <TYPE, ARG_TYPE> m_array;
   
   LONG  Add(ARG_TYPE newelement, LONG key=-1);
   LONG  AddForce(ARG_TYPE newelement);
   LONG  LookUp(ARG_TYPE newelement, LONG key=-1);
   TYPE *GetArray() { return m_array.GetArray(); }
   TYPE  GetAt(int index) const { return m_array.GetAt(index); }
   TYPE &ElementAt(int index) { return m_array.ElementAt(index); }
   int   GetSize() const { return m_array.GetSize(); }
   void  SetSize( int newsize, int growby = -1 ) { m_array.SetSize(newsize, growby); m_keyarray.SetSize(newsize, growby); }
   TYPE  operator [] ( int index ) const { return m_array.GetAt(index); }
   TYPE &operator [](int index) { return m_array.ElementAt(index); }

   void SetGranularity(int granularity) { 
      m_keyarray.SetGranularity(granularity);
      m_array.SetGranularity(granularity);
   }

   void Shrink() {
      m_keyarray.FreeExtra();
      m_array.FreeExtra();
   }
};

template <class TYPE, class ARG_TYPE>
inline LONG UDCollection<TYPE, ARG_TYPE>::Add(ARG_TYPE newelement, LONG key)
{
   int count = m_array.GetSize();
   for (int i=0; i<count; i++) {
      if (key!=-1 && m_keyarray.GetAt(i)!=-1) {
         if (m_keyarray.GetAt(i) == key)
            return i;
      }
      else {
         if (m_array.GetAt(i) == newelement)
            return i;
      }
   }
   
   m_keyarray.Add(key);
   return m_array.Add(newelement);
}

template <class TYPE, class ARG_TYPE>
inline LONG UDCollection<TYPE, ARG_TYPE>::AddForce(ARG_TYPE newelement)
{
   m_keyarray.Add(-1);
   return m_array.Add(newelement);
}

template <class TYPE, class ARG_TYPE>
inline LONG UDCollection<TYPE, ARG_TYPE>::LookUp(ARG_TYPE newelement, LONG key)
{
   int count = m_array.GetSize();
   for (int i=0; i<count; i++) {
      if (key!=-1 && m_keyarray.GetAt(i)!=-1) {
         if (m_keyarray.GetAt(i) == key)
            return i;
      }
      else {
         if (m_array.GetAt(i) == newelement)
            return i;
      }
   }
   return -1;
}

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

class RenderInfo;

class IEModel 
{
public:
   VectorCollection m_vertexlist;
   UDCollection<IEMap, IEMap &> m_maplist;
   UDCollection<Attr, Attr &> m_attrlist;
   
   IEBone *m_bonehead;
   
   IEModel() {
      m_bonehead = NULL;
      m_maplist.SetGranularity(20);
      m_attrlist.SetGranularity(20);
   }
   
   virtual ~IEModel() {
      DeleteBoneBranch(m_bonehead);       
   }
   void DeleteBoneBranch(IEBone *bone);
   void Draw( RenderInfo *renderinfo );
   Vector *GetVertexArray() { return m_vertexlist.GetArray(); }
   Vector &GetVertex( int i ) { return m_vertexlist[i]; }
};

inline void IEModel::DeleteBoneBranch(IEBone *startbone) 
{
   IEBone *sibling, *bone;
   
   for (bone=startbone; bone; bone=sibling) {
      sibling = bone->m_sibling;
      if (bone->m_child)
         DeleteBoneBranch(bone->m_child);
      delete bone;
   }   
}

class IEColor
{
public:
   BYTE m_red, m_green, m_blue, m_alpha;
   
   IEColor()
   {
      m_red = m_green = m_blue = m_alpha = 0;
   }
   
   IEColor(BYTE red, BYTE green, BYTE blue, BYTE alpha) {
      m_red   = red;
      m_green = green;
      m_blue  = blue;
      m_alpha = alpha;
   }
};
   
class IEPolyModel : public IEModel
{
public:
   HashArray<IEPoly *, IEPoly *> m_polyarray;  // this crazy array should definitely be an array of poly's, not an array of pointers to poly's, overworked allocator... pointless
   VectorCollection m_normallist;
   
   IEPolyModel() {
      m_polyarray.SetGranularity(1000);
   }
   IEPolyModel(const IEPolyModel &other)
   {
      m_polyarray.SetGranularity(1000);
      *this = other;
   }
   IEPolyModel &operator = (const IEPolyModel &other)
   {
      SetNumVerts(other.GetNumVerts());
      int i;
      for (i=0; i<GetNumVerts(); i++)
         m_vertexlist[i] = other.m_vertexlist[i];

      SetNumFaces(other.GetNumFaces());
      for (i=0; i<GetNumFaces(); i++) {
         IEPoly &poly = *other.m_polyarray[i];
         m_polyarray[i]->SetVerts(poly.m_vertexid[0], poly.m_vertexid[1], poly.m_vertexid[2], poly.m_vertexid[3]);
      }
      return *this;
   }
   virtual ~IEPolyModel()
   {
      FreeData();
   }
   void FreeData()
   {
      for (int i=0;i < m_polyarray.GetSize(); i++)
         delete m_polyarray[i];
   }
   PLUGINEXPORT void BuildNormalList( float angletolerance ); // 0-180
   PLUGINEXPORT void BuildNormalList();                       // same as 180 above, but much faster, always one normal per vertex

   int GetNumVerts() const 
   {
      return m_vertexlist.GetSize();
   }
   void SetNumVerts( int i )
   {
      m_vertexlist.SetSize( i );
   }
   int GetNumFaces() const
   {
      return m_polyarray.GetSize();
   }
   void SetNumFaces( int numfaces )
   {
      m_polyarray.SetSize( numfaces );     // it seems crazy that m_polyarray is not an array of IEPolys, but rather an array of pointers to IEPolys ??
      for (int i=0; i<numfaces; i++)
         m_polyarray[i] = new IEPoly;
   }
   int GetNumNormals() const
   {
      return m_normallist.GetSize();
   }
   void SetNumNormals( int i )
   {
      m_normallist.SetSize( i );
   }

   // for Vlado's EdgeLister
   int getNumVerts() { return GetNumVerts(); }
   int getNumFaces() { return GetNumFaces(); }
   int getFaceVertex(int face, int v) { return m_polyarray[face]->m_vertexid[v]; }
};

/*
// for vlado's EdgeLister
struct EdgeData {
   int v[2]; // The two vertices
   int f[2]; // The two faces
   int i[2]; // Indices of the edge in the faces
   int tv[2]; // The opposite vertices
   int numFaces;
};
*/

class PLUGINEXPORT IETriModel : public IEPolyModel
{
public:
   HashArray<IEPoly, IEPoly &> m_polyclassarray;  // this is an array of actual IEPoly classes, we initialize all the pointers in the base class m_polyarray to point at these
   HashArray<IEEdge, IEEdge &> m_edges;
   int *m_edgeindex;  // an array of edge indexes, these would be more easily stored in 3 in each Triangle, but we are using IEPoly which cannot be invalidated

   IETriModel() 
   {
      Init();
   }
   IETriModel(const IETriModel &other)
   {
      Init();
      *this = other;
   }
   IETriModel & operator = (const IETriModel &other)
   { 
      int i;
      SetNumVerts(other.GetNumVerts());
      for (i=0; i<GetNumVerts(); i++)
         m_vertexlist[i] = other.m_vertexlist[i];
      SetNumFaces(other.GetNumFaces());
      for (i=0; i<GetNumFaces(); i++)
         m_polyarray[i] = other.m_polyarray[i];
      SetNumEdges(other.GetNumEdges());
      for (i=0; i<GetNumEdges(); i++)
         m_edges[i] = other.m_edges[i];
      return *this;
   }
   virtual ~IETriModel();
   void FreeData()
   {
      m_edges.RemoveAll();
      if (m_edgeindex)
         delete [] m_edgeindex;
      m_edgeindex = NULL;
   }
   void Init()
   {
      m_polyarray.SetGranularity(1000);
      m_edges.RemoveAll();
      m_edgeindex = NULL;
   }

   void SetNumEdges( int i )
   {
      m_edges.SetSize( i );
   }
   int GetNumEdges() const
   {
      return m_edges.GetSize();
   }
   void SetNumFaces( int numfaces )  // override the IEPoly version, not virtual
   {
      m_polyarray.SetSize( numfaces );  // this one is pointers
      m_polyclassarray.SetSize( numfaces );
      for (int i=0; i<numfaces; i++)
         m_polyarray[i] = &m_polyclassarray[i];
   }
   void BuildEdges(BOOL deleteold=TRUE);

   friend PLUGINEXPORT void Triangulate( const IEPolyModel &mesh, IETriModel &tmesh );
   friend PLUGINEXPORT void LoopSubdivideStep( const IETriModel &mesh, IETriModel &smesh );
   friend PLUGINEXPORT void LoopSubdivide( IETriModel &mesh, IETriModel &smesh, int numSteps );

   // for Vlado's EdgeLister
   void setNumEdges(int numEdges) { SetNumEdges(numEdges); }
/*
   void setEdge(int idx, EdgeData &edge) {
      IEEdge &ieedge = m_edges[idx];
      ieedge.m_vertexid[0]      = edge.v[0];
      ieedge.m_vertexid[1]      = edge.v[1];
      ieedge.m_numfaces         = edge.numFaces;
      ieedge.m_polyid[0]        = edge.f[0];
      ieedge.m_polyid[1]        = edge.f[1];
      ieedge.m_polyvertexnum[0] = edge.i[0];
      ieedge.m_polyvertexnum[1] = edge.i[1];
      ieedge.m_thirdvertex[0]   = edge.tv[0];
      ieedge.m_thirdvertex[1]   = edge.tv[1];
   }
*/
};

class IEPatchModel : public IEModel
{
public:
   HashArray<IEPatch *, IEPatch *> m_patcharray;
   VectorCollection m_controlvertexlist;

   IEPatchModel() {
      m_patcharray.SetGranularity(1000);
   }

   virtual ~IEPatchModel() {
      for (int i=0;i < m_patcharray.GetSize(); i++) {
         IEPatch *patch = m_patcharray.ElementAt(i);
         delete patch;
      }
   }
};

class IEModelParms
{
public:
   MapLimit m_minmodelmapsize, m_maxmodelmapsize, 
    m_unused1, m_unused2;
   union { 
      unsigned long  m_flags;
      struct {
         unsigned long m_isbuildmaparray        : 1,
                       m_isbuildattrarray       : 1,
                       m_isbuildbonelist        : 1,
                       m_isbuildmodelmap        : 1,
                       m_isdisplaypercentbar    : 1,
                       m_useconsistentids       : 1,
                       m_isnormalizeuvs         : 1;
       };
   };
   
   IEModelParms() {
      m_flags = 0L;
      m_minmodelmapsize  = ML_0;
      m_maxmodelmapsize  = ML_256;
      m_isdisplaypercentbar = TRUE;
   }
};

enum SubType { ST_1, ST_4, ST_16, ST_VARIABLE, SUBTYPE_COUNT };

class IEPolyModelParms : public IEModelParms
{
public:
   SubType  m_subtype;

   union { 
      unsigned long m_polyflags;
      struct {
         unsigned long m_isbuildnormalarray : 1;
       };
   };

   IEPolyModelParms() {
      m_polyflags = 0L;
      m_subtype = ST_1;
   }
   IEPolyModelParms( SubType subdivisiontype, BOOL buildnormals ) {
      m_isbuildnormalarray = buildnormals;
      m_subtype = subdivisiontype;
   }
};

class HGroup;
class HCP;

class VertexInfo 
{
public:
   HashArray<HPatch *, HPatch *>          m_patcharray;    // the patch each vertex came from
   HashArray<Vector2, Vector2>            m_uvarray;       // the uv on that patch for each vertex
   HashArray<HCP *, HCP *>                m_cparray;       // the cp associated with the vertex, only if at a patch corner

// computed and used only by cloth plugin - these should be moved to plugin local storage
   HashArray<HGroup *, HGroup *>          m_grouparray;    // the custom group whose properties will control the behavior of the vertex
   HashArray<char, char>                  m_attachedarray; // a bool indicating whether the vertex is attached

   void RemoveAll()
   {
      m_patcharray.RemoveAll();
      m_uvarray.RemoveAll();
      m_cparray.RemoveAll();

      m_grouparray.RemoveAll();
      m_attachedarray.RemoveAll();
   }
};

---