@tushar-br/editing-pack 1.0.188 → 1.0.190

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/exp/animation/fcurves/sampler.py

@@ -1,231 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2022 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import bpy
-import typing
-import mathutils
-from .....io.com import gltf2_io
-from .....io.com import constants as gltf2_io_constants
-from .....blender.com.conversion import get_gltf_interpolation
-from .....io.exp import binary_data as gltf2_io_binary_data
-from .....io.exp.user_extensions import export_user_extensions
-from ....com.data_path import get_target_property_name
-from ....com import gltf2_blender_math
-from ...cache import cached
-from ...accessors import gather_accessor
-from ...tree import VExportNode
-from .keyframes import gather_fcurve_keyframes
-
-
-@cached
-def gather_animation_fcurves_sampler(
-        obj_uuid: str,
-        channel_group: typing.Tuple[bpy.types.FCurve],
-        bone: typing.Optional[str],
-        custom_range: typing.Optional[set],
-        extra_mode: bool,
-        export_settings
-) -> gltf2_io.AnimationSampler:
-
-    # matrix_parent_inverse needed for fcurves?
-
-    keyframes = __gather_keyframes(
-        obj_uuid,
-        channel_group,
-        bone,
-        custom_range,
-        extra_mode,
-        export_settings)
-
-    if keyframes is None:
-        # After check, no need to animate this node for this channel
-        return None
-
-    # Now we are raw input/output, we need to convert to glTF data
-    input, output = __convert_keyframes(obj_uuid, channel_group, bone, keyframes, extra_mode, export_settings)
-
-    sampler = gltf2_io.AnimationSampler(
-        extensions=None,
-        extras=None,
-        input=input,
-        interpolation=__gather_interpolation(channel_group, export_settings),
-        output=output
-    )
-
-    blender_object = export_settings['vtree'].nodes[obj_uuid].blender_object
-    export_user_extensions('animation_gather_fcurve_channel_sampler', export_settings, blender_object, bone)
-
-    return sampler
-
-
-@cached
-def __gather_keyframes(
-        obj_uuid: str,
-        channel_group: typing.Tuple[bpy.types.FCurve],
-        bone: typing.Optional[str],
-        custom_range: typing.Optional[set],
-        extra_mode: bool,
-        export_settings
-):
-
-    return gather_fcurve_keyframes(obj_uuid, channel_group, bone, custom_range, extra_mode, export_settings)
-
-
-def __convert_keyframes(
-        obj_uuid: str,
-        channel_group: typing.Tuple[bpy.types.FCurve],
-        bone_name: typing.Optional[str],
-        keyframes,
-        extra_mode: bool,
-        export_settings):
-
-    times = [k.seconds for k in keyframes]
-    input = gather_accessor(
-        gltf2_io_binary_data.BinaryData.from_list(times, gltf2_io_constants.ComponentType.Float),
-        gltf2_io_constants.ComponentType.Float,
-        len(times),
-        tuple([max(times)]),
-        tuple([min(times)]),
-        gltf2_io_constants.DataType.Scalar,
-        export_settings)
-
-    is_yup = export_settings['gltf_yup']
-
-    need_rotation_correction = (
-        export_settings['gltf_cameras'] and export_settings['vtree'].nodes[obj_uuid].blender_type == VExportNode.CAMERA) or (
-        export_settings['gltf_lights'] and export_settings['vtree'].nodes[obj_uuid].blender_type == VExportNode.LIGHT)
-
-    target_datapath = [c for c in channel_group if c is not None][0].data_path
-
-    if bone_name is not None:
-        bone = export_settings['vtree'].nodes[obj_uuid].blender_object.pose.bones[bone_name]
-        if bone.parent is None:
-            # bone at root of armature
-            axis_basis_change = mathutils.Matrix.Identity(4)
-            if is_yup:
-                axis_basis_change = mathutils.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)))
-            correction_matrix_local = axis_basis_change @ bone.bone.matrix_local
-        else:
-            # Bone is not at root of armature
-            # There are 2 cases :
-            parent_uuid = export_settings['vtree'].nodes[export_settings['vtree']
-                                                         .nodes[obj_uuid].bones[bone_name]].parent_uuid
-            if parent_uuid is not None and export_settings['vtree'].nodes[parent_uuid].blender_type == VExportNode.BONE:
-                # export bone is not at root of armature neither
-                blender_bone_parent = export_settings['vtree'].nodes[parent_uuid].blender_bone
-                correction_matrix_local = (
-                    blender_bone_parent.bone.matrix_local.inverted_safe() @
-                    bone.bone.matrix_local
-                )
-            else:
-                # exported bone (after filter) is at root of armature
-                axis_basis_change = mathutils.Matrix.Identity(4)
-                if is_yup:
-                    axis_basis_change = mathutils.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)))
-                correction_matrix_local = axis_basis_change
-
-        transform = correction_matrix_local
-
-    else:
-        if export_settings['vtree'].nodes[obj_uuid].blender_object.parent is not None:
-            matrix_parent_inverse = export_settings['vtree'].nodes[obj_uuid].blender_object.matrix_parent_inverse.copy(
-            ).freeze()
-        else:
-            matrix_parent_inverse = mathutils.Matrix.Identity(4).freeze()
-        transform = matrix_parent_inverse
-
-    values = []
-    fps = (bpy.context.scene.render.fps * bpy.context.scene.render.fps_base)
-    for keyframe in keyframes:
-
-        if extra_mode is True:
-            # Export as is, without trying to convert
-            keyframe_value = keyframe.value
-            if keyframe.in_tangent is not None:
-                keyframe_value = keyframe.in_tangent + keyframe_value
-            if keyframe.out_tangent is not None:
-                keyframe_value = keyframe_value + keyframe.out_tangent
-            values += keyframe_value
-            continue
-
-        # Transform the data and build gltf control points
-        value = gltf2_blender_math.transform(keyframe.value, target_datapath, transform, need_rotation_correction)
-        if is_yup and bone_name is None:
-            value = gltf2_blender_math.swizzle_yup(value, target_datapath)
-        keyframe_value = gltf2_blender_math.mathutils_to_gltf(value)
-
-        if keyframe.in_tangent is not None:
-            # we can directly transform the tangent as it currently is represented by a control point
-            in_tangent = gltf2_blender_math.transform(
-                keyframe.in_tangent, target_datapath, transform, need_rotation_correction)
-            if is_yup and bone_name is None:
-                in_tangent = gltf2_blender_math.swizzle_yup(in_tangent, target_datapath)
-            # the tangent in glTF is relative to the keyframe value and uses seconds
-            if not isinstance(value, list):
-                in_tangent = fps * (in_tangent - value)
-            else:
-                in_tangent = [fps * (in_tangent[i] - value[i]) for i in range(len(value))]
-            keyframe_value = gltf2_blender_math.mathutils_to_gltf(in_tangent) + keyframe_value  # append
-
-        if keyframe.out_tangent is not None:
-            # we can directly transform the tangent as it currently is represented by a control point
-            out_tangent = gltf2_blender_math.transform(
-                keyframe.out_tangent, target_datapath, transform, need_rotation_correction)
-            if is_yup and bone_name is None:
-                out_tangent = gltf2_blender_math.swizzle_yup(out_tangent, target_datapath)
-            # the tangent in glTF is relative to the keyframe value and uses seconds
-            if not isinstance(value, list):
-                out_tangent = fps * (out_tangent - value)
-            else:
-                out_tangent = [fps * (out_tangent[i] - value[i]) for i in range(len(value))]
-            keyframe_value = keyframe_value + gltf2_blender_math.mathutils_to_gltf(out_tangent)  # append
-
-        values += keyframe_value
-
-    # store the keyframe data in a binary buffer
-    component_type = gltf2_io_constants.ComponentType.Float
-    if get_target_property_name(target_datapath) == "value":
-        # channels with 'weight' targets must have scalar accessors
-        data_type = gltf2_io_constants.DataType.Scalar
-    else:
-        data_type = gltf2_io_constants.DataType.vec_type_from_num(len(keyframes[0].value))
-
-    output = gltf2_io.Accessor(
-        buffer_view=gltf2_io_binary_data.BinaryData.from_list(values, component_type),
-        byte_offset=None,
-        component_type=component_type,
-        count=len(values) // gltf2_io_constants.DataType.num_elements(data_type),
-        extensions=None,
-        extras=None,
-        max=None,
-        min=None,
-        name=None,
-        normalized=None,
-        sparse=None,
-        type=data_type
-    )
-
-    return input, output
-
-
-def __gather_interpolation(
-        channel_group: typing.Tuple[bpy.types.FCurve],
-        export_settings,
-) -> str:
-
-    # Note: channels has some None items only for SK if some SK are not animated
-    # Non-sampled keyframes implies that all keys are of the same type, and that the
-    # type is supported by glTF (because we checked in needs_baking).
-    blender_keyframe = [c for c in channel_group if c is not None][0].keyframe_points[0]
-
-    # Select the interpolation method.
-    return get_gltf_interpolation(blender_keyframe.interpolation, export_settings)

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/exp/animation/keyframes.py

@@ -1,127 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2022 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import typing
-import bpy
-import mathutils
-from ...com import gltf2_blender_math
-
-
-class Keyframe:
-    def __init__(self, channels: typing.Tuple[bpy.types.FCurve], frame: float, bake_channel: typing.Union[str, None]):
-        self.seconds = frame / (bpy.context.scene.render.fps * bpy.context.scene.render.fps_base)
-        self.frame = frame
-        self.fps = (bpy.context.scene.render.fps * bpy.context.scene.render.fps_base)
-        self.__length_morph = 0
-        # Note: channels has some None items only for SK if some SK are not animated
-        if bake_channel is None:
-            if not all([c is None for c in channels]):
-                self.target = [c for c in channels if c is not None][0].data_path.split('.')[-1]
-                if self.target != "value":
-                    self.__indices = [c.array_index for c in channels]
-                else:
-                    self.__indices = [i for i, c in enumerate(channels) if c is not None]
-                    self.__length_morph = len(channels)
-            else:
-                # If all channels are None (baking evaluate SK case)
-                self.target = "value"
-                self.__indices = []
-                self.__length_morph = len(channels)
-                for i in range(self.get_target_len()):
-                    self.__indices.append(i)
-
-        else:
-            if bake_channel == "value":
-                self.__length_morph = len(channels)
-            self.target = bake_channel
-            self.__indices = []
-            for i in range(self.get_target_len()):
-                self.__indices.append(i)
-
-        # Data holders for virtual properties
-        self.__value = None
-        self.__in_tangent = None
-        self.__out_tangent = None
-
-    def get_target_len(self):
-        length = {
-            "delta_location": 3,
-            "delta_rotation_euler": 3,
-            "delta_rotation_quaternion": 4,
-            "delta_scale": 3,
-            "location": 3,
-            "rotation_axis_angle": 4,
-            "rotation_euler": 3,
-            "rotation_quaternion": 4,
-            "scale": 3,
-            "value": self.__length_morph
-        }.get(self.target, 1)
-
-        return length
-
-    def __set_indexed(self, value):
-        # Sometimes blender animations only reference a subset of components of a data target. Keyframe should always
-        # contain a complete Vector/ Quaternion --> use the array_index value of the keyframe to set components in such
-        # structures
-        # For SK, must contains all SK values
-        result = [0.0] * self.get_target_len()
-        for i, v in zip(self.__indices, value):
-            result[i] = v
-        return result
-
-    def get_indices(self):
-        return self.__indices
-
-    def set_value_index(self, idx, val):
-        self.__value[idx] = val
-
-    def set_value_index_in(self, idx, val):
-        self.__in_tangent[idx] = val
-
-    def set_value_index_out(self, idx, val):
-        self.__out_tangent[idx] = val
-
-    def set_first_tangent(self):
-        self.__in_tangent = self.__value
-
-    def set_last_tangent(self):
-        self.__out_tangent = self.__value
-
-    @property
-    def value(self) -> typing.Union[mathutils.Vector, mathutils.Euler, mathutils.Quaternion, typing.List[float]]:
-        if self.target == "value":
-            return self.__value
-        return gltf2_blender_math.list_to_mathutils(self.__value, self.target)
-
-    @value.setter
-    def value(self, value: typing.List[float]):
-        self.__value = self.__set_indexed(value)
-
-    @value.setter
-    def value_total(self, value: typing.List[float]):
-        self.__value = value
-
-    @property
-    def in_tangent(self) -> typing.Union[mathutils.Vector, mathutils.Euler, mathutils.Quaternion, typing.List[float]]:
-        if self.__in_tangent is None:
-            return None
-        if self.target == "value":
-            return self.__in_tangent
-        return gltf2_blender_math.list_to_mathutils(self.__in_tangent, self.target)
-
-    @in_tangent.setter
-    def in_tangent(self, value: typing.List[float]):
-        self.__in_tangent = self.__set_indexed(value)
-
-    @property
-    def out_tangent(self) -> typing.Union[mathutils.Vector, mathutils.Euler, mathutils.Quaternion, typing.List[float]]:
-        if self.__out_tangent is None:
-            return None
-        if self.target == "value":
-            return self.__out_tangent
-        return gltf2_blender_math.list_to_mathutils(self.__out_tangent, self.target)
-
-    @out_tangent.setter
-    def out_tangent(self, value: typing.List[float]):
-        self.__out_tangent = self.__set_indexed(value)

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/exp/animation/sampled/armature/action_sampled.py

@@ -1,55 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import bpy
-import typing
-from ......io.exp.user_extensions import export_user_extensions
-from ......io.com import gltf2_io
-from .....com.extras import generate_extras
-from ...fcurves.sampler import gather_animation_fcurves_sampler
-from .channels import gather_armature_sampled_channels
-
-
-def gather_action_armature_sampled(armature_uuid: str,
-                                   blender_action: typing.Optional[bpy.types.Action],
-                                   slot_identifier: str,
-                                   cache_key: str,
-                                   export_settings):
-
-    blender_object = export_settings['vtree'].nodes[armature_uuid].blender_object
-
-    try:
-        channels, extra_channels = __gather_channels(
-            armature_uuid, blender_action.name if blender_action else cache_key, slot_identifier if blender_action else None, export_settings)
-    except RuntimeError as error:
-        export_settings['log'].warning("Animation channels on action '{}' could not be exported. Cause: {}".format(name, error))
-        return None
-
-    export_user_extensions('pre_gather_animation_hook', export_settings, channels, blender_action, slot_identifier, blender_object)
-
-    extra_samplers = []
-    if export_settings['gltf_export_extra_animations']:
-        for chan in [chan for chan in extra_channels.values() if len(chan['properties']) != 0]:
-            for channel_group_name, channel_group in chan['properties'].items():
-
-                # No glTF channel here, as we don't have any target
-                # Trying to retrieve sampler directly
-                sampler = gather_animation_fcurves_sampler(
-                    armature_uuid, tuple(channel_group), None, None, True, export_settings)
-                if sampler is not None:
-                    extra_samplers.append((channel_group_name, sampler))
-
-    if not channels:
-        return None, extra_samplers
-
-    # To allow reuse of samplers in one animation : This will be done later, when we know all channels are here
-
-    export_user_extensions('animation_channels_armature_sampled', export_settings,
-                           channels, blender_object, blender_action, slot_identifier, cache_key)
-
-    return channels, extra_samplers
-
-
-def __gather_channels(armature_uuid, blender_action_name, slot_identifier, export_settings) -> typing.List[gltf2_io.AnimationChannel]:
-    return gather_armature_sampled_channels(armature_uuid, blender_action_name, slot_identifier, export_settings)

package/staging_area/Blender/5.0/scripts/addons_core/io_scene_gltf2/blender/exp/animation/sampled/armature/channel_target.py

@@ -1,54 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2022 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from ......io.exp.user_extensions import export_user_extensions
-from ......io.com import gltf2_io
-from ....cache import cached
-from ....joints import gather_joint_vnode
-
-
-@cached
-def gather_armature_sampled_channel_target(
-        armature_uuid: str,
-        bone: str,
-        channel: str,
-        export_settings
-) -> gltf2_io.AnimationChannelTarget:
-
-    blender_object = export_settings['vtree'].nodes[armature_uuid].blender_object
-
-    animation_channel_target = gltf2_io.AnimationChannelTarget(
-        extensions=__gather_extensions(armature_uuid, bone, channel, export_settings),
-        extras=__gather_extras(armature_uuid, bone, channel, export_settings),
-        node=__gather_node(armature_uuid, bone, export_settings),
-        path=__gather_path(channel, export_settings)
-    )
-
-    export_user_extensions('gather_animation_bone_sampled_channel_target_hook',
-                           export_settings,
-                           blender_object,
-                           bone,
-                           channel)
-
-    return animation_channel_target
-
-
-def __gather_extensions(armature_uuid, bone, channel, export_settings):
-    return None
-
-
-def __gather_extras(armature_uuid, bone, channel, export_settings):
-    return None
-
-
-def __gather_node(armature_uuid, bone, export_settings):
-    return gather_joint_vnode(export_settings['vtree'].nodes[armature_uuid].bones[bone], export_settings)
-
-
-def __gather_path(channel, export_settings):
-    return {
-        "location": "translation",
-        "rotation_quaternion": "rotation",
-        "scale": "scale"
-    }.get(channel)