def execute(self, context): def close_rigify(meta): """Close Rigify Layers panel by default""" text = meta.data.rigify_rig_ui for (index, line) in enumerate(text.lines): if (line.body == "class RigLayers(bpy.types.Panel):"): text.cursor_set(index + 6) # bl_category = 'Item' text.write(" bl_options = {'DEFAULT_CLOSED'}\n") return True for daz in context.selected_objects: (meta, daz) = self.poll_parse(context, daz) if None in (meta, daz): continue layers_extra = get_layers_extra(meta) Set.active(context, meta) bpy.ops.pose.rigify_generate() close_rigify(meta) rig = context.active_object meta_to_rigify(daz, rig) adjust_rigify(rig) set_layers_extra(rig, layers_extra) return {'FINISHED'}
def execute(self, context): active = Get.active(context) active_select = Is.selected(active) selected = Get.selected(context) is_pose = bool(context.mode == 'POSE') arg = dict(only_selected=bool(selected)) if is_pose: clear = bpy.ops.pose.paths_clear # Operator only runs on active rig, so repeat for all in pose mode if selected: obs = {b.id_data for b in selected} else: obs = {ob for ob in Get.objects(context) if ob.mode == 'POSE'} for ob in obs: Set.active(context, ob) clear(**arg) else: Set.active(context, active) Set.select(active, active_select) elif bpy.ops.object.paths_clear.poll(context.copy()): bpy.ops.object.paths_clear(**arg) return {'FINISHED'}
def execute(self, context): (rig, mesh) = self.get_rig_mesh(context) # Switch to object mode first, to prevent sending rig to empty mode # happens when switching from Armature Edit to Weight Paint (warning but no error) # from there, trying to change the armature mode gives error after fixing the mode bpy.ops.object.mode_set(mode='OBJECT') if self.mode == 'POSE': Set.active(context, rig) return bpy.ops.object.mode_set(mode='POSE') elif self.mode == 'EDIT_ARMATURE': Set.active(context, rig) return bpy.ops.object.mode_set(mode='EDIT') elif self.mode == 'WEIGHT_PAINT': Set.active(context, mesh) return bpy.ops.object.mode_set(mode='WEIGHT_PAINT') elif self.mode == 'EDIT_MESH': Set.active(context, mesh) return bpy.ops.object.mode_set(mode='EDIT') elif self.mode == 'SCULPT': Set.active(context, mesh) return bpy.ops.object.mode_set(mode='SCULPT') return {'PASS_THROUGH'}
def returnToArmature(context, widget): bone = fromWidgetFindBone(widget) armature = bone.id_data # Unhide collection if it was hidden in a previous run if widget.users_collection: # Try to use the widget's collection collection = widget.users_collection[0] else: # otherwise use default collection = get_collection(context) Set.visible(context, collection) Set.mode(context, 'OBJECT', widget) # collection = get_collection(context) if [x for x in armature.users_collection if x != collection]: # Don't hide the active collection collection.hide_viewport = True "New version doesn't have this" # get_collection_view_layer(collection).hide_viewport = True if getattr(context.space_data, 'local_view', None): bpy.ops.view3d.localview() Set.active(context, armature) Set.select(armature, True) Set.mode(context, 'POSE', armature) # Set.select(bone, True) # Set.active(context, bone) armature.data.bones[bone.name].select = True armature.data.bones.active = armature.data.bones[bone.name]
def editWidget(context, active_bone): widget = active_bone.custom_shape armature = active_bone.id_data Set.mode(context, 'OBJECT', armature) Set.select(armature, False) ''' # 2.7 if context.space_data.lock_camera_and_layers == False : visibleLayers = numpy.array(bpy.context.space_data.layers)+widget.layers-armature.layers bpy.context.space_data.layers = visibleLayers.tolist() else : visibleLayers = numpy.array(bpy.context.scene.layers)+widget.layers-armature.layers bpy.context.scene.layers = visibleLayers.tolist() ''' "Commented because the new version only uses get_collection" if widget.users_collection: collection = widget.users_collection[0] else: collection = get_collection(context) collection.objects.link(widget) Set.in_scene(context, collection) Set.visible(context, collection) "Commented because new version uses operator" # get_collection_view_layer(collection).hide_viewport = False if getattr(context.space_data, 'local_view', None): bpy.ops.view3d.localview() # select object and make it active Set.select(widget, True) Set.active(context, widget) Set.mode(context, 'EDIT', widget)
def invoke(self, context, event): if event.alt: active = context.object for ob in context.selected_objects: if Is.mesh(ob) and (ob.data.shape_keys): Set.active(context, ob) self.purge(ob) Set.active(context, active) else: self.purge(context.object) return {'FINISHED'}
def execute(self, context): rig = context.active_object active = None if context.mode == 'PAINT_WEIGHT': for obj in context.selected_objects: if obj.type == 'ARMATURE': active = rig rig = obj Set.active(context, rig) # if rig.type =='ARMATURE' and context.mode != 'EDIT_ARMATURE': meshes = self.get_meshes(context, rig) bone1 = context.active_pose_bone # bone2 = context.selected_pose_bones[1] for bone2 in context.selected_pose_bones: if bone2 == bone1: continue found = None for mesh in meshes: utils.merge_vertex_groups( mesh, bone1.name, bone2.name, # If remove is False, and the bone stayed, it would be equivalent to transferring only partial weights remove=(self.mode == 'remove')) found = True # if found: # if self.mode == 'hide': # bone2.hide = True # elif self.mode == 'show': # bone2.hide = False # elif self.mode == 'remove': if (found and self.mode == 'remove'): for ch in bone2.id_data.children: if (ch.parent_type == 'BONE') and (ch.parent_bone == bone2.name): mat = Get.matrix(ch) ch.parent_bone = bone1.name Set.matrix(ch, mat) name2 = bone2.name Set.mode(context, mode='EDIT') bone2 = rig.data.edit_bones[name2] rig.data.edit_bones.remove(bone2) Set.mode(context, mode='POSE') if active: Set.active(context, active) return {'FINISHED'}
def execute(self, context): active = obj = context.object transfer = bpy.ops.object.data_transfer if (not Is.mesh(obj)) or getattr(obj, 'DazMannequin', False): # redesignate obj obj = None for o in context.selected_objects: if Is.mesh(o) and (not getattr(o, 'DazMannequin', False)): obj = o Set.active(context, o) break if not all(( obj, obj.data.polygons, transfer.poll(context.copy()), )): self.report({'INFO'}, "Only Mannequins Selected") return {'CANCELLED'} mesh = obj.data if mesh.polygons[0].use_smooth: # only check one face, rather than all bpy.ops.object.shade_smooth() if mesh.use_auto_smooth: transfer(data_type='CUSTOM_NORMAL') for o in context.selected_objects: if Is.mesh(o): o.data.use_auto_smooth = True if obj.vertex_groups: # Vertex groups add to file size, so don't keep them for everything transfer(data_type='VGROUP_WEIGHTS', layers_select_src='ALL', layers_select_dst='NAME') if mesh.vertex_colors: transfer(data_type='VCOL', layers_select_src='ALL', layers_select_dst='NAME') if mesh.uv_layers: transfer(data_type='UV', layers_select_src='ALL', layers_select_dst='NAME') Set.active(context, active) return {'FINISHED'}
def execute(self, context): area = context.area view = area.spaces.active reg = view.region_3d # Create new camera object, add to scene, and select it camo = New.camera(context, name="Viewport", size=0.5) cam = camo.data Set.active(context, camo) # Set.active_select(camo) # Set Lock viewport to the camera view.camera = camo view.use_local_camera = True view.lock_camera = True # Send camera object to the current viewport rotation/location Set.matrix(camo, reg.view_matrix.inverted()) # Switch to camera view if reg.view_perspective != 'CAMERA': bpy.ops.view3d.view_camera() # run op to prevent changing the (actual) viewport's position # reg.view_perspective = 'CAMERA' # Mirror viewport properties to the camera cam.lens = view.lens / 2 cam.clip_start = view.clip_start cam.clip_end = view.clip_end # Re-center the camera view window if it was changed bpy.ops.view3d.view_center_camera() # reg.view_camera_offset = [0.0, 0.0] # reg.view_camera_zoom = 28 # Setup Deph of Field cam.dof.use_dof = True # cam.dof.aperture_fstop = 0.5 # Blur amount # cam.dof.aperture_fstop = 2.8 # cam.dof.focus_distance = reg.view_distance bpy.ops.ui.eyedropper_depth('INVOKE_DEFAULT') return {'FINISHED'}
def execute(self, context): active = Get.active(context) mode = context.mode pose = list() for rig in context.selected_objects: (rig, meta) = self.poll_parse(context, rig) if None in (rig, meta): continue rigify_to_meta(rig, meta) pose.append((meta, rig)) else: if mode == 'POSE': Set.mode(context, 'OBJECT') for (meta, rig) in pose: Set.select(rig, False) Set.select(meta, True) if rig == active: Set.active(context, meta) if mode == 'POSE': Set.mode(context, 'POSE') return {'FINISHED'}
def execute(self, context): scn = context.scene active = Get.active(context) selected = Get.selected(context) is_pose = bool(context.mode == 'POSE') if not is_pose: self.use_tails = False mode = ('HEADS', 'TAILS')[self.use_tails] # Use the line thickness of the active item, across the selection if getattr(active, 'motion_path', None): line = active.motion_path.line_thickness else: line = 1 colors = dict() types = dict() for src in Get.selected(context): mp = src.motion_path if not mp: continue if mp.use_custom_color: colors[src] = mp.color if Is.posebone(src): display = src.id_data.pose.animation_visualization.motion_path else: display = src.animation_visualization.motion_path types[src] = display.type # Get the frame range to bake motion paths in motion = utils.prefs(__package__).motion if self.use_start_end: start = self.start_frame end = self.end_frame elif (motion.use_relative_range) or (scn.use_preview_range): start = scn.frame_preview_start end = scn.frame_preview_end fc = scn.frame_current fb = motion.frame_before fa = motion.frame_after if not (scn.use_preview_range) or (abs(end - start) > 100 > (fb + fa)): # If the preview range is too high, just default to nearby start = fc - fb end = fc + fa else: # if (active): # # Use the active object's motion path's in_range distance # if (Is.posebone(active)): # mp = active.id_data.pose.animation_visualization.motion_path # else: # mp = active.animation_visualization.motion_path # fb = mp.frame_before # fa = mp.frame_after # if (fb < 25): fb = 25 # if (fa < 25): fa = 25 # start = scn.frame_current - fb # end = scn.frame_current + fa start = scn.frame_start end = scn.frame_end fc = scn.frame_current if 150 < abs(end - start): start = fc - 50 end = fc + 50 # Create the motion paths args = dict(start_frame=start, end_frame=end + 1) if is_pose: op = bpy.ops.pose args['bake_location'] = mode # Operator only runs on active rig, so repeat for all in pose mode obs = {b.id_data for b in selected} for ob in obs: Set.active(context, ob) op.paths_clear(only_selected=True) op.paths_calculate(**args) else: Set.active(context, active) else: op = bpy.ops.object op.paths_clear(only_selected=True) op.paths_calculate(**args) for src in selected: mp = src.motion_path if not mp: continue mp.line_thickness = line color = colors.get(src) if color: mp.color = color if Is.posebone(src): display = src.id_data.pose.animation_visualization.motion_path else: display = src.animation_visualization.motion_path display.type = types.get(src, 'CURRENT_FRAME') # Set to use the frame hider instead of ever displaying all points # if is_pose: # src.id_data.pose.animation_visualization. \ # motion_path.type = 'CURRENT_FRAME' # else: # src.animation_visualization. \ # motion_path.type = 'CURRENT_FRAME' # scn.frame_set(scn.frame_current) return {'FINISHED'}
def execute(self, context): (rig, meshes) = self.get_rig_meshes(context) if not (rig and meshes): return {'CANCELLED'} use_mask = bool((self.from_active or self.normalize_active)) active = context.object active_bone = context.active_pose_bone.bone mode = active.mode pose = rig.data.pose_position scale = rig.scale.copy() if use_mask: active_bone.select = False Set.mode(context, 'OBJECT') rig.data.pose_position = 'REST' rig.scale *= 50 for mesh in meshes: mscale = mesh.scale.copy() mp = mesh.parent while mp and mp != rig: # Sort through mesh parent hierarchy to find if the rig is a parent somewhere in there mp = mp.parent if mp != rig: # The rig/parent is already scaled, so don't scale mesh again mesh.scale *= 50 Set.active(context, mesh) Set.mode(context, 'WEIGHT_PAINT') vg = mesh.vertex_groups bone_group = vg.get(active_bone.name) do_bone = bool((use_mask and bone_group)) mindex = vg.active_index bpy.ops.paint.weight_from_bones(type='AUTOMATIC') if do_bone: vg.active_index = mindex bpy.ops.object.vertex_group_invert() for b in context.selected_pose_bones: utils.subtract_vertex_groups(mesh, active_bone.name, b.name) bpy.ops.object.vertex_group_invert() if self.normalize_active: for b in context.selected_pose_bones: utils.subtract_vertex_groups(mesh, b.name, active_bone.name) if (mindex != -1): vg.active_index = mindex Set.mode(context, 'OBJECT') mesh.scale = mscale Set.active(context, active) rig.scale = scale rig.data.pose_position = pose Set.mode(context, mode) if use_mask: active_bone.select = True if len(meshes) > 1: self.report({'INFO'}, f"Assigned weights to {len(meshes)} meshes") else: self.report({'INFO'}, f"Assigned weights to {list(meshes)[0].name}") return {'FINISHED'}
def execute(self, context): active = obj = context.object if (not Is.mesh(obj)) or getattr(obj, 'DazMannequin', False): obj = None for o in context.selected_objects: if Is.mesh(o) and (not getattr(o, 'DazMannequin', False)): obj = o Set.active(context, obj) break if not (obj and obj.data.polygons): self.report({'INFO'}, "Only Mannequins Selected") return {'CANCELLED'} elif not obj.data.materials: self.report({'INFO'}, "Mesh doesn't have any materials to transfer") return {'CANCELLED'} def getface(f, o): r = self.Round area = round(f.area, r) center = utils.multiply_matrix(o.matrix_world, f.center) center = tuple([round(a, r) for a in center]) return (area, center) mesh = obj.data # obj_faces = { # # getface(f, obj): obj.material_slots[f.material_index].material # getface(f, obj): mesh.materials[f.material_index] # for f in mesh.polygons # } obj_faces = dict() count = 0 total = len(mesh.polygons) for (i, f) in enumerate(mesh.polygons): perc = round(((i + 1) / total * 100)) log = f"\rGetting face ids ({obj.name}): {count}/{total} ({perc}%)" print(log + " [old_mats]", end="") obj_faces[getface(f, obj)] = mesh.materials[f.material_index] count += 1 count_obj = 0 total_obj = len(context.selected_objects) - 1 for (i, o) in enumerate(context.selected_objects): if (o == obj) or (not Is.mesh(o)): continue omesh = o.data perc_obj = round(((i + 1) / total_obj * 100)) log = f"\rTransferring materials ({o.name}): {count_obj}/{total_obj} ({perc_obj}%)" print(log + " [old_mats]", end="") old_mats = {i: m for i, m in enumerate(omesh.materials)} print(log + " [for face in mesh.polygons]", end="") # count = 0 # total = len(omesh.polygons) for face in omesh.polygons: mat_i = obj_faces.get(getface(face, o)) if mat_i is None: # old_mats.pop(face.material_index) continue if mat_i.name not in omesh.materials: omesh.materials.append(mat_i) for (i, mat) in enumerate(o.material_slots): if mat.material == mat_i: face.material_index = i if i in old_mats: old_mats.pop(face.material_index) break print(log + " [for i in old_mats]", end="") for i in reversed(list(old_mats)): o.data.materials.pop(index=i) count_obj += 1 else: print( f"\rTransferred {count_obj}/{total_obj} materials from {obj.name}", " " * 20) Set.active(context, active) return {'FINISHED'}