mnmesh.h

Go to the documentation of this file.

//*****************************************************************************
// Copyright 2009 Autodesk, Inc.  All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license agreement
// provided at the time of installation or download, or which otherwise accompanies 
// this software in either electronic or hard copy form.   
//
//*****************************************************************************

#pragma once

#include "maxheap.h"
#include "export.h"
#include "baseinterface.h"
#include "mncommon.h"
#include "hitdata.h"
#include "point3.h"
#include "bitarray.h"
#include "matrix3.h"
#include "box3.h"
#include "TabTypes.h"
#include "GraphicsConstants.h"
#include "channels.h"
#include "mesh.h"

// forward declarations
class Point3;
class RVertex;
class GraphicsWindow;
class Material;
class TVFace;
class StripData;
class PerData;
class Mesh;
class MeshOpProgress;
class UVWMapper;
class HitRegion;
class SubObjHitList;
class IHardwareShader;
class TriStrip;
class MNMesh;

#define REALLOC_SIZE 10

#define MNMESH_FACEDATA_IMPL

#pragma region MNMesh Component Flags 




#define MN_SEL (1<<0)               //!< Indicates that a component is selected.
#define MN_DEAD (1<<1)              //!< Indicates that a component is not used and should be ignored. Vertices with the MN_DEAD flag are deleted in the next call MNMesh::CollapseDeadVerts().
#define MN_TARG (1<<2)              //!< Indicates that a component is targeted. (See the MNMesh methods starting with the words TargetBy.
#define MN_BACKFACING (1<<3)        //!< Indicates that the vertex faces "backwards" in the current viewport. This changes often.
#define MN_HIDDEN (1<<4)               
#define MN_CACHEINVALID (1<<5)
#define MN_INFOREGROUND (1<<7)      //!< Tags a face as not renderable but can be hit-test. 1<<6 is skipped because the tri strip uses that as face flag signifying a face to be stripped
#define MN_WHATEVER (1<<16)         //!< \internal SDK users should use MN_USER and higher flags.
#define MN_LOCAL_SEL (1<<17)        //!< Alternate selections (not passed up the pipe).
#define MN_HITTEST_CULLED (1<<18)   //!< Used to indicate culled components (neither selected nor not selected) in window-region hit testing.
#define MN_USER (1<<24)             //!< Any value above this can be used by applications.



#define MN_VERT_DONE (1<<8)         //!< Set in algorithms that may accidentally revisit the same vertex (MNVertext twice, to keep them from processing it the second time.
#define MN_VERT_WELDED (1<<9)       //!< Used by MNMesh::WeldBorderVerts()
#define MN_VERT_SUBDIVISION_CORNER (1<<10) //!< Track which vertices are direct "descendants" of the original cage vertices in subdivision.



#define MN_EDGE_INVIS (1<<8)        //!< Both faces using this edge consider it invisible.
#define MN_EDGE_NOCROSS (1<<9)      //!< This edge should not be crossed in algorithms like MNMesh::SabinDoo that can mix faces across edges.
#define MN_EDGE_MAP_SEAM (1<<10)    //!< Track which edges are direct descendants of the original cage edges in subdivision.
#define MN_EDGE_SUBDIVISION_BOUNDARY (1<<11)  //!< Track unwanted edges created by Cut, so they might be removed later.
#define MN_EDGE_CUT_EXTRA (1<<12)   //!< Used with MNMesh::CutPrepare() and MNMEsh::CutCleanUp()


#pragma endregion

const int kMNNurmsHourglassLimit = 2500; // between 4 and 5 iterations on a box.

//#define MNM_SELCONV_IGNORE_BACK 0x01  // Doesn't work - can't get good BACKFACING info.
#define MNM_SELCONV_REQUIRE_ALL 0x02



#define IMNMESHUTILITIES8_INTERFACE_ID Interface_ID(0xf5235e73, 0x3b304334)

#define IMNTEMPDATA10_INTERFACE_ID      Interface_ID(0x56d8fa2, 0x3459c774)





#define MN_FACE_OPEN_REGION (1<<8)  

#define MN_FACE_CHECKED (1<<9)      

#define MN_FACE_CHANGED (1<<10)     

#define MN_FACE_CULLED (1<<11)      



#define MAX_EDGEDATA 10
#define EDATA_KNOT 0
#define EDATA_CREASE 1


#define MN_MESH_NONTRI (1<<0)               

#define MN_MESH_FILLED_IN (1<<1)            

#define MN_MESH_RATSNEST (1<<2)             

#define MN_MESH_NO_BAD_VERTS (1<<3)         

#define MN_MESH_VERTS_ORDERED (1<<4)        

#define MN_MESH_FACE_NORMALS_INVALID (1<<6) 

#define MN_MESH_HAS_VOLUME (1<<7)           

#define MN_MESH_HITTEST_REQUIRE_ALL (1<<8)  

#define MN_MESH_PARTIALCACHEINVALID (1<<16) 
#define MN_MESH_CACHE_FLAGS (MN_MESH_FILLED_IN|MN_MESH_NO_BAD_VERTS|MN_MESH_VERTS_ORDERED)



#define MN_MESH_TEMP_1 (1<<13)          //!< \internal 
#define MN_MESH_TEMP_2 (1<<14)          //!< \internal
#define MN_MESH_DONTTRISTRIP (1<<15)    //!< \internal 


enum PMeshSelLevel { MNM_SL_OBJECT, MNM_SL_VERTEX, MNM_SL_EDGE, MNM_SL_FACE, MNM_SL_CURRENT };



#define MNDISP_VERTTICKS 0x01 //!< Display vertex tick marks.
#define MNDISP_SELVERTS 0x02 //!< Display selected vertices.
#define MNDISP_SELFACES 0x04 //!< Display selected faces.
#define MNDISP_SELEDGES 0x08 //!< Display selected edges
#define MNDISP_NORMALS 0x10 //!< Display face normals.


#define MNDISP_SMOOTH_SUBSEL 0x20 
#define MNDISP_BEEN_DISP 0x40 //!< Set when the MNMesh has been displayed (at the end of the render method.) 
#define MNDISP_DIAGONALS 0x80 //!< Set when diagonals should be displayed.
#define MNDISP_HIDE_SUBDIVISION_INTERIORS 0x100


// NOTE: these are the same bits used for object level.
//#define SUBHIT_SELONLY        (1<<0)
//#define SUBHIT_UNSELONLY  (1<<2)
//#define SUBHIT_ABORTONHIT (1<<3)
//#define SUBHIT_SELSOLID       (1<<4)




#define SUBHIT_MNUSECURRENTSEL (1<<22)      
#define SUBHIT_OPENONLY     (1<<23)
#define SUBHIT_MNVERTS      (1<<24)
#define SUBHIT_MNFACES      (1<<25)
#define SUBHIT_MNEDGES      (1<<26)

#define SUBHIT_MNDIAGONALS  (1<<27)     
#define SUBHIT_MNTYPEMASK   (SUBHIT_MNVERTS|SUBHIT_MNFACES|SUBHIT_MNEDGES|SUBHIT_MNDIAGONALS)



#define MN_SUBDIV_NEWMAP 0x01
#define MN_SUBDIV_HIDE_INTERNAL_EDGES 0x10


class MNVert : public FlagUser {
public:
    Point3 p;   
    int orig;   

    MNVert () { orig = -1; }
    
    DllExport MNVert & operator= (const MNVert & from);

    bool operator==(const MNVert & from) { return (from.p==p)&&(from.ExportFlags()==ExportFlags()); }
};

class MNEdge : public FlagUser {
public:

    int v1;

        int v2; 
    
        int f1; 
        
        int f2;

    int track;  

    MNEdge() { Init(); }

    MNEdge (int vv1, int vv2, int fc) { f1=fc; f2=-1; v1=vv1; v2=vv2; track=-1; }

    void Init() { v1=v2=f1=0; f2=-1; track=-1; }
    
    int OtherFace (int ff) { return (ff==f1) ? f2 : f1; }
    
    int OtherVert (int vv) { return (vv==v1) ? v2 : v1; }

    void Invert () { int hold=v1; v1=v2; v2=hold; hold=f1; f1=f2; f2=hold; }
    
    DllExport void ReplaceFace (int of, int nf, int vv1=-1);
    
    void ReplaceVert (int ov, int nv) { if (v1 == ov) v1 = nv; else { DbgAssert (v2==ov); v2 = nv; } }
    
    DllExport bool Uncrossable ();
    
    DllExport MNEdge & operator= (const MNEdge & from);
    
    bool operator==(MNEdge & f) { return (f.v1==v1)&&(f.v2==v2)&&(f.f1==f1)&&(f.f2==f2)&&(f.ExportFlags()==ExportFlags()); }
    
    int& operator[](int i) { return i ? v2 : v1; }  

    const int& operator[](int i) const { return i ? v2 : v1; }  
    
    DllExport void MNDebugPrint ();
};

class MNFace;

class MNMapFace: public MaxHeapOperators {
    friend class MNMesh;
    int dalloc;
public:
    int deg; 

    int *tv; 

    MNMapFace() { Init(); }
    
    DllExport MNMapFace (int d);

    ~MNMapFace () { Clear(); }

    DllExport void Init();
    
    DllExport void Clear();
    
    DllExport void SetAlloc (int d);
    
    void SetSize (int d) { SetAlloc(d); deg=d; }
    
    DllExport void MakePoly (int fdeg, int *tt);
    
    DllExport void Insert (int pos, int num=1);
    
    DllExport void Delete (int pos, int num=1);
    
    DllExport void RotateStart (int newstart);
    
    DllExport void Flip (); // Reverses order of verts.  0 remains start.

    DllExport int VertIndex (int vv);
    
    DllExport void ReplaceVert (int ov, int nv);

    DllExport MNMapFace & operator= (const MNMapFace & from);

    DllExport MNMapFace & operator= (const MNFace & from);

    DllExport bool operator== (const MNMapFace & from);

    DllExport void MNDebugPrint ();
};

DllExport void DiagSort (int dnum, int *diag);

class MNFace : public FlagUser {
    friend class MNMesh;
    
        /* This is the amount of space allocated for verts, edges, mapping coords, and
                other information that's based on degree (deg). */
        int dalloc;

    void SwapContents (MNFace & from);
public:
        
    int deg;    

    int *vtx;

    int *edg;   

    int *diag;  

    DWORD smGroup;

    MtlID material;

    int track;  

    BitArray visedg;

    BitArray edgsel; 

    BitArray bndedg;

    MNFace() { Init(); }

    MNFace (int d) { Init(); SetDeg (d); }

    DllExport MNFace (const MNFace *from);

    ~MNFace () { Clear(); }

    DllExport void Init();

    DllExport void SetDeg (int d);

    DllExport void Clear();

    int TriNum() { return deg-2; }
    
    DllExport int FindTriPoint (int edge);  // finds point that makes tri with this edge.
    
    DllExport int FindTriPoint (int a, int b);  // does the same for nonsequential verts - result is between a,b.

    DllExport void GetTriangles (Tab<int> &tri);

    DllExport void SetAlloc (int d);
    
    DllExport void MakePoly (int fdeg, int *vv, bool *vis=NULL, bool *sel=NULL);
    
    DllExport void Insert (int pos, int num=1);
    
    DllExport bool Delete (int pos, int num=1, int edir=1, bool fixtri=TRUE);
    
    DllExport void RotateStart (int newstart);
    
    DllExport void Flip ();

    DllExport int VertIndex (int vv, int ee=-1);
    
    DllExport int EdgeIndex (int ee, int vv=-1);
    
    DllExport void ReplaceVert (int ov, int nv, int ee=-1);
    
    DllExport void ReplaceEdge (int oe, int ne, int vv=-1);

    DllExport MNFace & operator= (const MNFace & from);
    
    DllExport bool operator== (const MNFace &from);
    
    int& operator[](int i) { return vtx[i]; }
    
    const int& operator[](int i) const { return vtx[i]; }  
    
    DllExport void MNDebugPrint (bool triprint=FALSE);

    DllExport IOResult Save (ISave *isave);
    DllExport IOResult Load (ILoad *iload);
};

class MNMap : public FlagUser {
    friend class MNMesh;
    int nv_alloc, nf_alloc;
public:
    MNMapFace *f;
    
    UVVert *v;
    
    int numv;
        
    int numf;

    MNMap () { Init(); }

    ~MNMap () { ClearAndFree (); }



    DllExport void Init ();
    
    DllExport void VAlloc (int num, bool keep=TRUE);
    
    DllExport void FAlloc (int num, bool keep=TRUE);



    int VNum () const { return numv; }
    
    UVVert V(int i) const { return v[i]; }

    int FNum () const { return numf; }
    
    MNMapFace *F(int i) const { return &(f[i]); }

    DllExport int NewTri (int a, int b, int c);

    DllExport int NewTri (int *vv);
    
    DllExport int NewQuad (int a, int b, int c, int d);
    
    DllExport int NewQuad (int *vv);
    
    DllExport int NewFace (int degg=0, int *vv=NULL);
    
    DllExport void setNumFaces (int nfnum);
    
    DllExport int NewVert (UVVert p, int uoff=0, int voff=0);
    
    DllExport void setNumVerts (int nvnum);

    DllExport void CollapseDeadVerts (MNFace *faces);
    
    DllExport void CollapseDeadFaces (MNFace *faces);
    
    DllExport void Clear ();
    
    DllExport void ClearAndFree ();

    DllExport void Transform (Matrix3& xfm);    



    DllExport MNMap & operator= (const MNMap & from);

    DllExport MNMap & operator+= (const MNMap & from);

    DllExport MNMap & operator+= (const MNMesh & from);

    DllExport void ShallowCopy (const MNMap & from);
    
    DllExport void NewAndCopy ();
    
    DllExport void MNDebugPrint (MNFace *faces);
    
    DllExport bool CheckAllData (int mapChannel, int nf, MNFace *faces);

    DllExport IOResult Save (ISave *isave, MNFace *faces=NULL);
    
    DllExport IOResult Load (ILoad *iload, MNFace *faces=NULL);
};

DllExport int EdgeDataType (int edID);
DllExport void *EdgeDataDefault (int edID);

class MNMeshBorder;
class MNChamferData;
class MNChamferData10;
class MNFaceClusters;

class MNDiagonalHitData : public HitData {
public:
    int mFace, mDiag;

    MNDiagonalHitData (int face, int diagonal) : mFace(face), mDiag(diagonal) { }

    ~MNDiagonalHitData () { }
};

namespace MaxGraphics {

    class IMNMeshInternal;
}



class MNMesh : public FlagUser, public BaseInterfaceServer {
    friend class HardwareMNMesh;
    friend void gfxCleanup(void *data);
    friend class MNNormalSpec;
    friend class MNMeshUtilites8Impl;
    friend class MNMeshUtilities10Impl;
    friend class MNMeshFGBGObject;
    friend class MaxGraphics::IMNMeshInternal;

private:

#pragma region Private Member Variables
    static int      refCount;
    static HANDLE   workMutex;
    static HANDLE   workEndEvent;

    int nv_alloc;
    int ne_alloc;
    int nf_alloc;
    int nm_alloc;

        

    Box3 bdgBox;
    Point3*  fnorm;
    RVertex* rVerts;           // <<< instance specific.
    GraphicsWindow *cacheGW;  // identifies rVerts cache

    //these are counter of various derived data so we can track when to delete them when they become unused
    UINT        mDXMeshCacheDrawCount;  //this the number of times that the direct mesh cache has been used to draw the mesh exclusively
    UINT        mRedrawCountFromLoad;  //this is the number of times the mesh has been redrawn from load.  This is used to prevent an initial memory spike on load
                                        //this will be set to -1 if the mesh was created and not loaded
    UINT        mBoxDisplayCount;  //this the number of times that the direct mesh cache has been drawn as a box exclusively


    // SCA revision for Max 5.0 - value of 0 for unbuilt, 1 for built according to legacy 4.0 scheme,
    // and 2 for built according to new scheme - this is so that we refresh normals if the user changes
    // the "Use Legacy 4.0 Vertex Normals" checkbox.
    int normalsBuilt;
    float norScale;

    // Hidden map channels
    // There are always NUM_HIDDENMAPS of these, but we dynamically allocate them
    // so that M(mapChannel) can be a const method.  (This wouldn't work if we had hmap[NUM_HIDDENMAPS].)
    MNMap *hmap;
    // Formerly public normal map channels:
    MNMap *m;

    // Vertex color arrays - for display use.
    int curVCChan;  // current map channel to use for colors (default = 0)
    UVVert *curVCVerts; // possible external color array (default = NULL)
    MNMapFace *curVCFaces;  // possible external face array (default = NULL)

    DWTab       norInd;         // indirection array for fast normal lookup
    int         normalCount;    // total number of normals
    Point3 *    gfxNormals;     // flattened list of normals

    // Derived arrays to contain generated texture coordinates
    int         numTexCoords[GFX_MAX_TEXTURES];
    Point3 *    texCoords[GFX_MAX_TEXTURES];

#pragma endregion

#pragma region Private Methods
    // Internal part of SabinDoo method:
    void SDVEdgeFace (int id, int vid, int *fv, Tab<Tab<int> *> & fmv, int selLevel);

    // Internal part of recursive smoothing-group search.
    DWORD FindReplacementSmGroup (int ff, DWORD os, int call);

    // Internal parts of Boolean. (MNBool.cpp)
    int BooleanZip (DWORD sortFlag, float weldThresh);
    bool BoolZipSeam (Tab<int> *lpi, Tab<int> *lpj, int & starth, int & startk, float weldThresh);
    void BoolPaintClassification (int ff, DWORD classification);

    // Internal data cache stuff (MNPipe.cpp)
    void buildBoundingBox ();
    void buildFaceNormals ();

    GraphicsWindow *getCacheGW() { return cacheGW; }
    void setCacheGW (GraphicsWindow *gw) { cacheGW = gw; }

    //Just some temporary structs to hold a list of only changed faces and verts.  They are used when building normals.
    BitArray        mInvalidVerts;
    BitArray        mInvalidFaces;
    Tab<int>    mInvalidVertList;
    Tab<int>    mInvalidFaceList;


    void    DrawOnlySelectedEdges(GraphicsWindow *gw);


    void    DrawOnlySelectedFaces(GraphicsWindow *gw);


    void    DrawNormals(GraphicsWindow *gw);


    void    DrawVertexTicks(GraphicsWindow *gw);

    // These next 2 functions need to be kept in sync if you make a change to the vertex display

    void    DrawVertexTicksGen(GraphicsWindow *gw);


    void    DrawVertexTicksDX(GraphicsWindow *gw);


    void    DrawMeshDX_NoCache(GraphicsWindow *gw, int compFlags, Material *ma, int numMat=-1);


    void    DrawMeshGenHW(GraphicsWindow *gw, int compFlags, Material *ma, int numMat=-1);
    

    void    DrawMeshSZB(GraphicsWindow *gw, int compFlags, Material *ma, int numMat=-1);


    // New MNMesh routines to drive HardwareShaders
    // NOTE alot of these were never implemented
    bool    CanDrawTriStrips(DWORD rndMode, int numMtls, Material *mtl);
    bool    BuildTriStrips(DWORD rndMode, int numMtls, Material *mtl);
    void    TriStripify(DWORD rndMode, int numTex, TVFace *tvf[], TriStrip *s, StripData *sd, int vtx);
    void    Draw3DTriStrips(IHardwareShader *phs, int numMat, Material *ma);
    void    Draw3DWireTriStrips(IHardwareShader *phs, int numMat, Material *ma);
    void    Draw3DVisEdgeList(IHardwareShader *phs, DWORD flags);
    int     render3DTriStrips(IHardwareShader *phs, int kmat, int kstrips);
    int     render3DWireTriStrips(IHardwareShader *phs, int kmat, int kstrips);
    int     render3DFaces(IHardwareShader *phs, DWORD index, int *custVis=NULL);

    // Vertex Removal approaches - Luna task 748O
    bool RemoveInternalVertex (int vertex);
    bool RemoveBorderVertex (int vertex);

    // Renders without any color handling - used only in hit-testing at this point.
    void renderSingleDiagonal (GraphicsWindow *gw, int ff, int d);

    // new methods for edge connection with slide and pinch values max8 
    bool ConnectEdges (DWORD edgeFlag, int segments=2, int pinch = 0, int slide = 0 );
    void MultiDivideEdge (int edge, int segments, int pinch, int slide, bool in_flipEdge );

    // new split method with extra distance parameters 
    bool SplitFlaggedVertices (DWORD in_vertexFlag, float in_distance );
    bool SplitFlaggedEdges ( DWORD in_edgeFlag , float in_distance );

    // new chamfer method with extra open flag 
    bool ChamferVertices (DWORD in_flag, MNChamferData *in_mcd, bool in_open);
    bool ChamferEdges (DWORD in_flag, MNChamferData *in_mcd, bool in_open );

    // new chamfer method with segments parameter
    bool ChamferEdges (DWORD in_flag, MNChamferData10& in_mcd, bool in_open, int in_segments);
#pragma endregion 

public:

#pragma region Public Member Variables 
    MNVert *v; 
    MNEdge *e; 
    MNFace *f; 
    int numv;  
    int nume;  
    int numf;  
    int numm;  

    PerData *vd;

    BitArray vdSupport;

    PerData *ed;

    BitArray edSupport;

    int selLevel;

    DWORD dispFlags;

    Tab<int> *vedg;

    Tab<int> *vfac;
#pragma endregion
        
#pragma region Constructors and Destructors



    MNMesh () { Init(); DefaultFlags (); }

    MNMesh (const Mesh & from) { Init(); SetFromTri (from); FillInMesh (); }
    
    MNMesh (const MNMesh & from) { Init(); DefaultFlags(); *this = from; }

    DllExport ~MNMesh();
#pragma endregion

#pragma region Allocation and Initialization Methods



    void DefaultFlags () { ClearAllFlags (); }  

    DllExport void Init ();

    DllExport void VAlloc (int num, bool keep=TRUE);
    
    DllExport void VShrink (int num=-1);    // default means "Shrink array allocation to numv"
    
    DllExport void freeVEdge();
    
    DllExport void VEdgeAlloc();
    
    DllExport void freeVFace();
    
    DllExport void VFaceAlloc();
    
    DllExport void EAlloc (int num, bool keep=TRUE);
    
    DllExport void EShrink (int num=-1);
    
    DllExport void FAlloc (int num, bool keep=TRUE);
    
    DllExport void FShrink (int num=-1);
    
    DllExport void MAlloc (int num, bool keep=TRUE);
    
    DllExport void MShrink (int num=-1);
#pragma endregion
        
#pragma region Component Access Functions



    int VNum () const { return numv; }

    MNVert *V(int i) const { return &(v[i]); }
    
    Point3 & P(int i) const { return v[i].p; }
    
    int ENum () const { return nume; }
    
    MNEdge *E(int i) const { return &(e[i]); }
    
    int FNum () const { return numf; }
    
    MNFace *F(int i) const { return &(f[i]); }
    
    int MNum () const { return numm; }
    
    DllExport int TriNum () const;
#pragma endregion

#pragma region Mapping Methods



    DllExport MNMap *M(int mapChannel) const;

    DllExport void SetMapNum (int mpnum);

    DllExport void InitMap (int mapChannel);    // Inits to current MNMesh topology.

    DllExport void ClearMap (int mapChannel);

    DllExport UVVert MV (int mapChannel, int i) const;

    DllExport MNMapFace *MF (int mapChannel, int i) const;

    DllExport UVVert ExtrapolateMapValue (int face, int edge, Point3 & pt, int mapChannel);

    DllExport bool SeparateMapVerticesInFaceCluster (MNFaceClusters & fclust, int clusterID);

    DllExport bool IsEdgeMapSeam (int mapChannel, int edge);

    DllExport void FindEdgeListMapVerts (const Tab<int> & lp, Tab<int> & mv, int mapChannel);
#pragma endregion

#pragma region Per-Vertex Data



    DllExport void setNumVData (int ct, BOOL keep=FALSE);
    int VDNum () const { return vdSupport.GetSize(); }
    DllExport BOOL vDataSupport (int vdChannel) const;
    DllExport void setVDataSupport (int vdChannel, BOOL support=TRUE);
    void *vertexData (int vdChannel) const { return vDataSupport(vdChannel) ? vd[vdChannel].data : NULL; }
    float *vertexFloat (int vdChannel) const { return (float *) vertexData (vdChannel); }
    DllExport void freeVData (int vdChannel);
    DllExport void freeAllVData ();
        #pragma endregion

        #pragma region Vertex Weight Methods



    float *getVertexWeights () { return vertexFloat(VDATA_WEIGHT); }
    void SupportVertexWeights () { setVDataSupport (VDATA_WEIGHT); }
    void freeVertexWeights () { freeVData (VDATA_WEIGHT); }
    float *getVSelectionWeights () { return vertexFloat(VDATA_SELECT); }
    void SupportVSelectionWeights () { setVDataSupport (VDATA_SELECT); }
    void freeVSelectionWeights () { freeVData (VDATA_SELECT); }
        #pragma endregion

        #pragma region Per-Edge Data



    DllExport void setNumEData (int ct, BOOL keep=FALSE);
    int EDNum () const { return edSupport.GetSize(); }
    DllExport BOOL eDataSupport (int edChannel) const;
    DllExport void setEDataSupport (int edChannel, BOOL support=TRUE);
    void *edgeData (int edChannel) const { return eDataSupport(edChannel) ? ed[edChannel].data : NULL; }
    float *edgeFloat (int edChannel) const { return (float *) edgeData (edChannel); }
    DllExport void freeEData (int edChannel);
    DllExport void freeAllEData ();
        #pragma endregion

        #pragma region Edge Knot Methods



    float *getEdgeKnots () { return edgeFloat(EDATA_KNOT); }
    void SupportEdgeKnots () { setEDataSupport (EDATA_KNOT); }
    void freeEdgeKnots () { freeEData (EDATA_KNOT); }
        #pragma endregion

        #pragma region Vertex Face and Edge Methods



    DllExport void VClear (int vv);
    DllExport void VInit (int vv);
    DllExport int VFaceIndex (int vv, int ff, int ee=-1);
    DllExport int VEdgeIndex (int vv, int ee);
    void VDeleteEdge (int vv, int ee) { if (vedg) vedg[vv].Delete (VEdgeIndex(vv, ee), 1); }
    DllExport void VDeleteFace (int vv, int ff);
    DllExport void VReplaceEdge (int vv, int oe, int ne);
    DllExport void VReplaceFace (int vv, int of, int nf);
    DllExport void CopyVert (int nv, int ov);   // copies face & edge too if appropriate
    DllExport void MNVDebugPrint (int vv);
        #pragma endregion

    #pragma region Mesh Building Functions



    DllExport int NewTri (int a, int b, int c, DWORD smG=0, MtlID mt=0);
    DllExport int NewTri (int *vv, DWORD smG=0, MtlID mt=0);
    DllExport int NewQuad (int a, int b, int c, int d, DWORD smG=0, MtlID mt=0);
    DllExport int NewQuad (int *vv, DWORD smG=0, MtlID mt=0);
    DllExport int NewFace (int initFace, int degg=0, int *vv=NULL, bool *vis=NULL, bool *sel=NULL);
    DllExport int CreateFace (int degg, int *vv);   
    DllExport int AppendNewFaces (int nfnum);
    DllExport void setNumFaces (int nfnum);
    DllExport int RegisterEdge (int v1, int v2, int f, int fpos);
    DllExport int SimpleNewEdge (int v1, int v2);
    DllExport int NewEdge (int v1, int v2, int f, int fpos);
    DllExport int AppendNewEdges (int nenum);
    DllExport void setNumEdges (int nenum);
    DllExport int NewVert (Point3 & p);
    DllExport int NewVert (Point3 & p, int vid);
    DllExport int NewVert (int vid);
    DllExport int NewVert (int v1, int v2, float prop);
    DllExport int AppendNewVerts (int nvnum);
    DllExport void setNumVerts (int nvnum);
    DllExport int InsertSpur (int face, int vertIndex, Tab<int> *ptMapVertArray=NULL);  
        #pragma endregion

        #pragma region Component Removal Routines





    DllExport void CollapseDeadVerts ();
    DllExport void CollapseDeadEdges ();
    DllExport void CollapseDeadFaces ();
    DllExport void CollapseDeadStructs();
    DllExport void Clear ();    // Deletes everything.
    DllExport void ClearAndFree (); // Deletes everything, frees all memory
    DllExport void freeVerts();
    DllExport void freeEdges();
    DllExport void freeFaces();
    DllExport void freeMap(int mapChannel);
    DllExport void freeMaps();
        /* This removes a vertex and then cleans up all the topology. */
    DllExport bool RemoveVertex (int vertex);   

        /* Removes an edge that goes out to an otherwise isolated vertex and back again which is used twice in a row on the same face.  
        \param spur The index of the edge to be removed. */
    DllExport bool RemoveSpur (int spur);   

    DllExport void DeleteFlaggedFaces (DWORD deathflags, DWORD nvCopyFlags=0x0);

    DllExport void RemoveEdge (int edge);

    DllExport void EliminateCollinearVerts ();
    DllExport void EliminateCoincidentVerts (float thresh=MNEPS);   
        #pragma endregion

        #pragma region Bulk Flag Clearing and Setting Functions



    void ClearVFlags (DWORD fl) { for (int i=0; i<numv; i++) v[i].ClearFlag (fl); }
    void ClearEFlags (DWORD fl) { for (int i=0; i<nume; i++) e[i].ClearFlag (fl); }
    void ClearFFlags (DWORD fl) { for (int i=0; i<numf; i++) f[i].ClearFlag (fl); }
    DllExport void PaintFaceFlag (int ff, DWORD fl, DWORD fenceflags=0x0);
    DllExport int PropegateComponentFlags (int slTo, DWORD flTo,
        int slFrom, DWORD flFrom, bool ampersand=FALSE, bool set=TRUE);
    DllExport void UpdateBackfacing (GraphicsWindow *gw, bool force);
        #pragma endregion

        #pragma region Selection Methods



    DllExport void VertexSelect (const BitArray & vsel);
    DllExport void EdgeSelect (const BitArray & esel);
    DllExport void FaceSelect (const BitArray & fsel);
    bool getVertexSel (BitArray & vsel) { return getVerticesByFlag (vsel, MN_SEL); }
    bool getEdgeSel (BitArray & esel) { return getEdgesByFlag (esel, MN_SEL); }
    bool getFaceSel (BitArray & fsel) { return getFacesByFlag (fsel, MN_SEL); }
    DllExport void SelectEdgeLoop (BitArray & edgeSel);

    DllExport void SelectEdgeRing (BitArray & edgeSel);
    DllExport BitArray VertexTempSel (DWORD fmask=MN_DEAD|MN_SEL, DWORD fset=MN_SEL);      
        #pragma endregion

        #pragma region Getting Components by Flag



    DllExport bool getVerticesByFlag (BitArray & vset, DWORD flags, DWORD fmask=0x0);
    DllExport bool getEdgesByFlag (BitArray & eset, DWORD flags, DWORD fmask=0x0);
    DllExport bool getFacesByFlag (BitArray & fset, DWORD flags, DWORD fmask=0x0);
    DllExport void ElementFromFace (int ff, BitArray & fset);
    DllExport void BorderFromEdge (int ee, BitArray & eset);
        #pragma endregion

        #pragma region Edge Visibility and Selection Methods



    DllExport void SetEdgeVis (int ee, BOOL vis=TRUE);
    DllExport void SetEdgeSel (int ee, BOOL sel=TRUE);
        #pragma endregion

        #pragma region Mesh Compatibility Functions



    void SetFromTri (const Mesh & from) { Clear (); AddTri (from); }
    DllExport void AddTri (const Mesh & from);  
    DllExport void OutToTri (Mesh & tmesh); 
        #pragma endregion

        #pragma region Mesh Computation Functions



    DllExport void FillInMesh ();   
    DllExport void FillInFaceEdges (); 
    DllExport void FillInVertEdgesFaces ();
    DllExport bool EliminateBadVerts (DWORD flag=0);    // o(n*8) or so
    DllExport void OrderVerts ();   // o(n*3) or so
    DllExport void OrderVert (int vid);
        #pragma endregion

        #pragma region Mesh Triangulation Routines



    DllExport void Triangulate ();  
    DllExport void TriangulateFace (int ff);    
    DllExport int DivideFace (int ff, Tab<float> & bary);
        #pragma endregion

    #pragma region Bounding Box Methods



    DllExport void FaceBBox (int ff, Box3 & bbox);
    DllExport void BBox (Box3 & bbox, bool targonly=FALSE);
    DllExport Box3 getBoundingBox (Matrix3 *tm=NULL, bool targonly=FALSE);
    #pragma endregion

        #pragma region Targeting Methods



    DllExport int TargetVertsBySelection (int selLevel);    
    DllExport int TargetEdgesBySelection (int selLevel);    // o(n)
    DllExport int TargetFacesBySelection (int selLevel);        
    DllExport void DetargetVertsBySharpness (float sharpval);   
        #pragma endregion

        #pragma region Face-Center methods



    DllExport void ComputeCenters (Point3 *ctr, bool targonly=FALSE);   // o(n)
    DllExport void ComputeCenter (int ff, Point3 & ctr);
    DllExport void ComputeNormal (int ff, Point3 & normal, Point3 *ctr=NULL);
    DllExport void ComputeSafeCenters (Point3 *ctr, bool targonly=FALSE, bool detarg=FALSE);    // o(n)
    DllExport bool ComputeSafeCenter (int ff, Point3 & ctr);    
        #pragma endregion

        #pragma region Triangulation-of-polygon Methods



    DllExport void RetriangulateFace (int ff);  // o(deg^2)
    DllExport void FindDiagonals (int ff, int *diag);
    DllExport void FindDiagonals (int deg, int *vv, int *diag);
    DllExport void BestConvexDiagonals (int ff, int *diag=NULL);
    DllExport void BestConvexDiagonals (int deg, int *vv, int *diag);
    DllExport bool SetDiagonal (int ff, int d1, int d2);
        #pragma endregion

        #pragma region Unification Methods




    DllExport void MakePolyMesh (int maxdeg=0, BOOL elimCollin=TRUE);
    
    DllExport void MakeConvexPolyMesh (int maxdeg=0);
        #pragma endregion

        #pragma region Normal methods




    DllExport int FindEdgeFromVertToVert (int vrt1, int vrt2);  // o(deg)
    DllExport void GetVertexSpace (int vrt, Matrix3 & tm);  // o(deg)
    DllExport Point3 GetVertexNormal (int vrt); // o(deg)
    DllExport Point3 GetEdgeNormal (int ed);    // o(deg)
    DllExport Point3 GetFaceNormal (int fc, bool nrmlz=FALSE);  //o(deg)
    Point3 GetEdgeNormal (int vrt1, int vrt2) { return GetEdgeNormal (FindEdgeFromVertToVert(vrt1, vrt2)); }
    DllExport float EdgeAngle (int ed);
    DllExport void FlipNormal(int faceIndex);
    DllExport void checkNormals (BOOL illum);
    DllExport void buildNormals ();
    DllExport void buildRenderNormals ();
    DllExport bool FlipElementNormals (DWORD flag=MN_SEL);    
    DllExport bool FlipFaceNormals (DWORD faceFlag);
        #pragma endregion

        #pragma region Smoothing Group Handling



    DllExport void Resmooth (bool smooth=TRUE, bool targonly=FALSE, DWORD targmask=~0x0);   // o(n)
    DllExport DWORD CommonSmoothing (bool targonly=FALSE);  // o(n)
    DllExport DWORD GetNewSmGroup (bool targonly=FALSE);    // o(n)
    DllExport MtlID GetNewMtlID (bool targonly = FALSE); // o(n)
    DllExport DWORD GetOldSmGroup (bool targonly=FALSE);    // up to o(n).
    DllExport DWORD GetAllSmGroups (bool targonly=FALSE);   // up to o(n)
    DllExport DWORD FindReplacementSmGroup (int ff, DWORD os);
    DllExport void PaintNewSmGroup (int ff, DWORD os, DWORD ns);
    DllExport bool SeparateSmGroups (int v1, int v2);
    DllExport void AutoSmooth(float angle,BOOL useSel,BOOL preventIndirectSmoothing);
        #pragma endregion

        #pragma region Fence Methods





    DllExport void FenceMaterials ();
    DllExport void FenceSmGroups ();
    DllExport void FenceFaceSel ();
    DllExport void FenceOneSidedEdges();
    DllExport void FenceNonPlanarEdges (float thresh=.9999f, bool makevis=FALSE);
    DllExport void SetMapSeamFlags ();
    DllExport void SetMapSeamFlags (int mapChannel);
        #pragma endregion

        #pragma region Face Point Functions




    DllExport int FindFacePointTri (int ff, Point3 & pt, double *bary, int *tri);
    DllExport UVVert FindFacePointMapValue (int ff, Point3 & pt, int mapChannel);
        #pragma endregion

        #pragma region Hole Fixing Functions



    DllExport void GetBorder (MNMeshBorder & brd, int selLevel=MNM_SL_OBJECT, DWORD targetFlag=MN_SEL);
    DllExport void FillInBorders (MNMeshBorder *b=NULL);
    DllExport void FindOpenRegions ();
        #pragma endregion

        #pragma region Doubled Mapping Vertex Functions

    DllExport BOOL CheckForDoubledMappingVerts();

    DllExport void EliminateDoubledMappingVerts();
        #pragma endregion

        #pragma region Isolated Mapping Vertex Functions




    DllExport void EliminateIsoMapVerts();

    DllExport void EliminateIsoMapVerts(int mapChannel);
        #pragma endregion

        #pragma region Operators



    DllExport MNMesh & operator= (const MNMesh & from);
    DllExport MNMesh & operator+= (const MNMesh & from);
        #pragma endregion

        #pragma region Debugging Functions


    DllExport void MNDebugPrint (bool triprint=FALSE);
    DllExport void MNDebugPrintVertexNeighborhood (int vv, bool triprint=FALSE);
    DllExport bool CheckAllData ();
        #pragma endregion

    #pragma region Splitting and Subdividing Methods



    DllExport int SplitTriEdge (int ee, float prop=.5f, float thresh=MNEPS,
        bool neVis=TRUE, bool neSel=FALSE);
    DllExport int SplitTriFace (int ff, double *bary=NULL, float thresh=MNEPS,
        bool neVis=TRUE, bool neSel=FALSE);
    DllExport void SplitTri6 (int ff, double *bary=NULL, int *nv=NULL);
    DllExport int SplitEdge (int ee, float prop=.5f);
    DllExport int SplitEdge (int ee, float prop, Tab<int> *newTVerts);
    DllExport int SplitEdge (int ff, int ed, float prop, bool right, int *nf=NULL,
        int *ne=NULL, bool neVis=FALSE, bool neSel=FALSE, bool allconvex=FALSE);
    DllExport int IndentFace (int ff, int ei, int nv, int *ne=NULL, bool nevis=TRUE, bool nesel=FALSE);
    DllExport void SeparateFace (int ff, int a, int b, int & nf, int & ne, bool neVis=FALSE, bool neSel=FALSE);
    DllExport bool Slice (Point3 & N, float off, float thresh, bool split, bool remove, bool flaggedFacesOnly=false, DWORD faceFlags=MN_SEL);   
    DllExport bool SplitFlaggedVertices (DWORD flag=MN_SEL);
    DllExport bool SplitFlaggedEdges (DWORD flag=MN_SEL);   
        /* A clean-up method that splits a face where the face share a common edge 
        \code
        edge[index].f1 == edge[index].f2
        \endcode
        This is called typically before subdivision type methods.*/
    DllExport bool SplitFacesUsingBothSidesOfEdge (DWORD edgeFlag=0x0);
    DllExport void MultiDivideEdge (int edge, int segments);
    DllExport void MakeConvex ();
    DllExport void MakeFaceConvex (int ff);
    DllExport void RestrictPolySize (int maxdeg);
    #pragma endregion

        #pragma region Planar functions

    DllExport void MakePlanar (float planarThresh);
    
    DllExport void MakeFacePlanar (int ff, float planarThresh);
        #pragma endregion

    #pragma region Welding Functions



    DllExport bool WeldVerts (int a, int b);
    DllExport bool WeldEdge (int ee);
    DllExport bool WeldBorderVerts (int v1, int v2, Point3 *destination);
    DllExport bool WeldBorderEdges (int e1, int e2);
    DllExport bool WeldBorderVerts (float thresh, DWORD flag=MN_SEL);
    DllExport bool WeldOpposingEdges (DWORD edgeFlag);
    #pragma endregion
        
        #pragma region Tessellation Methods



    DllExport void TessellateByEdges (float bulge, MeshOpProgress* mop = NULL);
    DllExport bool AndersonDo (float interp, int selLevel, MeshOpProgress *mop=NULL, DWORD subdivFlags=0);
    DllExport void TessellateByCenters (MeshOpProgress *mop=NULL);
    DllExport void SabinDoo (float interp, int selLevel, MeshOpProgress *mop=NULL, Tab<Point3> *offsets=NULL);
    DllExport void SabinDooVert (int vid, float interp, int selLevel, Point3 *ctr, Tab<Point3> *offsets=NULL);
    DllExport void CubicNURMS (MeshOpProgress *mop=NULL,
        Tab<Point3> *offsets=NULL, DWORD subdivFlags=0);
        #pragma endregion

        #pragma region Boolean Methods



    DllExport void PrepForBoolean ();
    DllExport bool BooleanCut (MNMesh & m2, int cutType, int fstart=0, MeshOpProgress *mop=NULL);
    DllExport bool MakeBoolean (MNMesh & m1, MNMesh & m2, int type, MeshOpProgress *mop=NULL);
        #pragma endregion

        #pragma region Connection Methods



    DllExport void Connect (MNMeshBorder & borderList, int segs, float tension,
        bool sm_bridge, bool sm_ends, Tab<int> *vsep=NULL);
    DllExport void ConnectLoops (Tab<int> & loop1, Tab<int> & loop2,
        int segs, float tension, DWORD smGroup, MtlID mat, bool sm_ends);
    DllExport bool ConnectEdges (DWORD edgeFlag, int segments=2);

    DllExport bool ConnectVertices (DWORD vertexFlag);          
        #pragma endregion

        #pragma region Barycentric Functions

    DllExport void FacePointBary (int ff, Point3 & p, Tab<float> & bary);

        /* Finds the vector in barycentric-space for the vector given.  The vector returned is based on the vertex index of the face. */
    DllExport void FindFaceBaryVector (int face, int vertIndex, Point3 & vector, Tab<float> & tBary);
        #pragma endregion

    #pragma region Cloning and Copying Operations



    DllExport void CloneVerts (DWORD cloneFlag = MN_SEL, bool clear_orig=TRUE);
    DllExport void CloneFaces (DWORD cloneFlag = MN_SEL, bool clear_orig=TRUE);

    DllExport void CopyBasics (const MNMesh & from, bool copyEdges = false);    
    #pragma endregion   

        #pragma region Plane Methods



    DllExport bool MakeFlaggedPlanar (int selLev, DWORD flag=MN_SEL, Point3 *delta=NULL);
    DllExport bool MoveVertsToPlane (Point3 & norm, float offset, DWORD flag=MN_SEL, Point3 *delta=NULL);
        #pragma endregion
    
    #pragma region Detach Operations



    DllExport bool DetachFaces (DWORD flag=MN_SEL);
    DllExport bool DetachElementToObject (MNMesh & nmesh, DWORD fflags=MN_SEL, bool delDetached=true);
    #pragma endregion
        
    #pragma region Extrusion Methods



    DllExport bool ExtrudeFaceClusters (MNFaceClusters & fclust);
    DllExport bool ExtrudeFaceCluster (MNFaceClusters & fclust, int cl);
    DllExport bool ExtrudeFaces (DWORD flag=MN_SEL);    // Does each face separately
    // Bug fix: second version of GetExtrudeDirection so that a faceFlag can be
    // passed in when there are no relevant face clusters.  -sca 2001.12.12
    // Version which accepts faceFlag is NEW FOR 5.0!
    // Do not use if you wish to maintain backward compatibility with 4.0!
    DllExport void GetExtrudeDirection (MNChamferData *mcd, DWORD faceFlag);
    DllExport void GetExtrudeDirection (MNChamferData *mcd,
        MNFaceClusters *fclust=NULL, Point3 *clustNormals=NULL);
        DllExport bool ExtrudeVertices (DWORD vertexFlag, MNChamferData *pMCD, Tab<Point3> & tUpDir);

    DllExport bool ExtrudeEdges (DWORD edgeFlag, MNChamferData *pMCD, Tab<Point3> & tUpDir);

    DllExport bool ExtrudeFaceClusterAlongPath (Tab<Matrix3> tFrenets, MNFaceClusters & fclust, int clusterID, bool align);

    #pragma endregion

    #pragma region Coloring Methods



    DllExport bool SetVertColor (UVVert clr, int mapChannel, DWORD flag=MN_SEL);
    DllExport bool SetFaceColor (UVVert clr, int mapChannel, DWORD flag=MN_SEL);
    #pragma endregion

    #pragma region Chamfer Operations



    DllExport bool ChamferVertices (DWORD flag=MN_SEL, MNChamferData *mcd=NULL);
    DllExport bool ChamferEdges (DWORD flag=MN_SEL, MNChamferData *mcd=NULL);
    #pragma endregion
    
    #pragma region Cutting Methods



    DllExport int CutFace (int f1, Point3 & p1, Point3 & p2, Point3 & Z, bool split);
    DllExport int CutEdge (int e1, float prop1, int e2, float prop2, Point3 & Z, bool split);
    DllExport int Cut (int startv, Point3 & end, Point3 & Z, bool split);
    #pragma endregion

        #pragma region Pipeline Object Functions



    DllExport void ApplyMapper (UVWMapper & mapChannel, int channel=0, BOOL useSel=FALSE);
    //Invalidates the geometry cache of the MNMesh - Forces any geometry related data to be rebuilt
    DllExport void InvalidateGeomCache ();
    //Invalidates the topology cache of the MNMesh - Forces any topology related data to be rebuilt
    //in_cacheClearFlags specifies whether the "MN_MESH_CACHE_FLAGS" flags will be cleared
    //true means the flags will be cleared, false means the flags will not be touched
    //These flags dictate whether the mesh has valid data in the edge and vertex caches, which is
    //typically false after invalidating the topology cache.  (i.e. these flags should be cleared)
    //If unsure about what to pass to this method, use the default behaviour
    DllExport void InvalidateTopoCache ( bool in_clearCacheFlags = true );
    DllExport void UpdateDisplayVertexColors ();
    DllExport void SetDisplayVertexColors (int chan);
    DllExport void SetDisplayVertexColors (UVVert *mv, MNMapFace *mf);
    DllExport void PrepForPipeline ();
    DllExport void allocRVerts ();
    DllExport void updateRVerts (GraphicsWindow *gw);
    DllExport void freeRVerts ();
        #pragma endregion 
    
        #pragma region Display Flag Methods




    void        SetDispFlag(DWORD f) { dispFlags |= f; }
    DWORD       GetDispFlag(DWORD f) { return dispFlags & f; }
    void        ClearDispFlag(DWORD f) { dispFlags &= ~f; }
        #pragma endregion

        #pragma region Render Methods



    DllExport void render(GraphicsWindow *gw, Material *ma, RECT *rp, int compFlags, int numMat=1, InterfaceServer *pi=NULL);
    DllExport void renderFace (GraphicsWindow *gw, int ff);
    DllExport void render3DFace (GraphicsWindow *gw, int ff);
    DllExport void render3DDiagonals (GraphicsWindow *gw, DWORD compFlags);
    DllExport void renderDiagonals (GraphicsWindow *gw, DWORD compFlags);
    DllExport void renderDiagonal (GraphicsWindow *gw, int ff, bool useSegments=false, bool *lastColorSubSel=NULL);
    DllExport void render3DEdges (GraphicsWindow *gw, DWORD compFlags);
    DllExport void renderEdges (GraphicsWindow *gw, DWORD compFlags);
    DllExport void renderEdge (GraphicsWindow *gw, int ee, bool useSegments=false, bool *lastColorSubSel=NULL);
        #pragma endregion

    #pragma region Intersection and Hit Testing Functions



    DllExport BOOL select (GraphicsWindow *gw, Material *ma, HitRegion *hr, int abortOnHit=FALSE, int numMat=1);
    DllExport BOOL SubObjectHitTest(GraphicsWindow *gw, Material *ma, HitRegion *hr,
                            DWORD flags, SubObjHitList& hitList, int numMat=1 );
    DllExport int IntersectRay (Ray& ray, float& at, Point3& norm);
    DllExport int IntersectRay (Ray& ray, float& at, Point3& norm, int &fi, Tab<float> & bary);
    #pragma endregion

    #pragma region Object Overrides



    DllExport void      ShallowCopy(MNMesh *amesh, ChannelMask channels);
    DllExport void      NewAndCopyChannels(ChannelMask channels);
    DllExport void      FreeChannels (ChannelMask channels, BOOL zeroOthers=1);
    #pragma endregion
        
        #pragma region IO Functions



    DllExport IOResult Save (ISave *isave);
    DllExport IOResult Load (ILoad *iload);
        #pragma endregion

    #pragma region FlagUser Overrides



    DllExport void ClearFlag (DWORD fl);
    #pragma endregion

    #pragma region InterfaceServer Overrides



    DllExport BaseInterface* GetInterface(Interface_ID id);
    #pragma endregion

    #pragma region Cache and Optimization Methods



    DllExport void ReduceDisplayCaches();

    DllExport bool NeedGWCacheRebuilt(GraphicsWindow *gw, Material *ma, int numMat);

    DllExport void BuildGWCache(GraphicsWindow *gw, Material *ma, int numMat, BOOL threaded);
    DllExport void InvalidateHardwareMesh (DWORD keepFlags=0);
    DllExport void SetStaticMesh(bool staticMesh);   
    #pragma endregion

    #pragma region Specified Normal Methods



    DllExport MNNormalSpec *GetSpecifiedNormals();
    DllExport MNNormalSpec *GetSpecifiedNormalsForDisplay();    
    DllExport void ClearSpecifiedNormals ();
    DllExport void SpecifyNormals ();
    #pragma endregion

    #pragma region Miscellaneous Methods



    DllExport void Transform (Matrix3 & xfm);   

    bool IsClosed() { for (int i=0; i<nume; i++) if (e[i].f2<0) return FALSE; return nume?TRUE:FALSE; } // o(n)

    DllExport void Relax (float relaxval, bool targonly=TRUE);

    DllExport bool LiftFaceClusterFromEdge (int liftEdge, float liftAngle, int segments, MNFaceClusters & fclust, int clusterID);

    DllExport void SmoothByCreases (DWORD creaseFlag);

#ifdef SEPARATE_GEOM_TOPO_INVALIDATION
    DllExport void InvalidateHardwareMeshTopo (DWORD keepFlags=0);
#endif

    #pragma endregion
};

class MNMeshBorder: public MaxHeapOperators {
    friend class MNMesh;
        Tab<Tab<int> *> bdr;
    BitArray btarg; 
public:
    ~MNMeshBorder () { Clear(); }
    DllExport void Clear ();
    int Num () { return bdr.Count(); }
    Tab<int> *Loop (int i) { return bdr[i]; }
    bool LoopTarg (int i) { return ((i>=0) && (i<bdr.Count()) && (btarg[i])); }
    DllExport void MNDebugPrint (MNMesh *m);
};

class MNFaceElement: public MaxHeapOperators {
public:
    // For each face, which element is it in
    Tab<int> elem;
    int count;

    DllExport MNFaceElement (MNMesh &mesh);
    
    int operator[](int i) {return elem[i];}
};

class MNFaceClusters: public MaxHeapOperators {
public:
        Tab<int> clust; 
    
        int count;

    DllExport MNFaceClusters (MNMesh & mesh, DWORD clusterFlags);
    
    DllExport MNFaceClusters (MNMesh & mesh, float angle, DWORD clusterFlags);

    int operator[](int i) { return (i<clust.Count()) ? clust[i] : -1; }
    
    DllExport void MakeVertCluster(MNMesh &mesh, Tab<int> & vclust);

    DllExport void GetNormalsCenters (MNMesh &mesh, Tab<Point3> & norm, Tab<Point3> & ctr);
    
    DllExport void GetBorder (MNMesh &mesh, int clustID, Tab<int> & cbord);
    
    DllExport void GetOutlineVectors (MNMesh & m, Tab<Point3> & cnorms, Tab<Point3> & odir);
};

class MNEdgeClusters: public MaxHeapOperators {
public:
        Tab<int> clust;
    
        int count;

    DllExport MNEdgeClusters (MNMesh &mesh, DWORD clusterFlags);
    
    int operator[](int i) {return clust[i];}

    DllExport void MakeVertCluster (MNMesh &mesh, Tab<int> & vclust);
    
    DllExport void GetNormalsCenters (MNMesh &mesh, Tab<Point3> & norm, Tab<Point3> & ctr);
};

class MNChamferData: public MaxHeapOperators {
    Tab<UVVert> hmdir[NUM_HIDDENMAPS]; 
public:
    Tab<Point3> vdir; 
    Tab<float> vmax; 
    Tab<UVVert> *mdir; 

    MNChamferData () { mdir=NULL;}
    
    MNChamferData (const MNMesh & m) { mdir=NULL; InitToMesh(m);}
    
    DllExport ~MNChamferData ();

        DllExport void InitToMesh (const MNMesh & m);
    
    DllExport void setNumVerts (int nv, bool keep=TRUE, int resizer=0);
    
    DllExport void ClearLimits ();
    
    DllExport void GetDelta (float amount, Tab<Point3> & delta);
    
    DllExport bool GetMapDelta (MNMesh & mm, int mapChannel, float amount, Tab<UVVert> & delta);
    
    Tab<UVVert> & MDir (int mapChannel) { return (mapChannel<0) ? hmdir[-1-mapChannel] : mdir[mapChannel]; }
};


DllExport void MNChamferDataDebugPrint (MNChamferData & mcd, int mapNum);

class MNTempData : public BaseInterfaceServer {
private:
    MNEdgeClusters *edgeCluster;
    MNFaceClusters *faceCluster;
    Tab<int> *vertCluster;
    Tab<Point3> *normals;
    Tab<Point3> *centers;
    Tab<Point3> *vnormals;
    Tab<Tab<float> *> *clustDist;
    Tab<float> *selDist;
    Tab<float> *vsWeight;
    MNChamferData *chamData;

    Tab<Point3> *outlineDir;

    MNMesh *mesh;

    //this is used to keep track of the selDist data.  We used to compute all the seldist data which
    //was really slow.  We now only track the selDist that fall within  this limit which can make things
    //much faster.
    float mFalloffLimit;

public:


    DllExport MNTempData ();
    
    DllExport MNTempData (MNMesh *m);
    
    DllExport ~MNTempData ();

    void SetMesh (MNMesh *m) { mesh = m; }

        #pragma region Cluster Methods



    DllExport MNFaceClusters *FaceClusters (DWORD clusterFlags=MN_SEL);

    DllExport MNEdgeClusters *EdgeClusters (DWORD clusterFlags=MN_SEL);
    DllExport Tab<int> *VertexClusters (int sl, DWORD clusterFlags=MN_SEL);
    
    DllExport Tab<Point3> *ClusterNormals (int sl, DWORD clusterFlags=MN_SEL);
    
    DllExport Tab<Point3> *ClusterCenters (int sl, DWORD clusterFlags=MN_SEL);
    
    DllExport Matrix3 ClusterTM (int clust);

    DllExport Tab<float> *ClusterDist (int sl, DWORD clusterFlags, int clustId, BOOL useEdgeDist, int edgeIts);
    #pragma endregion

    DllExport Tab<Point3> *VertexNormals ();
    
    DllExport Tab<float> *VSWeight (BOOL useEdgeDist, int edgeIts,
                                    BOOL ignoreBack, float falloff, float pinch, float bubble,
                                    DWORD selFlags=MN_SEL);

    DllExport Tab<float> *SelectionDist (BOOL useEdgeDist, int edgeIts, DWORD selFlags=MN_SEL, float falloffLimit = -1.0f);
    
    //DllExport Tab<Point3> *FaceExtDir (int extrusionType);
    
    DllExport Tab<Point3> *OutlineDir (int extrusionType, DWORD clusterFlags=MN_SEL);

    DllExport MNChamferData *ChamferData();

    DllExport void Invalidate (DWORD part);
    
    DllExport void InvalidateDistances ();
    
    DllExport void InvalidateSoftSelection ();
    
    DllExport void freeClusterDist ();
    
    DllExport void freeBevelInfo ();
    
    DllExport void freeChamferData();
    
    DllExport void freeAll ();

    DllExport BaseInterface* GetInterface(Interface_ID id);
};

class IMNTempData10 : public BaseInterface {
public:
        Interface_ID    GetID() { return IMNTEMPDATA10_INTERFACE_ID; }
    
    virtual MNChamferData10& ChamferData() = 0;
    
    virtual void freeChamferData() = 0;
};

DllExport void SelectionDistance (MNMesh & mesh, float *selDist, DWORD selFlags);

DllExport void SelectionDistance (MNMesh & mesh, float *selDist, int iters, DWORD selFlags);

DllExport void ClustDistances (MNMesh & mesh, int numClusts, int *vclust,
                                 Tab<float> **clustDist);
DllExport void ClustDistances (MNMesh & mesh, int numClusts, int *vclust,
                                 Tab<float> **clustDist, int iters);

class BasisFinder: public MaxHeapOperators {
public:
    DllExport static void BasisFromZDir (Point3 & zDir, Point3 & xDir, Point3 & yDir);
};

class MNMeshSelectionConverter : public FlagUser {
public:
    DllExport void FaceToElement (MNMesh & mesh, BitArray & faceSel, BitArray & elementSel);
    DllExport void EdgeToBorder (MNMesh & mesh, BitArray & edgeSel, BitArray & borderSel);
    
    DllExport void VertexToEdge (MNMesh & mesh, BitArray & vertexSel, BitArray & edgeSel);
    DllExport void VertexToFace (MNMesh & mesh, BitArray & vertexSel, BitArray & faceSel);
};

class MNMeshUtilities: public MaxHeapOperators
{
private:
    MNMesh *mpMesh;

    // Private methods used by public ones:
    // (All Bridge stuff.)
    void GetBorderVertices (Tab<int> & border, Tab<int> & verts, bool reversedLoop=false);
    void GetBorderMapVertices (Tab<int> & border, Tab<int> & mapVerts, int mapChannel, bool reversedLoop=false);
    void InterpolateVertices (int v1, int v2, float f, int outputVert);
    void GetBridgeSmoothingGroups (Tab<int> & smVerts, Tab<int> & lgVerts, Tab<int> & match,
        float smoothThresh, Tab<DWORD> & smoothers);
    MtlID GetBridgeMaterial (Tab<int> & smaller, Tab<int> & larger);
    // Now PolygonToBorder() won't do any face deletion work, just to create borders.
    // Deletion will be handled in FinalizePolygonToBorder(), which is used internally
    bool PolygonToBorder (int face, int start, Tab<int> & border);
    bool OrientBorders (Tab<int> & border1, Tab<int> & border2);
    bool SynchBorders (Tab<int> & border1, Tab<int> & border2);
    bool BridgeLoops (Tab<int> & smaller, Tab<int> & larger, float smoothThresh);
    bool BridgeLoops (Tab<int> & smaller, Tab<int> & larger, float smoothThresh,
        int segments, float taper, float bias);
    void MatchLoops (Tab<Tab<int> *> & loopList, Tab<int> & loopMatch,
        Tab<int> *loopClusterID=NULL, Tab<int> *clusterMatch=NULL);

public:
    MNMeshUtilities (MNMesh *mesh) { mpMesh = mesh; }

    DllExport bool GetBorderFromEdge (int edge, Tab<int> & border);

    DllExport bool AutoSmooth (float threshold, DWORD faceFlag);

    DllExport bool FlipHingeAngle (Point3 & origin, Point3 & axis, int hingeEdge, DWORD faceFlag);

    DllExport bool HingeFromEdge (Point3 & origin, Point3 & axis, float angle, int segments,
                                        MNFaceClusters & fclust, int clusterID);
    DllExport bool MakeFlaggedPlanar (int selLev, DWORD flag, float *softSel, Point3 *delta=NULL);

    DllExport bool MoveVertsToPlane (Point3 & norm, float offset, float *softSel, Point3 *delta=NULL);

    DllExport bool CollapseEdges (DWORD edgeFlag);

    DllExport bool CollapseEdges (DWORD edgeFlag, Tab<int>& pointDest);

    DllExport void ConstrainDeltaToEdges (Tab<Point3> *deltaIn, Tab<Point3> *deltaOut);

    DllExport void ConstrainDeltaToFaces (Tab<Point3> *deltaIn, Tab<Point3> *deltaOut);

    DllExport bool ExtrudeOpenEdges (DWORD edgeFlag, bool clearFlagOnOldEdges, bool useTracking);

    DllExport bool BridgeBorders (int edge1, int twist1, int edge2, int twist2,
        float smoothThresh, int segments, float taper, float bias);

    DllExport bool BridgePolygons (int face1, int twist1, int face2, int twist2,
        float smoothThresh, int segments, float taper, float bias);

    DllExport bool BridgePolygonClusters (DWORD polyFlag, float smoothThresh, int segments, float taper, float bias,
        int twist1, int twist2);

    DllExport bool BridgeSelectedBorders (DWORD edgeFlag, float smoothThresh, int segments, float taper, float bias,
        int twist1, int twist2);

    DllExport int FindDefaultBridgeTwist (int face1, int face2);

    DllExport bool TurnDiagonal (int face, int diagonal);

    DllExport bool Relax (DWORD vertexFlag, float *softSel, float relaxAmount,
        int relaxIters, bool holdBoundaryPts, bool holdOuterPts, Point3 *delta=NULL);

    DllExport int SelectPolygonsByAngle (int startPolygon, float angle, BitArray & polySel);

    DllExport void CutPrepare ();

    DllExport void CutCleanup ();
};

class MNMapPreserveData: public MaxHeapOperators
{
private:
    Tab<Point3> mFcx, mFcy; // face corner x and y directions.
    Tab<Point3 *> mMapXDir, mMapYDir;
    int mDegreeSum;
    bool mProtectVertexColors;

public:
    MNMapPreserveData () : mDegreeSum(0), mProtectVertexColors(true) { }

    ~MNMapPreserveData () { Clear(); }

    DllExport void Clear ();

    DllExport void Initialize (MNMesh & mm, const MapBitArray & mapsToDo);

    DllExport void Apply (MNMesh & mm, Point3 *pDelta, int numDeltas);
};

class IMNMeshUtilities8 : public BaseInterface
{
    public:
        virtual Interface_ID    GetID() { return IMNMESHUTILITIES8_INTERFACE_ID; }

        virtual bool BridgeTwoEdges(    
            const int   in_Edge1,                       
            const int   in_Edge2,                       
            const int   in_segmentsNumber,              
            const int   in_prevColumnIndex = 0,         
            const DWORD in_smoothingGroup = 0,          
            const MtlID in_materialId = 0,              
            const bool  in_triangleAdded = false) = 0 ; 

        virtual bool BridgeSelectedEdges (  
            const DWORD in_edgeFlag,                
            const float in_smoothThresh,            
            const int   in_segmentsNumber,                      
            const float in_adjacentAngle,           
            const bool  in_reverseTriangle ) = 0;   

        virtual bool ConnectEdges (
            const DWORD in_edgeFlag,                
            const int   in_segments = 2,            
            const int   in_pinch = 0,               
            const int   in_slide = 0 ) = 0 ;        

        virtual void SelectEdgeRingShift( 
            const int   in_ring_shift,              
            BitArray&   io_edgeSel) = 0;            

        virtual void SelectEdgeLoopShift( 
            const int   in_loop_shift,              
            BitArray&   io_edgeSel)=0;              
    
        virtual bool SplitFlaggedVertices (
            const DWORD in_vertexFlag   = MN_SEL,       
            const float in_distance     = 0.0 ) =0;     

        virtual bool SplitFlaggedEdges (
            const DWORD in_edgeFlag = MN_SEL,       
            const float in_distance = 0.0 )= 0;     

        virtual void GetFlippedEdges(  
            BitArray& io_edgeFlip,  
            const bool in_useOnlySelectedEdges = false) = 0;

        virtual bool ChamferEdges ( 
            const DWORD         in_flag = MN_SEL,       
                        MNChamferData *in_mcd   = NULL,         
            const bool          in_open = false) = 0;   
        
        virtual bool ChamferVertices (
            const DWORD         flag    = MN_SEL,       
                        MNChamferData *mcd  = NULL,         
            const bool          in_open = false) = 0 ;  



        virtual bool isFaceCacheInvalid(int faceIndex) = 0;

        virtual void InvalidateVertexCache (int vertex) = 0;
};

#define IMNMESHUTILITIES10_INTERFACE_ID Interface_ID(0x7b1acb31, 0x763982d5)

class IMNMeshUtilities10 : public BaseInterface {
public:
        Interface_ID    GetID() { return IMNMESHUTILITIES10_INTERFACE_ID; }

        virtual bool ChamferEdges ( 
            const DWORD           in_flag,      
                        MNChamferData10 &in_mcd,            
            const bool            in_open,
            const int             in_segments) = 0; 
    
        virtual bool ConstrainDeltaToNormals (Tab<Point3> *deltaIn, Tab<Point3> *deltaOut) = 0;

};

#define IMNMESHUTILITIES13_INTERFACE_ID Interface_ID(0x4dfa07c3, 0x637941b0)

class IMNMeshUtilities13 : public BaseInterface {
public:
    Interface_ID    GetID() { return IMNMESHUTILITIES13_INTERFACE_ID; }

    virtual bool FindLoopVertex(BitArray &hitSel, const BitArray &curSel) = 0;

    virtual bool FindLoopOrRingEdge(BitArray &hitSel, const BitArray &curSel) = 0;

    virtual bool FindLoopFace(BitArray &hitSel, const BitArray &curSel) = 0;
};