def _apply_individual_grip(self, armature_object): _LOG.enter() for finger_number in [1, 2, 3, 4, 5]: self._create_grip_bone(finger_number, armature_object) grip_name = self._get_grip_bone_name_for_finger(finger_number) bpy.ops.object.mode_set(mode='EDIT', toggle=False) parent_name = self.get_immediate_parent_name_of_finger(finger_number) parent_bone = RigService.find_edit_bone_by_name(parent_name, armature_object) grip_bone = RigService.find_edit_bone_by_name(grip_name, armature_object) grip_bone.parent = parent_bone bpy.ops.object.mode_set(mode='OBJECT', toggle=False) bpy.ops.object.mode_set(mode='POSE', toggle=False) finger_segments = self.get_reverse_list_of_bones_in_finger(finger_number) for bone_name in finger_segments: constraint = RigService.add_copy_rotation_constraint_to_pose_bone(bone_name, grip_name, armature_object, copy_y=False, copy_z=False) constraint.influence = 1.0 / len(finger_segments) bone_name = finger_segments[-1] constraint = RigService.add_copy_rotation_constraint_to_pose_bone(bone_name, grip_name, armature_object, copy_x=False) if self.settings["hide_fk"]: self._hide_bones(armature_object, finger_segments)
def _set_parent(self, armature_object, has_elbow_ik=False, has_shoulder_ik=False): _LOG.enter() bpy.ops.object.mode_set(mode='OBJECT', toggle=False) bpy.ops.object.mode_set(mode='EDIT', toggle=False) if not "arm_parenting_strategy" in self.settings: return strategy = self.settings["arm_parenting_strategy"] if not strategy or strategy == "NONE": return hand_ik = RigService.find_edit_bone_by_name(self.which_arm + "_hand_ik", armature_object) elbow_ik = None shoulder_ik = None if has_elbow_ik: elbow_ik = RigService.find_edit_bone_by_name(self.which_arm + "_elbow_ik", armature_object) if has_shoulder_ik: shoulder_ik = RigService.find_edit_bone_by_name(self.which_arm + "_shoulder_ik", armature_object) if strategy == "ROOT": root_bone = RigService.find_edit_bone_by_name(self.get_root(), armature_object) hand_ik.parent = root_bone if elbow_ik: elbow_ik.parent = root_bone if shoulder_ik: shoulder_ik.parent = root_bone if strategy == "SPINE": spine_bone = RigService.find_edit_bone_by_name(self.get_shoulders_immediate_parent(), armature_object) hand_ik.parent = spine_bone if elbow_ik: elbow_ik.parent = spine_bone if shoulder_ik: shoulder_ik.parent = spine_bone if strategy == "OUTER": if elbow_ik: elbow_ik.parent = hand_ik if shoulder_ik: shoulder_ik.parent = elbow_ik if strategy == "INNER": if elbow_ik: hand_ik.parent = elbow_ik if shoulder_ik: elbow_ik.parent = shoulder_ik bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
def _set_parent(self, armature_object, has_knee_ik=False, has_hip_ik=False): bpy.ops.object.mode_set(mode='OBJECT', toggle=False) bpy.ops.object.mode_set(mode='EDIT', toggle=False) if not "leg_parenting_strategy" in self.settings: return strategy = self.settings["leg_parenting_strategy"] if not strategy or strategy == "NONE": return foot_ik = RigService.find_edit_bone_by_name( self.which_leg + "_foot_ik", armature_object) knee_ik = None hip_ik = None if has_knee_ik: knee_ik = RigService.find_edit_bone_by_name( self.which_leg + "_knee_ik", armature_object) if has_hip_ik: hip_ik = RigService.find_edit_bone_by_name( self.which_leg + "_hip_ik", armature_object) if strategy == "ROOT": root_bone = RigService.find_edit_bone_by_name( self.get_root(), armature_object) foot_ik.parent = root_bone if knee_ik: knee_ik.parent = root_bone if hip_ik: hip_ik.parent = root_bone if strategy == "OUTER": if knee_ik: knee_ik.parent = foot_ik if hip_ik: hip_ik.parent = knee_ik if strategy == "INNER": if knee_ik: foot_ik.parent = knee_ik if hip_ik: knee_ik.parent = hip_ik bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
def execute(self, context): _LOG.enter() _LOG.debug("click") blender_object = context.active_object bpy.ops.object.mode_set(mode='EDIT', toggle=False) ball_r = RigService.find_edit_bone_by_name("ball_r", blender_object) bpy.ops.object.mode_set(mode='OBJECT', toggle=False) if not ball_r: self.report( {'ERROR'}, "Only the \"Game engine\" skeleton is supported so far") return {'FINISHED'} bpy.ops.object.transform_apply(location=True, scale=False, rotation=False) from mpfb.ui.rigify.rigifypanel import RIGIFY_PROPERTIES settings = RIGIFY_PROPERTIES.as_dict(entity_reference=context.scene) helpers = RigifyHelpers.get_instance(settings) helpers.convert_to_rigify(blender_object) self.report({'INFO'}, "Converted to rigify") return {'FINISHED'}
def _clear_finger_ik(self, finger_number, armature_object): _LOG.enter() bpy.ops.object.mode_set(mode='EDIT', toggle=False) bone_name = self._get_point_ik_bone_name_for_finger(finger_number) bone = RigService.find_edit_bone_by_name(bone_name, armature_object) _LOG.debug("Point bone to remove, if any", bone) if bone: armature_object.data.edit_bones.remove(bone)
def _clear_master_grip(self, armature_object): bone_name = self._get_master_grip_bone_name() bpy.ops.object.mode_set(mode='EDIT', toggle=False) bone = RigService.find_edit_bone_by_name(bone_name, armature_object) _LOG.debug("Master grip bone to remove, if any", bone) if bone: armature_object.data.edit_bones.remove(bone) bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
def reposition_edit_bone(self): """Reposition bones to fit the current state of the basemesh.""" bpy.ops.object.mode_set(mode='EDIT', toggle=False) for bone_name in self.rig_definition.keys(): bone_info = self.rig_definition[bone_name] bone = RigService.find_edit_bone_by_name(bone_name, self.armature_object) bone.head = self._get_best_location_from_strategy(bone_info["head"]) bone.tail = self._get_best_location_from_strategy(bone_info["tail"]) bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
def _apply_point(self, armature_object): _LOG.enter() for finger_number in [1, 2, 3, 4, 5]: self._create_point_ik_bone(finger_number, armature_object) ik_name = self._get_point_ik_bone_name_for_finger(finger_number) bpy.ops.object.mode_set(mode='EDIT', toggle=False) parent_name = self.get_immediate_parent_name_of_finger(finger_number) parent_bone = RigService.find_edit_bone_by_name(parent_name, armature_object) ik_bone = RigService.find_edit_bone_by_name(ik_name, armature_object) ik_bone.parent = parent_bone chain_length = self.get_finger_segment_count(finger_number) self._set_finger_ik_target(finger_number, armature_object, chain_length) if self.settings["hide_fk"]: bones_to_hide = self.get_reverse_list_of_bones_in_finger(finger_number) self._hide_bones(armature_object, bones_to_hide)
def update_edit_bone_metadata(self): """Assign metadata fitting for the edit bones.""" bpy.ops.object.mode_set(mode='EDIT', toggle=False) for bone_name in self.rig_definition.keys(): bone_info = self.rig_definition[bone_name] bone = RigService.find_edit_bone_by_name(bone_name, self.armature_object) if bone_info["parent"]: bone.parent = RigService.find_edit_bone_by_name(bone_info["parent"], self.armature_object) bone.use_connect = bone_info["use_connect"] bone.use_local_location = bone_info["use_local_location"] bone.use_inherit_rotation = bone_info["use_inherit_rotation"] bone.inherit_scale = bone_info["inherit_scale"] if "layers" in bone_info: i = 0 for layer in bone_info["layers"]: bone.layers[i] = layer i = i + 1 bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
def _create_master_grip_bone(self, armature_object): _LOG.enter() bpy.ops.object.mode_set(mode='EDIT', toggle=False) finger3_tip_name = self.get_last_segment_name_of_finger(3) finger4_tip_name = self.get_last_segment_name_of_finger(4) finger3_root_name = self.get_first_segment_name_of_finger(3) finger4_root_name = self.get_first_segment_name_of_finger(4) roll = self._bone_info["edit_bones"][finger3_root_name]["roll"] finger3_head = self._bone_info["edit_bones"][finger3_root_name]["head"] finger3_tail = self._bone_info["edit_bones"][finger3_tip_name]["tail"] finger4_head = self._bone_info["edit_bones"][finger4_root_name]["head"] finger4_tail = self._bone_info["edit_bones"][finger4_tip_name]["tail"] head = (finger3_head + finger4_head) / 2 tail = (finger3_tail + finger4_tail) / 2 bone_name = self._get_master_grip_bone_name() bones = armature_object.data.edit_bones bone = bones.new(bone_name) bone.head = head bone.tail = tail bone.roll = roll parent_name = self.get_immediate_parent_name_of_finger(3) parent_bone = RigService.find_edit_bone_by_name(parent_name, armature_object) bone.parent = parent_bone # Needed to save bone bpy.ops.object.mode_set(mode='OBJECT', toggle=False) bpy.ops.object.mode_set(mode='POSE', toggle=False) pose_bone = RigService.find_pose_bone_by_name(bone_name, armature_object) root_bone3 = RigService.find_pose_bone_by_name(finger3_root_name, armature_object) root_bone4 = RigService.find_pose_bone_by_name(finger4_root_name, armature_object) pose_bone.location = (root_bone3.location + root_bone4.location) / 2 RigService.display_pose_bone_as_empty(armature_object, bone_name, 'CIRCLE') pose_bone.custom_shape_scale = 0.6 for i in range(3): pose_bone.lock_location[i] = True pose_bone.lock_scale[i] = True
def execute(self, context): _LOG.enter() armature_object = context.object bpy.ops.object.mode_set(mode='EDIT', toggle=False) levator = RigService.find_edit_bone_by_name("levator03.L", armature_object) bpy.ops.object.mode_set(mode='OBJECT', toggle=False) if not levator: self.report({ 'ERROR' }, "Only the \"Default\" and \"Default no toes\" skeletons are supported so far" ) return {'FINISHED'} from mpfb.ui.righelpers.righelperspanel import SETUP_HELPERS_PROPERTIES # pylint: disable=C0415 settings = SETUP_HELPERS_PROPERTIES.as_dict( entity_reference=context.scene) if "arm_helpers_type" in settings and settings[ "arm_helpers_type"] and settings["arm_helpers_type"] != "NONE": _LOG.debug("Adding arm helpers:", settings["arm_helpers_type"]) self._arm_helpers(armature_object, settings) else: _LOG.debug("Not adding arm helpers") if "leg_helpers_type" in settings and settings[ "leg_helpers_type"] and settings["leg_helpers_type"] != "NONE": _LOG.debug("Adding leg helpers:", settings["leg_helpers_type"]) self._leg_helpers(armature_object, settings) else: _LOG.debug("Not adding leg helpers") if "finger_helpers_type" in settings and settings[ "finger_helpers_type"] and settings[ "finger_helpers_type"] != "NONE": _LOG.debug("Adding finger helpers:", settings["finger_helpers_type"]) self._finger_helpers(armature_object, settings) else: _LOG.debug("Not adding finger helpers") if "eye_ik" in settings and settings["eye_ik"]: _LOG.debug("Adding eye ik") self._eye_helpers(armature_object, settings) else: _LOG.debug("Not adding eye ik") self.report({'INFO'}, "Helpers were added") return {'FINISHED'}
def execute(self, context): scene = context.scene if not ObjectService.object_is_skeleton(context.active_object): self.report({'ERROR'}, "Must have armature object selected") return {'FINISHED'} from mpfb.ui.addrig.addrigpanel import ADD_RIG_PROPERTIES # pylint: disable=C0415 armature_object = context.active_object delete_after_generate = ADD_RIG_PROPERTIES.get_value( "delete_after_generate", entity_reference=scene) bpy.ops.pose.rigify_generate() rigify_object = context.active_object rigify_object.show_in_front = True _LOG.debug("rigify", rigify_object) for child in ObjectService.get_list_of_children(armature_object): child.parent = rigify_object for bone in armature_object.data.bones: name = bone.name if name in child.vertex_groups and not "teeth" in name: vertex_group = child.vertex_groups.get(name) vertex_group.name = "DEF-" + name for modifier in child.modifiers: if modifier.type == 'ARMATURE': modifier.object = rigify_object if delete_after_generate: objs = bpy.data.objects objs.remove(objs[armature_object.name], do_unlink=True) bpy.ops.object.mode_set(mode='EDIT', toggle=False) teethb = RigService.find_edit_bone_by_name("teeth.B", rigify_object) teethb.use_deform = True bpy.ops.object.mode_set(mode='OBJECT', toggle=False) self.report({'INFO'}, "A rig was generated") return {'FINISHED'}
def _set_use_connect_on_bones(self, armature_object, bone_names, exclude_first=True): _LOG.enter() bpy.ops.object.mode_set(mode='EDIT', toggle=False) if exclude_first: bone_names = list( bone_names) # to modify a copy rather than the source list bone_names.pop(0) for bone_name in bone_names: _LOG.debug("About to set use_connect on", bone_name) edit_bone = RigService.find_edit_bone_by_name( bone_name, armature_object) edit_bone.use_connect = True bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
def remove_ik(self, armature_object): """Remove rig helpers for arms and hands based on the settings that were provided when constructing the class, and information about the current status of the armature object.""" _LOG.enter() self._bone_info = RigService.get_bone_orientation_info_as_dict(armature_object) mode = str(RigHelpersProperties.get_value("arm_mode", entity_reference=armature_object)).strip() _LOG.debug("mode is", mode) include_shoulder = False if mode == "LOWERUPPERSHOULDER": include_shoulder = True if mode == "SHOULDERCHAIN": include_shoulder = True bpy.ops.object.mode_set(mode='POSE', toggle=False) bones_to_clear = self.get_reverse_list_of_bones_in_arm(True, True, True, include_shoulder) for bone_name in bones_to_clear: _LOG.debug("Will attempt to clear constraints from", bone_name) RigService.remove_all_constraints_from_pose_bone(bone_name, armature_object) self._show_bones(armature_object, bones_to_clear) bpy.ops.object.mode_set(mode='EDIT', toggle=False) ik_bones = [ self.which_arm + "_hand_ik", self.which_arm + "_elbow_ik", self.which_arm + "_shoulder_ik" ] for bone_name in ik_bones: bone = RigService.find_edit_bone_by_name(bone_name, armature_object) if bone: armature_object.data.edit_bones.remove(bone) bpy.ops.object.mode_set(mode='OBJECT', toggle=False) _LOG.debug("Done")
def remove_ik(self, armature_object): """Remove rig helpers for hips, legs and feet based on the settings that were provided when constructing the class, and information about the current status of the armature object.""" _LOG.enter() mode = str( RigHelpersProperties.get_value( "leg_mode", entity_reference=armature_object)).strip() _LOG.debug("mode is", mode) include_hip = mode == "LOWERUPPERHIP" bpy.ops.object.mode_set(mode='POSE', toggle=False) bones_to_clear = self.get_reverse_list_of_bones_in_leg( True, True, True, include_hip) for bone_name in bones_to_clear: _LOG.debug("Will attempt to clear constraints from", bone_name) RigService.remove_all_constraints_from_pose_bone( bone_name, armature_object) self._show_bones(armature_object, bones_to_clear) bpy.ops.object.mode_set(mode='EDIT', toggle=False) ik_bones = [ self.which_leg + "_foot_ik", self.which_leg + "_knee_ik", self.which_leg + "_hip_ik" ] for bone_name in ik_bones: bone = RigService.find_edit_bone_by_name(bone_name, armature_object) if bone: armature_object.data.edit_bones.remove(bone) bpy.ops.object.mode_set(mode='OBJECT', toggle=False) _LOG.debug("Done")
def remove_ik(self, armature_object): """Remove rig helpers for eyes based on the settings that were provided when constructing the class, and information about the current status of the armature object.""" _LOG.enter() bpy.ops.object.mode_set(mode='POSE', toggle=False) for bone_name in [self.get_eye_name(True), self.get_eye_name(False)]: RigService.remove_all_constraints_from_pose_bone( bone_name, armature_object) bpy.ops.object.mode_set(mode='EDIT', toggle=False) for bone_name in ["left_eye_ik", "right_eye_ik", "eye_ik"]: bone = RigService.find_edit_bone_by_name(bone_name, armature_object) armature_object.data.edit_bones.remove(bone) bpy.ops.object.mode_set(mode='OBJECT', toggle=False) _LOG.debug("Done")
def execute(self, context): scene = context.scene if not ObjectService.object_is_basemesh(context.active_object): self.report({'ERROR'}, "Rigs can only be added to the base mesh") return {'FINISHED'} basemesh = context.active_object from mpfb.ui.addrig.addrigpanel import ADD_RIG_PROPERTIES # pylint: disable=C0415 import_weights = ADD_RIG_PROPERTIES.get_value("import_weights_rigify", entity_reference=scene) generate = ADD_RIG_PROPERTIES.get_value("generate", entity_reference=scene) delete_after_generate = ADD_RIG_PROPERTIES.get_value( "delete_after_generate", entity_reference=scene) rigs_dir = LocationService.get_mpfb_data("rigs") rigify_dir = os.path.join(rigs_dir, "rigify") rig_file = os.path.join(rigify_dir, "rig.human.json") rig = Rig.from_json_file_and_basemesh(rig_file, basemesh) armature_object = rig.create_armature_and_fit_to_basemesh() armature_object.data.rigify_rig_basename = "Human.rigify" rigify_ui = dict() layer_file = os.path.join(rigify_dir, "rigify_layers.json") with open(layer_file, "r") as json_file: rigify_ui = json.load(json_file) bpy.ops.armature.rigify_add_bone_groups() bpy.ops.pose.rigify_layer_init() armature_object.data.rigify_colors_lock = rigify_ui[ "rigify_colors_lock"] armature_object.data.rigify_selection_colors.select = rigify_ui[ "selection_colors"]["select"] armature_object.data.rigify_selection_colors.active = rigify_ui[ "selection_colors"]["active"] i = 0 for color in armature_object.data.rigify_colors: col = rigify_ui["colors"][i] color.name = col["name"] color.normal = col["normal"] i = i + 1 i = 0 for rigify_layer in armature_object.data.layers: armature_object.data.layers[i] = rigify_ui["layers"][i] i = i + 1 i = 0 for rigify_layer in armature_object.data.rigify_layers: layer = rigify_ui["rigify_layers"][i] rigify_layer.name = layer["name"] rigify_layer.row = layer["row"] rigify_layer.selset = layer["selset"] rigify_layer.group = layer["group"] i = i + 1 if not generate: basemesh.parent = armature_object if import_weights: weights_file = os.path.join(rigify_dir, "weights.human.json") weights = dict() with open(weights_file, 'r') as json_file: weights = json.load(json_file) RigService.apply_weights(armature_object, basemesh, weights) if generate: bpy.ops.pose.rigify_generate() rigify_object = context.active_object rigify_object.show_in_front = True _LOG.debug("rigify", rigify_object) basemesh.parent = rigify_object for bone in armature_object.data.bones: name = bone.name if name in basemesh.vertex_groups and not "teeth" in name: vertex_group = basemesh.vertex_groups.get(name) vertex_group.name = "DEF-" + name for modifier in basemesh.modifiers: if modifier.type == 'ARMATURE': modifier.object = rigify_object if delete_after_generate: objs = bpy.data.objects objs.remove(objs[armature_object.name], do_unlink=True) bpy.ops.object.mode_set(mode='EDIT', toggle=False) teethb = RigService.find_edit_bone_by_name("teeth.B", rigify_object) teethb.use_deform = True bpy.ops.object.mode_set(mode='OBJECT', toggle=False) self.report({'INFO'}, "A rig was added") return {'FINISHED'}
def _create_eye_ik_bones(self, armature_object): _LOG.enter() bpy.ops.object.mode_set(mode='EDIT', toggle=False) bones = armature_object.data.edit_bones for side in ["left", "right"]: is_right = side == "right" bone_name = self.get_eye_name(is_right) bone = bones.new(side + "_eye_ik") head = self._bone_info["pose_bones"][bone_name]["head"] tail = self._bone_info["pose_bones"][bone_name]["tail"] length = tail - head bone.head = head + length * 4 bone.tail = tail = tail + length * 4 bone.roll = self._bone_info["edit_bones"][bone_name]["roll"] left_eye_bone = RigService.find_edit_bone_by_name( "left_eye_ik", armature_object) right_eye_bone = RigService.find_edit_bone_by_name( "right_eye_ik", armature_object) bone = bones.new("eye_ik") bone.head = (left_eye_bone.head + right_eye_bone.head) / 2 bone.tail = (left_eye_bone.tail + right_eye_bone.tail) / 2 bone.roll = left_eye_bone.roll left_eye_bone.parent = bone right_eye_bone.parent = bone if self.settings["eye_parenting_strategy"] == "HEAD": bone.parent = RigService.find_edit_bone_by_name( self.get_head_name(), armature_object) if self.settings["eye_parenting_strategy"] == "ROOT": bone.parent = RigService.find_edit_bone_by_name( self.get_root_name(), armature_object) # Needed to save bone bpy.ops.object.mode_set(mode='OBJECT', toggle=False) bpy.ops.object.mode_set(mode='POSE', toggle=False) RigService.display_pose_bone_as_empty(armature_object, "left_eye_ik", "CIRCLE", scale=0.5) RigService.display_pose_bone_as_empty(armature_object, "right_eye_ik", "CIRCLE", scale=0.5) RigService.display_pose_bone_as_empty(armature_object, "eye_ik", "CIRCLE", scale=1.4) for side in ["left", "right"]: pose_bone = RigService.find_pose_bone_by_name( side + "_eye_ik", armature_object) for i in range(3): pose_bone.lock_rotation[i] = True pose_bone.lock_scale[i] = True