@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/sampled/armature/channels.py

@@ -1,236 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2022 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import bpy
-import typing
-from ......io.com import gltf2_io
-from ......io.exp.user_extensions import export_user_extensions
-from .....com.conversion import get_gltf_interpolation
-from .....com.conversion import get_target, get_channel_from_target
-from ...fcurves.channels import get_channel_groups
-from ...fcurves.channels import needs_baking
-from ...drivers import get_sk_drivers
-from ..object.channels import gather_sampled_object_channel
-from ..shapekeys.channels import gather_sampled_sk_channel
-from .channel_target import gather_armature_sampled_channel_target
-from .sampler import gather_bone_sampled_animation_sampler
-
-
-def gather_armature_sampled_channels(armature_uuid, blender_action_name, slot_identifier,
-                                     export_settings) -> typing.List[gltf2_io.AnimationChannel]:
-    channels = []
-    extra_channels = {}
-
-    # Then bake all bones
-    bones_to_be_animated = []
-    bones_uuid = export_settings["vtree"].get_all_bones(armature_uuid)
-    bones_to_be_animated = [
-        export_settings["vtree"].nodes[b].blender_bone.name for b in bones_uuid if export_settings["vtree"].nodes[b].leaf_reference is None]
-
-    # List of really animated bones is needed for optimization decision
-    list_of_animated_bone_channels = {}
-    if slot_identifier is not None:
-        if armature_uuid != blender_action_name and blender_action_name in bpy.data.actions:
-            # Not bake situation
-            channels_animated, to_be_sampled, extra_channels = get_channel_groups(
-                armature_uuid, bpy.data.actions[blender_action_name],
-                    bpy.data.actions[blender_action_name].slots[slot_identifier], export_settings)
-            for chan in [chan for chan in channels_animated.values() if chan['bone'] is not None]:
-                for prop in chan['properties'].keys():
-                    list_of_animated_bone_channels[(chan['bone'], get_channel_from_target(get_target(prop)))] = get_gltf_interpolation(
-                        chan['properties'][prop][0].keyframe_points[0].interpolation, export_settings)  # Could be exported without sampling : keep interpolation
-
-            for _, _, chan_prop, chan_bone in [chan for chan in to_be_sampled if chan[1] == "BONE"]:
-                list_of_animated_bone_channels[
-                    (
-                        chan_bone,
-                        chan_prop,
-                    )
-                ] = get_gltf_interpolation(export_settings['gltf_sampling_interpolation_fallback'], export_settings)  # if forced to be sampled, keep the interpolation chosen by the user
-    else:
-        pass
-        # There is no animated channels (because if it was, we would have a slot_identifier)
-        # We are in a bake situation
-
-    for bone in bones_to_be_animated:
-        for p in ["location", "rotation_quaternion", "scale"]:
-            channel = gather_sampled_bone_channel(
-                armature_uuid,
-                bone,
-                p,
-                blender_action_name,
-                slot_identifier,
-                (bone, p) in list_of_animated_bone_channels.keys(),
-                list_of_animated_bone_channels[(bone, p)] if (bone, p) in list_of_animated_bone_channels.keys() else get_gltf_interpolation(export_settings['gltf_sampling_interpolation_fallback'], export_settings),
-                export_settings)
-            if channel is not None:
-                channels.append(channel)
-
-    bake_interpolation = get_gltf_interpolation(export_settings['gltf_sampling_interpolation_fallback'], export_settings)
-    # Retrieve animation on armature object itself, if any
-    if blender_action_name == armature_uuid or export_settings['gltf_animation_mode'] in ["SCENE", "NLA_TRACKS"]:
-        # If armature is baked (no animation of armature), need to use all channels
-        armature_channels = [
-            ["location", bake_interpolation],
-            ["rotation_quaternion", bake_interpolation],
-            ["scale", bake_interpolation]
-        ]
-        animated_channels = []
-    else:
-        # The armature has some channel(s) animated, checking which one(s)
-        armature_channels = __gather_armature_object_channel(
-            armature_uuid, bpy.data.actions[blender_action_name], slot_identifier, export_settings)
-        animated_channels = armature_channels
-
-    for (p, i) in armature_channels:
-        armature_channel = gather_sampled_object_channel(
-            armature_uuid,
-            p,
-            blender_action_name,
-            slot_identifier,
-            p in [a[0] for a in animated_channels],
-            [c[1] for c in animated_channels if c[0] == p][0] if p in [a[0] for a in animated_channels] else bake_interpolation,
-            export_settings
-        )
-
-        if armature_channel is not None:
-            channels.append(armature_channel)
-
-    # Retrieve channels for drivers, if needed
-    drivers_to_manage = get_sk_drivers(armature_uuid, export_settings)
-    for obj_driver_uuid in drivers_to_manage:
-        channel = gather_sampled_sk_channel(obj_driver_uuid, armature_uuid + "_" + blender_action_name, slot_identifier, export_settings)
-        if channel is not None:
-            channels.append(channel)
-
-    return channels, extra_channels
-
-
-def gather_sampled_bone_channel(
-        armature_uuid: str,
-        bone: str,
-        channel: str,
-        action_name: str,
-        slot_identifier: str,
-        node_channel_is_animated: bool,
-        node_channel_interpolation: str,
-        export_settings
-):
-
-    __target = __gather_target(armature_uuid, bone, channel, export_settings)
-    if __target.path is not None:
-        sampler = __gather_sampler(
-            armature_uuid,
-            bone,
-            channel,
-            action_name,
-            slot_identifier,
-            node_channel_is_animated,
-            node_channel_interpolation,
-            export_settings)
-
-        if sampler is None:
-            # After check, no need to animate this node for this channel
-            return None
-
-        animation_channel = gltf2_io.AnimationChannel(
-            extensions=None,
-            extras=None,
-            sampler=sampler,
-            target=__target
-        )
-
-        export_user_extensions('gather_animation_channel_hook',
-                               export_settings,
-                               animation_channel,
-                               channel,
-                               export_settings['vtree'].nodes[armature_uuid].blender_object,
-                               bone,
-                               action_name,
-                               node_channel_is_animated
-                               )
-
-        return animation_channel
-    return None
-
-
-def __gather_target(armature_uuid: str,
-                    bone: str,
-                    channel: str,
-                    export_settings
-                    ) -> gltf2_io.AnimationChannelTarget:
-
-    return gather_armature_sampled_channel_target(
-        armature_uuid, bone, channel, export_settings)
-
-
-def __gather_sampler(
-        armature_uuid,
-        bone,
-        channel,
-        action_name,
-        slot_identifier, #TODOSLOT
-        node_channel_is_animated,
-        node_channel_interpolation,
-        export_settings):
-    return gather_bone_sampled_animation_sampler(
-        armature_uuid,
-        bone,
-        channel,
-        action_name,
-        slot_identifier, #TODOSLOT
-        node_channel_is_animated,
-        node_channel_interpolation,
-        export_settings
-    )
-
-
-def __gather_armature_object_channel(obj_uuid: str, blender_action, slot_identifier, export_settings):
-    channels = []
-
-    channels_animated, to_be_sampled, extra_channels = get_channel_groups(obj_uuid, blender_action, blender_action.slots[slot_identifier], export_settings)
-    # Remove all channel linked to bones, keep only directly object channels
-    channels_animated = [c for c in channels_animated.values() if c['type'] == "OBJECT"]
-    to_be_sampled = [c for c in to_be_sampled if c[1] == "OBJECT"]
-
-    original_channels = []
-    for c in channels_animated:
-        original_channels.extend([(prop, c['properties'][prop][0].keyframe_points[0].interpolation)
-                                 for prop in c['properties'].keys()])
-
-    for c, inter in original_channels:
-        channels.append(
-            (
-                {
-                    "location": "location",
-                    "rotation_quaternion": "rotation_quaternion",
-                    "rotation_euler": "rotation_quaternion",
-                    "scale": "scale",
-                    "delta_location": "location",
-                    "delta_scale": "scale",
-                    "delta_rotation_euler": "rotation_quaternion",
-                    "delta_rotation_quaternion": "rotation_quaternion"
-                }.get(c),
-                get_gltf_interpolation(inter, export_settings)
-            )
-        )
-
-    for c in to_be_sampled:
-        channels.append(
-            (
-                {
-                    "location": "location",
-                    "rotation_quaternion": "rotation_quaternion",
-                    "rotation_euler": "rotation_quaternion",
-                    "scale": "scale",
-                    "delta_location": "location",
-                    "delta_scale": "scale",
-                    "delta_rotation_euler": "rotation_quaternion",
-                    "delta_rotation_quaternion": "rotation_quaternion"
-                }.get(c[2]),
-                get_gltf_interpolation(export_settings['gltf_sampling_interpolation_fallback'], export_settings)  # Forced to be sampled, so use the interpolation chosen by the user
-            )
-        )
-
-    return channels

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

@@ -1,95 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2022 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import typing
-import numpy as np
-from ....cache import cached
-from ...keyframes import Keyframe
-from ..sampling_cache import get_cache_data
-
-
-@cached
-def gather_bone_sampled_keyframes(
-        armature_uuid: str,
-        bone: str,
-        channel: str,
-        action_name: str,
-        slot_identifier: str,
-        node_channel_is_animated: bool,
-        export_settings
-) -> typing.List[Keyframe]:
-
-    start_frame = export_settings['ranges'][armature_uuid][action_name]['start']
-    end_frame = export_settings['ranges'][armature_uuid][action_name]['end']
-
-    keyframes = []
-
-    frame = start_frame
-    step = export_settings['gltf_frame_step']
-
-    while frame <= end_frame:
-        key = Keyframe(None, frame, channel)
-
-        mat = get_cache_data(
-            'bone',
-            armature_uuid,
-            bone,
-            action_name,
-            frame,
-            step,
-            slot_identifier,
-            export_settings)
-
-        trans, rot, scale = mat.decompose()
-
-        key.value = {
-            "location": trans,
-            "rotation_quaternion": rot,
-            "scale": scale
-        }[channel]
-
-        keyframes.append(key)
-        frame += step
-
-    if len(keyframes) == 0:
-        # For example, option CROP negative frames, but all are negatives
-        return None
-
-    if not export_settings['gltf_optimize_animation']:
-        # For bones, if all values are the same, keeping only if changing values, or if user want to keep data
-        if node_channel_is_animated is True:
-            return keyframes  # Always keeping
-        else:
-            # baked bones
-            if export_settings['gltf_optimize_animation_keep_armature'] is False:
-                # Not keeping if not changing property
-                cst = fcurve_is_constant(keyframes)
-                return None if cst is True else keyframes
-            else:
-                # Keep data, as requested by user. We keep all samples, as user don't want to optimize
-                return keyframes
-
-    else:
-
-        # For armatures
-        # Check if all values are the same
-        # In that case, if there is no real keyframe on this channel for this given bone,
-        # We can ignore these keyframes
-        # if there are some fcurve, we can keep only 2 keyframes, first and last
-        cst = fcurve_is_constant(keyframes)
-
-        if node_channel_is_animated is True:  # fcurve on this bone for this property
-            # Keep animation, but keep only 2 keyframes if data are not changing
-            return [keyframes[0], keyframes[-1]] if cst is True and len(keyframes) >= 2 else keyframes
-        else:  # bone is not animated (no fcurve)
-            # Not keeping if not changing property if user decided to not keep
-            if export_settings['gltf_optimize_animation_keep_armature'] is False:
-                return None if cst is True else keyframes
-            else:
-                # Keep at least 2 keyframes if data are not changing
-                return [keyframes[0], keyframes[-1]] if cst is True and len(keyframes) >= 2 else keyframes
-
-
-def fcurve_is_constant(keyframes):
-    return all([j < 0.0001 for j in np.ptp([[k.value[i] for i in range(len(keyframes[0].value))] for k in keyframes], axis=0)])

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

@@ -1,230 +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.exp.user_extensions import export_user_extensions
-from ......io.com import constants as gltf2_io_constants
-from ......io.exp import binary_data as gltf2_io_binary_data
-from .....com import gltf2_blender_math
-from ....accessors import gather_accessor
-from ....cache import cached
-from ....tree import VExportNode
-from .keyframes import gather_bone_sampled_keyframes
-
-
-@cached
-def gather_bone_sampled_animation_sampler(
-        armature_uuid: str,
-        bone: str,
-        channel: str,
-        action_name: str,
-        slot_identifier: str,
-        node_channel_is_animated: bool,
-        node_channel_interpolation: str,
-        export_settings
-):
-
-    pose_bone = export_settings['vtree'].nodes[armature_uuid].blender_object.pose.bones[bone]
-
-    keyframes = __gather_keyframes(
-        armature_uuid,
-        bone,
-        channel,
-        action_name,
-        slot_identifier,
-        node_channel_is_animated,
-        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(armature_uuid, bone, channel, keyframes, action_name, export_settings)
-
-    sampler = gltf2_io.AnimationSampler(
-        extensions=None,
-        extras=None,
-        input=input,
-        interpolation=__gather_interpolation(
-            node_channel_is_animated,
-            node_channel_interpolation,
-            keyframes,
-            export_settings),
-        output=output)
-
-    export_user_extensions('gather_animation_sampler_hook',
-                           export_settings,
-                           sampler,
-                           export_settings['vtree'].nodes[armature_uuid].blender_object,
-                           pose_bone,
-                           action_name,
-                           node_channel_is_animated)
-
-    return sampler
-
-
-@cached
-def __gather_keyframes(
-        armature_uuid: str,
-        bone: str,
-        channel: str,
-        action_name: str,
-        slot_identifier: str,
-        node_channel_is_animated: bool,
-        export_settings
-):
-
-    keyframes = gather_bone_sampled_keyframes(
-        armature_uuid,
-        bone,
-        channel,
-        action_name,
-        slot_identifier,
-        node_channel_is_animated,
-        export_settings
-    )
-
-    if keyframes is None:
-        # After check, no need to animation this node
-        return None
-
-    return keyframes
-
-
-def __convert_keyframes(armature_uuid, bone_name, channel, keyframes, action_name, export_settings):
-
-    # Sliding can come from:
-    # - option SLIDE for negative frames
-    # - option to start animation at frame 0 for looping
-    if armature_uuid in export_settings['slide'].keys(
-    ) and action_name in export_settings['slide'][armature_uuid].keys():
-        for k in keyframes:
-            k.frame += -export_settings['slide'][armature_uuid][action_name]
-            k.seconds = k.frame / (bpy.context.scene.render.fps * bpy.context.scene.render.fps_base)
-
-    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']
-
-    bone = export_settings['vtree'].nodes[armature_uuid].blender_object.pose.bones[bone_name]
-    target_datapath = "pose.bones['" + bone_name + "']." + channel
-
-    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[armature_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
-
-    values = []
-    fps = (bpy.context.scene.render.fps * bpy.context.scene.render.fps_base)
-    for keyframe in keyframes:
-        # Transform the data and build gltf control points
-        value = gltf2_blender_math.transform(keyframe.value, target_datapath, transform, False)
-        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, False)
-
-            # 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, False)
-
-            # 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
-    data_type = gltf2_io_constants.DataType.vec_type_from_num(len(keyframes[0].value))
-
-
-    output = gather_accessor(
-        gltf2_io_binary_data.BinaryData.from_list(values, component_type),
-        component_type,
-        len(values) // gltf2_io_constants.DataType.num_elements(data_type),
-        None,
-        None,
-        data_type,
-        export_settings)
-
-    return input, output
-
-
-def __gather_interpolation(node_channel_is_animated, node_channel_interpolation, keyframes, export_settings):
-
-    if len(keyframes) > 2:
-        # keep STEP as STEP, other become the interpolation chosen by the user
-        return {
-            "STEP": "STEP"
-        }.get(node_channel_interpolation, export_settings['gltf_sampling_interpolation_fallback'])
-    elif len(keyframes) == 1:
-        if node_channel_is_animated is False:
-            return "STEP"
-        elif node_channel_interpolation == "CUBICSPLINE":
-            return export_settings['gltf_sampling_interpolation_fallback']  # We can't have a single keyframe with CUBICSPLINE
-        else:
-            return node_channel_interpolation
-    else:
-        # If we only have 2 keyframes, set interpolation to STEP if baked
-        if node_channel_is_animated is False:
-            # baked => We have first and last keyframe
-            return "STEP"
-        else:
-            if keyframes[0].value == keyframes[1].value:
-                return "STEP"
-            else:
-                return export_settings['gltf_sampling_interpolation_fallback']

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

@@ -1,48 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2023 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from ......io.com import gltf2_io
-from ....cache import cached
-
-
-@cached
-def gather_data_sampled_channel_target(
-        blender_type_data: str,
-        blender_id,
-        channel: str,
-        additional_key: str,  # Used to differentiate between material / material node_tree
-        export_settings
-) -> gltf2_io.AnimationChannelTarget:
-
-    animation_channel_target = gltf2_io.AnimationChannelTarget(
-        extensions=__gather_extensions(blender_type_data, blender_id, channel, export_settings),
-        extras=__gather_extras(blender_type_data, blender_id, channel, export_settings),
-        node=__gather_node(blender_type_data, blender_id, export_settings),
-        path=__gather_path(blender_type_data, blender_id, channel, export_settings)
-    )
-
-    return animation_channel_target
-
-
-def __gather_extensions(blender_type_data, blender_id, channel, export_settings):
-    return None
-
-
-def __gather_extras(blender_type_data, blender_id, channel, export_settings):
-    return None
-
-
-def __gather_node(blender_type_data, blender_id, export_settings):
-    if blender_type_data == "materials":
-        return export_settings['KHR_animation_pointer']['materials'][blender_id]['glTF_material']
-    elif blender_type_data == "lights":
-        return export_settings['KHR_animation_pointer']['lights'][blender_id]['glTF_light']
-    elif blender_type_data == "cameras":
-        return export_settings['KHR_animation_pointer']['cameras'][blender_id]['glTF_camera']
-    else:
-        pass  # This should never happen
-
-
-def __gather_path(blender_type_data, blender_id, channel, export_settings):
-    return export_settings['KHR_animation_pointer'][blender_type_data][blender_id]['paths'][channel]['path']