bpy-vrm-format 4.7.4__py3-none-any.whl

io_scene_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)
+    ]

io_scene_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()
+    }

io_scene_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)

io_scene_vrm/common/deep.py

@@ -0,0 +1,162 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+import difflib
+import math
+from collections.abc import Mapping
+from json import dumps as json_dumps
+from types import MappingProxyType
+
+from . import convert
+from .convert import Json, JsonView
+from .logger import get_logger
+
+_logger = get_logger(__name__)
+
+
+def make_json(v: object) -> Json:
+    if v is None:
+        return None
+    if isinstance(v, int):
+        return v
+    if isinstance(v, float):
+        if not math.isfinite(v):
+            _logger.warning("%s %s is non-finite value", v, type(v))
+            return 0.0
+        return v
+    if isinstance(v, bool):
+        return v
+    if isinstance(v, str):
+        return v
+
+    mapping = convert.mapping_or_none(v)
+    if mapping is not None:
+        dict_result: dict[str, Json] = {}
+        for key, value in mapping.items():
+            if isinstance(key, str):
+                dict_result[key] = make_json(value)
+                continue
+            _logger.warning("%s %s is unrecognized type for dict key", key, type(key))
+        return dict_result
+
+    iterator = convert.iterator_or_none(v)
+    if iterator is not None:
+        return [make_json(x) for x in iterator]
+
+    _logger.warning("%s %s is unrecognized type", v, type(v))
+    return None
+
+
+def make_json_view(v: object) -> JsonView:
+    json = make_json(v)
+    if isinstance(json, dict):
+        return MappingProxyType(
+            {key: make_json_view(value) for key, value in json.items()}
+        )
+    if isinstance(json, list):
+        return tuple(make_json_view(x) for x in json)
+    return json
+
+
+def make_json_dict(v: Mapping[str, object]) -> dict[str, Json]:
+    return {key: make_json(value) for key, value in v.items()}
+
+
+def diff(
+    left: Json,
+    right: Json,
+    float_tolerance: float = 0,
+    path: str = "",
+) -> list[str]:
+    if isinstance(left, list):
+        if not isinstance(right, list):
+            return [f"{path}: left is list but right is {type(right)}"]
+        if len(left) != len(right):
+            result = [
+                f"{path}: left length is {len(left)} but right length is {len(right)}"
+            ]
+
+            right_json_str = json_dumps(right, indent=4, sort_keys=True)
+            right_json_lines = right_json_str.splitlines(keepends=True)
+            left_json_str = json_dumps(left, indent=4, sort_keys=True)
+            left_json_lines = left_json_str.splitlines(keepends=True)
+
+            if len(right_json_lines) > 1000 or len(left_json_lines) > 1000:
+                return result
+
+            unified_diff = [
+                line.rstrip()
+                for line in difflib.unified_diff(
+                    right_json_lines,
+                    left_json_lines,
+                    f"{path}/right",
+                    f"{path}/left",
+                )
+            ]
+            if len(unified_diff) > 1000:
+                return result
+            return result + unified_diff
+        diffs: list[str] = []
+        for i, (left_child, right_child) in enumerate(zip(left, right)):
+            diffs.extend(diff(left_child, right_child, float_tolerance, f"{path}[{i}]"))
+        return diffs
+
+    if isinstance(left, dict):
+        if not isinstance(right, dict):
+            return [f"{path}: left is dict but right is {type(right)}"]
+        diffs = []
+        for key in sorted(left.keys() | right.keys()):
+            if key not in left:
+                diffs.append(f'{path}: {key} not in left. right["{key}"]={right[key]}')
+                continue
+            if key not in right:
+                diffs.append(f'{path}: {key} not in right, left["{key}"]={left[key]}')
+                continue
+            diffs.extend(
+                diff(left[key], right[key], float_tolerance, f'{path}["{key}"]')
+            )
+        return diffs
+
+    if isinstance(left, bool):
+        if not isinstance(right, bool):
+            return [f"{path}: left is bool but right is {type(right)}"]
+        if left != right:
+            return [f"{path}: left is {left} but right is {right}"]
+        return []
+
+    if isinstance(left, str):
+        if not isinstance(right, str):
+            return [f"{path}: left is str but right is {type(right)}"]
+        if left != right:
+            return [f'{path}: left is "{left}" but right is "{right}"']
+        return []
+
+    if isinstance(left, int) and isinstance(right, int):
+        if left != right:
+            return [f"{path}: left is {left} but right is {right}"]
+        return []
+
+    if isinstance(left, (int, float)) and isinstance(right, (int, float)):
+        if (isinstance(left, float) and not math.isfinite(left)) or (
+            isinstance(right, float) and not math.isfinite(right)
+        ):
+            return [
+                f"{path}: left is {left}"
+                + f" but right is {right}, They are not comparable numbers"
+            ]
+
+        error = math.fabs(float(left) - float(right))
+        if error > float_tolerance:
+            return [
+                f"{path}: left is {float(left):20.17f}"
+                + f" but right is {float(right):20.17f}, error={error:19.17f}"
+            ]
+        return []
+
+    if left is None:
+        if right is None:
+            return []
+        return [f"{path}: left is None but right is {type(right)}"]
+    if right is None:
+        return [f"{path}: left is {type(left)} but right is None"]
+
+    message = f"{path}: unexpected type left={type(left)} right={type(right)}"
+    raise ValueError(message)