@volter/blender-engine 0.1.148 → 0.1.149

package/browser/addons/vrm/common/shape_key_mapper/__init__.py

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

package/browser/addons/vrm/common/shape_key_mapper/arkit_mapping.py

@@ -0,0 +1,168 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+
+from collections.abc import Mapping, Sequence
+from typing import Final
+
+from ..vrm1.expression_preset import (
+    ExpressionPreset,
+    ExpressionPresets,
+)
+
+ARKIT_SHAPE_KEYS: Final[tuple[str, ...]] = (
+    # https://developer.apple.com/documentation/arkit/arfaceanchor/blendshapelocation
+    "eyeBlinkLeft",
+    "eyeLookDownLeft",
+    "eyeLookInLeft",
+    "eyeLookOutLeft",
+    "eyeLookUpLeft",
+    "eyeSquintLeft",
+    "eyeWideLeft",
+    "eyeBlinkRight",
+    "eyeLookDownRight",
+    "eyeLookInRight",
+    "eyeLookOutRight",
+    "eyeLookUpRight",
+    "eyeSquintRight",
+    "eyeWideRight",
+    "jawForward",
+    "jawLeft",
+    "jawRight",
+    "jawOpen",
+    "mouthClose",
+    "mouthFunnel",
+    "mouthPucker",
+    "mouthLeft",
+    "mouthRight",
+    "mouthSmileLeft",
+    "mouthSmileRight",
+    "mouthFrownLeft",
+    "mouthFrownRight",
+    "mouthDimpleLeft",
+    "mouthDimpleRight",
+    "mouthStretchLeft",
+    "mouthStretchRight",
+    "mouthRollLower",
+    "mouthRollUpper",
+    "mouthShrugLower",
+    "mouthShrugUpper",
+    "mouthPressLeft",
+    "mouthPressRight",
+    "mouthLowerDownLeft",
+    "mouthLowerDownRight",
+    "mouthUpperUpLeft",
+    "mouthUpperUpRight",
+    "browDownLeft",
+    "browDownRight",
+    "browInnerUp",
+    "browOuterUpLeft",
+    "browOuterUpRight",
+    "cheekPuff",
+    "cheekSquintLeft",
+    "cheekSquintRight",
+    "noseSneerLeft",
+    "noseSneerRight",
+    "tongueOut",
+)
+
+
+VRM1_PRESET_TO_ARKIT_SHAPE_KEY_MAPPING: Final[
+    Mapping[ExpressionPreset, Sequence[Mapping[str, float]]]
+] = {
+    ExpressionPresets.HAPPY: [
+        {
+            "mouthSmileLeft": 0.5,
+            "mouthSmileRight": 0.5,
+        }
+    ],
+    ExpressionPresets.ANGRY: [
+        {
+            "mouthFrownLeft": 0.5,
+            "mouthFrownRight": 0.5,
+        }
+    ],
+    ExpressionPresets.SAD: [
+        {
+            "browDownLeft": 0.25,
+            "browDownRight": 0.25,
+        }
+    ],
+    ExpressionPresets.SURPRISED: [
+        {
+            "browInnerUp": 0.25,
+            "browOuterUpLeft": 0.25,
+            "browOuterUpRight": 0.25,
+            "jawOpen": 0.25,
+        }
+    ],
+    ExpressionPresets.AA: [
+        {
+            "jawOpen": 0.5,
+        }
+    ],
+    ExpressionPresets.IH: [
+        {
+            "jawOpen": 0.2,
+            "mouthStretchLeft": 0.2,
+            "mouthStretchRight": 0.2,
+        }
+    ],
+    ExpressionPresets.OU: [
+        {
+            "jawOpen": 0.2,
+            "mouthPucker": 0.2,
+        }
+    ],
+    ExpressionPresets.EE: [
+        {
+            "jawOpen": 0.3,
+            "mouthStretchLeft": 0.3,
+            "mouthStretchRight": 0.3,
+        }
+    ],
+    ExpressionPresets.OH: [
+        {
+            "jawOpen": 0.3,
+            "mouthPucker": 0.3,
+        }
+    ],
+    ExpressionPresets.BLINK: [
+        {
+            "eyeBlinkLeft": 1.0,
+            "eyeBlinkRight": 1.0,
+        }
+    ],
+    ExpressionPresets.BLINK_LEFT: [
+        {
+            "eyeBlinkLeft": 1.0,
+        }
+    ],
+    ExpressionPresets.BLINK_RIGHT: [
+        {
+            "eyeBlinkRight": 1.0,
+        }
+    ],
+    ExpressionPresets.LOOK_UP: [
+        {
+            "eyeLookUpLeft": 1.0,
+            "eyeLookUpRight": 1.0,
+        }
+    ],
+    ExpressionPresets.LOOK_DOWN: [
+        {
+            "eyeLookDownLeft": 1.0,
+            "eyeLookDownRight": 1.0,
+        }
+    ],
+    ExpressionPresets.LOOK_LEFT: [
+        {
+            "eyeLookOutLeft": 1.0,
+            "eyeLookInRight": 1.0,
+        }
+    ],
+    ExpressionPresets.LOOK_RIGHT: [
+        {
+            "eyeLookInLeft": 1.0,
+            "eyeLookOutRight": 1.0,
+        }
+    ],
+}

package/browser/addons/vrm/common/shape_key_mapper/mmd_mapping.py

@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+
+from collections.abc import Mapping, Sequence
+from typing import Final
+
+from ..vrm1.expression_preset import ExpressionPreset, ExpressionPresets
+
+VRM1_PRESET_TO_MMD_SHAPE_KEY_MAPPING: Final[
+    Mapping[ExpressionPreset, Sequence[Mapping[str, float]]]
+] = {
+    ExpressionPresets.AA: [
+        {"あ": 1.0},
+    ],
+    ExpressionPresets.IH: [
+        {"い": 1.0},
+    ],
+    ExpressionPresets.OU: [
+        {"う": 1.0},
+    ],
+    ExpressionPresets.EE: [
+        {"え": 1.0},
+        {"えー": 0.5},
+    ],
+    ExpressionPresets.OH: [
+        {"お": 1.0},
+    ],
+    ExpressionPresets.BLINK: [
+        {"まばたき": 1.0},
+    ],
+    ExpressionPresets.BLINK_RIGHT: [
+        {"ウィンク右": 1.0},
+        {"ウィンク２右": 1.0},
+        {"ｳｨﾝｸ２右": 1.0},
+    ],
+    ExpressionPresets.BLINK_LEFT: [
+        {"ウィンク": 1.0},
+        {"ウィンク２": 1.0},
+        {"ｳｨﾝｸ２": 1.0},
+    ],
+    ExpressionPresets.HAPPY: [
+        {"笑い": 1.0},
+        {"にこり": 1.0},
+    ],
+    ExpressionPresets.RELAXED: [
+        {"なごみ": 1.0},
+    ],
+    ExpressionPresets.ANGRY: [
+        {"怒り": 1.0},
+    ],
+    ExpressionPresets.SAD: [
+        {"困る": 1.0},
+    ],
+    ExpressionPresets.SURPRISED: [
+        {"びっくり": 1.0},
+    ],
+    ExpressionPresets.LOOK_UP: [
+        {"上": 1.0},
+    ],
+    ExpressionPresets.LOOK_DOWN: [
+        {"下": 1.0},
+    ],
+}

package/browser/addons/vrm/common/shape_key_mapper/ready_player_me_mapping.py

@@ -0,0 +1,52 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+
+from collections.abc import Mapping, Sequence
+from typing import Final
+
+from ..vrm1.expression_preset import ExpressionPreset, ExpressionPresets
+
+VRM1_PRESET_TO_READY_PLAYER_ME_SHAPE_KEY_MAPPING: Final[
+    Mapping[ExpressionPreset, Sequence[Mapping[str, float]]]
+] = {
+    # https://docs.readyplayer.me/ready-player-me/api-reference/avatars/morph-targets/oculus-ovr-libsync
+    ExpressionPresets.AA: [
+        {"viseme_aa": 1.0},
+    ],
+    ExpressionPresets.IH: [
+        {"viseme_I": 1.0},
+    ],
+    ExpressionPresets.OU: [
+        {"viseme_U": 1.0},
+    ],
+    ExpressionPresets.EE: [
+        {"viseme_E": 1.0},
+    ],
+    ExpressionPresets.OH: [
+        {"viseme_O": 1.0},
+    ],
+    # https://docs.readyplayer.me/ready-player-me/api-reference/avatars/morph-targets/apple-arkit
+    ExpressionPresets.BLINK: [
+        {"eyesClosed": 1.0},
+    ],
+    ExpressionPresets.BLINK_LEFT: [
+        {"eyeBlinkLeft": 1},
+    ],
+    ExpressionPresets.BLINK_RIGHT: [
+        {"eyeBlinkRight": 1},
+    ],
+    ExpressionPresets.LOOK_UP: [
+        {"eyeLookUp": 0.75},
+    ],
+    ExpressionPresets.LOOK_DOWN: [
+        {"eyesLookDown": 0.75},
+    ],
+    ExpressionPresets.RELAXED: [
+        {"browInnerUp": 0.5},
+    ],
+    ExpressionPresets.HAPPY: [
+        {"mouthSmile": 0.5},
+    ],
+    ExpressionPresets.SAD: [
+        {"mouthFrown": 0.5},
+    ],
+}

package/browser/addons/vrm/common/shape_key_mapper/vrchat_mapping.py

@@ -0,0 +1,17 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+
+from collections.abc import Mapping, Sequence
+from typing import Final
+
+from ..vrm1.expression_preset import ExpressionPreset, ExpressionPresets
+
+VRM1_PRESET_TO_VRCHAT_SHAPE_KEY_MAPPING: Final[
+    Mapping[ExpressionPreset, Sequence[Mapping[str, float]]]
+] = {
+    ExpressionPresets.AA: [{"vrc.v_aa": 1.0}, {"vrc_v_aa": 1.0}],
+    ExpressionPresets.EE: [{"vrc.v_e": 1.0}, {"vrc_v_e": 1.0}],
+    ExpressionPresets.IH: [{"vrc.v_ih": 1.0}, {"vrc_v_ih": 1.0}],
+    ExpressionPresets.OH: [{"vrc.v_oh": 1.0}, {"vrc_v_oh": 1.0}],
+    ExpressionPresets.OU: [{"vrc.v_ou": 1.0}, {"vrc_v_ou": 1.0}],
+    ExpressionPresets.BLINK: [{"Blink": 1.0}],
+}

package/browser/addons/vrm/common/third_party_user_extension.py

@@ -0,0 +1,214 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+import inspect
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+from types import ModuleType
+from typing import Optional
+
+import bpy
+from bpy.types import Context
+
+from . import convert
+from .logger import get_logger
+
+_logger = get_logger(__name__)
+
+
+def get_third_party_user_extension_name(module: ModuleType) -> Optional[str]:
+    module_name = module.__name__
+    module_init_path_str = getattr(module, "__file__", None)
+    if not isinstance(module_init_path_str, str):
+        _logger.warning(
+            "Module %s does not have a valid __file__ attribute",
+            module_name,
+        )
+        return None
+    if not module_init_path_str:
+        _logger.warning(
+            "Module %s has an empty __file__ attribute",
+            module_name,
+        )
+        return None
+    module_init_path = Path(module_init_path_str)
+    if not module_init_path.exists():
+        _logger.warning("Module init path %s does not exist", module_init_path)
+        return None
+    module_root_path = module_init_path.parent
+    if not module_root_path.is_dir():
+        _logger.warning("Module root path %s is not a directory", module_root_path)
+        return None
+
+    if (
+        bpy.app.version >= (4, 2)
+        and (
+            blender_manifest_path := module_root_path / "blender_manifest.toml"
+        ).exists()
+        and sys.version_info >= (3, 11)
+    ):
+        import tomllib
+
+        try:
+            blender_manifest_str = blender_manifest_path.read_text(encoding="utf-8")
+        except (OSError, UnicodeError):
+            _logger.exception(
+                "Failed to read blender_manifest.toml for module %s",
+                module_name,
+            )
+            return None
+        try:
+            blender_manifest = tomllib.loads(blender_manifest_str)
+        except tomllib.TOMLDecodeError:
+            _logger.warning(
+                "Failed to parse blender_manifest.toml for module %s",
+                module_name,
+            )
+            return None
+        blender_manifest_name = blender_manifest.get("name")
+        if not isinstance(blender_manifest_name, str) or not blender_manifest_name:
+            _logger.warning(
+                "Module %s has a blender_manifest.toml without a valid name",
+                module_name,
+            )
+            return None
+        blender_manifest_version = blender_manifest.get("version")
+        if (
+            not isinstance(blender_manifest_version, str)
+            or not blender_manifest_version
+        ):
+            _logger.warning(
+                "Module %s has a blender_manifest.toml without a valid version",
+                module_name,
+            )
+            return None
+        return blender_manifest_name + " " + blender_manifest_version
+
+    bl_info = convert.mapping_or_none(getattr(module, "bl_info", None))
+    if not bl_info:
+        _logger.warning(
+            "Module %s does not have a valid bl_info dictionary",
+            module_name,
+        )
+        return None
+
+    bl_info_name = bl_info.get("name")
+    if not isinstance(bl_info_name, str):
+        bl_info_name = module_name
+
+    bl_info_version = convert.sequence_or_none(bl_info.get("version"))
+    if not bl_info_version:
+        bl_info_version = ("no-version",)
+
+    return (
+        bl_info_name
+        + " "
+        + ".".join(str(version_element) for version_element in bl_info_version)
+    )
+
+
+def collect_third_party_user_extensions(
+    context: Context, user_extension_class_name: str
+) -> list[tuple[str, object]]:
+    user_extensions: list[tuple[str, object]] = []
+    preferences = context.preferences
+    for addon_name in preferences.addons.keys():
+        addon_module = sys.modules.get(addon_name)
+        if addon_module is None:
+            continue
+        user_extension_name = get_third_party_user_extension_name(addon_module)
+        if user_extension_name is None:
+            continue
+        user_extension_type = getattr(addon_module, user_extension_class_name, None)
+        if not isinstance(user_extension_type, type):
+            continue
+        try:
+            user_extension: object = user_extension_type()
+        except Exception:
+            _logger.exception(
+                "Failed to instantiate %s from addon '%s'",
+                user_extension_class_name,
+                addon_name,
+            )
+            continue
+        user_extensions.append((user_extension_name, user_extension))
+    return user_extensions
+
+
+def trigger_third_party_user_extension_hook(
+    user_extensions: Sequence[object], method_name: str, *args: object
+) -> None:
+    for user_extension in user_extensions:
+        method = getattr(user_extension, method_name, None)
+        if not callable(method):
+            continue
+
+        try:
+            parameters = tuple(inspect.signature(method).parameters.values())
+        except (TypeError, ValueError):
+            # Some callables implemented outside Python don't expose a signature.
+            method_args = args
+        else:
+            if any(
+                parameter.kind is inspect.Parameter.KEYWORD_ONLY
+                and parameter.default is inspect.Parameter.empty
+                for parameter in parameters
+            ):
+                _logger.error(
+                    "Failed to call %s of %s from addon '%s': "
+                    "the callback has keyword-only arguments without defaults",
+                    method_name,
+                    user_extension.__class__.__name__,
+                    user_extension.__class__.__module__,
+                )
+                continue
+
+            min_arg_count = sum(
+                1
+                for parameter in parameters
+                if parameter.default is inspect.Parameter.empty
+                and parameter.kind
+                in (
+                    inspect.Parameter.POSITIONAL_ONLY,
+                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                )
+            )
+            if len(args) < min_arg_count:
+                _logger.error(
+                    "Failed to call %s of %s from addon '%s': "
+                    "the callback requires %d argument%s, but only %d %s available",
+                    method_name,
+                    user_extension.__class__.__name__,
+                    user_extension.__class__.__module__,
+                    min_arg_count,
+                    "" if min_arg_count == 1 else "s",
+                    len(args),
+                    "is" if len(args) == 1 else "are",
+                )
+                continue
+
+            max_arg_count = sum(
+                1
+                for parameter in parameters
+                if parameter.kind
+                in (
+                    inspect.Parameter.POSITIONAL_ONLY,
+                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                )
+            )
+            if any(
+                parameter.kind is inspect.Parameter.VAR_POSITIONAL
+                for parameter in parameters
+            ):
+                method_args = args
+            else:
+                method_args = args[:max_arg_count]
+
+        try:
+            method(*method_args)
+        except Exception:
+            _logger.exception(
+                "Failed to call %s of %s from addon '%s'",
+                method_name,
+                user_extension.__class__.__name__,
+                user_extension.__class__.__module__,
+            )

package/browser/addons/vrm/common/version.py

@@ -0,0 +1,161 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+import platform
+from dataclasses import dataclass
+from sys import float_info
+from typing import Optional
+
+import bpy
+from bpy.app.translations import pgettext
+
+from .blender_manifest import BlenderManifest
+from .logger import get_logger
+
+_logger = get_logger(__name__)
+
+
+@dataclass
+class Cache:
+    use: bool
+    last_blender_restart_required: bool
+    last_blender_manifest_modification_time: float
+    initial_blender_manifest_content: bytes
+
+
+_cache = Cache(
+    use=False,
+    last_blender_restart_required=False,
+    last_blender_manifest_modification_time=0.0,
+    initial_blender_manifest_content=BlenderManifest.default_blender_manifest_path().read_bytes(),
+)
+
+
+def _clear_addon_version_cache() -> Optional[float]:
+    _cache.use = False
+    return None
+
+
+def trigger_clear_addon_version_cache() -> None:
+    if tuple(bpy.app.version) >= (4, 2):
+        return
+    if bpy.app.timers.is_registered(_clear_addon_version_cache):
+        return
+    bpy.app.timers.register(_clear_addon_version_cache, first_interval=0.5)
+
+
+def _min_unsupported_blender_major_minor_version() -> Optional[tuple[int, int]]:
+    blender_version_max = BlenderManifest.read().blender_version_max
+    if blender_version_max is None:
+        return None
+    return (blender_version_max[0], blender_version_max[1])
+
+
+def get_addon_version() -> tuple[int, int, int]:
+    return BlenderManifest.read().version
+
+
+def _blender_restart_required() -> bool:
+    if tuple(bpy.app.version) >= (4, 2):
+        return False
+
+    if _cache.use:
+        return _cache.last_blender_restart_required
+
+    _cache.use = True
+
+    if _cache.last_blender_restart_required:
+        return True
+
+    blender_manifest_path = BlenderManifest.default_blender_manifest_path()
+    blender_manifest_modification_time = blender_manifest_path.stat().st_mtime
+    if (
+        abs(
+            _cache.last_blender_manifest_modification_time
+            - blender_manifest_modification_time
+        )
+        < float_info.epsilon
+    ):
+        return False
+
+    _cache.last_blender_manifest_modification_time = blender_manifest_modification_time
+
+    blender_manifest_content = blender_manifest_path.read_bytes()
+    if blender_manifest_content == _cache.initial_blender_manifest_content:
+        return False
+
+    _cache.last_blender_restart_required = True
+    return True
+
+
+def _stable_release() -> bool:
+    if bpy.app.version_cycle == "release":
+        return True
+
+    # Microsoft Store distributes RC versions of 3.3.11 and 3.6.3 as
+    # release versions.
+    return platform.system() == "Windows" and bpy.app.version_cycle == "rc"
+
+
+def supported() -> bool:
+    v = _min_unsupported_blender_major_minor_version()
+    if v is None:
+        return True
+    return bpy.app.version[:2] < v
+
+
+def preferences_warning_message() -> Optional[str]:
+    if _blender_restart_required():
+        return pgettext(
+            "The VRM add-on has been updated."
+            + " Please restart Blender to apply the changes."
+        )
+    if not _stable_release():
+        return pgettext(
+            "VRM add-on is not compatible with Blender {blender_version_cycle}."
+        ).format(blender_version_cycle=bpy.app.version_cycle.capitalize())
+    if not supported():
+        return pgettext(
+            "The installed VRM add-on is not compatible with Blender {blender_version}."
+            + " Please upgrade the add-on.",
+        ).format(blender_version=".".join(map(str, bpy.app.version[:2])))
+    return None
+
+
+def panel_warning_message() -> Optional[str]:
+    if _blender_restart_required():
+        return pgettext(
+            "The VRM add-on has been\n"
+            + "updated. Please restart Blender\n"
+            + "to apply the changes."
+        )
+    if not _stable_release():
+        return pgettext(
+            "VRM add-on is\n"
+            + "not compatible with\n"
+            + "Blender {blender_version_cycle}."
+        ).format(blender_version_cycle=bpy.app.version_cycle.capitalize())
+    if not supported():
+        return pgettext(
+            "The installed VRM add-\n"
+            + "on is not compatible with\n"
+            + "Blender {blender_version}. Please update."
+        ).format(blender_version=".".join(map(str, bpy.app.version[:2])))
+    return None
+
+
+def validation_warning_message() -> Optional[str]:
+    if _blender_restart_required():
+        return pgettext(
+            "The VRM add-on has been updated."
+            + " Please restart Blender to apply the changes."
+        )
+    if not _stable_release():
+        return pgettext(
+            "VRM add-on is not compatible with Blender {blender_version_cycle}."
+            + " The VRM may not be exported correctly.",
+        ).format(blender_version_cycle=bpy.app.version_cycle.capitalize())
+    if not supported():
+        return pgettext(
+            "The installed VRM add-on is not compatible with Blender {blender_version}."
+            + " The VRM may not be exported correctly."
+        ).format(blender_version=".".join(map(str, bpy.app.version)))
+    return None

package/browser/addons/vrm/common/vrm0/__init__.py

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