Mesh Class Reference
Class Description
A triangular mesh.
Inheritance diagram for Mesh:
Public Member Functions | |
| def | AffectRegionFunction (args) |
| def | AngleBetweenFaces (self, args) |
| def | ApplyUVWMap (self, args) |
| def | AutoSmooth (self, args) |
| def | AverageSelVertCenter (self) |
| def | AverageSelVertNormal (self) |
| def | BaryCoords (self, args) |
| def | BreakVerts (self, args) |
| def | BuildBoundingBox (self) |
| def | BuildNormals (self) |
| def | BuildVisEdgeList (self) |
| def | CheckNormals (self, args) |
| def | ClearDispFlag (self, args) |
| def | ClearFlag (self, args) |
| def | ClearSpecifiedNormals (self) |
| def | ClearVChannel (self, args) |
| def | ClearVertexWeights (self) |
| def | ClearVSelectionWeights (self) |
| def | CloneFaces (self, args) |
| def | CombineMeshes (args) |
| def | CopyBasics (self, args) |
| def | DeepCopy (self, args) |
| def | DeleteFaceSet (self, args) |
| def | DeleteFlaggedFaces (self) |
| def | DeleteIsoVerts (self) |
| def | DeleteSelected (self) |
| def | DeleteVertSet (self, args) |
| def | DeselectHiddenEdges (self) |
| def | DeselectHiddenFaces (self) |
| def | DisplayAllEdges (self, args) |
| def | DisplayNormals (self, args) |
| def | DivideEdge (self, args) |
| def | DivideFace (self, args) |
| def | DoesFaceExist (self, args) |
| def | EdgeTessellate (self, args) |
| def | ElementFromFace (self, args) |
| def | EnableEdgeList (self, args) |
| def | ExtrudeFaces (self, args) |
| def | FaceCenter (self, args) |
| def | FaceCenterTessellate |
| def | FaceNormal (self, args) |
| def | FaceSel (self) |
| def | FindOpenEdges (self, args) |
| def | FindVertsUsedOnlyByFaces (self, args) |
| def | FitMaterialToMeshIDs (self, args) |
| def | FitMeshIDsToMaterial (self, args) |
| def | FlipNormal (self, args) |
| def | FreeAll (self) |
| def | FreeChannels (self, args) |
| def | FreeVChannel (self, args) |
| def | FreeVertexWeights (self) |
| def | FreeVSelectionWeights (self) |
| def | GetAlphaMap (self) |
| def | GetBoundingBox (self, args) |
| def | GetColorPerVertexMap (self) |
| def | GetCustomMap (self, args) |
| def | GetDefaultMap (self) |
| def | GetDispFlag (self, args) |
| def | GetDispFlags (self) |
| def | GetDisplayBackFaceVertices () |
| def | GetEdgeSel (self) |
| def | GetFace (self, args) |
| def | GetFaceCenter (self, args) |
| def | GetFaceEdgeVis (self, args) |
| def | GetFaceMatID (self, args) |
| def | GetFaceNormal (self, args) |
| def | GetFaceNormalFloat (self, args) |
| def | GetFaceSel (self) |
| def | GetFaceSmoothGroup (self, args) |
| def | GetFaceVertex (self, args) |
| def | GetFaceVertexIndex (self, args) |
| def | GetFaceVertices (self, args) |
| def | GetFlag (self, args) |
| def | GetHandleBoxType () |
| def | GetIsoMapVerts (self, args) |
| def | GetIsoVerts (self) |
| def | GetMapChannelID (args) |
| def | GetMapChannelNum (args) |
| def | GetMtlIndex (self) |
| def | GetNormalCount (self) |
| def | GetNormalsBuilt (self) |
| def | GetNumCustomMaps (self) |
| def | GetNumFaces (self) |
| def | GetNumTVerts (self) |
| def | GetNumVertices (self) |
| def | GetRenderedVertexNormal (self, args) |
| def | GetSelLevel (self) |
| def | GetShadingMap (self) |
| def | GetSmoothFlags (self) |
| def | GetTVert (self, args) |
| def | GetTVFace (self, args) |
| def | GetUseVertexDots () |
| def | GetUseVisEdge () |
| def | GetVChannel (self, args) |
| def | GetVertex (self, args) |
| def | GetVertexDotType () |
| def | GetVertexFlag (self, args) |
| def | GetVertexFloat (self, args) |
| def | GetVertexWeights (self, args) |
| def | GetVertHide (self) |
| def | GetVertSel (self) |
| def | GetVSelectionWeights (self, args) |
| def | HasVChannel (self, args) |
| def | HasVertexWeights (self) |
| def | HasVSelectionWeights (self) |
| def | HiddenFacesToVerts (self, args) |
| def | IndentSelFaces (self, args) |
| def | Init (self) |
| def | IntersectRay (self, args) |
| def | InvalidateEdgeList (self) |
| def | InvalidateGeomCache (self) |
| def | InvalidateTopologyCache (self) |
| def | InvalidateVertexCache (self, args) |
| def | IsFaceCacheInvalid (self, args) |
| def | MakeMapPlanar (self, args) |
| def | NewAndCopyChannels (self, args) |
| def | Optimize (self, args) |
| def | PolyFromFace (self, args) |
| def | ReduceDisplayCaches (self) |
| def | RemoveDegenerateFaces (self) |
| def | RemoveIllegalFaces (self) |
| def | SetDispFlag (self, args) |
| def | SetDisplayBackFaceVertices (args) |
| def | SetEdgeSel (self, args) |
| def | SetFaceEdgeVis (self, args) |
| def | SetFaceMatID (self, args) |
| def | SetFaceNormal (self, args) |
| def | SetFaceSel (self, args) |
| def | SetFaceSmoothGroup (self, args) |
| def | SetFaceVertexIndexes (self, args) |
| def | SetFlag (self, args) |
| def | SetHandleBoxType (args) |
| def | SetNormal (self, args) |
| def | SetNumFaces (self, args) |
| def | SetNumVerts (self, args) |
| def | SetSmoothFlags (self, args) |
| def | SetStaticMesh (self, args) |
| def | SetTVert (self, args) |
| def | SetUseVertexDots (args) |
| def | SetUseVisEdge (args) |
| def | SetVChannel (self, args) |
| def | SetVert (self, args) |
| def | SetVertexDotType (args) |
| def | SetVertexFlag (self, args) |
| def | SetVertexWeights (self, args) |
| def | SetVertSel (self, args) |
| def | SetVSelectionWeights (self, args) |
| def | ShallowCopy (self, args) |
| def | SliceMesh (args) |
| def | SubObjectHitTest (self, args) |
| def | SupportVChannel (self, args) |
| def | SupportVertexWeights (self) |
| def | SupportVSelectionWeights (self) |
| def | TurnEdge (self, args) |
| def | UnifyNormals (self, args) |
| def | VertexDataType (args) |
| def | VertexTempSel (self) |
| def | VertSel (self) |
| def | WeldCollinear (self, args) |
| def | ZeroTopologyCache (self) |
| 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 | AffectRegionFunction = staticmethod(AffectRegionFunction) |
| tuple | AlphaMap = _swig_property(GetDefaultMap) |
| tuple | ColorPerVertexMap = _swig_property(GetColorPerVertexMap) |
| tuple | CombineMeshes = staticmethod(CombineMeshes) |
| tuple | CustomMaps = _swig_property(lambda self: (self.GetCustomMap(i) for i in xrange(self.GetNumCustomMaps()))) |
| tuple | DefaultMap = _swig_property(GetDefaultMap) |
| tuple | FaceCenters = _swig_property(lambda self: (self.GetFaceCenter(i) for i in xrange(self.GetNumFaces()))) |
| tuple | FaceNormals = _swig_property(lambda self: (self.GetFaceNormal(i) for i in xrange(self.GetNumFaces()))) |
| tuple | Faces = _swig_property(lambda self: (self.GetFace(i) for i in xrange(self.GetNumFaces()))) |
| tuple | FaceVertices = _swig_property(lambda self: (self.GetFaceVertices(i) for i in xrange(self.GetNumFaces()))) |
| tuple | GetDisplayBackFaceVertices = staticmethod(GetDisplayBackFaceVertices) |
| tuple | GetHandleBoxType = staticmethod(GetHandleBoxType) |
| tuple | GetMapChannelID = staticmethod(GetMapChannelID) |
| tuple | GetMapChannelNum = staticmethod(GetMapChannelNum) |
| tuple | GetUseVertexDots = staticmethod(GetUseVertexDots) |
| tuple | GetUseVisEdge = staticmethod(GetUseVisEdge) |
| tuple | GetVertexDotType = staticmethod(GetVertexDotType) |
| tuple | NumCustomMaps = _swig_property(GetNumCustomMaps) |
| tuple | NumFaces = _swig_property(GetNumFaces) |
| tuple | NumVertices = _swig_property(GetNumVertices) |
| tuple | SetDisplayBackFaceVertices = staticmethod(SetDisplayBackFaceVertices) |
| tuple | SetHandleBoxType = staticmethod(SetHandleBoxType) |
| tuple | SetUseVertexDots = staticmethod(SetUseVertexDots) |
| tuple | SetUseVisEdge = staticmethod(SetUseVisEdge) |
| tuple | SetVertexDotType = staticmethod(SetVertexDotType) |
| tuple | ShadingMap = _swig_property(GetShadingMap) |
| tuple | SliceMesh = staticmethod(SliceMesh) |
| tuple | SmoothFlags = _swig_property(GetSmoothFlags, SetSmoothFlags) |
| tuple | thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') |
| tuple | VertexDataType = staticmethod(VertexDataType) |
| tuple | Vertices = _swig_property(lambda self: (self.GetVertex(i) for i in xrange(self.GetNumVertices()))) |
| 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 AffectRegionFunction | ( | args | ) |
AffectRegionFunction(float dist, float falloff, float pinch, float bubble) -> float
| def AngleBetweenFaces | ( | self, | |
| args | |||
| ) |
AngleBetweenFaces(Mesh self, DWORD f0, DWORD f1) -> float
| def ApplyUVWMap | ( | self, | |
| args | |||
| ) |
ApplyUVWMap(Mesh self, int type, float utile, float vtile, float wtile, int uflip, int vflip, int wflip,
int cap, Matrix3 tm, int channel=1)
ApplyUVWMap(Mesh self, int type, float utile, float vtile, float wtile, int uflip, int vflip, int wflip,
int cap, Matrix3 tm)
| def AutoSmooth | ( | self, | |
| args | |||
| ) |
AutoSmooth(Mesh self, float angle, bool useSel, bool preventIndirectSmoothing=True) AutoSmooth(Mesh self, float angle, bool useSel)
| def AverageSelVertCenter | ( | self | ) |
AverageSelVertCenter(Mesh self) -> Point3
| def AverageSelVertNormal | ( | self | ) |
AverageSelVertNormal(Mesh self) -> Point3
| def BaryCoords | ( | self, | |
| args | |||
| ) |
BaryCoords(Mesh self, DWORD face, Point3 p) -> Point3
| def BreakVerts | ( | self, | |
| args | |||
| ) |
BreakVerts(Mesh self, BitArray set)
| def BuildBoundingBox | ( | self | ) |
BuildBoundingBox(Mesh self)
| def BuildNormals | ( | self | ) |
BuildNormals(Mesh self)
| def BuildVisEdgeList | ( | self | ) |
BuildVisEdgeList(Mesh self)
| def CheckNormals | ( | self, | |
| args | |||
| ) |
CheckNormals(Mesh self, bool illum)
| def ClearDispFlag | ( | self, | |
| args | |||
| ) |
ClearDispFlag(Mesh self, DWORD f)
| def ClearFlag | ( | self, | |
| args | |||
| ) |
ClearFlag(Mesh self, DWORD f)
| def ClearSpecifiedNormals | ( | self | ) |
ClearSpecifiedNormals(Mesh self)
| def ClearVChannel | ( | self, | |
| args | |||
| ) |
ClearVChannel(Mesh self, int chan)
| def ClearVertexWeights | ( | self | ) |
ClearVertexWeights(Mesh self)
| def ClearVSelectionWeights | ( | self | ) |
ClearVSelectionWeights(Mesh self)
| def CloneFaces | ( | self, | |
| args | |||
| ) |
CloneFaces(Mesh self, BitArray fset)
| def CombineMeshes | ( | args | ) |
CombineMeshes(Mesh mesh, Mesh mesh1, Mesh mesh2, Matrix3 tm1, Matrix3 tm2, int whichInv=0) CombineMeshes(Mesh mesh, Mesh mesh1, Mesh mesh2, Matrix3 tm1, Matrix3 tm2) CombineMeshes(Mesh mesh, Mesh mesh1, Mesh mesh2, int whichInv=0) CombineMeshes(Mesh mesh, Mesh mesh1, Mesh mesh2)
| def CopyBasics | ( | self, | |
| args | |||
| ) |
CopyBasics(Mesh self, Mesh other)
| def DeepCopy | ( | self, | |
| args | |||
| ) |
DeepCopy(Mesh self, Mesh amesh, ChannelMask channels)
| def DeleteFaceSet | ( | self, | |
| args | |||
| ) |
DeleteFaceSet(Mesh self, BitArray set, BitArray isoVert=0) DeleteFaceSet(Mesh self, BitArray set)
| def DeleteFlaggedFaces | ( | self | ) |
DeleteFlaggedFaces(Mesh self) -> int
| def DeleteIsoVerts | ( | self | ) |
DeleteIsoVerts(Mesh self)
| def DeleteSelected | ( | self | ) |
DeleteSelected(Mesh self)
| def DeleteVertSet | ( | self, | |
| args | |||
| ) |
DeleteVertSet(Mesh self, BitArray set)
| def DeselectHiddenEdges | ( | self | ) |
DeselectHiddenEdges(Mesh self)
| def DeselectHiddenFaces | ( | self | ) |
DeselectHiddenFaces(Mesh self)
| def DisplayAllEdges | ( | self, | |
| args | |||
| ) |
DisplayAllEdges(Mesh self, int b)
| def DisplayNormals | ( | self, | |
| args | |||
| ) |
DisplayNormals(Mesh self, int b, float sc)
| def DivideEdge | ( | self, | |
| args | |||
| ) |
DivideEdge(Mesh self, DWORD edge, float prop=.5, bool visDiag1=TRUE, bool fixNeighbors=TRUE, bool visDiag2=TRUE) DivideEdge(Mesh self, DWORD edge, float prop=.5, bool visDiag1=TRUE, bool fixNeighbors=TRUE) DivideEdge(Mesh self, DWORD edge, float prop=.5, bool visDiag1=TRUE) DivideEdge(Mesh self, DWORD edge, float prop=.5) DivideEdge(Mesh self, DWORD edge)
| def DivideFace | ( | self, | |
| args | |||
| ) |
DivideFace(Mesh self, DWORD face, DWORD e1, DWORD e2, float prop1=.5, float prop2=.5, bool fixNeighbors=TRUE,
bool split=True)
DivideFace(Mesh self, DWORD face, DWORD e1, DWORD e2, float prop1=.5, float prop2=.5, bool fixNeighbors=TRUE)
DivideFace(Mesh self, DWORD face, DWORD e1, DWORD e2, float prop1=.5, float prop2=.5)
DivideFace(Mesh self, DWORD face, DWORD e1, DWORD e2, float prop1=.5)
DivideFace(Mesh self, DWORD face, DWORD e1, DWORD e2)
| def DoesFaceExist | ( | self, | |
| args | |||
| ) |
DoesFaceExist(Mesh self, DWORD v0, DWORD v1, DWORD v2) -> bool
| def EdgeTessellate | ( | self, | |
| args | |||
| ) |
EdgeTessellate(Mesh self, float tens, bool ignoreSel=True) EdgeTessellate(Mesh self, float tens)
| def ElementFromFace | ( | self, | |
| args | |||
| ) |
ElementFromFace(Mesh self, DWORD f, BitArray set)
| def EnableEdgeList | ( | self, | |
| args | |||
| ) |
EnableEdgeList(Mesh self, int e)
| def ExtrudeFaces | ( | self, | |
| args | |||
| ) |
ExtrudeFaces(Mesh self, bool doFace=TRUE) ExtrudeFaces(Mesh self)
| def FaceCenter | ( | self, | |
| args | |||
| ) |
FaceCenter(Mesh self, DWORD fi) -> Point3
| def FaceCenterTessellate | ( | self, | |
ignoreSel = True |
|||
| ) |
FaceCenterTessellate(Mesh self, bool ignoreSel=True) FaceCenterTessellate(Mesh self)
| def FaceNormal | ( | self, | |
| args | |||
| ) |
FaceNormal(Mesh self, DWORD fi, bool nrmlize=True) -> Point3 FaceNormal(Mesh self, DWORD fi) -> Point3
| def FaceSel | ( | self | ) |
FaceSel(Mesh self) -> BitArray
| def FindOpenEdges | ( | self, | |
| args | |||
| ) |
FindOpenEdges(Mesh self, BitArray edges)
| def FindVertsUsedOnlyByFaces | ( | self, | |
| args | |||
| ) |
FindVertsUsedOnlyByFaces(Mesh self, BitArray fset, BitArray vset)
| def FitMaterialToMeshIDs | ( | self, | |
| args | |||
| ) |
FitMaterialToMeshIDs(Mesh self, Mtl mat) -> Mtl
| def FitMeshIDsToMaterial | ( | self, | |
| args | |||
| ) |
FitMeshIDsToMaterial(Mesh self, Mtl mat)
| def FlipNormal | ( | self, | |
| args | |||
| ) |
FlipNormal(Mesh self, int i)
| def FreeAll | ( | self | ) |
FreeAll(Mesh self)
| def FreeChannels | ( | self, | |
| args | |||
| ) |
FreeChannels(Mesh self, ChannelMask channels, int zeroOthers=1) FreeChannels(Mesh self, ChannelMask channels)
| def FreeVChannel | ( | self, | |
| args | |||
| ) |
FreeVChannel(Mesh self, int chan)
| def FreeVertexWeights | ( | self | ) |
FreeVertexWeights(Mesh self)
| def FreeVSelectionWeights | ( | self | ) |
FreeVSelectionWeights(Mesh self)
| def GetAlphaMap | ( | self | ) |
GetAlphaMap(Mesh self) -> MappingChannel
| def GetBoundingBox | ( | self, | |
| args | |||
| ) |
GetBoundingBox(Mesh self, Matrix3 tm) -> Box3 GetBoundingBox(Mesh self) -> Box3
| def GetColorPerVertexMap | ( | self | ) |
GetColorPerVertexMap(Mesh self) -> MappingChannel
| def GetCustomMap | ( | self, | |
| args | |||
| ) |
GetCustomMap(Mesh self, int channel) -> MappingChannel
| def GetDefaultMap | ( | self | ) |
GetDefaultMap(Mesh self) -> MappingChannel
| def GetDispFlag | ( | self, | |
| args | |||
| ) |
GetDispFlag(Mesh self, DWORD f) -> DWORD
| def GetDispFlags | ( | self | ) |
GetDispFlags(Mesh self) -> DWORD
| def GetDisplayBackFaceVertices | ( | ) |
GetDisplayBackFaceVertices() -> bool
| def GetEdgeSel | ( | self | ) |
GetEdgeSel(Mesh self) -> BitArray
| def GetFace | ( | self, | |
| args | |||
| ) |
GetFace(Mesh self, int i) -> Face
| def GetFaceCenter | ( | self, | |
| args | |||
| ) |
GetFaceCenter(Mesh self, int i) -> Point3
| def GetFaceEdgeVis | ( | self, | |
| args | |||
| ) |
GetFaceEdgeVis(Mesh self, int i, int edge) -> bool
| def GetFaceMatID | ( | self, | |
| args | |||
| ) |
GetFaceMatID(Mesh self, int i) -> int
| def GetFaceNormal | ( | self, | |
| args | |||
| ) |
GetFaceNormal(Mesh self, int i, bool normalize=False) -> Point3 GetFaceNormal(Mesh self, int i) -> Point3
| def GetFaceNormalFloat | ( | self, | |
| args | |||
| ) |
GetFaceNormalFloat(Mesh self, int i, int element) -> float
| def GetFaceSel | ( | self | ) |
GetFaceSel(Mesh self) -> BitArray
| def GetFaceSmoothGroup | ( | self, | |
| args | |||
| ) |
GetFaceSmoothGroup(Mesh self, int i) -> int
| def GetFaceVertex | ( | self, | |
| args | |||
| ) |
GetFaceVertex(Mesh self, int face, int i) -> Point3
| def GetFaceVertexIndex | ( | self, | |
| args | |||
| ) |
GetFaceVertexIndex(Mesh self, int face, int i) -> int
| def GetFaceVertices | ( | self, | |
| args | |||
| ) |
GetFaceVertices(Mesh self, int i) -> FacePoints
| def GetFlag | ( | self, | |
| args | |||
| ) |
GetFlag(Mesh self, DWORD f) -> DWORD
| def GetHandleBoxType | ( | ) |
GetHandleBoxType() -> int
| def GetIsoMapVerts | ( | self, | |
| args | |||
| ) |
GetIsoMapVerts(Mesh self, int mp) -> BitArray
| def GetIsoVerts | ( | self | ) |
GetIsoVerts(Mesh self) -> BitArray
| def GetMapChannelID | ( | args | ) |
GetMapChannelID(int mp) -> DWORD
| def GetMapChannelNum | ( | args | ) |
GetMapChannelNum(int mp) -> int
| def GetMtlIndex | ( | self | ) |
GetMtlIndex(Mesh self) -> MtlID
| def GetNormalCount | ( | self | ) |
GetNormalCount(Mesh self) -> int
| def GetNormalsBuilt | ( | self | ) |
GetNormalsBuilt(Mesh self) -> int
| def GetNumCustomMaps | ( | self | ) |
GetNumCustomMaps(Mesh self) -> int
| def GetNumFaces | ( | self | ) |
GetNumFaces(Mesh self) -> int
| def GetNumTVerts | ( | self | ) |
GetNumTVerts(Mesh self) -> int
| def GetNumVertices | ( | self | ) |
GetNumVertices(Mesh self) -> int
| def GetRenderedVertexNormal | ( | self, | |
| args | |||
| ) |
GetRenderedVertexNormal(Mesh self, int i) -> Point3
| def GetSelLevel | ( | self | ) |
GetSelLevel(Mesh self) -> DWORD
| def GetShadingMap | ( | self | ) |
GetShadingMap(Mesh self) -> MappingChannel
| def GetSmoothFlags | ( | self | ) |
GetSmoothFlags(Mesh self) -> int
| def GetTVert | ( | self, | |
| args | |||
| ) |
GetTVert(Mesh self, int i) -> Point3
| def GetTVFace | ( | self, | |
| args | |||
| ) |
GetTVFace(Mesh self, int i) -> TVFace
| def GetUseVertexDots | ( | ) |
GetUseVertexDots() -> bool
| def GetUseVisEdge | ( | ) |
GetUseVisEdge() -> bool
| def GetVChannel | ( | self, | |
| args | |||
| ) |
GetVChannel(Mesh self, int chan, int v) -> float
| def GetVertex | ( | self, | |
| args | |||
| ) |
GetVertex(Mesh self, int i) -> Point3
| def GetVertexDotType | ( | ) |
GetVertexDotType() -> int
| def GetVertexFlag | ( | self, | |
| args | |||
| ) |
GetVertexFlag(Mesh self, int v) -> long
| def GetVertexFloat | ( | self, | |
| args | |||
| ) |
GetVertexFloat(Mesh self, int i, int element) -> float
| def GetVertexWeights | ( | self, | |
| args | |||
| ) |
GetVertexWeights(Mesh self, int v) -> float
| def GetVertHide | ( | self | ) |
GetVertHide(Mesh self) -> BitArray
| def GetVertSel | ( | self | ) |
GetVertSel(Mesh self) -> BitArray
| def GetVSelectionWeights | ( | self, | |
| args | |||
| ) |
GetVSelectionWeights(Mesh self, int v) -> float
| def HasVChannel | ( | self, | |
| args | |||
| ) |
HasVChannel(Mesh self, int chan) -> bool
| def HasVertexWeights | ( | self | ) |
HasVertexWeights(Mesh self) -> bool
| def HasVSelectionWeights | ( | self | ) |
HasVSelectionWeights(Mesh self) -> bool
| def HiddenFacesToVerts | ( | self, | |
| args | |||
| ) |
HiddenFacesToVerts(Mesh self, BitArray alsoHide)
| def IndentSelFaces | ( | self, | |
| args | |||
| ) |
IndentSelFaces(Mesh self, float amount)
| def Init | ( | self | ) |
Init(Mesh self)
| def IntersectRay | ( | self, | |
| args | |||
| ) |
IntersectRay(Mesh self, Ray ray, float & at, Point3 norm) -> bool IntersectRay(Mesh self, Ray ray, float & at, Point3 norm, DWORD & fi, Point3 bary) -> bool
| def InvalidateEdgeList | ( | self | ) |
InvalidateEdgeList(Mesh self)
| def InvalidateGeomCache | ( | self | ) |
InvalidateGeomCache(Mesh self)
| def InvalidateTopologyCache | ( | self | ) |
InvalidateTopologyCache(Mesh self)
| def InvalidateVertexCache | ( | self, | |
| args | |||
| ) |
InvalidateVertexCache(Mesh self, int vertex)
| def IsFaceCacheInvalid | ( | self, | |
| args | |||
| ) |
IsFaceCacheInvalid(Mesh self, int faceIndex) -> bool
| def MakeMapPlanar | ( | self, | |
| args | |||
| ) |
MakeMapPlanar(Mesh self, int mp)
| def NewAndCopyChannels | ( | self, | |
| args | |||
| ) |
NewAndCopyChannels(Mesh self, ChannelMask channels)
| def Optimize | ( | self, | |
| args | |||
| ) |
Optimize(Mesh self, float normThresh, float edgeThresh, float bias, float maxEdge, DWORD flags)
| def PolyFromFace | ( | self, | |
| args | |||
| ) |
PolyFromFace(Mesh self, DWORD f, BitArray set, float thresh, bool ignoreVisEdges)
| def ReduceDisplayCaches | ( | self | ) |
ReduceDisplayCaches(Mesh self)
| def RemoveDegenerateFaces | ( | self | ) |
RemoveDegenerateFaces(Mesh self) -> bool
| def RemoveIllegalFaces | ( | self | ) |
RemoveIllegalFaces(Mesh self) -> bool
| def SetDispFlag | ( | self, | |
| args | |||
| ) |
SetDispFlag(Mesh self, DWORD f)
| def SetDisplayBackFaceVertices | ( | args | ) |
SetDisplayBackFaceVertices(bool b)
| def SetEdgeSel | ( | self, | |
| args | |||
| ) |
SetEdgeSel(Mesh self, BitArray sel)
| def SetFaceEdgeVis | ( | self, | |
| args | |||
| ) |
SetFaceEdgeVis(Mesh self, int i, bool a, bool b, bool c)
| def SetFaceMatID | ( | self, | |
| args | |||
| ) |
SetFaceMatID(Mesh self, int i, int id)
| def SetFaceNormal | ( | self, | |
| args | |||
| ) |
SetFaceNormal(Mesh self, int i, Point3 xyz)
| def SetFaceSel | ( | self, | |
| args | |||
| ) |
SetFaceSel(Mesh self, BitArray sel)
| def SetFaceSmoothGroup | ( | self, | |
| args | |||
| ) |
SetFaceSmoothGroup(Mesh self, int i, int sg)
| def SetFaceVertexIndexes | ( | self, | |
| args | |||
| ) |
SetFaceVertexIndexes(Mesh self, int face, int a, int b, int c)
| def SetFlag | ( | self, | |
| args | |||
| ) |
SetFlag(Mesh self, DWORD f)
| def SetHandleBoxType | ( | args | ) |
SetHandleBoxType(int t)
| def SetNormal | ( | self, | |
| args | |||
| ) |
SetNormal(Mesh self, int i, Point3 xyz)
| def SetNumFaces | ( | self, | |
| args | |||
| ) |
SetNumFaces(Mesh self, int n)
| def SetNumVerts | ( | self, | |
| args | |||
| ) |
SetNumVerts(Mesh self, int n)
| def SetSmoothFlags | ( | self, | |
| args | |||
| ) |
SetSmoothFlags(Mesh self, int f)
| def SetStaticMesh | ( | self, | |
| args | |||
| ) |
SetStaticMesh(Mesh self, bool staticMesh)
| def SetTVert | ( | self, | |
| args | |||
| ) |
SetTVert(Mesh self, int i, Point3 xyz) SetTVert(Mesh self, int i, float x, float y, float z)
| def SetUseVertexDots | ( | args | ) |
SetUseVertexDots(bool b)
| def SetUseVisEdge | ( | args | ) |
SetUseVisEdge(bool b)
| def SetVChannel | ( | self, | |
| args | |||
| ) |
SetVChannel(Mesh self, int chan, int v, float w)
| def SetVert | ( | self, | |
| args | |||
| ) |
SetVert(Mesh self, int i, Point3 xyz) SetVert(Mesh self, int i, float x, float y, float z)
| def SetVertexDotType | ( | args | ) |
SetVertexDotType(int t)
| def SetVertexFlag | ( | self, | |
| args | |||
| ) |
SetVertexFlag(Mesh self, int v, long val)
| def SetVertexWeights | ( | self, | |
| args | |||
| ) |
SetVertexWeights(Mesh self, int v, float w)
| def SetVertSel | ( | self, | |
| args | |||
| ) |
SetVertSel(Mesh self, BitArray sel)
| def SetVSelectionWeights | ( | self, | |
| args | |||
| ) |
SetVSelectionWeights(Mesh self, int v, float w)
| def ShallowCopy | ( | self, | |
| args | |||
| ) |
ShallowCopy(Mesh self, Mesh amesh, ChannelMask channels)
| def SliceMesh | ( | args | ) |
SliceMesh(Mesh mesh, Point3 N, float off, bool split=True, bool remove=True) SliceMesh(Mesh mesh, Point3 N, float off, bool split=True) SliceMesh(Mesh mesh, Point3 N, float off)
| def SubObjectHitTest | ( | self, | |
| args | |||
| ) |
SubObjectHitTest(Mesh self, HitRegion hr, DWORD flags, SubObjHitList hitList) -> bool
| def SupportVChannel | ( | self, | |
| args | |||
| ) |
SupportVChannel(Mesh self, int chan)
| def SupportVertexWeights | ( | self | ) |
SupportVertexWeights(Mesh self)
| def SupportVSelectionWeights | ( | self | ) |
SupportVSelectionWeights(Mesh self)
| def TurnEdge | ( | self, | |
| args | |||
| ) |
TurnEdge(Mesh self, DWORD edge, DWORD * otherEdge=None) TurnEdge(Mesh self, DWORD edge)
| def UnifyNormals | ( | self, | |
| args | |||
| ) |
UnifyNormals(Mesh self, bool selOnly)
| def VertexDataType | ( | args | ) |
VertexDataType(bool vdID) -> bool
| def VertexTempSel | ( | self | ) |
VertexTempSel(Mesh self) -> BitArray
| def VertSel | ( | self | ) |
VertSel(Mesh self) -> BitArray
| def WeldCollinear | ( | self, | |
| args | |||
| ) |
WeldCollinear(Mesh self, BitArray set)
| def ZeroTopologyCache | ( | self | ) |
ZeroTopologyCache(Mesh self)