3ds Max C++ API Reference
Loading...
Searching...
No Matches
MNFace Class Reference

The face structure used with the MNMesh mesh. More...

#include <mnmesh.h>

+ Inheritance diagram for MNFace:

Public Member Functions

 MNFace ()
 Constructor.
 
 MNFace (int d)
 Constructor.
 
DllExport MNFace (const MNFace *from)
 Constructor.
 
 ~MNFace ()
 Frees all arrays.
 
DllExport void Init ()
 Initialize the face.
 
DllExport void SetDeg (int d)
 Set the number of edges and vertices this face has.
 
DllExport void Clear ()
 Frees all arrays, setting them to NULL, and resets degree.
 
int TriNum () const
 Returns the number of triangles in this face.
 
DllExport int FindTriPoint (int edge)
 Given the index of a particular edge, this routine returns the point (distinct from edge and (edge+1)deg) that forms a triangle with the edge, given the current scheme of diagonals.
 
DllExport int FindTriPoint (int a, int b)
 Given two verts that form a diagonal in the polygon, this method finds the vertex between them that connects by a diagonal or an outer edge to both of them.
 
DllExport void GetTriangles (Tab< int > &tri)
 This method fills in the table with the full triangulation for the face, based on the internal diagonal list.
 
DllExport void GetTriangles (Tab< int > &tri) const
 This method fills in the table with the full triangulation for the face, based on the internal diagonal list.
 
DllExport void SetAlloc (int d)
 Allocates enough memory in the arrays for the face to have degree d, but does not actually set the degree.
 
DllExport void MakePoly (int fdeg, int *vv, bool *vis=NULL, bool *sel=NULL)
 Makes this face into a polygon with the specified vertices and other information.
 
DllExport void Insert (int pos, int num=1)
 Inserts space for more vertices and edges on this face.
 
DllExport bool Delete (int pos, int num=1, int edir=1, bool fixtri=TRUE)
 Deletes vertices & edges from this face.
 
DllExport void RemoveNullEdges (Tab< int > &nullEdges, Tab< int > &excisedVertices, const MNMesh *mesh)
 Searches the edge list for this face for "null" edges, defined as edges with identical start and end vertices.
 
DllExport void RotateStart (int newstart)
 Re-indexes the vertices and edges so that the vertex in position newstart becomes the new first vertex.
 
DllExport void Flip ()
 Reverses order of verts, effectively inverting the face.
 
DllExport int VertIndex (int vv, int ee=-1)
 Returns the position of vertex vv in this face's list of vertices.
 
DllExport int EdgeIndex (int ee, int vv=-1) const
 Returns the position of edge ee in this face's list of edges.
 
DllExport void ReplaceVert (int ov, int nv, int ee=-1)
 Replaces vertex ov with vertex nv in the list of vertices.
 
DllExport void ReplaceEdge (int oe, int ne, int vv=-1)
 Replaces edge oe with edge ne in the list of edges.
 
DllExport MNFaceoperator= (const MNFace &from)
 Assignment operator.
 
DllExport bool operator== (const MNFace &from)
 Comparison operator.
 
intoperator[] (int i)
 Access operator.
 
const intoperator[] (int i) const
 Access operator.
 
DllExport void MNDebugPrint (bool triprint=FALSE)
 Uses DebugPrint to print out face information to the Debug Results window in DevStudio.
 
DllExport IOResult Save (ISave *isave)
 
DllExport IOResult Load (ILoad *iload)
 
- Public Member Functions inherited from FlagUser
 FlagUser ()=default
 
 FlagUser (const FlagUser &)=default
 
 FlagUser (FlagUser &&)=default
 
FlagUseroperator= (const FlagUser &)=default
 
FlagUseroperator= (FlagUser &&)=default
 
void SetFlag (DWORD fl, bool val=TRUE)
 
void ClearFlag (DWORD fl)
 
bool GetFlag (DWORD fl) const
 
void ClearAllFlags ()
 
void CopyFlags (DWORD fl)
 
void CopyFlags (const FlagUser &fu)
 
void CopyFlags (const FlagUser *fu)
 
void CopyFlags (DWORD fl, DWORD mask)
 
void CopyFlags (const FlagUser &fu, DWORD mask)
 
void CopyFlags (const FlagUser *fu, DWORD mask)
 
void OrFlags (const FlagUser &fu)
 
void OrFlags (const FlagUser *fu)
 
void AndFlags (const FlagUser &fu)
 
void AndFlags (const FlagUser *fu)
 
bool FlagMatch (DWORD fmask, DWORD fl) const
 
bool FlagMatch (DWORD fmask, const FlagUser &fu) const
 
bool FlagMatch (DWORD fmask, const FlagUser *fu) const
 
DWORD ExportFlags () const
 
void ImportFlags (DWORD fl)
 
IOResult WriteFlags (ISave *isave, ULONG *nb) const
 
IOResult ReadFlags (ILoad *iload, ULONG *nb)
 

Public Attributes

int deg
 This is the degree: the number of vertices and edges that this face has.
 
intvtx
 This is the list of vertices that make up the corners of this face.
 
intedg
 This is the list of edges that border this face, in order.
 
intdiag
 This is where the triangulation is stored.
 
DWORD smGroup
 This contains the smoothing groups assigned to this face.
 
MtlID material
 This is the material ID assigned to this face.
 
int track
 Generally for internal use, but may be used to track faces created by several methods.
 
BitArray visedg
 Contains a visibility bit for each edge on this face.
 
BitArray edgsel
 Contains a selection bit for each edge on this face.
 
BitArray bndedg
 Boundary Edges.
 

Friends

class MNMesh
 

Additional Inherited Members

- Static Public Member Functions inherited from MaxHeapOperators
static UtilExport voidoperator new (size_t size)
 Standard new operator used to allocate objects If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator new (size_t size, const std::nothrow_t &e)
 Standard new operator used to allocate objects if there is insufficient memory, NULL will be returned.
 
static UtilExport voidoperator new (size_t size, const char *filename, int line)
 New operator used to allocate objects that takes the filename and line number where the new was called If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator new (size_t size, int block_type, const char *filename, int line)
 New operator used to allocate objects that takes the type of memory, filename and line number where the new was called If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator new (size_t size, const std::nothrow_t &e, const char *filename, int line)
 New operator used to allocate objects that takes the filename and line number where the new was called If there is insufficient memory, NULL will be returned.
 
static UtilExport voidoperator new (size_t size, unsigned long flags)
 New operator used to allocate objects that takes extra flags to specify special operations If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator new (size_t size, const std::nothrow_t &e, unsigned long flags)
 New operator used to allocate objects that takes extra flags to specify special operations If there is insufficient memory, NULL will be returned.
 
static UtilExport voidoperator new[] (size_t size)
 New operator used to allocate arrays of objects If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator new[] (size_t size, const std::nothrow_t &e)
 New operator used to allocate arrays of objects If there is insufficient memory, NULL will be returned.
 
static UtilExport voidoperator new[] (size_t size, const char *filename, int line)
 New operator used to allocate arrays of objects If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator new[] (size_t size, int block_type, const char *filename, int line)
 New operator used to allocate arrays of objects.
 
static UtilExport voidoperator new[] (size_t size, const std::nothrow_t &e, const char *filename, int line)
 New operator used to allocate arrays of objects If there is insufficient memory, NULL will be returned.
 
static UtilExport voidoperator new[] (size_t size, unsigned long flags)
 New operator used to allocate arrays of objects If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator new[] (size_t size, const std::nothrow_t &e, unsigned long flags)
 New operator used to allocate arrays of objects If there is insufficient memory, NULL will be returned.
 
static UtilExport void operator delete (void *ptr)
 Standard delete operator used to deallocate an object If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete (void *ptr, const std::nothrow_t &e)
 Standard delete operator used to deallocate an object If the pointer is invalid, nothing will happen.
 
static UtilExport void operator delete (void *ptr, const char *filename, int line)
 Delete operator used to deallocate an object that takes the filename and line number where the delete was called If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete (void *ptr, int block_type, const char *filename, int line)
 Delete operator used to deallocate an object that takes the type of memory, filename and line number where the delete was called If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete (void *ptr, const std::nothrow_t &e, const char *filename, int line)
 Delete operator used to deallocate an object that takes the filename and line number where the delete was called If the pointer is invalid, nothing will happen.
 
static UtilExport void operator delete (void *ptr, unsigned long flags)
 Delete operator used to deallocate an object that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete (void *ptr, const std::nothrow_t &e, unsigned long flags)
 Delete operator used to deallocate an object that takes extra flags to specify special operations If the pointer is invalid, nothing will happen.
 
static UtilExport void operator delete[] (void *ptr)
 Standard delete operator used to deallocate an array of objects If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete[] (void *ptr, const std::nothrow_t &e)
 Standard delete operator used to deallocate an array of objects If the pointer is invalid, nothing will happen.
 
static UtilExport void operator delete[] (void *ptr, const char *filename, int line)
 Delete operator used to deallocate an array of objects that takes the filename and line number where the delete was called If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete[] (void *ptr, int block_type, const char *filename, int line)
 Delete operator used to deallocate an array of objects that takes the type of memory, filename and line number where the delete was called If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete[] (void *ptr, const std::nothrow_t &e, const char *filename, int line)
 Delete operator used to deallocate an array of objects that takes the filename and line number where the delete was called If the pointer is invalid, nothing will happen.
 
static UtilExport void operator delete[] (void *ptr, unsigned long flags)
 Delete operator used to deallocate an array of objects that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete[] (void *ptr, const std::nothrow_t &e, unsigned long flags)
 Delete operator used to deallocate an array of objects that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown.
 
static UtilExport voidoperator new (size_t size, void *placement_ptr)
 Placement new operator.
 
static UtilExport void operator delete (void *ptr, void *placement_ptr)
 Placement delete operator.
 
static UtilExport voidaligned_malloc (size_t size, size_t alignment)
 Allocates memory on a specified alignment boundary.
 
static UtilExport voidaligned_realloc (void *ptr, size_t size, size_t alignment)
 Reallocates memory on a specified alignment boundary.
 
static UtilExport void aligned_free (void *ptr)
 Frees a block of memory that was allocated with aligned_malloc/aligned_realloc.
 

Detailed Description

The face structure used with the MNMesh mesh.

MNFace are not necessarily triangles. They also may contain hidden vertices which are used in converting the face back to triangles. This triangulation is always maintained in the face.

See also
FlagUser, MNFace, BitArray.

Constructor & Destructor Documentation

◆ MNFace() [1/3]

MNFace ( )
inline

Constructor.

Initializes the face's arrays to NULL.

625{ Init(); }
DllExport void Init()
Initialize the face.

◆ MNFace() [2/3]

MNFace ( int  d)
inline

Constructor.

Initializes the face's degree to d and allocates space for all the arrays.

629{ Init(); SetDeg (d); }
DllExport void SetDeg(int d)
Set the number of edges and vertices this face has.

◆ MNFace() [3/3]

DllExport MNFace ( const MNFace from)

Constructor.

Copies flags, smoothing groups, and material from "from", but initializes the face's arrays to NULL and degree to 0.

◆ ~MNFace()

~MNFace ( )
inline

Frees all arrays.

636{ Clear(); }
DllExport void Clear()
Frees all arrays, setting them to NULL, and resets degree.

Member Function Documentation

◆ Init()

DllExport void Init ( )

Initialize the face.

◆ SetDeg()

DllExport void SetDeg ( int  d)

Set the number of edges and vertices this face has.

Parameters:
int d

Number of vertices and edges.

◆ Clear()

DllExport void Clear ( )

Frees all arrays, setting them to NULL, and resets degree.

◆ TriNum()

int TriNum ( ) const
inline

Returns the number of triangles in this face.

651{ return deg-2; }
int deg
This is the degree: the number of vertices and edges that this face has.
Definition: mnmesh.h:581

◆ FindTriPoint() [1/2]

DllExport int FindTriPoint ( int  edge)

Given the index of a particular edge, this routine returns the point (distinct from edge and (edge+1)deg) that forms a triangle with the edge, given the current scheme of diagonals.

Parameters:
int edge

An index into the vertex array (in the range 0 to deg-1) that indicates the starting vertex of the edge. (In other words, the edge falls between vertex vtx[edge] and vtx[(edge+1)deg].)
Returns
The index of the desired vertex, again in the (0,deg-1) range, or edge if there's an error.

◆ FindTriPoint() [2/2]

DllExport int FindTriPoint ( int  a,
int  b 
)

Given two verts that form a diagonal in the polygon, this method finds the vertex between them that connects by a diagonal or an outer edge to both of them.

(Here, "between them" means after a and before b in sequence around the outside of the polygon. If we have an octagon where a=6 and b=2, the result would be 7, 0, or 1. To get the other result, in the 3,4,5 range, call the method with a=2 and b=6.)

Parameters:
int a, b

Two vertices, "internally indexed" in the 0 to deg-1 range. This method is only guaranteed to work if the vertices share a diagonal. (Otherwise, there may be no solution.)
Returns
The index of the desired vertex, again in the (0,deg-1) range, or a if there's an error.

◆ GetTriangles() [1/2]

DllExport void GetTriangles ( Tab< int > &  tri)

This method fills in the table with the full triangulation for the face, based on the internal diagonal list.

The table is set to size (deg-2)*3.

Parameters:
Tab<int> &tri

The table of triangles.

◆ GetTriangles() [2/2]

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

This method fills in the table with the full triangulation for the face, based on the internal diagonal list.

The table is set to size (deg-2)*3. The const version doesn't reorder diags.

Parameters:
Tab<int> &tri

The table of triangles.

◆ SetAlloc()

DllExport void SetAlloc ( int  d)

Allocates enough memory in the arrays for the face to have degree d, but does not actually set the degree.

If the arrays are already large enough (or larger), it does not reallocate them. You generally don't need to use this method separately; MakePoly, Insert, and other methods which may require additional memory will call this if needed.

◆ MakePoly()

DllExport void MakePoly ( int  fdeg,
int vv,
bool *  vis = NULL,
bool *  sel = NULL 
)

Makes this face into a polygon with the specified vertices and other information.

This routine also supplies a default triangulation for the face; however, since this MNFace-level routine cannot access the vertex positions contained in the parent MNMesh, this triangulation may not work for non-convex faces. If the face may not be convex, a call to MNMesh::RetriangulateFace for this face will correct the triangulation.

Parameters:
int fdeg

The degree to set this face to.

int *vv

The list of vertices for this face. There must be at least fdeg of these. These values should be indices into the parent MNMesh's array of MNVerts.

bool *vis=NULL

The edge visibility flags for the edges of this face. If this is NULL, it is ignored; otherwise, there must be at least fdeg of these. vis[i] represents the visibility of the edge going from vv[i] to vv[(i+1)fdeg]. See the MNMesh note on edge selection & visibility for more information.

bool *sel=NULL

The edge selection flags for the edges of this face. If this is NULL, it is ignored; otherwise, there must be at least fdeg of these. sel[i] represents the selection bit of the edge going from vv[i] to vv[(i+1)fdeg]. See the MNMesh note on edge selection & visibility for more information.

◆ Insert()

DllExport void Insert ( int  pos,
int  num = 1 
)

Inserts space for more vertices and edges on this face.

This is used, for example, when two faces are joined, to add room for the vertices & edges of one face to the other. This routine also renumbers the existing vertices and corrects the existing face triangulation, although it cannot provide the triangulation for the new vertices. It reserves space for the new triangles at the end of the triangle array. If you do not want to compute the triangulation for the new vertices yourself, you may use the MNMesh RetriangulateFace method after filling in the new vertices.

Parameters:
int pos

The location within the face where the new vertices and edges should be added.

int num

The number of new vertices and edges.

◆ Delete()

DllExport bool Delete ( int  pos,
int  num = 1,
int  edir = 1,
bool  fixtri = TRUE 
)

Deletes vertices & edges from this face.

This routine also corrects the face triangulation, removing those triangles that include the deleted edges and re-indexing the rest. However, delete may cause the triangulation to become invalid, by causing one or more of the corrected triangles to have a flipped normal.

Parameters:
int pos

The position of the first vertex to be deleted.

int num=1

The number of vertices & edges to delete.

int edir=1

There are two choices for the edges to be deleted: we can delete the edges going from pos to pos+1, pos+1 to pos+2, ... pos+num-1 to pos+num, or we can delete pos-1 to pos, pos to pos+1, ... pos+num-2 to pos+num-1. (pos+num-1 is the last vertex deleted.) That is to say, we can delete the edges "before" the vertices we're deleting, or we can delete the edges "after" them. If edir is positive, we delete the edges after the vertices. If it's negative, we delete the edges before. Keep in mind that this also affects edge visibility and selection information on this face.

bool fixtri=TRUE

This argument indicates how far Delete should go in fixing the triangulation. Delete will always correct the values of the tri array to correspond to the reduced-degree face. If fixtri is true, it will also delete those triangles that have collapsed because they had two vertices in the deleted region. If not, it will leave these triangles with overlapping vertices, as in (0,0,2).
Returns
Delete returns TRUE if fixtri is FALSE. If fixtri is TRUE, Delete will return TRUE if it successfully corrected the triangulation, or FALSE if there was a problem. If FALSE is returned, the triangulation will need to be revised with a call to RetriangulateFace.

◆ RemoveNullEdges()

DllExport void RemoveNullEdges ( Tab< int > &  nullEdges,
Tab< int > &  excisedVertices,
const MNMesh mesh 
)

Searches the edge list for this face for "null" edges, defined as edges with identical start and end vertices.

These edges are excised from the face edge list, and the associated duplicate vertices are removed from the vertex list. The face is retriangulated if any null edges are encountered. If removing null edges would result in a degenerate face of degree less than three, the face simply flags itself as MN_DEAD and returns the identified edges in nullEdges.

Parameters
[out]nullEdgeslist of indices in the owning MNMesh container of null edges identified in this face; if the same null edge was present N times in this face's edge list, it will appear N times in nullEdges
[out]excisedVerticeslist of local indices, in face vtx container at entry to function, of duplicate vertices removed due to excision of a null edge
[in]meshmesh container in which this face resides

◆ RotateStart()

DllExport void RotateStart ( int  newstart)

Re-indexes the vertices and edges so that the vertex in position newstart becomes the new first vertex.

Triangulation is also corrected. Mapping coordinates and vertex colors are corrected automatically.

◆ Flip()

DllExport void Flip ( )

Reverses order of verts, effectively inverting the face.

vtx[0] remains unchanged, but vertex deg-1 becomes vertex 1, etc. Note that this operation wreaks havoc on nearby edges and should be used with caution.

◆ VertIndex()

DllExport int VertIndex ( int  vv,
int  ee = -1 
)

Returns the position of vertex vv in this face's list of vertices.

For a given face fc, if fc.vtx[i] = vv, fc.VertIndex (vv) = i. Sometimes a single vertex from the MNMesh's MNVert list can be referenced more than once by a single face. The picture below illustrates this problem. The small triangle is actually outside of the face, and the vertex at the top of it is referenced twice by the face. Thus an additional edge parameter can be accepted. If ee is -1, it is ignored, and the first instance of vv is used. If ee>-1, this method looks for the instance of vv that starts out edge ee. Thus if fc.vtx[i] = vv and fc.vtx[j] = vv, but fc.edg[i] != ee and fc.edg[j] = ee, j is returned. IMPORTANT: If no vertex is found matching the given parameters, this method generates an assertion failure. Please be sure that vertex vv is actually on the face (and that edge ee follows it if ee is not -1) before using this method.

◆ EdgeIndex()

DllExport int EdgeIndex ( int  ee,
int  vv = -1 
) const

Returns the position of edge ee in this face's list of edges.

For a given face fc, if fc.edg[i] = ee, fc.EdgeIndex (ee) = i. Sometimes a single edge from the MNMesh's MNEdge list can be referenced more than once by a single face. The small rectangle is actually outside of the face, and the edge above it is referenced twice by the face, once in each direction. Thus an additional vertex parameter can be accepted. If vv is -1, it is ignored, and the first instance of ee is used. If vv>-1, this method looks for the instance of ee that starts out with vertex vv. Thus if fc.edg[i] = ee and fc.edg[j] = ee, but fc.vtx[i] != vv and fc.vtx[j] = vv, j is returned. IMPORTANT: If no edge is found matching the given parameters, this method generates an assertion failure. Please be sure that edge ee is actually on the face (and that vertex vv follows it if vv is not -1) before using this method.

◆ ReplaceVert()

DllExport void ReplaceVert ( int  ov,
int  nv,
int  ee = -1 
)

Replaces vertex ov with vertex nv in the list of vertices.

It is possible for a face to reference the same vertex more than once, however the combination of a vertex followed by a specified edge is unique. Therefore if ee<0, all instances of ov are replaced by nv, but if not, only the instance of ov followed by ee is replaced.

◆ ReplaceEdge()

DllExport void ReplaceEdge ( int  oe,
int  ne,
int  vv = -1 
)

Replaces edge oe with edge ne in the list of edges.

It is possible for a face to reference the same edge twice, however the combination of an edge preceded by a specified vertex is unique. Therefore if vv<0, all instances of oe are replaced by ne, but if not, only the instance of oe preceded by vv is replaced.

◆ operator=()

DllExport MNFace & operator= ( const MNFace from)

Assignment operator.

Copies all information from "from", including triangulation, hidden vertices, flags, smoothing & material info, and "track".

◆ operator==()

DllExport bool operator== ( const MNFace from)

Comparison operator.

◆ operator[]() [1/2]

int & operator[] ( int  i)
inline

Access operator.

853{ return vtx[i]; }
int * vtx
This is the list of vertices that make up the corners of this face.
Definition: mnmesh.h:585

◆ operator[]() [2/2]

const int & operator[] ( int  i) const
inline

Access operator.

856{ return vtx[i]; }

◆ MNDebugPrint()

DllExport void MNDebugPrint ( bool  triprint = FALSE)

Uses DebugPrint to print out face information to the Debug Results window in DevStudio.

The information consists of the vertices and edges used by this face. It is generally a good idea to put in a DebugPrint immediately before this with the index of the edge, so you know which one is being printed out:

DebugPrint(_M("Face %d: "), fid);
F(fid)->MNDebugPrint();
UtilExport void DebugPrint(const MCHAR *format,...)
#define _M(x)
Used to wrap string literals.
Definition: strbasic.h:67
Parameters:
bool triprint=FALSE

Print out triangulation information.

bool hinfo=TRUE

Print out hidden vertex information.

◆ Save()

DllExport IOResult Save ( ISave isave)

◆ Load()

DllExport IOResult Load ( ILoad iload)

Friends And Related Function Documentation

◆ MNMesh

friend class MNMesh
friend

Member Data Documentation

◆ deg

int deg

This is the degree: the number of vertices and edges that this face has.

◆ vtx

int* vtx

This is the list of vertices that make up the corners of this face.

Each value is an index into the parent MNMesh's list of MNVerts.

◆ edg

int* edg

This is the list of edges that border this face, in order.

Each edg[i] goes between vtx[i] and vtx[(i+1)deg]. Each value is an index into the parent MNMesh's list of MNEdges. These values may not be valid if the MNMesh's MN_MESH_FILLED_IN flag is not set.

◆ diag

int* diag

This is where the triangulation is stored.

The number of triangles in a face is given by deg - 2 + hdeg*2. This array contains three times this number, for all the corners of all the sub-triangles. The triangle values are indices into the vtx and hvtx arrays of this face. Hidden vertices are indicated by values less than zero: hvtx[i] is represented by -1-i. Thus a triangle (1, 2, -2) would represent a triangle using vtx[1], vtx[2], and hvtx[-1]. The diag array's allocated size is always (dalloc-3)*2. If dalloc==3 (triangle), this pointer is NULL.

◆ smGroup

DWORD smGroup

This contains the smoothing groups assigned to this face.

◆ material

MtlID material

This is the material ID assigned to this face.

◆ track

int track

Generally for internal use, but may be used to track faces created by several methods.

See also
MakePlanar,
MakeFacePlanar,
SeparateFace.

◆ visedg

BitArray visedg

Contains a visibility bit for each edge on this face.

See the MNMesh note on edge selection & visibility for more information.

◆ edgsel

BitArray edgsel

Contains a selection bit for each edge on this face.

See the MNMesh note on edge selection & visibility for more information.

◆ bndedg

BitArray bndedg

Boundary Edges.