def initialise():
global_undo = bpy.context.user_preferences.edit.use_global_undo
bpy.context.user_preferences.edit.use_global_undo = False
object = bpy.context.active_object
if 'MIRROR' in [mod.type for mod in object.modifiers if mod.show_viewport]:
# ensure that selection is synced for the derived mesh
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.mode_set(mode='EDIT')
bm = bmesh.from_edit_mesh(object.data)
bm.verts.ensure_lookup_table()
bm.edges.ensure_lookup_table()
bm.faces.ensure_lookup_table()
return(global_undo, object, bm)
# move the vertices to their new locations
python类from_edit_mesh()的实例源码
def execute(self, context):
import bmesh
from .bmesh import find_adjacent
obj = context.active_object
me = obj.data
bm = bmesh.from_edit_mesh(me)
if find_adjacent.select_prev(bm, self.report):
bm.select_flush_mode()
bmesh.update_edit_mesh(me, False)
return {'FINISHED'}
# XXX This is hackish (going forth and back from Object mode...), to be redone once we have proper support of
# custom normals in BMesh/edit mode.
def execute(self, context):
mesh = bpy.context.object.data
bm = bmesh.from_edit_mesh(mesh)
bm.faces.ensure_lookup_table()
uv_layer = bm.loops.layers.uv.active
face0=[]
#save active face
for l in bm.faces.active.loops:
face0.append(l[uv_layer].uv)
#copy uvs to selected face
for f in bm.faces:
if f.select:
if f is not bm.faces.active:
for i,l in enumerate(f.loops):
if i < len(face0):
l[uv_layer].uv=face0[i]
else:
#TODO: possibly interpolate uvs for better transfer
l[uv_layer].uv=face0[len(face0)-1]
bmesh.update_edit_mesh(mesh, False, False)
return {'FINISHED'}
def update(self, context):
# update height via bmesh to avoid loosing material ids
# this should be the rule for other simple objects
# as long as there is no topologic changes
o = context.active_object
if archipack_wall.datablock(o) != self:
return
bpy.ops.object.mode_set(mode='EDIT')
me = o.data
bm = bmesh.from_edit_mesh(me)
bm.verts.ensure_lookup_table()
bm.faces.ensure_lookup_table()
new_z = self.z
last_z = list(v.co.z for v in bm.verts)
max_z = max(last_z)
for v in bm.verts:
if v.co.z == max_z:
v.co.z = new_z
bmesh.update_edit_mesh(me, True)
bpy.ops.object.mode_set(mode='OBJECT')
def execute(self, context):
ob = context.object
if self.direction and ob is not None:
verts = bmesh.from_edit_mesh(ob.data).verts
cur_set = from_string(eval("ob.shifter_{}_verts".format(self.direction)))
start_size = len(cur_set)
for v in verts:
if v.select and v.index not in cur_set:
cur_set.add(v.index)
end_size = len(cur_set)
exec("ob.shifter_{}_verts = to_string(list(cur_set))".format(self.direction))
self.report({"INFO"}, "Shifter: Added {} Vertices".format(end_size - start_size))
return {"FINISHED"}
def execute(self, context):
ob = context.object
if self.direction and ob is not None:
verts = bmesh.from_edit_mesh(ob.data).verts
indices = []
for v in verts:
if v.select:
indices.append(v.index)
size = len(indices)
if self.direction == "x":
ob.shifter_x_verts = to_string(indices)
elif self.direction == "y":
ob.shifter_y_verts = to_string(indices)
else:
ob.shifter_z_verts = to_string(indices)
self.report({"INFO"}, "Shifter: Set {} Vertices".format(size))
return {"FINISHED"}
def execute(self, context):
ob = context.object
if self.direction and ob is not None:
verts = bmesh.from_edit_mesh(ob.data).verts
cur_verts = from_string(eval("ob.shifter_{}_verts".format(self.direction)))
removed = 0
for v in verts:
if v.select and v.index in cur_verts:
cur_verts.remove(v.index)
removed += 1
exec("ob.shifter_{}_verts = to_string(list(cur_verts))".format(self.direction))
self.report({"INFO"}, "Shifter: Removed {} Vertices".format(removed))
return {"FINISHED"}
def initialise():
global_undo = bpy.context.user_preferences.edit.use_global_undo
bpy.context.user_preferences.edit.use_global_undo = False
object = bpy.context.active_object
if 'MIRROR' in [mod.type for mod in object.modifiers if mod.show_viewport]:
# ensure that selection is synced for the derived mesh
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.mode_set(mode='EDIT')
bm = bmesh.from_edit_mesh(object.data)
bm.verts.ensure_lookup_table()
bm.edges.ensure_lookup_table()
bm.faces.ensure_lookup_table()
return(global_undo, object, bm)
# move the vertices to their new locations
def get_mesh_vertices(myobj):
try:
if myobj.mode == 'EDIT':
bm = bmesh.from_edit_mesh(myobj.data)
obverts = bm.verts
else:
obverts = myobj.data.vertices
return obverts
except AttributeError:
return None
# --------------------------------------------------------------------
# Get position for scale text
#
# --------------------------------------------------------------------
def get_selected_faces_by_sel_seq(obj):
"""
get information about selected indices.
@param obj object
@return information about selected faces (list of SelectedFaceInfo)
"""
# get indices by selection sequence
bm = bmesh.from_edit_mesh(obj.data)
if check_version(2, 73, 0) >= 0:
bm.faces.ensure_lookup_table()
indices = [
e.loops[0].face.index
for e in bm.select_history
if isinstance(e, bmesh.types.BMFace) and e.select]
# get selected faces by selection sequence
return get_faces_from_indices(obj, indices)
def display_color_callback():
if bpy.context.object.mode == 'EDIT':
if display_color[0]:
ob = bpy.context.object
me = ob.data
bm = bmesh.from_edit_mesh(me)
quads = tris = ngons = 0
ngons_to_tris = 0
verts = len(bm.verts)
faces = len(bm.faces)
for f in bm.faces:
v = len(f.verts)
if v == 3: # tris
f.material_index = 2
elif v == 4: # quads
f.material_index = 0
elif v > 4: # ngons
f.material_index = 1
bmesh.update_edit_mesh(me)
def noise_obj(obj, context, self):
bm = bmesh.from_edit_mesh(obj.data)
verts = [v for v in bm.verts if v.select]
if not verts:
verts = [v for v in bm.verts if v.hide is False]
for vert in verts:
noise_pos = vert.co.copy()
noise_pos.x += self.offset_x
noise_pos.z += self.offset_y
noise_pos.z += self.offset_z
noise_val = None
if self.noise_type == 'Turbulence':
noise_val = mathu.noise.turbulence(noise_pos, self.octaves, self.hard, mathu.noise.types.STDPERLIN, self.amplitude_scale, self.frequency_scale)
elif self.noise_type == 'Fractal':
noise_val = mathu.noise.fractal(noise_pos, self.amplitude_scale, self.frequency_scale, self.octaves, mathu.noise.types.STDPERLIN)
else:
noise_val = mathu.noise.hetero_terrain(noise_pos, self.amplitude_scale, self.frequency_scale, self.octaves, 0, mathu.noise.types.STDPERLIN)
vert_offset = vert.normal.copy().normalized() * noise_val
vert.co += vert_offset * self.intensity
bm.normal_update()
bmesh.update_edit_mesh(obj.data)
def random_uvs(self, context):
import bpy
import bmesh
from mathutils import Vector
from random import uniform
bpy.ops.object.editmode_toggle()
bpy.ops.mesh.select_all(action="SELECT")
obj = bpy.context.object
me = obj.data
bm = bmesh.from_edit_mesh(me)
uv_layer = bm.loops.layers.uv.verify()
bm.faces.layers.tex.verify()
# adjust UVs
for f in bm.faces:
offset = Vector((uniform(-1.0, 1.0), uniform(-1.0, 1.0)))
for v in f.loops:
luv = v[uv_layer]
luv.uv = (luv.uv + offset).xy
bmesh.update_edit_mesh(me)
bpy.ops.object.editmode_toggle()
def side (self, nombre, offset):
bpy.ops.object.mode_set(mode="EDIT", toggle=0)
OBJECT = bpy.context.active_object
ODATA = bmesh.from_edit_mesh(OBJECT.data)
MODE = bpy.context.mode
bpy.context.tool_settings.mesh_select_mode = (True, False, False)
for VERTICE in ODATA.verts[:]:
VERTICE.select = False
if nombre == False:
for VERTICES in ODATA.verts[:]:
if VERTICES.co[0] < (offset):
VERTICES.select = 1
else:
for VERTICES in ODATA.verts[:]:
if VERTICES.co[0] > (offset):
VERTICES.select = 1
ODATA.select_flush(False)
bpy.ops.object.mode_set(mode="EDIT", toggle=0)
def execute(self, context):
active_obj = context.scene.objects.active
active_mesh = active_obj.data
select_and_change_mode(active_obj, 'EDIT')
edit_obj = bpy.context.edit_object
active_mesh = edit_obj.data
uv_layer_holdr1 = active_mesh.uv_textures.get(kWPLSmoothHolderUVMap1)
if uv_layer_holdr1 is None:
active_mesh.uv_textures.new(kWPLSmoothHolderUVMap1)
uv_layer_holdr2 = active_mesh.uv_textures.get(kWPLSmoothHolderUVMap2)
if uv_layer_holdr2 is None:
active_mesh.uv_textures.new(kWPLSmoothHolderUVMap2)
bm = bmesh.from_edit_mesh(active_mesh)
bm.verts.ensure_lookup_table()
bm.faces.ensure_lookup_table()
bm.verts.index_update()
uv_layer_holdr1 = bm.loops.layers.uv.get(kWPLSmoothHolderUVMap1)
uv_layer_holdr2 = bm.loops.layers.uv.get(kWPLSmoothHolderUVMap2)
for face in bm.faces:
for vert, loop in zip(face.verts, face.loops):
loop[uv_layer_holdr1].uv = (vert.co[0],vert.co[1])
loop[uv_layer_holdr2].uv = (vert.co[2],0)
return {'FINISHED'}
def remove_doubles(obj,edge_average_len,edge_min_len):
bm = bmesh.from_edit_mesh(obj.data)
verts = []
for vert in bm.verts:
if not vert.hide:
verts.append(vert)
bmesh.ops.remove_doubles(bm,verts=verts,dist=0.0001)
bmesh.update_edit_mesh(obj.data)
def reproject(self,context):
### unwrap
obj = context.active_object
hide_base_sprite = obj.data.coa_hide_base_sprite
obj.data.coa_hide_base_sprite = False
bm = bmesh.from_edit_mesh(obj.data)
selected_edges = []
for edge in bm.edges:
if edge.select:
selected_edges.append(edge)
unselected_verts = []
for vert in bm.verts:
if not vert.select:
unselected_verts.append(vert)
vert.select = True
unselected_faces = []
for face in bm.faces:
if not face.select:
unselected_faces.append(face)
face.select = True
bpy.ops.uv.project_from_view(camera_bounds=False, correct_aspect=True, scale_to_bounds=True)
for edge in selected_edges:
edge.select = True
for vert in unselected_verts:
vert.select = False
for face in unselected_faces:
face.select = False
bmesh.update_edit_mesh(obj.data)
obj.data.coa_hide_base_sprite = hide_base_sprite
def normal_fill(self,context):
obj = context.active_object
bpy.ops.mesh.edge_face_add()
bpy.ops.uv.project_from_view(camera_bounds=False, correct_aspect=True, scale_to_bounds=True)
self.reset_spritesheet(context,obj)
bm = bmesh.from_edit_mesh(obj.data)
unselected_faces = []
for face in bm.faces:
if face.select == False:
unselected_faces.append(face)
face.select = True
bpy.ops.uv.project_from_view(camera_bounds=False, correct_aspect=True, scale_to_bounds=True)
for face in unselected_faces:
face.select = False
bmesh.update_edit_mesh(obj.data)
self.revert_rest_spritesheet(context,obj)
def set_bone_shape_color_and_wireframe(self,context,obj):
if self.bone.bone_group != None:
bone_group_name = self.bone.bone_group.name
bone_group_color = self.bone.bone_group.colors.normal
suffix = "_group_color"
if (bone_group_name+suffix) not in bpy.data.materials:
material = bpy.data.materials.new(bone_group_name+suffix)
else:
material = bpy.data.materials[bone_group_name+suffix]
material.diffuse_color = bone_group_color
material.use_shadeless = True
if len(obj.material_slots) == 0:
obj.data.materials.append(material)
else:
obj.material_slots[0].material = material
else:
if len(obj.material_slots) > 0:
obj.material_slots[0].material = None
bm = bmesh.from_edit_mesh(obj.data)
if len(bm.faces) > 0:
self.armature.data.bones[self.bone.name].show_wire = False
else:
self.armature.data.bones[self.bone.name].show_wire = True
bm.free()
def get_selected_vert_pos(self,context):
bm = bmesh.from_edit_mesh(context.active_object.data)
for vert in bm.verts:
if vert.select == True:
bmesh.update_edit_mesh(context.active_object.data)
return vert.co
bmesh.update_edit_mesh(context.active_object.data)
return None
