MeshDelta Class Reference

Search for all occurrences

---

Detailed 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 is available in release 3.0 and later only.

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.

#include <meshdelta.h>

Inheritance diagram for MeshDelta:

List of all members.

Public Member Functions
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 ()
DllExport DWORD	PartsChanged ()
DllExport void	Apply (Mesh &mesh)
MeshDelta &	operator= (MeshDelta &td)
MeshDelta &	operator*= (MeshDelta &td)
DllExport void	Compose (MeshDelta &td)
DllExport DWORD	NumVMove (DWORD inVNum)
DllExport DWORD	NumVClone (DWORD inVNum)
DllExport DWORD	NumVDelete (DWORD inVNum)
DllExport DWORD	NumFDelete (DWORD inFNum)
int	NumFCreate ()
DllExport void	SetInFNum (int nface)
DllExport void	SetInVNum (int nv)
int	outVNum ()
int	outVNum (int inVNum)
int	outFNum ()
int	outFNum (int inFNum)
DllExport void	FillInFaces (Mesh &m)
DllExport void	AddVertexColors ()
DllExport void	AddMap (int mapID)
DllExport void	AddVertexData (int vdChan, Mesh *m=NULL)
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)
bool	IsVClone (DWORD i)
DWORD	VCloneOf (DWORD i)
bool	IsVCreate (DWORD i)
bool	IsFCreate (DWORD i)
DllExport DWORD	MoveID (DWORD i)
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 Point3	OutVert (Mesh &m, DWORD v)
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 DWORD	RemapID (DWORD ff)
DllExport DWORD	IsRemapped (DWORD ff, DWORD vid)
DllExport Face	OutFace (Mesh &m, DWORD ff)
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)
DllExport void	GetSavingPermutations (int &numCr, int &numCl, Tab< int > &vPermute, Tab< int > &vPReverse)
DllExport void	PermuteClonedVertices (Tab< int > &vPermute)
DllExport IOResult	Save (ISave *isave)
DllExport IOResult	Load (ILoad *iload)
DllExport void	MyDebugPrint (bool lut=FALSE, bool mp=FALSE)
DllExport DWORD	ChangeFlags (Tab< DWORD > *mChannels=NULL)
DllExport void	CopyMDChannels (MeshDelta &from, DWORD channels, Tab< DWORD > *mChannels=NULL)
DllExport BOOL	CheckOrder ()
DllExport BOOL	CheckMapFaces ()
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)
DllExport void	SetSingleEdgeVis (Mesh &m, DWORD ed, BOOL vis, AdjFaceList *adj=NULL)
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 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

---

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

)

Search for all occurrences

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

(

)

Search for all occurrences

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
	)

Search for all occurrences

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]

Search for all occurrences

Remarks:

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

{ return mapSupport.GetSize(); }

MapDelta& Map

(

int

mp

)

[inline]

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

Remarks:

Indicates whether any map channel is supported by this MeshDelta.

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

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

Search for all occurrences

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]

Search for all occurrences

Remarks:

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

{ return vdSupport.GetSize(); }

DllExport DWORD PartsChanged

(

)

Search for all occurrences

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 PART_GEOM|PART_SELECT. PART_GEOM represents the moves, and PART_SELECT represents the fact that MeshDeltas always overwrite selection info. Most of the changes in a MeshDelta will alter PART_TOPO. PART_VERTCOLOR and PART_TEXMAP 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

)

Search for all occurrences

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

)

Search for all occurrences

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 NumVMove

(

DWORD

inVNum

)

Search for all occurrences

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

)

Search for all occurrences

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

)

Search for all occurrences

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

)

Search for all occurrences

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]

Search for all occurrences

Remarks:

Returns the number of face creates in this MeshDelta.

{ return fCreate.Count(); }

DllExport void SetInFNum

(

int

nface

)

Search for all occurrences

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

)

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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

)

Search for all occurrences

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

(

)

Search for all occurrences

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

)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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

(

)

Search for all occurrences

Remarks:

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

DllExport DWORD VLut

(

DWORD

i

)

Search for all occurrences

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

)

Search for all occurrences

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

)

Search for all occurrences

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

)

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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

)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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 Point3 OutVert	(	Mesh &	m,
		DWORD	v
	)

Search for all occurrences

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 void VDelete	(	DWORD *	v,
		int	num = 1
	)

Search for all occurrences

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

)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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

)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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 - essesntially 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 DWORD RemapID

(

DWORD

ff

)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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 FChange	(	FaceChange *	f,
		int	num = 1
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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
	)

Search for all occurrences

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

)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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 void GetSavingPermutations	(	int &	numCr,
		int &	numCl,
		Tab< int > &	vPermute,
		Tab< int > &	vPReverse
	)

Search for all occurrences

DllExport void PermuteClonedVertices

(

Tab< int > &

vPermute

)

Search for all occurrences

DllExport IOResult Save

(

ISave *

isave

)

Search for all occurrences

Remarks:

Saves the MeshDelta to a 3ds Max file.

DllExport IOResult Load

(

ILoad *

iload

)

Search for all occurrences

Remarks:

Loads the MeshDelta from a 3ds Max file.

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

Search for all occurrences

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 DWORD ChangeFlags

(

Tab< DWORD > *

mChannels = NULL

)

Search for all occurrences

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
	)

Search for all occurrences

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 BOOL CheckOrder

(

)

Search for all occurrences

DllExport BOOL CheckMapFaces

(

)

Search for all occurrences

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

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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

)

Search for all occurrences

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

)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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[ed13], 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
	)

Search for all occurrences

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
	)

Search for all occurrences

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[ed3], 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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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

)

Search for all occurrences

Remarks:

This method resets the vertex corners.

Parameters:

Mesh & m

The mesh this MeshDelta should be based on.

DllExport void ResetVertWeights

(

Mesh &

m

)

Search for all occurrences

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]

Search for all occurrences

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]

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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
	)

Search for all occurrences

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

Search for all occurrences

DWORD fnum

Search for all occurrences

Tab<VertMove> vMove

Search for all occurrences

Tab<VertMove> vClone

Search for all occurrences

BitArray vDelete

Search for all occurrences

Tab<FaceCreate> fCreate

Search for all occurrences

Tab<FaceRemap> fRemap

Search for all occurrences

Tab<FaceChange> fChange

Search for all occurrences

Tab<FaceSmooth> fSmooth

Search for all occurrences

BitArray fDelete

Search for all occurrences

BitArray vsel

Search for all occurrences

BitArray esel

Search for all occurrences

BitArray fsel

Search for all occurrences

BitArray vhide

Search for all occurrences

MapDelta* map

Search for all occurrences

BitArray mapSupport

Search for all occurrences

VDataDelta* vd

Search for all occurrences

BitArray vdSupport

Search for all occurrences