MNNormalSpec Class Reference

#include <MNNormalSpec.h>

Inheritance diagram for MNNormalSpec:

Public Member Functions
	MNNormalSpec ()
	~MNNormalSpec ()
DllExport void	Initialize ()
DllExport bool	NAlloc (int num, bool keep=TRUE)
DllExport void	NShrink ()
DllExport bool	FAlloc (int num, bool keep=TRUE)
DllExport void	FShrink ()
DllExport void	Clear ()
DllExport void	ClearAndFree ()
int	GetNumFaces () const
DllExport bool	SetNumFaces (int numFaces)
int	GetNumNormals () const
DllExport bool	SetNumNormals (int numNormals)
Point3 &	Normal (int normID) const
Point3 *	GetNormalArray () const
bool	GetNormalExplicit (int normID) const
bool	AnyExplicitNormalsSet () const
void	SetNormalExplicit (int normID, bool value)
void	SetAllExplicit (bool value=true)
	Set all normals in this MNNormalSpec to be explicit.
MNNormalFace &	Face (int faceID) const
MNNormalFace *	GetFaceArray () const
void	SetParent (MNMesh *pMesh)
DllExport Point3 &	GetNormal (int face, int corner)
DllExport void	SetNormal (int face, int corner, Point3 &normal)
DllExport int	GetNormalIndex (int face, int corner)
DllExport void	SetNormalIndex (int face, int corner, int normalIndex)
DllExport int	NewNormal (Point3 &normal, bool explic=true)
DllExport void	SetSelection (BitArray &newSelection)
BitArray &	GetSelection ()
void	SetDisplayLength (float displayLength)
float	GetDisplayLength ()
DllExport void	CollapseDeadFaces ()
DllExport void	Display (GraphicsWindow *gw, bool showSel)
DllExport bool	HitTest (GraphicsWindow *gw, HitRegion *hr, DWORD flags, SubObjHitList &hitList)
DllExport Box3	GetBoundingBox (Matrix3 *tm=NULL, bool selectedOnly=false)
DllExport void	ClearNormals ()
DllExport void	BuildNormals ()
DllExport void	ComputeNormals ()
DllExport void	CheckNormals ()
DllExport void	AdjustToParent (bool doCheckDegree=true)
	Adjusts the number and topology of the normal faces to match the parent mesh.
DllExport MNNormalSpec &	operator= (const MNNormalSpec &from)
DllExport void	CopySpecified (const MNNormalSpec &from)
DllExport bool	CopySpecified (const MNNormalSpec &sourceNormals, const IntTab &faceIndexMap)
	For each face index map entry faceIndexMap[f] which is valid, i.e.
DllExport MNNormalSpec &	operator+= (const MNNormalSpec &from)
DllExport void	MNDebugPrint (bool printAll=false)
DllExport bool	CheckAllData (int numParentFaces)
DllExport IOResult	Save (ISave *isave)
DllExport IOResult	Save (ISave *isave, ChannelMask channels)
DllExport IOResult	Load (ILoad *iload)
DllExport IOResult	Load (ILoad *iload, ChannelMask channels)
Interface_ID	GetID ()
DllExport void	DeleteInterface ()
DllExport BaseInterface *	GetInterface (Interface_ID id)
DllExport BaseInterface *	CloneInterface (void *remapDir=NULL)
DllExport void	ShallowCopy (IPipelineClient *from, ChannelMask channels)
DllExport void	DeepCopy (IPipelineClient *from, ChannelMask channels)
DllExport void	NewAndCopyChannels (ChannelMask channels)
DllExport void	FreeChannels (ChannelMask channels, int zeroOthers=1)
DllExport void	ZeroChannels (ChannelMask channels)
DllExport void	AppendAllChannels (IPipelineClient *from)
DllExport bool	Transform (const Matrix3 &transformMat, bool useSelelection=false, const BitArray *normalSelection=nullptr, bool isGeomTransform=true)
	Transforms the normals.
DllExport bool	Translate (Point3 &translate, BOOL useSel=true, BitArray *normalSelection=NULL)
DllExport bool	BreakNormals (BOOL useSel=true, BitArray *normalSelection=NULL, BOOL toAverage=false)
DllExport bool	UnifyNormals (BOOL useSel=true, BitArray *normalSelection=NULL, BOOL toAverage=false)
DllExport bool	AverageNormals (BOOL useThresh=false, float threshold=0.0f, BOOL useSel=true, BitArray *normalSelection=NULL)
DllExport bool	SpecifyNormals (BOOL useSel=true, BitArray *normalSelection=NULL)
DllExport bool	MakeNormalsExplicit (BOOL useSel=true, BitArray *normalSelection=NULL, bool value=true)
DllExport bool	ResetNormals (BOOL useSel=true, BitArray *normalSelection=NULL)
virtual void	ShallowCopy (IPipelineClient *from, ChannelMask channels)=0
virtual void	DeepCopy (IPipelineClient *from, ChannelMask channels)=0
virtual void	NewAndCopyChannels (ChannelMask channels)=0
virtual void	FreeChannels (ChannelMask channels, int zeroOthers=1)=0
virtual void	ZeroChannels (ChannelMask channels)=0
virtual void	AppendAllChannels (IPipelineClient *from)=0
virtual Interface_ID	GetID ()
Public Member Functions inherited from BaseInterface
virtual UtilExport	~BaseInterface ()
	Destructor.
UtilExport BaseInterface *	GetInterface (Interface_ID id) override
virtual UtilExport Interface_ID	GetID ()
virtual LifetimeType	LifetimeControl ()
virtual bool	RegisterNotifyCallback (InterfaceNotifyCallback *incb)
virtual void	UnRegisterNotifyCallback (InterfaceNotifyCallback *incb)
virtual BaseInterface *	AcquireInterface ()
virtual void	ReleaseInterface ()
virtual void	DeleteInterface ()
virtual BaseInterface *	CloneInterface (void *remapDir=nullptr)
Public Member Functions inherited from InterfaceServer
virtual UtilExport	~InterfaceServer ()
	Destructor.
virtual UtilExport BaseInterface *	GetInterface (Interface_ID id)
template<class InterfaceType >
InterfaceType *	GetTypedInterface ()
Public Member Functions inherited from FlagUser
	FlagUser ()=default
	FlagUser (const FlagUser &)=default
	FlagUser (FlagUser &&)=default
FlagUser &	operator= (const FlagUser &)=default
FlagUser &	operator= (FlagUser &&)=default
void	SetFlag (DWORD fl, bool val=TRUE)
void	ClearFlag (DWORD fl)
bool	GetFlag (DWORD fl) const
void	ClearAllFlags ()
void	CopyFlags (DWORD fl)
void	CopyFlags (const FlagUser &fu)
void	CopyFlags (const FlagUser *fu)
void	CopyFlags (DWORD fl, DWORD mask)
void	CopyFlags (const FlagUser &fu, DWORD mask)
void	CopyFlags (const FlagUser *fu, DWORD mask)
void	OrFlags (const FlagUser &fu)
void	OrFlags (const FlagUser *fu)
void	AndFlags (const FlagUser &fu)
void	AndFlags (const FlagUser *fu)
bool	FlagMatch (DWORD fmask, DWORD fl) const
bool	FlagMatch (DWORD fmask, const FlagUser &fu) const
bool	FlagMatch (DWORD fmask, const FlagUser *fu) const
DWORD	ExportFlags () const
void	ImportFlags (DWORD fl)
IOResult	WriteFlags (ISave *isave, ULONG *nb) const
IOResult	ReadFlags (ILoad *iload, ULONG *nb)

Additional Inherited Members
Public Types inherited from BaseInterface
enum	LifetimeType { noRelease , immediateRelease , wantsRelease , serverControlled }
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.

Detailed Description

See also

Class MNMESH , Class MNNormalFace

Description:

This class is an interface used to store user-specified normals

(as created in the Edit Normals modifier). These normals have very

limited pipeline support. They are used for viewport display, but not

for rendering.

The MNNormalSpec contains three types of normals:

• Unspecified - these are the usual normals that are computed from
  
  smoothing groups. All normals are unspecified by default.
  
  
• Specified - these are normals that are intended for use by particular
  
  corners of particular faces, without regard to smoothing groups. For
  
  instance, you can create a box, apply Edit Normals, select a group of
  
  normals at a particular vertex, and click "Unify". Now those three
  
  faces are told to specifically use that one unified normal, and they
  
  ignore their smoothing groups at that vertex (which would normally
  
  tell them they should each have their own normal).
  
  
• Explicit - these are normals that are set to particular values.
  
  For instance, if the user wants to use the Edit Normals Move or Rotate
  
  commands to set a normal to something other than its default value,
  
  it has to be made explicit, so it won't be recomputed based on the
  
  face normals. All explicit normals are also considered to be specified..
  
  

Remarks

This interface is not available when you have used the NURMS conversion from Editable Poly as it computes normals, so any user specified normals will be erased.

Flags:

MNNORMAL_NORMALS_BUILT

Indicates that non-specified normals have been constructed using

smoothing groups. If not set, non-specified normals may be invalid.

MNNORMAL_NORMALS_COMPUTED

Indicates that non-explicit normals have been computed using geometrically

computed face normals. (If not set, only explicit normals may be assumed

to be pointing the right direction.)

Data Members:

All data members are private.

int mNumNormalAlloc, mNumFaceAlloc;

The current allocation length of the mpNormal and mpFace arrays.

int mNumNormals, mNumFaces;

The number of normals and faces in the mpNormal and mpFace arrays.

(May be less than the actual allocation above.)

MNNormalFace *mpFace;

The array of normal faces.

Point3 *mpNormal;

The array of normals, all of which should be either length 1 or (occasionally) 0.

BitArray mNormalExplicit;

Indicates whether mpNormal[i] is explicit or computed from face normals.

BitArray mNormalSel;

Current normal selection.

float mDisplayLength;

The length to use when displaying, hit testing, or moving normals.

MNMesh *mpParent;

A pointer to the "parent" MNMesh that owns this MNNormalSpec. This parent

information is required for some operations, such as display. (Such

operations should indicate below where parent information is required.) :

Constructor & Destructor Documentation

MNNormalSpec()

MNNormalSpec ( )

inline

Remarks

Constructor. Initializes all data members.

                    : mpFace(NULL), mpNormal(NULL), mNumNormalAlloc(0),
        mNumFaceAlloc(0), mNumNormals(0), mNumFaces(0), mpParent(NULL),
        mDisplayLength(MNNORMAL_LENGTH_DEFAULT) { }

~MNNormalSpec()

~MNNormalSpec ( )

inline

Remarks

Destructor. Calls ClearAndFree().

{ ClearAndFree (); }

Member Function Documentation

Initialize()

DllExport void Initialize

(

)

Remarks

Initializes all data members. Do not call if memory has already been

allocated, or that memory will be leaked.

NAlloc()

DllExport bool NAlloc	(	int	num,
		bool	keep = TRUE
	)

Remarks

Sets the size of the normal array

Returns

True if successful; false indicates a failed memory allocation.

NShrink()

DllExport void NShrink

(

)

Remarks

Reduces the allocation size down to the actual number of normals.

FAlloc()

DllExport bool FAlloc	(	int	num,
		bool	keep = TRUE
	)

Remarks

Sets the size of the face array.

Returns

True if successful; false indicates a failed memory allocation.

FShrink()

DllExport void FShrink

(

)

Remarks

Reduces the allocation size down to the actual number of faces.

Clear()

DllExport void Clear

(

)

Remarks

Clears out all data, but doesn't necessarily free array memory.

ClearAndFree()

DllExport void ClearAndFree

(

)

Remarks

Clears out all data and frees all memory.

GetNumFaces()

int GetNumFaces ( ) const

inline

Remarks

Returns the current number of faces in the MNNormalSpec

{ return mNumFaces; }

SetNumFaces()

DllExport bool SetNumFaces

(

int

numFaces

)

Remarks

Sets the current number of faces in the MNNormalSpec,

increasing the allocation size as needed.

Returns

True if successful; false indicates a failed memory allocation.

GetNumNormals()

int GetNumNormals ( ) const

inline

Remarks

Returns the current number of normals in the MNNormalSpec

{ return mNumNormals; }

SetNumNormals()

DllExport bool SetNumNormals

(

int

numNormals

)

Remarks

Sets the current number of normals in the MNNormalSpec,

increasing the allocation size as needed.

Returns

True if successful; false indicates a failed memory allocation.

Normal()

Point3 & Normal ( int  normID ) const

inline

Remarks

Returns the normal indicated. Since it returns a reference,

you can use it as a set method as well:

Normal(i) = Normalize (Point3(1,1,0));

(Note that all normals should be normalized to a length of 1.)

{ return mpNormal[normID]; }

GetNormalArray()

Point3 * GetNormalArray ( ) const

inline

Remarks

Returns a pointer to the whole normal array.

{ return mpNormal; }

GetNormalExplicit()

bool GetNormalExplicit ( int  normID ) const

inline

Remarks

Indicates whether a given normal is explicit or not.

{ return mNormalExplicit[normID] ? true : false; }

AnyExplicitNormalsSet()

bool AnyExplicitNormalsSet ( ) const

inline

Remarks

Returns true if there are any explicit normals set

{ return mNormalExplicit.AnyBitSet(); }

SetNormalExplicit()

void SetNormalExplicit ( int  normID, bool  value  )

inline

Remarks

Sets a particular normal to be explicit or not. Note that if

you make a normal non-explicit, it may need to be recomputed,

so you may want to call ComputeNormals or at least clear the

MNNORMAL_NORMALS_COMPUTED flag.

Parameters:

int normID

The index of the normal

bool value

True to make the normal explicit; false to make it non-explicit.

{ mNormalExplicit.Set (normID, value); }

SetAllExplicit()

void SetAllExplicit ( bool  value = true )

inline

Set all normals in this MNNormalSpec to be explicit.

{ if (value) mNormalExplicit.SetAll(); else mNormalExplicit.ClearAll (); }

Face()

MNNormalFace & Face ( int  faceID ) const

inline

Remarks

Returns the indicated face.

{ return mpFace[faceID]; }

GetFaceArray()

MNNormalFace * GetFaceArray ( ) const

inline

Remarks

Returns a pointer to the whole face array.

{ return mpFace; }

SetParent()

void SetParent ( MNMesh *  pMesh )

inline

Remarks

Tells the MNNormalSpec what MNMesh "owns" it.

This "Parent" MNMesh is used in methods such as

Display, Hit-Testing, and certain operations like

Unify to get information about the vertices that

normals are based on. (There's no vertex info

in the MNNormalSpec itself.)

If you have an isolated MNNormalSpec which doesn't

really have an associated "parent", you can

temporarily set this to a mesh with the right sort

of faces and vertices, but you should clear it

afterwards by calling SetParent (NULL). See the

Edit Normals modifier source in

maxsdk/SAMPLES/mesh/EditablePoly/EditNormals.cpp

for an example of this sort of usage.

{ mpParent = pMesh; }

GetNormal()

DllExport Point3 & GetNormal	(	int	face,
		int	corner
	)

Remarks

Returns the normal used by the indicated face, in the indicated corner.

SetNormal()

DllExport void SetNormal	(	int	face,
		int	corner,
		Point3 &	normal
	)

Remarks

Creates a new (explicit) normal and uses it in the indicated

corner of the indicated face. If "normal" is not already

normalized, this method will take care of it.

GetNormalIndex()

DllExport int GetNormalIndex	(	int	face,
		int	corner
	)

Remarks

Returns the index of the normal used in the indicated corner

of the indicated face.

SetNormalIndex()

DllExport void SetNormalIndex	(	int	face,
		int	corner,
		int	normalIndex
	)

Remarks

Sets the index of the normal used in the indicated corner of

the indicated face, and marks it as specified.

NewNormal()

DllExport int NewNormal	(	Point3 &	normal,
		bool	explic = true
	)

Remarks

Creates a new normal at the end of the normal array.

Parameters:

Point3 & normal

The desired normal direction. Will be normalized to a length

of 1 by the method if needed.

bool explic=true

Indicates whether the new normal should be considered explicit

or not.

SetSelection()

DllExport void SetSelection

(

BitArray &

newSelection

)

Remarks

Sets the current normal selection.

GetSelection()

BitArray & GetSelection ( )

inline

Remarks

Returns the current normal selection.

{ return mNormalSel; }

SetDisplayLength()

void SetDisplayLength ( float  displayLength )

inline

Remarks

Sets the current length used for normal display, hit-testing, and Translations.

{ mDisplayLength = displayLength; }

GetDisplayLength()

float GetDisplayLength ( )

inline

Remarks

Returns the current length used for normal display, hit-testing, and Translations.

{ return mDisplayLength; }

CollapseDeadFaces()

DllExport void CollapseDeadFaces

(

)

Remarks

Requires an accurate "parent" pointer (see SetParent).

This method is used in conjunction with the parent MNMesh's

CollapseDeadFaces method to keep the normal faces in synch with

the parent MNMesh faces. It removes any normal face whose

equivalent face in the parent mesh is considered "Dead".

Called by MNMesh::CollapseDeadFaces, so you generally don't

need or want to call it separately.

Display()

DllExport void Display	(	GraphicsWindow *	gw,
		bool	showSel
	)

Remarks

Requires an accurate "parent" pointer (see SetParent).

Displays the current normals in the graphics window indicated.

If "showSel" is true, selected normals are displayed in the

usual subobject selection color.

HitTest()

DllExport bool HitTest	(	GraphicsWindow *	gw,
		HitRegion *	hr,
		DWORD	flags,
		SubObjHitList &	hitList
	)

Remarks

Requires an accurate "parent" pointer (see SetParent). Hit-tests on the current normals.

Parameters:

GraphicsWindow *gw

The window to hit-test in.

HitRegion *hr

A hit region, typically generated by a call like MakeHitRegion(hr,type, crossing,4,p);

DWORD flags

Hit testing flags. Please see BaseObject::HitTest for a description of

these flags and of the "type" and "crossing" variables used to generate

the HitRegion.

SubObjHitList & hitList

Where the hits get stored.

Returns

True if a hit was found; false if not.

GetBoundingBox()

DllExport Box3 GetBoundingBox	(	Matrix3 *	tm = NULL,
		bool	selectedOnly = false
	)

Remarks

Requires an accurate "parent" pointer (see SetParent). Computes the bounding box of the normals.

Parameters:

Matrix3 tm=NULL

An optional transform for computing the bounding box in a different

space (such as world space).

bool selectedOnly=false

Indicates whether all normals should be included in the bounding box,

or only selected ones.

ClearNormals()

DllExport void ClearNormals

(

)

Remarks

This method dumps all unspecified normals. Best to use only from within BuildNormals,

since it leaves all unspecified normals in faces initialized to -1.

BuildNormals()

DllExport void BuildNormals

(

)

Remarks

Requires an accurate "parent" pointer (see SetParent).

Fills in the mpSpecNormal data by building all the unspecified normals,

and computing non-explicit ones. Does nothing if face array is not

allocated yet!

ComputeNormals()

DllExport void ComputeNormals

(

)

Remarks

Requires an accurate "parent" pointer (see SetParent).

This method just recomputes the directions of non-explicit normals,

without rebuilding the normal list.

CheckNormals()

DllExport void CheckNormals

(

)

Remarks

Requires an accurate "parent" pointer (see SetParent).

This checks our flags and calls BuildNormals or ComputeNormals as needed.

AdjustToParent()

DllExport void AdjustToParent

(

bool

doCheckDegree = true

)

Adjusts the number and topology of the normal faces to match the parent mesh.

For new faces added, or if doCheckDegree is true, for any faces encountered whose degree does not match the corresponding face of the parent mesh, all normals are set unspecified. If the parent mesh pointer is not set, does nothing.

Parameters

[in]

doCheckDegree

when true, the degree of each already-created normal face is checked against the corresponding face in the parent mesh

operator=()

DllExport MNNormalSpec & operator=

(

const MNNormalSpec &

from

)

Remarks

Typical = operator. Allocates arrays in this, and makes copies of all

the data in "from". Does NOT copy "Parent" pointer.

CopySpecified() [1/2]

DllExport void CopySpecified

(

const MNNormalSpec &

from

)

Remarks

This is similar to operator=, but copies only the specified and explicit

information from "from". Result will need to have BuildNormals and ComputeNormals

called.

CopySpecified() [2/2]

DllExport bool CopySpecified	(	const MNNormalSpec &	sourceNormals,
		const IntTab &	faceIndexMap
	)

For each face index map entry faceIndexMap[f] which is valid, i.e.

faceIndexMap[f] >= 0, the target face faceIndexMap[f] of this object is defined as a copy of source face f of object sourceNormals, which may be the same as this object. In particular, face faceIndexMap[f] is allocated if necessary, set to the same degree as the source face, and any vertex normals which are set as specified for the source face are copied to the corresponding vertices of the target face. The explicitness of normals is also preserved in the copy. Note that the operation will fail if sourceNormals is the same as this object, and the index map contains undefined copies, i.e. if 0 <= faceIndexMap[f] < faceIndexMap.Count() for any f, and faceIndexMap[faceIndexMap[f]] >= 0.

Parameters

[in]	sourceNormals	specified normals object containing the source face data
[in]	faceIndexMap	map from source to target faces; the condition faceIndexMap[f] < 0 indicates that source face f is not to be copied

Returns

Flag indicating whether copy operation was successful.

operator+=()

DllExport MNNormalSpec & operator+=

(

const MNNormalSpec &

from

)

Remarks

Adds the faces and normals from "from" to our normal spec, renumbering the

normals so they don't conflict with existing ones. Called by the

"AppendAllChannels" method below (which itself is called by MNMesh::operator+=).

MNDebugPrint()

DllExport void MNDebugPrint

(

bool

printAll = false

)

Remarks

Uses "DebugPrint" to output information about this MNNormalSpece to the

Debug buffer in DevStudio.

Parameters:

bool printAll=false

If false, only explicit normals and faces using specified normals will be

printed out. If true, all normals and faces will be completely printed out.

Here is what the output looks like on a box with mostly default (non-specified)

normals, but with one corner "Unified" into a single specified normal:

If printAll = true, you'll see:

MNNormalSpec Debug Output: 22 normals, 6 faces

Normal (Non ) 0: 0.577350, -0.577350, 0.577350

Normal (Non ) 1: 0.000000, 0.000000, -1.000000

Normal (Non ) 2: 0.000000, 0.000000, -1.000000

Normal (Non ) 3: 0.000000, 0.000000, -1.000000

Normal (Non ) 4: 0.000000, 0.000000, -1.000000

Normal (Non ) 5: 0.000000, 0.000000, 1.000000

Normal (Non ) 6: 0.000000, 0.000000, 1.000000

Normal (Non ) 7: 0.000000, 0.000000, 1.000000

Normal (Non ) 8: 0.000000, -1.000000, 0.000000

Normal (Non ) 9: 0.000000, -1.000000, 0.000000

Normal (Non ) 10: 0.000000, -1.000000, 0.000000

Normal (Non ) 11: 1.000000, 0.000000, 0.000000

Normal (Non ) 12: 1.000000, 0.000000, 0.000000

Normal (Non ) 13: 1.000000, 0.000000, 0.000000

Normal (Non ) 14: 0.000000, 1.000000, 0.000000

Normal (Non ) 15: 0.000000, 1.000000, 0.000000

Normal (Non ) 16: 0.000000, 1.000000, 0.000000

Normal (Non ) 17: 0.000000, 1.000000, 0.000000

Normal (Non ) 18: -1.000000, 0.000000, 0.000000

Normal (Non ) 19: -1.000000, 0.000000, 0.000000

Normal (Non ) 20: -1.000000, 0.000000, 0.000000

Normal (Non ) 21: -1.000000, 0.000000, 0.000000

Normal Selection:

0 6 13 17

Normal faces: _ before normal index means non-specified.

Face 0: _1 _2 _3 _4

Face 1: _5 0 _6 _7

Face 2: _8 _9 0 _10

Face 3: _11 _12 _13 0

Face 4: _14 _15 _16 _17

Face 5: _18 _19 _20 _21

If printAll is false, you'll just see:

MNNormalSpec Debug Output: 22 normals, 6 faces

Normal Selection:

0 6 13 17

Face 1: _ 0 _ _

Face 2: _ _ 0 _

Face 3: _ _ _ 0

CheckAllData()

DllExport bool CheckAllData

(

int

numParentFaces

)

Remarks

Performs a series of internal checks to verify that the normal

data is consistent. If there are any problems, messages are

sent out via DebugPrint.

Parameters:

int numParentFaces

The number of faces in the parent MNMesh. (This method does not

require an accurate "parent" pointer, but it does require this

number to be accurate.

Returns

True if everything checks out ok, false if not.

Save() [1/2]

DllExport IOResult Save

(

ISave *

isave

)

Remarks

Called by the system. Saves the MNNormalSpec to the buffer.

Save() [2/2]

DllExport IOResult Save	(	ISave *	isave,
		ChannelMask	channels
	)

Load() [1/2]

DllExport IOResult Load

(

ILoad *

iload

)

Remarks

Called by the system. Loads the MNNormalSpec from the buffer.

Load() [2/2]

DllExport IOResult Load	(	ILoad *	iload,
		ChannelMask	channels
	)

GetID()

Interface_ID GetID ( )

inlinevirtual

Remarks

This method returns the unique interface ID.

Reimplemented from IPipelineClient.

{return MN_NORMAL_SPEC_INTERFACE;}

DeleteInterface()

DllExport void DeleteInterface ( )

virtual

Remarks

This method can be used as a direct interface delete request.

Default Implementation:

{ }

Reimplemented from BaseInterface.

GetInterface()

DllExport BaseInterface * GetInterface ( Interface_ID  id )

virtual

Remarks

Returns a pointer to the interface whose ID is specified.

Parameters:

Interface_ID id

The ID of the interface to return.

Default Implementation:

{ return NULL; }

Reimplemented from BaseInterface.

CloneInterface()

DllExport BaseInterface * CloneInterface ( void *  remapDir = NULL )

virtual

Remarks

This method allows you to clone the base interface.

Parameters:

void* remapDir

The RemapDir passed to the clone method.

Default Implementation:

{ return NULL; }

Reimplemented from BaseInterface.

ShallowCopy()

DllExport void ShallowCopy ( IPipelineClient *  from, ChannelMask  channels  )

virtual

Implements IPipelineClient.

DeepCopy()

DllExport void DeepCopy ( IPipelineClient *  from, ChannelMask  channels  )

virtual

Implements IPipelineClient.

NewAndCopyChannels()

DllExport void NewAndCopyChannels ( ChannelMask  channels )

virtual

Implements IPipelineClient.

FreeChannels()

DllExport void FreeChannels ( ChannelMask  channels, int  zeroOthers = 1  )

virtual

Implements IPipelineClient.

ZeroChannels()

DllExport void ZeroChannels ( ChannelMask  channels )

virtual

Implements IPipelineClient.

AppendAllChannels()

DllExport void AppendAllChannels ( IPipelineClient *  from )

virtual

Implements IPipelineClient.

Transform()

DllExport bool Transform	(	const Matrix3 &	transformMat,
		bool	useSelelection = false,
		const BitArray *	normalSelection = nullptr,
		bool	isGeomTransform = true
	)

Transforms the normals.

If isGeomTransform is true, the normals are transformed consistent with the transformation defined by matrix transformMat being applied to the geometry, meaning that the normal vectors are multiplied by transpose of the inverse of transformMat. If isGeomTransform is false, then the matrix portion of transformMat is simply applied directly. In both cases, we disregard the translation vector, and renormalize the affected normal vectors. Note that if transformMat represents a rotation, then the result is independent of the choice of isGeomTransform, since the matrix will be orthogonal.

Parameters

[in]	transformMat	matrix representing the transformation to be applied
[in]	useSelelection	when true, only selected normals are altered, otherwise, the transformation is applied to all defined normals
[in]	normalSelection	when useSelection is true, the selected normals are defined by normalSelection if not null, or the usual member selection, otherwise
[in]	isGeomTransform	when true, matrix transformMat is interpreted as a transformation applied to the associated geometry, as discussed above

Returns

Flag indicating whether any normals were altered. In particular, if the specified values of transformMat and isGeomTransform indicate an identity transformation, we will return false.

Translate()

DllExport bool Translate	(	Point3 &	translate,
		BOOL	useSel = true,
		BitArray *	normalSelection = NULL
	)

Remarks

This is used to give a translation-like effect to normals. It's used in the Edit

Normals "Move" mode. Essentially it drags the "top" of the normals by the amount

given, and then renormalizes the vectors to unit length. It uses the current

display length as well, so the formula is basically

mpNormal[i] = Normalize (mpNormal[i]*mDisplayLength + translate);

This gives a fairly natural result in Edit Normals Move.

Parameters:

Point3 & translate

The desired translation.

BOOL useSel=false

Indicates whether all normals should be translated, or only selected ones.

BitArray *normalSelection=NULL

If non-NULL, this represents a selection of normals that should be used instead of

the usual selection, when deciding which normals to translate.

Returns

True if something was modified. False would indicate that no normals were changed,

perhaps because there are no normals in the spec or because none were selected.

BreakNormals()

DllExport bool BreakNormals	(	BOOL	useSel = true,
		BitArray *	normalSelection = NULL,
		BOOL	toAverage = false
	)

Remarks

"Breaks" normals so that none are shared between faces. Broken normals are set to Specified (but not explicit.)

Parameters:

BOOL useSel=false

Indicates whether all normals should be affected, or only selected ones.

BitArray *normalSelection=NULL

If non-NULL, this represents a selection of normals that should be used instead of

the usual selection, when deciding which normals to affect. (Irrelevant if

useSel=false.)

Returns

True if something was modified. False would indicate that no normals were changed,

perhaps because there are no normals present or because none were selected,

or because selected normals were already fully broken and specified.

If the return value is true, the MNNORMAL_NORMALS_BUILT and

MNNORMAL_NORMALS_COMPUTED flags are cleared, because the newly broken

normals need to be rebuilt and computed.

UnifyNormals()

DllExport bool UnifyNormals	(	BOOL	useSel = true,
		BitArray *	normalSelection = NULL,
		BOOL	toAverage = false
	)

Remarks

Requires an accurate "parent" pointer (see SetParent).

This method unifies selected normals so that there's a maximum of one

per vertex. For instance, a default box has 3 normals at every vertex.

You can select 2 or 3 of them and click "Unify" in Edit Normals, and

the normals will be shared across the faces that use them. See Edit

Normals documentation for more information.

This method does not unify normals that are based at different vertices.

If you want separate vertices to use the same normal, you must use more

direct, low-level methods like SetNormalIndex.

Unified normals are set to specified (but not explicit).

Parameters:

BOOL useSel=false

Indicates whether all normals should be affected, or only selected ones.

BitArray *normalSelection=NULL

If non-NULL, this represents a selection of normals that should be used instead of

the usual selection, when deciding which normals to affect. (Irrelevant if

useSel=false.)

Returns

True if something was modified. False would indicate that no normals were changed,

perhaps because there are no normals present or because none were selected,

or because selected normals were already fully unified and specified.

If the return value is true, the MNNORMAL_NORMALS_BUILT and

MNNORMAL_NORMALS_COMPUTED flags are cleared, because the newly unified

normals need to be rebuilt and computed.

AverageNormals()

DllExport bool AverageNormals	(	BOOL	useThresh = false,
		float	threshold = 0.0f,
		BOOL	useSel = true,
		BitArray *	normalSelection = NULL
	)

SpecifyNormals()

DllExport bool SpecifyNormals	(	BOOL	useSel = true,
		BitArray *	normalSelection = NULL
	)

Remarks

Specifies the indicated normals. DOESN'T remove the explicitness of the normals.

(That should be done separately with MakeNormalsExplicit, value=false.)

Parameters:

BOOL useSel=false

Indicates whether all normals should be affected, or only selected ones.

BitArray *normalSelection=NULL

If non-NULL, this represents a selection of normals that should be used instead of

the usual selection, when deciding which normals to affect. (Irrelevant if

useSel=false.)

Returns

True if something was modified. False would indicate that no normals were changed,

perhaps because there are no normals present or because none were selected, or because

they were all already specified.

MakeNormalsExplicit()

DllExport bool MakeNormalsExplicit	(	BOOL	useSel = true,
		BitArray *	normalSelection = NULL,
		bool	value = true
	)

Remarks

Makes the indicated normals both specified and explicit.

Parameters:

BOOL useSel=false

Indicates whether all normals should be affected, or only selected ones.

BitArray *normalSelection=NULL

If non-NULL, this represents a selection of normals that should be used instead of

the usual selection, when deciding which normals to affect. (Irrelevant if

useSel=false.)

bool value=true

I Indicates whether the normals should be set to explicit, or non-explicit.

Returns

True if something was modified. False would indicate that no normals were changed,

perhaps because there are no normals present or because none were selected.

If value=false and the return value is true, the MNNORMAL_NORMALS_COMPUTED

flag is cleared, because the newly nonexplicit normals need to be computed

.

ResetNormals()

DllExport bool ResetNormals	(	BOOL	useSel = true,
		BitArray *	normalSelection = NULL
	)

Remarks

Resets the indicated normals to be completely non-explicit and non-specified.

Parameters:

BOOL useSel=false

Indicates whether all normals should be affected, or only selected ones.

BitArray *normalSelection=NULL

If non-NULL, this represents a selection of normals that should be used instead of

the usual selection, when deciding which normals to affect. (Irrelevant if

useSel=false.)

Returns

True if something was modified. False would indicate that no normals were changed,

perhaps because there are no normals present or because none were selected.

If the return value is true, the MNNORMAL_NORMALS_BUILT and

MNNORMAL_NORMALS_COMPUTED flags are cleared, because the newly nonspecified

normals need to be rebuilt and computed.