MeshDelta Class Reference

#include <meshdelta.h>

Class Description

See also

Class Mesh, Class FaceChange, Class FaceRemap, Class FaceSmooth, Class VertMove, Class UVVertSet, Class MapDelta, Class VDataDelta, Class AdjEdgeList, Class AdjFaceList, Class MeshChamferData, Template Class Tab, Class BitArray.

Description:

This class represents the notion of a mesh edit. This is an SDK class that represent some kind of change to a mesh. This "delta" can include topological, geometric, map, and/or selection changes. Most standard mesh "edits" available in the Editable Mesh or Edit Mesh interface are available through the MeshDelta SDK, giving developers a powerful way to manipulate meshes while not having to "sweat the details" of maintaining maps to match the mesh changes, updating edge selections, etc. The MeshDelta members and methods make use of a number of mesh-related classes, including Class FaceChange, Class FaceRemap, Class FaceSmooth, Class VertMove, Class UVVertSet, Class MapDelta, Class VDataDelta, Class AdjEdgeList, Class AdjFaceList, Class MeshChamferData. While we often talk about the characteristics of the "input mesh" that a MeshDelta is based on, all MeshDeltas should be able to cope with any mesh. Note: You must #include "MESHDLIB.H" to use this class as it's not included by default by MAX.H.

Method Groups:

See Method Groups for Class MeshDelta.

Data Members:

DWORD vnum The expected number of vertices in the input mesh. DWORD fnum; The expected number of faces in the input mesh. Tab<VertMove> vMove; This data member stores movements of input vertices. Each VertMove consists of a vertex ID indicating which vertex should be moved and a Point3 offset in object space. VertMoves are stored in vertex ID order, and there is never more than one VertMove per original vertex. Tab<VertMove> vClone; If the vClone[i] record has a vid of UNDEFINED, it's considered a "create", and the coordinates of vClone[i].p are considered to be in object space. If vClone[i].vid is not undefined, it's the index of a vertex "original" in the input mesh, and vClone[i].p is treated as an offset from that vertex. If the vertex is not present in the input mesh, i.e. vClone[i].vid >= mesh::numVerts, the clone will not be created in the output. All creates and clones are stored in the order created.. BitArray vDelete; This data member stores deletions of vertices in the input mesh. vDelete's size is vnum. Tab<FaceCreate> fCreate; This data member stores faces newly created as part of the MeshDelta. These are stored in the order created. Tab<FaceRemap> fRemap; This data member stores changes in which vertices are used by existing faces. See class FaceRemap for more information. These are stored in original face order, and there is never more than one per original face. Tab<FaceChange> fChange; This data member stores changes in input face characteristics, such as material ID, edge visibility, and face hiding. See class FaceChange for more information. These are stored in original face order, and there is never more than one per original face. Tab<FaceSmooth> fSmooth; This data member stores changes in input face smoothing groups. See class FaceSmooth for more information. These are stored in original face order, and there is never more than one per original face. BitArray fDelete; This data member stores deletions of faces in the input mesh. The size of this BitArray is fnum. BitArray vsel; This data member stores the vertex selection of the output mesh. BitArray esel; This data member stores the edge selection of the output mesh. As with class Mesh's edgeSel data member, this information is indexed by side of face: esel[ff*3+k] is the edge selection for face ff, side k. BitArray fsel; This data member stores the face selection of the output mesh. BitArray vhide; This data member stores the vertex hide information of the output mesh. MapDelta *map; Points to an array of MapDeltas which maintain any relevant changes to the various map channels. The size of this array is always equal to mapSupport.GetSize(). BitArray mapSupport; Indicates which maps are supported by this MeshDelta. VDataDelta *vd; Points to an array of VDataDeltas which maintain any relevant changes to the various vertex data channels. The size of this array is always equal to vdSupport.GetSize(). BitArray vdSupport; Indicates which vertex data channels are supported by this MeshDelta.

Inheritance diagram for MeshDelta:

Public Member Functions
DllExport void	GetSavingPermutations (int &numCr, int &numCl, Tab< int > &vPermute, Tab< int > &vPReverse)
DllExport void	PermuteClonedVertices (Tab< int > &vPermute)
DllExport BOOL	CheckOrder ()
DllExport BOOL	CheckMapFaces ()
DllExport void	SetSingleEdgeVis (Mesh &m, DWORD ed, BOOL vis, AdjFaceList *adj=NULL)
Initialization and Clean-up
DllExport	MeshDelta ()
DllExport	MeshDelta (const Mesh &m)
DllExport	~MeshDelta ()
DllExport void	InitToMesh (const Mesh &m)
DllExport void	ClearAllOps ()
DllExport void	SetMapNum (int n, bool keep=TRUE)
int	GetMapNum ()
MapDelta &	Map (int mp)
bool	getMapSupport (int mp)
void	setMapSupport (int mp, bool val=true)
bool	hasMapSupport ()
DllExport void	SetVDataNum (int size, bool keep=TRUE)
int	GetVDataNum ()
Mesh Interaction
DllExport ChannelMask	PartsChanged ()
DllExport void	Apply (Mesh &mesh)
DllExport void	FillInFaces (Mesh &m)
Composition and Operators
MeshDeltas can be multiplied together like Transforms before being applied to a mesh. This is especially useful in Edit Mesh, where a single MeshDelta is used to store the current "state" of the Edit Mesh and extra MeshDeltas are created for each operation and added on to the main MeshDelta. An example of this is as follows: given a Mesh m that we want to divide a face on, and then we want to break the vertex created in the face divide. These operations are adequately handled by the DivideFace and BreakVerts methods independently, but to combine the two into one operation, we must compose two MeshDeltas. MeshDelta DivideThenBreak (const Mesh & m, int ff) { MeshDelta md1, md2 Mesh mcopy = m md1.DivideFace (mcopy, ff) int nvid = md1.vnum // since DivideFace creates exactly one vertex, this must be its index in the result. md1.Apply (mcopy) md2.InitToMesh (mcopy) // second MeshDelta must be based on first MeshDelta result. BitArray vset vset.SetSize (mcopy.numVerts) vset.Set (nvid) md2.BreakVerts (mcopy, vset) // breaks the new vertex into a separate vert for each face. md1.Compose (md2) // Adds the second MeshDelta into the first. return md1 } If all we wanted was to perform these operations on the mesh given, we could have done so without making the composition. The point here is to be able to construct complex MeshDeltas representing a series of user operations while remaining flexible enough to respond to changes in the actual mesh given as input.
MeshDelta &	operator= (MeshDelta &td)
MeshDelta &	operator*= (MeshDelta &td)
DllExport void	Compose (MeshDelta &td)
DllExport DWORD	ChangeFlags (Tab< DWORD > *mChannels=NULL)
DllExport void	CopyMDChannels (MeshDelta &from, DWORD channels, Tab< DWORD > *mChannels=NULL)
Characteristics
DllExport DWORD	NumVMove (DWORD inVNum)
DllExport DWORD	NumVClone (DWORD inVNum)
DllExport DWORD	NumVDelete (DWORD inVNum)
DllExport DWORD	NumFDelete (DWORD inFNum)
int	NumFCreate ()
int	outVNum ()
int	outVNum (int inVNum)
int	outFNum ()
int	outFNum (int inFNum)
bool	IsVClone (DWORD i)
DWORD	VCloneOf (DWORD i)
bool	IsVCreate (DWORD i)
bool	IsFCreate (DWORD i)
DllExport DWORD	MoveID (DWORD i)
DllExport Point3	OutVert (Mesh &m, DWORD v)
DllExport DWORD	RemapID (DWORD ff)
DllExport DWORD	IsRemapped (DWORD ff, DWORD vid)
DllExport Face	OutFace (Mesh &m, DWORD ff)
Initialization and Cleanup
DllExport void	SetInFNum (int nface)
DllExport void	SetInVNum (int nv)
DllExport void	AddVertexColors ()
DllExport void	AddMap (int mapID)
DllExport void	AddVertexData (int vdChan, Mesh *m=NULL)
Lookup Table Methods
DllExport void	UpdateLUTs (int extraV=0, int extraF=0)
DllExport void	ClearLUTs ()
DllExport DWORD	VLut (DWORD i)
DllExport DWORD	FLut (DWORD i)
DllExport DWORD	PostVIndex (DWORD i)
DllExport DWORD	PostFIndex (DWORD i)
Basic Operations
These operations are the "building blocks" of MeshDeltas. All of them may be safely performed on MeshDeltas that are already quite complex. Those that accept DWORD indices require output mesh indices as all operations are appended to the end of the existing delta.
DllExport DWORD	VCreate (Point3 *p, int num=1, BitArray *sel=NULL, BitArray *hide=NULL)
DllExport DWORD	VClone (DWORD *v, int num=1)
DllExport DWORD	VClone (DWORD *v, Point3 *off, int num=1)
DllExport DWORD	VClone (VertMove *vm, int num=1)
DWORD	VClone (DWORD v)
DWORD	VClone (DWORD v, Point3 off)
DllExport void	VDelete (DWORD *v, int num=1)
DllExport void	VDelete (BitArray &vdel)
DllExport DWORD	FCreate (Face *f, int num=1)
DllExport DWORD	FCreate (FaceCreate *f, int num=1)
DllExport DWORD	FCreateQuad (DWORD *v, DWORD smG=0, MtlID matID=0, int orig=UNDEFINED)
DllExport DWORD	FClone (Face &f, DWORD ff, DWORD remapFlags=0, DWORD *v=NULL)
DllExport void	CreateDefaultMapFaces (int num=1)
DllExport void	FRemap (FaceRemap *f, int num=1)
DllExport void	FRemap (DWORD f, DWORD flags, DWORD *v)
DllExport void	FChange (FaceChange *f, int num=1)
DllExport void	FChange (DWORD f, DWORD flags, DWORD dat)
DllExport void	FSmooth (FaceSmooth *f, int num=1)
DllExport void	FSmooth (DWORD f, DWORD mask, DWORD val)
void	SetMatID (DWORD f, MtlID mt)
void	SetSmGroup (DWORD f, DWORD smG)
void	SetEdgeVis (DWORD f, DWORD ed, BOOL vis=TRUE)
DllExport void	FDelete (DWORD *f, int num=1)
DllExport void	FDelete (BitArray &fdel)
DllExport void	Move (int i, const Point3 &p)
DllExport void	Move (BitArray &sel, const Point3 &p)
DllExport void	Move (VertMove *vm, int num)
I/O and Debugging
DllExport IOResult	Save (ISave *isave)
DllExport IOResult	Load (ILoad *iload)
DllExport void	MyDebugPrint (bool lut=FALSE, bool mp=FALSE)
Advanced Additive Operations
The following are more complex operations. The mesh given is expected to be the result of the current MeshDelta. They must all work no matter how complex the current MeshDelta is, but they have not been extensively tested on complex MeshDeltas.
DllExport void	AutoSmooth (Mesh &m, BitArray sel, float angle, AdjFaceList *af=NULL, AdjEdgeList *ae=NULL)
DllExport void	Bevel (Mesh &m, BitArray vset, float outline, Tab< Point3 > *odir, float height, Tab< Point3 > *hdir)
DllExport DWORD	CreatePolygon (Mesh &m, int deg, int *v, DWORD smG=0, MtlID matID=0)
DllExport void	DeleteVertSet (Mesh &m, BitArray sel)
DllExport void	DeleteEdgeSet (Mesh &m, BitArray sel)
DllExport void	DeleteFaceSet (Mesh &m, BitArray sel)
DllExport void	DeleteSelected (Mesh &m)
DllExport void	DeleteIsoVerts (Mesh &m)
DllExport void	FlipNormal (Mesh &m, DWORD face)
DllExport void	MakeSelFacesPlanar (Mesh &m, BitArray sel)
DllExport void	MakeSelVertsPlanar (Mesh &m, BitArray sel)
DllExport void	MoveVertsToPlane (Mesh &m, BitArray sel, Point3 &N, float offset)
DllExport void	RestrictMatIDs (Mesh &m, int numMats)
DllExport void	SelectFacesByFlags (Mesh &m, BOOL onoff, DWORD flagmask, DWORD flags)
Advanced Operations
The following will initialize to the mesh given: they cannot be used to "add" ops to an existing MeshDelta. To add these ops, make a new MeshDelta, call one of the following, and append it to your previous one with Compose.
DllExport void	AttachMesh (Mesh &m, Mesh &attachment, Matrix3 &relativeTransform, int matOffset)
DllExport void	BreakVerts (Mesh &m, BitArray vset)
DllExport void	ChamferEdges (Mesh &m, BitArray eset, MeshChamferData &mcd, AdjEdgeList *ae=NULL)
DllExport void	ChamferMove (Mesh &m, MeshChamferData &mcd, float amount, AdjEdgeList *ae=NULL)
DllExport void	ChamferVertices (Mesh &m, BitArray vset, MeshChamferData &mcd, AdjEdgeList *ae=NULL)
DllExport void	CloneFaces (Mesh &m, BitArray fset)
DllExport void	CloneVerts (Mesh &m, BitArray vset)
DllExport void	CollapseEdges (Mesh &m, BitArray ecol, AdjEdgeList *ae=NULL)
DllExport DWORD	Cut (Mesh &m, DWORD ed1, float prop1, DWORD ed2, float prop2, Point3 &norm, bool fixNeighbors=TRUE, bool split=FALSE)
DllExport void	Detach (Mesh &m, Mesh *out, BitArray fset, BOOL faces, BOOL del, BOOL elem)
DllExport void	DivideEdge (Mesh &m, DWORD ed, float prop=.5f, AdjEdgeList *el=NULL, bool visDiag1=FALSE, bool fixNeighbors=TRUE, bool visDiag2=FALSE, bool split=FALSE)
DllExport void	DivideEdges (Mesh &m, BitArray eset, AdjEdgeList *el=NULL)
DllExport void	DivideFace (Mesh &m, DWORD f, float *bary=NULL)
DllExport void	DivideFaces (Mesh &m, BitArray fset, MeshOpProgress *mop=NULL)
DllExport void	EdgeTessellate (Mesh &m, BitArray fset, float tens, AdjEdgeList *ae=NULL, AdjFaceList *af=NULL, MeshOpProgress *mop=NULL)
DllExport void	ExplodeFaces (Mesh &m, float thresh, bool useFaceSel=FALSE, AdjFaceList *af=NULL)
DllExport void	ExtrudeEdges (Mesh &m, BitArray eset, Tab< Point3 > *edir=NULL)
DllExport void	ExtrudeFaces (Mesh &m, BitArray fset, AdjEdgeList *el=NULL)
DllExport void	ResetVertCorners (Mesh &m)
DllExport void	ResetVertWeights (Mesh &m)
void	SetFaceAlpha (Mesh &m, BitArray fset, float alpha, int mp=MAP_ALPHA)
void	SetVertAlpha (Mesh &m, BitArray vset, float alpha, int mp=MAP_ALPHA)
DllExport void	SetFaceColors (Mesh &m, BitArray fset, VertColor vc, int mp=0)
DllExport void	SetVertColors (Mesh &m, BitArray vset, VertColor vc, int mp=0)
DllExport void	SetVertCorners (Mesh &m, BitArray vset, float corner)
DllExport void	SetVertWeights (Mesh &m, BitArray vset, float weight)
DllExport DWORD	TurnEdge (Mesh &m, DWORD ed, AdjEdgeList *el=NULL)
DllExport BOOL	WeldByThreshold (Mesh &m, BitArray vset, float thresh)
DllExport void	WeldVertSet (Mesh &m, BitArray vset, Point3 *weldPoint=NULL)
DllExport void	PropagateFacing (Mesh &m, BitArray &fset, int face, AdjFaceList &af, BitArray &done, BOOL bias=1)
DllExport void	UnifyNormals (Mesh &m, BitArray fset, AdjFaceList *af=NULL)
DllExport void	Slice (Mesh &m, Point3 N, float off, bool sep=FALSE, bool remove=FALSE, BitArray *fslice=NULL, AdjEdgeList *ae=NULL)
Public Member Functions inherited from BaseInterfaceServer
virtual UtilExport BaseInterface *	GetInterface (Interface_ID id)
virtual UtilExport int	NumInterfaces () const
virtual UtilExport BaseInterface *	GetInterfaceAt (int i) const
virtual UtilExport	~BaseInterfaceServer ()
Public Member Functions inherited from InterfaceServer
virtual UtilExport	~InterfaceServer ()
	Destructor. More...

Public Attributes
DWORD	vnum
DWORD	fnum
Tab< VertMove >	vMove
Tab< VertMove >	vClone
BitArray	vDelete
Tab< FaceCreate >	fCreate
Tab< FaceRemap >	fRemap
Tab< FaceChange >	fChange
Tab< FaceSmooth >	fSmooth
BitArray	fDelete
BitArray	vsel
BitArray	esel
BitArray	fsel
BitArray	vhide
MapDelta *	map
BitArray	mapSupport
VDataDelta *	vd
BitArray	vdSupport

Additional Inherited Members
Static Public Member Functions inherited from MaxHeapOperators
static UtilExport void *	operator new (size_t size)
	Standard new operator used to allocate objects If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator 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. More...
static UtilExport void *	operator 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. More...
static UtilExport void *	operator 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. More...
static UtilExport void *	operator 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. More...
static UtilExport void *	operator 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. More...
static UtilExport void *	operator 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. More...
static UtilExport void *	operator new[] (size_t size)
	New operator used to allocate arrays of objects If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator 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. More...
static UtilExport void *	operator 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. More...
static UtilExport void *	operator new[] (size_t size, int block_type, const char *filename, int line)
	New operator used to allocate arrays of objects. More...
static UtilExport void *	operator 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. More...
static UtilExport void *	operator 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. More...
static UtilExport void *	operator 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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
static UtilExport void *	operator new (size_t size, void *placement_ptr)
	Placement new operator. More...
static UtilExport void	operator delete (void *ptr, void *placement_ptr)
	Placement delete operator. More...
Protected Attributes inherited from BaseInterfaceServer
Tab< BaseInterface * >	interfaces

Constructor & Destructor Documentation

DllExport MeshDelta

(

)

Remarks

Constructor. Initializes the MeshDelta with NULL pointers and 0's for input mesh size.

DllExport MeshDelta

(

const Mesh &

m

)

Remarks

Constructor. Initializes the MeshDelta to be based on the mesh given. MapDeltas and VDataDeltas are allocated as appropriate, and vnum and fnum are set.

DllExport ~MeshDelta

(

)

Remarks

Destructor. Frees all allocated memory, including the MapDeltas.

Member Function Documentation

DllExport void InitToMesh

(

const Mesh &

m

)

Remarks

Initializes the MeshDelta to the mesh given, setting map and vdata support as appropriate. Does NOT clear out existing changes.

Parameters:

const Mesh &m The mesh to init from.

DllExport void ClearAllOps

(

)

Remarks

Clears out all existing mesh changes. Zeroes all the vCreate, vMove, etc arrays, as well as those in the active MapDeltas. Does not clear memory.

DllExport void SetMapNum	(	int	n,
		bool	keep = TRUE
	)

Remarks

Sets the number of map channels used by the MeshDelta - allocates the "map" array.

Parameters:

int num The number of maps to allocate. bool keep=TRUE If TRUE any previous maps are kept; otherwise they are discarded.

int GetMapNum ( )

inline

Remarks

Gets the number of map channels in the MeshDelta - equivalent to mapSupport.GetSize().

{ return mapSupport.GetSize(); }

MapDelta& Map ( int  mp )

inline

Remarks

Data accessor - gets the MapDelta for the specified map channel. Since in 4.0 we now have "hidden map channels" which are accessed by negative indices (-1 for MAP_SHADING, for example), data accessor methods like this one should be used instead of the actual arrays. (Hidden map channels are stored in a new private data member, not as part of the public map array.)

{ return (mp<0) ? hmap[-1-mp] : map[mp]; }

bool getMapSupport ( int  mp )

inline

Remarks

Indicates whether the specified map channel is supported by this MeshDelta. Since in 4.0 we now have "hidden map channels" which are accessed by negative indices (-1 for MAP_SHADING, for example), data accessor methods like this one should be used instead of the actual data members. (Hidden map channel support information is stored in a new private data member, not as part of the public mapSupport BitArray.)

{ return ((mp<0) ? hmapSupport[-1-mp] : mapSupport[mp]) ? true : false; }

void setMapSupport ( int  mp, bool  val = true  )

inline

Remarks

Sets map support in this MeshDelta for the specified map channel. Since in 4.0 we now have "hidden map channels" which are accessed by negative indices (-1 for MAP_SHADING, for example), data accessor methods like this one should be used instead of the actual data members. (Hidden map channel support information is stored in a new private data member, not as part of the public mapSupport BitArray.)

{ if (mp<0) hmapSupport.Set(-1-mp, val); else mapSupport.Set(mp, val); }

bool hasMapSupport ( )

inline

Remarks

Indicates whether any map channel is supported by this MeshDelta.

{ return !(mapSupport.IsEmpty() && hmapSupport.IsEmpty()); }

DllExport void SetVDataNum	(	int	size,
		bool	keep = TRUE
	)

Remarks

Sets the number of vertex data channels used by the MeshDelta

• allocates the "vd" array.

Parameters:

int num The number of vertex data channels to allocate. bool keep=TRUE If TRUE any previous vertex data channels are kept; otherwise they are discarded.

int GetVDataNum ( )

inline

Remarks

Gets the number of vertex data channels in the MeshDelta - equivalent to vdSupport.GetSize().

{ return vdSupport.GetSize(); }

DllExport ChannelMask PartsChanged

(

)

Remarks

Indicates what data channels of a mesh would be changed by this MeshDelta. For instance, a MeshDelta with vertex moves but no other changes would return GEOM_CHANNEL|SELECT_CHANNEL. GEOM_CHANNEL represents the moves, and SELECT_CHANNEL represents the fact that MeshDeltas always overwrite selection info. Most of the changes in a MeshDelta will alter TOPO_CHANNEL. VERTCOLOR_CHANNEL and TEXMAP_CHANNEL may also be returned. This is especially useful for knowing what parts of a mesh to back up in a restore object for an undo/redo. (See the SDK implementation of Editable Mesh for an example of this.) Also, it can be used for invalidating temporary data, as in both Edit and Editable Mesh.

DllExport void Apply

(

Mesh &

mesh

)

Remarks

Changes the given mesh by this MeshDelta, in the following manner: First, any maps that are supported by the MeshDelta but not by the mesh are assigned to the mesh in their default form. (Vertex color channels are white, and other maps are copies of the mesh vertices. All have the same topology as the mesh.) Next, any UNDEFINED mapping verts in the MeshDelta are filled in by FillInFaces. Then the new vertices are added, creates first, followed by clones. The original vertices are then moved. The faces are then modified, by applying all the FaceRemaps, FaceChanges, and FaceSmooths to the appropriate faces. New faces (in fCreate) are appended to the end of the face list. Map changes are applied to all active maps, and map channels not supported by this MeshDelta are removed. After all that is done, the vertices and faces marked in the vDelete and fDelete arrays are deleted. Finally, the vertex data, vertex hide, and selections kept in the MeshDelta are applied to the result.

MeshDelta& operator= ( MeshDelta &  td )

inline

Remarks

Assignment operator - makes this MeshDelta just like the one given.

{ CopyMDChannels (td, MDELTA_ALL); return *this; }

MeshDelta& operator*= ( MeshDelta &  td )

inline

Remarks

Appends the given MeshDelta to the current one.

Parameters:

MeshDelta & td The MeshDelta to append. This MeshDelta may be modified to make it suitable, ie the vnum and fnum values will be set to the expected output of the current MeshDelta if they don't already match. (This may result in the loss of some data - see "SetInVNum" and "SetInFNum" for more information.)

{ Compose(td); return *this; }

DllExport void Compose

(

MeshDelta &

td

)

Remarks

Appends the given MeshDelta to the current one.

Parameters:

MeshDelta & td The MeshDelta to append. This MeshDelta may be modified to make it suitable, ie the vnum and fnum values will be set to the expected output of the current MeshDelta if they don't already match. (This may result in the loss of some data - see "SetInVNum" and "SetInFNum" for more information.)

DllExport DWORD ChangeFlags

(

Tab< DWORD > *

mChannels = NULL

)

Remarks

Indicates what parts of a MeshDelta could be changed if this MeshDelta were appended to it. This is useful when backing up MeshDelta for Restore Objects. For instance, if you had a MeshDelta with lots of face smoothing changes, and you wanted to compose it with one that only moved vertices, there would be no reason to back up the smoothing changes for an undo.

Parameters:

Tab<DWORD> *mChannels=NULL If non-NULL, this points to a table that should be filled with change flags for the various map channels. The table is set to the number of map channels, and each DWORD in it is filled in by calling MapDelta::ChangeFlags on the appropriate map channel (or left at zero if the map channel is inactive.)

Returns

Returns some combination of the following flags, corresponding to the data members that would be changed: MDELTA_VMOVE MDELTA_VCREATE MDELTA_VCLONE MDELTA_VDELETE MDELTA_VDATA MDELTA_FREMAP MDELTA_FCHANGE MDELTA_FCREATE MDELTA_FDELETE MDELTA_FDATA MDELTA_NUMBERS MDELTA_FSMOOTH Note that in 4.0 and thereafter, the MDELTA_VCREATE and MDELTA_VCLONE flags are identical and represent the same information. (This was not true in 3.0 or 3.1.)

DllExport void CopyMDChannels	(	MeshDelta &	from,
		DWORD	channels,
		Tab< DWORD > *	mChannels = NULL
	)

Remarks

Copies the specified parts of the MeshDelta. (Useful in combination with ChangeFlags to create efficient Restore objects.)

Parameters:

MeshDelta & from The MeshDelta to copy into this. DWORD channels Indicates the parts to copy - some combination of the following flags: MDELTA_VMOVE MDELTA_VCREATE MDELTA_VCLONE MDELTA_VDELETE MDELTA_VDATA MDELTA_FREMAP MDELTA_FCHANGE MDELTA_FCREATE MDELTA_FDELETE MDELTA_FDATA MDELTA_NUMBERS MDELTA_FSMOOTH Note that in 4.0 and thereafter, the MDELTA_VCREATE and MDELTA_VCLONE flags are identical and represent the same information. (This was not true in 3.0 or 3.1.) Tab<DWORD> *mChannels=NULL If non-NULL, this points to a table that contains channels to copy in the various map channels. The table should be of the size of the number of map channels. For each active map channel in from, the corresponding DWORD in this table is passed in MapDelta::CopyMDChannels to copy the relevant parts of the map.

DllExport DWORD NumVMove

(

DWORD

inVNum

)

Remarks

Returns the number of vertex moves that would be applied to a mesh with the specified number of vertices. If that number equals this MeshDelta's vnum, this is simply vMove.Count().

Parameters:

DWORD inVNum The number of vertices in the input mesh we're inquiring about.

DllExport DWORD NumVClone

(

DWORD

inVNum

)

Remarks

Returns the number of vertex clones & creates that would be applied to a mesh with the specified number of vertices. If that number equals this MeshDelta's vnum, this is simply vClone.Count(). If, however, inVNum is lower than the expected vnum, some of the clones might be eliminated, reducing this number.

Parameters:

DWORD inVNum The number of vertices in the input mesh we're inquiring about.

DllExport DWORD NumVDelete

(

DWORD

inVNum

)

Remarks

Returns the number of vertex deletes that would be applied to a mesh with the specified number of vertices. If that number equals this MeshDelta's vnum, this is simply vDelete.NumberSet ().

Parameters:

DWORD inVNum The number of vertices in the input mesh we're inquiring about.

DllExport DWORD NumFDelete

(

DWORD

inFNum

)

Remarks

Returns the number of face deletes that would be applied to a mesh with the specified number of faces. If inFNum equals this MeshDelta's fnum, this is simply fDelete.NumberSet ().

Parameters:

DWORD inFNum The number of faces in the input mesh we're inquiring about.

int NumFCreate ( )

inline

Remarks

Returns the number of face creates in this MeshDelta.

{ return fCreate.Count(); }

DllExport void SetInFNum

(

int

nface

)

Remarks

Sets the number of faces in the input mesh. NOTE that if nface is less than the current fnum, the data relating to the extra faces will be lost. (That is, if one of your face remaps is applied to face 32, and you SetInFNum to 30, that face remap will be lost, and will not be recovered if you later SetInFNum to 35.) It is NOT necessary to call this method before applying this MeshDelta to a smaller than expected Mesh.

Parameters:

int nface The number of faces expected from the input mesh.

DllExport void SetInVNum

(

int

nv

)

Remarks

Sets the number of vertices in the input mesh. NOTE that if nv is less than the current vnum, the data relating to the extra vertices will be lost. (That is, if one of your vertex moves is applied to vertex 32, and you SetInVNum to 30, that vertex move will be lost, and will not be recovered if you later SetInVNum to 35.) It is NOT necessary to call this method before applying this MeshDelta to a smaller than expected Mesh.

Parameters:

int nv The number of vertices expected from the input mesh.

int outVNum ( )

inline

Remarks

Returns the number of vertices in the output mesh, assuming that the input mesh is of the expected (vnum) size.

{ return vnum + vClone.Count() - vDelete.NumberSet(); }

int outVNum ( int  inVNum )

inline

Remarks

Returns the number of vertices in the output mesh, assuming that the input mesh has the specified number of vertices.

Parameters:

int inVNum The number of vertices expected in the input mesh.

{ return inVNum + NumVClone(inVNum) - NumVDelete(inVNum); }

int outFNum ( )

inline

Remarks

Returns the number of faces in the output mesh, assuming that the input mesh is of the expected (fnum) size.

{ return fnum + fCreate.Count() - fDelete.NumberSet(); }

int outFNum ( int  inFNum )

inline

Remarks

Returns the number of faces in the output mesh, assuming that the input mesh has the specified number of faces.

Parameters:

DWORD inFNum The number of faces expected in the input mesh.

{ return inFNum + fCreate.Count() - NumFDelete(inFNum); }

DllExport void FillInFaces

(

Mesh &

m

)

Remarks

To make things easy for developers, it's possible to create or remap mapping faces to use UNDEFINED mapping verts. This routine, which is called by Apply below, fills in those UNDEFINED mapping values with the mapping vertices used by neighboring faces, or, if necessary, by new mapping vertices. (These new mapping vertices are always (.5,.5,0) for regular map channels or (1,1,1) for the vertex color channel.) This process does not produce very good maps, but it allows a sort of minimal mapping support that prevents maps from being lost before the user can make their manual corrections.

DllExport void AddVertexColors

(

)

Remarks

Activates the vertex color MapDelta, adding whatever new map verts or faces are needed to match the current MeshDelta. After calling this method, applying this MeshDelta to a mesh without vertex colors will result in a vertex color map with all white vertices and a topology identical to the mesh.

DllExport void AddMap

(

int

mapID

)

Remarks

Activates the specified MapDelta, adding whatever new map verts or faces are needed to match the current MeshDelta. If mapID is 0, the standard vertex colors (white) will be applied (see AddVertexColors). Otherwise, after calling this method, applying this MeshDelta to a mesh without the specified map active will result in a map with the same topology as the mesh and UVVerts that are copies of the mesh vertices.

Parameters:

int mapID The map channel to add. 0 represents vertex colors, 1 is the original map channel (referred to in class Mesh by tVerts and tvFaces), and 2-99 are the new map channels (stored in meshes in the MeshMap class).

DllExport void AddVertexData	(	int	vdChan,
		Mesh *	m = NULL
	)

Remarks

Activates the specified vertex data channel, creating a default set of vertex data to match the output of the current MeshDelta. ("Default" values of vertex data depend on the channel, and are given by VDataDefault (vdChan).)

Parameters:

int vdChan The vertex data channel Mesh *m=NULL A pointer to the Mesh object.

DllExport void UpdateLUTs	(	int	extraV = 0,
		int	extraF = 0
	)

Remarks

Updates the MeshDelta's internal lookup tables, which make use of all delete and create records to set up a correspondence between output and input vertices and faces.

Parameters:

int extraV If nonzero, this indicates the number of extra spaces that should be added to the lookup table. This is useful for example if you want the lookup table to still be valid after the next <extraV> vertex creates or clones. int extraF If nonzero, this indicates the number of extra spaces that should be added to the lookup table. This is useful for example if you want the lookup table to still be valid after the next <extraF> face creates.

DllExport void ClearLUTs

(

)

Remarks

Invalidates and clears the lookup tables. This usually only needs to be called internally.

DllExport DWORD VLut

(

DWORD

i

)

Remarks

Finds the input mesh index of the vertex with the specified output mesh index. Note that these indices are the same if there are no vertex deletes.

Parameters:

DWORD i The output mesh index.

Returns

The input mesh index of the same vertex. If the vertex specified is actually created by this MeshDelta, the return value would be vnum+i for vClone[i].

DllExport DWORD FLut

(

DWORD

i

)

Remarks

Finds the input mesh index of the face with the specified output mesh index. Note that these indices are the same if there are no face deletes.

Parameters:

DWORD i The output mesh index.

Returns

The input mesh index of the same face. If the face specified is actually created by this MeshDelta, the return value would be fnum+i for fCreate[i].

DllExport DWORD PostVIndex

(

DWORD

i

)

Remarks

Returns the index in the output mesh of the specified input vertex. Note that these indices are the same if there are no vertex deletes.

Parameters:

DWORD i The index of the vertex in the input mesh.

Returns

The output mesh index of the same vertex. If the vertex was deleted in this MeshDelta, UNDEFINED is returned.

DllExport DWORD PostFIndex

(

DWORD

i

)

Remarks

Returns the index in the output mesh of the specified input face. Note that these indices are the same if there are no face deletes.

Parameters:

DWORD i The index of the face in the input mesh.

Returns

The output mesh index of the same face. If the face was deleted in this MeshDelta, UNDEFINED is returned.

bool IsVClone ( DWORD  i )

inline

Remarks

Indicates whether or not the specified vertex is created in this MeshDelta.

Parameters:

DWORD i The output-based vertex index.

{ int j=VLut(i)-vnum; return ((j>=0) && (j<vClone.Count())); }

DWORD VCloneOf ( DWORD  i )

inline

Remarks

Tells you what input vertex the specified output vertex is a clone of.

Parameters:

DWORD i The output-based vertex index.

Returns

The index in the input mesh of the original vertex this one's a clone of. If this vertex is not a clone, UNDEFINED is returned.

{ int j=VLut(i)-vnum; return ((j>=0) && (j<vClone.Count())) ? vClone[j].vid : UNDEFINED; }

bool IsVCreate ( DWORD  i )

inline

Remarks

No longer used. This method was used in 3.0 and 3.1 to indicate whether the specified vertex was created as a create, not a clone in this MeshDelta. In 4.0, we integrated the clone and create records together, and this method is now set to always return FALSE.

Parameters:

DWORD i The output-based vertex index.

{ return FALSE; }

bool IsFCreate ( DWORD  i )

inline

Remarks

Indicated whether the specified face was created in this MeshDelta.

Parameters:

DWORD i The face index in the output mesh.

{ int j=FLut(i)-fnum; return ((j>=0) && (j<fCreate.Count())); }   

DllExport DWORD MoveID

(

DWORD

i

)

Remarks

Obtains the index of the vMove entry that relates to this vertex.

Parameters:

DWORD i The input-based vertex index.

Returns

The index in the vMove array of the vertex move corresponding to this vertex, or UNDEFINED if this vertex has no move associated with it.

DllExport DWORD VCreate	(	Point3 *	p,
		int	num = 1,
		BitArray *	sel = NULL,
		BitArray *	hide = NULL
	)

Remarks

Creates new vertices.

Parameters:

Point3 *p A pointer to an array of points representing the new vertices. int num The size of the point array. BitArray *sel=NULL If non-NULL, this points to a BitArray of size num that indicates which of these new vertices should be selected. (If NULL, none of the new vertices are selected.) BitArray *hide=NULL If non-NULL, this points to a BitArray of size num that indicates which of these new vertices should be hidden. (If NULL, none of the new vertices are hidden.)

Returns

The index (in the output mesh) of the first of these new vertices.

DllExport DWORD VClone	(	DWORD *	v,
		int	num = 1
	)

Remarks

Clones some vertices.

Parameters:

DWORD *v A pointer to an array of indices of verts that should be cloned. int num The size of the array.

Returns

The index (in the output mesh) of the first of the clones.

DllExport DWORD VClone	(	DWORD *	v,
		Point3 *	off,
		int	num = 1
	)

Remarks

Clones some vertices.

Parameters:

DWORD *v A pointer to an array of ids of vertices that should be cloned. Point3 *off A pointer to an array of offsets for the clones. int num The size of the arrays.

Returns

The index (in the output mesh) of the first of the clones.

DllExport DWORD VClone	(	VertMove *	vm,
		int	num = 1
	)

Remarks

Clones some vertices.

Parameters:

VertMove *vm A pointer to an array of VertMoves indicating which vertices should be cloned and what offsets the clones should use. int num The size of the vm array.

Returns

The index (in the output mesh) of the first of the clones.

DWORD VClone ( DWORD  v )

inline

Remarks

Clones a single vertex.

Parameters:

DWORD v The index (in the output mesh) of the vertex you wish to clone.

Returns

The index (in the output mesh) of the clone.

{ return VClone (&v, 1); }

DWORD VClone ( DWORD  v, Point3  off  )

inline

Remarks

Clones and offsets a single vertex.

Parameters:

DWORD v The index (in the output mesh) of the vertex you wish to clone. Point3 off The desired offset from the original vertex.

Returns

The index (in the output mesh) of the clone.

{ return VClone (&v, &off, 1); }

DllExport void VDelete	(	DWORD *	v,
		int	num = 1
	)

Remarks

Deletes the specified vertices.

Parameters:

DWORD *v A pointer to an array of (output-based) ids of the vertices that should be deleted. int num The number of vertices to delete (the size of the v array).

DllExport void VDelete

(

BitArray &

vdel

)

Remarks

Deletes the specified vertices.

Parameters:

BitArray & vdel A BitArray, of size OutVNum, indicating which of the vertices should be deleted. Vertices in this array are indexed by output mesh order.

DllExport DWORD FCreate	(	Face *	f,
		int	num = 1
	)

Remarks

Creates new faces. Note: MapDeltas must be kept up to date with all new face creations - see CreateDefaultMapFaces.

Parameters:

Face *f A pointer to an array of faces to be added to the MeshDelta. int num The size of the face array.

Returns

The index (in the output mesh) of the first of these new faces.

DllExport DWORD FCreate	(	FaceCreate *	f,
		int	num = 1
	)

Remarks

Creates new faces. This is what's used to add in face creations in the all-important Compose method. It assumes that the "originals" in the array of FaceCreates are post-indexed, and uses FLut and extracts originals for creates-of-creates as appropriate. Note: MapDeltas must be kept up to date with all new face creations - see CreateDefaultMapFaces.

Parameters:

FaceCreate *f A pointer to an array of face create records to be added to the MeshDelta. int num The size of the face create array.

Returns

The index (in the output mesh) of the first of these new faces.

DllExport DWORD FCreateQuad	(	DWORD *	v,
		DWORD	smG = 0,
		MtlID	matID = 0,
		int	orig = UNDEFINED
	)

Remarks

Creates 2 new faces, forming a quad. Note: MapDeltas must be kept up to date with all new face creations - see CreateDefaultMapFaces.

Parameters:

DWORD *v A pointer to an array of 4 vertices to be used as corners of the quad. DWORD smG=0 The smoothing group desired for the new faces. MtlID matID=0 The material ID desired for the new faces. int orig=UNDEFINED This optional parameter sets the map faces to undefined.

Returns

The index (in the output mesh) of the first of these 2 new faces.

DllExport DWORD FClone	(	Face &	f,
		DWORD	ff,
		DWORD	remapFlags = 0,
		DWORD *	v = NULL
	)

Remarks

Creates a new face by copying an existing face. The result is put into the fCreate array and treated thereafter like a face create - this is different from vertex clones, which are maintained separately from vertex creates. Note: MapDeltas must be kept up to date with all new face creations - see CreateDefaultMapFaces.

Parameters:

Face & f The face we wish to clone. (This is typically generated by the outFace method.) DWORD ff The (output-based) index of the face we're cloning. (This is used to copy face and edge selection.) DWORD remapFlags=0 DWORD *v=NULL If we wish to remap any of the corners of this face while cloning, the appropriate flags and vertices should be passed in these last two arguments. v should point to an array of 3 vertex (output) indices, although the ones not marked as used by the remapFlags need not be set to anything in particular. See class FaceRemap for more information about face remapping.

Returns

The index (in the output mesh) of the new face.

DllExport void CreateDefaultMapFaces

(

int

num = 1

)

Remarks

MapDeltas must always keep their faces in sync with the parent MeshDelta. If the developer creates new faces, but doesn't want to go through the bother of figuring out exactly how the related map faces should look, this method may be used to create map faces with UNDEFINED verts. These can then be filled in automatically later. (See the MeshDelta FillInFaces method for details.) For every face created in the MeshDelta, either CreateDefaultMapFaces should be called, or map faces should be created in every active map channel, using MapDelta::FCreate and related methods.

Parameters:

int num=1 The number of default faces we wish to create in each active map channel.

DllExport void FRemap	(	FaceRemap *	f,
		int	num = 1
	)

Remarks

Adds face remaps to this MeshDelta. If the face specified in each FaceRemap already has a remap record, the two are combined. If the face specified is a face created by this MeshDelta, the remap is applied directly to the fCreate entry instead of being stored in fRemap.

Parameters:

FaceRemap *f A pointer to an array of FaceRemap that should be appended to this MeshDelta. Note that the faces and vertices in each FaceRemap must be indexed by their positions after all of the current MeshDelta's creates, clones, etc, but before any vertex or face deletes. Vertex index values of 0 through vnum-1 are considered to be the original mesh's vertices; values above this are cloned or created vertices. Likewise, face index values of 0 through fnum-1 are considered to be the original mesh faces, while fnum through fnum+fCreate.Count()-1 are this MeshDelta's face creates. int num=1 The number of elements in the FaceRemap array.

DllExport void FRemap	(	DWORD	f,
		DWORD	flags,
		DWORD *	v
	)

Remarks

Adds a face remap to this MeshDelta. If the face specified already has a remap record, the two are combined. If the face specified is a face created by this MeshDelta, the remap is applied directly to the fCreate entry instead of being stored in fRemap.

Parameters:

DWORD f The face to remap. Note that this face must be indexed by its position after all of the current MeshDelta's face creates, but before any face deletes. Face index values of 0 through fnum-1 are considered to be the original mesh faces, while fnum through fnum+fCreate.Count()-1 are this MeshDelta's face creates. DWORD flags Face Remap flags - these indicate which vertices should be remapped. The possibilities are FR_V0 (1), FR_V1 (2), and FR_V2 (4). (See class FaceRemap for more information.) DWORD *v A pointer to the vertices to remap the face to use. Only the positions indicated in the remap flags need contain meaningful data. Note that the vertices indicated here must be indexed by their positions after all of the current MeshDelta's creates and clones, but before any vertex deletes - essentially input-based indexing. Vertex index values of 0 through vnum-1 are considered to be the original mesh's vertices; values of vnum through vnum+vCreate.Count()-1 are considered to be this MeshDelta's newly created vertices; and values above this are cloned vertices.

DllExport void FChange	(	FaceChange *	f,
		int	num = 1
	)

Remarks

Appends some face changes to the current MeshDelta. Face changes can encompass changes to face material IDs, edge visibility, or face hiding. See class FaceChange for more information.

Parameters:

FaceChange *f A pointer to an array of new face changes for this MeshDelta. int num=1 The number of elements in the FaceChange array.

DllExport void FChange	(	DWORD	f,
		DWORD	flags,
		DWORD	dat
	)

Remarks

Changes the characteristics of one face.

Parameters:

DWORD f The output-indexed face to change. DWORD flags DWORD dat These two parameters describe the change desired. See class FaceChange for a description of these flags. flags indicates which characteristics should be set, and dat includes the on-or-off state of each flag we're setting. So for example FChange (26, ATTRIB_EDGE_A| ATTRIB_EDGE_B, ATTRIB_EDGE_A) would set face 26 to have the first edge visible and the second invisible, without changing the existing visibility for the third edge.

DllExport void FSmooth	(	FaceSmooth *	f,
		int	num = 1
	)

Remarks

Adds smoothing group changes to this MeshDelta. See class FaceSmooth for more information.

Parameters:

FaceSmooth *f A pointer to an array of smoothing change records. The face IDs in these records should be output-indexed. int num=1 The number of elements in the FaceSmooth array.

DllExport void FSmooth	(	DWORD	f,
		DWORD	mask,
		DWORD	val
	)

Remarks

Changes the smoothing groups on the specified face.

Parameters:

DWORD f The output-based index of the face to change. DWORD mask The smoothing groups to change. DWORD val The smoothing group values. For instance, FSmooth (32, 7, 2) would set smoothing group 2 and clear groups 1 and 3 for face 32, since mask has bits 0, 1, and 2 set but val only has bit 1 set.

void SetMatID ( DWORD  f, MtlID  mt  )

inline

Remarks

Sets the material ID for the specified face. If the face is created by this MeshDelta, the fCreate record is amended. If it's an input face, a FaceChange record is created or amended.

Parameters:

DWORD f The output-indexed face to change. MtlID mt The desired material ID.

{ FChange (f, ATTRIB_MATID, mt<<ATTRIB_MATID_SHIFT); }

void SetSmGroup ( DWORD  f, DWORD  smG  )

inline

Remarks

Sets the smoothing groups on the specified face.

Parameters:

DWORD f The output-based index of the face to change. DWORD smG The smoothing groups to set. All bits not set in this parameter are cleared.

{ FSmooth (f, ~DWORD(0), smG); }

void SetEdgeVis ( DWORD  f, DWORD  ed, BOOL  vis = TRUE  )

inline

Remarks

Sets the edge visibility for the specified side of the specified face. If the face is created by this MeshDelta, the fCreate record is amended. If it's an input face, a FaceChange record is created or amended.

Parameters:

DWORD f The output-indexed face to change. DWORD ed The side of the face to change (0, 1, or 2). BOOL vis=TRUE The desired visibility.

{ FChange (f, (1<<ed), vis?(1<<ed):0); }

DllExport void FDelete	(	DWORD *	f,
		int	num = 1
	)

Remarks

Deletes the specified faces.

Parameters:

DWORD *f A pointer to an array of output-based indices of faces we wish to delete. Note that all the elements should be based on the output before any deletions occur. So if you wanted to delete what are currently faces 3 and 5, you could pass an array with 3 and 5, you would not have to think, "Ah, 3 will be deleted, so I should use 4 instead of 5." int num=1 The size of the array.

DllExport void FDelete

(

BitArray &

fdel

)

Remarks

Deletes the specified faces.

Parameters:

BitArray & fdel The faces to delete. The faces are indexed by their output mesh positions.

DllExport void Move	(	int	i,
		const Point3 &	p
	)

Remarks

Moves a single vertex. (Note that if the same vertex is moved twice, the new move is simply added to the old one - there is never more than one VertMove in the vMove array for a single input vertex.)

Parameters:

int i The index of the vertex in the output mesh. const Point3 & p The vector to move the vertex by.

DllExport void Move	(	BitArray &	sel,
		const Point3 &	p
	)

Remarks

Moves the specified vertices. (Note that if the same vertex is moved twice, the new move is simply added to the old one - there is never more than one VertMove in the vMove array for a single input vertex.)

Parameters:

BitArray & sel Indicates which vertices should be moved. Vertices are indexed based on the output mesh. const Point3 & p The vector to move the vertices by.

DllExport void Move	(	VertMove *	vm,
		int	num
	)

Remarks

Adds in the specified vertex moves. (Note that if the same vertex is moved twice, the new move is simply added to the old one - there is never more than one VertMove in the vMove array for a single input vertex.)

Parameters:

VertMove *vm A pointer to an array of VertMoves to apply to this MeshDelta. Vertices are indexed based on the output mesh. int num The size of the VertMove array.

DllExport Point3 OutVert	(	Mesh &	m,
		DWORD	v
	)

Remarks

Returns the expected location in the output mesh of the specified vertex.

Parameters:

Mesh & m The input mesh. DWORD v The vertex you want the output location of. This index is input-based - the vertex index in m, not in the output mesh.

DllExport DWORD RemapID

(

DWORD

ff

)

Remarks

Obtains the index of the fRemap entry that relates to this face.

Parameters:

DWORD ff The input-based face index.

Returns

If there is such an entry, the index is returned, so fRemap[RemapID(ff)].fid == ff. If there is no remap record for this face, the method returns UNDEFINED.

DllExport DWORD IsRemapped	(	DWORD	ff,
		DWORD	vid
	)

Remarks

Tells whether the specified corner of the specified face has been remapped in this MeshDelta.

Parameters:

DWORD ff The input-based face index. DWORD vid The corner of the face - 0, 1, or 2.

Returns

If this corner has been remapped, it returns the vertex it's been remapped to. Otherwise, it returns UNDEFINED.

DllExport Face OutFace	(	Mesh &	m,
		DWORD	ff
	)

Remarks

Returns the specified face as it would appear in the MeshDelta output. Face Changes, Smooths, and Remaps are applied.

Parameters:

Mesh & m The input mesh. DWORD f The index of the face you want the output version of. This index is input-based

• the face index in m, not in the output mesh.

DllExport void GetSavingPermutations	(	int &	numCr,
		int &	numCl,
		Tab< int > &	vPermute,
		Tab< int > &	vPReverse
	)

DllExport void PermuteClonedVertices

(

Tab< int > &

vPermute

)

DllExport IOResult Save

(

ISave *

isave

)

Remarks

Saves the MeshDelta to a 3ds Max file.

DllExport IOResult Load

(

ILoad *

iload

)

Remarks

Loads the MeshDelta from a 3ds Max file.

DllExport void MyDebugPrint	(	bool	lut = FALSE,
		bool	mp = FALSE
	)

Remarks

Prints out the MeshDelta to the DebugPrint window in Developer Studio.

Parameters:

bool lut=FALSE If TRUE, the vertex and face lookup tables are printed out. bool mp=FALSE Active map deltas are also printed out if this is TRUE.

DllExport BOOL CheckOrder

(

)

DllExport BOOL CheckMapFaces

(

)

DllExport void AutoSmooth	(	Mesh &	m,
		BitArray	sel,
		float	angle,
		AdjFaceList *	af = NULL,
		AdjEdgeList *	ae = NULL
	)

Remarks

Automatically generates smoothing groups for the selected faces. Existing smoothing groups are ignored. See the AutoSmooth feature in Edit Mesh for an example.

Parameters:

Mesh & m The mesh, which should match the output of the current MeshDelta, that should be affected. BitArray sel The faces to AutoSmooth. float angle The maximum angle between faces that should be smoothed together. AdjFaceList *af=NULL A pointer to the adjacent face list for this mesh. If NULL, the method constructs its own AdjFaceList. AdjEdgeList *ae=NULL A pointer to the adjacent edge list for this mesh. If NULL, the method constructs its own AdjEdgeList.

DllExport void Bevel	(	Mesh &	m,
		BitArray	vset,
		float	outline,
		Tab< Point3 > *	odir,
		float	height,
		Tab< Point3 > *	hdir
	)

Remarks

Moves the selected vertices along the directions given to produce the movement corresponding to the mouse drags of a Bevel operation in Editable Mesh. Note that this method only changes geometry.

Parameters:

Mesh & m The mesh, which should match the output of the current MeshDelta, that should be affected. BitArray vset The set of vertices to move. float outline The amount of outlining to do in this Bevel move. Tab<Point3> *odir The outline direction for each vertex. This should be given by MeshTempData::OutlineDir. See the Edit Mesh source for details. float height The amount of extrusion to do in this Bevel move. Tab<Point3> *hdir The extrusion direction for each vertex. This should be given by MeshTempData::EdgeExtDir or FaceExtDir. See the Edit Mesh source for examples.

DllExport DWORD CreatePolygon	(	Mesh &	m,
		int	deg,
		int *	v,
		DWORD	smG = 0,
		MtlID	matID = 0
	)

Remarks

Create a polygon of any size. The polygon may be nonconvex, but should be (roughly) coplanar.

Parameters:

Mesh & m The mesh, which should match the output of the current MeshDelta, that should be affected. int deg The number of vertices used by this polygon (its degree). int *v The indices of the vertices in Mesh m that this polygon should use. DWORD smG=0 The desired smoothing group for the new polygon. MtlID matID=0 The desired material ID for the new polygon.

DllExport void DeleteVertSet	(	Mesh &	m,
		BitArray	sel
	)

Remarks

Deletes the specified vertices, along with any faces that used them.

Parameters:

Mesh & m The mesh, which should match the output of the current MeshDelta, that should be affected. BitArray sel The vertices to delete. Any face that uses any of the vertices selected here will also be deleted.

DllExport void DeleteEdgeSet	(	Mesh &	m,
		BitArray	sel
	)

Remarks

Deletes all faces using the specified edges. (Doesn't delete any verts.)

Parameters:

Mesh & m The mesh, which should match the output of the current MeshDelta, that should be affected. BitArray sel The edges to delete the faces of. Edges are indexed by face*3+side.

DllExport void DeleteFaceSet	(	Mesh &	m,
		BitArray	sel
	)

Remarks

Deletes the specified faces. (Doesn't delete any verts.)

Parameters:

Mesh & m The mesh, which should match the output of the current MeshDelta, that should be affected. BitArray sel The faces to delete.

DllExport void DeleteSelected

(

Mesh &

m

)

Remarks

Deletes the current subobject selection. If m.selLevel is MESH_OBJECT, nothing is deleted. If it's MESH_VERTEX, the faces using the selected vertices are also deleted.

Parameters:

Mesh & m The mesh, which should match the output of the current MeshDelta, that should be affected.

DllExport void DeleteIsoVerts

(

Mesh &

m

)

Remarks

Deletes the vertices not in use by any faces.

Parameters:

Mesh & m The mesh, which should match the output of the current MeshDelta, that should be affected.

DllExport void FlipNormal	(	Mesh &	m,
		DWORD	face
	)

Remarks

Flips the normal of the specified face (by switching the face's v[0] and v[1]). (Related map faces are also flipped.)

Parameters:

Mesh & m The mesh, which should match the output of the current MeshDelta, that should be affected. DWORD face The face to flip.

DllExport void MakeSelFacesPlanar	(	Mesh &	m,
		BitArray	sel
	)

Remarks

Flattens the faces indicated into the same plane. The target plane is determined by the average of all the face centers and the average of all the face normals.

Parameters:

Mesh & m The mesh, which should match the output of the current MeshDelta, that should be affected. BitArray sel The faces to make coplanar.

DllExport void MakeSelVertsPlanar	(	Mesh &	m,
		BitArray	sel
	)

Remarks

Flattens the vertices indicated into the same plane. The target plane is determined by the average position and normal of the vertices.

Parameters:

Mesh & m The mesh, which should match the output of the current MeshDelta, that should be affected. BitArray sel The vertices to make coplanar.

DllExport void MoveVertsToPlane	(	Mesh &	m,
		BitArray	sel,
		Point3 &	N,
		float	offset
	)

Remarks

Moves the vertices indicated into the specified plane. (The target plane is defined as all points which, when DotProd'd with N, return offset.) All vertices are moved along the normal vector N.

Parameters:

Mesh & m The mesh, which should match the output of the current MeshDelta, that should be affected. BitArray sel The vertices to move into the plane. Point3 & N The unit normal to the plane. float offset The offset of the plane (also its distance from the origin).

DllExport void RestrictMatIDs	(	Mesh &	m,
		int	numMats
	)

Remarks

Like the old standalone method "FitMeshIDsToMaterial", this method limits the material IDs to values between 0 and numMats-1. This is useful eg in matching the number of material Ids to the number of materials used on this node.

Parameters:

Mesh & m The mesh, which should match the output of the current MeshDelta, that should be affected. int numMats The number of material ids allowed.

DllExport void SelectFacesByFlags	(	Mesh &	m,
		BOOL	onoff,
		DWORD	flagmask,
		DWORD	flags
	)

Remarks

Sets or clears face selection depending on whether they match a pattern of flags. This is pretty much only useful for selecting or deselecting hidden faces: mdelta.SelectFacesByFlags(*mesh, FALSE, FACE_HIDDEN, FACE_HIDDEN); // deselects hidden faces.

Parameters:

Mesh & m The mesh, which should match the output of the current MeshDelta, that should be affected. BOOL onoff Indicates whether faces should be selected or deselected if they match the flag pattern. DWORD flagmask Indicates whether faces should be selected or deselected if they match the flag pattern. DWORD flags Indicates whether faces should be selected or deselected if they match the flag pattern.

DllExport void SetSingleEdgeVis	(	Mesh &	m,
		DWORD	ed,
		BOOL	vis,
		AdjFaceList *	adj = NULL
	)

DllExport void AttachMesh	(	Mesh &	m,
		Mesh &	attachment,
		Matrix3 &	relativeTransform,
		int	matOffset
	)

Remarks

Attaches another mesh to this one.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. Mesh & attachment The mesh this MeshDelta should attach. Matrix3 & relativeTransform The transform taking the attachment mesh from its object space to ours. int matOffset The offset that should be applied to all the material IDs in the attachment.

DllExport void BreakVerts	(	Mesh &	m,
		BitArray	vset
	)

Remarks

Splits the selected vertices into a separate vertex for every face that uses them.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray vset The vertices that should be broken.

DllExport void ChamferEdges	(	Mesh &	m,
		BitArray	eset,
		MeshChamferData &	mcd,
		AdjEdgeList *	ae = NULL
	)

Remarks

Performs the topological changes needed for an edge chamfer, and creates the information necessary to do the geometric changes.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray eset The edges to chamfer. MeshChamferData & mcd A class in which the directions and limits of movement for all the vertices involved in the chamfer should be stored. See class MeshChamferData. AdjEdgeList *ae=NULL A pointer to the adjacent edge list for this mesh. If NULL, the method constructs its own AdjEdgeList.

DllExport void ChamferMove	(	Mesh &	m,
		MeshChamferData &	mcd,
		float	amount,
		AdjEdgeList *	ae = NULL
	)

Remarks

Moves the relevant vertices to a specified chamfer value.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. MeshChamferData & mcd A class in which the directions and limits of movement for all the vertices involved in the chamfer have been stored by a previous ChamferVertices or ChamferEdges call. See class MeshChamferData. float amount The amount (in object space units) of chamfering to do. For vertex chamfers, this indicates how far along the edges each point should move. For edge chamfers, it represents how far along each face each edge should move. AdjEdgeList *ae=NULL A pointer to the adjacent edge list for this mesh. If NULL, the method constructs its own AdjEdgeList.

DllExport void ChamferVertices	(	Mesh &	m,
		BitArray	vset,
		MeshChamferData &	mcd,
		AdjEdgeList *	ae = NULL
	)

Remarks

Performs the topological changes needed for a vertex chamfer, and creates the information necessary to do the geometric changes.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray vset The vertices that should be chamfered. MeshChamferData & mcd A class in which the directions and limits of movement for all the vertices involved in the chamfer should be stored. See class MeshChamferData. AdjEdgeList *ae=NULL A pointer to the adjacent edge list for this mesh. If NULL, the method constructs its own AdjEdgeList.

DllExport void CloneFaces	(	Mesh &	m,
		BitArray	fset
	)

Remarks

Clones the specified faces, along with the vertices and mapping vertices they use.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray fset The faces that should be cloned.

DllExport void CloneVerts	(	Mesh &	m,
		BitArray	vset
	)

Remarks

Clones the specified vertices. More efficient on an initialized MeshDelta than VClone, which has to be able to cope with existing complex MeshDeltas.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray vset The vertices that should be cloned.

DllExport void CollapseEdges	(	Mesh &	m,
		BitArray	ecol,
		AdjEdgeList *	ae = NULL
	)

Remarks

Collapses the edges indicated down to a point.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray ecol The edges to collapse. AdjEdgeList *ae=NULL A pointer to the adjacent edge list for this mesh. If NULL, the method constructs its own AdjEdgeList.

DllExport DWORD Cut	(	Mesh &	m,
		DWORD	ed1,
		float	prop1,
		DWORD	ed2,
		float	prop2,
		Point3 &	norm,
		bool	fixNeighbors = TRUE,
		bool	split = FALSE
	)

Remarks

Cuts the mesh from a point on one edge to a point on another, along a line drawn by looking at the mesh from a particular viewpoint. (See Edit Mesh's Cut feature for an illustration.)

Parameters:

Mesh & m The mesh this MeshDelta should be based on. DWORD ed1 The edge that the cut starts on. The edge is indexed by face*3+side, so the start vertex is m.faces[ed1/3].v[ed1%3], and the end vertex is m.faces[ed1/3].v[(ed1+1)%3]. float prop1 The position on the edge to start the cut from. 0 means the start vertex of the edge, and 1 means the end vertex. DWORD ed2 The edge that the cut should end on. float prop2 The position on the edge to finish the cut on. 0 means the start vertex of the edge, and 1 means the end vertex. Point3 &norm The direction of view. The cut will take place on this "side" of the mesh, in the plane formed by this vector and the direction from the start to the end. bool fixNeigbors=TRUE Indicates whether the faces on the other side of each end of the cut should be split to prevent splits at the ends. bool split=FALSE Indicates whether the cut should actually split the mesh apart or just refine it by adding geometry.

DllExport void Detach	(	Mesh &	m,
		Mesh *	out,
		BitArray	fset,
		BOOL	faces,
		BOOL	del,
		BOOL	elem
	)

Remarks

Detaches a subset of the geometry from the mesh given, either separating it as a new element or creating a new mesh with it.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. Mesh *out The new mesh into which the detached portion can be put. (If elem is TRUE, this is not used and may be NULL.) BitArray fset The selection to detach. If faces is TRUE, this is a face selection. Otherwise, it's a vertex selection. BOOL faces If TRUE, we should detach the selected faces; otherwise, we should detach the selected vertices. BOOL del Indicates whether the detached portion should be deleted from the original mesh. BOOL elem If TRUE, we're actually just detaching to an element, and the out mesh will not be used.

DllExport void DivideEdge	(	Mesh &	m,
		DWORD	ed,
		float	prop = .5f,
		AdjEdgeList *	el = NULL,
		bool	visDiag1 = FALSE,
		bool	fixNeighbors = TRUE,
		bool	visDiag2 = FALSE,
		bool	split = FALSE
	)

Remarks

Divides the specified edge, adding a point and dividing faces to match.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. DWORD ed The edge to divide, indexed as face*3+side. float prop=.5f The proportion along the edge where the division should occur. 0 is the start vertex, m.faces[ed/3].v[ed%3], and 1 is the end vertex, m.faces[ed/3].v[(ed+1)%3]. AdjEdgeList *el=NULL A pointer to the adjacent edge list for this mesh. If NULL, the method constructs its own AdjEdgeList if needed. bool visDiag1=FALSE Indicates whether the diagonal connecting the new point on this edge with the far corner of face ed/3 should be visible. bool fixNeighbors=TRUE Indicates whether the face on the other side of this edge, that is, the face using this edge that isn't ed/3, should be divided as well to prevent the introduction of a seam. bool visDiag2=FALSE Indicates whether the diagonal connecting the new point on this edge with the far corner of the face on the other side of the edge should be visible. (Not used if fixNeighbors is FALSE.) bool split=FALSE Indicates whether the method should create separate vertices for the two halves of the edge, splitting the mesh open along the diagonal(s).

DllExport void DivideEdges	(	Mesh &	m,
		BitArray	eset,
		AdjEdgeList *	el = NULL
	)

Remarks

Divides all the selected edges in half, creating new points and subdividing faces.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray eset The edges to divide. AdjEdgeList *ae=NULL A pointer to the adjacent edge list for this mesh. If NULL, the method constructs its own AdjEdgeList.

DllExport void DivideFace	(	Mesh &	m,
		DWORD	f,
		float *	bary = NULL
	)

Remarks

Divides the selected face into 3, by introducing a new point on the face and splitting the original face along lines from the corners to the new point.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. DWORD f The face to divide. float *bary=NULL A pointer to the barycentric coordinates of the new point on the face. If NULL, the center of the face is used. Barycentric coordinates on a triangle are a set of three numbers between 0 and 1 that add up to 1. Any point on a triangle can be uniquely described by a set of these. The point corresponding to barycentric coordinates (a,b,c) on a face with corners A,B,C is a*A + b*B + c*C.

DllExport void DivideFaces	(	Mesh &	m,
		BitArray	fset,
		MeshOpProgress *	mop = NULL
	)

Remarks

Divides the selected faces into 3, by creating their center points and splitting the original faces along lines from the corners to the center.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray fset The faces to divide. MeshOpProgress *mop=NULL If non-NULL, this points to an implementation of class MeshOpProgress which can be used to interrupt the algorithm if it's taking too long. See class MeshOpProgress for details.

DllExport void EdgeTessellate	(	Mesh &	m,
		BitArray	fset,
		float	tens,
		AdjEdgeList *	ae = NULL,
		AdjFaceList *	af = NULL,
		MeshOpProgress *	mop = NULL
	)

Remarks

Tessellates the mesh. This algorithm is exactly the one used in the Tessellate modifier, when operating on "Faces" (triangle icon) and in "Edge" type.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray fset The faces to tessellate. float tens The tension for the edge tessellation. This value should be fairly small, between 0 and .5, and corresponds to the value in the Tessellate, Edit Mesh, or Editable Mesh UI's divided by 400. AdjEdgeList *ae=NULL A pointer to the adjacent edge list for this mesh. If NULL, the method constructs its own AdjEdgeList. AdjFaceList *af=NULL A pointer to the adjacent face list for this mesh. If NULL, the method constructs its own AdjFaceList. MeshOpProgress *mop=NULL If non-NULL, this points to an implementation of class MeshOpProgress which can be used to interrupt the algorithm if it's taking too long. See class MeshOpProgress for details.

DllExport void ExplodeFaces	(	Mesh &	m,
		float	thresh,
		bool	useFaceSel = FALSE,
		AdjFaceList *	af = NULL
	)

Remarks

"Explodes" the mesh into separate elements.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. float thresh The threshold angle between faces that indicates whether they should be in the same or different element. bool useFaceSel=FALSE Indicates whether the mesh's current face selection should be used or if the whole mesh should be exploded. AdjFaceList *af=NULL A pointer to the adjacent face list for this mesh. If NULL, the method constructs its own AdjFaceList.

DllExport void ExtrudeEdges	(	Mesh &	m,
		BitArray	eset,
		Tab< Point3 > *	edir = NULL
	)

Remarks

Performs the topological changes necessary to extrude the indicated edges. (The geometric component is handled later by the Bevel method.)

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray eset The edges to extrude. Tab<Point3> *edir=NULL Fills in the directions for moving all the relevant vertices to handle the geometric part of the extrusion. See the Edit Mesh or Editable Mesh source in MAXSDK/SAMPLES/MODIFIERS and MAXSDK/SAMPLES/MESH/EDITABLEMESH to see how this is used.

DllExport void ExtrudeFaces	(	Mesh &	m,
		BitArray	fset,
		AdjEdgeList *	el = NULL
	)

Remarks

Performs the topological changes necessary to extrude the indicated faces. (The geometric component is handled later by the Bevel method.)

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray fset The faces that should be extruded. AdjEdgeList *el=NULL A pointer to the adjacent edge list for this mesh. If NULL, the method constructs its own AdjEdgeList.

DllExport void ResetVertCorners

(

Mesh &

m

)

Remarks

This method resets the vertex corners.

Parameters:

Mesh & m The mesh this MeshDelta should be based on.

DllExport void ResetVertWeights

(

Mesh &

m

)

Remarks

Resets all the vertex weights to 1.

Parameters:

Mesh & m The mesh this MeshDelta should be based on.

void SetFaceAlpha ( Mesh &  m, BitArray  fset, float  alpha, int  mp = MAP_ALPHA  )

inline

Remarks

Sets the indicated faces to have face alpha.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray fset The faces that should be affected. float alpha The amount of alpha int mp=MAP_ALPHA The map channel. Use 0 for normal vertex colors, MAP_SHADING for the illumination channel, and MAP_ALPHA for the alpha channel.

{ SetFaceColors (m, fset, UVVert(alpha,alpha,alpha), mp); }

void SetVertAlpha ( Mesh &  m, BitArray  vset, float  alpha, int  mp = MAP_ALPHA  )

inline

Remarks

Sets the indicated vertices to have face alpha.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray vset The vertices that should be affected. float alpha The amount of alpha int mp=MAP_ALPHA The map channel. Use 0 for normal vertex colors, MAP_SHADING for the illumination channel, and MAP_ALPHA for the alpha channel.

{ SetVertColors (m, vset, UVVert(alpha,alpha,alpha),mp); }

DllExport void SetFaceColors	(	Mesh &	m,
		BitArray	fset,
		VertColor	vc,
		int	mp = 0
	)

Remarks

Sets the indicated faces to have vertex colors all equal to the color value specified. (This often involves creating new vertex color map vertices, so faces that neighbor the indicated faces are not affected.)

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray fset The faces that should be affected. VertColor vc The desired color. int mp=0 The map channel. Use 0 for normal vertex colors, MAP_SHADING for the illumination channel, and MAP_ALPHA for the alpha channel.

DllExport void SetVertColors	(	Mesh &	m,
		BitArray	vset,
		VertColor	vc,
		int	mp = 0
	)

Remarks

Sets all vertex color map vertices associated with the indicated vertices to the specified color.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray vset The vertices that should be affected. If more than one map vertex is used at this vertex, all of them have their colors set. VertColor vc The desired color. int mp=0 The map channel. Use 0 for normal vertex colors, MAP_SHADING for the illumination channel, and MAP_ALPHA for the alpha channel.

DllExport void SetVertCorners	(	Mesh &	m,
		BitArray	vset,
		float	corner
	)

DllExport void SetVertWeights	(	Mesh &	m,
		BitArray	vset,
		float	weight
	)

Remarks

Sets the weights of the specified vertices. (These weight values are only used in MeshSmooth NURMS mode as of 3ds Max 3.0.)

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray vset The vertices that should have their weights set. float weight The weight to set.

DllExport DWORD TurnEdge	(	Mesh &	m,
		DWORD	ed,
		AdjEdgeList *	el = NULL
	)

Remarks

"Turns" the specified edge. Only works on edges that have a face on both sides. These two faces are considered as a quad, where this edge is the diagonal, and remapped so that the diagonal flows the other way, between the vertices that were opposite this edge on each face.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. DWORD ed The edge to turn, indexed as face*3+side. AdjEdgeList *ae=NULL A pointer to the adjacent edge list for this mesh. If NULL, the method constructs its own AdjEdgeList.

DllExport BOOL WeldByThreshold	(	Mesh &	m,
		BitArray	vset,
		float	thresh
	)

Remarks

Welds all vertices that are sufficiently close together.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray vset The vertices that are candidates for being welded. float thresh The maximum distance (in object space units) between two vertices that will allow them to be welded.

Returns

Returns TRUE if any vertices were welded, FALSE if none were within threshold.

DllExport void WeldVertSet	(	Mesh &	m,
		BitArray	vset,
		Point3 *	weldPoint = NULL
	)

Remarks

Welds the specified vertices together into one vertex, no matter how far apart they are.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray vset The vertices that should be welded. Point3 *weldPoint=NULL If non-NULL, this points to the location we'd like to put the weld result. (If NULL, the result is put at the average location of the selected vertices.)

DllExport void PropagateFacing	(	Mesh &	m,
		BitArray &	fset,
		int	face,
		AdjFaceList &	af,
		BitArray &	done,
		BOOL	bias = 1
	)

Remarks

This method is designed for internal use, in UnifyNormals, but may also be called directly.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray fset The faces that should be affected. int face The starting face to propagate normal directions from. AdjFaceList & af The adjacent face list corresponding to the mesh. Required, can't be made locally, for efficiency's sake. BitArray & done Keeps track of which faces have had their normals unified. Faces that are set here when the call is made will not be processed, and will not be crossed to reach other faces. Faces that are still clear upon completion were not processed, probably because they were on a separate element from "face". BOOL bias=1 Used to keep track of whether the current face has been oriented correctly. For example, if the starting face was not selected in fset, and therefore doesn't have the right orientation, but you still want selected faces in the same element to be corrected, you would submit FALSE here.

DllExport void UnifyNormals	(	Mesh &	m,
		BitArray	fset,
		AdjFaceList *	af = NULL
	)

Remarks

Unifies normals on selected faces, making the normals consistent from face to face.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. BitArray fset The faces that should be affected. Nonselected faces can be traversed by the algorithm, but they will not be corrected if their normals are pointing the "wrong" way. AdjFaceList *af=NULL A pointer to the adjacent face list corresponding to the mesh. If NULL, an adjacent face list is computed by the method.

DllExport void Slice	(	Mesh &	m,
		Point3	N,
		float	off,
		bool	sep = FALSE,
		bool	remove = FALSE,
		BitArray *	fslice = NULL,
		AdjEdgeList *	ae = NULL
	)

Remarks

Slices the mesh along the specified slicing plane.

Parameters:

Mesh & m The mesh this MeshDelta should be based on. Point3 N The normal of the slice plane. float off These parameters define the slicing plane as all points p satisfying the equation DotProd(p,N) = off. N should be normalized. bool sep=FALSE Indicates whether the slice should separate the mesh into two separate elements (if TRUE) or just refine the existing mesh by splitting faces (if FALSE). bool remove=FALSE Indicates whether the slice should remove the portion of the mesh "below" the slicing plane, where "below" is defined as the area where DotProd (p,N)

• off < 0. If remove is TRUE, sep is ignored. BitArray *fslice=NULL A bit array containing the list of faces to slice. AdjEdgeList *ae=NULL A pointer to the adjacent edge list for this mesh. If NULL, the method constructs its own AdjEdgeList.

Member Data Documentation

DWORD vnum

DWORD fnum

Tab<VertMove> vMove

Tab<VertMove> vClone

BitArray vDelete

Tab<FaceCreate> fCreate

Tab<FaceRemap> fRemap

Tab<FaceChange> fChange

Tab<FaceSmooth> fSmooth

BitArray fDelete

BitArray vsel

BitArray esel

BitArray fsel

BitArray vhide

MapDelta* map

BitArray mapSupport

VDataDelta* vd

BitArray vdSupport