@tushar-br/editing-pack 1.0.188 → 1.0.190

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/__init__.py

@@ -1,3 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2022 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/com/blender_default.py

@@ -1,15 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2022 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-BLENDER_IOR = 1.45
-BLENDER_SPECULAR = 0.5
-BLENDER_SPECULAR_TINT = 0.0
-
-BLENDER_GLTF_SPECIAL_COLLECTION = "glTF_not_exported"
-
-LIGHTS = {
-    "POINT": "point",
-    "SUN": "directional",
-    "SPOT": "spot"
-}

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/com/conversion.py

@@ -1,229 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from math import sin, cos, tan, atan
-from mathutils import Matrix, Vector
-import numpy as np
-from ...io.com import constants as gltf2_io_constants
-
-PBR_WATTS_TO_LUMENS = 683
-# Industry convention, biological peak at 555nm, scientific standard as part of SI candela definition.
-
-
-# This means use the inverse of the TRS transform.
-def inverted_trs_mapping_node(mapping_transform):
-    offset = mapping_transform["offset"]
-    rotation = mapping_transform["rotation"]
-    scale = mapping_transform["scale"]
-
-    # Inverse of a TRS is not always a TRS. This function will be right
-    # at least when the following don't occur.
-    if abs(rotation) > 1e-5 and abs(scale[0] - scale[1]) > 1e-5:
-        return None
-    if abs(scale[0]) < 1e-5 or abs(scale[1]) < 1e-5:
-        return None
-
-    new_offset = Matrix.Rotation(-rotation, 3, 'Z') @ Vector((-offset[0], -offset[1], 1))
-    new_offset[0] /= scale[0]
-    new_offset[1] /= scale[1]
-    return {
-        "offset": new_offset[0:2],
-        "rotation": -rotation,
-        "scale": [1 / scale[0], 1 / scale[1]],
-    }
-
-
-def texture_transform_blender_to_gltf(mapping_transform):
-    """
-    Converts the offset/rotation/scale from a Mapping node applied in Blender's
-    UV space to the equivalent KHR_texture_transform.
-    """
-    offset = mapping_transform.get('offset', [0, 0])
-    rotation = mapping_transform.get('rotation', 0)
-    scale = mapping_transform.get('scale', [1, 1])
-    return {
-        'offset': [
-            offset[0] - scale[1] * sin(rotation),
-            1 - offset[1] - scale[1] * cos(rotation),
-        ],
-        'rotation': rotation,
-        'scale': [scale[0], scale[1]],
-    }
-
-
-def texture_transform_gltf_to_blender(texture_transform):
-    """
-    Converts a KHR_texture_transform into the equivalent offset/rotation/scale
-    for a Mapping node applied in Blender's UV space.
-    """
-    offset = texture_transform.get('offset', [0, 0])
-    rotation = texture_transform.get('rotation', 0)
-    scale = texture_transform.get('scale', [1, 1])
-    return {
-        'offset': [
-            offset[0] + scale[1] * sin(rotation),
-            1 - offset[1] - scale[1] * cos(rotation),
-        ],
-        'rotation': rotation,
-        'scale': [scale[0], scale[1]],
-    }
-
-
-def get_target(property):
-    return {
-        "delta_location": "translation",
-        "delta_rotation_euler": "rotation",
-        "delta_rotation_quaternion": "rotation",
-        "delta_scale": "scale",
-        "location": "translation",
-        "rotation_axis_angle": "rotation",
-        "rotation_euler": "rotation",
-        "rotation_quaternion": "rotation",
-        "scale": "scale",
-        "value": "weights"
-    }.get(property, None)
-
-
-def get_component_type(attribute_component_type):
-    return {
-        "INT8": gltf2_io_constants.ComponentType.Float,
-        "BYTE_COLOR": gltf2_io_constants.ComponentType.UnsignedShort,
-        "FLOAT2": gltf2_io_constants.ComponentType.Float,
-        "FLOAT_COLOR": gltf2_io_constants.ComponentType.Float,
-        "FLOAT_VECTOR": gltf2_io_constants.ComponentType.Float,
-        "FLOAT_VECTOR_4": gltf2_io_constants.ComponentType.Float,
-        "QUATERNION": gltf2_io_constants.ComponentType.Float,
-        "FLOAT4X4": gltf2_io_constants.ComponentType.Float,
-        "INT": gltf2_io_constants.ComponentType.Float,  # No signed Int in glTF accessor
-        "FLOAT": gltf2_io_constants.ComponentType.Float,
-        "BOOLEAN": gltf2_io_constants.ComponentType.Float,
-        "UNSIGNED_BYTE": gltf2_io_constants.ComponentType.UnsignedByte
-    }.get(attribute_component_type)
-
-
-def get_channel_from_target(target):
-    return {
-        "rotation": "rotation_quaternion",
-        "translation": "location",
-        "scale": "scale"
-    }.get(target)
-
-
-def get_data_type(attribute_component_type):
-    return {
-        "INT8": gltf2_io_constants.DataType.Scalar,
-        "BYTE_COLOR": gltf2_io_constants.DataType.Vec4,
-        "FLOAT2": gltf2_io_constants.DataType.Vec2,
-        "FLOAT_COLOR": gltf2_io_constants.DataType.Vec4,
-        "FLOAT_VECTOR": gltf2_io_constants.DataType.Vec3,
-        "FLOAT_VECTOR_4": gltf2_io_constants.DataType.Vec4,
-        "QUATERNION": gltf2_io_constants.DataType.Vec4,
-        "FLOAT4X4": gltf2_io_constants.DataType.Mat4,
-        "INT": gltf2_io_constants.DataType.Scalar,
-        "FLOAT": gltf2_io_constants.DataType.Scalar,
-        "BOOLEAN": gltf2_io_constants.DataType.Scalar,
-    }.get(attribute_component_type)
-
-
-def get_data_length(attribute_component_type):
-    return {
-        "INT8": 1,
-        "BYTE_COLOR": 4,
-        "FLOAT2": 2,
-        "FLOAT_COLOR": 4,
-        "FLOAT_VECTOR": 3,
-        "FLOAT_VECTOR_4": 4,
-        "QUATERNION": 4,
-        "FLOAT4X4": 16,
-        "INT": 1,
-        "FLOAT": 1,
-        "BOOLEAN": 1
-    }.get(attribute_component_type)
-
-
-def get_numpy_type(attribute_component_type):
-    return {
-        "INT8": np.float32,
-        "BYTE_COLOR": np.float32,
-        "FLOAT2": np.float32,
-        "FLOAT_COLOR": np.float32,
-        "FLOAT_VECTOR": np.float32,
-        "FLOAT_VECTOR_4": np.float32,
-        "QUATERNION": np.float32,
-        "FLOAT4X4": np.float32,
-        "INT": np.float32,  # signed integer are not supported by glTF
-        "FLOAT": np.float32,
-        "BOOLEAN": np.float32,
-        "UNSIGNED_BYTE": np.uint8,
-    }.get(attribute_component_type)
-
-
-def get_attribute_type(component_type, data_type):
-    if gltf2_io_constants.DataType.num_elements(data_type) == 1:
-        return {
-            gltf2_io_constants.ComponentType.Float: "FLOAT",
-            gltf2_io_constants.ComponentType.UnsignedByte: "INT"  # What is the best for compatibility?
-        }.get(component_type, None)
-    elif gltf2_io_constants.DataType.num_elements(data_type) == 2:
-        return {
-            gltf2_io_constants.ComponentType.Float: "FLOAT2"
-        }.get(component_type, None)
-    elif gltf2_io_constants.DataType.num_elements(data_type) == 3:
-        return {
-            gltf2_io_constants.ComponentType.Float: "FLOAT_VECTOR"
-        }.get(component_type, None)
-    elif gltf2_io_constants.DataType.num_elements(data_type) == 4:
-        return {
-            gltf2_io_constants.ComponentType.Float: "FLOAT_COLOR",
-            gltf2_io_constants.ComponentType.UnsignedShort: "BYTE_COLOR",
-            gltf2_io_constants.ComponentType.UnsignedByte: "BYTE_COLOR"  # What is the best for compatibility?
-        }.get(component_type, None)
-    elif gltf2_io_constants.DataType.num_elements(data_type) == 16:
-        return {
-            gltf2_io_constants.ComponentType.Float: "FLOAT4X4"
-        }.get(component_type, None)
-    else:
-        pass
-
-
-def get_attribute(attributes, name, data_type, domain):
-    attribute = attributes.get(name)
-    if attribute is not None and attribute.data_type == data_type and attribute.domain == domain:
-        return attribute
-    else:
-        return None
-
-
-def get_gltf_interpolation(interpolation, export_settings):
-    return {
-        "BEZIER": "CUBICSPLINE",
-        "LINEAR": "LINEAR",
-        "CONSTANT": "STEP"
-    }.get(interpolation, export_settings['gltf_sampling_interpolation_fallback']) # If unknown, default to the mode chosen by the user
-
-
-def get_anisotropy_rotation_gltf_to_blender(rotation):
-    # glTF rotation is in randian, Blender in 0 to 1
-    return rotation / (2 * np.pi)
-
-
-def get_anisotropy_rotation_blender_to_gltf(rotation):
-    # glTF rotation is in randian, Blender in 0 to 1
-    return rotation * (2 * np.pi)
-
-
-def yvof_blender_to_gltf(angle, width, height, sensor_fit):
-
-    aspect_ratio = width / height
-
-    if width >= height:
-        if sensor_fit != 'VERTICAL':
-            return 2.0 * atan(tan(angle * 0.5) / aspect_ratio)
-        else:
-            return angle
-    else:
-        if sensor_fit != 'HORIZONTAL':
-            return angle
-        else:
-            return 2.0 * atan(tan(angle * 0.5) / aspect_ratio)

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/com/data_path.py

@@ -1,110 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-
-def get_target_property_name(data_path: str) -> str:
-    """Retrieve target property."""
-
-    if data_path.endswith("]"):
-        return None
-    else:
-        return data_path.rsplit('.', 1)[-1]
-
-
-def get_target_object_path(data_path: str) -> str:
-    """Retrieve target object data path without property"""
-    if data_path.endswith("]"):
-        return data_path.rsplit('[', 1)[0]
-    elif data_path.startswith("pose.bones["):
-        return data_path[:data_path.find('"]')] + '"]'
-    path_split = data_path.rsplit('.', 1)
-    self_targeting = len(path_split) < 2
-    if self_targeting:
-        return ""
-    return path_split[0]
-
-
-def get_rotation_modes(target_property: str):
-    """Retrieve rotation modes based on target_property"""
-    if target_property in ["rotation_euler", "delta_rotation_euler"]:
-        return True, ["XYZ", "XZY", "YXZ", "YZX", "ZXY", "ZYX"]
-    elif target_property in ["rotation_quaternion", "delta_rotation_quaternion"]:
-        return True, ["QUATERNION"]
-    elif target_property in ["rotation_axis_angle"]:
-        return True, ["AXIS_ANGLE"]
-    else:
-        return False, []
-
-
-def is_location(target_property):
-    return "location" in target_property
-
-
-def is_rotation(target_property):
-    return "rotation" in target_property
-
-
-def is_scale(target_property):
-    return "scale" in target_property
-
-
-def get_delta_modes(target_property: str) -> str:
-    """Retrieve location based on target_property"""
-    return target_property.startswith("delta_")
-
-
-def is_bone_anim_channel(data_path: str) -> bool:
-    return data_path[:10] == "pose.bones"
-
-
-def get_sk_exported(key_blocks):
-    return [
-        k
-        for k in key_blocks
-        if not skip_sk(key_blocks, k)
-    ]
-
-
-def skip_sk(key_blocks, k):
-    # Do not export:
-    # - if muted
-    # - if relative key is SK itself (this avoid exporting Basis too if user didn't change order)
-    # - the Basis (the first SK of the list)
-    return k == k.relative_key \
-        or k.mute \
-        or is_first_index(key_blocks, k) is True
-
-
-def is_first_index(key_blocks, k):
-    return key_blocks[0].name == k.name
-
-
-def get_object_from_datapath(blender_object, data_path: str):
-    if "." in data_path:
-        # gives us: ('modifiers["Subsurf"]', 'levels')
-        path_prop, path_attr = data_path.rsplit(".", 1)
-
-        # same as: prop = obj.modifiers["Subsurf"]
-        if path_attr in ["rotation", "scale", "location",
-                         "rotation_axis_angle", "rotation_euler", "rotation_quaternion"]:
-            prop = blender_object.path_resolve(path_prop)
-        else:
-            prop = blender_object.path_resolve(data_path)
-    else:
-        prop = blender_object
-        # single attribute such as name, location... etc
-        # path_attr = data_path
-
-    return prop
-
-
-def get_channelbag_for_slot(action, slot):
-    # This is on purpose limited to the first layer and strip. To support more
-    # than 1 layer, a rewrite of this operator is needed which ideally would
-    # happen in C++.
-    for layer in action.layers:
-        for strip in layer.strips:
-            channelbag = strip.channelbag(slot)
-            return channelbag
-    return None

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/com/extras.py

@@ -1,89 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-
-import bpy
-from .json_util import is_json_convertible
-
-
-# Custom properties, which are in most cases present and should not be imported/exported.
-BLACK_LIST = ['cycles', 'cycles_visibility', 'cycles_curves', 'glTF2ExportSettings', 'gltf2_mesh_applied',
-    'gltf2_KHR_materials_variants_variants', 'gltf2_active_variant', 'gltf2_variant_default_materials', 'gltf2_variant_mesh_data'
-]
-
-
-def generate_extras(blender_element):
-    """Filter and create a custom property, which is stored in the glTF extra field."""
-    if not blender_element:
-        return None
-
-    extras = {}
-
-    for custom_property in blender_element.keys():
-        if custom_property in BLACK_LIST:
-            continue
-
-        value = __to_json_compatible(blender_element[custom_property])
-
-        if value is not None:
-            extras[custom_property] = value
-
-    if not extras:
-        return None
-
-    return extras
-
-
-def __to_json_compatible(value):
-    """Make a value (usually a custom property) compatible with json"""
-
-    if isinstance(value, bpy.types.ID):
-        return value
-
-    elif isinstance(value, str):
-        return value
-
-    elif isinstance(value, (int, float)):
-        return value
-
-    # for list classes
-    elif isinstance(value, list):
-        value = list(value)
-        # make sure contents are json-compatible too
-        for index in range(len(value)):
-            value[index] = __to_json_compatible(value[index])
-        return value
-
-    # for IDPropertyArray classes
-    elif hasattr(value, "to_list"):
-        value = value.to_list()
-        return value
-
-    elif hasattr(value, "to_dict"):
-        value = value.to_dict()
-        if is_json_convertible(value):
-            return value
-
-    return None
-
-
-def set_extras(blender_element, extras, exclude=[]):
-    """Copy extras onto a Blender object."""
-    if not extras or not isinstance(extras, dict):
-        return
-
-    for custom_property, value in extras.items():
-        if custom_property in BLACK_LIST:
-            continue
-        if custom_property in exclude:
-            continue
-
-        try:
-            blender_element[custom_property] = value
-        except Exception:
-            # Try to convert to string
-            try:
-                blender_element[custom_property] = str(value)
-            except Exception:
-                print('Error setting property %s to value of type %s' % (custom_property, type(value)))

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/com/gltf2_blender_math.py

@@ -1,209 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import typing
-import math
-from mathutils import Matrix, Vector, Quaternion, Euler
-
-from .data_path import get_target_property_name
-
-
-def list_to_mathutils(values: typing.List[float], data_path: str) -> typing.Union[Vector, Quaternion, Euler]:
-    """Transform a list to blender py object."""
-    target = get_target_property_name(data_path)
-
-    if target == 'delta_location':
-        return Vector(values)  # TODO Should be Vector(values) - Vector(something)?
-    elif target == 'delta_rotation_euler':
-        return Euler(values).to_quaternion()  # TODO Should be Euler(values).to_quaternion() @ something?
-    elif target == 'location':
-        return Vector(values)
-    elif target == 'rotation_axis_angle':
-        angle = values[0]
-        axis = values[1:]
-        return Quaternion(axis, math.radians(angle))
-    elif target == 'rotation_euler':
-        return Euler(values).to_quaternion()
-    elif target == 'rotation_quaternion':
-        return Quaternion(values)
-    elif target == 'scale':
-        return Vector(values)
-    elif target == 'value':
-        return Vector(values)
-
-    return values
-
-
-def mathutils_to_gltf(x: typing.Union[Vector, Quaternion]) -> typing.List[float]:
-    """Transform a py object to glTF list."""
-    if isinstance(x, Vector):
-        return list(x)
-    if isinstance(x, Quaternion):
-        # Blender has w-first quaternion notation
-        return [x[1], x[2], x[3], x[0]]
-    else:
-        return list(x)
-
-
-def to_yup() -> Matrix:
-    """Transform to Yup."""
-    return Matrix(
-        ((1.0, 0.0, 0.0, 0.0),
-         (0.0, 0.0, 1.0, 0.0),
-         (0.0, -1.0, 0.0, 0.0),
-         (0.0, 0.0, 0.0, 1.0))
-    )
-
-
-to_zup = to_yup
-
-
-def swizzle_yup(v: typing.Union[Vector, Quaternion], data_path: str) -> typing.Union[Vector, Quaternion]:
-    """Manage Yup."""
-    target = get_target_property_name(data_path)
-    swizzle_func = {
-        "delta_location": swizzle_yup_location,
-        "delta_rotation_euler": swizzle_yup_rotation,
-        "location": swizzle_yup_location,
-        "rotation_axis_angle": swizzle_yup_rotation,
-        "rotation_euler": swizzle_yup_rotation,
-        "rotation_quaternion": swizzle_yup_rotation,
-        "scale": swizzle_yup_scale,
-        "value": swizzle_yup_value
-    }.get(target)
-
-    if swizzle_func is None:
-        raise RuntimeError("Cannot transform values at {}".format(data_path))
-
-    return swizzle_func(v)
-
-
-def swizzle_yup_location(loc: Vector) -> Vector:
-    """Manage Yup location."""
-    return Vector((loc[0], loc[2], -loc[1]))
-
-
-def swizzle_yup_rotation(rot: Quaternion) -> Quaternion:
-    """Manage Yup rotation."""
-    return Quaternion((rot[0], rot[1], rot[3], -rot[2]))
-
-
-def swizzle_yup_scale(scale: Vector) -> Vector:
-    """Manage Yup scale."""
-    return Vector((scale[0], scale[2], scale[1]))
-
-
-def swizzle_yup_value(value: typing.Any) -> typing.Any:
-    """Manage Yup value."""
-    return value
-
-
-def transform(v: typing.Union[Vector, Quaternion], data_path: str, transform: Matrix = Matrix.Identity(
-        4), need_rotation_correction: bool = False) -> typing .Union[Vector, Quaternion]:
-    """Manage transformations."""
-    target = get_target_property_name(data_path)
-    transform_func = {
-        "delta_location": transform_location,
-        "delta_rotation_euler": transform_rotation,
-        "location": transform_location,
-        "rotation_axis_angle": transform_rotation,
-        "rotation_euler": transform_rotation,
-        "rotation_quaternion": transform_rotation,
-        "scale": transform_scale,
-        "value": transform_value
-    }.get(target)
-
-    if transform_func is None:
-        raise RuntimeError("Cannot transform values at {}".format(data_path))
-
-    return transform_func(v, transform, need_rotation_correction)
-
-
-def transform_location(location: Vector, transform: Matrix = Matrix.Identity(4),
-                       need_rotation_correction: bool = False) -> Vector:
-    """Transform location."""
-    correction = Quaternion((2**0.5 / 2, -2**0.5 / 2, 0.0, 0.0))
-    m = Matrix.Translation(location)
-    if need_rotation_correction:
-        m @= correction.to_matrix().to_4x4()
-    m = transform @ m
-    return m.to_translation()
-
-
-def transform_rotation(rotation: Quaternion, transform: Matrix = Matrix.Identity(4),
-                       need_rotation_correction: bool = False) -> Quaternion:
-    """Transform rotation."""
-    rotation.normalize()
-    correction = Quaternion((2**0.5 / 2, -2**0.5 / 2, 0.0, 0.0))
-    m = rotation.to_matrix().to_4x4()
-    if need_rotation_correction:
-        m @= correction.to_matrix().to_4x4()
-    m = transform @ m
-    return m.to_quaternion()
-
-
-def transform_scale(scale: Vector, transform: Matrix = Matrix.Identity(4),
-                    need_rotation_correction: bool = False) -> Vector:
-    """Transform scale."""
-    m = Matrix.Identity(4)
-    m[0][0] = scale.x
-    m[1][1] = scale.y
-    m[2][2] = scale.z
-    m = transform @ m
-
-    return m.to_scale()
-
-
-def transform_value(value: Vector, _: Matrix = Matrix.Identity(4), need_rotation_correction: bool = False) -> Vector:
-    """Transform value."""
-    return value
-
-
-def round_if_near(value: float, target: float) -> float:
-    """If value is very close to target, round to target."""
-    return value if abs(value - target) > 2.0e-6 else target
-
-
-def scale_rot_swap_matrix(rot):
-    """Returns a matrix m st. Scale[s] Rot[rot] = Rot[rot] Scale[m s].
-    If rot.to_matrix() is a signed permutation matrix, works for any s.
-    Otherwise works only if s is a uniform scaling.
-    """
-    m = nearby_signed_perm_matrix(rot)  # snap to signed perm matrix
-    m.transpose()  # invert permutation
-    for i in range(3):
-        for j in range(3):
-            m[i][j] = abs(m[i][j])  # discard sign
-    return m
-
-
-def nearby_signed_perm_matrix(rot):
-    """Returns a signed permutation matrix close to rot.to_matrix().
-    (A signed permutation matrix is like a permutation matrix, except
-    the non-zero entries can be ±1.)
-    """
-    m = rot.to_matrix()
-    x, y, z = m[0], m[1], m[2]
-
-    # Set the largest entry in the first row to ±1
-    a, b, c = abs(x[0]), abs(x[1]), abs(x[2])
-    i = 0 if a >= b and a >= c else 1 if b >= c else 2
-    x[i] = 1 if x[i] > 0 else -1
-    x[(i + 1) % 3] = 0
-    x[(i + 2) % 3] = 0
-
-    # Same for second row: only two columns to consider now.
-    a, b = abs(y[(i + 1) % 3]), abs(y[(i + 2) % 3])
-    j = (i + 1) % 3 if a >= b else (i + 2) % 3
-    y[j] = 1 if y[j] > 0 else -1
-    y[(j + 1) % 3] = 0
-    y[(j + 2) % 3] = 0
-
-    # Same for third row: only one column left
-    k = (0 + 1 + 2) - i - j
-    z[k] = 1 if z[k] > 0 else -1
-    z[(k + 1) % 3] = 0
-    z[(k + 2) % 3] = 0
-
-    return m