@volter/blender-engine 0.1.148 → 0.1.149

package/browser/addons/vrm/__init__.py

@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2018 iCyP
+
+from . import registration
+from .exporter import gltf2_export_user_extension
+from .importer import gltf2_import_user_extension
+
+bl_info = {
+    "name": "VRM format",
+    "author": "saturday06, iCyP",
+    "version": (
+        4,  # x-release-please-major
+        10,  # x-release-please-minor
+        3,  # x-release-please-patch
+    ),
+    "location": "File > Import-Export",
+    "description": "Import-Edit-Export VRM",
+    "blender": (2, 93, 0),
+    "warning": "",
+    "support": "COMMUNITY",
+    "wiki_url": "",
+    "doc_url": "https://vrm-addon-for-blender.info",
+    "tracker_url": "https://github.com/saturday06/VRM-Addon-for-Blender/issues",
+    "category": "Import-Export",
+}
+
+
+def register() -> None:
+    registration.register()
+
+
+def unregister() -> None:
+    registration.unregister()
+
+
+class glTF2ImportUserExtension(gltf2_import_user_extension.glTF2ImportUserExtension):
+    pass
+
+
+class glTF2ExportUserExtension(gltf2_export_user_extension.glTF2ExportUserExtension):
+    pass

package/browser/addons/vrm/blender_manifest.toml

@@ -0,0 +1,16 @@
+schema_version = "1.0.0"
+id = "vrm"
+version = "4.10.3"
+name = "VRM format"
+tagline = "VRM import, export and editing capabilities"
+maintainer = "Isamu Mogi <dyob@lunaport.net>"
+type = "add-on"
+website = "https://vrm-addon-for-blender.info"
+tags = ["Animation", "Import-Export", "Material", "Modeling", "Physics"]
+blender_version_min = "4.2.0"
+blender_version_max = "5.3.0"
+license = ["SPDX:MIT", "SPDX:GPL-3.0-or-later"]
+copyright = ["2020 Isamu Mogi", "2018 iCyP"]
+
+[permissions]
+files = "Import/export VRM from/to disk"

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

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

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

@@ -0,0 +1,58 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+
+from dataclasses import dataclass
+from typing import Final
+
+from bpy.app.handlers import persistent
+from bpy.types import Context
+
+from .logger import get_logger
+
+_logger = get_logger(__name__)
+
+
+@dataclass
+class State:
+    during_animation_playback: bool = False
+    during_frame_change: bool = False
+
+
+_state: Final = State()
+
+
+def _is_animation_playing(context: Context) -> bool:
+    if _state.during_animation_playback:
+        return True
+    screen = context.screen
+    if not screen:
+        return False
+    return screen.is_animation_playing
+
+
+def defer_shape_key_update(context: Context) -> bool:
+    return _is_animation_playing(context) or _state.during_frame_change
+
+
+@persistent
+def animation_playback_pre(_unused: object) -> None:
+    _state.during_animation_playback = True
+
+
+@persistent
+def animation_playback_post(_unused: object) -> None:
+    _state.during_animation_playback = False
+
+
+@persistent
+def frame_change_pre(_unused: object) -> None:
+    _state.during_frame_change = True
+
+
+@persistent
+def frame_change_post(_unused: object) -> None:
+    _state.during_frame_change = False
+
+
+def clear_global_variables() -> None:
+    _state.during_animation_playback = False
+    _state.during_frame_change = False

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

@@ -0,0 +1,82 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class BlenderManifest:
+    id: str
+    version: tuple[int, int, int]
+    blender_version_min: tuple[int, int, int]
+    blender_version_max: Optional[tuple[int, int, int]]
+
+    @classmethod
+    def default_blender_manifest_path(cls) -> Path:
+        return Path(__file__).parent.parent / "blender_manifest.toml"
+
+    @classmethod
+    def _read_str(cls, blender_manifest: str, key: str) -> Optional[str]:
+        # When the version of Python used by the minimum supported version of Blender
+        # exceeds 3.11, it is rewritten in the tomllib library.
+        lines = [line.strip() for line in blender_manifest.splitlines()]
+
+        pattern = key + r' = "([^"]+)"'
+        for line in lines:
+            match = re.fullmatch(pattern, line)
+            if not match:
+                continue
+            return match[1]
+
+        return None
+
+    @classmethod
+    def _read_3_tuple_version(
+        cls, blender_manifest: str, key: str
+    ) -> Optional[tuple[int, int, int]]:
+        # When the version of Python used by the minimum supported version of Blender
+        # exceeds 3.11, it is rewritten in the tomli library.
+        lines = [line.strip() for line in blender_manifest.splitlines()]
+
+        pattern = key + r' = "(\d+)\.(\d+)\.(\d+)"'
+        for line in lines:
+            match = re.fullmatch(pattern, line)
+            if not match:
+                continue
+            return (int(match[1]), int(match[2]), int(match[3]))
+
+        return None
+
+    @classmethod
+    def read(cls, blender_manifest: Optional[str] = None) -> "BlenderManifest":
+        if blender_manifest is None:
+            blender_manifest = cls.default_blender_manifest_path().read_text(
+                encoding="UTF-8"
+            )
+
+        addon_id = cls._read_str(blender_manifest, "id")
+        if addon_id is None:
+            message = "'id' was not found in blender manifest"
+            raise ValueError(message)
+
+        version = cls._read_3_tuple_version(blender_manifest, "version")
+        if version is None:
+            message = "'version' was not found in blender manifest"
+            raise ValueError(message)
+
+        blender_version_min = cls._read_3_tuple_version(
+            blender_manifest, "blender_version_min"
+        )
+        if blender_version_min is None:
+            message = "'blender_version_min' was not found in blender manifest"
+            raise ValueError(message)
+
+        return BlenderManifest(
+            id=addon_id,
+            version=version,
+            blender_version_min=blender_version_min,
+            blender_version_max=cls._read_3_tuple_version(
+                blender_manifest, "blender_version_max"
+            ),
+        )

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

@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+from collections.abc import Mapping
+from typing import Final
+
+INTERNAL_NAME_PREFIX: Final = "\N{FULLWIDTH BROKEN BAR}"
+"""
+The letter to be prefixed when naming internal invisible objects. It was chosen so that
+the sort order would be backward and also so that it would be easy to identify the
+object as internal.
+"""
+
+DISABLE_TRANSLATION: Final = "\N{ZERO WIDTH SPACE}"
+
+FULLWIDTH_ASCII_TO_ASCII_MAP: Final[Mapping[str, str]] = {
+    chr(ascii_char + 0x0000_FEE0): chr(ascii_char) for ascii_char in range(0x21, 0x7E)
+}

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

@@ -0,0 +1,287 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+import math
+from collections.abc import Iterator, Mapping, Sequence
+from sys import float_info
+from typing import Final, Optional, Union
+
+from . import convert_any
+from .logger import get_logger
+
+_logger = get_logger(__name__)
+
+BPY_TRACK_AXIS_TO_VRM_AIM_AXIS: Final[Mapping[str, str]] = {
+    "TRACK_X": "PositiveX",
+    "TRACK_Y": "PositiveY",
+    "TRACK_Z": "PositiveZ",
+    "TRACK_NEGATIVE_X": "NegativeX",
+    "TRACK_NEGATIVE_Y": "NegativeY",
+    "TRACK_NEGATIVE_Z": "NegativeZ",
+}
+
+VRM_AIM_AXIS_TO_BPY_TRACK_AXIS: Final[Mapping[str, str]] = {
+    v: k for k, v in BPY_TRACK_AXIS_TO_VRM_AIM_AXIS.items()
+}
+
+
+Json = Union[
+    None,
+    bool,
+    int,
+    float,
+    str,
+    list["Json"],
+    dict[str, "Json"],
+]
+
+JsonView = Union[
+    None,
+    bool,
+    int,
+    float,
+    str,
+    Sequence["JsonView"],
+    Mapping[str, "JsonView"],
+]
+
+
+def iterator_or_none(v: object) -> Optional[Iterator[object]]:
+    try:
+        # "isinstance(v, Iterable)" doesn't work.
+        # https://github.com/python/cpython/blob/3.9/Doc/library/collections.abc.rst?plain=1#L126-L127
+        iterator = iter(v)  # type: ignore[call-overload]
+    except TypeError:
+        return None
+    return convert_any.iterator_to_object_iterator(iterator)
+
+
+def sequence_or_none(
+    sequence_object: object,
+) -> Optional[Sequence[object]]:
+    iterator = iterator_or_none(sequence_object)
+    if iterator is None:
+        return None
+    return list(iterator)
+
+
+def mapping_or_none(
+    mapping_object: object,
+) -> Optional[Mapping[object, object]]:
+    return convert_any.mapping_to_object_mapping(mapping_object)
+
+
+def vrm_json_vector3_to_tuple(
+    value: Json,
+) -> Optional[tuple[float, float, float]]:
+    if not isinstance(value, dict):
+        return None
+    x = float_or(value.get("x"), 0.0)
+    y = float_or(value.get("y"), 0.0)
+    z = float_or(value.get("z"), 0.0)
+    return (x, y, z)
+
+
+def vrm_json_curve_to_list(curve: Json) -> Optional[list[float]]:
+    if not isinstance(curve, list):
+        return None
+    values: list[float] = [float_or(v, 0.0) for v in curve]
+    while len(values) < 8:
+        values.append(0)
+    while len(values) > 8:
+        values.pop()
+    return values
+
+
+def vrm_json_array_to_float_vector(
+    input_values: Json, defaults: list[float]
+) -> list[float]:
+    if not isinstance(input_values, list):
+        return defaults
+
+    output_values: list[float] = []
+    for index, default in enumerate(defaults):
+        if index >= len(input_values):
+            output_values.append(default)
+            continue
+
+        input_value = float_or(input_values[index], default)
+        output_values.append(input_value)
+
+    return output_values
+
+
+def mtoon_shading_toony_1_to_0(shading_toony: float, shading_shift: float) -> float:
+    base = 2 - shading_toony + shading_shift
+    if abs(base) < float_info.epsilon:
+        # https://github.com/Santarh/MToon/blob/43f02fe8c9b19c3cf9f3238003b7d8b332933833/MToon/Resources/Shaders/MToon.shader#L17
+        return 0.9
+    return max(0, min((shading_toony + shading_shift) / base, 1))
+
+
+def mtoon_shading_shift_1_to_0(shading_toony: float, shading_shift: float) -> float:
+    return max(-1, min(shading_toony - shading_shift - 1, 1))
+
+
+def mtoon_gi_equalization_to_intensity(gi_equalization: float) -> float:
+    return max(0, min(1.0, 1.0 - gi_equalization))
+
+
+# https://github.com/vrm-c/UniVRM/blob/f3479190c330ec6ecd2b40be919285aa93a53aff/Assets/VRMShaders/VRM10/MToon10/Runtime/MToon10Migrator.cs#L10-L19
+def mtoon_shading_toony_0_to_1(
+    shading_toony_0x: float, shading_shift_0x: float
+) -> float:
+    (range_min, range_max) = _get_shading_range_0x(shading_toony_0x, shading_shift_0x)
+    return max(0, min(1.0, (2.0 - (range_max - range_min)) * 0.5))
+
+
+# https://github.com/vrm-c/UniVRM/blob/f3479190c330ec6ecd2b40be919285aa93a53aff/Assets/VRMShaders/VRM10/MToon10/Runtime/MToon10Migrator.cs#L21-L30
+def mtoon_shading_shift_0_to_1(
+    shading_toony_0x: float, shading_shift_0x: float
+) -> float:
+    (range_min, range_max) = _get_shading_range_0x(shading_toony_0x, shading_shift_0x)
+    return max(-1, min(1.0, ((range_max + range_min) * 0.5 * -1)))
+
+
+# https://github.com/vrm-c/UniVRM/blob/f3479190c330ec6ecd2b40be919285aa93a53aff/Assets/VRMShaders/VRM10/MToon10/Runtime/MToon10Migrator.cs#L32-L38
+def mtoon_intensity_to_gi_equalization(gi_intensity_0x: float) -> float:
+    return max(0, min(1.0, 1.0 - gi_intensity_0x))
+
+
+# https://github.com/vrm-c/UniVRM/blob/f3479190c330ec6ecd2b40be919285aa93a53aff/Assets/VRMShaders/VRM10/MToon10/Runtime/MToon10Migrator.cs#L40-L46
+def _get_shading_range_0x(
+    shading_toony_0x: float, shading_shift_0x: float
+) -> tuple[float, float]:
+    range_min = shading_shift_0x
+    range_max = (1 - shading_toony_0x) + shading_toony_0x * shading_shift_0x
+    return (range_min, range_max)
+
+
+def float_or_none(
+    v: object,
+    min_value: float = -float_info.max,
+    max_value: float = float_info.max,
+) -> Optional[float]:
+    if isinstance(v, float):
+        if math.isnan(v):
+            return None
+        return max(min_value, min(v, max_value))
+
+    if isinstance(v, bool):
+        return max(min_value, min(1.0 if v else 0.0, max_value))
+
+    if isinstance(v, int):
+        return max(min_value, min(float(v), max_value))
+
+    return None
+
+
+def float_or(
+    v: object,
+    default: float,
+    min_value: float = -float_info.max,
+    max_value: float = float_info.max,
+) -> float:
+    float_or_none_value = float_or_none(v, min_value, max_value)
+    if float_or_none_value is not None:
+        return float_or_none_value
+
+    if min_value <= default <= max_value:
+        return default
+
+    _logger.warning(
+        "Default float value %s is out of range [%s, %s]", default, min_value, max_value
+    )
+
+    return max(min_value, min(default, max_value))
+
+
+def float4_or_none(value4: object) -> Optional[tuple[float, float, float, float]]:
+    value4_iterator = iterator_or_none(value4)
+    if value4_iterator is None:
+        return None
+
+    result: list[float] = []
+    for value in value4_iterator:
+        if len(result) == 4:
+            return None
+        float_value = float_or_none(value)
+        if float_value is None:
+            return None
+        result.append(float_value)
+    if len(result) != 4:
+        return None
+    return (result[0], result[1], result[2], result[3])
+
+
+def float4_or(
+    value4: object, default: tuple[float, float, float, float]
+) -> tuple[float, float, float, float]:
+    float4 = float4_or_none(value4)
+    return float4 if float4 is not None else default
+
+
+def float3_or_none(value3: object) -> Optional[tuple[float, float, float]]:
+    value3_iterator = iterator_or_none(value3)
+    if value3_iterator is None:
+        return None
+
+    result: list[float] = []
+    for value in value3_iterator:
+        if len(result) == 3:
+            return None
+        float_value = float_or_none(value)
+        if float_value is None:
+            return None
+        result.append(float_value)
+    if len(result) != 3:
+        return None
+    return (result[0], result[1], result[2])
+
+
+def float3_or(
+    value3: object, default: tuple[float, float, float]
+) -> tuple[float, float, float]:
+    float3 = float3_or_none(value3)
+    return float3 if float3 is not None else default
+
+
+def float2_or_none(value2: object) -> Optional[tuple[float, float]]:
+    value2_iterator = iterator_or_none(value2)
+    if value2_iterator is None:
+        return None
+    result: list[float] = []
+    for value in value2_iterator:
+        if len(result) == 2:
+            return None
+        float_value = float_or_none(value)
+        if float_value is None:
+            return None
+        result.append(float_value)
+    if len(result) != 2:
+        return None
+    return (result[0], result[1])
+
+
+def axis_blender_to_gltf(vector3: Sequence[float]) -> tuple[float, float, float]:
+    return (
+        -vector3[0],
+        vector3[2],
+        vector3[1],
+    )
+
+
+def linear_to_srgb(
+    non_color: Sequence[float],
+) -> Sequence[float]:
+    return [
+        math.pow(channel_value, 1.0 / 2.2) if channel_index < 3 else channel_value
+        for channel_index, channel_value in enumerate(non_color)
+    ]
+
+
+def srgb_to_linear(
+    srgb_color: Sequence[float],
+) -> Sequence[float]:
+    return [
+        math.pow(channel_value, 2.2) if channel_index < 3 else channel_value
+        for channel_index, channel_value in enumerate(srgb_color)
+    ]

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

@@ -0,0 +1,48 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+"""A module provides a function to convert a variable of type Any to a concrete type.
+
+Inevitably, variables of type Any may occur, and such variables cannot be handled
+in type checkers in strict mode. Any is allowed only in the module here.
+"""
+
+import sys
+from collections.abc import Iterator, Mapping
+from typing import (
+    Any,  # Any is allowed only in the module here.
+    Optional,
+)
+
+
+def to_object(  # type: ignore[explicit-any]
+    any_object: Any,  # noqa: ANN401  # Any is allowed only in the module here.
+) -> object:
+    # Interpret Unknown as object
+    # https://github.com/microsoft/pyright/issues/3650
+    if not isinstance(any_object, object):
+        if sys.version_info >= (3, 11):
+            from typing import assert_never
+
+            assert_never(any_object)
+        raise TypeError
+    return any_object
+
+
+def iterator_to_object_iterator(  # type: ignore[explicit-any]
+    any_iterator: Any,  # noqa: ANN401  # Any is allowed only in the module here.
+) -> Optional[Iterator[object]]:
+    any_iterator_without_partial_type_narrowing = any_iterator
+    if not isinstance(any_iterator, Iterator):
+        return None
+    return map(to_object, any_iterator_without_partial_type_narrowing)
+
+
+def mapping_to_object_mapping(  # type: ignore[explicit-any]
+    any_mapping: Any,  # noqa: ANN401  # Any is allowed only in the module here.
+) -> Optional[Mapping[object, object]]:
+    any_mapping_without_partial_type_narrowing = any_mapping
+    if not isinstance(any_mapping, Mapping):
+        return None
+    return {
+        to_object(k): to_object(v)
+        for k, v in any_mapping_without_partial_type_narrowing.items()
+    }

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

@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+import math
+from collections.abc import Sequence
+from typing import Union
+
+from mathutils import Matrix, Quaternion, Vector
+
+
+def dump(v: Union[Matrix, Vector, Quaternion, float]) -> str:
+    if isinstance(v, (float, int)):
+        return str(v)
+
+    if isinstance(v, Matrix):
+        t, r, s = v.decompose()
+        return f"Matrix(T={dump(t)},R={dump(r)},S={dump(s)})"
+
+    if isinstance(v, Vector):
+        return f"({v.x:.3f},{v.y:.3f},{v.z:.3f})"
+
+    x, y, z = (round(math.degrees(xyz)) for xyz in v.to_euler()[:])
+    return f"Euler({x},{y},{z})"
+
+
+def assert_vector3_equals(
+    expected: Vector, actual: Sequence[float], message: str
+) -> None:
+    if len(actual) != 3:
+        message = f"actual length is not 3: {actual}"
+        raise AssertionError(message)
+
+    threshold = 0.0001
+    if abs(expected[0] - actual[0]) > threshold:
+        message = f"{message}: {tuple(expected)} is different from {tuple(actual)}"
+        raise AssertionError(message)
+    if abs(expected[1] - actual[1]) > threshold:
+        message = f"{message}: {tuple(expected)} is different from {tuple(actual)}"
+        raise AssertionError(message)
+    if abs(expected[2] - actual[2]) > threshold:
+        message = f"{message}: {tuple(expected)} is different from {tuple(actual)}"
+        raise AssertionError(message)