This reference page is linked to from the following overview topics: SDK Change Details, Incremental Improvements, Modeling, Meshes, Mesh Related Classes, MNMesh Edges, Creating Pipeline-Friendly Meshes, Hardware Mesh Support, MNMesh Note on Debugging.

Detailed Description

The MNMesh class is provided for temporary use by plug-ins, to help with complex topology-based modifications to Meshes.

It has certain capabilities, such as the ability to recognize faces with more than 3 sides, that are useful in some applications. It is not suitable for use as a pipeline object. All methods of this class are implemented by the system.

MNMesh has a winged-edge structure and a highly interlinked topology. This is very useful for some modifiers, but requires far more memory and processing time than an equivalent normal mesh. It's convenient for the programmer, but may be sluggish for the user.

Although some methods can be a bit slow, none of them are non-linear in the amount of time they take. Even the tessellation algorithms, which can as much as quadruple the size of the meshes, operate locally, vertex by vertex, so they are order-of-n algorithms.

MNMesh derives from FlagUser and supports the flags listed at MNMesh Flags.

{MNMesh Note on Debugging}

See also:: FlagUser, MNFace, MNVert, MNEdge, MNMap, PerData, MNMeshBorder, Mesh, BitArray, Tab, MNMeshBorder,

#include <mnmesh.h>

Inheritance diagram for MNMesh:

[legend]

List of all members.

Public Member Functions
DllExport void	FacePointBary (int ff, Point3 &p, Tab< float > &bary)
	Finds "Generalized Barycentric Coordinates" for the point given.
DllExport void	FindFaceBaryVector (int face, int vertIndex, Point3 &vector, Tab< float > &tBary)
Constructors and Destructors
	MNMesh ()
	Initializes the MNMesh with no components and the default flags.
	MNMesh (const Mesh &from)
	Constructor.
	MNMesh (const MNMesh &from)
	Copy constructor.
DllExport	~MNMesh ()
	Destructor.
Allocation and Initialization Methods
void	DefaultFlags ()
	Clears all flags.
DllExport void	Init ()
	The data members are initialized as follows:
DllExport void	VAlloc (int num, bool keep=TRUE)
	Allocates and inits the specified number of MNVerts.
DllExport void	VShrink (int num=-1)
	Shrinks the nv_alloc size of the MNVert array to the specified size.
DllExport void	freeVEdge ()
	Deallocates any MNEdges in the vedg table and sets the vedg pointer to NULL.
DllExport void	VEdgeAlloc ()
	Allocates the vedg array.
DllExport void	freeVFace ()
	Deallocates the vfac array.
DllExport void	VFaceAlloc ()
	Allocates the vfac array.
DllExport void	EAlloc (int num, bool keep=TRUE)
	Allocates the MNEdge data array e with the specified size.
DllExport void	EShrink (int num=-1)
	Reduces the ne_alloc size of the MNEdge data array e to the specified number of elements.
DllExport void	FAlloc (int num, bool keep=TRUE)
	Allocates the MNFace array f with the specified size.
DllExport void	FShrink (int num=-1)
	Reduces the nf_alloc size of the MNFace data array f to the specified number of elements.
DllExport void	MAlloc (int num, bool keep=TRUE)
	Allocates the MNMap array m with the specified size.
DllExport void	MShrink (int num=-1)
	Reduces the nm_alloc size of the MNMap data array m to the specified number of elements.
Component Access Functions
int	VNum () const
	Returns the number of vertices.
MNVert *	V (int i) const
	Returns a pointer to the i'th MNVert.
Point3 &	P (int i) const
	Returns the point in the i'th MNVert.
int	ENum () const
	Returns the number of edges.
MNEdge *	E (int i) const
	Returns a pointer to the i'th MNEdge.
int	FNum () const
	Returns the number of faces.
MNFace *	F (int i) const
	Returns a pointer to the i'th MNFace.
int	MNum () const
	Internal.
DllExport int	TriNum () const
	Number of triangles.
Mapping Methods
DllExport MNMap *	M (int mapChannel) const
	This accessor accepts a value in the range -NUM_HIDDENMAPS to MNum().
DllExport void	SetMapNum (int mpnum)
	Allocates and initializes the specified number of MNMap elements in the m array.
DllExport void	InitMap (int mapChannel)
	Allocates and initializes basic planar map, or a white map for the vertex color channel.
DllExport void	ClearMap (int mapChannel)
	Clears and frees the specified map channel, setting the MN_DEAD flag.
DllExport UVVert	MV (int mapChannel, int i) const
	Returns the specified UVVert from the specified mapping channel.
DllExport MNMapFace *	MF (int mapChannel, int i) const
	Returns a pointer to the specified MNMapFace from the specified mapping channel.
DllExport UVVert	ExtrapolateMapValue (int face, int edge, Point3 &pt, int mapChannel)
	Returns the total number of triangles; this is a sum of the number of triangles in each face that does not have the MN_DEAD flag set.
DllExport bool	SeparateMapVerticesInFaceCluster (MNFaceClusters &fclust, int clusterID)
	Detaches the texture vertices on the border edges of the fclust.
DllExport bool	IsEdgeMapSeam (int mapChannel, int edge)
	Returns whether an edge is a seam or not.
DllExport void	FindEdgeListMapVerts (const Tab< int > &lp, Tab< int > &mv, int mapChannel)
	Returns map verts for both ends of each edge (from f1's perspective) (Very useful for creating new faces at borders.) mv[j*2] is the map vertex corresponding to edge j's v1.
Per-Vertex Data
DllExport void	setNumVData (int ct, BOOL keep=FALSE)
	Sets the specified number of vertex data elements.
int	VDNum () const
	Returns the number of vertex data channels maintained by this MNMesh.
DllExport BOOL	vDataSupport (int vdChannel) const
	Returns TRUE if the specified channel of vertex data is available for this MNMesh; otherwise FALSE.
DllExport void	setVDataSupport (int vdChannel, BOOL support=TRUE)
	Sets if the specified channel of vertex data is supported by this MNMesh.
void *	vertexData (int vdChannel) const
	Returns a pointer to the vertex data for the specified channel or NULL if the channel is not supported.
float *	vertexFloat (int vdChannel) const
	Returns a pointer to the floating point vertex data for the specified channel of this mesh or NULL if the channel is not supported.
DllExport void	freeVData (int vdChannel)
	Deletes (deallocates) the vertex data for the specified channel.
DllExport void	freeAllVData ()
	Deallocates the vertex data from all channels and sets the number of supported channels to 0.
Vertex Weight Methods
float *	getVertexWeights ()
	Returns a pointer to the floating point vertex weight data.
void	SupportVertexWeights ()
	Sets the channel support for the vertex weights channel (VDATA_WEIGHT).
void	freeVertexWeights ()
	Frees (deallocates) the vertex weight channel data.
float *	getVSelectionWeights ()
	Returns a pointer to the floating point vertex selection weight data.
void	SupportVSelectionWeights ()
	Sets the channel support for the vertex weights channel (VDATA_SELECT).
void	freeVSelectionWeights ()
	Frees (deallocates) the vertex selection weight channel data.
Per-Edge Data
DllExport void	setNumEData (int ct, BOOL keep=FALSE)
	Sets the specified number of edge data elements.
int	EDNum () const
	Returns the number of edge data channels maintained by this MNMesh.
DllExport BOOL	eDataSupport (int edChannel) const
	Returns TRUE if the specified channel of edge data is available for this MNMesh; otherwise FALSE.
DllExport void	setEDataSupport (int edChannel, BOOL support=TRUE)
	Sets if the specified channel of edge data is supported by this MNMesh.
void *	edgeData (int edChannel) const
	Returns a pointer to the edge data for the specified channel or NULL if the channel is not supported.
float *	edgeFloat (int edChannel) const
	Returns a pointer to the floating point edge data for the specified channel of this MNMesh or NULL if the channel is not supported.
DllExport void	freeEData (int edChannel)
	Deletes (deallocates) the edge data for the specified channel.
DllExport void	freeAllEData ()
	Deallocates the edge data from all channels and sets the number of supported channels to 0.
Edge Knot Methods
float *	getEdgeKnots ()
	Returns a pointer to the floating point edge knot data.
void	SupportEdgeKnots ()
	Sets the channel support for the edge knot channel (EDATA_KNOT).
void	freeEdgeKnots ()
	Frees (deallocates) the edge knot channel data.
Vertex Face and Edge Methods
DllExport void	VClear (int vv)
	Clears and frees the flags and face/edge lists for the specified vertex.
DllExport void	VInit (int vv)
	Initializes the specified MNVert, clearing its flags and emptying its face & edge lists (if vfac & edg are allocated).
DllExport int	VFaceIndex (int vv, int ff, int ee=-1)
	Returns the index of face ff in the vfac[vv] table.
DllExport int	VEdgeIndex (int vv, int ee)
	This method is available in release 3.0 and later only.
void	VDeleteEdge (int vv, int ee)
	This method is available in release 3.0 and later only.
DllExport void	VDeleteFace (int vv, int ff)
	This method is available in release 3.0 and later only.
DllExport void	VReplaceEdge (int vv, int oe, int ne)
	This method is available in release 3.0 and later only.
DllExport void	VReplaceFace (int vv, int of, int nf)
	This method is available in release 3.0 and later only.
DllExport void	CopyVert (int nv, int ov)
	This method is available in release 3.0 and later only.
DllExport void	MNVDebugPrint (int vv)
	This method is available in release 3.0 and later only.
Mesh Building Functions
DllExport int	NewTri (int a, int b, int c, DWORD smG=0, MtlID mt=0)
	Creates a new tri-face.
DllExport int	NewTri (int *vv, DWORD smG=0, MtlID mt=0)
	Creates a new face of degree 3.
DllExport int	NewQuad (int a, int b, int c, int d, DWORD smG=0, MtlID mt=0)
	This method will create a new quad.
DllExport int	NewQuad (int *vv, DWORD smG=0, MtlID mt=0)
	This method will create a new quad.
DllExport int	NewFace (int initFace, int degg=0, int vv=NULL, bool vis=NULL, bool *sel=NULL)
	This method creates a (single) new face with the characteristics given.
DllExport int	CreateFace (int degg, int *vv)
	Creates a new face, using the vertices given.
DllExport int	AppendNewFaces (int nfnum)
	Appends the specified number of MNFaces to f.
DllExport void	setNumFaces (int nfnum)
	Sets the specified number of MNFaces allocated in f.
DllExport int	RegisterEdge (int v1, int v2, int f, int fpos)
	Edge creation tool.
DllExport int	SimpleNewEdge (int v1, int v2)
	Edge creation tool.
DllExport int	NewEdge (int v1, int v2, int f, int fpos)
	Edge creation tool.
DllExport int	AppendNewEdges (int nenum)
	Appends the specified number of edges.
DllExport void	setNumEdges (int nenum)
	Sets the number of MNEdges allocated in e.
DllExport int	NewVert (Point3 &p)
	Creates a new vertex (increasing numv) and sets it to the specified point.
DllExport int	NewVert (Point3 &p, int vid)
	This method is available in release 3.0 and later only.
DllExport int	NewVert (int vid)
	Creates a new vertex and initializes it to location, flags and other characteristics of vertex vid.
DllExport int	NewVert (int v1, int v2, float prop)
	Creates a new vertex which is a linear combination of two existing vertices.
DllExport int	AppendNewVerts (int nvnum)
	Appends the specified number of MNVerts.
DllExport void	setNumVerts (int nvnum)
	Sets the number of verts, allocating if needed.
DllExport int	InsertSpur (int face, int vertIndex, Tab< int > *ptMapVertArray=NULL)
	Creates a spur on the face at vertexIndex.
Component Removal Routines
To delete a component set the appropriate MN_XXX_DEAD flags (e.g. MN_EDGE_DEAD) and use following routines. These all have O(N) complexity.
DllExport void	CollapseDeadVerts ()
	Removes all MNVerts with the MN_DEAD flag from the list of vertices.
DllExport void	CollapseDeadEdges ()
	Removes all MNEdges with the MN_DEAD flag from the list of edges.
DllExport void	CollapseDeadFaces ()
	Removes all MNFaces with the MN_DEAD flag from the list of faces.
DllExport void	CollapseDeadStructs ()
	Performs all 5 of the above collapse functions, safely removing all unused components from this mesh.
DllExport void	Clear ()
	Reinitializes all verts, faces, and edges, freeing the data members of these components, but not freeing the vertex, edge, and face arrays themselves.
DllExport void	ClearAndFree ()
	Deletes everything and frees all relevant memory.
DllExport void	freeVerts ()
	Deletes the MNVert array and frees any corresponding vertex data.
DllExport void	freeEdges ()
	Deletes the MNEdge array and frees and corresponding edge data.
DllExport void	freeFaces ()
	Deletes the MNFace array.
DllExport void	freeMap (int mapChannel)
	Deletes the MNMap on the specified map channel.
DllExport void	freeMaps ()
	Deletes and frees all the MNMaps.
DllExport bool	RemoveVertex (int vertex)
DllExport bool	RemoveSpur (int spur)
DllExport void	DeleteFlaggedFaces (DWORD deathflags, DWORD nvCopyFlags=0x0)
	Deletes faces with any of the death flags set, as well as delete vertices and edges surrounded by faces with death flags, and correct the mesh components remaining.
DllExport void	RemoveEdge (int edge)
	Kills the edge and joins the faces on either side.
DllExport void	EliminateCollinearVerts ()
	This routine scans through a mesh from which invisible edges have been removed, looking for vertices that essentially seem to lie in the middle of edges.
DllExport void	EliminateCoincidentVerts (float thresh=MNEPS)
	This merges vertices that lie extremely close together, similar to what's done in Edit Mesh's Weld function, but it only affects vertices that are joined by an edge.
Bulk Flag Clearing and Setting Functions
void	ClearVFlags (DWORD fl)
	Clears all specified flag bits in all MNVerts.
void	ClearEFlags (DWORD fl)
	Clears all specified flag bits in all MNEdges.
void	ClearFFlags (DWORD fl)
	Clears all specified flag bits in all MNFaces.
DllExport void	PaintFaceFlag (int ff, DWORD fl, DWORD fenceflags=0x0)
	Recursively sets flag on given face and all faces connected to it.
DllExport int	PropegateComponentFlags (int slTo, DWORD flTo, int slFrom, DWORD flFrom, bool ampersand=FALSE, bool set=TRUE)
	This allows the developer to set flags in one type of component based on what the nearby flags of another type of component are.
DllExport void	UpdateBackfacing (GraphicsWindow *gw, bool force)
	Updates the MN_BACKFACING flag in all components based on the specified view.
Selection Methods
DllExport void	VertexSelect (const BitArray &vsel)
	Selects or deselects the vertices as specified by on bits in the given bit array.
DllExport void	EdgeSelect (const BitArray &esel)
	Selects or deselects the edges as specified by on bits in the given bit array.
DllExport void	FaceSelect (const BitArray &fsel)
	Selects or deselects the faces as specified by on bits in the given bit array.
bool	getVertexSel (BitArray &vsel)
	Fills the given bit array with the current vertex selection state.
bool	getEdgeSel (BitArray &esel)
	Fills the given bit array with the current edge selection state.
bool	getFaceSel (BitArray &fsel)
	Fills the given bit array with the current face selection state.
DllExport void	SelectEdgeLoop (BitArray &edgeSel)
	Using the current edge selection this returns the original selection and the edge loop defined by those selections.
DllExport void	SelectEdgeRing (BitArray &edgeSel)
	Using the current edge selection this returns the original selection and the ring loop defined by those selections.
DllExport BitArray	VertexTempSel (DWORD fmask=MN_DEAD\|MN_SEL, DWORD fset=MN_SEL)
	Gets the current vertex selection, based on the current selection level.
Getting Components by Flag
DllExport bool	getVerticesByFlag (BitArray &vset, DWORD flags, DWORD fmask=0x0)
	Creates a BitArray of all vertices using the specified flags.
DllExport bool	getEdgesByFlag (BitArray &eset, DWORD flags, DWORD fmask=0x0)
	Creates a BitArray of all edges using the specified flags.
DllExport bool	getFacesByFlag (BitArray &fset, DWORD flags, DWORD fmask=0x0)
	Creates a BitArray of all faces using the specified flags.
DllExport void	ElementFromFace (int ff, BitArray &fset)
	Sets bits for all faces in the same "element", or connected component, with face ff.
DllExport void	BorderFromEdge (int ee, BitArray &eset)
	Takes a one-sided edge and sets the bits representing this edge's "border".
Edge Visibility and Selection Methods
DllExport void	SetEdgeVis (int ee, BOOL vis=TRUE)
	This not only sets the edge's MN_EDGE_INVIS flag, it also sets the visedg state of the faces on either side.
DllExport void	SetEdgeSel (int ee, BOOL sel=TRUE)
	This not only sets the edge's MN_SEL flag, it also sets the edgsel state of the faces on either side.
Mesh Compatibility Functions
void	SetFromTri (const Mesh &from)
	Clears out all current information, and copies in new faces and vertices from the `from` argument.
DllExport void	AddTri (const Mesh &from)
	Adds vertices and faces in "from" to current MNMesh.
DllExport void	OutToTri (Mesh &tmesh)
	Outputs current MNMesh into the mesh given.
Mesh Computation Functions
DllExport void	FillInMesh ()
	If this mesh does not have the MN_MESH_FILLED_IN flag, this method completely recomputes all combinatorial information.
DllExport void	FillInFaceEdges ()
	Fills in the faces' edge arrays based on the edge list.
DllExport void	FillInVertEdgesFaces ()
	Fills in the vertex edge and face lists based on the edge list.
DllExport bool	EliminateBadVerts (DWORD flag=0)
	A "bad" vertex in this context is one which is shared between two distinct boundaries for this mesh.
DllExport void	OrderVerts ()
	This routine organizes the face and edge lists of each vertex such that going counterclockwise around the vertex (with the surface normal pointing up), you'll encounter edg[0], fac[0], edg[1], fac[1], etc, ending in either the last face if the vertex is not on a boundary or the last edge if the vertex is on a boundary.
DllExport void	OrderVert (int vid)
	This routine organizes the face and edge lists of the specified vertex such that going counterclockwise around the vertex (with the surface normal pointing towards you), you'll encounter edg[0], fac[0], edg[1], fac[1], etc, ending in either the last face if the vertex is not on a boundary or the last edge if the vertex is on a boundary.
Mesh Triangulation Routines
DllExport void	Triangulate ()
	Converts a MN_MESH_NONTRI mesh, with polygon faces and possibly hidden vertices, into a completely triangulated mesh, wherein all faces have degree 3.
DllExport void	TriangulateFace (int ff)
	Triangulates the specified face, splitting it into as many faces as are needed (deg-2+hdeg*2) to represent all the triangles.
DllExport int	DivideFace (int ff, Tab< float > &bary)
	Divides a face by creating a point in the face's interior and creating an edge from that point to each of the face's vertices.
Bounding Box Methods
DllExport void	FaceBBox (int ff, Box3 &bbox)
	Finds the bounding box of all vertices and hidden vertices used by face ff.
DllExport void	BBox (Box3 &bbox, bool targonly=FALSE)
	Calculates the bounding box of the vertices & hidden vertices of this mesh.
DllExport Box3	getBoundingBox (Matrix3 *tm=NULL, bool targonly=FALSE)
	Retrieves a bounding box for the MNMesh.
Targeting Methods
DllExport int	TargetVertsBySelection (int selLevel)
	Sets vertex MN_TARG flags based on the existing MN_SEL flags.
DllExport int	TargetEdgesBySelection (int selLevel)
	Sets edge MN_TARG flags based on the existing MN_SEL flags.
DllExport int	TargetFacesBySelection (int selLevel)
	Sets face MN_TARG flags based on the existing MN_SEL flags.
DllExport void	DetargetVertsBySharpness (float sharpval)
	Clears the MN_TARG flag on vertices representing relatively flat areas, keeping the flag on vertices at sharper corners.
Face-Center methods
DllExport void	ComputeCenters (Point3 *ctr, bool targonly=FALSE)
	Finds the centers of all the faces, using repeated calls to ComputeCenter.
DllExport void	ComputeCenter (int ff, Point3 &ctr)
	Finds the center of face ff by finding the average of all its vertices.
DllExport void	ComputeNormal (int ff, Point3 &normal, Point3 *ctr=NULL)
	Computes a "balanced" normal, in that the normal takes the contribution of all vertices equally.
DllExport void	ComputeSafeCenters (Point3 *ctr, bool targonly=FALSE, bool detarg=FALSE)
	Finds the "safe" centers of all the faces, using repeated calls to ComputeSafeCenter.
DllExport bool	ComputeSafeCenter (int ff, Point3 &ctr)
	Finds the "safe" center of face ff, if possible.
Triangulation-of-polygon Methods
DllExport void	RetriangulateFace (int ff)
	Throws out the current triangulation for face ff and computes a new one.
DllExport void	FindDiagonals (int ff, int *diag)
	Finds a diagonal of face ff that does not include any hidden vertices.
DllExport void	FindDiagonals (int deg, int vv, int diag)
	This method finds diagonals for this sequence of vertices, creating a triangulation for the polygon they form.
DllExport void	BestConvexDiagonals (int ff, int *diag=NULL)
	If the given face is convex, this will often produce a better diagonals than RetriangulateFace would.
DllExport void	BestConvexDiagonals (int deg, int vv, int diag)
	Uses a triangulation scheme optimized for convex polygons to find a set of diagonals for this sequence of vertices, creating a triangulation for the polygon they form.
DllExport bool	SetDiagonal (int ff, int d1, int d2)
Unification Methods
These methods turn triangle meshes into polygon meshes
DllExport void	MakePolyMesh (int maxdeg=0, BOOL elimCollin=TRUE)
	Unifies triangles into polygons across invisible edges.
DllExport void	MakeConvexPolyMesh (int maxdeg=0)
	Turns a mesh with triangle faces into a mesh with (fewer) convex polygon faces by removing all hidden edges that aren't necessary to maintain convexity.
Normal methods
DllExport int	FindEdgeFromVertToVert (int vrt1, int vrt2)
	Some of these methods do not make use of user-specified normals or smoothing groups.
DllExport void	GetVertexSpace (int vrt, Matrix3 &tm)
	Chooses a suitable "local space", and sets tm's rotation to match that space.
DllExport Point3	GetVertexNormal (int vrt)
	Returns the surface normal at the vertex vrt.
DllExport Point3	GetEdgeNormal (int ed)
	Returns the surface normal at the edge ed.
DllExport Point3	GetFaceNormal (int fc, bool nrmlz=FALSE)
	Returns the surface normal of face fc.
Point3	GetEdgeNormal (int vrt1, int vrt2)
	This merely combines GetEdgeNormal (int ed) with FindEdge (int vrt1, int vrt2).
DllExport float	EdgeAngle (int ed)
	Computes the angle at the given edge.
DllExport void	FlipNormal (int faceIndex)
	Flips the normal of the specified face, as well as the corresponding map faces in active maps.
DllExport void	checkNormals (BOOL illum)
	This method can be used to build the normals and allocate RVert space only if necessary.
DllExport void	buildNormals ()
	This method resolves the normals on the RVertex array.
DllExport void	buildRenderNormals ()
	This method is similar to buildNormals() above, but ignores the material index (mtlIndex).
DllExport bool	FlipElementNormals (DWORD flag=MN_SEL)
	Flips the normals of the specified elements in the mesh.
DllExport bool	FlipFaceNormals (DWORD faceFlag)
	This flips the face normals of the tagged faces and also reverses the face winding.
Smoothing Group Handling
DllExport void	Resmooth (bool smooth=TRUE, bool targonly=FALSE, DWORD targmask=~0x0)
	Applies new smoothing (or removes smoothing groups) from selected areas of the MNMesh.
DllExport DWORD	CommonSmoothing (bool targonly=FALSE)
	Finds what smoothing groups, if any, are common to all faces in this MNMesh.
DllExport DWORD	GetNewSmGroup (bool targonly=FALSE)
	Produces a single smoothing group that is not currently used in the MNMesh.
DllExport MtlID	GetNewMtlID (bool targonly=FALSE)
	Produces the lowest material ID not used in any faces in the MNMesh.
DllExport DWORD	GetOldSmGroup (bool targonly=FALSE)
	Returns a smoothing group that is currently used somewhere in the mesh, or returns zero if all faces have no smoothing.
DllExport DWORD	GetAllSmGroups (bool targonly=FALSE)
	Find all smoothing groups used in this mesh.
DllExport DWORD	FindReplacementSmGroup (int ff, DWORD os)
	Finds available smoothing groups you can use to replace the given smoothing group without messing up the mesh's shading.
DllExport void	PaintNewSmGroup (int ff, DWORD os, DWORD ns)
	Recursively replaces the old smoothing group with the new smoothing group.
DllExport bool	SeparateSmGroups (int v1, int v2)
	Changes the smoothing groups on faces using v2 so that they are distinct from any smoothing groups on faces using v1.
DllExport void	AutoSmooth (float angle, BOOL useSel, BOOL preventIndirectSmoothing)
	Applies new smoothing groups to the whole mesh or to selected faces based on angles between faces.
Fence Methods
DllExport void	FenceMaterials ()
	Thes methods make fences for the MNMesh::SabinDoo() algorithm.
DllExport void	FenceSmGroups ()
	Sets the MN_EDGE_NOCROSS flag on all edges that lie between faces with exclusive smoothing groups.
DllExport void	FenceFaceSel ()
	Sets the MN_EDGE_NOCROSS flag on all edges that lie between selected & non-selected faces.
DllExport void	FenceOneSidedEdges ()
	Sets the MN_EDGE_NOCROSS flag on all edges that are on the boundary.
DllExport void	FenceNonPlanarEdges (float thresh=.9999f, bool makevis=FALSE)
	Sets MN_EDGE_NOCROSS flags on edges between faces that aren't in the same plane.
DllExport void	SetMapSeamFlags ()
	Sets the MN_EDGE_MAP_SEAM on all edges that are "seams" for any active map(s).
DllExport void	SetMapSeamFlags (int mapChannel)
	Sets the MN_EDGE_MAP_SEAM on all edges that are "seams" for the specified map(s).
Face Point Functions
These functions are for querying details about a point on a face.
DllExport int	FindFacePointTri (int ff, Point3 &pt, double bary, int tri)
	Finds the sub-triangle and (optionally) barycentric coordinates within that triangle of a point that lies on this face.
DllExport UVVert	FindFacePointMapValue (int ff, Point3 &pt, int mapChannel)
	This method is available in release 3.0 and later only.
Hole Fixing Functions
DllExport void	GetBorder (MNMeshBorder &brd, int selLevel=MNM_SL_OBJECT, DWORD targetFlag=MN_SEL)
	Finds border loops composed of all one-sided edges.
DllExport void	FillInBorders (MNMeshBorder *b=NULL)
	Fills in all the borders of a mesh.
DllExport void	FindOpenRegions ()
	Scans mesh to determine what parts of it are open or closed.
Doubled Mapping Vertex Functions
Double mapped vertexes are individual map vertices that are used to correspond to different regular vertices. For example, the standard map on the box object uses the same mapping vertices on the top as on the bottom. This can be a problem if the user wants to change the map in one region, but not the other. It also causes problems in NURMS MeshSmooth, where the user can change weights in one region but not in the other. So the following methods detect and fix such vertices.
DllExport BOOL	CheckForDoubledMappingVerts ()
	This method is a debugging tool.
DllExport void	EliminateDoubledMappingVerts ()
	Eliminates double mapped vertices in linear time.
Isolated Mapping Vertex Functions
Isolated mapping vertices are vertexes that aren't used by any mapping faces.
DllExport void	EliminateIsoMapVerts ()
	Deletes isolated mapping vertices.
DllExport void	EliminateIsoMapVerts (int mapChannel)
	Deletes isolated mapping vertices on a specific channel.
Operators
DllExport MNMesh &	operator= (const MNMesh &from)
	Assignment operator.
DllExport MNMesh &	operator+= (const MNMesh &from)
	Union operator.
Debugging Functions
Uses DebugPrint to print out the entire MNMesh to the Debug Results window in DevStudio. This can be useful for tracking down bugs. Be careful not to leave MNDebugPrint calls in your final build; they will slow down your effect to no purpose. Parameters: bool triprint=FALSE Controls whether or not triangulation information is printed out for each face. Usually this information isn't desired.
DllExport void	MNDebugPrint (bool triprint=FALSE)
DllExport void	MNDebugPrintVertexNeighborhood (int vv, bool triprint=FALSE)
	Uses DebugPrint to print out information about all the edges, faces, and vertices in the immediate vicinity of vertex vv.
DllExport bool	CheckAllData ()
	Thoroughly checks a MNMesh to make sure that no components refer to dead components; that when one component refers to another, the other refers back to the first; and that orientation is correctly matched between faces and edges.
Splitting and Subdividing Method
DllExport int	SplitTriEdge (int ee, float prop=.5f, float thresh=MNEPS, bool neVis=TRUE, bool neSel=FALSE)
	Creates a new vertex in the middle of an edge, splitting the edge into two edges.
DllExport int	SplitTriFace (int ff, double *bary=NULL, float thresh=MNEPS, bool neVis=TRUE, bool neSel=FALSE)
	Adds a vertex somewhere in a triangle face, and also adds edges from that vertex to each of the corners, splitting the face into 3 smaller triangle faces.
DllExport void	SplitTri6 (int ff, double bary=NULL, int nv=NULL)
	This is another way to subdivide a face on a triangular mesh into sub-triangles.
DllExport int	SplitEdge (int ee, float prop=.5f)
	Creates a new vertex somewhere in the middle of an edge, splitting the edge into two edges.
DllExport int	SplitEdge (int ee, float prop, Tab< int > *newTVerts)
	This new SplitEdge variant allows you to recover information about the new map vertices created at the point where the edge is split.
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)
	Splits an edge that is specified from the face level, and splits off triangles from the adjacent faces.
DllExport int	IndentFace (int ff, int ei, int nv, int *ne=NULL, bool nevis=TRUE, bool nesel=FALSE)
	Uses a new vertex to "indent" one of the sides of the face.
DllExport void	SeparateFace (int ff, int a, int b, int &nf, int &ne, bool neVis=FALSE, bool neSel=FALSE)
	This routine takes a larger face and divides it into two smaller faces, creating a new edge in the process.
DllExport bool	Slice (Point3 &N, float off, float thresh, bool split, bool remove, bool flaggedFacesOnly=false, DWORD faceFlags=MN_SEL)
	Slices the MNMesh along a specified plane, splitting edges and faces as needed to divide faces into those above and those below the plane.
DllExport bool	SplitFlaggedVertices (DWORD flag=MN_SEL)
	Splits the flagged vertices into a clone for each face using the vertex.
DllExport bool	SplitFlaggedEdges (DWORD flag=MN_SEL)
	"Splits" edges by breaking vertices on two or more flagged edges into as many copies as needed.
DllExport bool	SplitFacesUsingBothSidesOfEdge (DWORD edgeFlag=0x0)
DllExport void	MultiDivideEdge (int edge, int segments)
	Splits an edge into multiple edges.
DllExport void	MakeConvex ()
	Calls MakeFaceConvex() on all (non-dead) faces, producing a mesh with 100% convex faces.
DllExport void	MakeFaceConvex (int ff)
	Makes face ff convex, essentially by chopping off corners.
DllExport void	RestrictPolySize (int maxdeg)
	Subdivides polygons as needed so that no polygon has degree larger than maxdeg.
DllExport void	MakePlanar (float planarThresh)
	Makes all faces planar, within the angle threshold given, by subdividing them as necessary.
DllExport void	MakeFacePlanar (int ff, float planarThresh)
	Makes the specified face planar by subdividing if necessary.
Welding Functions
DllExport bool	WeldVerts (int a, int b)
	Welds vertices a and b, correcting the mesh topology to match.
DllExport bool	WeldEdge (int ee)
	Welds the endpoints of edge ee, correcting the mesh topology to match.
DllExport bool	WeldBorderVerts (int v1, int v2, Point3 *destination)
	Welds vertices v1 and v2 together.
DllExport bool	WeldBorderEdges (int e1, int e2)
	Welds the specified border edges together.
DllExport bool	WeldBorderVerts (float thresh, DWORD flag=MN_SEL)
	Welds the specified border vertices together.
DllExport bool	WeldOpposingEdges (DWORD edgeFlag)
	Welds pairs of one-sided edges between the same two vertices.
Tessellation Methods
DllExport void	TessellateByEdges (float bulge, MeshOpProgress *mop=NULL)
	This is a tessellation routine similar to AndersonDo().
DllExport bool	AndersonDo (float interp, int selLevel, MeshOpProgress *mop=NULL, DWORD subdivFlags=0)
	It breaks every MNFace into deg new faces with four sides.
DllExport void	TessellateByCenters (MeshOpProgress *mop=NULL)
	Note that this algorithm roughly triples the size of the MNMesh.
DllExport void	SabinDoo (float interp, int selLevel, MeshOpProgress mop=NULL, Tab< Point3 > offsets=NULL)
	Note that this algorithm roughly triples the size of the MNMesh.
DllExport void	SabinDooVert (int vid, float interp, int selLevel, Point3 ctr, Tab< Point3 > offsets=NULL)
	This applies the Sabin-Doo tessellation technique to a single vertex.
DllExport void	CubicNURMS (MeshOpProgress mop=NULL, Tab< Point3 > offsets=NULL, DWORD subdivFlags=0)
	Non-uniform rational mesh smooth.
Boolean Methods
DllExport void	PrepForBoolean ()
	Prepares a MNMesh for a Boolean operation.
DllExport bool	BooleanCut (MNMesh &m2, int cutType, int fstart=0, MeshOpProgress *mop=NULL)
	BooleanCut uses the same techniques as MakeBoolean to cut the faces of this with the faces of m2.
DllExport bool	MakeBoolean (MNMesh &m1, MNMesh &m2, int type, MeshOpProgress *mop=NULL)
	Makes this MNMesh into a Boolean result of the given MNMeshes.
Connection Methods
DllExport void	Connect (MNMeshBorder &borderList, int segs, float tension, bool sm_bridge, bool sm_ends, Tab< int > *vsep=NULL)
	Connect automatically figures out which loops in the given MNMeshBorder would make good candidates for connecting, and calls ConnectLoop on them all to connect them.
DllExport void	ConnectLoops (Tab< int > &loop1, Tab< int > &loop2, int segs, float tension, DWORD smGroup, MtlID mat, bool sm_ends)
	Connects two border loops by filling in new geometry between them, as is done in the Connect compound object.
DllExport bool	ConnectEdges (DWORD edgeFlag, int segments=2)
	Connect the marked edges of a polygon if they are opposing.
DllExport bool	ConnectVertices (DWORD vertexFlag)
	Connects tagged vertices across a polygon.
Face and Vertex Cloning Operations
DllExport void	CloneVerts (DWORD cloneFlag=MN_SEL, bool clear_orig=TRUE)
	Clones flagged vertices, creating new vertices that aren't used by any faces.
DllExport void	CloneFaces (DWORD cloneFlag=MN_SEL, bool clear_orig=TRUE)
	Clones the flagged faces, as well as all the vertices and edges that are used by the faces.
DllExport void	CopyBasics (const MNMesh &from, bool copyEdges=false)
	Copies bare geometry only - no per-vertex data, maps, or normals.
Plane Methods
DllExport bool	MakeFlaggedPlanar (int selLev, DWORD flag=MN_SEL, Point3 *delta=NULL)
	Moves the flagged components into their "average plane".
DllExport bool	MoveVertsToPlane (Point3 &norm, float offset, DWORD flag=MN_SEL, Point3 *delta=NULL)
	Projects the flagged vertices into the specified plane, or produces an array of offsets which would do so.
Detach Operations
DllExport bool	DetachFaces (DWORD flag=MN_SEL)
	Detaches specified faces to a separate element, cloning vertices and edges as necessary on the boundary between flagged and unflagged faces.
DllExport bool	DetachElementToObject (MNMesh &nmesh, DWORD fflags=MN_SEL, bool delDetached=true)
	Detaches specified faces (and related vertices and edges) to a new MNMesh.
Extrusion Methods
DllExport bool	ExtrudeFaceClusters (MNFaceClusters &fclust)
	Performs the topological component of an extrusion on all face clusters.
DllExport bool	ExtrudeFaceCluster (MNFaceClusters &fclust, int cl)
	Performs the topological component of an extrusion on the specified face cluster.
DllExport bool	ExtrudeFaces (DWORD flag=MN_SEL)
	Performs the topological component of an extrusion on each flagged face individually.
DllExport void	GetExtrudeDirection (MNChamferData *mcd, DWORD faceFlag)
DllExport void	GetExtrudeDirection (MNChamferData mcd, MNFaceClusters fclust=NULL, Point3 *clustNormals=NULL)
	Finds the direction vectors for the geometric component of an extrusion after the topological component has been completed.
DllExport bool	ExtrudeVertices (DWORD vertexFlag, MNChamferData *pMCD, Tab< Point3 > &tUpDir)
	This computes the new extruded vertices from the selected vertices using the using the current vertex selection.
DllExport bool	ExtrudeEdges (DWORD edgeFlag, MNChamferData *pMCD, Tab< Point3 > &tUpDir)
	Same as ExtrudeVertices() but is applied to the edges.
DllExport bool	ExtrudeFaceClusterAlongPath (Tab< Matrix3 > tFrenets, MNFaceClusters &fclust, int clusterID, bool align)
	Extrudes a group of faces along a path defined by tFrenets.
Coloring Methods
DllExport bool	SetVertColor (UVVert clr, int mapChannel, DWORD flag=MN_SEL)
	Sets vertex colors for the specified vertices.
DllExport bool	SetFaceColor (UVVert clr, int mapChannel, DWORD flag=MN_SEL)
	Sets vertex colors for the specified faces.
Chamfer Operations
DllExport bool	ChamferVertices (DWORD flag=MN_SEL, MNChamferData *mcd=NULL)
	Performs the topological component of a vertex chamfer on the flagged vertices, and provides the data needed to do the geometric component.
DllExport bool	ChamferEdges (DWORD flag=MN_SEL, MNChamferData *mcd=NULL)
	Performs the topological component of an edge chamfer on the flagged edges, and provides the data needed to do the geometric component.
Cutting Methods
DllExport int	CutFace (int f1, Point3 &p1, Point3 &p2, Point3 &Z, bool split)
	Implements the Editable Poly Cut algorithm from the face level - cuts from a point on one face to a point on another face.
DllExport int	CutEdge (int e1, float prop1, int e2, float prop2, Point3 &Z, bool split)
	Implements the Editable Poly Cut algorithm from the edge level - cuts from a point on one edge to a point on another edge.
DllExport int	Cut (int startv, Point3 &end, Point3 &Z, bool split)
	Implements the Editable Poly Cut algorithm from the vertex level - cuts from one vertex to another.
Pipeline Object Functions
DllExport void	ApplyMapper (UVWMapper &mapChannel, int channel=0, BOOL useSel=FALSE)
	Applies UVW Mapper to create the desired mapping in the specified channel.
DllExport void	InvalidateGeomCache ()
	Invalidates information, like bounding box and face normals, that's dependent on Geometry.
DllExport void	InvalidateTopoCache (bool in_clearCacheFlags=true)
	Clears out topology-dependent cache information.
DllExport void	UpdateDisplayVertexColors ()
	This method is used to manage the display of vertex colors from any channel (or those that are passed in by some calling routine).
DllExport void	SetDisplayVertexColors (int chan)
	This method is used to manage the display of vertex colors from any channel (or those that are passed in by some calling routine).
DllExport void	SetDisplayVertexColors (UVVert mv, MNMapFace mf)
	If you have cached your own vertex color information that isn't in any of the map channels provided, you can use this method to set the internal pointers to use your data.
DllExport void	PrepForPipeline ()
	This method reconciles flags with arrays, checks and modifies data, ensures that the caches are consistent, and prepares the MNMesh pipeline.
DllExport void	allocRVerts ()
	Allocates the "render vertices" used to optimize display routines.
DllExport void	updateRVerts (GraphicsWindow *gw)
	Fills in the render vertices with display coordinates based on the specified view.
DllExport void	freeRVerts ()
	Frees the "render vertices" used to optimize display routines.
Display Flag Methods
See MNMesh Display Flags for a list of supported display flags.
void	SetDispFlag (DWORD f)
	This method allows you to set the display flags.
DWORD	GetDispFlag (DWORD f)
	This method returns the displFlags & f.
void	ClearDispFlag (DWORD f)
	This method allows you to clear the specified display flags.
Render Methods
DllExport void	render (GraphicsWindow gw, Material ma, RECT rp, int compFlags, int numMat=1, InterfaceServer pi=NULL)
	Causes the MNMesh to display itself in the indicated GraphicsWindow.
DllExport void	renderFace (GraphicsWindow *gw, int ff)
	Displays the indicated face in the GraphicsWindow.
DllExport void	render3DFace (GraphicsWindow *gw, int ff)
	Displays the indicated face in the GraphicsWindow using hardware acceleration for texture and lighting if available.
DllExport void	render3DDiagonals (GraphicsWindow *gw, DWORD compFlags)
	Displays all face diagonals in the GraphicsWindow using hardware acceleration for texture and lighting if available.
DllExport void	renderDiagonals (GraphicsWindow *gw, DWORD compFlags)
	Displays all face diagonals in the GraphicsWindow.
DllExport void	renderDiagonal (GraphicsWindow gw, int ff, bool useSegments=false, bool lastColorSubSel=NULL)
	Displays diagonals for the specified face in the GraphicsWindow.
DllExport void	render3DEdges (GraphicsWindow *gw, DWORD compFlags)
	Displays all edges in the GraphicsWindow using hardware acceleration for texture and lighting if available.
DllExport void	renderEdges (GraphicsWindow *gw, DWORD compFlags)
	Displays all edges in the GraphicsWindow.
DllExport void	renderEdge (GraphicsWindow gw, int ee, bool useSegments=false, bool lastColorSubSel=NULL)
	Displays an edge in a GraphicsWindow.
Intersection and Hit Testing Functions
DllExport BOOL	select (GraphicsWindow gw, Material ma, HitRegion *hr, int abortOnHit=FALSE, int numMat=1)
	Checks the given HitRegion to see if it intersects this Mesh object.
DllExport BOOL	SubObjectHitTest (GraphicsWindow gw, Material ma, HitRegion *hr, DWORD flags, SubObjHitList &hitList, int numMat=1)
	This method may be called to perform sub-object hit testing on this mesh.
DllExport int	IntersectRay (Ray &ray, float &at, Point3 &norm)
	Provides the intersection point and normal for the ray with this mesh.
DllExport int	IntersectRay (Ray &ray, float &at, Point3 &norm, int &fi, Tab< float > &bary)
	Provides the intersection point and normal for the ray with this mesh.
Object Overrides
DllExport void	ShallowCopy (MNMesh *amesh, ChannelMask channels)
DllExport void	NewAndCopyChannels (ChannelMask channels)
DllExport void	FreeChannels (ChannelMask channels, BOOL zeroOthers=1)
IO Functions
See also: Animatable
DllExport IOResult	Save (ISave *isave)
DllExport IOResult	Load (ILoad *iload)
FlagUser Overrides
DllExport void	ClearFlag (DWORD fl)
InterfaceServer Overrides
DllExport BaseInterface *	GetInterface (Interface_ID id)
Cache and Optimization Methods
DllExport void	ReduceDisplayCaches ()
	Forces all the derived data used to display the mesh to be deleted.
DllExport bool	NeedGWCacheRebuilt (GraphicsWindow gw, Material ma, int numMat)
	This returns whether the Graphics Cache for this object needs to be rebuilt.
DllExport void	BuildGWCache (GraphicsWindow gw, Material ma, int numMat, BOOL threaded)
	Builds the graphics window cached mesh.
DllExport void	InvalidateHardwareMesh (DWORD keepFlags=0)
	This method can be used to invalidate any display-technology-specific caches of the MNMesh.
DllExport void	SetStaticMesh (bool staticMesh)
	Set the mesh or as static or not.
Specified Normal Methods
DllExport MNNormalSpec *	GetSpecifiedNormals ()
	Returns a pointer to the user-specified normal interface, if present.
DllExport MNNormalSpec *	GetSpecifiedNormalsForDisplay ()
	Returns a non-NULL MNNormalSpec interface pointer only if the interface is present, and is prepared for use in display - otherwise, it returns NULL, and we fall back on the smoothing groups.
DllExport void	ClearSpecifiedNormals ()
	Clears out the specified normal interface, if present.
DllExport void	SpecifyNormals ()
	Creates the user-specified normal interface in this mesh.
Miscellaneous Methods
DllExport void	Transform (Matrix3 &xfm)
	Transforms all vertices & hidden vertices by the Matrix xfm.
bool	IsClosed ()
	Figures out if this mesh is completely closed.
DllExport void	Relax (float relaxval, bool targonly=TRUE)
	Similar to the 3ds Max "Relax" modifier: this modifier moves each MNVert towards the average of all vertices to which it is connected (by MNEdges).
DllExport bool	LiftFaceClusterFromEdge (int liftEdge, float liftAngle, int segments, MNFaceClusters &fclust, int clusterID)
	Detaches the face cluster and rotates its around the hinge edge and fills in the gap.
DllExport void	SmoothByCreases (DWORD creaseFlag)
	This is an auto-smooth algorithm that allows the developer to specify exactly which edges should be creases and which should be smoothed across.
Public Attributes
MNVert *	v
	The array of vertices.
MNEdge *	e
	The array of edges.
MNFace *	f
	The array of faces;.
int	numv
	Number of MNVert elements in v.
int	nume
	Number of MNEdge elements in e.
int	numf
	Number of MNFace elements in f.
int	numm
PerData *	vd
	The array of PerData objects which maintain and provide access to the floating point vertex data.
BitArray	vdSupport
	This bit array indicates if a particular vertex data channel is supported in this MNMesh.
PerData *	ed
	The array of PerData objects which maintain and provide access to the floating point edge data.
BitArray	edSupport
	This bit array indicates if a particular edge data channel is supported in this MNMesh.
int	selLevel
	The current MNMesh selection level.
DWORD	dispFlags
	Display flags.
Tab< int > *	vedg
	This is an array of int Tabs that records which edges use each vertex.
Tab< int > *	vfac
	This is an array of int Tabs that records which faces touch each vertex.
Friends
class	HardwareMNMesh
class	MNNormalSpec
class	MNMeshUtilites8Impl
class	MNMeshUtilities10Impl
class	MNMeshFGBGObject
class	MaxGraphics::IMNMeshInternal
void	gfxCleanup (void *data)

Constructor & Destructor Documentation

MNMesh ( ) [inline]

Initializes the MNMesh with no components and the default flags.

{ Init(); DefaultFlags (); }

MNMesh ( const Mesh & from ) [inline]

Constructor.

Initializes the MNMesh with the mesh "from", and fills in the topology completely (using FillInMesh).

{ Init(); SetFromTri (from); FillInMesh (); }

MNMesh ( const MNMesh & from ) [inline]

Copy constructor.

{ Init(); DefaultFlags(); *this = from; }

DllExport ~MNMesh ( )

Destructor.

Frees all allocated memory (using Clear).

Member Function Documentation

void DefaultFlags ( ) [inline]

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

DllExport bool SeparateMapVerticesInFaceCluster	(	MNFaceClusters &	fclust,
		int	clusterID
	)

fclust	A set of face clusters.
clusterID	The ID of the cluster to operate on.

mapChannel	The map channel to look at the texture of..
edge	The edge number.

DllExport void FindEdgeListMapVerts	(	const Tab< int > &	lp,
		Tab< int > &	mv,
		int	mapChannel
	)

DllExport void setVDataSupport	(	int	vdChannel,
		BOOL	support = `TRUE`
	)

DllExport void setEDataSupport	(	int	edChannel,
		BOOL	support = `TRUE`
	)

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 NewFace	(	int	initFace,
		int	degg = `0`,
		int *	vv = `NULL`,
		bool *	vis = `NULL`,
		bool *	sel = `NULL`
	)

DllExport int InsertSpur	(	int	face,
		int	vertIndex,
		Tab< int > *	ptMapVertArray = `NULL`
	)

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

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
	)

DllExport BitArray VertexTempSel	(	DWORD	fmask = `MN_DEAD\|MN_SEL`,
		DWORD	fset = `MN_SEL`
	)

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`
	)

MNMesh Class Reference

Detailed Description

Public Member Functions

Public Attributes

Friends

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

DllExport Box3 getBoundingBox	(	Matrix3 *	tm = `NULL`,
		bool	targonly = `FALSE`
	)

DllExport void ComputeCenters	(	Point3 *	ctr,
		bool	targonly = `FALSE`
	)

DllExport void ComputeNormal	(	int	ff,
		Point3 &	normal,
		Point3 *	ctr = `NULL`
	)

DllExport void ComputeSafeCenters	(	Point3 *	ctr,
		bool	targonly = `FALSE`,
		bool	detarg = `FALSE`
	)

DllExport void BestConvexDiagonals	(	int	ff,
		int *	diag = `NULL`
	)

DllExport void BestConvexDiagonals	(	int	deg,
		int *	vv,
		int *	diag
	)

DllExport void MakePolyMesh	(	int	maxdeg = `0`,
		BOOL	elimCollin = `TRUE`
	)

DllExport void Resmooth	(	bool	smooth = `TRUE`,
		bool	targonly = `FALSE`,
		DWORD	targmask = `~0x0`
	)

DllExport void AutoSmooth	(	float	angle,
		BOOL	useSel,
		BOOL	preventIndirectSmoothing
	)

DllExport void FenceNonPlanarEdges	(	float	thresh = `.9999f`,
		bool	makevis = `FALSE`
	)