@volter/blender-engine 0.1.148 → 0.1.149

package/browser/addons/vrm/editor/vrm1/menu.py

@@ -0,0 +1,76 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+from collections.abc import Callable
+from typing import Final
+
+from bpy.types import Context, Menu, Object, UILayout
+
+from ...common.logger import get_logger
+from ..ops import layout_operator
+from .ops import (
+    VRM_OT_assign_vrm1_expressions_automatically,
+    VRM_OT_assign_vrm1_expressions_from_arkit,
+    VRM_OT_assign_vrm1_expressions_from_mmd,
+    VRM_OT_assign_vrm1_expressions_from_ready_player_me,
+    VRM_OT_assign_vrm1_expressions_from_vrchat,
+    VRM_OT_assign_vrm1_expressions_from_vrm0,
+    VRM_OT_restore_vrm1_expression_morph_target_bind_object,
+)
+
+_logger = get_logger(__name__)
+
+
+class VRM_MT_vrm1_expression(Menu):
+    bl_label = "Expression Menu"
+    bl_idname = "VRM_MT_vrm1_expression"
+
+    CONTEXT_POINTER_ARMATURE: Final = bl_idname + "_armature"
+
+    @classmethod
+    def layout_context_pointer_set(cls, armature: Object) -> Callable[[UILayout], None]:
+        return lambda layout: layout.context_pointer_set(
+            cls.CONTEXT_POINTER_ARMATURE, armature
+        )
+
+    def draw(self, context: Context) -> None:
+        layout = self.layout
+
+        armature = getattr(context, self.CONTEXT_POINTER_ARMATURE, None)
+        if not isinstance(armature, Object):
+            return
+
+        restore_vrm1_expression_morph_target_bind_object_op = layout_operator(
+            layout, VRM_OT_restore_vrm1_expression_morph_target_bind_object
+        )
+        restore_vrm1_expression_morph_target_bind_object_op.armature_object_name = (
+            armature.name
+        )
+
+        auto_detection_op = layout_operator(
+            layout, VRM_OT_assign_vrm1_expressions_automatically
+        )
+        auto_detection_op.armature_object_name = armature.name
+
+        vrchat_expressions_op = layout_operator(
+            layout, VRM_OT_assign_vrm1_expressions_from_vrchat
+        )
+        vrchat_expressions_op.armature_object_name = armature.name
+
+        mmd_expressions_op = layout_operator(
+            layout, VRM_OT_assign_vrm1_expressions_from_mmd
+        )
+        mmd_expressions_op.armature_object_name = armature.name
+
+        ready_player_me_expressions_op = layout_operator(
+            layout, VRM_OT_assign_vrm1_expressions_from_ready_player_me
+        )
+        ready_player_me_expressions_op.armature_object_name = armature.name
+
+        vrm0_blend_shapes_expressions_op = layout_operator(
+            layout, VRM_OT_assign_vrm1_expressions_from_vrm0
+        )
+        vrm0_blend_shapes_expressions_op.armature_object_name = armature.name
+
+        arkit_expressions_op = layout_operator(
+            layout, VRM_OT_assign_vrm1_expressions_from_arkit
+        )
+        arkit_expressions_op.armature_object_name = armature.name

package/browser/addons/vrm/editor/vrm1/migration.py

@@ -0,0 +1,321 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+from bpy.types import Armature, Context, Material, Object
+from idprop.types import IDPropertyGroup
+from mathutils import Vector
+
+from ...common import convert, shader
+from ..extension_accessor import get_armature_extension
+from .ops import (
+    assign_vrm1_expressions_automatically,
+    assign_vrm1_humanoid_human_bones_automatically,
+    update_vrm1_expression_ui_list_elements,
+)
+from .property_group import (
+    Vrm1ExpressionPropertyGroup,
+    Vrm1ExpressionsPropertyGroup,
+    Vrm1HumanBonesPropertyGroup,
+    Vrm1MaterialColorBindPropertyGroup,
+    Vrm1PropertyGroup,
+)
+
+
+def _migrate_old_expression_layout(
+    old_expression: object, expression: Vrm1ExpressionPropertyGroup
+) -> None:
+    if not isinstance(old_expression, IDPropertyGroup):
+        return
+
+    old_morph_target_binds = convert.iterator_or_none(
+        old_expression.get("morph_target_binds")
+    )
+    if old_morph_target_binds is not None:
+        for old_morph_target_bind in old_morph_target_binds:
+            if not isinstance(old_morph_target_bind, IDPropertyGroup):
+                continue
+
+            morph_target_bind = expression.morph_target_binds.add()
+            old_node = old_morph_target_bind.get("node")
+            if isinstance(old_node, IDPropertyGroup):
+                old_bpy_object = old_node.get("bpy_object")
+                if isinstance(old_bpy_object, Object) and old_bpy_object.type == "MESH":
+                    morph_target_bind.node.mesh_object_name = old_bpy_object.name
+                old_node.clear()
+
+            old_index = old_morph_target_bind.get("index")
+            if isinstance(old_index, str):
+                morph_target_bind.index = old_index
+
+            old_weight = old_morph_target_bind.get("weight")
+            if isinstance(old_weight, (float, int)):
+                morph_target_bind.weight = old_weight
+
+            old_morph_target_bind.clear()
+
+    old_material_color_binds = convert.iterator_or_none(
+        old_expression.get("material_color_binds")
+    )
+    if old_material_color_binds is not None:
+        for old_material_color_bind in old_material_color_binds:
+            if not isinstance(old_material_color_bind, IDPropertyGroup):
+                continue
+
+            material_color_bind = expression.material_color_binds.add()
+            old_material = old_material_color_bind.get("material")
+            if isinstance(old_material, Material):
+                material_color_bind.material = old_material
+
+            old_type = next(
+                (
+                    enum.identifier
+                    for enum in Vrm1MaterialColorBindPropertyGroup.type_enum
+                    if old_material_color_bind.get("type") == enum.value
+                ),
+                None,
+            )
+            if old_type is not None:
+                material_color_bind.type = old_type
+
+            old_target_value = shader.rgba_or_none(
+                old_material_color_bind.get("target_value"), 0.0, 1.0
+            )
+            if old_target_value:
+                material_color_bind.target_value = old_target_value
+
+            old_material_color_bind.clear()
+
+    old_texture_transform_binds = convert.iterator_or_none(
+        old_expression.get("texture_transform_binds")
+    )
+    if old_texture_transform_binds is not None:
+        for old_texture_transform_bind in old_texture_transform_binds:
+            if not isinstance(old_texture_transform_bind, IDPropertyGroup):
+                continue
+
+            texture_transform_bind = expression.texture_transform_binds.add()
+            old_material = old_texture_transform_bind.get("material")
+            if isinstance(old_material, Material):
+                texture_transform_bind.material = old_material
+
+            old_scale = convert.float2_or_none(old_texture_transform_bind.get("scale"))
+            if old_scale:
+                texture_transform_bind.scale = old_scale
+
+            old_offset = convert.float2_or_none(
+                old_texture_transform_bind.get("offset")
+            )
+            if old_offset:
+                texture_transform_bind.offset = old_offset
+
+            old_texture_transform_bind.clear()
+
+    old_is_binary = old_expression.get("is_binary")
+    if isinstance(old_is_binary, int):
+        expression.is_binary = bool(old_is_binary)
+
+    old_override_blink = next(
+        (
+            enum.identifier
+            for enum in Vrm1ExpressionPropertyGroup.expression_override_type_enum
+            if old_expression.get("override_blink") == enum.value
+        ),
+        None,
+    )
+    if old_override_blink is not None:
+        expression.override_blink = old_override_blink
+
+    old_override_look_at = next(
+        (
+            enum.identifier
+            for enum in Vrm1ExpressionPropertyGroup.expression_override_type_enum
+            if old_expression.get("override_look_at") == enum.value
+        ),
+        None,
+    )
+    if old_override_look_at is not None:
+        expression.override_look_at = old_override_look_at
+
+    old_override_mouth = next(
+        (
+            enum.identifier
+            for enum in Vrm1ExpressionPropertyGroup.expression_override_type_enum
+            if old_expression.get("override_mouth") == enum.value
+        ),
+        None,
+    )
+    if old_override_mouth is not None:
+        expression.override_mouth = old_override_mouth
+
+
+def _migrate_old_expressions_layout(expressions: Vrm1ExpressionsPropertyGroup) -> None:
+    for name, expression in expressions.preset.name_to_expression_dict().items():
+        property_name = {
+            "blinkLeft": "blink_left",
+            "blinkRight": "blink_right",
+            "lookUp": "look_up",
+            "lookDown": "look_down",
+            "lookLeft": "look_left",
+            "lookRight": "look_right",
+        }.get(name)
+        if property_name is None:
+            property_name = name
+        old_expression = expressions.get(property_name)
+        _migrate_old_expression_layout(old_expression, expression)
+        expression.name = name
+    for expression in expressions.custom:
+        old_expression = expression.get("expression")
+        _migrate_old_expression_layout(old_expression, expression)
+
+
+def _migrate_pose(context: Context, _armature: Object, armature_data: Armature) -> None:
+    ext = get_armature_extension(armature_data)
+    if tuple(ext.addon_version) >= (2, 20, 34):
+        return
+
+    humanoid = ext.vrm1.humanoid
+    if isinstance(humanoid.get("pose"), int):
+        return
+
+    if tuple(ext.addon_version) == ext.UNMANAGED_ADDON_VERSION:
+        return
+
+    if tuple(ext.addon_version) <= (2, 0, 1):
+        humanoid.pose = humanoid.POSE_CURRENT_POSE.identifier
+        return
+
+    action = humanoid.pose_library
+    if action and action.name in context.blend_data.actions:
+        humanoid.pose = humanoid.POSE_CUSTOM_POSE.identifier
+    elif armature_data.pose_position == "REST":
+        humanoid.pose = humanoid.POSE_REST_POSITION_POSE.identifier
+    else:
+        humanoid.pose = humanoid.POSE_CURRENT_POSE.identifier
+
+
+def _migrate_auto_pose(_context: Context, armature_data: Armature) -> None:
+    ext = get_armature_extension(armature_data)
+    if (
+        tuple(ext.addon_version) >= (2, 20, 81)
+        or tuple(ext.addon_version) == ext.UNMANAGED_ADDON_VERSION
+    ):
+        return
+
+    humanoid = ext.vrm1.humanoid
+    if not isinstance(humanoid.get("pose"), int):
+        humanoid.pose = humanoid.POSE_CURRENT_POSE.identifier
+
+
+def is_unnecessary(vrm1: Vrm1PropertyGroup, *, heavy_migration: bool) -> bool:
+    if not heavy_migration:
+        return True
+    return (
+        not vrm1.humanoid.human_bones.initial_automatic_bone_assignment
+        and not vrm1.expressions.initial_automatic_expression_assignment
+    )
+
+
+def migrate(
+    context: Context,
+    vrm1: Vrm1PropertyGroup,
+    armature: Object,
+    *,
+    heavy_migration: bool,
+) -> None:
+    armature_data = armature.data
+    if not isinstance(armature_data, Armature):
+        return
+
+    human_bones = vrm1.humanoid.human_bones
+    human_bones.pop("last_bone_names", None)
+    human_bones.pop("last_bone_names_str", None)
+    Vrm1HumanBonesPropertyGroup.fixup_human_bones(armature)
+    if heavy_migration:
+        Vrm1HumanBonesPropertyGroup.update_all_bone_name_candidates(
+            context, armature_data.name
+        )
+
+    if heavy_migration and human_bones.initial_automatic_bone_assignment:
+        human_bones.initial_automatic_bone_assignment = False
+        human_bone_name_to_human_bone = human_bones.human_bone_name_to_human_bone()
+        if all(not b.node.bone_name for b in human_bone_name_to_human_bone.values()):
+            assign_vrm1_humanoid_human_bones_automatically(context, armature)
+
+    if tuple(get_armature_extension(armature_data).addon_version) <= (2, 14, 10):
+        ext = get_armature_extension(armature_data)
+        head_bone_name = ext.vrm1.humanoid.human_bones.head.node.bone_name
+        head_bone = armature_data.bones.get(head_bone_name)
+        if head_bone:
+            look_at = get_armature_extension(armature_data).vrm1.look_at
+            world_translation = (
+                armature.matrix_world @ head_bone.matrix_local
+            ).to_quaternion() @ Vector(look_at.offset_from_head_bone)
+            look_at.offset_from_head_bone = list(world_translation)
+
+    if tuple(get_armature_extension(armature_data).addon_version) <= (2, 15, 5):
+        # Apply lower limit value
+        look_at = get_armature_extension(armature_data).vrm1.look_at
+        look_at.range_map_horizontal_inner.input_max_value = (
+            look_at.range_map_horizontal_inner.input_max_value
+        )
+        look_at.range_map_horizontal_outer.input_max_value = (
+            look_at.range_map_horizontal_outer.input_max_value
+        )
+        look_at.range_map_vertical_down.input_max_value = (
+            look_at.range_map_vertical_down.input_max_value
+        )
+        look_at.range_map_vertical_up.input_max_value = (
+            look_at.range_map_vertical_up.input_max_value
+        )
+
+    if tuple(get_armature_extension(armature_data).addon_version) < (2, 18, 0):
+        _migrate_old_expressions_layout(
+            get_armature_extension(armature_data).vrm1.expressions
+        )
+
+    if tuple(get_armature_extension(armature_data).addon_version) < (2, 20, 0):
+        look_at = get_armature_extension(armature_data).vrm1.look_at
+        look_at.offset_from_head_bone = (
+            look_at.offset_from_head_bone[0],
+            look_at.offset_from_head_bone[2],
+            -look_at.offset_from_head_bone[1],
+        )
+
+    _migrate_pose(context, armature, armature_data)
+    _migrate_auto_pose(context, armature_data)
+
+    expressions = get_armature_extension(armature_data).vrm1.expressions
+    expressions.fill_missing_expression_names()
+
+    if tuple(get_armature_extension(armature_data).addon_version) < (3, 9, 0):
+        for expression in expressions.preset.name_to_expression_dict().values():
+            for morph_target_bind in expression.morph_target_binds:
+                morph_target_bind.node.saved_mesh_object_name_to_restore = (
+                    morph_target_bind.node.mesh_object_name
+                )
+
+    if (
+        (ext := get_armature_extension(armature_data))
+        and tuple(ext.addon_version) < (3, 18)
+        and tuple(ext.addon_version) != ext.UNMANAGED_ADDON_VERSION
+    ):
+        expressions.initial_automatic_expression_assignment = False
+
+    if expressions.initial_automatic_expression_assignment:
+        expressions.initial_automatic_expression_assignment = False
+        assign_vrm1_expressions_automatically(context, armature.name)
+        expression_preset_and_expressions = (
+            expressions.preset.expression_preset_and_expressions()
+        )
+        if any(
+            preset.look_at and expression.morph_target_binds
+            for preset, expression in expression_preset_and_expressions
+        ):
+            look_at = get_armature_extension(armature_data).vrm1.look_at
+            look_at.type = look_at.TYPE_EXPRESSION.identifier
+
+    if heavy_migration:
+        Vrm1HumanBonesPropertyGroup.update_all_bone_name_candidates(
+            context,
+            armature_data.name,
+            force=True,
+        )
+    update_vrm1_expression_ui_list_elements(context)