forked from bartvdbraak/blender
rna naming: verts -> vertices
This commit is contained in:
parent
f32a35fd9d
commit
9784a1169d
@ -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
|
||||
|
||||
|
@ -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:
|
||||
|
@ -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()
|
||||
|
||||
|
@ -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)
|
||||
|
@ -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):
|
||||
|
@ -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))
|
||||
|
||||
|
@ -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())
|
||||
|
||||
|
@ -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:
|
||||
|
@ -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])
|
||||
|
||||
|
@ -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
|
||||
|
@ -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)):
|
||||
|
@ -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
|
||||
|
@ -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:
|
||||
|
@ -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]
|
||||
|
@ -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:
|
||||
|
@ -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:
|
||||
|
@ -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
|
||||
|
@ -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="")
|
||||
|
@ -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");
|
||||
|
@ -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);
|
||||
|
@ -1475,7 +1475,7 @@
|
||||
#+ * 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"
|
||||
@ -2163,7 +2163,7 @@
|
||||
#+ * 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"
|
||||
@ -2171,8 +2171,8 @@
|
||||
#+ * 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"
|
||||
@ -4602,4 +4602,4 @@
|
||||
+ * 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]"
|
||||
|
Loading…
Reference in New Issue
Block a user