Trees       Indices       Help   
Module Mesh :: Class MFace
[hide private]
[frames] | no frames]

Class MFace

source code

The MFace object

This object holds mesh face data.

Example:

       import Blender
       from Blender import Mesh, Window

       in_emode = Window.EditMode()
       if in_emode: Window.EditMode(0)

       me = Mesh.Get("Mesh")
       faces = me.faces

       ## Example for editmode faces selection:
       selected_faces = []
       for f in faces:
               if f.sel:
                       selected_faces.append(f)
       # ... unselect selected and select all the others:
       for f in faces:
               f.sel = not f.sel # 1 becomes 0, 0 becomes 1

       ## Example for UV textured faces selection:
       selected_faces = []
       SEL = Mesh.FaceFlags['SELECT']
       # get selected faces:
       for f in faces:
               if f.flag & SEL:
                       selected_faces.append(f)
       # ... unselect selected and select all the others:
       for f in faces:
               if f.flag & SEL:
                       f.flag &= ~SEL # unselect these
               else:
                       f.flag |= SEL # and select these

       if in_emode: Window.EditMode(1)
       Blender.Redraw()
Notes:
Instance Methods [hide private]
MVert
__iter__()
Iterator for MVert.		 source code
int
__len__()
len for MVert.		 source code
Instance Variables [hide private]
float area
The area of the face.
vector cent
The center of the face.
tuple of MCols col
The face's vertex colors, if defined.
tuple edge_keys
A tuple, each item a key that can reference an edge by its ordered indices.
  flag
The face's texture mode flags; indicates the selection, active , and visibility states of a textured face (see FaceFlags for values).
int hide
The face's edit mode visibility state (hidden=1).
Image image
The Image used as a texture for this face.
int index
The face's index within the mesh.
int mat
The face's index into the mesh's materials list.
int mode
The texture mode bitfield (see FaceModes).
vector no
The face's normal vector (x, y, z).
int sel
The face's edit mode selection state (selected=1).
int smooth
If set, the vertex normals are averaged to make this face look smooth.
int transp
Transparency mode.
tuple of vectors (WRAPPED DATA) uv
The face's UV coordinates.
tuple of ints uvSel
The face's UV coordinates selection state; a 1 indicates the vertex is selected.
  v
Same as verts.
list of MVerts verts
The face's vertices.
Method Details [hide private]

__iter__()

source code 

Iterator for MVert. It iterates over the MVerts of the face, returning v1, v2, v3 (and optionally v4);

Returns: MVert
one of the face's vertices

__len__()
(Length operator)

source code 

len for MVert. It returns the number of vertices in the face.

Returns: int

Instance Variable Details [hide private]

area

The area of the face. Read-only.
Type:
float

cent

The center of the face. Read-only.
Type:
vector

col

The face's vertex colors, if defined. Each vertex has its own color. Will throw an exception if Mesh.vertexColors is False.

Example:

       # This example uses vertex normals to apply normal colors to each face.
       import bpy
       from Blender import Window
       scn= bpy.scenes.active  # Current scene, important to be scene aware
       ob= scn.objects.active  # last selected object
       me= ob.getData(mesh=1)  # thin wrapper doesn't copy mesh data like nmesh
       me.vertexColors= True   # Enable face, vertex colors
       for f in me.faces:
               for i, v in enumerate(f):
                       no= v.no
                       col= f.col[i]
                       col.r= int((no.x+1)*128)
                       col.g= int((no.y+1)*128)
                       col.b= int((no.z+1)*128)
       Window.RedrawAll()
Type:
tuple of MCols

edge_keys

A tuple, each item a key that can reference an edge by its ordered indices. Read-only. This is useful for building connectivity data. Example: 
               from Blender import Mesh
               me = Mesh.Get('Cube')
               # a dictionary where the edge is the key, and a list of faces that use it are the value
               edge_faces = dict([(ed.key, []) for ed in me.edges])

               # Add the faces to the dict
               for f in me.faces:
                       for key in f.edge_keys:
                               edge_faces[key].append(f) # add this face to the edge as a user

               # Print the edges and the number of face users
               for key, face_users in edge_faces.iteritems():
                       print 'Edge:', key, 'uses:', len(face_users),'faces'
Type:
tuple

flag

The face's texture mode flags; indicates the selection, active , and visibility states of a textured face (see FaceFlags for values). This is not the same as the selection or visibility states of the faces in edit mode (see sel and hide). To set the active face, use the Mesh.activeFace attribute instead. Will throw an exception if the mesh does not have UV faces; use Mesh.faceUV to test.

hide

The face's edit mode visibility state (hidden=1). This is not the same as the visibility state of the textured faces (see flag).
Type:
int

image

The Image used as a texture for this face. Setting this attribute will create UV faces if they do not exist. Getting this attribute throw an exception if the mesh does not have UV faces; use Mesh.faceUV to test. Assigning an image will automatically set the TEX attribute of the mode bitfield. Use "del f.image" or "f.image = None" to clear the image assigned to the face.
Type:
Image

index

The face's index within the mesh. Read-only.
Type:
int

mat

The face's index into the mesh's materials list. It is in the range [0,15].
Type:
int

mode

The texture mode bitfield (see FaceModes). Will throw an exception if the mesh does not have UV faces; use Mesh.faceUV to test.
Type:
int

no

The face's normal vector (x, y, z). Read-only.
Type:
vector

sel

The face's edit mode selection state (selected=1). This is not the same as the selection state of the textured faces (see flag). Note: changing the select state of a face changes the select state of the face's vertices.
Type:
int

smooth

If set, the vertex normals are averaged to make this face look smooth. (This is the same as choosing "Set Smooth" in the Editing Panel (F9) under "Link and Material" properties).
Type:
int

transp

Transparency mode. It is one of the values in FaceTranspModes). Will throw an exception if the mesh does not have UV faces; use Mesh.faceUV to test.
Type:
int

uv

The face's UV coordinates. Each vertex has its own UV coordinate. Setting this attribute will create UV faces if they do not exist. Getting this attribute throw an exception if the mesh does not have UV faces; use Mesh.faceUV to test.
Type:
tuple of vectors (WRAPPED DATA)

uvSel

The face's UV coordinates selection state; a 1 indicates the vertex is selected. Each vertex has its own UV coordinate select state (this is not the same as the vertex's edit mode selection state). Setting this attribute will create UV faces if they do not exist. Getting this attribute throw an exception if the mesh does not have UV faces; use Mesh.faceUV to test.
Type:
tuple of ints

v

Same as verts. This attribute is only for compatibility with NMesh scripts and will probably be deprecated in the future.

verts

The face's vertices. Each face has 3 or 4 vertices.
Type:
list of MVerts

   Trees       Indices       Help   
Generated by Epydoc 3.0.1 on Fri Oct 24 10:23:52 2008 http://epydoc.sourceforge.net