MNMesh Class Reference
MNMesh Class Reference
Class Description
The MNMesh class is provided for temporary use by plug-ins, to help with complex topology-based modifications to Meshes.
Inheritance diagram for MNMesh:
Public Member Functions | |
| def | AddTri (self, args) |
| def | allocRVerts (self) |
| def | AppendNewEdges (self, args) |
| def | AppendNewFaces (self, args) |
| def | AppendNewVerts (self, args) |
| def | AsFlagUser (self) |
| def | AutoSmooth (self, args) |
| def | BBox (self, args) |
| def | BestConvexDiagonals (self, args) |
| def | BorderFromEdge (self, args) |
| def | buildNormals (self) |
| def | buildRenderNormals (self) |
| def | CheckAllData (self) |
| def | CheckForDoubledMappingVerts (self) |
| def | checkNormals (self, args) |
| def | Clear (self) |
| def | ClearAndFree (self) |
| def | ClearDispFlag (self, args) |
| def | ClearEFlags (self, args) |
| def | ClearFFlags (self, args) |
| def | ClearFlag (self, args) |
| def | ClearMap (self, args) |
| def | ClearVFlags (self, args) |
| def | CollapseDeadEdges (self) |
| def | CollapseDeadFaces (self) |
| def | CollapseDeadStructs (self) |
| def | CollapseDeadVerts (self) |
| def | CommonSmoothing |
| def | ComputeCenter (self, args) |
| def | ComputeCenters (self, args) |
| def | CopyVert (self, args) |
| def | CreateFace (self, args) |
| def | Cut (self, args) |
| def | Cut_Versioned (self, args) |
| def | CutEdge (self, args) |
| def | CutEdge_Versioned (self, args) |
| def | CutFace (self, args) |
| def | DeleteFlaggedFaces (self, args) |
| def | DetargetVertsBySharpness (self, args) |
| def | DivideFace (self, args) |
| def | DivideFace_2015 (self, args) |
| def | E (self, args) |
| def | eDataSupport (self, args) |
| def | EdgeAngle (self, args) |
| def | edgeData (self, args) |
| def | edgeFloat (self, args) |
| def | EdgeSelect (self, args) |
| def | EDNum (self) |
| def | ElementFromFace (self, args) |
| def | EliminateBadVerts |
| def | EliminateCoincidentVerts (self, args) |
| def | EliminateCollinearVerts (self) |
| def | EliminateDoubledMappingVerts (self) |
| def | EliminateIsoMapVerts (self, args) |
| def | ENum (self) |
| def | ExtrapolateMapValue (self, args) |
| def | F (self, args) |
| def | FaceBBox (self, args) |
| def | FaceFindAdjacentFaces (self, args) |
| def | FaceFindEdgeAdjacentFaces (self, args) |
| def | FaceSelect (self, args) |
| def | FenceFaceSel (self) |
| def | FenceMaterials (self) |
| def | FenceNonPlanarEdges (self, args) |
| def | FenceOneSidedEdges (self) |
| def | FenceSmGroups (self) |
| def | FillInFaceEdges (self) |
| def | FillInMesh (self) |
| def | FillInVertEdgesFaces (self) |
| def | FindAvailableSmoothingGroupFromFaceList (self, args) |
| def | FindAvailableSmoothingGroups (self, args) |
| def | FindDiagonals (self, args) |
| def | FindEdgeFromVertToVert (self, args) |
| def | FindEdgeListMapVerts (self, args) |
| def | FindFacePointMapValue (self, args) |
| def | FindFacePointTri (self, args) |
| def | FindOpenRegions (self) |
| def | FindReplacementSmGroup (self, args) |
| def | FlipElementNormals (self, args) |
| def | FlipFaceNormals (self, args) |
| def | FlipNormal (self, args) |
| def | FNum (self) |
| def | freeAllEData (self) |
| def | freeAllVData (self) |
| def | FreeChannels (self, args) |
| def | freeEData (self, args) |
| def | freeEdgeKnots (self) |
| def | freeEdges (self) |
| def | freeFaces (self) |
| def | freeMap (self, args) |
| def | freeMaps (self) |
| def | freeRVerts (self) |
| def | freeVData (self, args) |
| def | freeVertexWeights (self) |
| def | freeVerts (self) |
| def | freeVSelectionWeights (self) |
| def | GetAllSmGroups |
| def | GetBorder (self, args) |
| def | getBoundingBox |
| def | GetDispFlag (self, args) |
| def | getEdgeKnots (self) |
| def | GetEdgeNormal (self, args) |
| def | getEdgesByFlag (self, args) |
| def | getEdgeSel (self, args) |
| def | GetFaceNormal (self, args) |
| def | getFacesByFlag (self, args) |
| def | getFaceSel (self, args) |
| def | GetInterface (self, args) |
| def | GetNewMtlID |
| def | GetNewSmGroup |
| def | GetOldSmGroup |
| def | GetSelLevel (self) |
| def | GetVertexNormal (self, args) |
| def | getVertexSel (self, args) |
| def | GetVertexSpace (self, args) |
| def | getVertexWeights (self) |
| def | getVerticesByFlag (self, args) |
| def | getVSelectionWeights (self) |
| def | IndentFace (self, args) |
| def | InitMap (self, args) |
| def | InsertSpur (self, args) |
| def | InvalidateGeomCache (self) |
| def | InvalidateTopoCache |
| def | IsClosed (self) |
| def | IsEdgeMapSeam (self, args) |
| def | LiftFaceClusterFromEdge (self, args) |
| def | M (self, args) |
| def | MakeConvex (self) |
| def | MakeConvexPolyMesh |
| def | MakeFaceConvex (self, args) |
| def | MakeFacePlanar (self, args) |
| def | MakePlanar (self, args) |
| def | MakePolyMesh (self, args) |
| def | MF (self, args) |
| def | MNDebugPrint |
| def | MNDebugPrintVertexNeighborhood (self, args) |
| def | MNum (self) |
| def | MNVDebugPrint (self, args) |
| def | MultiDivideEdge (self, args) |
| def | MV (self, args) |
| def | NewAndCopyChannels (self, args) |
| def | NewEdge (self, args) |
| def | NewFace (self, args) |
| def | NewQuad (self, args) |
| def | NewTri (self, args) |
| def | NewVert (self, args) |
| def | OptimizeSmoothingGroups (self, args) |
| def | OrderVert (self, args) |
| def | OrderVerts (self) |
| def | OutToTri (self, args) |
| def | P (self, args) |
| def | PaintFaceFlag (self, args) |
| def | PaintNewSmGroup (self, args) |
| def | PrepForPipeline (self) |
| def | PropegateComponentFlags (self, args) |
| def | RegisterEdge (self, args) |
| def | Relax (self, args) |
| def | RemoveEdge (self, args) |
| def | RemoveSpur (self, args) |
| def | RemoveVertex (self, args) |
| def | Resmooth (self, args) |
| def | RestrictPolySize (self, args) |
| def | RetriangulateFace (self, args) |
| def | SelectEdgeLoop (self, args) |
| def | SelectEdgeRing (self, args) |
| def | SeparateFace (self, args) |
| def | SeparateSmGroups (self, args) |
| def | SetDiagonal (self, args) |
| def | SetDispFlag (self, args) |
| def | SetDisplayVertexColors (self, args) |
| def | setEDataSupport (self, args) |
| def | SetEdgeSel (self, args) |
| def | SetEdgeVis (self, args) |
| def | SetFaceColor (self, args) |
| def | SetFromTri (self, args) |
| def | SetMapNum (self, args) |
| def | SetMapSeamFlags (self, args) |
| def | setNumEData (self, args) |
| def | SetNumEdges (self, args) |
| def | SetNumFaces (self, args) |
| def | setNumVData (self, args) |
| def | SetNumVerts (self, args) |
| def | setVDataSupport (self, args) |
| def | SetVertColor (self, args) |
| def | ShallowCopy (self, args) |
| def | SimpleNewEdge (self, args) |
| def | Slice (self, args) |
| def | SmoothByCreases (self, args) |
| def | SplitEdge (self, args) |
| def | SplitFacesUsingBothSidesOfEdge |
| def | SplitFlaggedEdges (self, args) |
| def | SplitFlaggedVertices (self, args) |
| def | SplitTri6 (self, args) |
| def | SplitTriEdge (self, args) |
| def | SplitTriFace (self, args) |
| def | SupportEdgeKnots (self) |
| def | SupportVertexWeights (self) |
| def | SupportVSelectionWeights (self) |
| def | TargetEdgesBySelection (self, args) |
| def | TargetFacesBySelection (self, args) |
| def | TargetVertsBySelection (self, args) |
| def | Transform (self, args) |
| def | Triangulate (self) |
| def | TriangulateFace (self, args) |
| def | TriNum (self) |
| def | UpdateDisplayVertexColors (self) |
| def | updateRVerts (self, args) |
| def | V (self, args) |
| def | VClear (self, args) |
| def | vDataSupport (self, args) |
| def | VDeleteEdge (self, args) |
| def | VDeleteFace (self, args) |
| def | VDNum (self) |
| def | VEdgeIndex (self, args) |
| def | vertexData (self, args) |
| def | VertexFindAdjacentFaces (self, args) |
| def | vertexFloat (self, args) |
| def | VertexSelect (self, args) |
| def | VertexTempSel (self, args) |
| def | VFaceIndex (self, args) |
| def | VInit (self, args) |
| def | VNum (self) |
| def | VReplaceEdge (self, args) |
| def | VReplaceFace (self, args) |
| def | WeldBorderEdges (self, args) |
| def | WeldBorderVerts (self, args) |
| def | WeldEdge (self, args) |
| def | WeldOpposingEdges (self, args) |
| def | WeldVerts (self, args) |
| Public Member Functions inherited from BaseInterfaceServer | |
| def | GetInterfaceAt (self, args) |
| def | GetNumInterfaces (self) |
| Public Member Functions inherited from InterfaceServer | |
| def | GetInterface (self, args) |
| Public Member Functions inherited from Wrapper | |
| def | GetUnwrappedPtr (self) |
Static Public Attributes | |
| tuple | e = _swig_property(lambda self: (self.E(i) for i in xrange(self.ENum()))) |
| tuple | f = _swig_property(lambda self: (self.F(i) for i in xrange(self.FNum()))) |
| tuple | selLevel = _swig_property(GetSelLevel) |
| tuple | thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') |
| tuple | v = _swig_property(lambda self: (self.V(i) for i in xrange(self.VNum()))) |
| Static Public Attributes inherited from BaseInterfaceServer | |
| tuple | Interfaces = _swig_property(lambda self: (self.GetInterfaceAt(i) for i in xrange(self.GetNumInterfaces()))) |
| tuple | NumInterfaces = _swig_property(GetNumInterfaces) |
| tuple | thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') |
| Static Public Attributes inherited from InterfaceServer | |
| tuple | thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') |
| Static Public Attributes inherited from Wrapper | |
| tuple | thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') |
Member Function Documentation
| def AddTri | ( | self, | |
| args | |||
| ) |
AddTri(MNMesh self, Mesh f)
| def allocRVerts | ( | self | ) |
allocRVerts(MNMesh self)
| def AppendNewEdges | ( | self, | |
| args | |||
| ) |
AppendNewEdges(MNMesh self, int nenum) -> int
| def AppendNewFaces | ( | self, | |
| args | |||
| ) |
AppendNewFaces(MNMesh self, int nfnum) -> int
| def AppendNewVerts | ( | self, | |
| args | |||
| ) |
AppendNewVerts(MNMesh self, int nvnum) -> int
| def AsFlagUser | ( | self | ) |
AsFlagUser(MNMesh self) -> FlagUser
| def AutoSmooth | ( | self, | |
| args | |||
| ) |
AutoSmooth(MNMesh self, float angle, BOOL useSel, BOOL preventIndirectSmoothing)
| def BBox | ( | self, | |
| args | |||
| ) |
BBox(MNMesh self, Box3 bbox, bool targonly=True) BBox(MNMesh self, Box3 bbox)
| def BestConvexDiagonals | ( | self, | |
| args | |||
| ) |
BestConvexDiagonals(MNMesh self, int ff, int * diag=None) BestConvexDiagonals(MNMesh self, int ff) BestConvexDiagonals(MNMesh self, int deg, int * vv, int * diag)
| def BorderFromEdge | ( | self, | |
| args | |||
| ) |
BorderFromEdge(MNMesh self, int ee, BitArray eset)
| def buildNormals | ( | self | ) |
buildNormals(MNMesh self)
| def buildRenderNormals | ( | self | ) |
buildRenderNormals(MNMesh self)
| def CheckAllData | ( | self | ) |
CheckAllData(MNMesh self) -> bool
| def CheckForDoubledMappingVerts | ( | self | ) |
CheckForDoubledMappingVerts(MNMesh self) -> BOOL
| def checkNormals | ( | self, | |
| args | |||
| ) |
checkNormals(MNMesh self, BOOL illum)
| def Clear | ( | self | ) |
Clear(MNMesh self)
| def ClearAndFree | ( | self | ) |
ClearAndFree(MNMesh self)
| def ClearDispFlag | ( | self, | |
| args | |||
| ) |
ClearDispFlag(MNMesh self, DWORD f)
| def ClearEFlags | ( | self, | |
| args | |||
| ) |
ClearEFlags(MNMesh self, DWORD fl)
| def ClearFFlags | ( | self, | |
| args | |||
| ) |
ClearFFlags(MNMesh self, DWORD fl)
| def ClearFlag | ( | self, | |
| args | |||
| ) |
ClearFlag(MNMesh self, DWORD fl)
| def ClearMap | ( | self, | |
| args | |||
| ) |
ClearMap(MNMesh self, int mapChannel)
| def ClearVFlags | ( | self, | |
| args | |||
| ) |
ClearVFlags(MNMesh self, DWORD fl)
| def CollapseDeadEdges | ( | self | ) |
CollapseDeadEdges(MNMesh self)
| def CollapseDeadFaces | ( | self | ) |
CollapseDeadFaces(MNMesh self)
| def CollapseDeadStructs | ( | self | ) |
CollapseDeadStructs(MNMesh self)
| def CollapseDeadVerts | ( | self | ) |
CollapseDeadVerts(MNMesh self)
| def CommonSmoothing | ( | self, | |
targonly = True |
|||
| ) |
CommonSmoothing(MNMesh self, bool targonly=True) -> DWORD CommonSmoothing(MNMesh self) -> DWORD
| def ComputeCenter | ( | self, | |
| args | |||
| ) |
ComputeCenter(MNMesh self, int ff, Point3 ctr)
| def ComputeCenters | ( | self, | |
| args | |||
| ) |
ComputeCenters(MNMesh self, Point3 ctr, bool targonly=True) ComputeCenters(MNMesh self, Point3 ctr)
| def CopyVert | ( | self, | |
| args | |||
| ) |
CopyVert(MNMesh self, int nv, int ov)
| def CreateFace | ( | self, | |
| args | |||
| ) |
CreateFace(MNMesh self, int degg, int * vv) -> int
| def Cut | ( | self, | |
| args | |||
| ) |
Cut(MNMesh self, int startv, Point3 end, Point3 Z, bool split) -> int
| def Cut_Versioned | ( | self, | |
| args | |||
| ) |
Cut_Versioned(MNMesh self, int startv, Point3 end, Point3 Z, bool split, DWORD ver) -> int
| def CutEdge | ( | self, | |
| args | |||
| ) |
CutEdge(MNMesh self, int e1, float prop1, int e2, float prop2, Point3 Z, bool split) -> int
| def CutEdge_Versioned | ( | self, | |
| args | |||
| ) |
CutEdge_Versioned(MNMesh self, int e1, float prop1, int e2, float prop2, Point3 Z, bool split, DWORD ver) -> int
| def CutFace | ( | self, | |
| args | |||
| ) |
CutFace(MNMesh self, int f1, Point3 p1, Point3 p2, Point3 Z, bool split) -> int
| def DeleteFlaggedFaces | ( | self, | |
| args | |||
| ) |
DeleteFlaggedFaces(MNMesh self, DWORD deathflags, DWORD nvCopyFlags=0x0) DeleteFlaggedFaces(MNMesh self, DWORD deathflags)
| def DetargetVertsBySharpness | ( | self, | |
| args | |||
| ) |
DetargetVertsBySharpness(MNMesh self, float sharpval)
| def DivideFace | ( | self, | |
| args | |||
| ) |
DivideFace(MNMesh self, int ff, FloatList bary) -> int
| def DivideFace_2015 | ( | self, | |
| args | |||
| ) |
DivideFace_2015(MNMesh self, int ff, FloatList bary) -> int
| def E | ( | self, | |
| args | |||
| ) |
E(MNMesh self, int i) -> MNEdge
| def eDataSupport | ( | self, | |
| args | |||
| ) |
eDataSupport(MNMesh self, int edChannel) -> BOOL
| def EdgeAngle | ( | self, | |
| args | |||
| ) |
EdgeAngle(MNMesh self, int ed) -> float
| def edgeData | ( | self, | |
| args | |||
| ) |
edgeData(MNMesh self, int edChannel) -> void *
| def edgeFloat | ( | self, | |
| args | |||
| ) |
edgeFloat(MNMesh self, int edChannel) -> float *
| def EdgeSelect | ( | self, | |
| args | |||
| ) |
EdgeSelect(MNMesh self, BitArray esel)
| def EDNum | ( | self | ) |
EDNum(MNMesh self) -> int
| def ElementFromFace | ( | self, | |
| args | |||
| ) |
ElementFromFace(MNMesh self, int ff, BitArray fset)
| def EliminateBadVerts | ( | self, | |
flag = 0 |
|||
| ) |
EliminateBadVerts(MNMesh self, DWORD flag=0) -> bool EliminateBadVerts(MNMesh self) -> bool
| def EliminateCoincidentVerts | ( | self, | |
| args | |||
| ) |
EliminateCoincidentVerts(MNMesh self, float thresh=MNEPS) EliminateCoincidentVerts(MNMesh self)
| def EliminateCollinearVerts | ( | self | ) |
EliminateCollinearVerts(MNMesh self)
| def EliminateDoubledMappingVerts | ( | self | ) |
EliminateDoubledMappingVerts(MNMesh self)
| def EliminateIsoMapVerts | ( | self, | |
| args | |||
| ) |
EliminateIsoMapVerts(MNMesh self) EliminateIsoMapVerts(MNMesh self, int mapChannel)
| def ENum | ( | self | ) |
ENum(MNMesh self) -> int
| def ExtrapolateMapValue | ( | self, | |
| args | |||
| ) |
ExtrapolateMapValue(MNMesh self, int face, int edge, Point3 pt, int mapChannel) -> Point3
| def F | ( | self, | |
| args | |||
| ) |
F(MNMesh self, int i) -> MNFace
| def FaceBBox | ( | self, | |
| args | |||
| ) |
FaceBBox(MNMesh self, int ff, Box3 bbox)
| def FaceFindAdjacentFaces | ( | self, | |
| args | |||
| ) |
FaceFindAdjacentFaces(MNMesh self, int faceIndex, BitArray adjacentFaces, IntList adjacentFaceIndexes, bool includeFaceIndex=False) FaceFindAdjacentFaces(MNMesh self, int faceIndex, BitArray adjacentFaces, IntList adjacentFaceIndexes)
| def FaceFindEdgeAdjacentFaces | ( | self, | |
| args | |||
| ) |
FaceFindEdgeAdjacentFaces(MNMesh self, int faceIndex, BitArray adjacentFaces, IntList adjacentFaceIndexes, bool includeFaceIndex=False) FaceFindEdgeAdjacentFaces(MNMesh self, int faceIndex, BitArray adjacentFaces, IntList adjacentFaceIndexes)
| def FaceSelect | ( | self, | |
| args | |||
| ) |
FaceSelect(MNMesh self, BitArray fsel)
| def FenceFaceSel | ( | self | ) |
FenceFaceSel(MNMesh self)
| def FenceMaterials | ( | self | ) |
FenceMaterials(MNMesh self)
| def FenceNonPlanarEdges | ( | self, | |
| args | |||
| ) |
FenceNonPlanarEdges(MNMesh self, float thresh=.9999, bool makevis=True) FenceNonPlanarEdges(MNMesh self, float thresh=.9999) FenceNonPlanarEdges(MNMesh self)
| def FenceOneSidedEdges | ( | self | ) |
FenceOneSidedEdges(MNMesh self)
| def FenceSmGroups | ( | self | ) |
FenceSmGroups(MNMesh self)
| def FillInFaceEdges | ( | self | ) |
FillInFaceEdges(MNMesh self)
| def FillInMesh | ( | self | ) |
FillInMesh(MNMesh self)
| def FillInVertEdgesFaces | ( | self | ) |
FillInVertEdgesFaces(MNMesh self)
| def FindAvailableSmoothingGroupFromFaceList | ( | self, | |
| args | |||
| ) |
FindAvailableSmoothingGroupFromFaceList(MNMesh self, IntTab faceList, DWORD excludeSmoothing=0) -> DWORD FindAvailableSmoothingGroupFromFaceList(MNMesh self, IntTab faceList) -> DWORD
| def FindAvailableSmoothingGroups | ( | self, | |
| args | |||
| ) |
FindAvailableSmoothingGroups(MNMesh self, int faceIndex, DWORD excludeSmoothing=0) -> DWORD FindAvailableSmoothingGroups(MNMesh self, int faceIndex) -> DWORD
| def FindDiagonals | ( | self, | |
| args | |||
| ) |
FindDiagonals(MNMesh self, int ff, int * diag) FindDiagonals(MNMesh self, int deg, int * vv, int * diag)
| def FindEdgeFromVertToVert | ( | self, | |
| args | |||
| ) |
FindEdgeFromVertToVert(MNMesh self, int vrt1, int vrt2) -> int
| def FindEdgeListMapVerts | ( | self, | |
| args | |||
| ) |
FindEdgeListMapVerts(MNMesh self, IntList lp, IntList mv, int mapChannel)
| def FindFacePointMapValue | ( | self, | |
| args | |||
| ) |
FindFacePointMapValue(MNMesh self, int ff, Point3 pt, int mapChannel) -> Point3
| def FindFacePointTri | ( | self, | |
| args | |||
| ) |
FindFacePointTri(MNMesh self, int ff, Point3 pt, double * bary, int * tri) -> int
| def FindOpenRegions | ( | self | ) |
FindOpenRegions(MNMesh self)
| def FindReplacementSmGroup | ( | self, | |
| args | |||
| ) |
FindReplacementSmGroup(MNMesh self, int ff, DWORD os) -> DWORD
| def FlipElementNormals | ( | self, | |
| args | |||
| ) |
FlipElementNormals(MNMesh self, DWORD flag=MN_SEL) -> bool FlipElementNormals(MNMesh self) -> bool
| def FlipFaceNormals | ( | self, | |
| args | |||
| ) |
FlipFaceNormals(MNMesh self, DWORD faceFlag) -> bool
| def FlipNormal | ( | self, | |
| args | |||
| ) |
FlipNormal(MNMesh self, int faceIndex)
| def FNum | ( | self | ) |
FNum(MNMesh self) -> int
| def freeAllEData | ( | self | ) |
freeAllEData(MNMesh self)
| def freeAllVData | ( | self | ) |
freeAllVData(MNMesh self)
| def FreeChannels | ( | self, | |
| args | |||
| ) |
FreeChannels(MNMesh self, ChannelMask channels, BOOL zeroOthers=1) FreeChannels(MNMesh self, ChannelMask channels)
| def freeEData | ( | self, | |
| args | |||
| ) |
freeEData(MNMesh self, int edChannel)
| def freeEdgeKnots | ( | self | ) |
freeEdgeKnots(MNMesh self)
| def freeEdges | ( | self | ) |
freeEdges(MNMesh self)
| def freeFaces | ( | self | ) |
freeFaces(MNMesh self)
| def freeMap | ( | self, | |
| args | |||
| ) |
freeMap(MNMesh self, int mapChannel)
| def freeMaps | ( | self | ) |
freeMaps(MNMesh self)
| def freeRVerts | ( | self | ) |
freeRVerts(MNMesh self)
| def freeVData | ( | self, | |
| args | |||
| ) |
freeVData(MNMesh self, int vdChannel)
| def freeVertexWeights | ( | self | ) |
freeVertexWeights(MNMesh self)
| def freeVerts | ( | self | ) |
freeVerts(MNMesh self)
| def freeVSelectionWeights | ( | self | ) |
freeVSelectionWeights(MNMesh self)
| def GetAllSmGroups | ( | self, | |
targonly = True |
|||
| ) |
GetAllSmGroups(MNMesh self, bool targonly=True) -> DWORD GetAllSmGroups(MNMesh self) -> DWORD
| def GetBorder | ( | self, | |
| args | |||
| ) |
GetBorder(MNMesh self, MNMeshBorder & brd, int selLevel=MNM_SL_OBJECT, DWORD targetFlag=MN_SEL) GetBorder(MNMesh self, MNMeshBorder & brd, int selLevel=MNM_SL_OBJECT) GetBorder(MNMesh self, MNMeshBorder & brd)
| def getBoundingBox | ( | self, | |
tm = None, |
|||
targonly = True |
|||
| ) |
getBoundingBox(MNMesh self, Matrix3 tm=None, bool targonly=True) -> Box3 getBoundingBox(MNMesh self, Matrix3 tm=None) -> Box3 getBoundingBox(MNMesh self) -> Box3
| def GetDispFlag | ( | self, | |
| args | |||
| ) |
GetDispFlag(MNMesh self, DWORD f) -> DWORD
| def getEdgeKnots | ( | self | ) |
getEdgeKnots(MNMesh self) -> float *
| def GetEdgeNormal | ( | self, | |
| args | |||
| ) |
GetEdgeNormal(MNMesh self, int ed) -> Point3 GetEdgeNormal(MNMesh self, int vrt1, int vrt2) -> Point3
| def getEdgesByFlag | ( | self, | |
| args | |||
| ) |
getEdgesByFlag(MNMesh self, BitArray eset, DWORD flags, DWORD fmask=0x0) -> bool getEdgesByFlag(MNMesh self, BitArray eset, DWORD flags) -> bool
| def getEdgeSel | ( | self, | |
| args | |||
| ) |
getEdgeSel(MNMesh self, BitArray esel) -> bool
| def GetFaceNormal | ( | self, | |
| args | |||
| ) |
GetFaceNormal(MNMesh self, int fc, bool nrmlz=True) -> Point3 GetFaceNormal(MNMesh self, int fc) -> Point3
| def getFacesByFlag | ( | self, | |
| args | |||
| ) |
getFacesByFlag(MNMesh self, BitArray fset, DWORD flags, DWORD fmask=0x0) -> bool getFacesByFlag(MNMesh self, BitArray fset, DWORD flags) -> bool
| def getFaceSel | ( | self, | |
| args | |||
| ) |
getFaceSel(MNMesh self, BitArray fsel) -> bool
| def GetInterface | ( | self, | |
| args | |||
| ) |
GetInterface(MNMesh self, Interface_ID id) -> BaseInterface
| def GetNewMtlID | ( | self, | |
targonly = True |
|||
| ) |
GetNewMtlID(MNMesh self, bool targonly=True) -> MtlID GetNewMtlID(MNMesh self) -> MtlID
| def GetNewSmGroup | ( | self, | |
targonly = True |
|||
| ) |
GetNewSmGroup(MNMesh self, bool targonly=True) -> DWORD GetNewSmGroup(MNMesh self) -> DWORD
| def GetOldSmGroup | ( | self, | |
targonly = True |
|||
| ) |
GetOldSmGroup(MNMesh self, bool targonly=True) -> DWORD GetOldSmGroup(MNMesh self) -> DWORD
| def GetSelLevel | ( | self | ) |
GetSelLevel(MNMesh self) -> int
| def GetVertexNormal | ( | self, | |
| args | |||
| ) |
GetVertexNormal(MNMesh self, int vrt) -> Point3
| def getVertexSel | ( | self, | |
| args | |||
| ) |
getVertexSel(MNMesh self, BitArray vsel) -> bool
| def GetVertexSpace | ( | self, | |
| args | |||
| ) |
GetVertexSpace(MNMesh self, int vrt, Matrix3 tm)
| def getVertexWeights | ( | self | ) |
getVertexWeights(MNMesh self) -> float *
| def getVerticesByFlag | ( | self, | |
| args | |||
| ) |
getVerticesByFlag(MNMesh self, BitArray vset, DWORD flags, DWORD fmask=0x0) -> bool getVerticesByFlag(MNMesh self, BitArray vset, DWORD flags) -> bool
| def getVSelectionWeights | ( | self | ) |
getVSelectionWeights(MNMesh self) -> float *
| def IndentFace | ( | self, | |
| args | |||
| ) |
IndentFace(MNMesh self, int ff, int ei, int nv, int * ne=None, bool nevis=TRUE, bool nesel=True) -> int IndentFace(MNMesh self, int ff, int ei, int nv, int * ne=None, bool nevis=TRUE) -> int IndentFace(MNMesh self, int ff, int ei, int nv, int * ne=None) -> int IndentFace(MNMesh self, int ff, int ei, int nv) -> int
| def InitMap | ( | self, | |
| args | |||
| ) |
InitMap(MNMesh self, int mapChannel)
| def InsertSpur | ( | self, | |
| args | |||
| ) |
InsertSpur(MNMesh self, int face, int vertIndex, Tab< int > * ptMapVertArray=None) -> int InsertSpur(MNMesh self, int face, int vertIndex) -> int
| def InvalidateGeomCache | ( | self | ) |
InvalidateGeomCache(MNMesh self)
| def InvalidateTopoCache | ( | self, | |
in_clearCacheFlags = True |
|||
| ) |
InvalidateTopoCache(MNMesh self, bool in_clearCacheFlags=True) InvalidateTopoCache(MNMesh self)
| def IsClosed | ( | self | ) |
IsClosed(MNMesh self) -> bool
| def IsEdgeMapSeam | ( | self, | |
| args | |||
| ) |
IsEdgeMapSeam(MNMesh self, int mapChannel, int edge) -> bool
| def LiftFaceClusterFromEdge | ( | self, | |
| args | |||
| ) |
LiftFaceClusterFromEdge(MNMesh self, int liftEdge, float liftAngle, int segments, MNFaceClusters & fclust, int clusterID) -> bool
| def M | ( | self, | |
| args | |||
| ) |
M(MNMesh self, int mapChannel) -> MNMap
| def MakeConvex | ( | self | ) |
MakeConvex(MNMesh self)
| def MakeConvexPolyMesh | ( | self, | |
maxdeg = 0 |
|||
| ) |
MakeConvexPolyMesh(MNMesh self, int maxdeg=0) MakeConvexPolyMesh(MNMesh self)
| def MakeFaceConvex | ( | self, | |
| args | |||
| ) |
MakeFaceConvex(MNMesh self, int ff)
| def MakeFacePlanar | ( | self, | |
| args | |||
| ) |
MakeFacePlanar(MNMesh self, int ff, float planarThresh)
| def MakePlanar | ( | self, | |
| args | |||
| ) |
MakePlanar(MNMesh self, float planarThresh)
| def MakePolyMesh | ( | self, | |
| args | |||
| ) |
MakePolyMesh(MNMesh self, int maxdeg=0, BOOL elimCollin=TRUE) MakePolyMesh(MNMesh self, int maxdeg=0) MakePolyMesh(MNMesh self)
| def MF | ( | self, | |
| args | |||
| ) |
MF(MNMesh self, int mapChannel, int i) -> MNMapFace
| def MNDebugPrint | ( | self, | |
triprint = True |
|||
| ) |
MNDebugPrint(MNMesh self, bool triprint=True) MNDebugPrint(MNMesh self)
| def MNDebugPrintVertexNeighborhood | ( | self, | |
| args | |||
| ) |
MNDebugPrintVertexNeighborhood(MNMesh self, int vv, bool triprint=True) MNDebugPrintVertexNeighborhood(MNMesh self, int vv)
| def MNum | ( | self | ) |
MNum(MNMesh self) -> int
| def MNVDebugPrint | ( | self, | |
| args | |||
| ) |
MNVDebugPrint(MNMesh self, int vv)
| def MultiDivideEdge | ( | self, | |
| args | |||
| ) |
MultiDivideEdge(MNMesh self, int edge, int segments)
| def MV | ( | self, | |
| args | |||
| ) |
MV(MNMesh self, int mapChannel, int i) -> Point3
| def NewAndCopyChannels | ( | self, | |
| args | |||
| ) |
NewAndCopyChannels(MNMesh self, ChannelMask channels)
| def NewEdge | ( | self, | |
| args | |||
| ) |
NewEdge(MNMesh self, int v1, int v2, int f, int fpos) -> int
| def NewFace | ( | self, | |
| args | |||
| ) |
NewFace(MNMesh self, int initFace, int degg=0, int * vv=None, bool * vis=None, bool * sel=None) -> int NewFace(MNMesh self, int initFace, int degg=0, int * vv=None, bool * vis=None) -> int NewFace(MNMesh self, int initFace, int degg=0, int * vv=None) -> int NewFace(MNMesh self, int initFace, int degg=0) -> int NewFace(MNMesh self, int initFace) -> int
| def NewQuad | ( | self, | |
| args | |||
| ) |
NewQuad(MNMesh self, int a, int b, int c, int d, DWORD smG=0, MtlID mt=0) -> int NewQuad(MNMesh self, int a, int b, int c, int d, DWORD smG=0) -> int NewQuad(MNMesh self, int a, int b, int c, int d) -> int NewQuad(MNMesh self, int * vv, DWORD smG=0, MtlID mt=0) -> int NewQuad(MNMesh self, int * vv, DWORD smG=0) -> int NewQuad(MNMesh self, int * vv) -> int
| def NewTri | ( | self, | |
| args | |||
| ) |
NewTri(MNMesh self, int a, int b, int c, DWORD smG=0, MtlID mt=0) -> int NewTri(MNMesh self, int a, int b, int c, DWORD smG=0) -> int NewTri(MNMesh self, int a, int b, int c) -> int NewTri(MNMesh self, int * vv, DWORD smG=0, MtlID mt=0) -> int NewTri(MNMesh self, int * vv, DWORD smG=0) -> int NewTri(MNMesh self, int * vv) -> int
| def NewVert | ( | self, | |
| args | |||
| ) |
NewVert(MNMesh self, Point3 p) -> int NewVert(MNMesh self, Point3 p, int vid) -> int NewVert(MNMesh self, int vid) -> int NewVert(MNMesh self, int v1, int v2, float prop) -> int
| def OptimizeSmoothingGroups | ( | self, | |
| args | |||
| ) |
OptimizeSmoothingGroups(MNMesh self, BitArray optimizeFaces) -> bool
| def OrderVert | ( | self, | |
| args | |||
| ) |
OrderVert(MNMesh self, int vid)
| def OrderVerts | ( | self | ) |
OrderVerts(MNMesh self)
| def OutToTri | ( | self, | |
| args | |||
| ) |
OutToTri(MNMesh self, Mesh tmesh)
| def P | ( | self, | |
| args | |||
| ) |
P(MNMesh self, int i) -> Point3
| def PaintFaceFlag | ( | self, | |
| args | |||
| ) |
PaintFaceFlag(MNMesh self, int ff, DWORD fl, DWORD fenceflags=0x0) PaintFaceFlag(MNMesh self, int ff, DWORD fl)
| def PaintNewSmGroup | ( | self, | |
| args | |||
| ) |
PaintNewSmGroup(MNMesh self, int ff, DWORD os, DWORD ns)
| def PrepForPipeline | ( | self | ) |
PrepForPipeline(MNMesh self)
| def PropegateComponentFlags | ( | self, | |
| args | |||
| ) |
PropegateComponentFlags(MNMesh self, int slTo, DWORD flTo, int slFrom, DWORD flFrom, bool ampersand=True, bool set=TRUE) -> int PropegateComponentFlags(MNMesh self, int slTo, DWORD flTo, int slFrom, DWORD flFrom, bool ampersand=True) -> int PropegateComponentFlags(MNMesh self, int slTo, DWORD flTo, int slFrom, DWORD flFrom) -> int
| def RegisterEdge | ( | self, | |
| args | |||
| ) |
RegisterEdge(MNMesh self, int v1, int v2, int f, int fpos) -> int
| def Relax | ( | self, | |
| args | |||
| ) |
Relax(MNMesh self, float relaxval, bool targonly=TRUE) Relax(MNMesh self, float relaxval)
| def RemoveEdge | ( | self, | |
| args | |||
| ) |
RemoveEdge(MNMesh self, int edge)
| def RemoveSpur | ( | self, | |
| args | |||
| ) |
RemoveSpur(MNMesh self, int spur) -> bool
| def RemoveVertex | ( | self, | |
| args | |||
| ) |
RemoveVertex(MNMesh self, int vertex) -> bool
| def Resmooth | ( | self, | |
| args | |||
| ) |
Resmooth(MNMesh self, bool smooth=TRUE, bool targonly=True, DWORD targmask=~0x0) Resmooth(MNMesh self, bool smooth=TRUE, bool targonly=True) Resmooth(MNMesh self, bool smooth=TRUE) Resmooth(MNMesh self)
| def RestrictPolySize | ( | self, | |
| args | |||
| ) |
RestrictPolySize(MNMesh self, int maxdeg)
| def RetriangulateFace | ( | self, | |
| args | |||
| ) |
RetriangulateFace(MNMesh self, int ff)
| def SelectEdgeLoop | ( | self, | |
| args | |||
| ) |
SelectEdgeLoop(MNMesh self, BitArray edgeSel)
| def SelectEdgeRing | ( | self, | |
| args | |||
| ) |
SelectEdgeRing(MNMesh self, BitArray edgeSel)
| def SeparateFace | ( | self, | |
| args | |||
| ) |
SeparateFace(MNMesh self, int ff, int a, int b, int & nf, int & ne, bool neVis=True, bool neSel=True) SeparateFace(MNMesh self, int ff, int a, int b, int & nf, int & ne, bool neVis=True) SeparateFace(MNMesh self, int ff, int a, int b, int & nf, int & ne)
| def SeparateSmGroups | ( | self, | |
| args | |||
| ) |
SeparateSmGroups(MNMesh self, int v1, int v2) -> bool
| def SetDiagonal | ( | self, | |
| args | |||
| ) |
SetDiagonal(MNMesh self, int ff, int d1, int d2) -> bool
| def SetDispFlag | ( | self, | |
| args | |||
| ) |
SetDispFlag(MNMesh self, DWORD f)
| def SetDisplayVertexColors | ( | self, | |
| args | |||
| ) |
SetDisplayVertexColors(MNMesh self, int chan)
| def setEDataSupport | ( | self, | |
| args | |||
| ) |
setEDataSupport(MNMesh self, int edChannel, BOOL support=TRUE) setEDataSupport(MNMesh self, int edChannel)
| def SetEdgeSel | ( | self, | |
| args | |||
| ) |
SetEdgeSel(MNMesh self, int ee, BOOL sel=TRUE) SetEdgeSel(MNMesh self, int ee)
| def SetEdgeVis | ( | self, | |
| args | |||
| ) |
SetEdgeVis(MNMesh self, int ee, BOOL vis=TRUE) SetEdgeVis(MNMesh self, int ee)
| def SetFaceColor | ( | self, | |
| args | |||
| ) |
SetFaceColor(MNMesh self, Point3 clr, int mapChannel, DWORD flag=MN_SEL) -> bool SetFaceColor(MNMesh self, Point3 clr, int mapChannel) -> bool
| def SetFromTri | ( | self, | |
| args | |||
| ) |
SetFromTri(MNMesh self, Mesh f)
| def SetMapNum | ( | self, | |
| args | |||
| ) |
SetMapNum(MNMesh self, int mpnum)
| def SetMapSeamFlags | ( | self, | |
| args | |||
| ) |
SetMapSeamFlags(MNMesh self) SetMapSeamFlags(MNMesh self, int mapChannel)
| def setNumEData | ( | self, | |
| args | |||
| ) |
setNumEData(MNMesh self, int ct, BOOL keep=True) setNumEData(MNMesh self, int ct)
| def SetNumEdges | ( | self, | |
| args | |||
| ) |
SetNumEdges(MNMesh self, int nenum)
| def SetNumFaces | ( | self, | |
| args | |||
| ) |
SetNumFaces(MNMesh self, int nfnum)
| def setNumVData | ( | self, | |
| args | |||
| ) |
setNumVData(MNMesh self, int ct, BOOL keep=True) setNumVData(MNMesh self, int ct)
| def SetNumVerts | ( | self, | |
| args | |||
| ) |
SetNumVerts(MNMesh self, int nvnum)
| def setVDataSupport | ( | self, | |
| args | |||
| ) |
setVDataSupport(MNMesh self, int vdChannel, BOOL support=TRUE) setVDataSupport(MNMesh self, int vdChannel)
| def SetVertColor | ( | self, | |
| args | |||
| ) |
SetVertColor(MNMesh self, Point3 clr, int mapChannel, DWORD flag=MN_SEL) -> bool SetVertColor(MNMesh self, Point3 clr, int mapChannel) -> bool
| def ShallowCopy | ( | self, | |
| args | |||
| ) |
ShallowCopy(MNMesh self, MNMesh amesh, ChannelMask channels)
| def SimpleNewEdge | ( | self, | |
| args | |||
| ) |
SimpleNewEdge(MNMesh self, int v1, int v2) -> int
| def Slice | ( | self, | |
| args | |||
| ) |
Slice(MNMesh self, Point3 N, float off, float thresh, bool split, bool remove, bool flaggedFacesOnly=False,
DWORD faceFlags=MN_SEL) -> bool
Slice(MNMesh self, Point3 N, float off, float thresh, bool split, bool remove, bool flaggedFacesOnly=False) -> bool
Slice(MNMesh self, Point3 N, float off, float thresh, bool split, bool remove) -> bool
| def SmoothByCreases | ( | self, | |
| args | |||
| ) |
SmoothByCreases(MNMesh self, DWORD creaseFlag)
| def SplitEdge | ( | self, | |
| args | |||
| ) |
SplitEdge(MNMesh self, int ee, float prop=.5) -> int
SplitEdge(MNMesh self, int ee) -> int
SplitEdge(MNMesh self, int ee, float prop, Tab< int > * newTVerts) -> int
SplitEdge(MNMesh self, int ff, int ed, float prop, bool right, int * nf=None, int * ne=None, bool neVis=True,
bool neSel=True, bool allconvex=True) -> int
SplitEdge(MNMesh self, int ff, int ed, float prop, bool right, int * nf=None, int * ne=None, bool neVis=True,
bool neSel=True) -> int
SplitEdge(MNMesh self, int ff, int ed, float prop, bool right, int * nf=None, int * ne=None, bool neVis=True) -> int
SplitEdge(MNMesh self, int ff, int ed, float prop, bool right, int * nf=None, int * ne=None) -> int
SplitEdge(MNMesh self, int ff, int ed, float prop, bool right, int * nf=None) -> int
SplitEdge(MNMesh self, int ff, int ed, float prop, bool right) -> int
| def SplitFacesUsingBothSidesOfEdge | ( | self, | |
edgeFlag = 0x0 |
|||
| ) |
SplitFacesUsingBothSidesOfEdge(MNMesh self, DWORD edgeFlag=0x0) -> bool SplitFacesUsingBothSidesOfEdge(MNMesh self) -> bool
| def SplitFlaggedEdges | ( | self, | |
| args | |||
| ) |
SplitFlaggedEdges(MNMesh self, DWORD flag=MN_SEL) -> bool SplitFlaggedEdges(MNMesh self) -> bool
| def SplitFlaggedVertices | ( | self, | |
| args | |||
| ) |
SplitFlaggedVertices(MNMesh self, DWORD flag=MN_SEL) -> bool SplitFlaggedVertices(MNMesh self) -> bool
| def SplitTri6 | ( | self, | |
| args | |||
| ) |
SplitTri6(MNMesh self, int ff, double * bary=None, int * nv=None) SplitTri6(MNMesh self, int ff, double * bary=None) SplitTri6(MNMesh self, int ff)
| def SplitTriEdge | ( | self, | |
| args | |||
| ) |
SplitTriEdge(MNMesh self, int ee, float prop=.5, float thresh=MNEPS, bool neVis=TRUE, bool neSel=True) -> int SplitTriEdge(MNMesh self, int ee, float prop=.5, float thresh=MNEPS, bool neVis=TRUE) -> int SplitTriEdge(MNMesh self, int ee, float prop=.5, float thresh=MNEPS) -> int SplitTriEdge(MNMesh self, int ee, float prop=.5) -> int SplitTriEdge(MNMesh self, int ee) -> int
| def SplitTriFace | ( | self, | |
| args | |||
| ) |
SplitTriFace(MNMesh self, int ff, double * bary=None, float thresh=MNEPS, bool neVis=TRUE, bool neSel=True) -> int SplitTriFace(MNMesh self, int ff, double * bary=None, float thresh=MNEPS, bool neVis=TRUE) -> int SplitTriFace(MNMesh self, int ff, double * bary=None, float thresh=MNEPS) -> int SplitTriFace(MNMesh self, int ff, double * bary=None) -> int SplitTriFace(MNMesh self, int ff) -> int
| def SupportEdgeKnots | ( | self | ) |
SupportEdgeKnots(MNMesh self)
| def SupportVertexWeights | ( | self | ) |
SupportVertexWeights(MNMesh self)
| def SupportVSelectionWeights | ( | self | ) |
SupportVSelectionWeights(MNMesh self)
| def TargetEdgesBySelection | ( | self, | |
| args | |||
| ) |
TargetEdgesBySelection(MNMesh self, int selLevel) -> int
| def TargetFacesBySelection | ( | self, | |
| args | |||
| ) |
TargetFacesBySelection(MNMesh self, int selLevel) -> int
| def TargetVertsBySelection | ( | self, | |
| args | |||
| ) |
TargetVertsBySelection(MNMesh self, int selLevel) -> int
| def Transform | ( | self, | |
| args | |||
| ) |
Transform(MNMesh self, Matrix3 xfm)
| def Triangulate | ( | self | ) |
Triangulate(MNMesh self)
| def TriangulateFace | ( | self, | |
| args | |||
| ) |
TriangulateFace(MNMesh self, int ff)
| def TriNum | ( | self | ) |
TriNum(MNMesh self) -> int
| def UpdateDisplayVertexColors | ( | self | ) |
UpdateDisplayVertexColors(MNMesh self)
| def updateRVerts | ( | self, | |
| args | |||
| ) |
updateRVerts(MNMesh self, GraphicsWindow gw)
| def V | ( | self, | |
| args | |||
| ) |
V(MNMesh self, int i) -> MNVert
| def VClear | ( | self, | |
| args | |||
| ) |
VClear(MNMesh self, int vv)
| def vDataSupport | ( | self, | |
| args | |||
| ) |
vDataSupport(MNMesh self, int vdChannel) -> BOOL
| def VDeleteEdge | ( | self, | |
| args | |||
| ) |
VDeleteEdge(MNMesh self, int vv, int ee)
| def VDeleteFace | ( | self, | |
| args | |||
| ) |
VDeleteFace(MNMesh self, int vv, int ff)
| def VDNum | ( | self | ) |
VDNum(MNMesh self) -> int
| def VEdgeIndex | ( | self, | |
| args | |||
| ) |
VEdgeIndex(MNMesh self, int vv, int ee) -> int
| def vertexData | ( | self, | |
| args | |||
| ) |
vertexData(MNMesh self, int vdChannel) -> void *
| def VertexFindAdjacentFaces | ( | self, | |
| args | |||
| ) |
VertexFindAdjacentFaces(MNMesh self, int vertexIndex, BitArray adjacentFaces, IntList adjacentFaceIndexes)
| def vertexFloat | ( | self, | |
| args | |||
| ) |
vertexFloat(MNMesh self, int vdChannel) -> float *
| def VertexSelect | ( | self, | |
| args | |||
| ) |
VertexSelect(MNMesh self, BitArray vsel)
| def VertexTempSel | ( | self, | |
| args | |||
| ) |
VertexTempSel(MNMesh self, DWORD fmask=MN_DEAD|MN_SEL, DWORD fset=MN_SEL) -> BitArray VertexTempSel(MNMesh self, DWORD fmask=MN_DEAD|MN_SEL) -> BitArray VertexTempSel(MNMesh self) -> BitArray
| def VFaceIndex | ( | self, | |
| args | |||
| ) |
VFaceIndex(MNMesh self, int vv, int ff, int ee=-1) -> int VFaceIndex(MNMesh self, int vv, int ff) -> int
| def VInit | ( | self, | |
| args | |||
| ) |
VInit(MNMesh self, int vv)
| def VNum | ( | self | ) |
VNum(MNMesh self) -> int
| def VReplaceEdge | ( | self, | |
| args | |||
| ) |
VReplaceEdge(MNMesh self, int vv, int oe, int ne)
| def VReplaceFace | ( | self, | |
| args | |||
| ) |
VReplaceFace(MNMesh self, int vv, int of, int nf)
| def WeldBorderEdges | ( | self, | |
| args | |||
| ) |
WeldBorderEdges(MNMesh self, int e1, int e2) -> bool
| def WeldBorderVerts | ( | self, | |
| args | |||
| ) |
WeldBorderVerts(MNMesh self, int v1, int v2, Point3 destination) -> bool WeldBorderVerts(MNMesh self, float thresh, DWORD flag=MN_SEL) -> bool WeldBorderVerts(MNMesh self, float thresh) -> bool
| def WeldEdge | ( | self, | |
| args | |||
| ) |
WeldEdge(MNMesh self, int ee) -> bool
| def WeldOpposingEdges | ( | self, | |
| args | |||
| ) |
WeldOpposingEdges(MNMesh self, DWORD edgeFlag) -> bool
| def WeldVerts | ( | self, | |
| args | |||
| ) |
WeldVerts(MNMesh self, int a, int b) -> bool