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(DWORD partsChanged)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

#include <mnmesh.h>

Inheritance diagram for MNTempData:

[legend]

List of all members.

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 (DWORD part)
	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.

Constructor & Destructor Documentation

DllExport MNTempData ( )

Constructor.

Sets all data members to NULL.

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.

DllExport ~MNTempData ( )

Destructor.

Member Function Documentation

void SetMesh ( MNMesh * m ) [inline]

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

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

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

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

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

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

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.

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

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

MNTempData Class Reference

Detailed Description

Public Member Functions

Constructor & Destructor Documentation

Member Function Documentation