@volter/blender-engine 0.1.148 → 0.1.149

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

@@ -0,0 +1,90 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+from dataclasses import dataclass
+
+from bpy.types import Armature, Context
+
+from ...common import ops
+from ...common.logger import get_logger
+from ...common.scene_watcher import RunState, SceneWatcher
+from ..extension_accessor import get_armature_extension
+from .property_group import Vrm1LookAtPropertyGroup
+
+_logger = get_logger(__name__)
+
+
+@dataclass
+class LookAtPreviewUpdater(SceneWatcher):
+    object_index: int = 0
+
+    def reset_run_progress(self) -> None:
+        self.object_index = 0
+
+    def run(self, context: Context) -> RunState:
+        """Detect updates to the target object of Look At and update the state."""
+        # If this value becomes zero, return PREEMPT and interrupt the process.
+        # If a change is detected, update previews and return FINISH.
+        preempt_countdown = 50
+
+        if not context.blend_data.armatures:
+            return RunState.FINISH
+        objects = context.visible_objects
+        if not objects:
+            return RunState.FINISH
+
+        objects_len = len(objects)
+        if self.object_index >= objects_len:
+            self.object_index = 0
+
+        next_object_index = self.object_index
+        for obj in objects[self.object_index : objects_len]:
+            self.object_index = next_object_index
+            next_object_index += 1
+
+            preempt_countdown -= 1
+            if preempt_countdown <= 0:
+                return RunState.PREEMPT
+
+            if obj.type != "ARMATURE":
+                continue
+            armature_data = obj.data
+            if not isinstance(armature_data, Armature):
+                continue
+            ext = get_armature_extension(armature_data)
+            if not ext.is_vrm1():
+                continue
+            look_at = ext.vrm1.look_at
+            if look_at.update_preview(context, obj, ext.vrm1, check_only=True):
+                Vrm1LookAtPropertyGroup.update_all_previews(context)
+                return RunState.FINISH
+
+            preempt_countdown -= 10
+
+        return RunState.FINISH
+
+    def create_fast_path_performance_test_objects(self, context: Context) -> None:
+        blend_data = context.blend_data
+
+        for i in range(300):
+            if i % 3 != 0:
+                mesh = blend_data.meshes.new(f"Mesh#{i}")
+                obj = blend_data.objects.new(f"Object#{i}", mesh)
+                context.scene.collection.objects.link(obj)
+                continue
+
+            ops.icyp.make_basic_armature()
+            active_object = context.active_object
+            if not active_object:
+                message = f"Not an armature: {active_object}"
+                raise ValueError(message)
+            armature = active_object.data
+            if not isinstance(armature, Armature):
+                raise TypeError
+
+            ext = get_armature_extension(armature)
+            ext.spec_version = ext.SPEC_VERSION_VRM1
+            look_at = ext.vrm1.look_at
+            look_at.type = ext.vrm1.look_at.TYPE_BONE.identifier
+            look_at.preview_target_bpy_object = blend_data.objects[
+                i * 5 % len(blend_data.objects)
+            ]
+            ext.vrm1.look_at.enable_preview = True

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

@@ -0,0 +1,533 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+from bpy.app.translations import pgettext
+from bpy.types import Context, Mesh, UILayout, UIList
+
+from ...common import convert
+from ...common.logger import get_logger
+from ..property_group import StringPropertyGroup
+from .property_group import (
+    Vrm1ExpressionsPropertyGroup,
+    Vrm1FirstPersonPropertyGroup,
+    Vrm1MaterialColorBindPropertyGroup,
+    Vrm1MeshAnnotationPropertyGroup,
+    Vrm1MetaPropertyGroup,
+    Vrm1MorphTargetBindPropertyGroup,
+    Vrm1TextureTransformBindPropertyGroup,
+)
+
+_logger = get_logger(__name__)
+
+
+class VRM_UL_vrm1_meta_author(UIList):
+    bl_idname = "VRM_UL_vrm1_meta_author"
+
+    def filter_items(
+        self,
+        _context: Context,
+        data: object,
+        propname: str,
+    ) -> tuple[list[int], list[int]]:
+        items = convert.sequence_or_none(getattr(data, propname, None))
+        if items is None:
+            return ([], [])
+
+        flt_flags: list[int] = [self.bitflag_filter_item] * len(items)
+        flt_neworder: list[int] = []
+
+        filter_name: str = self.filter_name.casefold()
+        if not filter_name:
+            return (flt_flags, flt_neworder)
+
+        for index, item in enumerate(items):
+            if (
+                isinstance(item, StringPropertyGroup)
+                and filter_name in item.value.casefold()
+            ):
+                continue
+            flt_flags[index] = 0
+
+        return (flt_flags, flt_neworder)
+
+    def draw_item(
+        self,
+        _context: Context,
+        layout: UILayout,
+        meta: object,
+        author: object,
+        _icon: int,
+        _active_data: object,
+        _active_prop_name: str,
+        index: int,
+        _flt_flag: int,
+    ) -> None:
+        if not isinstance(meta, Vrm1MetaPropertyGroup):
+            return
+        if not isinstance(author, StringPropertyGroup):
+            return
+
+        icon = "USER"
+
+        if self.layout_type == "GRID":
+            layout.alignment = "CENTER"
+            layout.label(text="", translate=False, icon=icon)
+            return
+
+        if self.layout_type not in {"DEFAULT", "COMPACT"}:
+            return
+
+        if index == meta.active_author_index:
+            layout.prop(author, "value", icon=icon, text="", translate=False)
+        else:
+            layout.label(text=author.value, icon=icon, translate=False)
+
+
+class VRM_UL_vrm1_meta_reference(UIList):
+    bl_idname = "VRM_UL_vrm1_meta_reference"
+
+    def filter_items(
+        self,
+        _context: Context,
+        data: object,
+        propname: str,
+    ) -> tuple[list[int], list[int]]:
+        items = convert.sequence_or_none(getattr(data, propname, None))
+        if items is None:
+            return ([], [])
+
+        flt_flags: list[int] = [self.bitflag_filter_item] * len(items)
+        flt_neworder: list[int] = []
+
+        filter_name: str = self.filter_name.casefold()
+        if not filter_name:
+            return (flt_flags, flt_neworder)
+
+        for index, item in enumerate(items):
+            if (
+                isinstance(item, StringPropertyGroup)
+                and filter_name in item.value.casefold()
+            ):
+                continue
+            flt_flags[index] = 0
+
+        return (flt_flags, flt_neworder)
+
+    def draw_item(
+        self,
+        _context: Context,
+        layout: UILayout,
+        meta: object,
+        reference: object,
+        _icon: int,
+        _active_data: object,
+        _active_prop_name: str,
+        index: int,
+        _flt_flag: int,
+    ) -> None:
+        if not isinstance(meta, Vrm1MetaPropertyGroup):
+            return
+        if not isinstance(reference, StringPropertyGroup):
+            return
+
+        icon = "URL"
+
+        if self.layout_type == "GRID":
+            layout.alignment = "CENTER"
+            layout.label(text="", translate=False, icon=icon)
+            return
+
+        if self.layout_type not in {"DEFAULT", "COMPACT"}:
+            return
+
+        if index == meta.active_reference_index:
+            layout.prop(reference, "value", icon=icon, text="", translate=False)
+        else:
+            layout.label(text=reference.value, icon=icon, translate=False)
+
+
+class VRM_UL_vrm1_first_person_mesh_annotation(UIList):
+    bl_idname = "VRM_UL_vrm1_first_person_mesh_annotation"
+
+    def filter_items(
+        self,
+        _context: Context,
+        data: object,
+        propname: str,
+    ) -> tuple[list[int], list[int]]:
+        items = convert.sequence_or_none(getattr(data, propname, None))
+        if items is None:
+            return ([], [])
+
+        flt_flags: list[int] = [self.bitflag_filter_item] * len(items)
+        flt_neworder: list[int] = []
+
+        filter_name: str = self.filter_name.casefold()
+        if not filter_name:
+            return (flt_flags, flt_neworder)
+
+        for index, item in enumerate(items):
+            if (
+                isinstance(item, Vrm1MeshAnnotationPropertyGroup)
+                and filter_name in item.node.mesh_object_name.casefold()
+            ):
+                continue
+            flt_flags[index] = 0
+
+        return (flt_flags, flt_neworder)
+
+    def draw_item(
+        self,
+        _context: Context,
+        layout: UILayout,
+        first_person: object,
+        mesh_annotation: object,
+        _icon: int,
+        _active_data: object,
+        _active_prop_name: str,
+        index: int,
+        _flt_flag: int,
+    ) -> None:
+        if not isinstance(first_person, Vrm1FirstPersonPropertyGroup):
+            return
+        if not isinstance(mesh_annotation, Vrm1MeshAnnotationPropertyGroup):
+            return
+
+        icon = "OUTLINER_OB_MESH"
+
+        if self.layout_type == "GRID":
+            layout.alignment = "CENTER"
+            layout.label(text="", translate=False, icon=icon)
+            return
+
+        if self.layout_type not in {"DEFAULT", "COMPACT"}:
+            return
+
+        row = layout.split(factor=0.6, align=True)
+        if index == first_person.active_mesh_annotation_index:
+            row.prop(
+                mesh_annotation.node,
+                "bpy_object",
+                text="",
+                translate=False,
+                icon=icon,
+            )
+        else:
+            row.label(
+                text=mesh_annotation.node.mesh_object_name,
+                translate=False,
+                icon=icon,
+            )
+        row.prop(mesh_annotation, "type", text="", translate=False)
+
+
+class VRM_UL_vrm1_expression(UIList):
+    bl_idname = "VRM_UL_vrm1_expression"
+
+    def filter_items(
+        self,
+        _context: Context,
+        expressions: object,
+        _propname: str,
+    ) -> tuple[list[int], list[int]]:
+        if not isinstance(expressions, Vrm1ExpressionsPropertyGroup):
+            return ([], [])
+
+        expression_ui_list_elements = expressions.expression_ui_list_elements
+        flt_flags: list[int] = [self.bitflag_filter_item] * len(
+            expression_ui_list_elements
+        )
+        flt_neworder: list[int] = []
+
+        filter_name: str = self.filter_name.casefold()
+        if not filter_name:
+            return (flt_flags, flt_neworder)
+
+        preset_expression_items = list(
+            expressions.preset.name_to_expression_dict().items()
+        )
+        preset_len = len(preset_expression_items)
+        custom_expressions = expressions.custom
+
+        for index in range(len(expression_ui_list_elements)):
+            if index < preset_len:
+                name, _ = preset_expression_items[index]
+            else:
+                custom_index = index - preset_len
+                if custom_index >= len(custom_expressions):
+                    flt_flags[index] = 0
+                    continue
+                name = custom_expressions[custom_index].custom_name
+
+            if filter_name not in name.casefold():
+                flt_flags[index] = 0
+
+        return (flt_flags, flt_neworder)
+
+    def draw_item(
+        self,
+        _context: Context,
+        layout: UILayout,
+        expressions: object,
+        _item: object,
+        _icon: int,
+        _active_data: object,
+        _active_prop_name: str,
+        index: int,
+        _flt_flag: int,
+    ) -> None:
+        if not isinstance(expressions, Vrm1ExpressionsPropertyGroup):
+            return
+        preset_expression_items = list(
+            expressions.preset.name_to_expression_dict().items()
+        )
+        if index < len(preset_expression_items):
+            name, expression = preset_expression_items[index]
+            icon = expressions.preset.get_icon(name)
+            if not icon:
+                _logger.error("Unknown preset expression: %s", name)
+                icon = "SHAPEKEY_DATA"
+        else:
+            custom_expressions = expressions.custom
+            custom_index = index - len(preset_expression_items)
+            if custom_index >= len(custom_expressions):
+                return
+            expression = custom_expressions[custom_index]
+            name = expression.custom_name
+            icon = "SHAPEKEY_DATA"
+
+        if self.layout_type == "GRID":
+            layout.alignment = "CENTER"
+            layout.label(text="", translate=False, icon=icon)
+            return
+
+        if self.layout_type not in {"DEFAULT", "COMPACT"}:
+            return
+
+        split = layout.split(align=True, factor=0.55)
+        split.label(text=name, translate=False, icon=icon)
+        split.prop(expression, "preview", text="Preview")
+
+
+class VRM_UL_vrm1_morph_target_bind(UIList):
+    bl_idname = "VRM_UL_vrm1_morph_target_bind"
+
+    def format_label_text(
+        self, context: Context, morph_target_bind: Vrm1MorphTargetBindPropertyGroup
+    ) -> str:
+        text = morph_target_bind.node.mesh_object_name
+        mesh_object = context.blend_data.objects.get(
+            morph_target_bind.node.mesh_object_name
+        )
+        if mesh_object:
+            mesh_data = mesh_object.data
+            if isinstance(mesh_data, Mesh):
+                shape_keys = mesh_data.shape_keys
+                if shape_keys:
+                    keys = shape_keys.key_blocks.keys()
+                    if morph_target_bind.index in keys:
+                        text += " / " + morph_target_bind.index
+        return text
+
+    def filter_items(
+        self,
+        context: Context,
+        data: object,
+        propname: str,
+    ) -> tuple[list[int], list[int]]:
+        items = convert.sequence_or_none(getattr(data, propname, None))
+        if items is None:
+            return ([], [])
+
+        flt_flags: list[int] = [self.bitflag_filter_item] * len(items)
+        flt_neworder: list[int] = []
+
+        filter_name: str = self.filter_name.casefold()
+        if not filter_name:
+            return (flt_flags, flt_neworder)
+
+        for index, item in enumerate(items):
+            if (
+                isinstance(item, Vrm1MorphTargetBindPropertyGroup)
+                and filter_name in self.format_label_text(context, item).casefold()
+            ):
+                continue
+            flt_flags[index] = 0
+
+        return (flt_flags, flt_neworder)
+
+    def draw_item(
+        self,
+        context: Context,
+        layout: UILayout,
+        _data: object,
+        morph_target_bind: object,
+        icon: int,
+        _active_data: object,
+        _active_prop_name: str,
+        _index: int,
+        _flt_flag: int,
+    ) -> None:
+        if not isinstance(morph_target_bind, Vrm1MorphTargetBindPropertyGroup):
+            return
+
+        if self.layout_type == "GRID":
+            layout.alignment = "CENTER"
+            layout.label(text="", icon_value=icon)
+            return
+
+        if self.layout_type not in {"DEFAULT", "COMPACT"}:
+            return
+
+        layout.label(
+            text=self.format_label_text(context, morph_target_bind),
+            translate=False,
+            icon="MESH_DATA",
+        )
+
+
+class VRM_UL_vrm1_material_color_bind(UIList):
+    bl_idname = "VRM_UL_vrm1_material_color_bind"
+
+    def format_label_text(
+        self, material_color_bind: Vrm1MaterialColorBindPropertyGroup
+    ) -> str:
+        text = ""
+        material = material_color_bind.material
+        if material:
+            text = material.name
+            type_name = next(
+                (
+                    enum.name
+                    for enum in Vrm1MaterialColorBindPropertyGroup.type_enum
+                    if enum.identifier == material_color_bind.type
+                ),
+                None,
+            )
+            if type_name:
+                text += " / " + pgettext(type_name)
+        return text
+
+    def filter_items(
+        self,
+        _context: Context,
+        data: object,
+        propname: str,
+    ) -> tuple[list[int], list[int]]:
+        items = convert.sequence_or_none(getattr(data, propname, None))
+        if items is None:
+            return ([], [])
+
+        flt_flags: list[int] = [self.bitflag_filter_item] * len(items)
+        flt_neworder: list[int] = []
+
+        filter_name: str = self.filter_name.casefold()
+        if not filter_name:
+            return (flt_flags, flt_neworder)
+
+        for index, item in enumerate(items):
+            if (
+                isinstance(item, Vrm1MaterialColorBindPropertyGroup)
+                and filter_name in self.format_label_text(item).casefold()
+            ):
+                continue
+            flt_flags[index] = 0
+
+        return (flt_flags, flt_neworder)
+
+    def draw_item(
+        self,
+        _context: Context,
+        layout: UILayout,
+        _data: object,
+        material_color_bind: object,
+        icon: int,
+        _active_data: object,
+        _active_prop_name: str,
+        _index: int,
+        _flt_flag: int,
+    ) -> None:
+        if not isinstance(material_color_bind, Vrm1MaterialColorBindPropertyGroup):
+            return
+
+        if self.layout_type == "GRID":
+            layout.alignment = "CENTER"
+            layout.label(text="", translate=False, icon_value=icon)
+            return
+
+        if self.layout_type not in {"DEFAULT", "COMPACT"}:
+            return
+
+        layout.label(
+            text=self.format_label_text(material_color_bind),
+            translate=False,
+            icon="MATERIAL",
+        )
+
+
+class VRM_UL_vrm1_texture_transform_bind(UIList):
+    bl_idname = "VRM_UL_vrm1_texture_transform_bind"
+
+    def format_label_text(
+        self, texture_transform_bind: Vrm1TextureTransformBindPropertyGroup
+    ) -> str:
+        material = texture_transform_bind.material
+        if not material:
+            return ""
+        return material.name
+
+    def filter_items(
+        self,
+        _context: Context,
+        data: object,
+        propname: str,
+    ) -> tuple[list[int], list[int]]:
+        items = convert.sequence_or_none(getattr(data, propname, None))
+        if items is None:
+            return ([], [])
+
+        flt_flags: list[int] = [self.bitflag_filter_item] * len(items)
+        flt_neworder: list[int] = []
+
+        filter_name: str = self.filter_name.casefold()
+        if not filter_name:
+            return (flt_flags, flt_neworder)
+
+        for index, item in enumerate(items):
+            if (
+                isinstance(item, Vrm1TextureTransformBindPropertyGroup)
+                and filter_name in self.format_label_text(item).casefold()
+            ):
+                continue
+            flt_flags[index] = 0
+
+        return (flt_flags, flt_neworder)
+
+    def draw_item(
+        self,
+        _context: Context,
+        layout: UILayout,
+        _data: object,
+        texture_transform_bind: object,
+        icon: int,
+        _active_data: object,
+        _active_prop_name: str,
+        _index: int,
+        _flt_flag: int,
+    ) -> None:
+        if not isinstance(
+            texture_transform_bind, Vrm1TextureTransformBindPropertyGroup
+        ):
+            return
+
+        if self.layout_type == "GRID":
+            layout.alignment = "CENTER"
+            layout.label(text="", translate=False, icon_value=icon)
+            return
+
+        if self.layout_type not in {"DEFAULT", "COMPACT"}:
+            return
+
+        layout.label(
+            text=self.format_label_text(texture_transform_bind),
+            translate=False,
+            icon="MATERIAL",
+        )

package/browser/addons/vrm/exporter/__init__.py

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