Class IEditNormalsMod
See Also: Class MNMESH , Class MNNormalSpec
class IEditNormalsMod : public FPMixinInterface
Description:
This class is available in release 5.0 and later only.
This class is an interface used by the scripter and the SDK to access
the Edit Normals modifier. See the documentation for that modifier
for background on the normals and the basic operations like Break
and Unify.
All but the last two of these methods are available via the scripter
with commands like:
numNormals = $.modifiers[#Edit_Normals].EditNormalsMod.GetNumNormals ()
$.modifiers[#Edit_Normals].EditNormalsMod.SetSelection #{1..numNormals}
$.modifiers[#Edit_Normals].EditNormalsMod.Unify ().
Methods:
.
Prototype:
int EnfnGetSelLevel ();
Remarks:
"Get" accessor for selection level - one of these values:
EN_SL_OBJECT, EN_SL_NORMAL, EN_SL_VERTEX, EN_SL_EDGE, EN_SL_FACE
.
Prototype:
int EnfnSetSelLevel (int selLevel);
Remarks:
"Set" accessor for selection level - one of these values:
EN_SL_OBJECT, EN_SL_NORMAL, EN_SL_VERTEX, EN_SL_EDGE, EN_SL_FACE
.
Prototype:
bool EnfnMove (Point3& offset, TimeValue t);
Remarks:
Moves the ends of currently selected normals by the offset indicated
- then renormalizes them to unit length.
Note that the time is currently ignored, as the Edit Normals modifier
is not yet animatable
.
Prototype:
bool EnfnRotate (Quat & rotation, TimeValue t);
Remarks:
Rotates currently selected normals by the rotation indicated.
Note that the time is currently ignored, as the Edit Normals modifier
is not yet animatable
Prototype:
bool EnfnBreakNormals (BitArray *normalSelection=NULL, INode *pNode=NULL)
Remarks:
Breaks the indicated normals into separate normals for each face.
Parameters:
BitArray *normalSelection=NULL
An optional selection set to use. If NULL, the current selection is used.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
bool EnfnUnifyNormals (BitArray *normalSelection=NULL, INode *pNode=NULL)
Remarks:
Unifies the indicated normals so there's at most one normal per vertex.
(Basically causes normals to be shared across faces at a vertex.)
Parameters:
BitArray *normalSelection=NULL
An optional selection set to use. If NULL, the current selection is used.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
bool EnfnResetNormals (BitArray *normalSelection=NULL, INode *pNode=NULL)
Remarks:
Makes the indicated normals completely non-explicit and unspecified. Generates
a rebuild & computation to determine the topology and direction of the newly
unspecified normals.
Parameters:
BitArray *normalSelection=NULL
An optional selection set to use. If NULL, the current selection is used.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
bool EnfnSpecifyNormals (BitArray *normalSelection=NULL, INode *pNode=NULL)
Remarks:
Specifies the normals indicated to be fixed to the faces they're currently used by.
Parameters:
BitArray *normalSelection=NULL
An optional selection set to use. If NULL, the current selection is used.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
bool EnfnMakeNormalsExplicit (BitArray *normalSelection=NULL, INode *pNode=NULL)
Remarks:
Make the indicated normals explicit, so they won't be based on underlying face normals.
Parameters:
BitArray *normalSelection=NULL
An optional selection set to use. If NULL, the current selection is used.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
bool EnfnCopyNormal (int normalID, INode *pNode=NULL)
Remarks:
Copies the indicated normal into the Edit Normals modifier's copy/paste buffer.
Parameters:
int normalID
The ID of the normal we want to copy.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
bool EnfnPasteNormal (BitArray *normalSelection=NULL, INode *pNode=NULL)
Remarks:
Pastes the normal currently in the Edit Normals modifier's copy/paste buffer
into the normals indicated, making them specified and explicit.
Parameters:
BitArray *normalSelection = NULL
An optional selection set to use. If NULL, the current selection is used.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
BitArray *EnfnGetSelection (INode *pNode=NULL)
Remarks:
Returns a pointer to the current selection.
Parameters:
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
bool EnfnSetSelection (BitArray & selection, INode *pNode=NULL)
Remarks:
Sets the normal selection to the selection given.
Parameters:
BitArray & selection
The desired selection
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Return Value:
True if the selection was changed; false if the new selection was the
same as the old selection.
Prototype:
bool EnfnSelect (BitArray & selection, bool invert=false, bool select=true, INode *pNode=NULL)
Remarks:
Selects, deselects, or inverts the selection of the normals indicated.
Parameters:
BitArray & selection
The normals whose selection we are trying to change
bool invert=false
If true, indicates that the normals in <selection> should have their
selection status inverted
bool select=true
If <invert> is true, this is ignored. Otherwise, if true, the normals
indicated should be selected; if false, they should be deselected.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Return Value:
True if the selection changed, false otherwise.
Prototype:
void EnfnConvertVertexSelection (BitArray & vertexSelection, BitArray & normalSelection, INode *pNode=NULL)
Remarks:
Converts a vertex selection into a selection of normals, by setting bits
on normals based at selected faces.
Parameters:
BitArray & vertexSelection
The vertex selection we're converting
BitArray & normalSelection
The output normal selection
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Return Value:
True if the selection changed, false otherwise.
Prototype:
void EnfnConvertEdgeSelection (BitArray & edgeSelection, BitArray & normalSelection, INode *pNode=NULL)
Remarks:
Converts an edge selection into a selection of normals, by setting bits
for normals used on either end and either side of selected edges.
Parameters:
BitArray & edgeSelection
The edge selection we're converting
BitArray & normalSelection
The output normal selection
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
void EnfnConvertFaceSelection (BitArray & faceSelection, BitArray & normalSelection, INode *pNode=NULL)
Remarks:
Converts a face selection into a selection of normals, by setting bits
on normals used by selected faces.
Parameters:
BitArray & faceSelection
The face selection we're converting
BitArray & normalSelection
The output normal selection
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
int EnfnGetNumNormals (INode *pNode=NULL)
Remarks:
Returns the current number of normals.
Parameters:
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
Point3 *EnfnGetNormal (int normalID, INode *pNode=NULL, TimeValue t=0)
Remarks:
Returns a pointer to the normal indicated.
Parameters:
int normalID
The index of the normal
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
TimeValue t=0
This is currently unused - but might be important if we add animation
capabilities to Edit Normals in the future.
Prototype:
void EnfnSetNormal (int normalID, Point3 &direction, INode *pNode=NULL, TimeValue t=0)
Remarks:
Sets the indicated normal to a specific value. NOTE that this does
not set the "explicitness" of this normal. If the normal is not made
explicit, it will be restored to its default value the next time non
explicit normals are recomputed.
Parameters:
int normalID
The index of the normal
Point3 & direction
The desired normal direction. If not already normalized to a length of 1,
this method will normalize it.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
TimeValue t=0
This is currently unused - but might be important if we add animation
capabilities to Edit Normals in the future.
Prototype:
bool EnfnGetNormalExplicit (int normalID, INode *pNode=NULL)
Remarks:
Controls whether a given normal is built from smoothing groups or set to an explicit value
(Also makes the normal specified for all faces using this normal.)
Parameters:
int normalID
The index of the normal
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
void EnfnSetNormalExplicit (int normID, bool value, INode *pNode=NULL)
Remarks:
Makes the indicated normal explicit (or not). If setting the normal to
explicit, it will also be set to "specified" on all faces using it. If
setting it to non-explicit, the modifier recomputes all non-explicit
normals to bring it up to date.
Parameters:
int normalID
The index of the normal
bool value
True to make this normal explicit, false to make it non-explicit.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
int EnfnGetNumFaces (INode *pNode=NULL)
Remarks:
Returns the number of faces in the normal specification..
Parameters:
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
int EnfnGetFaceDegree (int face, INode *pNode=NULL)
Remarks:
Returns the degree of the face indicated. (3 for triangle, 4
for quad, etc.)
Parameters:
int face
The desired face.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
int EnfnGetNormalID (int face, int corner, INode *pNode=NULL)
Remarks:
Gets the index of the normal in the indicated corner of the indicated
face
Parameters:
int face
The desired face.
int corner
The desired corner, in the range of 0 to EnfnGetFaceDegree(face)-1.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
void EnfnSetNormalID (int face, int corner, int normalID, INode *pNode=NULL)
Remarks:
Sets the index of the normal in the indicated corner of the indicated
face
Parameters:
int face
The desired face.
int corner
The desired corner, in the range of 0 to EnfnGetFaceDegree(face)-1.
int normalID
The index of the desired normal
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
bool EnfnGetFaceNormalSpecified (int face, int corner, INode *pNode=NULL)
Remarks:
Indicates whether a particular corner of a particular face is specified
to use a specific normal or not.
Parameters:
int face
The desired face.
int corner
The desired corner, in the range of 0 to EnfnGetFaceDegree(face)-1.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
void EnfnSetFaceNormalSpecified (int face, int corner, bool specified,
INode *pNode=NULL)
Remarks:
Controls whether a corner of a face uses a specific normal ID, or
builds normals based on smoothing groups. If called to set a corner
to unspecified, it generates a rebuild of nonspecified normals and
a recomputation of nonexplicit normals at next update.
Parameters:
int face
The desired face.
int corner
The desired corner, in the range of 0 to EnfnGetFaceDegree(face)-1.
bool specified
True to specify, false to set as unspecified.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
int EnfnGetNumVertices (INode *pNode=NULL)
Remarks:
Returns the number of vertices in the current mesh cache..
Parameters:
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
int EnfnGetVertexID (int face, int corner, INode *pNode=NULL)
Remarks:
Returns the vertex used in a corner of a face, in the current mesh cache.
(Useful for determining the "base" of the normal used in that corner of
that face.)
Parameters:
int face
The desired face.
int corner
The desired corner, in the range of 0 to EnfnGetFaceDegree(face)-1.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
Point3 EnfnGetVertex (int vertexID, INode *pNode=NULL, TimeValue t=0)
Remarks:
Returns the location of the vertex indicated (in the current mesh cache).
Parameters:
int vertexID
The desired vertex.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
TimeValue t=0
This is currently unused - but might be important if we add animation
capabilities to Edit Normals in the future.
Prototype:
int EnfnGetNumEdges (INode *pNode=NULL)
Remarks:
Returns the number of edges in the current mesh cache.
Parameters:
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
int EnfnGetEdgeID (int faceIndex, int sideIndex, INode *pNode=NULL)
Remarks:
Returns the index of the edge used on a particular side of a particular
face, in the current mesh cache
Parameters:
int faceIndex
The desired face.
int side
The desired side, in the range of 0 to EnfnGetFaceDegree(faceIndex)-1.
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
int EnfnGetFaceEdgeSide (int faceIndex, int edgeIndex, INode *pNode=NULL)
Remarks:
Tells you which side of the face a given edge is on. (Can be useful for
getting normal and vertex information around the edge.)
Parameters:
int faceIndex
The desired face.
int edgeIndex
The desired edge
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Return Value:
The side of the face, in the range of 0 to EnfnGetFaceDegree(faceIndex)-1,
or -1 if the edge was not found on this face
Prototype:
int EnfnGetEdgeVertex (int edgeIndex, int end, INode *pNode=NULL)
Remarks:
Returns the vertex at the end of the edge.
Parameters:
int edgeIndex
The desired edge.
int end
The desired end - either 0 or 1
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
int EnfnGetEdgeFace (int edgeIndex, int side, INode *pNode=NULL) { return 0; }
Remarks:
Tells you what face is on a particular side of a particular edge.
Parameters:
int edgeIndex
The index of the edge in the MNMesh's edge array.
int side
Indicates which side of the edge you want the face from. (Values: 0 or 1.)
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Return Value:
The index of the desired face, or -1 if there's an error or if there is
no face on that side.
Prototype:
int EnfnGetEdgeNormal (int edgeIndex, int end, int side, INode *pNode=NULL)
Remarks:
Returns the normal associated with a particular end and side of this edge.
Parameters:
int edgeIndex
The index of the edge in the MNMesh's edge array.
int end
Indicates which end of the edge should be used. (Values: 0 or 1.)
int side
Indicates which side of the edge should be used - the edge may have
different normals used by the faces on either side. (Values:
0 or 1.)
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Return Value:
The index of the desired normal..
Prototype:
void EnfnRebuildNormals (INode *pNode=NULL) { }
Remarks:
Forces the modifier to rebuild all non-specified normals from the
face smoothing groups. Note that this can change the number of
normals in some cases, and often changes their order
Parameters:
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
void EnfnRecomputeNormals (INode *pNode=NULL) { }
Remarks:
Forces the modifier to recompute all non-explicit normals.
Parameters:
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
Prototype:
MNMesh *EnfnGetMesh (INode *pNode=NULL, TimeValue t=0)
Remarks:
Returns a pointer to the cached copy of the MNMesh held by the
EditNormalsModData. This is a "stripped-down" copy of the last mesh
that was output by the modifier. It contains no maps, vertex or
edge data, or normals. It's mainly used as a temporary "parent"
to the localdata's MNNormalSpec in operations such as Display.
Parameters:
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
TimeValue t=0
This is currently unused - but might be important if we add animation
capabilities to Edit Normals in the future.
Prototype:
MNNormalSpec *EnfnGetNormals (INode *pNode=NULL, TimeValue t=0)
Remarks:
Returns a pointer to the MNNormalSpec used by the EditNormalsModData.
This MNNormalSpec is not part of any particular MNMesh, rather it's
used as the local data of the EditNormalsMod to indicate what normals
should be applied to the mesh coming up the pipe. Its "parent"
pointer is generally set to NULL, and should be set to a mesh like
the one you get from EnfnGetMesh before you do certain operations.
(See class MNNormalSpec for details on which methods require an
accurate "parent" pointer.
Parameters:
INode *pNode = NULL
If the Edit Normals modifier is instanced across several nodes, this
parameter can be used to indicate which node you mean to modify normals in.
If you want to modify normals in all nodes, you must make a separate call
for each node. If NULL, it assumes you want to modify normals in the "first"
node. (This is fine if the modifier is only applied to one node, as is
usually the case.)
TimeValue t=0
This is currently unused - but might be important if we add animation
capabilities to Edit Normals in the future.