MNTempData Class Reference

Used for caching face and edge clusters, vertex normals, and other derived data about an MNMesh. More...

#include <mnmesh.h>

Inheritance diagram for MNTempData:

Public Member Functions
void	SetMesh (MNMesh *m)
	Sets the internal mesh pointer to m.
DllExport Tab< Point3 > *	VertexNormals ()
	Returns a table of local average normals for vertices.
DllExport Tab< float > *	VSWeight (BOOL useEdgeDist, int edgeIts, BOOL ignoreBack, float falloff, float pinch, float bubble, DWORD selFlags=MN_SEL)
	Returns Vertex Selection weights (for soft selection).
DllExport Tab< float > *	SelectionDist (BOOL useEdgeDist, int edgeIts, DWORD selFlags=MN_SEL, float falloffLimit=-1.0f)
	Computes the distances of the unselected vertices from the current selection within a falloff.
DllExport Tab< Point3 > *	OutlineDir (int extrusionType, DWORD clusterFlags=MN_SEL)
	Produces the "Outline" direction of all vertices, based on the current face selection.
DllExport MNChamferData *	ChamferData ()
	Rreturns the cache of a ChamferData for use in the MNMesh Chamfer methods.
DllExport void	Invalidate (ChannelMask channels)
	This method invalidates all data based on the specified part of the mesh.
DllExport void	InvalidateDistances ()
	Uncaches (frees) the distance dependent data returned by VSWeight, SelectionDist, and ClusterDist.
DllExport void	InvalidateSoftSelection ()
	This method frees the VSWeight data (but not the underlying distance-from-selection info).
DllExport void	freeClusterDist ()
	This method is mainly for internal use, this frees just the cluster distance data.
DllExport void	freeBevelInfo ()
	This method frees only the outlining data.
DllExport void	freeChamferData ()
	This method frees only the chamfer data structure.
DllExport void	freeAll ()
	This method frees all cached data of any kind.
DllExport BaseInterface *	GetInterface (Interface_ID id)
	Returns an interfaces.
Constructors and Destructors
DllExport	MNTempData ()
	Constructor.
DllExport	MNTempData (MNMesh *m)
	Constructor.
DllExport	~MNTempData ()
	Destructor.
Cluster Methods
DllExport MNFaceClusters *	FaceClusters (DWORD clusterFlags=MN_SEL)
	This method returns a face cluster list, which groups selected faces into "clusters" for transformation.
DllExport MNEdgeClusters *	EdgeClusters (DWORD clusterFlags=MN_SEL)
	Returns an edge cluster list, which groups selected edges into "clusters" for applying transforms.
DllExport Tab< int > *	VertexClusters (int sl, DWORD clusterFlags=MN_SEL)
	This method returns an index of which cluster, if any, each vertex is in.
DllExport Tab< Point3 > *	ClusterNormals (int sl, DWORD clusterFlags=MN_SEL)
	Returns average normals for each cluster.
DllExport Tab< Point3 > *	ClusterCenters (int sl, DWORD clusterFlags=MN_SEL)
	Returns mean centers for each cluster.
DllExport Matrix3	ClusterTM (int clust)
	Uses the current cluster center and normal caches to return the "objectspace to clusterspace" transform.
DllExport Tab< float > *	ClusterDist (int sl, DWORD clusterFlags, int clustId, BOOL useEdgeDist, int edgeIts)
	Computes the current distance of each vertex from the specified cluster.
Public Member Functions inherited from BaseInterfaceServer
UtilExport BaseInterface *	GetInterface (Interface_ID id) override
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.
virtual UtilExport BaseInterface *	GetInterface (Interface_ID id)
template<class InterfaceType >
InterfaceType *	GetTypedInterface ()

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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
static UtilExport void *	operator new[] (size_t size, int block_type, const char *filename, int line)
	New operator used to allocate arrays of objects.
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.
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.
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.
static UtilExport void	operator delete (void *ptr)
	Standard delete operator used to deallocate an object If the pointer is invalid, an exception will be thrown.
static UtilExport void	operator delete (void *ptr, const std::nothrow_t &e)
	Standard delete operator used to deallocate an object If the pointer is invalid, nothing will happen.
static UtilExport void	operator delete (void *ptr, const char *filename, int line)
	Delete operator used to deallocate an object that takes the filename and line number where the delete was called If the pointer is invalid, an exception will be thrown.
static UtilExport void	operator delete (void *ptr, int block_type, const char *filename, int line)
	Delete operator used to deallocate an object that takes the type of memory, filename and line number where the delete was called If the pointer is invalid, an exception will be thrown.
static UtilExport void	operator delete (void *ptr, const std::nothrow_t &e, const char *filename, int line)
	Delete operator used to deallocate an object that takes the filename and line number where the delete was called If the pointer is invalid, nothing will happen.
static UtilExport void	operator delete (void *ptr, unsigned long flags)
	Delete operator used to deallocate an object that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown.
static UtilExport void	operator delete (void *ptr, const std::nothrow_t &e, unsigned long flags)
	Delete operator used to deallocate an object that takes extra flags to specify special operations If the pointer is invalid, nothing will happen.
static UtilExport void	operator delete[] (void *ptr)
	Standard delete operator used to deallocate an array of objects If the pointer is invalid, an exception will be thrown.
static UtilExport void	operator delete[] (void *ptr, const std::nothrow_t &e)
	Standard delete operator used to deallocate an array of objects If the pointer is invalid, nothing will happen.
static UtilExport void	operator delete[] (void *ptr, const char *filename, int line)
	Delete operator used to deallocate an array of objects that takes the filename and line number where the delete was called If the pointer is invalid, an exception will be thrown.
static UtilExport void	operator delete[] (void *ptr, int block_type, const char *filename, int line)
	Delete operator used to deallocate an array of objects that takes the type of memory, filename and line number where the delete was called If the pointer is invalid, an exception will be thrown.
static UtilExport void	operator delete[] (void *ptr, const std::nothrow_t &e, const char *filename, int line)
	Delete operator used to deallocate an array of objects that takes the filename and line number where the delete was called If the pointer is invalid, nothing will happen.
static UtilExport void	operator delete[] (void *ptr, unsigned long flags)
	Delete operator used to deallocate an array of objects that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown.
static UtilExport void	operator delete[] (void *ptr, const std::nothrow_t &e, unsigned long flags)
	Delete operator used to deallocate an array of objects that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown.
static UtilExport void *	operator new (size_t size, void *placement_ptr)
	Placement new operator.
static UtilExport void	operator delete (void *ptr, void *placement_ptr)
	Placement delete operator.
static UtilExport void *	aligned_malloc (size_t size, size_t alignment)
	Allocates memory on a specified alignment boundary.
static UtilExport void *	aligned_realloc (void *ptr, size_t size, size_t alignment)
	Reallocates memory on a specified alignment boundary.
static UtilExport void	aligned_free (void *ptr)
	Frees a block of memory that was allocated with aligned_malloc/aligned_realloc.
Protected Attributes inherited from BaseInterfaceServer
Tab< BaseInterface * >	interfaces

Detailed Description

Used for caching face and edge clusters, vertex normals, and other derived data about an MNMesh.

There is a SetMesh() method to set the current mesh that the TempData is based on, then there's a series of methods to update the cache and return some sort of derived data. All of these methods follow the form:

DerivedData *MNTempData::DData(parameters);

DerivedData is the container for the derived data requested (often a simple table, though there are some specialized classes returned from some methods). If the data has already been computed, the parameters are ignored and the cached data is returned. Otherwise, the data is computed from the parameters and the current mesh.

There are no procedures in place to detect changes in parameters or the mesh since the last time a method was called, so it's the calling routine's responsibility to free invalid structures. If you know that only certain pipeline channels, such as GEOM_CHANNEL have changed, you can use the Invalidate(ChannelMask channels) method. (GEOM_CHANNEL would free the distances-to-selected-vertices, for example, but not the Edge Clusters.)

In particular, there is no way for the MNTempData to know when its mesh pointer is no longer valid, so it's vital that the calling routine clear the mesh (with SetMesh(NULL)) or stop using the MNTempData when this happens.

All data members are private. They basically consist of a series of pointers which are initialized to NULL and then filled with allocated derived data as requested. There is also a NULL-initialized, private mesh pointer which is set with SetMesh(). Editable Poly uses this class to hold all the varieties of temporary, cached data it creates – examples are vertex normals and face clusters.

To use MNTempData, just set it to your mesh and start querying the member functions.

MyAlgorithm (MNMesh *m) {
        MNTempData mtd(m);
        // Get Edge Clusters.
        MNEdgeClusters *eclust = mtd.EdgeClusters ();
}

See also

BaseInterfaceServer, MNMesh, MNFaceClusters, MNEdgeClusters, MNFaceElement, MNChamferData

Constructor & Destructor Documentation

MNTempData() [1/2]

DllExport MNTempData

(

)

Constructor.

Sets all data members to NULL.

MNTempData() [2/2]

DllExport MNTempData

(

MNMesh *

m

)

Constructor.

Sets the internal mesh pointer to the mesh passed. (Sets all other data members to NULL.)

Parameters:

MNMesh *m

The internal mesh pointer to set.

~MNTempData()

DllExport ~MNTempData

(

)

Destructor.

Member Function Documentation

SetMesh()

void SetMesh ( MNMesh *  m )

inline

Sets the internal mesh pointer to m.

Parameters:

MNMesh *m

The internal mesh pointer to set.

{ mesh = m; }

FaceClusters()

DllExport MNFaceClusters * FaceClusters

(

DWORD

clusterFlags = MN_SEL

)

This method returns a face cluster list, which groups selected faces into "clusters" for transformation.

See Class MNFaceClusters for more information. If cached, the cache is returned. Otherwise a cache is allocated and computed from the current mesh.

Parameters:

DWORD clusterFlags=MN_SEL

The face flags to cluster the faces by. For instance, with the default value, faces are clustered by their selection.

EdgeClusters()

DllExport MNEdgeClusters * EdgeClusters

(

DWORD

clusterFlags = MN_SEL

)

Returns an edge cluster list, which groups selected edges into "clusters" for applying transforms.

See Class MNEdgeClusters for more information. If cached, the cache is returned. Otherwise a cache is allocated and computed from the current mesh.

Parameters:

DWORD clusterFlags=MN_SEL

The edge flags to cluster the edges by. For instance, with the default value, edges are clustered by their selection.

VertexClusters()

DllExport Tab< int > * VertexClusters	(	int	sl,
		DWORD	clusterFlags = MN_SEL
	)

This method returns an index of which cluster, if any, each vertex is in.

If cached, the cache is returned. Otherwise a cache is allocated and computed from the current mesh and the parameter.

Parameters:

int sl

The selection level. This should be either MNM_SL_EDGE or MNM_SL_FACE, to indicate whether the vertex cluster information should be based on edge or face clusters. Note that this parameter is ignored if there's already a vertex cluster cache.

DWORD clusterFlags=MN_SEL

The edge or face flags to cluster the edges or faces by. For instance, with the default value, edges or faces are clustered by their selection. Note that this parameter is ignored if there's already a vertex cluster cache.

Returns

A table of DWORD's is returned, one for each vertex. If (VertexClusters(sl))[i] is UNDEFINED, vertex i is not in any cluster. Otherwise, the value for vertex i is the cluster index.

ClusterNormals()

DllExport Tab< Point3 > * ClusterNormals	(	int	sl,
		DWORD	clusterFlags = MN_SEL
	)

Returns average normals for each cluster.

If cached, the cache is returned. Otherwise a cache is allocated and computed from the current mesh and the parameter. Note that cluster centers and normals are computed and cached at the same time, when you call either method.

Parameters:

int sl

The selection level. This should be either MNM_SL_EDGE or MNM_SL_FACE, to indicate whether the vertex cluster information should be based on edge or face clusters. Note that this parameter is ignored if there's already a cluster normal cache.

DWORD clusterFlags=MN_SEL

The edge or face flags to cluster the edges or faces by. For instance, with the default value, edges or faces are clustered by their selection. Note that this parameter is ignored if there's already a cluster normal cache.

Returns

A table of Point3's is returned, one for each cluster. The values are already normalized to length 1.

ClusterCenters()

DllExport Tab< Point3 > * ClusterCenters	(	int	sl,
		DWORD	clusterFlags = MN_SEL
	)

Returns mean centers for each cluster.

If cached, the cache is returned. Otherwise a cache is allocated and computed from the current mesh and the parameter. Note that cluster centers and normals are computed and cached at the same time, when you call either method.

Parameters:

int sl

Selection level. This should be either MNM_SL_EDGE or MNM_SL_FACE, to indicate whether the clusters we're talking about are the edge or face clusters. Note that this parameter is ignored if there's already a cluster center cache.

DWORD clusterFlags=MN_SEL

The edge or face flags to cluster the edges or faces by. For instance, with the default value, edges or faces are clustered by their selection. Note that this parameter is ignored if there's already a cluster center cache.

Returns

A table of Point3's is returned, one for each cluster.

ClusterTM()

DllExport Matrix3 ClusterTM

(

int

clust

)

Uses the current cluster center and normal caches to return the "objectspace to clusterspace" transform.

This is the transform of the "local" axis in moving edge or face clusters in Editable Poly. If the cluster centers and normals have not been cached, the identity matrix is returned; thus the control over whether this is an edge or face cluster is handled by the last call to ClusterCenters or ClusterNormals.

Parameters:

int clust

The cluster you want the transform for.

ClusterDist()

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

Computes the current distance of each vertex from the specified cluster.

If cached, the cache is returned. Otherwise a cache is allocated and computed from the current mesh and the parameters.

NOTE: If useEdgeDist is FALSE, this is an n-log-n algorithm: it compares every vertex not in the cluster with every vertex in it. If useEdgeDist is TRUE, the time it takes is proportional to the number of verts in the cluster times edgeIts.

Parameters:

int sl

Indicates whether we should use edges (MNM_SL_EDGE) or faces (MNM_SL_FACE) to construct the clusters, if needed.

DWORD clusterFlags

The edge or face flags to cluster the edges or faces by. For instance, if clusterFlags==MN_SEL, edges or faces are clustered by selection.

int clustId

The ID of the cluster we're measuring distance from.

BOOL useEdgeDist

If set to TRUE, the distance between vertices is computed along edges. If set to FALSE, it's computed directly through space.

int edgeIts

This indicates the maximum number of edges the algorithm may travel along in finding the distance between vertices. (Maximum path length.)

Returns

A table consisting of one float value per vertex. If this value is 0, the vertex is either selected or on top of a vertex in the cluster. Otherwise it represents the distance to the closest selected vertex. If useEdgeDist is TRUE, values of -1.0 are returned for vertices with no edgeIts-length path to a vertex in the cluster.

VertexNormals()

DllExport Tab< Point3 > * VertexNormals

(

)

Returns a table of local average normals for vertices.

These normals are computed using the MNMesh::GetVertexNormal() method, wherein each face's contribution to the vertex normal is weighted by the face angle at the vertex.

VSWeight()

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

Returns Vertex Selection weights (for soft selection).

If cached, the cache is returned. Otherwise a cache is allocated and computed from the current mesh and the parameters. Weights are based on the standard soft selection falloff from the currently selected vertices.

Note: If useEdgeDist is FALSE, this is an n-log-n algorithm: it compares every vertex not in the cluster with every vertex in it. If useEdgeDist is TRUE, the time it takes is proportional to the number of verts in the cluster times edgeIts.

Parameters:

BOOL useEdgeDist

If set to TRUE, the distance between vertices is computed along edges. If set to FALSE, it's computed directly through space.

int edgeIts

This indicates the maximum number of edges the algorithm may travel along in finding the distance between vertices. (Maximum path length.)

BOOL ignoreBack

If set to TRUE, vertices with a normal (as computed in VertexNormals) that points more than 90 degrees away from the average normal of the selection are not given any partial selections. They're either 1 if selected or 0 otherwise.

float falloff

The limit distance of the effect. If distance > falloff, the function will always return 0.

float pinch

Use this to affect the tangency of the curve near distance=0. Positive values produce a pointed tip, with a negative slope at 0, while negative values produce a dimple, with positive slope.

float bubble

Use this to change the curvature of the function. A value of 1.0 produces a half-dome. As you reduce this value, the sides of the dome slope more steeply. Negative values lower the base of the curve below 0.

DWORD selFlags=MN_SEL

Indicates what flag defines the hard selection we're basing this soft selection on.

Returns

A table of float values, one per vertex, that are 1.0 if the vertex is in the current selection, 0.0 if it's more than falloff distance (or more than edgeIts edges, if (useEdgeDist)), and AffectRegionFunction((*SelectionDist(useEdgeDist, edgeIts)), falloff, pinch, bubble) otherwise.

SelectionDist()

DllExport Tab< float > * SelectionDist	(	BOOL	useEdgeDist,
		int	edgeIts,
		DWORD	selFlags = MN_SEL,
		float	falloffLimit = -1.0f
	)

Computes the distances of the unselected vertices from the current selection within a falloff.

If cached, the cache is returned. Otherwise a cache is allocated and computed from the current mnmesh and the parameters. The term "Selected verts" below refers to the vertices that are selected in the mesh's current selection level. (See the MNMesh method GetTempSel for details.)

Parameters

useEdgeDist	If TRUE, the distance between vertices is computed along edges. If FALSE, it's computed directly through space.
edgeIts	This indicates the maximum number of edges the algorithm may travel along in finding the distance between vertices. (Maximum path length.). WARNING: If useEdgeDist is FALSE, this is an n-squared algorithm: it compares every nonselected vertex with every selected one within the falloffLimit. If useEdgeDist is TRUE, the time it takes is proportional to the number of selected vertices times edgeIts.
selFlags	The flags used to dertermine what edges are considered selected.
falloffLimit	= -1.0f this limits the number of unselected vertices to check against Only vertices that fall within the selected vertices bounding box + this limit will be computed. If this value is -1.0 all vertices will be computed. Any vertex outside this limit will be set to a distance of the limit.

Returns

A table consisting of one float value per vertex. If this value is 0, the vertex is either selected or on top of a selected vertex. Otherwise it represents the distance to the closest selected vertex. If useEdgeDist is TRUE, values of -1.0 are returned for vertices with no edgeIts-length path to a selected vertex.

OutlineDir()

DllExport Tab< Point3 > * OutlineDir	(	int	extrusionType,
		DWORD	clusterFlags = MN_SEL
	)

Produces the "Outline" direction of all vertices, based on the current face selection.

"Outlining" is the direction vertices move to move edges of the current face selection outward at a constant rate. They are not set to length 1, but rather to whatever "rate" best makes the outline edges move most consistently, without changing their angles.

Parameters:

int extrusionType

This is one of MESH_EXTRUDE_CLUSTER or MESH_EXTRUDE_LOCAL, to indicate whether vertices should move according to cluster or local face normals.

DWORD clusterFlags=MN_SEL

The face flags to cluster the faces by. For instance, if left at the default value, faces are clustered by selection. Note that this parameter is ignored if the extrusionType is LOCAL.

ChamferData()

DllExport MNChamferData * ChamferData

(

)

Rreturns the cache of a ChamferData for use in the MNMesh Chamfer methods.

Unlike other MeshTempData methods, this method makes no calculations based on the current mesh, but merely supplies a memory cache. (Computing this information is left to the MNMesh methods GetExtrudeDirection, ChamferVertices, and ChamferEdges.)

Invalidate()

DllExport void Invalidate

(

ChannelMask

channels

)

This method invalidates all data based on the specified part of the mesh.

In the following chart, the columns represent the channels GEOM_CHANNEL (G), TOPO_CHANNEL (T), SELECT_CHANNEL (S), and SUBSEL_TYPE_CHANNEL (U). X's indicate dependency of the specified data cache on the given channel.

Method to get cache	G	T	S	U
FaceClusters		X	X
EdgeClusters		X	X
VertexClusters		X	X	X
ClusterCenters	X	X	X	X
ClusterNormals	X	X	X	X
VertexNormals	X	X
SelectionDist	X	X	X	X
ClusterDist	X	X	X	X
VSWeight	X	X	X	X

NOTE: ChamferData and the Outline direction info are handled separately in freeChamferData and freeBevelInfo.

Parameters:

ChannelMask channels

One or more of the following channels: GEOM_CHANNEL, TOPO_CHANNEL, SELECT_CHANNEL, SUBSEL_TYPE_CHANNEL.

InvalidateDistances()

DllExport void InvalidateDistances

(

)

Uncaches (frees) the distance dependent data returned by VSWeight, SelectionDist, and ClusterDist.

InvalidateSoftSelection()

DllExport void InvalidateSoftSelection

(

)

This method frees the VSWeight data (but not the underlying distance-from-selection info).

This is useful, e.g., if the mesh has not changed, but you wish to change the falloff, pinch, or bubble parameters to get new vertex selection weights.

freeClusterDist()

DllExport void freeClusterDist

(

)

This method is mainly for internal use, this frees just the cluster distance data.

freeBevelInfo()

DllExport void freeBevelInfo

(

)

This method frees only the outlining data.

freeChamferData()

DllExport void freeChamferData

(

)

This method frees only the chamfer data structure.

freeAll()

DllExport void freeAll

(

)

This method frees all cached data of any kind.

GetInterface()

DllExport BaseInterface * GetInterface ( Interface_ID  id )

virtual

Returns an interfaces.

Reimplemented from BaseInterfaceServer.