@tushar-br/editing-pack 1.0.188 → 1.0.190

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

@@ -1,366 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import bpy
-from typing import List, Optional, Tuple
-import numpy as np
-from ...io.com import gltf2_io, constants as gltf2_io_constants, gltf2_io_extensions
-from ...blender.com.data_path import get_sk_exported
-from ...io.exp import binary_data as gltf2_io_binary_data
-from .cache import cached, cached_by_key
-from . import primitive_extract as gltf2_blender_gather_primitives_extract
-from . import primitive_attributes as gltf2_blender_gather_primitive_attributes
-from .accessors import gather_accessor, array_to_accessor
-from .material.materials import get_final_material, gather_material, get_base_material, get_material_from_idx
-from .material.extensions import variants as ext_variants
-
-
-@cached
-def gather_primitive_cache_key(
-        blender_mesh,
-        uuid_for_skined_data,
-        vertex_groups,
-        modifiers,
-        materials,
-        export_settings):
-
-    # Use id of mesh
-    # Do not use bpy.types that can be unhashable
-    # Do not use mesh name, that can be not unique (when linked)
-
-    # TODO check what is really needed for modifiers
-
-    return (
-        (id(blender_mesh),),
-        (modifiers,),
-        tuple(id(m) if m is not None else None for m in materials)
-    )
-
-
-@cached_by_key(key=gather_primitive_cache_key)
-def gather_primitives(
-        blender_mesh: bpy.types.Mesh,
-        uuid_for_skined_data,
-        vertex_groups: bpy.types.VertexGroups,
-        modifiers: Optional[bpy.types.ObjectModifiers],
-        materials: Tuple[bpy.types.Material],
-        export_settings
-) -> List[gltf2_io.MeshPrimitive]:
-    """
-    Extract the mesh primitives from a blender object
-
-    :return: a list of glTF2 primitives
-    """
-    primitives = []
-
-    blender_primitives, addional_materials_udim = __gather_cache_primitives(
-        materials, blender_mesh, uuid_for_skined_data, vertex_groups, modifiers, export_settings)
-
-    for internal_primitive, udim_material in zip(blender_primitives, addional_materials_udim):
-
-        if udim_material is None:  # classic case, not an udim material
-            # We already call this function, in order to retrieve uvmap info, if any
-            # So here, only the cache will be used
-            base_material, material_info = get_base_material(internal_primitive['material'], materials, export_settings)
-
-            # Now, we can retrieve the real material, by checking attributes and active maps
-            blender_mat = get_material_from_idx(internal_primitive['material'], materials, export_settings)
-            material = get_final_material(
-                blender_mesh,
-                blender_mat,
-                internal_primitive['uvmap_attributes_index'],
-                base_material,
-                material_info["uv_info"],
-                export_settings)
-        else:
-            # UDIM case
-            base_material, material_info, unique_material_id, tile = udim_material
-            material = get_final_material(
-                blender_mesh,
-                unique_material_id,
-                internal_primitive['uvmap_attributes_index'],
-                base_material,
-                material_info["uv_info"],
-                export_settings)
-
-            # Force change name of material to get the tile number in the name
-            material.name = material.name + "." + tile
-
-        primitive = gltf2_io.MeshPrimitive(
-            attributes=internal_primitive['attributes'],
-            extensions=__gather_extensions(
-                blender_mesh,
-                internal_primitive['material'],
-                internal_primitive['uvmap_attributes_index'],
-                export_settings),
-            extras=None,
-            indices=internal_primitive['indices'],
-            material=material,
-            mode=internal_primitive['mode'],
-            targets=internal_primitive['targets'])
-        primitives.append(primitive)
-
-    return primitives
-
-
-@cached
-def get_primitive_cache_key(
-        materials,
-        blender_mesh,
-        uuid_for_skined_data,
-        vertex_groups,
-        modifiers,
-        export_settings):
-
-    # Use id of mesh
-    # Do not use bpy.types that can be unhashable
-    # Do not use mesh name, that can be not unique (when linked)
-    # Do not use materials here
-
-    # TODO check what is really needed for modifiers
-
-    return (
-        (id(blender_mesh),),
-        (modifiers,)
-    )
-
-
-@cached_by_key(key=get_primitive_cache_key)
-def __gather_cache_primitives(
-        materials,
-        blender_mesh: bpy.types.Mesh,
-        uuid_for_skined_data,
-        vertex_groups: bpy.types.VertexGroups,
-        modifiers: Optional[bpy.types.ObjectModifiers],
-        export_settings
-) -> List[dict]:
-    """
-    Gather parts that are identical for instances, i.e. excluding materials
-    """
-    primitives = []
-
-    blender_primitives, additional_materials_udim, shared_attributes = gltf2_blender_gather_primitives_extract.extract_primitives(
-        materials, blender_mesh, uuid_for_skined_data, vertex_groups, modifiers, export_settings)
-
-    if shared_attributes is not None:
-
-        if len(blender_primitives) > 0:
-            shared = {}
-            shared["attributes"] = shared_attributes
-
-            attributes = __gather_attributes(shared, blender_mesh, modifiers, export_settings)
-            targets = __gather_targets(shared, blender_mesh, modifiers, export_settings)
-
-        for internal_primitive in blender_primitives:
-            if internal_primitive.get('mode') is None:
-
-                primitive = {
-                    "attributes": attributes,
-                    "indices": __gather_indices(internal_primitive, blender_mesh, modifiers, export_settings),
-                    "mode": internal_primitive.get('mode'),
-                    "material": internal_primitive.get('material'),
-                    "targets": targets,
-                    "uvmap_attributes_index": internal_primitive.get('uvmap_attributes_index')
-                }
-
-            else:
-                # Edges & points, no shared attributes
-                primitive = {
-                    "attributes": __gather_attributes(internal_primitive, blender_mesh, modifiers, export_settings),
-                    "indices": __gather_indices(internal_primitive, blender_mesh, modifiers, export_settings),
-                    "mode": internal_primitive.get('mode'),
-                    "material": internal_primitive.get('material'),
-                    "targets": __gather_targets(internal_primitive, blender_mesh, modifiers, export_settings),
-                    "uvmap_attributes_index": internal_primitive.get('uvmap_attributes_index')
-                }
-            primitives.append(primitive)
-
-    else:
-
-        for internal_primitive in blender_primitives:
-            primitive = {
-                "attributes": __gather_attributes(internal_primitive, blender_mesh, modifiers, export_settings),
-                "indices": __gather_indices(internal_primitive, blender_mesh, modifiers, export_settings),
-                "mode": internal_primitive.get('mode'),
-                "material": internal_primitive.get('material'),
-                "targets": __gather_targets(internal_primitive, blender_mesh, modifiers, export_settings),
-                "uvmap_attributes_index": internal_primitive.get('uvmap_attributes_index')
-            }
-            primitives.append(primitive)
-
-    return primitives, additional_materials_udim
-
-
-def __gather_indices(blender_primitive, blender_mesh, modifiers, export_settings):
-    indices = blender_primitive.get('indices')
-    if indices is None:
-        return None
-
-    # NOTE: Values used by some graphics APIs as "primitive restart" values are disallowed.
-    # Specifically, the values 65535 (in UINT16) and 4294967295 (in UINT32) cannot be used as indices.
-    # https://github.com/KhronosGroup/glTF/issues/1142
-    # https://github.com/KhronosGroup/glTF/pull/1476/files
-    # Also, UINT8 mode is not supported:
-    # https://github.com/KhronosGroup/glTF/issues/1471
-    max_index = indices.max()
-    if max_index < 65535:
-        component_type = gltf2_io_constants.ComponentType.UnsignedShort
-        indices = indices.astype(np.uint16, copy=False)
-    elif max_index < 4294967295:
-        component_type = gltf2_io_constants.ComponentType.UnsignedInt
-        indices = indices.astype(np.uint32, copy=False)
-    else:
-        export_settings['log'].error(
-            'A mesh contains too many vertices (' +
-            str(max_index) +
-            ') and needs to be split before export.')
-        return None
-
-    element_type = gltf2_io_constants.DataType.Scalar
-    binary_data = gltf2_io_binary_data.BinaryData(
-        indices.tobytes(), bufferViewTarget=gltf2_io_constants.BufferViewTarget.ELEMENT_ARRAY_BUFFER)
-    return gather_accessor(
-        binary_data,
-        component_type,
-        len(indices),
-        None,
-        None,
-        element_type,
-        export_settings
-    )
-
-
-def __gather_attributes(blender_primitive, blender_mesh, modifiers, export_settings):
-    return gltf2_blender_gather_primitive_attributes.gather_primitive_attributes(blender_primitive, export_settings)
-
-
-def __gather_targets(blender_primitive, blender_mesh, modifiers, export_settings):
-    if export_settings['gltf_morph']:
-        targets = []
-        if blender_mesh.shape_keys is not None:
-            morph_index = 0
-            for blender_shape_key in get_sk_exported(blender_mesh.shape_keys.key_blocks):
-
-                target_position_id = 'MORPH_POSITION_' + str(morph_index)
-                target_normal_id = 'MORPH_NORMAL_' + str(morph_index)
-                target_tangent_id = 'MORPH_TANGENT_' + str(morph_index)
-
-                if blender_primitive["attributes"].get(target_position_id) is not None:
-                    target = {}
-                    internal_target_position = blender_primitive["attributes"][target_position_id]["data"]
-                    target["POSITION"] = array_to_accessor(
-                        internal_target_position,
-                        export_settings,
-                        component_type=gltf2_io_constants.ComponentType.Float,
-                        data_type=gltf2_io_constants.DataType.Vec3,
-                        include_max_and_min=True,
-                        sparse_type='SK'
-                    )
-
-                    if export_settings['gltf_normals'] \
-                            and export_settings['gltf_morph_normal'] \
-                            and blender_primitive["attributes"].get(target_normal_id) is not None:
-
-                        internal_target_normal = blender_primitive["attributes"][target_normal_id]["data"]
-                        target['NORMAL'] = array_to_accessor(
-                            internal_target_normal,
-                            export_settings,
-                            component_type=gltf2_io_constants.ComponentType.Float,
-                            data_type=gltf2_io_constants.DataType.Vec3,
-                            sparse_type='SK'
-                        )
-
-                    if export_settings['gltf_tangents'] \
-                            and export_settings['gltf_morph_tangent'] \
-                            and blender_primitive["attributes"].get(target_tangent_id) is not None:
-                        internal_target_tangent = blender_primitive["attributes"][target_tangent_id]["data"]
-                        target['TANGENT'] = array_to_accessor(
-                            internal_target_tangent,
-                            export_settings,
-                            component_type=gltf2_io_constants.ComponentType.Float,
-                            data_type=gltf2_io_constants.DataType.Vec3,
-                            sparse_type='SK'
-                        )
-                    targets.append(target)
-                    morph_index += 1
-        return targets
-    return None
-
-
-def __gather_extensions(blender_mesh,
-                        material_idx: int,
-                        attr_indices: dict,
-                        export_settings):
-    extensions = {}
-
-    if bpy.context.preferences.addons['io_scene_gltf2'].preferences.KHR_materials_variants_ui is False:
-        return None
-
-    if not bpy.data.scenes[0].gltf2_KHR_materials_variants_variants:
-        return None
-
-    # Material idx is the slot idx. Retrieve associated variant, if any
-    mapping = []
-    variants_idx_in_use = []
-    for i in [v for v in blender_mesh.gltf2_variant_mesh_data if v.material_slot_index == material_idx]:
-        variants = []
-        for idx, v in enumerate(i.variants):
-            if v.variant.variant_idx in [o.variant.variant_idx for o in i.variants[:idx]]:
-                # Avoid duplicates
-                continue
-
-            # Avoid duplicates from a previous variant (in mapping list)
-            # This happen only before fix of #2542
-            if v.variant.variant_idx in variants_idx_in_use:
-                # Avoid duplicates
-                export_settings['log'].warning(
-                    'Variant ' + str(v.variant.variant_idx) +
-                    ' has 2 different materials for a single slot. Skipping it.')
-                continue
-
-            vari = ext_variants.gather_variant(v.variant.variant_idx, export_settings)
-            if vari is not None:
-                variants_idx_in_use.append(v.variant.variant_idx)
-                variant_extension = gltf2_io_extensions.ChildOfRootExtension(
-                    name="KHR_materials_variants",
-                    path=["variants"],
-                    extension=vari,
-                    required=False
-                )
-            variants.append(variant_extension)
-        if len(variants) > 0:
-            if i.material:
-                export_settings['current_paths'] = {}  # Used for KHR_animation_pointer.
-                base_material, material_info = gather_material(
-                    i.material,
-                    export_settings
-                )
-            else:
-                # empty slot
-                base_material = None
-
-            if base_material is not None:
-                # Now, we can retrieve the real material, by checking attributes and active maps
-                mat = get_final_material(
-                    blender_mesh,
-                    i.material,
-                    attr_indices,
-                    base_material,
-                    material_info["uv_info"],
-                    export_settings)
-            else:
-                mat = None
-
-            mapping.append({'material': mat, 'variants': variants})
-
-    if len(mapping) > 0:
-        extensions["KHR_materials_variants"] = gltf2_io_extensions.Extension(
-            name="KHR_materials_variants",
-            extension={
-                "mappings": mapping
-            },
-            required=False
-        )
-
-    return extensions if extensions else None

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

@@ -1,187 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import bpy
-from ...io.com import gltf2_io
-from ...io.exp.user_extensions import export_user_extensions
-from ...io.com.constants import TextureFilter, TextureWrap
-from .cache import cached
-from .material.search_node_tree import previous_node, previous_socket, get_const_from_socket, NodeSocket
-
-
-@cached
-def gather_sampler(blender_shader_node: bpy.types.Node, group_path_str, export_settings):
-    # reconstruct group_path from group_path_str
-    sep_item = "##~~gltf-sep~~##"
-    sep_inside_item = "##~~gltf-inside-sep~~##"
-    group_path = []
-    tab = group_path_str.split(sep_item)
-    if len(tab) > 0:
-        group_path.append(bpy.data.materials[tab[0]])
-    for idx, i in enumerate(tab[1:]):
-        subtab = i.split(sep_inside_item)
-        if idx == 0:
-            group_path.append(bpy.data.materials[tab[0]].node_tree.nodes[subtab[1]])
-        else:
-            group_path.append(bpy.data.node_groups[subtab[0]].nodes[subtab[1]])
-
-    wrap_s, wrap_t = __gather_wrap(blender_shader_node, group_path, export_settings)
-
-    sampler = gltf2_io.Sampler(
-        extensions=__gather_extensions(blender_shader_node, export_settings),
-        extras=__gather_extras(blender_shader_node, export_settings),
-        mag_filter=__gather_mag_filter(blender_shader_node, export_settings),
-        min_filter=__gather_min_filter(blender_shader_node, export_settings),
-        name=__gather_name(blender_shader_node, export_settings),
-        wrap_s=wrap_s,
-        wrap_t=wrap_t,
-    )
-
-    export_user_extensions('gather_sampler_hook', export_settings, sampler, blender_shader_node)
-
-    if not sampler.extensions and not sampler.extras and not sampler.name:
-        return __sampler_by_value(
-            sampler.mag_filter,
-            sampler.min_filter,
-            sampler.wrap_s,
-            sampler.wrap_t,
-            export_settings,
-        )
-
-    return sampler
-
-
-@cached
-def __sampler_by_value(mag_filter, min_filter, wrap_s, wrap_t, export_settings):
-    # @cached function to dedupe samplers with the same settings.
-    return gltf2_io.Sampler(
-        extensions=None,
-        extras=None,
-        mag_filter=mag_filter,
-        min_filter=min_filter,
-        name=None,
-        wrap_s=wrap_s,
-        wrap_t=wrap_t,
-    )
-
-
-def __gather_extensions(blender_shader_node, export_settings):
-    return None
-
-
-def __gather_extras(blender_shader_node, export_settings):
-    return None
-
-
-def __gather_mag_filter(blender_shader_node, export_settings):
-    if blender_shader_node.interpolation == 'Closest':
-        return TextureFilter.Nearest
-    return TextureFilter.Linear
-
-
-def __gather_min_filter(blender_shader_node, export_settings):
-    if blender_shader_node.interpolation == 'Closest':
-        return TextureFilter.NearestMipmapNearest
-    return TextureFilter.LinearMipmapLinear
-
-
-def __gather_name(blender_shader_node, export_settings):
-    return None
-
-
-def __gather_wrap(blender_shader_node, group_path, export_settings):
-    # First gather from the Texture node
-    if blender_shader_node.extension == 'EXTEND':
-        wrap_s = TextureWrap.ClampToEdge
-    elif blender_shader_node.extension == 'CLIP':
-        # Not possible in glTF, but ClampToEdge is closest
-        wrap_s = TextureWrap.ClampToEdge
-    elif blender_shader_node.extension == 'MIRROR':
-        wrap_s = TextureWrap.MirroredRepeat
-    else:
-        wrap_s = TextureWrap.Repeat
-    wrap_t = wrap_s
-
-    # Starting Blender 3.5, MIRROR is now an extension of image node
-    # So this manual uv wrapping trick is no more useful for MIRROR x MIRROR
-    # But still works for old files
-    # Still needed for heterogen heterogeneous sampler, like MIRROR x REPEAT, for example
-    # Take manual wrapping into account
-    result = detect_manual_uv_wrapping(blender_shader_node, group_path)
-    if result:
-        if result['wrap_s'] is not None:
-            wrap_s = result['wrap_s']
-        if result['wrap_t'] is not None:
-            wrap_t = result['wrap_t']
-
-    # Omit if both are repeat
-    if (wrap_s, wrap_t) == (TextureWrap.Repeat, TextureWrap.Repeat):
-        wrap_s, wrap_t = None, None
-
-    return wrap_s, wrap_t
-
-
-def detect_manual_uv_wrapping(blender_shader_node, group_path):
-    # Detects UV wrapping done using math nodes. This is for emulating wrap
-    # modes Blender doesn't support. It looks like
-    #
-    #     next_socket => [Sep XYZ] => [Wrap S] => [Comb XYZ] => blender_shader_node
-    #                              => [Wrap T] =>
-    #
-    # The [Wrap _] blocks are either math nodes (eg. PINGPONG for mirrored
-    # repeat), or can be omitted.
-    #
-    # Returns None if not detected. Otherwise a dict containing the wrap
-    # mode in each direction (or None), and next_socket.
-    result = {}
-
-    comb = previous_node(NodeSocket(blender_shader_node.inputs['Vector'], group_path))
-    if comb.node is None or comb.node.type != 'COMBXYZ':
-        return None
-
-    for soc in ['X', 'Y']:
-        node = previous_node(NodeSocket(comb.node.inputs[soc], comb.group_path))
-        if node.node is None:
-            return None
-
-        if node.node.type == 'SEPXYZ':
-            # Passed through without change
-            wrap = None
-            prev_socket = previous_socket(NodeSocket(comb.node.inputs[soc], comb.group_path))
-        elif node.node.type == 'MATH':
-            # Math node applies a manual wrap
-            if (node.node.operation == 'PINGPONG' and get_const_from_socket(NodeSocket(
-                    node.node.inputs[1], node.group_path), kind='VALUE')[0] == 1.0):  # scale = 1
-                wrap = TextureWrap.MirroredRepeat
-            elif (node.node.operation == 'WRAP' and
-                    # min = 0
-                    get_const_from_socket(NodeSocket(node.node.inputs[1], node.group_path), kind='VALUE')[0] == 0.0 and
-                    get_const_from_socket(NodeSocket(node.node.inputs[2], node.group_path), kind='VALUE')[0] == 1.0):    # max = 1
-                wrap = TextureWrap.Repeat
-            else:
-                return None
-
-            prev_socket = previous_socket(NodeSocket(node.node.inputs[0], node.group_path))
-        else:
-            return None
-
-        if prev_socket.socket is None:
-            return None
-        prev_node = prev_socket.socket.node
-        if prev_node.type != 'SEPXYZ':
-            return None
-        # Make sure X goes to X, etc.
-        if prev_socket.socket.name != soc:
-            return None
-        # Make sure both attach to the same SeparateXYZ node
-        if soc == 'X':
-            sep = prev_node
-        else:
-            if sep != prev_node:
-                return None
-
-        result['wrap_s' if soc == 'X' else 'wrap_t'] = wrap
-
-    result['next_socket'] = NodeSocket(sep.inputs[0], prev_socket.group_path)
-    return result

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

@@ -1,148 +0,0 @@
-# SPDX-FileCopyrightText: 2018-2021 The glTF-Blender-IO authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import mathutils
-from ...io.com import gltf2_io, constants as gltf2_io_constants
-from ...io.exp import binary_data as gltf2_io_binary_data
-from ...io.exp.user_extensions import export_user_extensions
-from . import accessors as gltf2_blender_gather_accessors
-from . import joints as gltf2_blender_gather_joints
-from .tree import VExportNode
-from .cache import cached
-
-
-@cached
-def gather_skin(armature_uuid, export_settings):
-    """
-    Gather armatures, bones etc into a glTF2 skin object.
-
-    :param blender_object: the object which may contain a skin
-    :param export_settings:
-    :return: a glTF2 skin object
-    """
-
-    if armature_uuid not in export_settings['vtree'].nodes:
-        # User filtered objects to export, and keep the skined mesh, without keeping the armature
-        return None
-
-    blender_armature_object = export_settings['vtree'].nodes[armature_uuid].blender_object
-
-    if not __filter_skin(blender_armature_object, export_settings):
-        return None
-
-    skin = gltf2_io.Skin(
-        extensions=__gather_extensions(blender_armature_object, export_settings),
-        extras=__gather_extras(blender_armature_object, export_settings),
-        inverse_bind_matrices=__gather_inverse_bind_matrices(armature_uuid, export_settings),
-        joints=__gather_joints(armature_uuid, export_settings),
-        name=__gather_name(blender_armature_object, export_settings),
-        skeleton=__gather_skeleton(blender_armature_object, export_settings)
-    )
-
-    # If armature is not exported, joints will be empty.
-    # Do not construct skin in that case
-    if len(skin.joints) == 0:
-        return None
-
-    export_user_extensions('gather_skin_hook', export_settings, skin, blender_armature_object)
-
-    return skin
-
-
-def __filter_skin(blender_armature_object, export_settings):
-    if not export_settings['gltf_skins']:
-        return False
-    if blender_armature_object.type != 'ARMATURE' or len(blender_armature_object.pose.bones) == 0:
-        return False
-
-    return True
-
-
-def __gather_extensions(blender_armature_object, export_settings):
-    return None
-
-
-def __gather_extras(blender_armature_object, export_settings):
-    return None
-
-
-def __gather_inverse_bind_matrices(armature_uuid, export_settings):
-
-    blender_armature_object = export_settings['vtree'].nodes[armature_uuid].blender_object
-
-    axis_basis_change = mathutils.Matrix.Identity(4)
-    if export_settings['gltf_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)))
-
-    # store matrix_world of armature in case we need to add a neutral bone
-    export_settings['vtree'].nodes[armature_uuid].matrix_world_armature = blender_armature_object.matrix_world.copy()
-
-    bones_uuid = export_settings['vtree'].get_all_bones(armature_uuid)
-
-    def __collect_matrices(bone):
-        inverse_bind_matrix = (
-            axis_basis_change @
-            (
-                blender_armature_object.matrix_world @
-                bone.bone.matrix_local
-            )
-        ).inverted_safe()
-        matrices.append(inverse_bind_matrix)
-
-    matrices = []
-    for b in bones_uuid:
-        if export_settings['vtree'].nodes[b].leaf_reference is None:
-            __collect_matrices(blender_armature_object.pose.bones[export_settings['vtree'].nodes[b].blender_bone.name])
-        else:
-            inverse_bind_matrix = (
-                axis_basis_change @
-                (
-                    blender_armature_object.matrix_world @
-                    export_settings['vtree'].nodes[export_settings['vtree'].nodes[b].leaf_reference].matrix_world_tail
-                )
-            ).inverted_safe()
-            matrices.append(inverse_bind_matrix)  # Leaf bone
-
-    # flatten the matrices
-    inverse_matrices = []
-    for matrix in matrices:
-        for column in range(0, 4):
-            for row in range(0, 4):
-                inverse_matrices.append(matrix[row][column])
-
-    binary_data = gltf2_io_binary_data.BinaryData.from_list(inverse_matrices, gltf2_io_constants.ComponentType.Float)
-    return gltf2_blender_gather_accessors.gather_accessor(
-        binary_data,
-        gltf2_io_constants.ComponentType.Float,
-        len(inverse_matrices) // gltf2_io_constants.DataType.num_elements(gltf2_io_constants.DataType.Mat4),
-        None,
-        None,
-        gltf2_io_constants.DataType.Mat4,
-        export_settings
-    )
-
-
-def __gather_joints(armature_uuid, export_settings):
-
-    all_armature_children = export_settings['vtree'].nodes[armature_uuid].children
-    root_bones_uuid = [
-        c for c in all_armature_children if export_settings['vtree'].nodes[c].blender_type == VExportNode.BONE]
-
-    # Create bone nodes
-    for root_bone_uuid in root_bones_uuid:
-        gltf2_blender_gather_joints.gather_joint_vnode(root_bone_uuid, export_settings)
-
-    bones_uuid = export_settings['vtree'].get_all_bones(armature_uuid)
-    joints = [export_settings['vtree'].nodes[b].node for b in bones_uuid]
-    return joints
-
-
-def __gather_name(blender_armature_object, export_settings):
-    return blender_armature_object.name
-
-
-def __gather_skeleton(blender_armature_object, export_settings):
-    # In the future support the result of https://github.com/KhronosGroup/glTF/pull/1195
-    return None