IEditNormalsMod Class Reference
#include <iEditNormals.h>
Inheritance diagram for IEditNormalsMod:
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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| static UtilExport void * | operator new[] (size_t size, int block_type, const char *filename, int line) |
| New operator used to allocate arrays of objects. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| 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. More... | |
| static UtilExport void * | operator new (size_t size, void *placement_ptr) |
| Placement new operator. More... | |
| static UtilExport void | operator delete (void *ptr, void *placement_ptr) |
| Placement delete operator. More... | |
| static UtilExport void * | aligned_malloc (size_t size, size_t alignment) |
| Allocates memory on a specified alignment boundary. More... | |
| static UtilExport void * | aligned_realloc (void *ptr, size_t size, size_t alignment) |
| Reallocates memory on a specified alignment boundary. More... | |
| static UtilExport void | aligned_free (void *ptr) |
| Frees a block of memory that was allocated with aligned_malloc/aligned_realloc. More... | |
| Static Public Attributes inherited from FPInterface | |
| static CoreExport FPInterfaceDesc | nullInterface |
| Protected Member Functions inherited from FPMixinInterface | |
| FPMixinInterface (const FPMixinInterface &rhs) | |
| FPMixinInterface & | operator= (const FPMixinInterface &rhs) |
| Protected Member Functions inherited from FPInterface | |
| virtual FPStatus | _dispatch_fn (FunctionID fid, TimeValue t, FPValue &result, FPParams *p) |
| Protected Attributes inherited from FPMixinInterface | |
| Tab< InterfaceNotifyCallback * > * | interfaceNotifyCBs |
Detailed Description
- See also
- Class MNMesh , Class MNNormalSpec
class IEditNormalsMod : public FPMixinInterface
- Description:
- 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 ()
Member Function Documentation
◆ PROP_FNS()
| PROP_FNS | ( | enfn_get_sel_level | , |
| EnfnGetSelLevel | , | ||
| enfn_set_sel_level | , | ||
| EnfnSetSelLevel | , | ||
| TYPE_INT | |||
| ) |
◆ FNT_1() [1/2]
| FNT_1 | ( | enfn_move | , |
| TYPE_bool | , | ||
| EnfnMove | , | ||
| TYPE_POINT3_BR | |||
| ) |
◆ FNT_1() [2/2]
| FNT_1 | ( | enfn_rotate | , |
| TYPE_bool | , | ||
| EnfnRotate | , | ||
| TYPE_QUAT_BR | |||
| ) |
◆ FN_3() [1/9]
| FN_3 | ( | enfn_break | , |
| TYPE_bool | , | ||
| EnfnBreakNormals | , | ||
| TYPE_BITARRAY | , | ||
| TYPE_INODE | , | ||
| TYPE_bool | |||
| ) |
◆ FN_3() [2/9]
| FN_3 | ( | enfn_unify | , |
| TYPE_bool | , | ||
| EnfnUnifyNormals | , | ||
| TYPE_BITARRAY | , | ||
| TYPE_INODE | , | ||
| TYPE_bool | |||
| ) |
◆ FN_2() [1/9]
| FN_2 | ( | enfn_reset | , |
| TYPE_bool | , | ||
| EnfnResetNormals | , | ||
| TYPE_BITARRAY | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_2() [2/9]
| FN_2 | ( | enfn_specify | , |
| TYPE_bool | , | ||
| EnfnSpecifyNormals | , | ||
| TYPE_BITARRAY | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_2() [3/9]
| FN_2 | ( | enfn_make_explicit | , |
| TYPE_bool | , | ||
| EnfnMakeNormalsExplicit | , | ||
| TYPE_BITARRAY | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_2() [4/9]
| FN_2 | ( | enfn_copy | , |
| TYPE_bool | , | ||
| EnfnCopyNormal | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_2() [5/9]
| FN_2 | ( | enfn_paste | , |
| TYPE_bool | , | ||
| EnfnPasteNormal | , | ||
| TYPE_BITARRAY | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_4() [1/4]
| FN_4 | ( | enfn_average | , |
| TYPE_bool | , | ||
| EnfnAverageNormals | , | ||
| TYPE_bool | , | ||
| TYPE_FLOAT | , | ||
| TYPE_BITARRAY | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_2() [6/9]
| FN_2 | ( | enfn_average_global | , |
| TYPE_bool | , | ||
| EnfnAverageGlobalNormals | , | ||
| TYPE_bool | , | ||
| TYPE_FLOAT | |||
| ) |
◆ FN_4() [2/4]
| FN_4 | ( | enfn_average_two | , |
| TYPE_bool | , | ||
| EnfnAverageTwoNormals | , | ||
| TYPE_INODE | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | , | ||
| TYPE_INDEX | |||
| ) |
◆ FN_1() [1/5]
| FN_1 | ( | enfn_get_selection | , |
| TYPE_BITARRAY | , | ||
| EnfnGetSelection | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_2() [7/9]
| FN_2 | ( | enfn_set_selection | , |
| TYPE_bool | , | ||
| EnfnSetSelection | , | ||
| TYPE_BITARRAY_BR | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_4() [3/4]
| FN_4 | ( | enfn_select | , |
| TYPE_bool | , | ||
| EnfnSelect | , | ||
| TYPE_BITARRAY_BR | , | ||
| TYPE_bool | , | ||
| TYPE_bool | , | ||
| TYPE_INODE | |||
| ) |
◆ VFN_3() [1/4]
| VFN_3 | ( | enfn_convert_vertex_selection | , |
| EnfnConvertVertexSelection | , | ||
| TYPE_BITARRAY_BR | , | ||
| TYPE_BITARRAY_BR | , | ||
| TYPE_INODE | |||
| ) |
◆ VFN_3() [2/4]
| VFN_3 | ( | enfn_convert_edge_selection | , |
| EnfnConvertEdgeSelection | , | ||
| TYPE_BITARRAY_BR | , | ||
| TYPE_BITARRAY_BR | , | ||
| TYPE_INODE | |||
| ) |
◆ VFN_3() [3/4]
| VFN_3 | ( | enfn_convert_face_selection | , |
| EnfnConvertFaceSelection | , | ||
| TYPE_BITARRAY_BR | , | ||
| TYPE_BITARRAY_BR | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_1() [2/5]
| FN_1 | ( | enfn_get_num_normals | , |
| TYPE_INT | , | ||
| EnfnGetNumNormals | , | ||
| TYPE_INODE | |||
| ) |
◆ FNT_2() [1/2]
| FNT_2 | ( | enfn_get_normal | , |
| TYPE_POINT3 | , | ||
| EnfnGetNormal | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | |||
| ) |
◆ VFNT_3()
| VFNT_3 | ( | enfn_set_normal | , |
| EnfnSetNormal | , | ||
| TYPE_INDEX | , | ||
| TYPE_POINT3_BR | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_2() [8/9]
| FN_2 | ( | enfn_get_normal_explicit | , |
| TYPE_bool | , | ||
| EnfnGetNormalExplicit | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | |||
| ) |
◆ VFN_3() [4/4]
| VFN_3 | ( | enfn_set_normal_explicit | , |
| EnfnSetNormalExplicit | , | ||
| TYPE_INDEX | , | ||
| TYPE_bool | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_1() [3/5]
| FN_1 | ( | enfn_get_num_faces | , |
| TYPE_INT | , | ||
| EnfnGetNumFaces | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_2() [9/9]
| FN_2 | ( | enfn_get_face_degree | , |
| TYPE_INT | , | ||
| EnfnGetFaceDegree | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_3() [3/9]
| FN_3 | ( | enfn_get_normal_id | , |
| TYPE_INDEX | , | ||
| EnfnGetNormalID | , | ||
| TYPE_INDEX | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | |||
| ) |
◆ VFN_4() [1/2]
| VFN_4 | ( | enfn_set_normal_id | , |
| EnfnSetNormalID | , | ||
| TYPE_INDEX | , | ||
| TYPE_INDEX | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_3() [4/9]
| FN_3 | ( | enfn_get_face_normal_specified | , |
| TYPE_bool | , | ||
| EnfnGetFaceNormalSpecified | , | ||
| TYPE_INDEX | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | |||
| ) |
◆ VFN_4() [2/2]
| VFN_4 | ( | enfn_set_face_normal_specified | , |
| EnfnSetFaceNormalSpecified | , | ||
| TYPE_INDEX | , | ||
| TYPE_INDEX | , | ||
| TYPE_bool | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_1() [4/5]
| FN_1 | ( | enfn_get_num_vertices | , |
| TYPE_INT | , | ||
| EnfnGetNumVertices | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_3() [5/9]
| FN_3 | ( | enfn_get_vertex_id | , |
| TYPE_INDEX | , | ||
| EnfnGetVertexID | , | ||
| TYPE_INDEX | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | |||
| ) |
◆ FNT_2() [2/2]
| FNT_2 | ( | enfn_get_vertex | , |
| TYPE_POINT3_BV | , | ||
| EnfnGetVertex | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_1() [5/5]
| FN_1 | ( | enfn_get_num_edges | , |
| TYPE_INT | , | ||
| EnfnGetNumEdges | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_3() [6/9]
| FN_3 | ( | enfn_get_edge_id | , |
| TYPE_INDEX | , | ||
| EnfnGetEdgeID | , | ||
| TYPE_INDEX | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_3() [7/9]
| FN_3 | ( | enfn_get_face_edge_side | , |
| TYPE_INDEX | , | ||
| EnfnGetFaceEdgeSide | , | ||
| TYPE_INDEX | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_3() [8/9]
| FN_3 | ( | enfn_get_edge_vertex | , |
| TYPE_INDEX | , | ||
| EnfnGetEdgeVertex | , | ||
| TYPE_INDEX | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_3() [9/9]
| FN_3 | ( | enfn_get_edge_face | , |
| TYPE_INDEX | , | ||
| EnfnGetEdgeFace | , | ||
| TYPE_INDEX | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | |||
| ) |
◆ FN_4() [4/4]
| FN_4 | ( | enfn_get_edge_normal | , |
| TYPE_INDEX | , | ||
| EnfnGetEdgeNormal | , | ||
| TYPE_INDEX | , | ||
| TYPE_INDEX | , | ||
| TYPE_INDEX | , | ||
| TYPE_INODE | |||
| ) |
◆ VFN_1() [1/2]
| VFN_1 | ( | enfn_rebuild_normals | , |
| EnfnRebuildNormals | , | ||
| TYPE_INODE | |||
| ) |
◆ VFN_1() [2/2]
| VFN_1 | ( | enfn_recompute_normals | , |
| EnfnRecomputeNormals | , | ||
| TYPE_INODE | |||
| ) |
◆ GetDesc()
|
virtual |
- Remarks
- Returns a pointer to the class which contains the interface metadata.
Implements FPInterface.
◆ EnfnGetSelLevel()
|
inlinevirtual |
- 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
◆ EnfnSetSelLevel()
◆ EnfnMove()
◆ EnfnRotate()
◆ EnfnBreakNormals()
|
inlinevirtual |
In 3ds Max 6, the Edit normals modifier had an average function added to its tool set.
- Remarks
- Breaks the indicated normals into separate normals for each face.
In 3ds Max 6, the Edit normals modifier had an average function added to its tool set. This allows the user to average the normals across the surface of the object(s). The toAverage parameter was added to this method to provide access to this new functionality.
- 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.)
bool toAverage=false
Default is false. When true, this parameter causes the normals to be averaged across the surface of the object(s).
This allows the user to average the normals across the surface of the objects(s). This method and the next four methods were added to an existing interface to provide access to this new functionality.
- 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.)
◆ EnfnUnifyNormals()
|
inlinevirtual |
- 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.)
In 3ds Max 6, the Edit normals modifier had an average function added to its tool set. This allows the user to average the normals across the surface of the objects(s). The toAverage parameter was added to this method to provide access to this new functionality.
- 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.)
bool toAverage=false
Default is false. When true, this parameter causes the normals to be averaged across the surface of the object(s).
◆ EnfnResetNormals()
|
inlinevirtual |
- 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.)
◆ EnfnSpecifyNormals()
|
inlinevirtual |
- 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.)
◆ EnfnMakeNormalsExplicit()
|
inlinevirtual |
- 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.)
◆ EnfnCopyNormal()
- 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.)
◆ EnfnPasteNormal()
|
inlinevirtual |
- 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.)
◆ EnfnAverageNormals()
◆ EnfnAverageGlobalNormals()
|
inlinevirtual |
- Remarks
- Added in 3ds Max 6 SDK.
- Parameters:
- bool useThresh=false
float threshhold=0.0f
◆ EnfnAverageTwoNormals()
◆ EnfnGetSelection()
- 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.)
◆ EnfnSetSelection()
- 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.)
- Returns
- True if the selection was changed; false if the new selection was the same as the old selection.
◆ EnfnSelect()
|
inlinevirtual |
- 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.)
- Returns
- True if the selection changed, false otherwise.
◆ EnfnConvertVertexSelection()
|
inlinevirtual |
- 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.)
- Returns
- True if the selection changed, false otherwise.
◆ EnfnConvertEdgeSelection()
|
inlinevirtual |
- 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.)
◆ EnfnConvertFaceSelection()
|
inlinevirtual |
- 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.)
◆ EnfnGetNumNormals()
- 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.)
◆ EnfnGetNormal()
- 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.
◆ EnfnSetNormal()
|
inlinevirtual |
- 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.
◆ EnfnGetNormalExplicit()
- 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.)
◆ EnfnSetNormalExplicit()
- 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.)
◆ EnfnGetNumFaces()
- 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.)
◆ EnfnGetFaceDegree()
- 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.)
◆ EnfnGetNormalID()
- 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.)
◆ EnfnSetNormalID()
|
inlinevirtual |
- 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.)
◆ EnfnGetFaceNormalSpecified()
|
inlinevirtual |
- 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.)
◆ EnfnSetFaceNormalSpecified()
|
inlinevirtual |
- 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.)
◆ EnfnGetNumVertices()
- 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.)
◆ EnfnGetVertexID()
- 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.)
◆ EnfnGetVertex()
- 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.
◆ EnfnGetNumEdges()
- 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.)
◆ EnfnGetEdgeID()
- 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.)
◆ EnfnGetFaceEdgeSide()
|
inlinevirtual |
- 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.)
- Returns
- 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
◆ EnfnGetEdgeVertex()
- 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.)
◆ EnfnGetEdgeFace()
- 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.)
- Returns
- The index of the desired face, or -1 if there's an error or if there is no face on that side.
◆ EnfnGetEdgeNormal()
|
inlinevirtual |
- 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.)
- Returns
- The index of the desired normal..
◆ EnfnRebuildNormals()
- 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.)
◆ EnfnRecomputeNormals()
- 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.)
◆ EnfnGetMesh()
- 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.
◆ EnfnGetNormals()
|
inlinevirtual |
- 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.
