rna naming: verts -> vertices
authorCampbell Barton <ideasman42@gmail.com>
Wed, 18 Aug 2010 03:42:26 +0000 (03:42 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 18 Aug 2010 03:42:26 +0000 (03:42 +0000)
21 files changed:
release/scripts/io/export_3ds.py
release/scripts/io/export_fbx.py
release/scripts/io/export_mdd.py
release/scripts/io/export_obj.py
release/scripts/io/export_ply.py
release/scripts/io/export_x3d.py
release/scripts/io/import_scene_3ds.py
release/scripts/io/import_scene_obj.py
release/scripts/modules/bpy_types.py
release/scripts/op/add_mesh_torus.py
release/scripts/op/mesh.py
release/scripts/op/object.py
release/scripts/op/uvcalc_follow_active.py
release/scripts/op/uvcalc_smart_project.py
release/scripts/op/vertexpaint_dirt.py
release/scripts/templates/operator_uv.py
release/scripts/ui/space_image.py
release/scripts/ui/space_view3d.py
source/blender/makesrna/intern/rna_mesh.c
source/blender/makesrna/intern/rna_mesh_api.c
source/blender/makesrna/rna_cleanup/rna_properties.txt

index 83c9defd6ab9c2bb8a44de9b92a97285883edde4..4a5521bd9e933ee8d719081afbe5e3715aaf3a88 100644 (file)
@@ -564,14 +564,14 @@ def extract_triangles(mesh):
 
     img = None
     for i, face in enumerate(mesh.faces):
-        f_v = face.verts
+        f_v = face.vertices
 #              f_v = face.v
 
         uf = mesh.active_uv_texture.data[i] if do_uv else None
 
         if do_uv:
             f_uv = uf.uv
-            # f_uv =  (uf.uv1, uf.uv2, uf.uv3, uf.uv4) if face.verts[3] else (uf.uv1, uf.uv2, uf.uv3)
+            # f_uv =  (uf.uv1, uf.uv2, uf.uv3, uf.uv4) if face.vertices[3] else (uf.uv1, uf.uv2, uf.uv3)
 #                      f_uv = face.uv
             img = uf.image if uf else None
 #                      img = face.image
@@ -761,18 +761,18 @@ def make_mesh_chunk(mesh, materialDict):
     if len(mesh.uv_textures):
 #      if mesh.faceUV:
         # Remove the face UVs and convert it to vertex UV:
-        vert_array, uv_array, tri_list = remove_face_uv(mesh.verts, tri_list)
+        vert_array, uv_array, tri_list = remove_face_uv(mesh.vertices, tri_list)
     else:
         # Add the vertices to the vertex array:
         vert_array = _3ds_array()
-        for vert in mesh.verts:
+        for vert in mesh.vertices:
             vert_array.add(_3ds_point_3d(vert.co))
         # If the mesh has vertex UVs, create an array of UVs:
         if len(mesh.sticky):
 #              if mesh.vertexUV:
             uv_array = _3ds_array()
             for uv in mesh.sticky:
-#                      for vert in mesh.verts:
+#                      for vert in mesh.vertices:
                 uv_array.add(_3ds_point_uv(uv.co))
 #                              uv_array.add(_3ds_point_uv(vert.uvco))
         else:
@@ -1065,7 +1065,7 @@ def write(filename, context):
         '''
         if not blender_mesh.users:
             bpy.data.meshes.remove(blender_mesh)
-#              blender_mesh.verts = None
+#              blender_mesh.vertices = None
 
         i+=i
 
index 19d330f1ce22e072203de0208cf610eccda60933..b97c00e2aa7f7b63a5a35af9edadd186f9c02d88 100644 (file)
@@ -221,7 +221,7 @@ def mat4x4str(mat):
 def getVertsFromGroup(me, group_index):
     ret = []
 
-    for i, v in enumerate(me.verts):
+    for i, v in enumerate(me.vertices):
         for g in v.groups:
             if g.group == group_index:
                 ret.append((i, g.weight))
@@ -243,11 +243,11 @@ def BPyMesh_meshWeight2List(ob):
 
     if not len_groupNames:
         # no verts? return a vert aligned empty list
-        return [[] for i in range(len(me.verts))], []
+        return [[] for i in range(len(me.vertices))], []
     else:
-        vWeightList= [[0.0]*len_groupNames for i in range(len(me.verts))]
+        vWeightList= [[0.0]*len_groupNames for i in range(len(me.vertices))]
 
-    for i, v in enumerate(me.verts):
+    for i, v in enumerate(me.vertices):
         for g in v.groups:
             vWeightList[i][g.group] = g.weight
 
@@ -1398,7 +1398,7 @@ def write(filename, batch_objects = None, \
                 # TODO - this is a bit lazy, we could have a simple write loop
                 # for this case because all weights are 1.0 but for now this is ok
                 # Parent Bones arent used all that much anyway.
-                vgroup_data = [(j, 1.0) for j in range(len(my_mesh.blenData.verts))]
+                vgroup_data = [(j, 1.0) for j in range(len(my_mesh.blenData.vertices))]
             else:
                 # This bone is not a parent of this mesh object, no weights
                 vgroup_data = []
@@ -1487,7 +1487,7 @@ def write(filename, batch_objects = None, \
         file.write('\n\t\tVertices: ')
         i=-1
 
-        for v in me.verts:
+        for v in me.vertices:
             if i==-1:
                 file.write('%.6f,%.6f,%.6f' % tuple(v.co));    i=0
             else:
@@ -1499,7 +1499,7 @@ def write(filename, batch_objects = None, \
         file.write('\n\t\tPolygonVertexIndex: ')
         i=-1
         for f in me.faces:
-            fi = f.verts[:]
+            fi = f.vertices[:]
 
             # last index XORd w. -1 indicates end of face
             fi[-1] = fi[-1] ^ -1
@@ -1520,7 +1520,7 @@ def write(filename, batch_objects = None, \
         # write loose edges as faces.
         for ed in me.edges:
             if ed.loose:
-                ed_val = ed.verts[:]
+                ed_val = ed.vertices[:]
                 ed_val = ed_val[0], ed_val[-1] ^ -1
 
                 if i==-1:
@@ -1538,14 +1538,14 @@ def write(filename, batch_objects = None, \
         i=-1
         for ed in me.edges:
                 if i==-1:
-                    file.write('%i,%i' % (ed.verts[0], ed.verts[1]))
+                    file.write('%i,%i' % (ed.vertices[0], ed.vertices[1]))
 #                                      file.write('%i,%i' % (ed.v1.index, ed.v2.index))
                     i=0
                 else:
                     if i==13:
                         file.write('\n\t\t')
                         i=0
-                    file.write(',%i,%i' % (ed.verts[0], ed.verts[1]))
+                    file.write(',%i,%i' % (ed.vertices[0], ed.vertices[1]))
 #                                      file.write(',%i,%i' % (ed.v1.index, ed.v2.index))
                 i+=1
 
@@ -1560,7 +1560,7 @@ def write(filename, batch_objects = None, \
             Normals: ''')
 
         i=-1
-        for v in me.verts:
+        for v in me.vertices:
             if i==-1:
                 file.write('%.15f,%.15f,%.15f' % tuple(v.normal));     i=0
 #                              file.write('%.15f,%.15f,%.15f' % tuple(v.no));  i=0
@@ -1622,7 +1622,7 @@ def write(filename, batch_objects = None, \
         # returns a slice of data depending on number of face verts
         # data is either a MeshTextureFace or MeshColor
         def face_data(data, face):
-            totvert = len(f.verts)
+            totvert = len(f.vertices)
 
             return data[:totvert]
 
@@ -2072,7 +2072,7 @@ def write(filename, batch_objects = None, \
 #                                                              ob.copy().link(me)
 #                                                              # If new mesh has no vgroups we can try add if verts are teh same
 #                                                              if not me.getVertGroupNames(): # vgroups were not kept by the modifier
-#                                                                      if len(me.verts) == len(orig_mesh.verts):
+#                                                                      if len(me.vertices) == len(orig_mesh.vertices):
 #                                                                              groupNames, vWeightDict = BPyMesh.meshWeight2Dict(orig_mesh)
 #                                                                              BPyMesh.dict2MeshWeight(me, groupNames, vWeightDict)
 
@@ -2961,7 +2961,7 @@ Takes:  {''')
     # Clear mesh data Only when writing with modifiers applied
     for me in meshes_to_clear:
         bpy.data.meshes.remove(me)
-#              me.verts = None
+#              me.vertices = None
 
     # --------------------------- Footer
     if world:
index a3e491a7bd577d7cdc11593bc3ce68f416995c01..b2eda13fc8f2e0e978c24913c4fd35d75ad6a056 100644 (file)
@@ -65,7 +65,7 @@ def check_vertcount(mesh, vertcount):
     '''
     check and make sure the vertcount is consistent throughout the frame range
     '''
-    if len(mesh.verts) != vertcount:
+    if len(mesh.vertices) != vertcount:
         raise Exception('Error, number of verts has changed during animation, cannot export')
         f.close()
         zero_file(filepath)
@@ -94,7 +94,7 @@ def write(filename, sce, ob, PREF_STARTFRAME, PREF_ENDFRAME, PREF_FPS):
     [0.0, 0.0, 0.0, 1.0],\
     )
 
-    numverts = len(me.verts)
+    numverts = len(me.vertices)
 
     numframes = PREF_ENDFRAME - PREF_STARTFRAME + 1
     PREF_FPS = float(PREF_FPS)
@@ -114,7 +114,7 @@ def write(filename, sce, ob, PREF_STARTFRAME, PREF_ENDFRAME, PREF_FPS):
 
     check_vertcount(me, numverts)
     me.transform(mat_flip * ob.matrix_world)
-    f.write(pack(">%df" % (numverts * 3), *[axis for v in me.verts for axis in v.co]))
+    f.write(pack(">%df" % (numverts * 3), *[axis for v in me.vertices for axis in v.co]))
 
     for frame in range(PREF_STARTFRAME, PREF_ENDFRAME + 1):#in order to start at desired frame
         """
@@ -128,10 +128,10 @@ def write(filename, sce, ob, PREF_STARTFRAME, PREF_ENDFRAME, PREF_FPS):
         me.transform(mat_flip * ob.matrix_world)
 
         # Write the vertex data
-        f.write(pack(">%df" % (numverts * 3), *[axis for v in me.verts for axis in v.co]))
+        f.write(pack(">%df" % (numverts * 3), *[axis for v in me.vertices for axis in v.co]))
 
     """
-    me_tmp.verts= None
+    me_tmp.vertices= None
     """
     f.close()
 
index 3a551c9aa7eea6558bdd8cca50a412c989d5e242..97334d6a7847c438fd5316a8837432fd2ec5acc7 100644 (file)
@@ -308,7 +308,7 @@ def write_file(filepath, objects, scene,
         of vertices is the face's group
         """
         weightDict = {}
-        for vert_index in face.verts:
+        for vert_index in face.vertices:
 #       for vert in face:
             vWeights = vWeightMap[vert_index]
 #           vWeights = vWeightMap[vert]
@@ -326,7 +326,7 @@ def write_file(filepath, objects, scene,
     def getVertsFromGroup(me, group_index):
         ret = []
 
-        for i, v in enumerate(me.verts):
+        for i, v in enumerate(me.vertices):
             for g in v.groups:
                 if g.group == group_index:
                     ret.append((i, g.weight))
@@ -422,7 +422,7 @@ def write_file(filepath, objects, scene,
             else:
                 faceuv = False
 
-            me_verts = me.verts[:]
+            me_verts = me.vertices[:]
 
             # XXX - todo, find a better way to do triangulation
             # ...removed convert_to_triface because it relies on editmesh
@@ -432,7 +432,7 @@ def write_file(filepath, objects, scene,
                 # Add a dummy object to it.
                 has_quads = False
                 for f in me.faces:
-                    if f.verts[3] != 0:
+                    if f.vertices[3] != 0:
                         has_quads = True
                         break
 
@@ -454,7 +454,7 @@ def write_file(filepath, objects, scene,
             else:
                 edges = []
 
-            if not (len(face_index_pairs)+len(edges)+len(me.verts)): # Make sure there is somthing to write
+            if not (len(face_index_pairs)+len(edges)+len(me.vertices)): # Make sure there is somthing to write
 
                 # clean up
                 bpy.data.meshes.remove(me)
@@ -560,7 +560,7 @@ def write_file(filepath, objects, scene,
             if EXPORT_NORMALS:
                 for f, f_index in face_index_pairs:
                     if f.smooth:
-                        for v_idx in f.verts:
+                        for v_idx in f.vertices:
                             v = me_verts[v_idx]
                             noKey = veckey3d(v.normal)
                             if noKey not in globalNormals:
@@ -594,9 +594,9 @@ def write_file(filepath, objects, scene,
                         vgroupsMap[v_idx].append((g.name, vWeight))
 
             for f, f_index in face_index_pairs:
-                f_v = [me_verts[v_idx] for v_idx in f.verts]
+                f_v = [me_verts[v_idx] for v_idx in f.vertices]
 
-                # if f.verts[3] == 0:
+                # if f.vertices[3] == 0:
                 #   f_v.pop()
 
 #               f_v= f.v
@@ -610,7 +610,7 @@ def write_file(filepath, objects, scene,
                     f_image = tface.image
                     f_uv = tface.uv
                     # f_uv= [tface.uv1, tface.uv2, tface.uv3]
-                    # if len(f.verts) == 4:
+                    # if len(f.vertices) == 4:
                     #   f_uv.append(tface.uv4)
 #                   f_image = f.image
 #                   f_uv= f.uv
@@ -723,7 +723,7 @@ def write_file(filepath, objects, scene,
             if EXPORT_EDGES:
                 for ed in edges:
                     if ed.loose:
-                        file.write('f %d %d\n' % (ed.verts[0] + totverts, ed.verts[1] + totverts))
+                        file.write('f %d %d\n' % (ed.vertices[0] + totverts, ed.vertices[1] + totverts))
 
             # Make the indicies global rather then per mesh
             totverts += len(me_verts)
index 7ea3c72a6628da8a2fe5f5da94b3d18eb1600363..1c2fb02b1c7d1a52d7eb129551efe2a492854c98 100644 (file)
@@ -147,7 +147,7 @@ def write(filename, scene, ob, \
     # incase
     color = uvcoord = uvcoord_key = normal = normal_key = None
 
-    mesh_verts = mesh.verts # save a lookup
+    mesh_verts = mesh.vertices # save a lookup
     ply_verts = [] # list of dictionaries
     # vdict = {} # (index, normal, uv) -> new index
     vdict = [{} for i in range(len(mesh_verts))]
@@ -168,7 +168,7 @@ def write(filename, scene, ob, \
             col = active_col_layer[i]
             col = col.color1, col.color2, col.color3, col.color4
 
-        f_verts = f.verts
+        f_verts = f.vertices
 
         pf = ply_faces[i]
         for j, vidx in enumerate(f_verts):
index 0d9c3efaec5e0782e8d1f645f45e2611f163188d..a078ca1e00e493ce720ade26cd047f0bde7d20a7 100644 (file)
@@ -581,7 +581,7 @@ class x3d_class:
         if self.writingcoords == 0:
             self.file.write('coordIndex="')
             for face in mesh.faces:
-                fv = face.verts
+                fv = face.vertices
                 # fv = face.v
 
                 if len(fv)==3:
@@ -604,7 +604,7 @@ class x3d_class:
             # mesh.transform(ob.matrix_world)
             self.writeIndented("<Coordinate DEF=\"%s%s\" \n" % ("coord_",meshName), 1)
             self.file.write("\t\t\t\tpoint=\"")
-            for v in mesh.verts:
+            for v in mesh.vertices:
                 self.file.write("%.6f %.6f %.6f, " % tuple(v.co))
             self.file.write("\" />")
             self.writeIndented("\n", -1)
@@ -618,7 +618,7 @@ class x3d_class:
         # for face in mesh.faces:
             # workaround, since tface.uv iteration is wrong atm
             uvs = face.uv
-            # uvs = [face.uv1, face.uv2, face.uv3, face.uv4] if face.verts[3] else [face.uv1, face.uv2, face.uv3]
+            # uvs = [face.uv1, face.uv2, face.uv3, face.uv4] if face.vertices[3] else [face.uv1, face.uv2, face.uv3]
 
             for uv in uvs:
             # for uv in face.uv:
@@ -912,7 +912,7 @@ class x3d_class:
 
         # if EXPORT_APPLY_MODIFIERS:
         #      if containerMesh:
-        #              containerMesh.verts = None
+        #              containerMesh.vertices = None
 
         self.cleanup()
 
@@ -1030,7 +1030,7 @@ class x3d_class:
         # print("Debug: mesh.faceUV=%d" % mesh.faceUV)
         print("Debug: mesh.hasVertexColours=%d" % (len(mesh.vertex_colors) > 0))
         # print("Debug: mesh.hasVertexColours=%d" % mesh.hasVertexColours())
-        print("Debug: mesh.verts=%d" % len(mesh.verts))
+        print("Debug: mesh.vertices=%d" % len(mesh.vertices))
         print("Debug: mesh.faces=%d" % len(mesh.faces))
         print("Debug: mesh.materials=%d" % len(mesh.materials))
 
index 0c30a8bd127825bbb1f658c3fc97027f8eaef0b9..266f7001cc2d9a0d2588f97920773eb4058ad027 100644 (file)
@@ -338,12 +338,12 @@ def process_next_chunk(file, previous_chunk, importedObjects, IMAGE_SEARCH):
         if myContextMesh_vertls:
 
             bmesh.add_geometry(len(myContextMesh_vertls)//3, 0, len(myContextMesh_facels))
-            bmesh.verts.foreach_set("co", myContextMesh_vertls)
+            bmesh.vertices.foreach_set("co", myContextMesh_vertls)
             
             eekadoodle_faces = []
             for v1, v2, v3 in myContextMesh_facels:
                 eekadoodle_faces.extend([v3, v1, v2, 0] if v3 == 0 else [v1, v2, v3, 0])
-            bmesh.faces.foreach_set("verts_raw", eekadoodle_faces)
+            bmesh.faces.foreach_set("vertices_raw", eekadoodle_faces)
             
             if bmesh.faces and contextMeshUV:
                 bmesh.add_uv_texture()
@@ -830,7 +830,7 @@ def load_3ds(filename, context, IMPORT_CONSTRAIN_BOUNDS=10.0, IMAGE_SEARCH=True,
     for ob in importedObjects:
         if ob.type == 'MESH':
             me = ob.data
-#           me.verts.delete([me.verts[0],]) # XXX, todo
+#           me.vertices.delete([me.vertices[0],]) # XXX, todo
             if not APPLY_MATRIX:
                 me.transform(ob.matrix_world.copy().invert())
 
index 3827b3225b6d9a52e11e687ef848d70c299856ab..84f0f3c65687b9549e2bce4d855d85793f250087 100644 (file)
@@ -137,7 +137,7 @@ def BPyMesh_ngon(from_data, indices, PREF_FIX_LOOPS= True):
         if type(from_data) in (tuple, list):
             verts= [Vector(from_data[i]) for ii, i in enumerate(indices)]
         else:
-            verts= [from_data.verts[i].co for ii, i in enumerate(indices)]
+            verts= [from_data.vertices[i].co for ii, i in enumerate(indices)]
 
         for i in range(len(verts)-1, 0, -1): # same as reversed(xrange(1, len(verts))):
             if verts[i][1]==verts[i-1][0]:
@@ -154,7 +154,7 @@ def BPyMesh_ngon(from_data, indices, PREF_FIX_LOOPS= True):
         if type(from_data) in (tuple, list):
             verts= [vert_treplet(Vector(from_data[i]), ii) for ii, i in enumerate(indices)]
         else:
-            verts= [vert_treplet(from_data.verts[i].co, ii) for ii, i in enumerate(indices)]
+            verts= [vert_treplet(from_data.vertices[i].co, ii) for ii, i in enumerate(indices)]
 
         edges= [(i, i-1) for i in range(len(verts))]
         if edges:
@@ -677,18 +677,18 @@ def create_mesh(new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_loc, v
     # make sure the list isnt too big
     for material in materials:
         me.add_material(material)
-    #me.verts.extend([(0,0,0)]) # dummy vert
+    #me.vertices.extend([(0,0,0)]) # dummy vert
 
     me.add_geometry(len(verts_loc), 0, len(faces))
 
     # verts_loc is a list of (x, y, z) tuples
-    me.verts.foreach_set("co", unpack_list(verts_loc))
-#      me.verts.extend(verts_loc)
+    me.vertices.foreach_set("co", unpack_list(verts_loc))
+#      me.vertices.extend(verts_loc)
 
     # faces is a list of (vert_indices, texco_indices, ...) tuples
     # XXX faces should contain either 3 or 4 verts
     # XXX no check for valid face indices
-    me.faces.foreach_set("verts_raw", unpack_face_list([f[0] for f in faces]))
+    me.faces.foreach_set("vertices_raw", unpack_face_list([f[0] for f in faces]))
 #      face_mapping= me.faces.extend([f[0] for f in faces], indexList=True)
 
     if verts_tex and me.faces:
@@ -776,7 +776,7 @@ def create_mesh(new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_loc, v
         me.add_geometry(0, len(edges), 0)
 
         # edges should be a list of (a, b) tuples
-        me.edges.foreach_set("verts", unpack_list(edges))
+        me.edges.foreach_set("vertices", unpack_list(edges))
 #              me_edges.extend( edges )
 
 #      del me_edges
@@ -791,7 +791,7 @@ def create_mesh(new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_loc, v
 #      if CREATE_FGONS and fgon_edges:
 #              for fgon_edge in fgon_edges.keys():
 #                      for ed in me.edges:
-#                              if edges_match(fgon_edge, ed.verts):
+#                              if edges_match(fgon_edge, ed.vertices):
 #                                      ed.fgon = True
 
 #      if CREATE_FGONS and fgon_edges:
@@ -805,7 +805,7 @@ def create_mesh(new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_loc, v
 #      if unique_smooth_groups and sharp_edges:
 #              for sharp_edge in sharp_edges.keys():
 #                      for ed in me.edges:
-#                              if edges_match(sharp_edge, ed.verts):
+#                              if edges_match(sharp_edge, ed.vertices):
 #                                      ed.sharp = True
 
 #      if unique_smooth_groups and sharp_edges:
index 0a796793d01088f5b93ad64b9e6925cae49d2495..77e231dc478cc87bbde10966e928bb35539ef8bc 100644 (file)
@@ -309,11 +309,11 @@ class Mesh(bpy_types.ID):
         self.add_geometry(len(verts), len(edges), len(faces))
 
         verts_flat = [f for v in verts for f in v]
-        self.verts.foreach_set("co", verts_flat)
+        self.vertices.foreach_set("co", verts_flat)
         del verts_flat
 
         edges_flat = [i for e in edges for i in e]
-        self.edges.foreach_set("verts", edges_flat)
+        self.edges.foreach_set("vertices", edges_flat)
         del edges_flat
 
         def treat_face(f):
@@ -324,7 +324,7 @@ class Mesh(bpy_types.ID):
             return f
 
         faces_flat = [v for f in faces for v in treat_face(f)]
-        self.faces.foreach_set("verts_raw", faces_flat)
+        self.faces.foreach_set("vertices_raw", faces_flat)
         del faces_flat
 
     @property
@@ -372,7 +372,7 @@ class Mesh(bpy_types.ID):
 
         for f in faces:
 #            if len(f) == 4:
-            if f.verts_raw[3] != 0:
+            if f.vertices_raw[3] != 0:
                 edge_keys = f.edge_keys
                 for i, edkey in enumerate(f.edge_keys):
                     edges.setdefault(edkey, []).append(edge_keys[OTHER_INDEX[i]])
@@ -449,7 +449,7 @@ class Mesh(bpy_types.ID):
 
         while edges:
             current_edge = edges.pop()
-            vert_end, vert_start = current_edge.verts[:]
+            vert_end, vert_start = current_edge.vertices[:]
             line_poly = [vert_start, vert_end]
 
             ok = True
@@ -460,7 +460,7 @@ class Mesh(bpy_types.ID):
                 while i:
                     i -= 1
                     ed = edges[i]
-                    v1, v2 = ed.verts
+                    v1, v2 = ed.vertices
                     if v1 == vert_end:
                         line_poly.append(v2)
                         vert_end = line_poly[-1]
@@ -495,7 +495,7 @@ class MeshEdge(StructRNA):
 
     @property
     def key(self):
-        return ord_ind(*tuple(self.verts))
+        return ord_ind(*tuple(self.vertices))
 
 
 class MeshFace(StructRNA):
@@ -504,8 +504,8 @@ class MeshFace(StructRNA):
     @property
     def center(self):
         """The midpoint of the face."""
-        face_verts = self.verts[:]
-        mesh_verts = self.id_data.verts
+        face_verts = self.vertices[:]
+        mesh_verts = self.id_data.vertices
         if len(face_verts) == 3:
             return (mesh_verts[face_verts[0]].co + mesh_verts[face_verts[1]].co + mesh_verts[face_verts[2]].co) / 3.0
         else:
@@ -513,7 +513,7 @@ class MeshFace(StructRNA):
 
     @property
     def edge_keys(self):
-        verts = self.verts[:]
+        verts = self.vertices[:]
         if len(verts) == 3:
             return ord_ind(verts[0], verts[1]), ord_ind(verts[1], verts[2]), ord_ind(verts[2], verts[0])
 
index d64b92a8b19322e41759cae4c20b6d731720154c..e19f2b4e18caa1c6ca929f001b10cbc699e97b2e 100644 (file)
@@ -122,8 +122,8 @@ class AddTorus(bpy.types.Operator):
         mesh = bpy.data.meshes.new("Torus")
 
         mesh.add_geometry(int(len(verts_loc) / 3), 0, int(len(faces) / 4))
-        mesh.verts.foreach_set("co", verts_loc)
-        mesh.faces.foreach_set("verts_raw", faces)
+        mesh.vertices.foreach_set("co", verts_loc)
+        mesh.faces.foreach_set("vertices_raw", faces)
         mesh.update()
 
         import add_object_utils
index 736ec41ba14ea3911520a521ff70d23ec6a0be06..9e684cea9c27e8dd13c6c36028fd351037826996 100644 (file)
@@ -91,7 +91,7 @@ class MeshMirrorUV(bpy.types.Operator):
         mirror_gt = {}
         mirror_lt = {}
 
-        vcos = [v.co.to_tuple(5) for v in mesh.verts]
+        vcos = [v.co.to_tuple(5) for v in mesh.vertices]
 
         for i, co in enumerate(vcos):
             if co[0] > 0.0:
@@ -102,7 +102,7 @@ class MeshMirrorUV(bpy.types.Operator):
                 mirror_gt[co] = i
                 mirror_lt[co] = i
 
-        #for i, v in enumerate(mesh.verts):
+        #for i, v in enumerate(mesh.vertices):
         vmap = {}
         for mirror_a, mirror_b in (mirror_gt, mirror_lt), (mirror_lt, mirror_gt):
             for co, i in mirror_a.items():
@@ -130,14 +130,14 @@ class MeshMirrorUV(bpy.types.Operator):
         # find mirror faces
         mirror_fm = {}
         for i, f in enumerate(faces):
-            verts = f.verts[:]
+            verts = f.vertices[:]
             verts.sort()
             verts = tuple(verts)
             mirror_fm[verts] = i
 
         fmap = {}
         for i, f in enumerate(faces):
-            verts = [vmap.get(j) for j in f.verts]
+            verts = [vmap.get(j) for j in f.vertices]
             if None not in verts:
                 verts.sort()
                 j = mirror_fm.get(tuple(verts))
@@ -159,8 +159,8 @@ class MeshMirrorUV(bpy.types.Operator):
             uv2 = fuvs_cpy[j]
 
             # get the correct rotation
-            v1 = faces[j].verts[:]
-            v2 = [vmap[k] for k in faces[i].verts[:]]
+            v1 = faces[j].vertices[:]
+            v2 = [vmap[k] for k in faces[i].vertices[:]]
 
 
             for k in range(len(uv1)):
index 56c4394c7965a84e4851019d826383181ed426ad..56c43c0728c6c896cd261a5905087b42f499ed6b 100644 (file)
@@ -269,28 +269,28 @@ class ShapeTransfer(bpy.types.Operator):
 
         orig_shape_coords = me_cos(ob_act.active_shape_key.data)
 
-        orig_normals = me_nos(me.verts)
-        # orig_coords = me_cos(me.verts) # the actual mverts location isnt as relyable as the base shape :S
+        orig_normals = me_nos(me.vertices)
+        # orig_coords = me_cos(me.vertices) # the actual mverts location isnt as relyable as the base shape :S
         orig_coords = me_cos(me.shape_keys.keys[0].data)
 
         for ob_other in objects:
             me_other = ob_other.data
-            if len(me_other.verts) != len(me.verts):
+            if len(me_other.vertices) != len(me.vertices):
                 self.report({'WARNING'}, "Skipping '%s', vertex count differs" % ob_other.name)
                 continue
 
-            target_normals = me_nos(me_other.verts)
+            target_normals = me_nos(me_other.vertices)
             if me_other.shape_keys:
                 target_coords = me_cos(me_other.shape_keys.keys[0].data)
             else:
-                target_coords = me_cos(me_other.verts)
+                target_coords = me_cos(me_other.vertices)
 
             ob_add_shape(ob_other, orig_key_name)
 
             # editing the final coords, only list that stores wrapped coords
             target_shape_coords = [v.co for v in ob_other.active_shape_key.data]
 
-            median_coords = [[] for i in range(len(me.verts))]
+            median_coords = [[] for i in range(len(me.vertices))]
 
             # Method 1, edge
             if mode == 'OFFSET':
@@ -299,7 +299,7 @@ class ShapeTransfer(bpy.types.Operator):
 
             elif mode == 'RELATIVE_FACE':
                 for face in me.faces:
-                    i1, i2, i3, i4 = face.verts_raw
+                    i1, i2, i3, i4 = face.vertices_raw
                     if i4 != 0:
                         pt = BarycentricTransform(orig_shape_coords[i1],
                             orig_coords[i4], orig_coords[i1], orig_coords[i2],
@@ -339,7 +339,7 @@ class ShapeTransfer(bpy.types.Operator):
 
             elif mode == 'RELATIVE_EDGE':
                 for ed in me.edges:
-                    i1, i2 = ed.verts
+                    i1, i2 = ed.vertices
                     v1, v2 = orig_coords[i1], orig_coords[i2]
                     edge_length = (v1 - v2).length
                     n1loc = v1 + orig_normals[i1] * edge_length
@@ -505,8 +505,8 @@ class MakeDupliFace(bpy.types.Operator):
             mesh = bpy.data.meshes.new(data.name + "_dupli")
 
             mesh.add_geometry(int(len(face_verts) / 3), 0, int(len(face_verts) / (4 * 3)))
-            mesh.verts.foreach_set("co", face_verts)
-            mesh.faces.foreach_set("verts_raw", faces)
+            mesh.vertices.foreach_set("co", face_verts)
+            mesh.faces.foreach_set("vertices_raw", faces)
             mesh.update() # generates edge data
 
             # pick an object to use
index f02ee497999f6b13c6d5bc34eed5b4dba77e3e3b..6e2a1277a36aa29a7bc83e1d42003517a4b1cbb9 100644 (file)
@@ -26,7 +26,7 @@ import bpy
 
 def extend(obj, operator, EXTEND_MODE):
     me = obj.data
-    me_verts = me.verts
+    me_verts = me.vertices
     # script will fail without UVs
     if not me.active_uv_texture:
         me.add_uv_texture()
@@ -54,8 +54,8 @@ def extend(obj, operator, EXTEND_MODE):
             # assume a quad
             return [(vi[0], vi[1]), (vi[1], vi[2]), (vi[2], vi[3]), (vi[3], vi[0])]
 
-        vidx_source = face_source.verts
-        vidx_target = face_target.verts
+        vidx_source = face_source.vertices
+        vidx_target = face_target.vertices
 
         faceUVsource = me.active_uv_texture.data[face_source.index]
         uvs_source = [faceUVsource.uv1, faceUVsource.uv2, faceUVsource.uv3, faceUVsource.uv4]
@@ -146,7 +146,7 @@ def extend(obj, operator, EXTEND_MODE):
         operator.report({'ERROR'}, "No active face.")
         return
 
-    face_sel = [f for f in me.faces if len(f.verts) == 4 and f.select]
+    face_sel = [f for f in me.faces if len(f.vertices) == 4 and f.select]
 
     face_act_local_index = -1
     for i, f in enumerate(face_sel):
@@ -181,7 +181,7 @@ def extend(obj, operator, EXTEND_MODE):
 
     if EXTEND_MODE == 'LENGTH':
         edge_loops = me.edge_loops_from_faces(face_sel, [ed.key for ed in me.edges if ed.seam])
-        me_verts = me.verts
+        me_verts = me.vertices
         for loop in edge_loops:
             looplen = [0.0]
             for ed in loop:
index bbd0102fc6108faf2e1eab3854b55f4c50646821..3b0d861a15266a254608a9c38eba633f06c97cbc 100644 (file)
@@ -792,7 +792,7 @@ def VectoMat(vec):
 class thickface(object):
     __slost__= 'v', 'uv', 'no', 'area', 'edge_keys'
     def __init__(self, face, uvface, mesh_verts):
-        self.v = [mesh_verts[i] for i in face.verts]
+        self.v = [mesh_verts[i] for i in face.vertices]
         if len(self.v)==4:
             self.uv = uvface.uv1, uvface.uv2, uvface.uv3, uvface.uv4
         else:
@@ -896,7 +896,7 @@ def main(context, island_margin, projection_limit):
             me.add_uv_texture()
 
         uv_layer = me.active_uv_texture.data
-        me_verts = list(me.verts)
+        me_verts = list(me.vertices)
 
         if USER_ONLY_SELECTED_FACES:
             meshFaces = [thickface(f, uv_layer[i], me_verts) for i, f in enumerate(me.faces) if f.select]
index 21c19d528ccec34bed1a61f42f3c88523f4b31fd..72317cf8c11c5d7b321527fafbb0a0679b6bd7ab 100644 (file)
@@ -43,7 +43,7 @@ def applyVertexDirt(me, blur_iterations, blur_strength, clamp_dirt, clamp_clean,
 
     #BPyMesh.meshCalcNormals(me)
 
-    vert_tone = [0.0] * len(me.verts)
+    vert_tone = [0.0] * len(me.vertices)
 
     min_tone = 180.0
     max_tone = 0.0
@@ -51,21 +51,21 @@ def applyVertexDirt(me, blur_iterations, blur_strength, clamp_dirt, clamp_clean,
     # create lookup table for each vertex's connected vertices (via edges)
     con = []
 
-    con = [[] for i in range(len(me.verts))]
+    con = [[] for i in range(len(me.vertices))]
 
     # add connected verts
     for e in me.edges:
-        con[e.verts[0]].append(e.verts[1])
-        con[e.verts[1]].append(e.verts[0])
+        con[e.vertices[0]].append(e.vertices[1])
+        con[e.vertices[1]].append(e.vertices[0])
 
-    for i, v in enumerate(me.verts):
+    for i, v in enumerate(me.vertices):
         vec = Vector()
         no = v.normal
         co = v.co
 
         # get the direction of the vectors between the vertex and it's connected vertices
         for c in con[i]:
-            vec += (me.verts[c].co - co).normalize()
+            vec += (me.vertices[c].co - co).normalize()
 
         # normalize the vector by dividing by the number of connected verts
         tot_con = len(con[i])
@@ -133,9 +133,9 @@ def applyVertexDirt(me, blur_iterations, blur_strength, clamp_dirt, clamp_clean,
 
             f_col = [f_col.color1, f_col.color2, f_col.color3, f_col.color4]
 
-            for j, v in enumerate(f.verts):
+            for j, v in enumerate(f.vertices):
                 col = f_col[j]
-                tone = vert_tone[me.verts[v].index]
+                tone = vert_tone[me.vertices[v].index]
                 tone = (tone - min_tone) / tone_range
 
                 if dirt_only:
index 46ce15f090d258de628b5a86c46f67aac50fb6d5..a18aaf358c882827d11fa4a551ae87b37d7f5849 100644 (file)
@@ -15,10 +15,10 @@ def main(context):
     # adjust UVs
     for i, uv in enumerate(mesh.active_uv_texture.data):
         uvs = uv.uv1, uv.uv2, uv.uv3, uv.uv4
-        for j, v_idx in enumerate(mesh.faces[i].verts):
+        for j, v_idx in enumerate(mesh.faces[i].vertices):
             if uv.select_uv[j]:
                 # apply the location of the vertex as a UV
-                uvs[j][:] = mesh.verts[v_idx].co.xy
+                uvs[j][:] = mesh.vertices[v_idx].co.xy
 
 
     if is_editmode:
index 3ca7139a01ce29e1cd15db683f13defffde17430..a614023e849f1a1630d99a5b2c8d531632c9b043 100644 (file)
@@ -312,7 +312,7 @@ class IMAGE_HT_header(bpy.types.Header):
                 row.prop(toolsettings, "proportional_edit_falloff", text="", icon_only=True)
 
             row = layout.row(align=True)
-            row.prop(toolsettings, "snap", text="")
+            row.prop(toolsettings, "use_snap", text="")
             row.prop(toolsettings, "snap_element", text="", icon_only=True)
 
             # mesh = context.edit_object.data
index 828cd04f461e7ea053d52591f2845ab4b1f453c3..eb868284005334a2cf5c995d71ad5a5e978730e1 100644 (file)
@@ -88,7 +88,7 @@ class VIEW3D_HT_header(bpy.types.Header):
 
         # Snap
         row = layout.row(align=True)
-        row.prop(toolsettings, "snap", text="")
+        row.prop(toolsettings, "use_snap", text="")
         row.prop(toolsettings, "snap_element", text="", icon_only=True)
         if toolsettings.snap_element != 'INCREMENT':
             row.prop(toolsettings, "snap_target", text="")
index 9ee23c954f6337434b774642fc3faf0c902af903..4faebe7c3f0409c6f549d802035a1e7a98fc8f0c 100644 (file)
@@ -1148,7 +1148,7 @@ static void rna_def_medge(BlenderRNA *brna)
        RNA_def_struct_path_func(srna, "rna_MeshEdge_path");
        RNA_def_struct_ui_icon(srna, ICON_EDGESEL);
 
-       prop= RNA_def_property(srna, "verts", PROP_INT, PROP_UNSIGNED);
+       prop= RNA_def_property(srna, "vertices", PROP_INT, PROP_UNSIGNED);
        RNA_def_property_int_sdna(prop, NULL, "v1");
        RNA_def_property_array(prop, 2);
        RNA_def_property_ui_text(prop, "Vertices", "Vertex indices");
@@ -1212,7 +1212,7 @@ static void rna_def_mface(BlenderRNA *brna)
        RNA_def_struct_ui_icon(srna, ICON_FACESEL);
 
        // XXX allows creating invalid meshes
-       prop= RNA_def_property(srna, "verts", PROP_INT, PROP_UNSIGNED);
+       prop= RNA_def_property(srna, "vertices", PROP_INT, PROP_UNSIGNED);
        RNA_def_property_array(prop, 4);
        RNA_def_property_flag(prop, PROP_DYNAMIC);
        RNA_def_property_dynamic_array_funcs(prop, "rna_MeshFace_verts_get_length");
@@ -1220,7 +1220,7 @@ static void rna_def_mface(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Vertices", "Vertex indices");
 
        /* leaving this fixed size array for foreach_set used in import scripts */
-       prop= RNA_def_property(srna, "verts_raw", PROP_INT, PROP_UNSIGNED);
+       prop= RNA_def_property(srna, "vertices_raw", PROP_INT, PROP_UNSIGNED);
        RNA_def_property_int_sdna(prop, NULL, "v1");
        RNA_def_property_array(prop, 4);
        RNA_def_property_ui_text(prop, "Vertices", "Fixed size vertex indices array");
@@ -1640,7 +1640,7 @@ static void rna_def_mesh(BlenderRNA *brna)
        RNA_def_struct_ui_text(srna, "Mesh", "Mesh datablock defining geometric surfaces");
        RNA_def_struct_ui_icon(srna, ICON_MESH_DATA);
 
-       prop= RNA_def_property(srna, "verts", PROP_COLLECTION, PROP_NONE);
+       prop= RNA_def_property(srna, "vertices", PROP_COLLECTION, PROP_NONE);
        RNA_def_property_collection_sdna(prop, NULL, "mvert", "totvert");
        RNA_def_property_struct_type(prop, "MeshVertex");
        RNA_def_property_ui_text(prop, "Vertices", "Vertices of the mesh");
index 1657e0e64d7e25d1ab07ea612687003636289959..97252ce754e2cd6b06ef3a6e059d230a20929453 100644 (file)
@@ -61,7 +61,7 @@ void RNA_api_mesh(StructRNA *srna)
 
        func= RNA_def_function(srna, "add_geometry", "ED_mesh_geometry_add");
        RNA_def_function_flag(func, FUNC_USE_REPORTS);
-       parm= RNA_def_int(func, "verts", 0, 0, INT_MAX, "Number", "Number of vertices to add.", 0, INT_MAX);
+       parm= RNA_def_int(func, "vertices", 0, 0, INT_MAX, "Number", "Number of vertices to add.", 0, INT_MAX);
        RNA_def_property_flag(parm, PROP_REQUIRED);
        parm= RNA_def_int(func, "edges", 0, 0, INT_MAX, "Number", "Number of edges to add.", 0, INT_MAX);
        RNA_def_property_flag(parm, PROP_REQUIRED);
index 09e873268e193b765b2da742aac58045487285cd..b463cd9cc30f1ff10fe4f8d7f64183bc57a40286 100644 (file)
 #+ * ID|Mesh.uv_texture_stencil_index -> uv_texture_stencil_index:   int  "Mask UV texture index"
 #+ * ID|Mesh.uv_textures -> uv_textures:   collection,  "(read-only)"
 #+ * ID|Mesh.vertex_colors -> vertex_colors:   collection,  "(read-only)"
- + * ID|Mesh.verts -> vertices:   collection,  "(read-only)    Vertices of the mesh"
+#ID|Mesh.vertices -> vertices:   collection,  "(read-only)    Vertices of the mesh"
 #TODO MOVE TO ELEMENTS * ID|MetaBall.active_element -> active_element:   pointer,  "(read-only)    Last selected element"
 #+ * ID|MetaBall.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
 #+ * ID|MetaBall.elements -> elements:   collection,  "(read-only)    Meta elements"
 #+ * MeshEdge.select -> select:   boolean  "NO DESCRIPTION"
  + * MeshEdge.seam -> use_seam:   boolean  "Seam edge for UV unwrapping"
  + * MeshEdge.sharp -> use_sharp:   boolean  "Sharp edge for the EdgeSplit modifier"
- + * MeshEdge.verts -> vertices:   int[2]  "Vertex indices"
+#MeshEdge.vertices -> vertices:   int[2]  "Vertex indices"
 #+ * MeshFace.area -> area:   float,  "(read-only)    read only area of the face"
 #+ * MeshFace.hide -> hide:   boolean  "NO DESCRIPTION"
 #+ * MeshFace.index -> index:   int,  "(read-only)    Index number of the vertex"
 #+ * MeshFace.normal -> normal:   float[3],  "(read-only)    local space unit length normal vector for this face"
 #+ * MeshFace.select -> select:   boolean  "NO DESCRIPTION"
  + * MeshFace.smooth -> use_smooth:   boolean  "NO DESCRIPTION"
- + * MeshFace.verts -> vertices:   int[4]  "Vertex indices"
- + * MeshFace.verts_raw -> vertices_raw:   int[4]  "Fixed size vertex indices array"
+#MeshFace.vertices -> vertices:   int[4]  "Vertex indices"
+#MeshFace.vertices_raw -> vertices_raw:   int[4]  "Fixed size vertex indices array"
 #+ * MeshFaces.active -> active:   int  "The active face for this mesh"
 #+ * MeshFaces.active_tface -> active_tface:   pointer,  "(read-only)    Active Texture Face"
 #+ * MeshFloatProperty.value -> value:   float  "NO DESCRIPTION"
  + * WorldStarsSettings.color_randomization -> color_random:   float  "Randomize star colors"
  + * WorldStarsSettings.min_distance -> distance_min:   float  "Minimum distance to the camera for stars"
 #+ * WorldStarsSettings.size -> size:   float  "Average screen dimension of stars"
-#+ * WorldStarsSettings.use_stars -> use_stars:   boolean  "Enable starfield generation[651123 refs]"
+#+ * WorldStarsSettings.use_stars -> use_stars:   boolean  "Enable starfield generation[651125 refs]"