Mesh Class Reference

Public Member Functions | Static Public Attributes
Mesh Class Reference
+ This reference page is linked to from the following overview topics:

Class Description

A triangular mesh.
+ Inheritance diagram for Mesh:

Public Member Functions

def AffectRegionFunction
 
def AngleBetweenFaces
 
def ApplyUVWMap
 
def AutoSmooth
 
def AverageSelVertCenter
 
def AverageSelVertNormal
 
def BaryCoords
 
def BreakVerts
 
def BuildBoundingBox
 
def BuildNormals
 
def BuildVisEdgeList
 
def CheckNormals
 
def ClearDispFlag
 
def ClearFlag
 
def ClearSpecifiedNormals
 
def ClearVertexWeights
 
def ClearVSelectionWeights
 
def CloneFaces
 
def CombineMeshes
 
def CopyBasics
 
def DeepCopy
 
def DeleteFaceSet
 
def DeleteFlaggedFaces
 
def DeleteIsoVerts
 
def DeleteSelected
 
def DeleteVertSet
 
def DeselectHiddenEdges
 
def DeselectHiddenFaces
 
def DisplayAllEdges
 
def DisplayNormals
 
def DivideEdge
 
def DivideFace
 
def DoesFaceExist
 
def EdgeTessellate
 
def ElementFromFace
 
def EnableEdgeList
 
def ExtrudeFaces
 
def FaceCenter
 
def FaceCenterTessellate
 
def FaceNormal
 
def FaceSel
 
def FindOpenEdges
 
def FindVertsUsedOnlyByFaces
 
def FitMaterialToMeshIDs
 
def FitMeshIDsToMaterial
 
def FlipNormal
 
def FreeAll
 
def FreeChannels
 
def FreeVertexWeights
 
def FreeVSelectionWeights
 
def GetAlphaMap
 
def GetBoundingBox
 
def GetColorPerVertexMap
 
def GetCustomMap
 
def GetDefaultMap
 
def GetDispFlag
 
def GetDispFlags
 
def GetDisplayBackFaceVertices
 
def GetEdgeSel
 
def GetFace
 
def GetFaceCenter
 
def GetFaceMtlIndex
 
def GetFaceNormal
 
def GetFaceSel
 
def GetFaceVertex
 
def GetFaceVertices
 
def GetFlag
 
def GetHandleBoxType
 
def GetIsoMapVerts
 
def GetIsoVerts
 
def GetMapChannelID
 
def GetMapChannelNum
 
def GetMtlIndex
 
def GetNormalCount
 
def GetNormalsBuilt
 
def GetNumCustomMaps
 
def GetNumFaces
 
def GetNumTVerts
 
def GetNumVertices
 
def GetRenderedVertexNormal
 
def GetSelLevel
 
def GetShadingMap
 
def GetSmoothFlags
 
def GetTVert
 
def GetTVFace
 
def GetUseVertexDots
 
def GetUseVisEdge
 
def GetVertex
 
def GetVertexDotType
 
def GetVertexFlag
 
def GetVertexWeights
 
def GetVertHide
 
def GetVertSel
 
def GetVSelectionWeights
 
def HiddenFacesToVerts
 
def IndentSelFaces
 
def Init
 
def IntersectRay
 
def InvalidateEdgeList
 
def InvalidateGeomCache
 
def InvalidateTopologyCache
 
def InvalidateVertexCache
 
def IsFaceCacheInvalid
 
def MakeMapPlanar
 
def NewAndCopyChannels
 
def Optimize
 
def PolyFromFace
 
def ReduceDisplayCaches
 
def RemoveDegenerateFaces
 
def RemoveIllegalFaces
 
def SetDispFlag
 
def SetDisplayBackFaceVertices
 
def SetFaceMtlIndex
 
def SetFaceNormal
 
def SetFlag
 
def SetHandleBoxType
 
def SetNormal
 
def SetNumFaces
 
def SetNumVerts
 
def SetSmoothFlags
 
def SetStaticMesh
 
def SetTVert
 
def SetUseVertexDots
 
def SetUseVisEdge
 
def SetVert
 
def SetVertexDotType
 
def SetVertexFlag
 
def ShallowCopy
 
def SliceMesh
 
def SupportVertexWeights
 
def SupportVSelectionWeights
 
def TurnEdge
 
def UnifyNormals
 
def VertexDataType
 
def VertexTempSel
 
def VertSel
 
def WeldCollinear
 
def ZeroTopologyCache
 
- Public Member Functions inherited from BaseInterfaceServer
def GetInterfaceAt
 
def GetNumInterfaces
 
- Public Member Functions inherited from InterfaceServer
def GetInterface
 
- Public Member Functions inherited from Wrapper
def GetUnwrappedPtr
 

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 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 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 GetFaceMtlIndex (   self,
  args 
) 
GetFaceMtlIndex(Mesh self, int i) -> MtlID
def GetFaceNormal (   self,
  args 
) 
GetFaceNormal(Mesh self, int i, bool normalize=False) -> Point3
GetFaceNormal(Mesh self, int i) -> Point3
def GetFaceSel (   self) 
GetFaceSel(Mesh self) -> BitArray
def GetFaceVertex (   self,
  args 
) 
GetFaceVertex(Mesh self, int face, int i) -> Point3
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 GetVertex (   self,
  args 
) 
GetVertex(Mesh self, int i) -> Point3
def GetVertexDotType ( ) 
GetVertexDotType() -> int
def GetVertexFlag (   self,
  args 
) 
GetVertexFlag(Mesh self, int v) -> long
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 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 SetFaceMtlIndex (   self,
  args 
) 
SetFaceMtlIndex(Mesh self, int i, MtlID id)
def SetFaceNormal (   self,
  args 
) 
SetFaceNormal(Mesh self, int i, Point3 xyz)
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 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 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 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)
Please send us your comment about this page