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