From a3111644af9d398f21225f3f7aedc6bccd0107cd Mon Sep 17 00:00:00 2001 From: Yusarina Date: Fri, 20 Sep 2024 16:48:51 +0100 Subject: [PATCH 1/2] Rigify To Unity Function - This is an work in progress, this expands on the system that NyankoNyan and improves that system. - It remaps the bone hierarchy to match Unity's expectations - It adds necessary constraints to ensure proper bone movement (For the people who need it, can be removed via remove constraints button). - It removes redundant bones that could cause issues in Unity. - It renames bones to match Unity's Humanoid Avatar naming convention. - It provides an option to merge or remove twist bones, which are not supported by Unity's humanoid system. - It adjusts bone connections and deformation settings. I think more needs to be added, but this seems to work for now. --- core/properties.py | 5 + functions/rigify_functions.py | 184 ++++++++++++++++++++++++++++++ resources/translations/en_US.json | 3 + ui/tools.py | 5 + 4 files changed, 197 insertions(+) create mode 100644 functions/rigify_functions.py diff --git a/core/properties.py b/core/properties.py index 92e5ea6..e75d2ae 100644 --- a/core/properties.py +++ b/core/properties.py @@ -63,6 +63,11 @@ def register() -> None: min=0.0, max=2.0 ))) + register_property((bpy.types.Scene, "merge_twist_bones", bpy.props.BoolProperty( + name=t("Tools.merge_twist_bones.label"), + description=t("Tools.merge_twist_bones.desc"), + default=True + ))) register_property((bpy.types.Scene, "selected_armature", bpy.props.EnumProperty( items=get_armatures, diff --git a/functions/rigify_functions.py b/functions/rigify_functions.py new file mode 100644 index 0000000..8ca932f --- /dev/null +++ b/functions/rigify_functions.py @@ -0,0 +1,184 @@ +# This code is heavily based on the Rigify-Move-DEF by NyankoNyan (https://github.com/NyankoNyan/Rigify-Move-DEF), which is licensed under the MIT License. We just heavily improve the code and add some new features. + +import bpy +from ..core.register import register_wrap +from ..core.common import get_selected_armature, is_valid_armature +from ..functions.translations import t +from bpy.types import Operator, Context + +import bpy +from ..core.register import register_wrap +from ..core.common import get_selected_armature, is_valid_armature +from ..functions.translations import t +from bpy.types import Operator, Context + +@register_wrap +class AvatarToolKit_OT_ConvertRigifyToUnity(Operator): + bl_idname = "avatar_toolkit.convert_rigify_to_unity" + bl_label = t("Tools.convert_rigify_to_unity.label") + bl_description = t("Tools.convert_rigify_to_unity.desc") + bl_options = {'REGISTER', 'UNDO'} + + @classmethod + def poll(cls, context: Context) -> bool: + armature = get_selected_armature(context) + return armature is not None and is_valid_armature(armature) and "DEF-spine" in armature.data.bones + + def execute(self, context: Context) -> set[str]: + armature = get_selected_armature(context) + if not armature: + self.report({'ERROR'}, t("Tools.no_armature_selected")) + return {'CANCELLED'} + + self.move_def_bones(armature) + self.rename_bones_for_unity(armature) + if context.scene.merge_twist_bones: + self.handle_twist_bones(armature) + self.report({'INFO'}, t("Tools.convert_rigify_to_unity.success")) + return {'FINISHED'} + + def move_def_bones(self, armature): + remap = self.get_org_remap(armature) + remap.update(self.get_special_remap()) + + remove_bones_in_chain = [ + 'DEF-upper_arm.L.001', 'DEF-forearm.L.001', + 'DEF-upper_arm.R.001', 'DEF-forearm.R.001', + 'DEF-thigh.L.001', 'DEF-shin.L.001', + 'DEF-thigh.R.001', 'DEF-shin.R.001' + ] + + transform_copies = self.get_transform_copies(armature) + + # Add missing constraints + bpy.ops.object.mode_set(mode='POSE') + for bone_name in transform_copies: + bone = armature.pose.bones[bone_name] + org_name = 'ORG-' + self.get_proto_name(bone_name) + if org_name in armature.pose.bones: + constraint = bone.constraints.new('COPY_TRANSFORMS') + constraint.target = armature + constraint.subtarget = org_name + constr_count = len(bone.constraints) + if constr_count > 1: + bone.constraints.move(constr_count-1, 0) + + # Apply new parents + bpy.ops.object.mode_set(mode='EDIT') + for remap_key in remap: + if remap_key in armature.data.edit_bones and remap[remap_key] in armature.data.edit_bones: + armature.data.edit_bones[remap_key].parent = armature.data.edit_bones[remap[remap_key]] + + # Remove extra bones in chains + bpy.ops.object.mode_set(mode='OBJECT') + for bone_name in remove_bones_in_chain: + if bone_name in armature.data.bones: + armature.data.bones[bone_name].use_deform = False + + bpy.ops.object.mode_set(mode='EDIT') + for bone_name in remove_bones_in_chain: + if bone_name in armature.data.bones: + remove_bone = armature.data.edit_bones[bone_name] + parent_bone = remove_bone.parent + parent_bone.tail = remove_bone.tail + retarget_bones = list(remove_bone.children) + for bone in retarget_bones: + bone.parent = parent_bone + armature.data.edit_bones.remove(remove_bone) + + def rename_bones_for_unity(self, armature): + unity_bone_names = { + "DEF-spine": "Hips", + "DEF-spine.001": "Spine", + "DEF-spine.002": "Chest", + "DEF-spine.003": "UpperChest", + "DEF-neck": "Neck", + "DEF-head": "Head", + "DEF-shoulder.L": "LeftShoulder", + "DEF-upper_arm.L": "LeftUpperArm", + "DEF-forearm.L": "LeftLowerArm", + "DEF-hand.L": "LeftHand", + "DEF-shoulder.R": "RightShoulder", + "DEF-upper_arm.R": "RightUpperArm", + "DEF-forearm.R": "RightLowerArm", + "DEF-hand.R": "RightHand", + "DEF-thigh.L": "LeftUpperLeg", + "DEF-shin.L": "LeftLowerLeg", + "DEF-foot.L": "LeftFoot", + "DEF-toe.L": "LeftToes", + "DEF-thigh.R": "RightUpperLeg", + "DEF-shin.R": "RightLowerLeg", + "DEF-foot.R": "RightFoot", + "DEF-toe.R": "RightToes" + } + + for old_name, new_name in unity_bone_names.items(): + bone = armature.pose.bones.get(old_name) + if bone: + bone.name = new_name + + def handle_twist_bones(self, armature): + twist_bones = [ + ("DEF-upper_arm_twist.L", "DEF-upper_arm.L"), + ("DEF-upper_arm_twist.R", "DEF-upper_arm.R"), + ("DEF-forearm_twist.L", "DEF-forearm.L"), + ("DEF-forearm_twist.R", "DEF-forearm.R"), + ("DEF-thigh_twist.L", "DEF-thigh.L"), + ("DEF-thigh_twist.R", "DEF-thigh.R") + ] + + bpy.ops.object.mode_set(mode='EDIT') + for twist_bone, parent_bone in twist_bones: + if twist_bone in armature.data.edit_bones and parent_bone in armature.data.edit_bones: + twist = armature.data.edit_bones[twist_bone] + parent = armature.data.edit_bones[parent_bone] + parent.tail = twist.tail + for child in twist.children: + child.parent = parent + armature.data.edit_bones.remove(twist) + + bpy.ops.object.mode_set(mode='OBJECT') + + def get_org_remap(self, armature): + remap = {} + for bone in armature.data.bones: + if self.is_def_bone(bone.name): + name = self.get_proto_name(bone.name) + parent = bone.parent + while parent: + parent_name = self.get_proto_name(parent.name) + if parent_name != name: + if ('DEF-' + parent_name) in armature.data.bones: + remap[bone.name] = 'DEF-' + parent_name + break + parent = parent.parent + return remap + + def get_special_remap(self): + return { + 'DEF-thigh.L': 'DEF-pelvis.L', + 'DEF-thigh.R': 'DEF-pelvis.R', + 'DEF-upper_arm.L': 'DEF-shoulder.L', + 'DEF-upper_arm.R': 'DEF-shoulder.R', + } + + def get_transform_copies(self, armature): + result = [] + for bone in armature.pose.bones: + if self.is_def_bone(bone.name) and not self.has_transform_copies(bone): + result.append(bone.name) + return result + + def has_transform_copies(self, bone): + return any(constraint.type == 'COPY_TRANSFORMS' for constraint in bone.constraints) + + def is_def_bone(self, bone_name): + return bone_name.startswith('DEF-') + + def is_org_bone(self, bone_name): + return bone_name.startswith('ORG-') + + def get_proto_name(self, bone_name): + if self.is_def_bone(bone_name) or self.is_org_bone(bone_name): + return bone_name[4:] + return bone_name diff --git a/resources/translations/en_US.json b/resources/translations/en_US.json index 4101169..0946093 100644 --- a/resources/translations/en_US.json +++ b/resources/translations/en_US.json @@ -165,6 +165,9 @@ "Tools.merge_bones_to_parents.label": "Merge Bones to Individual Parents", "Tools.remove_zero_weight_bones.threshold.label": "Weight Threshold", "Tools.remove_zero_weight_bones.threshold.desc": "If a bone is not weighted to any part of any mesh under the armature with a threshold greater than this, it is removed", + "Tools.convert_rigify_to_unity.label": "Convert Rigify to Unity", + "Tools.convert_rigify_to_unity.desc": "Prepare Rigify armature for use in Unity", + "Tools.convert_rigify_to_unity.success": "Rigify armature successfully converted for Unity", "MergeArmatures.select_armature": "Please select an armature", "MergeArmatures.title.label": "Merge Armatures:", "MergeArmatures.label": "Merge Armatures", diff --git a/ui/tools.py b/ui/tools.py index 05f3fa9..cdc1fd9 100644 --- a/ui/tools.py +++ b/ui/tools.py @@ -10,6 +10,7 @@ from ..functions.mesh_tools import AvatarToolkit_OT_RemoveUnusedShapekeys from ..functions.seperate_by import AvatarToolKit_OT_SeparateByMaterials, AvatarToolKit_OT_SeparateByLooseParts from ..functions.additional_tools import AvatarToolKit_OT_ApplyTransforms from ..functions.armature_modifying import AvatarToolkit_OT_RemoveZeroWeightBones, AvatarToolkit_OT_MergeBonesToActive, AvatarToolkit_OT_MergeBonesToParents +from ..functions.rigify_functions import AvatarToolKit_OT_ConvertRigifyToUnity @register_wrap class AvatarToolkit_PT_ToolsPanel(bpy.types.Panel): @@ -47,5 +48,9 @@ class AvatarToolkit_PT_ToolsPanel(bpy.types.Panel): row = layout.row(align=True) row.operator(AvatarToolkit_OT_MergeBonesToActive.bl_idname, text=t("Tools.merge_bones_to_active.label"), icon='BONE_DATA') row.operator(AvatarToolkit_OT_MergeBonesToParents.bl_idname, text=t("Tools.merge_bones_to_parents.label"), icon='BONE_DATA') + row = layout.row(align=True) + row.operator(AvatarToolKit_OT_ConvertRigifyToUnity.bl_idname, text=t("Tools.convert_rigify_to_unity.label"), icon='ARMATURE_DATA') + row = layout.row() + row.prop(context.scene, "merge_twist_bones") else: layout.label(text=t("Tools.select_armature"), icon='ERROR') From 8191c795f47bbafdcfaa69c60e8d6bab8eec02a9 Mon Sep 17 00:00:00 2001 From: 989onan Date: Sun, 22 Sep 2024 14:50:26 -0400 Subject: [PATCH 2/2] Add apply shapekey to basis add apply shapekey to basis to shapekey menu I believe I wrote this simple implementation for Tuxedo, I don't remember how I came up with it. --- __init__.py | 5 +++++ core/common.py | 30 ++++++++++++++++++++++++++++++ functions/mesh_tools.py | 29 +++++++++++++++++++++++++++-- resources/translations/en_US.json | 3 +++ 4 files changed, 65 insertions(+), 2 deletions(-) diff --git a/__init__.py b/__init__.py index 8817dec..eea85d4 100644 --- a/__init__.py +++ b/__init__.py @@ -33,6 +33,11 @@ def register(): #finally register properties that may use some classes. core.register.register_properties() + from functions.mesh_tools import AvatarToolkit_OT_ApplyShapeKey + + bpy.types.MESH_MT_shape_key_context_menu.append((lambda self, context: self.layout.separator())) + bpy.types.MESH_MT_shape_key_context_menu.append((lambda self, context: self.layout.operator(AvatarToolkit_OT_ApplyShapeKey.bl_idname, icon="KEY_HLT"))) + def unregister(): print("Unregistering Avatar Toolkit") # Unregister the UI classes diff --git a/core/common.py b/core/common.py index c4e06fa..6b060f9 100644 --- a/core/common.py +++ b/core/common.py @@ -144,6 +144,36 @@ def select_current_armature(context: Context) -> bool: return True return False +def apply_shapekey_to_basis(context: bpy.types.Context, obj: bpy.types.Object, shape_key_name: str, delete_old: bool = False) -> bool: + if shape_key_name not in obj.data.shape_keys.key_blocks: + return False + shapekeynum = obj.data.shape_keys.key_blocks.find(shape_key_name) + + bpy.ops.object.mode_set(mode="EDIT") + + bpy.ops.mesh.select_all(action='SELECT') + + + obj.active_shape_key_index = 0 + bpy.ops.mesh.blend_from_shape(shape = shape_key_name, add=True, blend=1) + obj.active_shape_key_index = shapekeynum + bpy.ops.mesh.select_all(action='SELECT') + bpy.ops.mesh.blend_from_shape(shape = shape_key_name, add=True, blend=-2) + + + bpy.ops.mesh.select_all(action='DESELECT') + + bpy.ops.object.mode_set(mode="OBJECT") + print("blended!") + + if delete_old: + obj.active_shape_key_index = shapekeynum + bpy.ops.object.shape_key_remove(all=False) + else: + mesh: bpy.types.Mesh = obj.data + mesh.shape_keys.key_blocks[shape_key_name].name = shape_key_name + "_reversed" + return True + def apply_pose_as_rest(context: Context, armature_obj: bpy.types.Object, meshes: list[bpy.types.Object]) -> bool: for obj in meshes: mesh_data: Mesh = obj.data diff --git a/functions/mesh_tools.py b/functions/mesh_tools.py index 9819e66..89a76ac 100644 --- a/functions/mesh_tools.py +++ b/functions/mesh_tools.py @@ -1,7 +1,7 @@ import numpy as np import bpy from bpy.types import Context -from ..core.common import get_selected_armature, get_all_meshes, is_valid_armature +from ..core.common import get_selected_armature, get_all_meshes, is_valid_armature, apply_shapekey_to_basis, has_shapekeys from ..functions.translations import t from ..core.register import register_wrap @@ -53,4 +53,29 @@ class AvatarToolkit_OT_RemoveUnusedShapekeys(bpy.types.Operator): for kb_name in to_delete: if ("-" in kb_name) or ("=" in kb_name) or ("~" in kb_name): #don't delete category names. - @989onan continue - ob.shape_key_remove(ob.data.shape_keys.key_blocks[kb_name]) \ No newline at end of file + ob.shape_key_remove(ob.data.shape_keys.key_blocks[kb_name]) + + + +@register_wrap +class AvatarToolkit_OT_ApplyShapeKey(bpy.types.Operator): + bl_idname = "avatar_toolkit.apply_shape_key" + bl_label = t("Tools.apply_shape_key.label") + bl_description = t("Tools.apply_shape_key.desc") + bl_options = {'REGISTER', 'UNDO'} + + + @classmethod + def poll(cls, context: Context) -> bool: + armature = get_selected_armature(context) + return armature is not None and is_valid_armature(armature) and (len(get_all_meshes(context)) > 0) and (context.mode == "OBJECT") and context.view_layer.objects.active is not None and has_shapekeys(context.view_layer.objects.active) + + def execute(self, context: Context) -> set[str]: + obj: bpy.types.Object = context.view_layer.objects.active + + + if (apply_shapekey_to_basis(context,obj,obj.active_shape_key.name,False)): + return {'FINISHED'} + else: + self.report({'ERROR'}, t("Tools.apply_shape_key.error")) + return {'FINISHED'} \ No newline at end of file diff --git a/resources/translations/en_US.json b/resources/translations/en_US.json index 40e635e..fc913fd 100644 --- a/resources/translations/en_US.json +++ b/resources/translations/en_US.json @@ -151,6 +151,9 @@ "Tools.remove_unused_shapekeys.tolerance.desc": "Min movement for position on any coordinate\n for any vertex for a shapekey to be kept.", "Tools.remove_unused_shapekeys.desc": "Remove shapekeys that don't move anything.\nDoesn't get rid of category shapekeys.\n(ex: has \"~\", \"-\", or \"=\" in the name.)", "Tools.remove_unused_shapekeys.tolerance.label": "Position Tolerance", + "Tools.apply_shape_key.label": "Apply Shapekey to Basis", + "Tools.apply_shape_key.desc": "Apply the selected shapekey to the basis, making it default on.", + "Tools.apply_shape_key.error": "The shape keys were not merged for some reason!", "Tools.remove_zero_weight_bones.success": "Zero weight bones removed successfully", "Tools.remove_zero_weight_bones.label": "Remove Zero Weight Bones", "Tools.remove_zero_weight_bones.desc": "Remove bones from the armature that have weights less than threshold.",