@volter/blender-engine 0.1.148 → 0.1.150

package/browser/addons/vrm/editor/extension.py

@@ -0,0 +1,425 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+import math
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Optional
+
+from bpy.props import (
+    CollectionProperty,
+    EnumProperty,
+    IntVectorProperty,
+    PointerProperty,
+    StringProperty,
+)
+from bpy.types import (
+    Armature,
+    Context,
+    Object,
+    PropertyGroup,
+)
+from mathutils import Matrix, Quaternion
+
+from ..common.logger import get_logger
+from ..common.preferences import VrmAddonPreferences
+from ..common.vrm0.material_property import GLTF_PROPERTIES, MTOON0_PROPERTIES
+from .extension_accessor import (
+    get_armature_extension,
+    get_scene_extension,
+)
+from .khr_character.property_group import KhrCharacterPropertyGroup
+from .mtoon1.property_group import Mtoon1MaterialPropertyGroup
+from .node_constraint1.property_group import NodeConstraint1NodeConstraintPropertyGroup
+from .property_group import (
+    StringPropertyGroup,
+    clear_expression_material_binds,
+    property_group_enum,
+)
+from .spring_bone1.property_group import SpringBone1SpringBonePropertyGroup
+from .vrm0.property_group import Vrm0PropertyGroup
+from .vrm1.property_group import Vrm1LookAtPropertyGroup, Vrm1PropertyGroup
+
+if TYPE_CHECKING:
+    from .property_group import CollectionPropertyProtocol
+
+_logger = get_logger(__name__)
+
+
+class VrmAddonSceneExtensionPropertyGroup(PropertyGroup):
+    vrm0_material_gltf_property_names: CollectionProperty(  # type: ignore[valid-type]
+        type=StringPropertyGroup
+    )
+
+    vrm0_material_mtoon0_property_names: CollectionProperty(  # type: ignore[valid-type]
+        type=StringPropertyGroup
+    )
+
+    @staticmethod
+    def update_vrm0_material_property_names(context: Context) -> None:
+        # Unity 2022.3.4 + UniVRM 0.112.0
+        gltf_property_names = list(GLTF_PROPERTIES.keys())
+
+        # UniVRM 0.112.0
+        mtoon0_property_names = list(MTOON0_PROPERTIES.keys())
+
+        for scene in context.blend_data.scenes:
+            ext = get_scene_extension(scene)
+
+            if gltf_property_names != [
+                n.value for n in ext.vrm0_material_gltf_property_names
+            ]:
+                ext.vrm0_material_gltf_property_names.clear()
+                for gltf_property_name in gltf_property_names:
+                    n = ext.vrm0_material_gltf_property_names.add()
+                    n.value = gltf_property_name
+
+            if mtoon0_property_names != [
+                n.value for n in ext.vrm0_material_mtoon0_property_names
+            ]:
+                ext.vrm0_material_mtoon0_property_names.clear()
+                for mtoon0_property_name in mtoon0_property_names:
+                    n = ext.vrm0_material_mtoon0_property_names.add()
+                    n.value = mtoon0_property_name
+
+    if TYPE_CHECKING:
+        # This code is auto generated.
+        # To regenerate, run the `uv run tools/property_typing.py` command.
+        vrm0_material_gltf_property_names: CollectionPropertyProtocol[  # type: ignore[no-redef]
+            StringPropertyGroup
+        ]
+        vrm0_material_mtoon0_property_names: CollectionPropertyProtocol[  # type: ignore[no-redef]
+            StringPropertyGroup
+        ]
+
+
+class VrmAddonBoneExtensionPropertyGroup(PropertyGroup):
+    uuid: StringProperty()  # type: ignore[valid-type]
+
+    (
+        axis_translation_enum,
+        (
+            AXIS_TRANSLATION_AUTO,
+            AXIS_TRANSLATION_NONE,
+            AXIS_TRANSLATION_X_TO_Y,
+            AXIS_TRANSLATION_MINUS_X_TO_Y,
+            AXIS_TRANSLATION_MINUS_Y_TO_Y_AROUND_Z,
+            AXIS_TRANSLATION_Z_TO_Y,
+            AXIS_TRANSLATION_MINUS_Z_TO_Y,
+        ),
+    ) = property_group_enum(
+        ("AUTO", "Auto", "", "NONE", 0),
+        ("NONE", "None", "", "NONE", 1),
+        ("X_TO_Y", "X,Y to Y,-X", "", "NONE", 2),
+        ("MINUS_X_TO_Y", "X,Y to -Y,X", "", "NONE", 3),
+        ("MINUS_Y_TO_Y_AROUND_Z", "X,Y to -X,-Y", "", "NONE", 4),
+        ("Z_TO_Y", "Y,Z to -Z,Y", "", "NONE", 5),
+        ("MINUS_Z_TO_Y", "Y,Z to Z,-Y", "", "NONE", 6),
+    )
+
+    @classmethod
+    def reverse_axis_translation(cls, axis_translation: str) -> str:
+        return {
+            cls.AXIS_TRANSLATION_AUTO.identifier: cls.AXIS_TRANSLATION_AUTO,
+            cls.AXIS_TRANSLATION_NONE.identifier: cls.AXIS_TRANSLATION_NONE,
+            cls.AXIS_TRANSLATION_X_TO_Y.identifier: (cls.AXIS_TRANSLATION_MINUS_X_TO_Y),
+            cls.AXIS_TRANSLATION_MINUS_X_TO_Y.identifier: (cls.AXIS_TRANSLATION_X_TO_Y),
+            cls.AXIS_TRANSLATION_Z_TO_Y.identifier: (cls.AXIS_TRANSLATION_MINUS_Z_TO_Y),
+            cls.AXIS_TRANSLATION_MINUS_Z_TO_Y.identifier: (cls.AXIS_TRANSLATION_Z_TO_Y),
+            cls.AXIS_TRANSLATION_MINUS_Y_TO_Y_AROUND_Z.identifier: (
+                cls.AXIS_TRANSLATION_MINUS_Y_TO_Y_AROUND_Z
+            ),
+        }[axis_translation].identifier
+
+    @classmethod
+    def node_constraint_roll_axis_translation(
+        cls, axis_translation: str, roll_axis: Optional[str]
+    ) -> Optional[str]:
+        if roll_axis is None:
+            return None
+        return {
+            cls.AXIS_TRANSLATION_AUTO.identifier: {"X": "X", "Y": "Y", "Z": "Z"},
+            cls.AXIS_TRANSLATION_NONE.identifier: {"X": "X", "Y": "Y", "Z": "Z"},
+            cls.AXIS_TRANSLATION_X_TO_Y.identifier: {"X": "Y", "Y": "X", "Z": "Z"},
+            cls.AXIS_TRANSLATION_MINUS_X_TO_Y.identifier: {
+                "X": "Y",
+                "Y": "X",
+                "Z": "Z",
+            },
+            cls.AXIS_TRANSLATION_Z_TO_Y.identifier: {"X": "X", "Y": "Z", "Z": "Y"},
+            cls.AXIS_TRANSLATION_MINUS_Z_TO_Y.identifier: {
+                "X": "X",
+                "Y": "Z",
+                "Z": "Y",
+            },
+            cls.AXIS_TRANSLATION_MINUS_Y_TO_Y_AROUND_Z.identifier: {
+                "X": "X",
+                "Y": "Y",
+                "Z": "Z",
+            },
+        }[axis_translation][roll_axis]
+
+    @classmethod
+    def node_constraint_aim_axis_translation(
+        cls, axis_translation: str, aim_axis: Optional[str]
+    ) -> Optional[str]:
+        if aim_axis is None:
+            return None
+        return {
+            cls.AXIS_TRANSLATION_AUTO.identifier: {
+                "PositiveX": "PositiveX",
+                "PositiveY": "PositiveY",
+                "PositiveZ": "PositiveZ",
+                "NegativeX": "NegativeX",
+                "NegativeY": "NegativeY",
+                "NegativeZ": "NegativeZ",
+            },
+            cls.AXIS_TRANSLATION_NONE.identifier: {
+                "PositiveX": "PositiveX",
+                "PositiveY": "PositiveY",
+                "PositiveZ": "PositiveZ",
+                "NegativeX": "NegativeX",
+                "NegativeY": "NegativeY",
+                "NegativeZ": "NegativeZ",
+            },
+            cls.AXIS_TRANSLATION_X_TO_Y.identifier: {
+                "PositiveX": "PositiveY",
+                "PositiveY": "NegativeX",
+                "PositiveZ": "PositiveZ",
+                "NegativeX": "NegativeY",
+                "NegativeY": "PositiveX",
+                "NegativeZ": "NegativeZ",
+            },
+            cls.AXIS_TRANSLATION_MINUS_X_TO_Y.identifier: {
+                "PositiveY": "PositiveX",
+                "NegativeX": "PositiveY",
+                "PositiveZ": "PositiveZ",
+                "NegativeY": "NegativeX",
+                "PositiveX": "NegativeY",
+                "NegativeZ": "NegativeZ",
+            },
+            cls.AXIS_TRANSLATION_Z_TO_Y.identifier: {
+                "PositiveX": "PositiveX",
+                "PositiveY": "NegativeZ",
+                "PositiveZ": "PositiveY",
+                "NegativeX": "NegativeX",
+                "NegativeY": "PositiveZ",
+                "NegativeZ": "NegativeY",
+            },
+            cls.AXIS_TRANSLATION_MINUS_Z_TO_Y.identifier: {
+                "PositiveX": "PositiveX",
+                "NegativeZ": "PositiveY",
+                "PositiveY": "PositiveZ",
+                "NegativeX": "NegativeX",
+                "PositiveZ": "NegativeY",
+                "NegativeY": "NegativeZ",
+            },
+            cls.AXIS_TRANSLATION_MINUS_Y_TO_Y_AROUND_Z.identifier: {
+                "PositiveX": "NegativeX",
+                "PositiveY": "NegativeY",
+                "PositiveZ": "PositiveZ",
+                "NegativeX": "PositiveX",
+                "NegativeY": "PositiveY",
+                "NegativeZ": "NegativeZ",
+            },
+        }[axis_translation][aim_axis]
+
+    @classmethod
+    def translate_axis(cls, matrix: Matrix, axis_translation: str) -> Matrix:
+        location, rotation, scale = matrix.decompose()
+
+        if axis_translation == cls.AXIS_TRANSLATION_X_TO_Y.identifier:
+            rotation @= Quaternion((0, 0, 1), -math.pi / 2)
+        elif axis_translation == cls.AXIS_TRANSLATION_MINUS_X_TO_Y.identifier:
+            rotation @= Quaternion((0, 0, 1), math.pi / 2)
+        elif axis_translation == cls.AXIS_TRANSLATION_MINUS_Y_TO_Y_AROUND_Z.identifier:
+            rotation @= Quaternion((0, 0, 1), math.pi)
+        elif axis_translation == cls.AXIS_TRANSLATION_Z_TO_Y.identifier:
+            rotation @= Quaternion((1, 0, 0), math.pi / 2)
+        elif axis_translation == cls.AXIS_TRANSLATION_MINUS_Z_TO_Y.identifier:
+            rotation @= Quaternion((1, 0, 0), -math.pi / 2)
+
+        # return Matrix.LocRotScale(location, rotation, scale)
+        return (
+            Matrix.Translation(location)
+            @ rotation.to_matrix().to_4x4()
+            @ Matrix.Diagonal(scale).to_4x4()
+        )
+
+    axis_translation: EnumProperty(  # type: ignore[valid-type]
+        items=axis_translation_enum.items(),
+        name="Axis Translation on Export",
+    )
+
+    if TYPE_CHECKING:
+        # This code is auto generated.
+        # To regenerate, run the `uv run tools/property_typing.py` command.
+        uuid: str  # type: ignore[no-redef]
+        axis_translation: str  # type: ignore[no-redef]
+
+
+class VrmAddonObjectExtensionPropertyGroup(PropertyGroup):
+    axis_translation: EnumProperty(  # type: ignore[valid-type]
+        items=VrmAddonBoneExtensionPropertyGroup.axis_translation_enum.items(),
+        name="Axis Translation on Export",
+    )
+
+    if TYPE_CHECKING:
+        # This code is auto generated.
+        # To regenerate, run the `uv run tools/property_typing.py` command.
+        axis_translation: str  # type: ignore[no-redef]
+
+
+class VrmAddonArmatureExtensionPropertyGroup(PropertyGroup):
+    UNMANAGED_ADDON_VERSION = VrmAddonPreferences.UNMANAGED_ADDON_VERSION
+
+    addon_version: IntVectorProperty(  # type: ignore[valid-type]
+        size=3,
+        default=UNMANAGED_ADDON_VERSION,
+    )
+
+    vrm0: PointerProperty(  # type: ignore[valid-type]
+        type=Vrm0PropertyGroup
+    )
+
+    vrm1: PointerProperty(  # type: ignore[valid-type]
+        type=Vrm1PropertyGroup
+    )
+
+    spring_bone1: PointerProperty(  # type: ignore[valid-type]
+        type=SpringBone1SpringBonePropertyGroup
+    )
+
+    node_constraint1: PointerProperty(  # type: ignore[valid-type]
+        type=NodeConstraint1NodeConstraintPropertyGroup
+    )
+
+    khr_character: PointerProperty(  # type: ignore[valid-type]
+        type=KhrCharacterPropertyGroup
+    )
+
+    SPEC_VERSION_VRM0 = "0.0"
+    SPEC_VERSION_VRM1 = "1.0"
+    SPEC_VERSION_KHR_CHARACTER = "KHR_character"
+    SPEC_VERSION_DEFAULT = str(SPEC_VERSION_VRM1)
+    spec_version_items = (
+        (SPEC_VERSION_VRM0, "VRM 0.0", "", "NONE", 0),
+        (SPEC_VERSION_VRM1, "VRM 1.0", "", "NONE", 1),
+        (
+            SPEC_VERSION_KHR_CHARACTER,
+            "KHR Character (Experimental)",
+            "",
+            "EXPERIMENTAL",
+            2,
+        ),
+    )
+
+    def _update_spec_version(self, context: Context) -> None:
+        clear_expression_material_binds(context)
+
+        for blend_shape_group in self.vrm0.blend_shape_master.blend_shape_groups:
+            blend_shape_group.preview = 0
+
+        for expression in self.vrm1.expressions.all_name_to_expression_dict().values():
+            expression.preview = 0
+
+        vrm0_hidden = True
+        vrm1_hidden = True
+        if self.spec_version == self.SPEC_VERSION_VRM0:
+            vrm0_hidden = False
+        elif self.spec_version == self.SPEC_VERSION_VRM1:
+            vrm1_hidden = False
+            Vrm1LookAtPropertyGroup.update_all_previews(context)
+
+        for vrm0_collider in (
+            collider.bpy_object
+            for collider_group in self.vrm0.secondary_animation.collider_groups
+            for collider in collider_group.colliders
+            if collider.bpy_object
+        ):
+            vrm0_collider.hide_set(vrm0_hidden)
+
+        for vrm1_collider in (
+            collider.bpy_object
+            for collider in self.spring_bone1.colliders
+            if collider.bpy_object
+        ):
+            vrm1_collider.hide_set(vrm1_hidden)
+            for child in vrm1_collider.children:
+                child.hide_set(vrm1_hidden)
+
+    spec_version: EnumProperty(  # type: ignore[valid-type]
+        items=spec_version_items,
+        name="Spec Version",
+        update=_update_spec_version,
+        default=SPEC_VERSION_DEFAULT,
+    )
+
+    def is_vrm0(self) -> bool:
+        return str(self.spec_version) == self.SPEC_VERSION_VRM0
+
+    def is_vrm1(self) -> bool:
+        return str(self.spec_version) == self.SPEC_VERSION_VRM1
+
+    def is_vrm(self) -> bool:
+        return (
+            str(self.spec_version) == self.SPEC_VERSION_VRM0
+            or str(self.spec_version) == self.SPEC_VERSION_VRM1
+        )
+
+    def is_khr_character(self) -> bool:
+        return str(self.spec_version) == self.SPEC_VERSION_KHR_CHARACTER
+
+    @staticmethod
+    def has_vrm_model_metadata(obj: Object) -> bool:
+        if obj.type != "ARMATURE":
+            return False
+        armature = obj.data
+        if not isinstance(armature, Armature):
+            return False
+
+        # https://github.com/saturday06/VRM-Addon-for-Blender/blob/2_0_3/io_scene_vrm/editor/migration.py#L372-L373
+        ext = get_armature_extension(armature)
+        if tuple(ext.addon_version) > (2, 0, 1):
+            return True
+
+        # https://github.com/saturday06/VRM-Addon-for-Blender/blob/0_79/importer/model_build.py#L731
+        humanoid_params_key = obj.get("humanoid_params")
+        if not isinstance(humanoid_params_key, str):
+            return False
+
+        # https://github.com/saturday06/VRM-Addon-for-Blender/blob/0_79/importer/model_build.py#L706
+        return "hips" in armature
+
+    if TYPE_CHECKING:
+        # This code is auto generated.
+        # To regenerate, run the `uv run tools/property_typing.py` command.
+        addon_version: Sequence[int]  # type: ignore[no-redef]
+        vrm0: Vrm0PropertyGroup  # type: ignore[no-redef]
+        vrm1: Vrm1PropertyGroup  # type: ignore[no-redef]
+        spring_bone1: SpringBone1SpringBonePropertyGroup  # type: ignore[no-redef]
+        node_constraint1: (  # type: ignore[no-redef]
+            NodeConstraint1NodeConstraintPropertyGroup
+        )
+        khr_character: KhrCharacterPropertyGroup  # type: ignore[no-redef]
+        spec_version: str  # type: ignore[no-redef]
+
+
+class VrmAddonMaterialExtensionPropertyGroup(PropertyGroup):
+    mtoon1: PointerProperty(  # type: ignore[valid-type]
+        type=Mtoon1MaterialPropertyGroup
+    )
+    if TYPE_CHECKING:
+        # This code is auto generated.
+        # To regenerate, run the `uv run tools/property_typing.py` command.
+        mtoon1: Mtoon1MaterialPropertyGroup  # type: ignore[no-redef]
+
+
+class VrmAddonNodeTreeExtensionPropertyGroup(PropertyGroup):
+    UNMANAGED_ADDON_VERSION = VrmAddonPreferences.UNMANAGED_ADDON_VERSION
+
+    addon_version: IntVectorProperty(  # type: ignore[valid-type]
+        size=3,
+        default=UNMANAGED_ADDON_VERSION,
+    )
+    if TYPE_CHECKING:
+        # This code is auto generated.
+        # To regenerate, run the `uv run tools/property_typing.py` command.
+        addon_version: Sequence[int]  # type: ignore[no-redef]

package/browser/addons/vrm/editor/extension_accessor.py

@@ -0,0 +1,75 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+from typing import TYPE_CHECKING, TypeVar
+
+from bpy.types import Armature, Bone, Material, NodeTree, Object, Scene
+
+if TYPE_CHECKING:
+    from .extension import (
+        VrmAddonArmatureExtensionPropertyGroup,
+        VrmAddonBoneExtensionPropertyGroup,
+        VrmAddonMaterialExtensionPropertyGroup,
+        VrmAddonNodeTreeExtensionPropertyGroup,
+        VrmAddonObjectExtensionPropertyGroup,
+        VrmAddonSceneExtensionPropertyGroup,
+    )
+
+__Extension = TypeVar("__Extension")
+
+
+def _get_vrm_addon_extension_or_raise(
+    obj: object, expected_type: type[__Extension]
+) -> __Extension:
+    extension = getattr(obj, "vrm_addon_extension", None)
+    if isinstance(extension, expected_type):
+        return extension
+
+    message = f"{extension} is not a {expected_type} but {type(extension)}"
+    raise TypeError(message)
+
+
+def get_material_extension(
+    material: Material,
+) -> "VrmAddonMaterialExtensionPropertyGroup":
+    from .extension import VrmAddonMaterialExtensionPropertyGroup
+
+    return _get_vrm_addon_extension_or_raise(
+        material, VrmAddonMaterialExtensionPropertyGroup
+    )
+
+
+def get_armature_extension(
+    armature: Armature,
+) -> "VrmAddonArmatureExtensionPropertyGroup":
+    from .extension import VrmAddonArmatureExtensionPropertyGroup
+
+    return _get_vrm_addon_extension_or_raise(
+        armature, VrmAddonArmatureExtensionPropertyGroup
+    )
+
+
+def get_node_tree_extension(
+    node_tree: NodeTree,
+) -> "VrmAddonNodeTreeExtensionPropertyGroup":
+    from .extension import VrmAddonNodeTreeExtensionPropertyGroup
+
+    return _get_vrm_addon_extension_or_raise(
+        node_tree, VrmAddonNodeTreeExtensionPropertyGroup
+    )
+
+
+def get_scene_extension(scene: Scene) -> "VrmAddonSceneExtensionPropertyGroup":
+    from .extension import VrmAddonSceneExtensionPropertyGroup
+
+    return _get_vrm_addon_extension_or_raise(scene, VrmAddonSceneExtensionPropertyGroup)
+
+
+def get_bone_extension(bone: Bone) -> "VrmAddonBoneExtensionPropertyGroup":
+    from .extension import VrmAddonBoneExtensionPropertyGroup
+
+    return _get_vrm_addon_extension_or_raise(bone, VrmAddonBoneExtensionPropertyGroup)
+
+
+def get_object_extension(obj: Object) -> "VrmAddonObjectExtensionPropertyGroup":
+    from .extension import VrmAddonObjectExtensionPropertyGroup
+
+    return _get_vrm_addon_extension_or_raise(obj, VrmAddonObjectExtensionPropertyGroup)

package/browser/addons/vrm/editor/handler.py

@@ -0,0 +1,84 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+
+from dataclasses import dataclass, field
+from typing import Final
+
+import bpy
+from bpy.app.handlers import persistent
+from bpy.types import Depsgraph, Scene
+
+from ..common.logger import get_logger
+from .extension_accessor import get_armature_extension, get_scene_extension
+from .vrm1.ops import update_vrm1_expression_ui_list_elements
+
+_logger = get_logger(__name__)
+
+
+@dataclass
+class State:
+    last_scene_names: Final[list[str]] = field(default_factory=list[str])
+    last_armature_names: Final[list[str]] = field(default_factory=list[str])
+
+    def clear(self) -> None:
+        self.last_scene_names.clear()
+        self.last_armature_names.clear()
+
+
+_state: Final = State()
+
+
+@persistent
+def depsgraph_update_post(_scene: Scene, depsgraph: Depsgraph) -> None:
+    # This callback is invoked very frequently,
+    # so please keep the checks for changes as lightweight as possible.
+    # Be careful as this can easily cause recursive calls.
+    context = bpy.context
+
+    if (
+        depsgraph.id_type_updated("SCENE")
+        and (True, scenes := context.blend_data.scenes)
+        and (
+            len(scenes) != len(_state.last_scene_names)
+            or any(
+                last_scene_name != scene.name
+                for last_scene_name, scene in zip(_state.last_scene_names, scenes)
+            )
+        )
+    ):
+        new_scenes = [
+            scene for scene in scenes if scene.name not in _state.last_scene_names
+        ]
+        _state.last_scene_names.clear()
+        _state.last_scene_names.extend(scene.name for scene in scenes)
+        for new_scene in new_scenes:
+            get_scene_extension(new_scene).update_vrm0_material_property_names(context)
+
+    if (
+        depsgraph.id_type_updated("ARMATURE")
+        and (True, armatures := context.blend_data.armatures)
+        and (
+            len(armatures) != len(_state.last_armature_names)
+            or any(
+                last_armature_name != armature.name
+                for last_armature_name, armature in zip(
+                    _state.last_armature_names, armatures
+                )
+            )
+        )
+    ):
+        new_armatures = [
+            armature
+            for armature in armatures
+            if armature.name not in _state.last_armature_names
+        ]
+        _state.last_armature_names.clear()
+        _state.last_armature_names.extend(armature.name for armature in armatures)
+        for new_armature in new_armatures:
+            ext = get_armature_extension(new_armature)
+            expressions = ext.vrm1.expressions
+            expressions.fill_missing_expression_names()
+        update_vrm1_expression_ui_list_elements(context)
+
+
+def clear_global_variables() -> None:
+    _state.clear()

package/browser/addons/vrm/editor/khr_character/__init__.py

@@ -0,0 +1 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later

package/browser/addons/vrm/editor/khr_character/panel.py

@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+
+
+from typing import ClassVar
+
+from bpy.types import Armature, Context, Panel
+
+from .. import search
+from ..extension_accessor import get_armature_extension
+from ..khr_xmp_json_ld.panel import draw_khr_xmp_json_ld_packet_layout
+from ..panel import VRM_PT_vrm_armature_object_property
+
+
+class VRM_PT_khr_character_armature_object_property(Panel):
+    bl_idname = "VRM_PT_khr_character_armature_object_property"
+    bl_label = "XMP Linked Data"
+    bl_translation_context = "VRM"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "object"
+    bl_options: ClassVar = {"DEFAULT_CLOSED"}
+    bl_parent_id = VRM_PT_vrm_armature_object_property.bl_idname
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        return search.active_object_is_khr_character_armature(context)
+
+    def draw(self, context: Context) -> None:
+        active_object = context.active_object
+        if not active_object or active_object.type != "ARMATURE":
+            return
+        armature_data = active_object.data
+        if not isinstance(armature_data, Armature):
+            return
+        ext = get_armature_extension(armature_data)
+        draw_khr_xmp_json_ld_packet_layout(
+            context,
+            active_object,
+            self.layout,
+            ext.khr_character.khr_xmp_json_ld_packet,
+        )
+
+
+class VRM_PT_khr_character_ui(Panel):
+    bl_idname = "VRM_PT_khr_character_ui"
+    bl_label = "XMP Linked Data"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "UI"
+    bl_category = "VRM"
+    bl_options: ClassVar = {"DEFAULT_CLOSED"}
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        return search.active_object_is_khr_character_armature(context)
+
+    def draw(self, context: Context) -> None:
+        active_object = context.active_object
+        if not active_object or active_object.type != "ARMATURE":
+            return
+        armature_data = active_object.data
+        if not isinstance(armature_data, Armature):
+            return
+        ext = get_armature_extension(armature_data)
+        draw_khr_xmp_json_ld_packet_layout(
+            context,
+            active_object,
+            self.layout,
+            ext.khr_character.khr_xmp_json_ld_packet,
+        )

package/browser/addons/vrm/editor/khr_character/property_group.py

@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+
+
+from typing import TYPE_CHECKING
+
+from bpy.props import (
+    PointerProperty,
+)
+from bpy.types import PropertyGroup
+
+from ...common.logger import get_logger
+from ..khr_xmp_json_ld.property_group import KhrXmpJsonLdKhrCharacterPacketPropertyGroup
+
+_logger = get_logger(__name__)
+
+
+class KhrCharacterPropertyGroup(PropertyGroup):
+    khr_xmp_json_ld_packet: PointerProperty(  # type: ignore[valid-type]
+        type=KhrXmpJsonLdKhrCharacterPacketPropertyGroup
+    )
+
+    if TYPE_CHECKING:
+        # This code is auto generated.
+        # To regenerate, run the `uv run tools/property_typing.py` command.
+        khr_xmp_json_ld_packet: (  # type: ignore[no-redef]
+            KhrXmpJsonLdKhrCharacterPacketPropertyGroup
+        )

package/browser/addons/vrm/editor/khr_xmp_json_ld/__init__.py

@@ -0,0 +1 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later