# SPDX-FileCopyrightText: 2013-2023 Blender Foundation
#
# SPDX-License-Identifier: GPL-2.0-or-later

# FBX 7.1.0 -> 7.4.0 loader for Blender

# Not totally pep8 compliant.
#   pep8 import_fbx.py --ignore=E501,E123,E702,E125

if "bpy" in locals():
    import importlib
    if "parse_fbx" in locals():
        importlib.reload(parse_fbx)
    if "fbx_utils" in locals():
        importlib.reload(fbx_utils)

import bpy
from bpy.app.translations import pgettext_rpt as rpt_
from mathutils import Matrix, Euler, Vector, Quaternion
from bpy_extras import anim_utils

# Also imported in .fbx_utils, so importing here is unlikely to further affect Blender startup time.
import numpy as np

# -----
# Utils
from . import parse_fbx, fbx_utils

from .parse_fbx import (
    data_types,
    FBXElem,
)
from .fbx_utils import (
    PerfMon,
    units_blender_to_fbx_factor,
    units_convertor_iter,
    array_to_matrix4,
    similar_values,
    similar_values_iter,
    FBXImportSettings,
    vcos_transformed,
    nors_transformed,
    parray_as_ndarray,
    astype_view_signedness,
    MESH_ATTRIBUTE_MATERIAL_INDEX,
    MESH_ATTRIBUTE_POSITION,
    MESH_ATTRIBUTE_EDGE_VERTS,
    MESH_ATTRIBUTE_CORNER_VERT,
    MESH_ATTRIBUTE_SHARP_FACE,
    MESH_ATTRIBUTE_SHARP_EDGE,
    expand_shape_key_range,
    FBX_KTIME_V7,
    FBX_KTIME_V8,
    FBX_TIMECODE_DEFINITION_TO_KTIME_PER_SECOND,
)

LINEAR_INTERPOLATION_VALUE = bpy.types.Keyframe.bl_rna.properties['interpolation'].enum_items['LINEAR'].value

# global singleton, assign on execution
fbx_elem_nil = None

# Units converters...
convert_deg_to_rad_iter = units_convertor_iter("degree", "radian")

MAT_CONVERT_BONE = fbx_utils.MAT_CONVERT_BONE.inverted()
MAT_CONVERT_LIGHT = fbx_utils.MAT_CONVERT_LIGHT.inverted()
MAT_CONVERT_CAMERA = fbx_utils.MAT_CONVERT_CAMERA.inverted()


def validate_blend_names(name):
    assert type(name) == bytes
    # Blender typically does not accept names over 63 bytes...
    if len(name) > 63:
        import hashlib
        h = hashlib.sha1(name).hexdigest()
        n = 55
        name_utf8 = name[:n].decode('utf-8', 'replace') + "_" + h[:7]
        while len(name_utf8.encode()) > 63:
            n -= 1
            name_utf8 = name[:n].decode('utf-8', 'replace') + "_" + h[:7]
        return name_utf8
    else:
        # We use 'replace' even though FBX 'specs' say it should always be utf8, see T53841.
        return name.decode('utf-8', 'replace')


def elem_find_first(elem, id_search, default=None):
    for fbx_item in elem.elems:
        if fbx_item.id == id_search:
            return fbx_item
    return default


def elem_find_iter(elem, id_search):
    for fbx_item in elem.elems:
        if fbx_item.id == id_search:
            yield fbx_item


def elem_find_first_string(elem, id_search):
    fbx_item = elem_find_first(elem, id_search)
    if fbx_item is not None and fbx_item.props:  # Do not error on complete empty properties (see T45291).
        assert len(fbx_item.props) == 1
        assert fbx_item.props_type[0] == data_types.STRING
        return fbx_item.props[0].decode('utf-8', 'replace')
    return None


def elem_find_first_string_as_bytes(elem, id_search):
    fbx_item = elem_find_first(elem, id_search)
    if fbx_item is not None and fbx_item.props:  # Do not error on complete empty properties (see T45291).
        assert len(fbx_item.props) == 1
        assert fbx_item.props_type[0] == data_types.STRING
        return fbx_item.props[0]  # Keep it as bytes as requested...
    return None


def elem_find_first_bytes(elem, id_search, decode=True):
    fbx_item = elem_find_first(elem, id_search)
    if fbx_item is not None and fbx_item.props:  # Do not error on complete empty properties (see T45291).
        assert len(fbx_item.props) == 1
        assert fbx_item.props_type[0] == data_types.BYTES
        return fbx_item.props[0]
    return None


def elem_repr(elem):
    return "%s: props[%d=%r], elems=(%r)" % (
        elem.id,
        len(elem.props),
        ", ".join([repr(p) for p in elem.props]),
        # elem.props_type,
        b", ".join([e.id for e in elem.elems]),
    )


def elem_split_name_class(elem):
    assert elem.props_type[-2] == data_types.STRING
    elem_name, elem_class = elem.props[-2].split(b'\x00\x01')
    return elem_name, elem_class


def elem_name_ensure_class(elem, clss=...):
    elem_name, elem_class = elem_split_name_class(elem)
    if clss is not ...:
        assert elem_class == clss
    return validate_blend_names(elem_name)


def elem_name_ensure_classes(elem, clss=...):
    elem_name, elem_class = elem_split_name_class(elem)
    if clss is not ...:
        assert elem_class in clss
    return validate_blend_names(elem_name)


def elem_split_name_class_nodeattr(elem):
    assert elem.props_type[-2] == data_types.STRING
    elem_name, elem_class = elem.props[-2].split(b'\x00\x01')
    assert elem_class == b'NodeAttribute'
    assert elem.props_type[-1] == data_types.STRING
    elem_class = elem.props[-1]
    return elem_name, elem_class


def elem_uuid(elem):
    assert elem.props_type[0] == data_types.INT64
    return elem.props[0]


def elem_prop_first(elem, default=None):
    return elem.props[0] if (elem is not None) and elem.props else default


# ----
# Support for
# Properties70: { ... P:
# Custom properties ("user properties" in FBX) are ignored here and get handled separately (see #104773).
def elem_props_find_first(elem, elem_prop_id):
    if elem is None:
        # When properties are not found... Should never happen, but happens - as usual.
        return None
    # support for templates (tuple of elems)
    if type(elem) is not FBXElem:
        assert type(elem) is tuple
        for e in elem:
            result = elem_props_find_first(e, elem_prop_id)
            if result is not None:
                return result
        assert len(elem) > 0
        return None

    for subelem in elem.elems:
        assert subelem.id == b'P'
        # 'U' flag indicates that the property has been defined by the user.
        if subelem.props[0] == elem_prop_id and b'U' not in subelem.props[3]:
            return subelem
    return None


def elem_props_get_color_rgb(elem, elem_prop_id, default=None):
    elem_prop = elem_props_find_first(elem, elem_prop_id)
    if elem_prop is not None:
        assert elem_prop.props[0] == elem_prop_id
        if elem_prop.props[1] == b'Color':
            # FBX version 7300
            assert elem_prop.props[1] == b'Color'
            assert elem_prop.props[2] == b''
        else:
            assert elem_prop.props[1] == b'ColorRGB'
            assert elem_prop.props[2] == b'Color'
        assert elem_prop.props_type[4:7] == bytes((data_types.FLOAT64,)) * 3
        return elem_prop.props[4:7]
    return default


def elem_props_get_vector_3d(elem, elem_prop_id, default=None):
    elem_prop = elem_props_find_first(elem, elem_prop_id)
    if elem_prop is not None:
        assert elem_prop.props_type[4:7] == bytes((data_types.FLOAT64,)) * 3
        return elem_prop.props[4:7]
    return default


def elem_props_get_number(elem, elem_prop_id, default=None):
    elem_prop = elem_props_find_first(elem, elem_prop_id)
    if elem_prop is not None:
        assert elem_prop.props[0] == elem_prop_id
        if elem_prop.props[1] == b'double':
            assert elem_prop.props[1] == b'double'
            assert elem_prop.props[2] == b'Number'
        else:
            assert elem_prop.props[1] == b'Number'
            assert elem_prop.props[2] == b''

        # we could allow other number types
        assert elem_prop.props_type[4] == data_types.FLOAT64

        return elem_prop.props[4]
    return default


def elem_props_get_integer(elem, elem_prop_id, default=None):
    elem_prop = elem_props_find_first(elem, elem_prop_id)
    if elem_prop is not None:
        assert elem_prop.props[0] == elem_prop_id
        if elem_prop.props[1] == b'int':
            assert elem_prop.props[1] == b'int'
            assert elem_prop.props[2] == b'Integer'
        elif elem_prop.props[1] == b'ULongLong':
            assert elem_prop.props[1] == b'ULongLong'
            assert elem_prop.props[2] == b''

        # we could allow other number types
        assert elem_prop.props_type[4] in {data_types.INT32, data_types.INT64}

        return elem_prop.props[4]
    return default


def elem_props_get_bool(elem, elem_prop_id, default=None):
    elem_prop = elem_props_find_first(elem, elem_prop_id)
    if elem_prop is not None:
        assert elem_prop.props[0] == elem_prop_id
        # b'Bool' with a capital seems to be used for animated property... go figure...
        assert elem_prop.props[1] in {b'bool', b'Bool'}
        assert elem_prop.props[2] == b''

        # we could allow other number types
        assert elem_prop.props_type[4] == data_types.INT32
        assert elem_prop.props[4] in {0, 1}

        return bool(elem_prop.props[4])
    return default


def elem_props_get_enum(elem, elem_prop_id, default=None):
    elem_prop = elem_props_find_first(elem, elem_prop_id)
    if elem_prop is not None:
        assert elem_prop.props[0] == elem_prop_id
        assert elem_prop.props[1] == b'enum'
        assert elem_prop.props[2] == b''
        assert elem_prop.props[3] == b''

        # we could allow other number types
        assert elem_prop.props_type[4] == data_types.INT32

        return elem_prop.props[4]
    return default


def elem_props_get_visibility(elem, elem_prop_id, default=None):
    elem_prop = elem_props_find_first(elem, elem_prop_id)
    if elem_prop is not None:
        assert elem_prop.props[0] == elem_prop_id
        assert elem_prop.props[1] == b'Visibility'
        assert elem_prop.props[2] == b''

        # we could allow other number types
        assert elem_prop.props_type[4] == data_types.FLOAT64

        return elem_prop.props[4]
    return default


# ----------------------------------------------------------------------------
# Blender

# ------
# Object
from collections import namedtuple


FBXTransformData = namedtuple("FBXTransformData", (
    "loc", "geom_loc",
    "rot", "rot_ofs", "rot_piv", "pre_rot", "pst_rot", "rot_ord", "rot_alt_mat", "geom_rot",
    "sca", "sca_ofs", "sca_piv", "geom_sca",
))


def blen_read_custom_properties(fbx_obj, blen_obj, settings):
    # There doesn't seem to be a way to put user properties into templates, so this only get the object properties:
    fbx_obj_props = elem_find_first(fbx_obj, b'Properties70')
    if fbx_obj_props:
        for fbx_prop in fbx_obj_props.elems:
            assert fbx_prop.id == b'P'

            if b'U' in fbx_prop.props[3]:
                if fbx_prop.props[0] == b'UDP3DSMAX':
                    # Special case for 3DS Max user properties:
                    try:
                        assert fbx_prop.props[1] == b'KString'
                    except AssertionError as exc:
                        print(exc)
                    assert fbx_prop.props_type[4] == data_types.STRING
                    items = fbx_prop.props[4].decode('utf-8', 'replace')
                    for item in items.split('\r\n'):
                        if item:
                            split_item = item.split('=', 1)
                            if len(split_item) != 2:
                                split_item = item.split(':', 1)
                            if len(split_item) != 2:
                                print("cannot parse UDP3DSMAX custom property '%s', ignoring..." % item)
                            else:
                                prop_name, prop_value = split_item
                                prop_name = validate_blend_names(prop_name.strip().encode('utf-8'))
                                blen_obj[prop_name] = prop_value.strip()
                else:
                    prop_name = validate_blend_names(fbx_prop.props[0])
                    prop_type = fbx_prop.props[1]
                    if prop_type in {b'Vector', b'Vector3D', b'Color', b'ColorRGB'}:
                        assert fbx_prop.props_type[4:7] == bytes((data_types.FLOAT64,)) * 3
                        blen_obj[prop_name] = fbx_prop.props[4:7]
                    elif prop_type in {b'Vector4', b'ColorRGBA'}:
                        assert fbx_prop.props_type[4:8] == bytes((data_types.FLOAT64,)) * 4
                        blen_obj[prop_name] = fbx_prop.props[4:8]
                    elif prop_type == b'Vector2D':
                        assert fbx_prop.props_type[4:6] == bytes((data_types.FLOAT64,)) * 2
                        blen_obj[prop_name] = fbx_prop.props[4:6]
                    elif prop_type in {b'Integer', b'int'}:
                        assert fbx_prop.props_type[4] == data_types.INT32
                        blen_obj[prop_name] = fbx_prop.props[4]
                    elif prop_type == b'KString':
                        assert fbx_prop.props_type[4] == data_types.STRING
                        blen_obj[prop_name] = fbx_prop.props[4].decode('utf-8', 'replace')
                    elif prop_type in {b'Number', b'double', b'Double'}:
                        assert fbx_prop.props_type[4] == data_types.FLOAT64
                        blen_obj[prop_name] = fbx_prop.props[4]
                    elif prop_type in {b'Float', b'float'}:
                        assert fbx_prop.props_type[4] == data_types.FLOAT32
                        blen_obj[prop_name] = fbx_prop.props[4]
                    elif prop_type in {b'Bool', b'bool'}:
                        assert fbx_prop.props_type[4] == data_types.INT32
                        blen_obj[prop_name] = fbx_prop.props[4] != 0
                    elif prop_type in {b'Enum', b'enum'}:
                        assert fbx_prop.props_type[4:6] == bytes((data_types.INT32, data_types.STRING))
                        val = fbx_prop.props[4]
                        if settings.use_custom_props_enum_as_string and fbx_prop.props[5]:
                            enum_items = fbx_prop.props[5].decode('utf-8', 'replace').split('~')
                            if val >= 0 and val < len(enum_items):
                                blen_obj[prop_name] = enum_items[val]
                            else:
                                print("WARNING: User property '%s' has wrong enum value, skipped" % prop_name)
                        else:
                            blen_obj[prop_name] = val
                    else:
                        print(
                            "WARNING: User property type '%s' is not supported" %
                            prop_type.decode(
                                'utf-8', 'replace'))


def blen_read_object_transform_do(transform_data):
    # This is a nightmare. FBX SDK uses Maya way to compute the transformation matrix of a node - utterly simple:
    #
    #     WorldTransform = ParentWorldTransform @ T @ Roff @ Rp @ Rpre @ R @ Rpost-1 @ Rp-1 @ Soff @ Sp @ S @ Sp-1
    #
    # Where all those terms are 4 x 4 matrices that contain:
    #     WorldTransform: Transformation matrix of the node in global space.
    #     ParentWorldTransform: Transformation matrix of the parent node in global space.
    #     T: Translation
    #     Roff: Rotation offset
    #     Rp: Rotation pivot
    #     Rpre: Pre-rotation
    #     R: Rotation
    #     Rpost-1: Inverse of the post-rotation (FBX 2011 documentation incorrectly specifies this without inversion)
    #     Rp-1: Inverse of the rotation pivot
    #     Soff: Scaling offset
    #     Sp: Scaling pivot
    #     S: Scaling
    #     Sp-1: Inverse of the scaling pivot
    #
    # But it was still too simple, and FBX notion of compatibility is... quite specific. So we also have to
    # support 3DSMax way:
    #
    #     WorldTransform = ParentWorldTransform @ T @ R @ S @ OT @ OR @ OS
    #
    # Where all those terms are 4 x 4 matrices that contain:
    #     WorldTransform: Transformation matrix of the node in global space
    #     ParentWorldTransform: Transformation matrix of the parent node in global space
    #     T: Translation
    #     R: Rotation
    #     S: Scaling
    #     OT: Geometric transform translation
    #     OR: Geometric transform rotation
    #     OS: Geometric transform scale
    #
    # Notes:
    #     Geometric transformations ***are not inherited***: ParentWorldTransform does not contain the OT, OR, OS
    #     of WorldTransform's parent node.
    #     The R matrix takes into account the rotation order. Other rotation matrices are always 'XYZ' order.
    #
    # Taken from https://help.autodesk.com/view/FBX/2020/ENU/
    #            ?guid=FBX_Developer_Help_nodes_and_scene_graph_fbx_nodes_computing_transformation_matrix_html

    # translation
    lcl_translation = Matrix.Translation(transform_data.loc)
    geom_loc = Matrix.Translation(transform_data.geom_loc)

    # rotation
    def to_rot(rot, rot_ord): return Euler(convert_deg_to_rad_iter(rot), rot_ord).to_matrix().to_4x4()
    lcl_rot = to_rot(transform_data.rot, transform_data.rot_ord) @ transform_data.rot_alt_mat
    pre_rot = to_rot(transform_data.pre_rot, 'XYZ')
    pst_rot = to_rot(transform_data.pst_rot, 'XYZ')
    geom_rot = to_rot(transform_data.geom_rot, 'XYZ')

    rot_ofs = Matrix.Translation(transform_data.rot_ofs)
    rot_piv = Matrix.Translation(transform_data.rot_piv)
    sca_ofs = Matrix.Translation(transform_data.sca_ofs)
    sca_piv = Matrix.Translation(transform_data.sca_piv)

    # scale
    lcl_scale = Matrix()
    lcl_scale[0][0], lcl_scale[1][1], lcl_scale[2][2] = transform_data.sca
    geom_scale = Matrix()
    geom_scale[0][0], geom_scale[1][1], geom_scale[2][2] = transform_data.geom_sca

    base_mat = (
        lcl_translation @
        rot_ofs @
        rot_piv @
        pre_rot @
        lcl_rot @
        pst_rot.inverted_safe() @
        rot_piv.inverted_safe() @
        sca_ofs @
        sca_piv @
        lcl_scale @
        sca_piv.inverted_safe()
    )
    geom_mat = geom_loc @ geom_rot @ geom_scale
    # We return mat without 'geometric transforms' too, because it is to be used for children, sigh...
    return (base_mat @ geom_mat, base_mat, geom_mat)


# XXX This might be weak, now that we can add vertex-groups from both bones and shapes,
#     name collisions become more likely, will have to make this more robust!!!
def add_vgroup_to_objects(vg_indices, vg_weights, vg_name, objects):
    assert len(vg_indices) == len(vg_weights)
    if vg_indices:
        for obj in objects:
            # We replace/override here...
            vg = obj.vertex_groups.get(vg_name)
            if vg is None:
                vg = obj.vertex_groups.new(name=vg_name)
            vg_add = vg.add
            for i, w in zip(vg_indices, vg_weights):
                vg_add((i,), w, 'REPLACE')


def blen_read_object_transform_preprocess(fbx_props, fbx_obj, rot_alt_mat, use_prepost_rot):
    # This is quite involved, 'fbxRNode.cpp' from openscenegraph used as a reference
    const_vector_zero_3d = 0.0, 0.0, 0.0
    const_vector_one_3d = 1.0, 1.0, 1.0

    loc = list(elem_props_get_vector_3d(fbx_props, b'Lcl Translation', const_vector_zero_3d))
    rot = list(elem_props_get_vector_3d(fbx_props, b'Lcl Rotation', const_vector_zero_3d))
    sca = list(elem_props_get_vector_3d(fbx_props, b'Lcl Scaling', const_vector_one_3d))

    geom_loc = list(elem_props_get_vector_3d(fbx_props, b'GeometricTranslation', const_vector_zero_3d))
    geom_rot = list(elem_props_get_vector_3d(fbx_props, b'GeometricRotation', const_vector_zero_3d))
    geom_sca = list(elem_props_get_vector_3d(fbx_props, b'GeometricScaling', const_vector_one_3d))

    rot_ofs = elem_props_get_vector_3d(fbx_props, b'RotationOffset', const_vector_zero_3d)
    rot_piv = elem_props_get_vector_3d(fbx_props, b'RotationPivot', const_vector_zero_3d)
    sca_ofs = elem_props_get_vector_3d(fbx_props, b'ScalingOffset', const_vector_zero_3d)
    sca_piv = elem_props_get_vector_3d(fbx_props, b'ScalingPivot', const_vector_zero_3d)

    is_rot_act = elem_props_get_bool(fbx_props, b'RotationActive', False)

    if is_rot_act:
        if use_prepost_rot:
            pre_rot = elem_props_get_vector_3d(fbx_props, b'PreRotation', const_vector_zero_3d)
            pst_rot = elem_props_get_vector_3d(fbx_props, b'PostRotation', const_vector_zero_3d)
        else:
            pre_rot = const_vector_zero_3d
            pst_rot = const_vector_zero_3d
        rot_ord = {
            0: 'XYZ',
            1: 'XZY',
            2: 'YZX',
            3: 'YXZ',
            4: 'ZXY',
            5: 'ZYX',
            6: 'XYZ',  # XXX eSphericXYZ, not really supported...
        }.get(elem_props_get_enum(fbx_props, b'RotationOrder', 0))
    else:
        pre_rot = const_vector_zero_3d
        pst_rot = const_vector_zero_3d
        rot_ord = 'XYZ'

    return FBXTransformData(loc, geom_loc,
                            rot, rot_ofs, rot_piv, pre_rot, pst_rot, rot_ord, rot_alt_mat, geom_rot,
                            sca, sca_ofs, sca_piv, geom_sca)


# ---------
# Animation
def _blen_read_object_transform_do_anim(transform_data, lcl_translation_mat, lcl_rot_euler, lcl_scale_mat,
                                        extra_pre_matrix, extra_post_matrix):
    """Specialized version of blen_read_object_transform_do for animation that pre-calculates the non-animated matrices
    and returns a function that calculates (base_mat @ geom_mat). See the comments in blen_read_object_transform_do for
    a full description of what this function is doing.

    The lcl_translation_mat, lcl_rot_euler and lcl_scale_mat arguments should have their values updated each frame and
    then calling the returned function will calculate the matrix for the current frame.

    extra_pre_matrix and extra_post_matrix are any extra matrices to multiply first/last."""
    # Translation
    geom_loc = Matrix.Translation(transform_data.geom_loc)

    # Rotation
    def to_rot_xyz(rot):
        # All the rotations that can be pre-calculated have a fixed XYZ order.
        return Euler(convert_deg_to_rad_iter(rot), 'XYZ').to_matrix().to_4x4()
    pre_rot = to_rot_xyz(transform_data.pre_rot)
    pst_rot_inv = to_rot_xyz(transform_data.pst_rot).inverted_safe()
    geom_rot = to_rot_xyz(transform_data.geom_rot)

    # Offsets and pivots
    rot_ofs = Matrix.Translation(transform_data.rot_ofs)
    rot_piv = Matrix.Translation(transform_data.rot_piv)
    rot_piv_inv = rot_piv.inverted_safe()
    sca_ofs = Matrix.Translation(transform_data.sca_ofs)
    sca_piv = Matrix.Translation(transform_data.sca_piv)
    sca_piv_inv = sca_piv.inverted_safe()

    # Scale
    geom_scale = Matrix()
    geom_scale[0][0], geom_scale[1][1], geom_scale[2][2] = transform_data.geom_sca

    # Some matrices can be combined in advance, using the associative property of matrix multiplication, so that less
    # matrix multiplication is required each frame.
    geom_mat = geom_loc @ geom_rot @ geom_scale
    post_lcl_translation = rot_ofs @ rot_piv @ pre_rot
    post_lcl_rotation = transform_data.rot_alt_mat @ pst_rot_inv @ rot_piv_inv @ sca_ofs @ sca_piv
    post_lcl_scaling = sca_piv_inv @ geom_mat @ extra_post_matrix

    # Get the bound to_matrix method to avoid re-binding it on each call.
    lcl_rot_euler_to_matrix_3x3 = lcl_rot_euler.to_matrix
    # Get the unbound Matrix.to_4x4 method to avoid having to look it up again on each call.
    matrix_to_4x4 = Matrix.to_4x4

    if extra_pre_matrix == Matrix():
        # There aren't any other matrices that must be multiplied before lcl_translation_mat that extra_pre_matrix can
        # be combined with, so skip extra_pre_matrix when it's the identity matrix.
        return lambda: (lcl_translation_mat @
                        post_lcl_translation @
                        matrix_to_4x4(lcl_rot_euler_to_matrix_3x3()) @
                        post_lcl_rotation @
                        lcl_scale_mat @
                        post_lcl_scaling)
    else:
        return lambda: (extra_pre_matrix @
                        lcl_translation_mat @
                        post_lcl_translation @
                        matrix_to_4x4(lcl_rot_euler_to_matrix_3x3()) @
                        post_lcl_rotation @
                        lcl_scale_mat @
                        post_lcl_scaling)


def _transformation_curves_gen(item, values_arrays, channel_keys):
    """Yields flattened location/rotation/scaling values for imported PoseBone/Object Lcl Translation/Rotation/Scaling
    animation curve values.

    The value arrays must have the same lengths, where each index of each array corresponds to a single keyframe.

    Each value array must have a corresponding channel key tuple that identifies the fbx property
    (b'Lcl Translation'/b'Lcl Rotation'/b'Lcl Scaling') and the channel (x/y/z as 0/1/2) of that property."""
    from operator import setitem
    from functools import partial

    if item.is_bone:
        bl_obj = item.bl_obj.pose.bones[item.bl_bone]
    else:
        bl_obj = item.bl_obj

    rot_mode = bl_obj.rotation_mode
    transform_data = item.fbx_transform_data
    rot_eul_prev = bl_obj.rotation_euler.copy()
    rot_quat_prev = bl_obj.rotation_quaternion.copy()

    # Pre-compute combined pre-matrix
    # Remove that rest pose matrix from current matrix (also in parent space) by computing the inverted local rest
    # matrix of the bone, if relevant.
    combined_pre_matrix = item.get_bind_matrix().inverted_safe() if item.is_bone else Matrix()
    # item.pre_matrix will contain any correction for a parent's correction matrix or the global matrix
    if item.pre_matrix:
        combined_pre_matrix @= item.pre_matrix

    # Pre-compute combined post-matrix
    # Compensate for changes in the local matrix during processing
    combined_post_matrix = item.anim_compensation_matrix.copy() if item.anim_compensation_matrix else Matrix()
    # item.post_matrix will contain any correction for lights, camera and bone orientation
    if item.post_matrix:
        combined_post_matrix @= item.post_matrix

    # Create matrices/euler from the initial transformation values of this item.
    # These variables will be updated in-place as we iterate through each frame.
    lcl_translation_mat = Matrix.Translation(transform_data.loc)
    lcl_rotation_eul = Euler(convert_deg_to_rad_iter(transform_data.rot), transform_data.rot_ord)
    lcl_scaling_mat = Matrix()
    lcl_scaling_mat[0][0], lcl_scaling_mat[1][1], lcl_scaling_mat[2][2] = transform_data.sca

    # Create setters into lcl_translation_mat, lcl_rotation_eul and lcl_scaling_mat for each values_array and convert
    # any rotation values into radians.
    lcl_setters = []
    values_arrays_converted = []
    for values_array, (fbx_prop, channel) in zip(values_arrays, channel_keys):
        if fbx_prop == b'Lcl Translation':
            # lcl_translation_mat.translation[channel] = value
            setter = partial(setitem, lcl_translation_mat.translation, channel)
        elif fbx_prop == b'Lcl Rotation':
            # FBX rotations are in degrees, but Blender uses radians, so convert all rotation values in advance.
            values_array = np.deg2rad(values_array)
            # lcl_rotation_eul[channel] = value
            setter = partial(setitem, lcl_rotation_eul, channel)
        else:
            assert fbx_prop == b'Lcl Scaling'
            # lcl_scaling_mat[channel][channel] = value
            setter = partial(setitem, lcl_scaling_mat[channel], channel)
        lcl_setters.append(setter)
        values_arrays_converted.append(values_array)

    # Create an iterator that gets one value from each array. Each iterated tuple will be all the imported
    # Lcl Translation/Lcl Rotation/Lcl Scaling values for a single frame, in that order.
    # Note that an FBX animation does not have to animate all the channels, so only the animated channels of each
    # property will be present.
    # .data, the memoryview of an np.ndarray, is faster to iterate than the ndarray itself.
    frame_values_it = zip(*(arr.data for arr in values_arrays_converted))

    # Getting the unbound methods in advance avoids having to look them up again on each call within the loop.
    mat_decompose = Matrix.decompose
    quat_to_axis_angle = Quaternion.to_axis_angle
    quat_to_euler = Quaternion.to_euler
    quat_dot = Quaternion.dot

    calc_mat = _blen_read_object_transform_do_anim(transform_data,
                                                   lcl_translation_mat, lcl_rotation_eul, lcl_scaling_mat,
                                                   combined_pre_matrix, combined_post_matrix)

    # Iterate through the values for each frame.
    for frame_values in frame_values_it:
        # Set each value into its corresponding lcl matrix/euler.
        for lcl_setter, value in zip(lcl_setters, frame_values):
            lcl_setter(value)

        # Calculate the updated matrix for this frame.
        mat = calc_mat()

        # Now we have a virtual matrix of transform from AnimCurves, we can yield keyframe values!
        loc, rot, sca = mat_decompose(mat)
        if rot_mode == 'QUATERNION':
            if quat_dot(rot_quat_prev, rot) < 0.0:
                rot = -rot
            rot_quat_prev = rot
        elif rot_mode == 'AXIS_ANGLE':
            vec, ang = quat_to_axis_angle(rot)
            rot = ang, vec.x, vec.y, vec.z
        else:  # Euler
            rot = quat_to_euler(rot, rot_mode, rot_eul_prev)
            rot_eul_prev = rot

        # Yield order matches the order that the location/rotation/scale FCurves are created in.
        yield from loc
        yield from rot
        yield from sca


def _combine_curve_keyframe_times(times_and_values_tuples, initial_values):
    """Combine multiple parsed animation curves, that affect different channels, such that every animation curve
    contains the keyframes from every other curve, interpolating the values for the newly inserted keyframes in each
    curve.

    Currently, linear interpolation is assumed, but FBX does store how keyframes should be interpolated, so correctly
    interpolating the keyframe values is a TODO."""
    if len(times_and_values_tuples) == 1:
        # Nothing to do when there is only a single curve.
        times, values = times_and_values_tuples[0]
        return times, [values]

    all_times = [t[0] for t in times_and_values_tuples]

    # Get the combined sorted unique times of all the curves.
    sorted_all_times = np.unique(np.concatenate(all_times))

    values_arrays = []
    for (times, values), initial_value in zip(times_and_values_tuples, initial_values):
        if sorted_all_times.size == times.size:
            # `sorted_all_times` will always contain all values in `times` and both `times` and `sorted_all_times` must
            # be strictly increasing, so if both arrays have the same size, they must be identical.
            extended_values = values
        else:
            # For now, linear interpolation is assumed. NumPy conveniently has a fast C-compiled function for this.
            # Efficiently implementing other FBX supported interpolation will most likely be much more complicated.
            extended_values = np.interp(sorted_all_times, times, values, left=initial_value)
        values_arrays.append(extended_values)
    return sorted_all_times, values_arrays


def blen_read_invalid_animation_curve(key_times, key_values):
    """FBX will parse animation curves even when their keyframe times are invalid (not strictly increasing). It's
    unclear exactly how FBX handles invalid curves, but this matches in some cases and is how the FBX IO addon has been
    handling invalid keyframe times for a long time.

    Notably, this function will also correctly parse valid animation curves, though is much slower than the trivial,
    regular way.

    The returned keyframe times are guaranteed to be strictly increasing."""
    sorted_unique_times = np.unique(key_times)

    # Unsure if this can be vectorized with numpy, so using iteration for now.
    def index_gen():
        idx = 0
        key_times_data = key_times.data
        key_times_len = len(key_times)
        # Iterating .data, the memoryview of the array, is faster than iterating the array directly.
        for curr_fbxktime in sorted_unique_times.data:
            if key_times_data[idx] < curr_fbxktime:
                if idx >= 0:
                    idx += 1
                    if idx >= key_times_len:
                        # We have reached our last element for this curve, stay on it from now on...
                        idx = -1
            yield idx

    indices = np.fromiter(index_gen(), dtype=np.int64, count=len(sorted_unique_times))
    indexed_times = key_times[indices]
    indexed_values = key_values[indices]

    # Linear interpolate the value for each time in sorted_unique_times according to the times and values at each index
    # and the previous index.
    interpolated_values = np.empty_like(indexed_values)

    # Where the index is 0, there's no previous value to interpolate from, so we set the value without interpolating.
    # Because the indices are in increasing order, all zeroes must be at the start, so we can find the index of the last
    # zero and use that to index with a slice instead of a boolean array for performance.
    # Equivalent to, but as a slice:
    # idx_zero_mask = indices == 0
    # idx_nonzero_mask = ~idx_zero_mask
    first_nonzero_idx = np.searchsorted(indices, 0, side='right')
    idx_zero_slice = slice(0, first_nonzero_idx)  # [:first_nonzero_idx]
    idx_nonzero_slice = slice(first_nonzero_idx, None)  # [first_nonzero_idx:]

    interpolated_values[idx_zero_slice] = indexed_values[idx_zero_slice]

    indexed_times_nonzero_idx = indexed_times[idx_nonzero_slice]
    indexed_values_nonzero_idx = indexed_values[idx_nonzero_slice]
    indices_nonzero = indices[idx_nonzero_slice]

    prev_indices_nonzero = indices_nonzero - 1
    prev_indexed_times_nonzero_idx = key_times[prev_indices_nonzero]
    prev_indexed_values_nonzero_idx = key_values[prev_indices_nonzero]

    ifac_a = sorted_unique_times[idx_nonzero_slice] - prev_indexed_times_nonzero_idx
    ifac_b = indexed_times_nonzero_idx - prev_indexed_times_nonzero_idx
    # If key_times contains two (or more) duplicate times in a row, then values in `ifac_b` can be zero which would
    # result in division by zero.
    # Use the `np.errstate` context manager to suppress printing the RuntimeWarning to the system console.
    with np.errstate(divide='ignore'):
        ifac = ifac_a / ifac_b
    interpolated_values[idx_nonzero_slice] = ((indexed_values_nonzero_idx - prev_indexed_values_nonzero_idx) * ifac
                                              + prev_indexed_values_nonzero_idx)

    # If the time to interpolate at is larger than the time in indexed_times, then the value has been extrapolated.
    # Extrapolated values are excluded.
    valid_mask = indexed_times >= sorted_unique_times

    key_times = sorted_unique_times[valid_mask]
    key_values = interpolated_values[valid_mask]

    return key_times, key_values


def _convert_fbx_time_to_blender_time(key_times, blen_start_offset, fbx_start_offset, fps, fbx_ktime):
    timefac = fps / fbx_ktime

    # Convert from FBX timing to Blender timing.
    # Cannot subtract in-place because key_times could be read directly from FBX and could be used by multiple Actions.
    key_times = key_times - fbx_start_offset
    # FBX times are integers and timefac is a Python float, so the new array will be a np.float64 array.
    key_times = key_times * timefac

    key_times += blen_start_offset

    return key_times


def blen_read_animation_curve(fbx_curve):
    """Read an animation curve from FBX data.

    The parsed keyframe times are guaranteed to be strictly increasing."""
    key_times = parray_as_ndarray(elem_prop_first(elem_find_first(fbx_curve, b'KeyTime')))
    key_values = parray_as_ndarray(elem_prop_first(elem_find_first(fbx_curve, b'KeyValueFloat')))

    assert len(key_values) == len(key_times)

    # The FBX SDK specifies that only one key per time is allowed and that the keys are sorted in time order.
    # https://help.autodesk.com/view/FBX/2020/ENU/?guid=FBX_Developer_Help_cpp_ref_class_fbx_anim_curve_html
    all_times_strictly_increasing = (key_times[1:] > key_times[:-1]).all()

    if all_times_strictly_increasing:
        return key_times, key_values
    else:
        # FBX will still read animation curves even if they are invalid.
        return blen_read_invalid_animation_curve(key_times, key_values)


def blen_store_keyframes(fbx_key_times, blen_fcurve, key_values, blen_start_offset, fps, fbx_ktime, fbx_start_offset=0):
    """Set all keyframe times and values for a newly created FCurve.
    Linear interpolation is currently assumed.

    This is a convenience function for calling blen_store_keyframes_multi with only a single fcurve and values array."""
    blen_store_keyframes_multi(fbx_key_times, [(blen_fcurve, key_values)], blen_start_offset, fps, fbx_ktime,
                               fbx_start_offset)


def blen_store_keyframes_multi(fbx_key_times, fcurve_and_key_values_pairs, blen_start_offset, fps, fbx_ktime,
                               fbx_start_offset=0):
    """Set all keyframe times and values for multiple pairs of newly created FCurves and keyframe values arrays, where
    each pair has the same keyframe times.
    Linear interpolation is currently assumed."""
    bl_key_times = _convert_fbx_time_to_blender_time(fbx_key_times, blen_start_offset, fbx_start_offset, fps, fbx_ktime)
    num_keys = len(bl_key_times)

    # Compatible with C float type
    bl_keyframe_dtype = np.single
    # Compatible with C char type
    bl_enum_dtype = np.ubyte

    # The keyframe_points 'co' are accessed as flattened pairs of (time, value).
    # The key times are the same for each (blen_fcurve, key_values) pair, so only the values need to be updated for each
    # array of values.
    keyframe_points_co = np.empty(len(bl_key_times) * 2, dtype=bl_keyframe_dtype)
    # Even indices are times.
    keyframe_points_co[0::2] = bl_key_times

    interpolation_array = np.full(num_keys, LINEAR_INTERPOLATION_VALUE, dtype=bl_enum_dtype)

    for blen_fcurve, key_values in fcurve_and_key_values_pairs:
        # The fcurve must be newly created and thus have no keyframe_points.
        assert len(blen_fcurve.keyframe_points) == 0

        # Odd indices are values.
        keyframe_points_co[1::2] = key_values

        # Add the keyframe points to the FCurve and then set the 'co' and 'interpolation' of each point.
        blen_fcurve.keyframe_points.add(num_keys)
        blen_fcurve.keyframe_points.foreach_set('co', keyframe_points_co)
        blen_fcurve.keyframe_points.foreach_set('interpolation', interpolation_array)

        # Since we inserted our keyframes in 'ultra-fast' mode, we have to update the fcurves now.
        blen_fcurve.update()


def blen_read_animations_action_item(channelbag, item, cnodes, fps, anim_offset, global_scale, shape_key_deforms,
                                     fbx_ktime):
    """
    'Bake' loc/rot/scale into the channelbag,
    taking any pre_ and post_ matrix into account to transform from fbx into blender space.
    """
    from bpy.types import ShapeKey, Material, Camera

    fbx_curves: dict[bytes, dict[int, FBXElem]] = {}
    for curves, fbxprop in cnodes.values():
        channels_dict = fbx_curves.setdefault(fbxprop, {})
        for (fbx_acdata, _blen_data), channel in curves.values():
            if channel in channels_dict:
                # Ignore extra curves when one has already been found for this channel because FBX's default animation
                # system implementation only uses the first curve assigned to a channel.
                # Additional curves per channel are allowed by the FBX specification, but the handling of these curves
                # is considered the responsibility of the application that created them. Note that each curve node is
                # expected to have a unique set of channels, so these additional curves with the same channel would have
                # to belong to separate curve nodes. See the FBX SDK documentation for FbxAnimCurveNode.
                continue
            channels_dict[channel] = fbx_acdata

    # Leave if no curves are attached (if a blender curve is attached to scale but without keys it defaults to 0).
    if len(fbx_curves) == 0:
        return

    if isinstance(item, Material):
        grpname = item.name
        props = [("diffuse_color", 3, grpname or "Diffuse Color")]
    elif isinstance(item, ShapeKey):
        props = [(item.path_from_id("value"), 1, "Key")]
    elif isinstance(item, Camera):
        props = [(item.path_from_id("lens"), 1, "Camera"), (item.dof.path_from_id("focus_distance"), 1, "Camera")]
    else:  # Object or PoseBone:
        if item.is_bone:
            bl_obj = item.bl_obj.pose.bones[item.bl_bone]
        else:
            bl_obj = item.bl_obj

        # We want to create actions for objects, but for bones we 'reuse' armatures' actions!
        grpname = bl_obj.name

        # Since we might get other channels animated in the end, due to all FBX transform magic,
        # we need to add curves for whole loc/rot/scale in any case.
        props = [(bl_obj.path_from_id("location"), 3, grpname or "Location"),
                 None,
                 (bl_obj.path_from_id("scale"), 3, grpname or "Scale")]
        rot_mode = bl_obj.rotation_mode
        if rot_mode == 'QUATERNION':
            props[1] = (bl_obj.path_from_id("rotation_quaternion"), 4, grpname or "Quaternion Rotation")
        elif rot_mode == 'AXIS_ANGLE':
            props[1] = (bl_obj.path_from_id("rotation_axis_angle"), 4, grpname or "Axis Angle Rotation")
        else:  # Euler
            props[1] = (bl_obj.path_from_id("rotation_euler"), 3, grpname or "Euler Rotation")

    blen_curves = [channelbag.fcurves.new(prop, index=channel, group_name=grpname)
                   for prop, nbr_channels, grpname in props for channel in range(nbr_channels)]

    if isinstance(item, Material):
        for fbxprop, channel_to_curve in fbx_curves.items():
            assert fbxprop == b'DiffuseColor'
            for channel, curve in channel_to_curve.items():
                assert channel in {0, 1, 2}
                blen_curve = blen_curves[channel]
                fbx_key_times, values = blen_read_animation_curve(curve)
                blen_store_keyframes(fbx_key_times, blen_curve, values, anim_offset, fps, fbx_ktime)

    elif isinstance(item, ShapeKey):
        for fbxprop, channel_to_curve in fbx_curves.items():
            assert fbxprop == b'DeformPercent'
            for channel, curve in channel_to_curve.items():
                assert channel == 0
                blen_curve = blen_curves[channel]

                fbx_key_times, values = blen_read_animation_curve(curve)
                # A fully activated shape key in FBX DeformPercent is 100.0 whereas it is 1.0 in Blender.
                values = values / 100.0
                blen_store_keyframes(fbx_key_times, blen_curve, values, anim_offset, fps, fbx_ktime)

                # Store the minimum and maximum shape key values, so that the shape key's slider range can be expanded
                # if necessary after reading all animations.
                if values.size:
                    deform_values = shape_key_deforms.setdefault(item, [])
                    deform_values.append(values.min())
                    deform_values.append(values.max())

    elif isinstance(item, Camera):
        for fbxprop, channel_to_curve in fbx_curves.items():
            is_focus_distance = fbxprop == b'FocusDistance'
            assert fbxprop == b'FocalLength' or is_focus_distance
            for channel, curve in channel_to_curve.items():
                assert channel == 0
                # The indices are determined by the creation of the `props` list above.
                blen_curve = blen_curves[1 if is_focus_distance else 0]

                fbx_key_times, values = blen_read_animation_curve(curve)
                if is_focus_distance:
                    # Remap the imported values from FBX to Blender.
                    values = values / 1000.0
                    values *= global_scale
                blen_store_keyframes(fbx_key_times, blen_curve, values, anim_offset, fps, fbx_ktime)

    else:  # Object or PoseBone:
        transform_data = item.fbx_transform_data

        # Each transformation curve needs to have keyframes at the times of every other transformation curve
        # (interpolating missing values), so that we can construct a matrix at every keyframe.
        transform_prop_to_attr = {
            b'Lcl Translation': transform_data.loc,
            b'Lcl Rotation': transform_data.rot,
            b'Lcl Scaling': transform_data.sca,
        }

        times_and_values_tuples = []
        initial_values = []
        channel_keys = []
        for fbxprop, channel_to_curve in fbx_curves.items():
            if fbxprop not in transform_prop_to_attr:
                # Currently, we only care about transformation curves.
                continue
            for channel, curve in channel_to_curve.items():
                assert channel in {0, 1, 2}
                fbx_key_times, values = blen_read_animation_curve(curve)

                channel_keys.append((fbxprop, channel))

                initial_values.append(transform_prop_to_attr[fbxprop][channel])

                times_and_values_tuples.append((fbx_key_times, values))
        if not times_and_values_tuples:
            # If `times_and_values_tuples` is empty, all the imported animation curves are for properties other than
            # transformation (e.g. animated custom properties), so there is nothing to do until support for those other
            # properties is added.
            return

        # Combine the keyframe times of all the transformation curves so that each curve has a value at every time.
        combined_fbx_times, values_arrays = _combine_curve_keyframe_times(times_and_values_tuples, initial_values)

        # Convert from FBX Lcl Translation/Lcl Rotation/Lcl Scaling to the Blender location/rotation/scaling properties
        # of this Object/PoseBone.
        # The number of fcurves for the Blender properties varies depending on the rotation mode.
        num_loc_channels = 3
        num_rot_channels = 4 if rot_mode in {'QUATERNION', 'AXIS_ANGLE'} else 3  # Variations of EULER are all 3
        num_sca_channels = 3
        num_channels = num_loc_channels + num_rot_channels + num_sca_channels
        num_frames = len(combined_fbx_times)
        full_length = num_channels * num_frames

        # Do the conversion.
        flattened_channel_values_gen = _transformation_curves_gen(item, values_arrays, channel_keys)
        flattened_channel_values = np.fromiter(flattened_channel_values_gen, dtype=np.single, count=full_length)

        # Reshape to one row per frame and then view the transpose so that each row corresponds to a single channel.
        # e.g.
        # loc_channels = channel_values[:num_loc_channels]
        # rot_channels = channel_values[num_loc_channels:num_loc_channels + num_rot_channels]
        # sca_channels = channel_values[num_loc_channels + num_rot_channels:]
        channel_values = flattened_channel_values.reshape(num_frames, num_channels).T

        # Each channel has the same keyframe times, so the combined times can be passed once along with all the curves
        # and values arrays.
        blen_store_keyframes_multi(combined_fbx_times, zip(blen_curves, channel_values), anim_offset, fps, fbx_ktime)


def blen_read_animations(fbx_tmpl_astack, fbx_tmpl_alayer, stacks, scene, anim_offset, global_scale, fbx_ktime):
    """
    Recreate an action per stack/layer/object combinations.
    Only the first found action is linked to objects, more complex setups are not handled,
    it's up to user to reproduce them!
    """
    from bpy.types import ShapeKey, Material, Camera

    shape_key_values = {}
    actions = {}
    for as_uuid, ((fbx_asdata, _blen_data), alayers) in stacks.items():
        stack_name = elem_name_ensure_class(fbx_asdata, b'AnimStack')
        for al_uuid, ((fbx_aldata, _blen_data), items) in alayers.items():
            layer_name = elem_name_ensure_class(fbx_aldata, b'AnimLayer')
            for item, cnodes in items.items():
                if isinstance(item, Material):
                    id_data = item
                elif isinstance(item, ShapeKey):
                    id_data = item.id_data
                elif isinstance(item, Camera):
                    id_data = item
                else:
                    id_data = item.bl_obj
                    # XXX Ignore rigged mesh animations - those are a nightmare to handle, see note about it in
                    #     FbxImportHelperNode class definition.
                    if id_data and id_data.type == 'MESH' and id_data.parent and id_data.parent.type == 'ARMATURE':
                        continue
                if id_data is None:
                    continue

                # Create new action if needed (should always be needed, except for key-blocks from shape-keys cases).
                key = (as_uuid, al_uuid, id_data)
                action = actions.get(key)
                if action is None:
                    if stack_name == layer_name:
                        action_name = "|".join((id_data.name, stack_name))
                    else:
                        action_name = "|".join((id_data.name, stack_name, layer_name))
                    actions[key] = action = bpy.data.actions.new(action_name)
                    action.use_fake_user = True

                    # Always use the same name for the slot. It should be simple
                    # to switch between imported Actions while keeping Slot
                    # auto-assignment, which means that all Actions should use
                    # the same slot name. As long as there's no separate
                    # indicator for the "intended object name" for this FBX
                    # animation, this is the best Blender can do. Maybe the
                    # 'stack name' would be a better choice?
                    action.slots.new(id_data.id_type, "Slot")

                # If none yet assigned, assign this action to id_data.
                if not id_data.animation_data:
                    id_data.animation_data_create()
                if not id_data.animation_data.action:
                    id_data.animation_data.action = action
                    id_data.animation_data.action_slot = action.slots[0]

                # And actually populate the action!
                channelbag = anim_utils.action_ensure_channelbag_for_slot(action, action.slots[0])
                blen_read_animations_action_item(channelbag, item, cnodes, scene.render.fps, anim_offset, global_scale,
                                                 shape_key_values, fbx_ktime)

    # If the minimum/maximum animated value is outside the slider range of the shape key, attempt to expand the slider
    # range until the animated range fits and has extra room to be decreased or increased further.
    # Shape key slider_min and slider_max have hard min/max values, if an imported animation uses a value outside that
    # range, a warning message will be printed to the console and the slider_min/slider_max values will end up clamped.
    shape_key_values_in_range = True
    for shape_key, deform_values in shape_key_values.items():
        min_animated_deform = min(deform_values)
        max_animated_deform = max(deform_values)
        shape_key_values_in_range &= expand_shape_key_range(shape_key, min_animated_deform)
        shape_key_values_in_range &= expand_shape_key_range(shape_key, max_animated_deform)
    if not shape_key_values_in_range:
        print("WARNING: The imported animated Value of a Shape Key is beyond the minimum/maximum allowed and will be"
              " clamped during playback.")


# ----
# Mesh

def blen_read_geom_layerinfo(fbx_layer):
    return (
        validate_blend_names(elem_find_first_string_as_bytes(fbx_layer, b'Name')),
        elem_find_first_string_as_bytes(fbx_layer, b'MappingInformationType'),
        elem_find_first_string_as_bytes(fbx_layer, b'ReferenceInformationType'),
    )


def blen_read_geom_validate_blen_data(blen_data, blen_dtype, item_size):
    """Validate blen_data when it's not a bpy_prop_collection.
    Returns whether blen_data is a bpy_prop_collection"""
    blen_data_is_collection = isinstance(blen_data, bpy.types.bpy_prop_collection)
    if not blen_data_is_collection:
        if item_size > 1:
            assert len(blen_data.shape) == 2
            assert blen_data.shape[1] == item_size
        assert blen_data.dtype == blen_dtype
    return blen_data_is_collection


def blen_read_geom_parse_fbx_data(fbx_data, stride, item_size):
    """Parse fbx_data as an array.array into a 2d np.ndarray that shares the same memory, where each row is a single
    item"""
    # Technically stride < item_size could be supported, but there's probably not a use case for it since it would
    # result in a view of the data with self-overlapping memory.
    assert stride >= item_size
    # View the array.array as an np.ndarray.
    fbx_data_np = parray_as_ndarray(fbx_data)

    if stride == item_size:
        if item_size > 1:
            # Need to make sure fbx_data_np has a whole number of items to be able to view item_size elements per row.
            items_remainder = len(fbx_data_np) % item_size
            if items_remainder:
                print("ERROR: not a whole number of items in this FBX layer, skipping the partial item!")
                fbx_data_np = fbx_data_np[:-items_remainder]
        fbx_data_np = fbx_data_np.reshape(-1, item_size)
    else:
        # Create a view of fbx_data_np that is only the first item_size elements of each stride. Note that the view will
        # not be C-contiguous.
        stride_remainder = len(fbx_data_np) % stride
        if stride_remainder:
            if stride_remainder < item_size:
                print("ERROR: not a whole number of items in this FBX layer, skipping the partial item!")
                # Not enough in the remainder for a full item, so cut off the partial stride
                fbx_data_np = fbx_data_np[:-stride_remainder]
                # Reshape to one stride per row and then create a view that includes only the first item_size elements
                # of each stride.
                fbx_data_np = fbx_data_np.reshape(-1, stride)[:, :item_size]
            else:
                print("ERROR: not a whole number of strides in this FBX layer! There are a whole number of items, but"
                      " this could indicate an error!")
                # There is not a whole number of strides, but there is a whole number of items.
                # This is a pain to deal with because fbx_data_np.reshape(-1, stride) is not possible.
                # A view of just the items can be created using stride_tricks.as_strided by specifying the shape and
                # strides of the view manually.
                # Extreme care must be taken when using stride_tricks.as_strided because improper usage can result in
                # a view that gives access to memory outside the array.
                from numpy.lib import stride_tricks

                # fbx_data_np should always start off as flat and C-contiguous.
                assert fbx_data_np.strides == (fbx_data_np.itemsize,)

                num_whole_strides = len(fbx_data_np) // stride
                # Plus the one partial stride that is enough elements for a complete item.
                num_items = num_whole_strides + 1
                shape = (num_items, item_size)

                # strides are the number of bytes to step to get to the next element, for each axis.
                step_per_item = fbx_data_np.itemsize * stride
                step_per_item_element = fbx_data_np.itemsize
                strides = (step_per_item, step_per_item_element)

                fbx_data_np = stride_tricks.as_strided(fbx_data_np, shape, strides)
        else:
            # There's a whole number of strides, so first reshape to one stride per row and then create a view that
            # includes only the first item_size elements of each stride.
            fbx_data_np = fbx_data_np.reshape(-1, stride)[:, :item_size]

    return fbx_data_np


def blen_read_geom_check_fbx_data_length(blen_data, fbx_data_np, is_indices=False):
    """Check that there are the same number of items in blen_data and fbx_data_np.

    Returns a tuple of two elements:
        0: fbx_data_np or, if fbx_data_np contains more items than blen_data, a view of fbx_data_np with the excess
           items removed
        1: Whether the returned fbx_data_np contains enough items to completely fill blen_data"""
    bl_num_items = len(blen_data)
    fbx_num_items = len(fbx_data_np)
    enough_data = fbx_num_items >= bl_num_items
    if not enough_data:
        if is_indices:
            print("ERROR: not enough indices in this FBX layer, missing data will be left as default!")
        else:
            print("ERROR: not enough data in this FBX layer, missing data will be left as default!")
    elif fbx_num_items > bl_num_items:
        if is_indices:
            print("ERROR: too many indices in this FBX layer, skipping excess!")
        else:
            print("ERROR: too much data in this FBX layer, skipping excess!")
        fbx_data_np = fbx_data_np[:bl_num_items]

    return fbx_data_np, enough_data


def blen_read_geom_xform(fbx_data_np, xform):
    """xform is either None, or a function that takes fbx_data_np as its only positional argument and returns an
    np.ndarray with the same total number of elements as fbx_data_np.
    It is acceptable for xform to return an array with a different dtype to fbx_data_np.

    Returns xform(fbx_data_np) when xform is not None and ensures the result of xform(fbx_data_np) has the same shape as
    fbx_data_np before returning it.
    When xform is None, fbx_data_np is returned as is."""
    if xform is not None:
        item_size = fbx_data_np.shape[1]
        fbx_total_data = fbx_data_np.size
        fbx_data_np = xform(fbx_data_np)
        # The amount of data should not be changed by xform
        assert fbx_data_np.size == fbx_total_data
        # Ensure fbx_data_np is still item_size elements per row
        if len(fbx_data_np.shape) != 2 or fbx_data_np.shape[1] != item_size:
            fbx_data_np = fbx_data_np.reshape(-1, item_size)
    return fbx_data_np


def blen_read_geom_array_foreach_set_direct(blen_data, blen_attr, blen_dtype, fbx_data, stride, item_size, descr,
                                            xform):
    """Generic fbx_layer to blen_data foreach setter for Direct layers.
    blen_data must be a bpy_prop_collection or 2d np.ndarray whose second axis length is item_size.
    fbx_data must be an array.array."""
    fbx_data_np = blen_read_geom_parse_fbx_data(fbx_data, stride, item_size)
    fbx_data_np, enough_data = blen_read_geom_check_fbx_data_length(blen_data, fbx_data_np)
    fbx_data_np = blen_read_geom_xform(fbx_data_np, xform)

    blen_data_is_collection = blen_read_geom_validate_blen_data(blen_data, blen_dtype, item_size)

    if blen_data_is_collection:
        if not enough_data:
            blen_total_data = len(blen_data) * item_size
            buffer = np.empty(blen_total_data, dtype=blen_dtype)
            # It's not clear what values should be used for the missing data, so read the current values into a buffer.
            blen_data.foreach_get(blen_attr, buffer)

            # Change the buffer shape to one item per row
            buffer.shape = (-1, item_size)

            # Copy the fbx data into the start of the buffer
            buffer[:len(fbx_data_np)] = fbx_data_np
        else:
            # Convert the buffer to the Blender C type of blen_attr
            buffer = astype_view_signedness(fbx_data_np, blen_dtype)

        # Set blen_attr of blen_data. The buffer must be flat and C-contiguous, which ravel() ensures
        blen_data.foreach_set(blen_attr, buffer.ravel())
    else:
        assert blen_data.size % item_size == 0
        blen_data = blen_data.view()
        blen_data.shape = (-1, item_size)
        blen_data[:len(fbx_data_np)] = fbx_data_np


def blen_read_geom_array_foreach_set_indexed(blen_data, blen_attr, blen_dtype, fbx_data, fbx_layer_index, stride,
                                             item_size, descr, xform):
    """Generic fbx_layer to blen_data foreach setter for IndexToDirect layers.
    blen_data must be a bpy_prop_collection or 2d np.ndarray whose second axis length is item_size.
    fbx_data must be an array.array or a 1d np.ndarray."""
    fbx_data_np = blen_read_geom_parse_fbx_data(fbx_data, stride, item_size)
    fbx_data_np = blen_read_geom_xform(fbx_data_np, xform)

    # fbx_layer_index is allowed to be a 1d np.ndarray for use with blen_read_geom_array_foreach_set_looptovert.
    if not isinstance(fbx_layer_index, np.ndarray):
        fbx_layer_index = parray_as_ndarray(fbx_layer_index)

    fbx_layer_index, enough_indices = blen_read_geom_check_fbx_data_length(blen_data, fbx_layer_index, is_indices=True)

    blen_data_is_collection = blen_read_geom_validate_blen_data(blen_data, blen_dtype, item_size)

    blen_data_items_len = len(blen_data)
    blen_data_len = blen_data_items_len * item_size
    fbx_num_items = len(fbx_data_np)

    # Find all indices that are out of bounds of fbx_data_np.
    min_index_inclusive = -fbx_num_items
    max_index_inclusive = fbx_num_items - 1
    valid_index_mask = np.equal(fbx_layer_index, fbx_layer_index.clip(min_index_inclusive, max_index_inclusive))
    indices_invalid = not valid_index_mask.all()

    fbx_data_items = fbx_data_np.reshape(-1, item_size)

    if indices_invalid or not enough_indices:
        if blen_data_is_collection:
            buffer = np.empty(blen_data_len, dtype=blen_dtype)
            buffer_item_view = buffer.view()
            buffer_item_view.shape = (-1, item_size)
            # Since we don't know what the default values should be for the missing data, read the current values into a
            # buffer.
            blen_data.foreach_get(blen_attr, buffer)
        else:
            buffer_item_view = blen_data

        if not enough_indices:
            # Reduce the length of the view to the same length as the number of indices.
            buffer_item_view = buffer_item_view[:len(fbx_layer_index)]

        # Copy the result of indexing fbx_data_items by each element in fbx_layer_index into the buffer.
        if indices_invalid:
            print("ERROR: indices in this FBX layer out of bounds of the FBX data, skipping invalid indices!")
            buffer_item_view[valid_index_mask] = fbx_data_items[fbx_layer_index[valid_index_mask]]
        else:
            buffer_item_view[:] = fbx_data_items[fbx_layer_index]

        if blen_data_is_collection:
            blen_data.foreach_set(blen_attr, buffer.ravel())
    else:
        if blen_data_is_collection:
            # Cast the buffer to the Blender C type of blen_attr
            fbx_data_items = astype_view_signedness(fbx_data_items, blen_dtype)
            buffer_items = fbx_data_items[fbx_layer_index]
            blen_data.foreach_set(blen_attr, buffer_items.ravel())
        else:
            blen_data[:] = fbx_data_items[fbx_layer_index]


def blen_read_geom_array_foreach_set_allsame(blen_data, blen_attr, blen_dtype, fbx_data, stride, item_size, descr,
                                             xform):
    """Generic fbx_layer to blen_data foreach setter for AllSame layers.
    blen_data must be a bpy_prop_collection or 2d np.ndarray whose second axis length is item_size.
    fbx_data must be an array.array."""
    fbx_data_np = blen_read_geom_parse_fbx_data(fbx_data, stride, item_size)
    fbx_data_np = blen_read_geom_xform(fbx_data_np, xform)
    blen_data_is_collection = blen_read_geom_validate_blen_data(blen_data, blen_dtype, item_size)
    fbx_items_len = len(fbx_data_np)
    blen_items_len = len(blen_data)

    if fbx_items_len < 1:
        print("ERROR: not enough data in this FBX layer, skipping!")
        return

    if blen_data_is_collection:
        # Create an array filled with the value from fbx_data_np
        buffer = np.full((blen_items_len, item_size), fbx_data_np[0], dtype=blen_dtype)

        blen_data.foreach_set(blen_attr, buffer.ravel())
    else:
        blen_data[:] = fbx_data_np[0]


def blen_read_geom_array_foreach_set_looptovert(mesh, blen_data, blen_attr, blen_dtype, fbx_data, stride, item_size,
                                                descr, xform):
    """Generic fbx_layer to blen_data foreach setter for face corner ByVertice layers.
    blen_data must be a bpy_prop_collection or 2d np.ndarray whose second axis length is item_size.
    fbx_data must be an array.array"""
    # The fbx_data is mapped to vertices. To expand fbx_data to face corners, get an array of the vertex index of each
    # face corner that will then be used to index fbx_data.
    corner_vertex_indices = MESH_ATTRIBUTE_CORNER_VERT.to_ndarray(mesh.attributes)
    blen_read_geom_array_foreach_set_indexed(blen_data, blen_attr, blen_dtype, fbx_data, corner_vertex_indices, stride,
                                             item_size, descr, xform)


# generic error printers.
def blen_read_geom_array_error_mapping(descr, fbx_layer_mapping, quiet=False):
    if not quiet:
        print("warning layer %r mapping type unsupported: %r" % (descr, fbx_layer_mapping))


def blen_read_geom_array_error_ref(descr, fbx_layer_ref, quiet=False):
    if not quiet:
        print("warning layer %r ref type unsupported: %r" % (descr, fbx_layer_ref))


def blen_read_geom_array_mapped_vert(
        mesh, blen_data, blen_attr, blen_dtype,
        fbx_layer_data, fbx_layer_index,
        fbx_layer_mapping, fbx_layer_ref,
        stride, item_size, descr,
        xform=None, quiet=False,
):
    if fbx_layer_mapping == b'ByVertice':
        if fbx_layer_ref == b'IndexToDirect':
            # XXX Looks like we often get no fbx_layer_index in this case, shall not happen but happens...
            #     We fallback to 'Direct' mapping in this case.
            # ~ assert fbx_layer_index is not None
            if fbx_layer_index is None:
                blen_read_geom_array_foreach_set_direct(blen_data, blen_attr, blen_dtype, fbx_layer_data, stride,
                                                        item_size, descr, xform)
            else:
                blen_read_geom_array_foreach_set_indexed(blen_data, blen_attr, blen_dtype, fbx_layer_data,
                                                         fbx_layer_index, stride, item_size, descr, xform)
            return True
        elif fbx_layer_ref == b'Direct':
            assert fbx_layer_index is None
            blen_read_geom_array_foreach_set_direct(blen_data, blen_attr, blen_dtype, fbx_layer_data, stride, item_size,
                                                    descr, xform)
            return True
        blen_read_geom_array_error_ref(descr, fbx_layer_ref, quiet)
    elif fbx_layer_mapping == b'AllSame':
        if fbx_layer_ref == b'IndexToDirect':
            assert fbx_layer_index is None
            blen_read_geom_array_foreach_set_allsame(blen_data, blen_attr, blen_dtype, fbx_layer_data, stride,
                                                     item_size, descr, xform)
            return True
        blen_read_geom_array_error_ref(descr, fbx_layer_ref, quiet)
    else:
        blen_read_geom_array_error_mapping(descr, fbx_layer_mapping, quiet)

    return False


def blen_read_geom_array_mapped_edge(
        mesh, blen_data, blen_attr, blen_dtype,
        fbx_layer_data, fbx_layer_index,
        fbx_layer_mapping, fbx_layer_ref,
        stride, item_size, descr,
        xform=None, quiet=False,
):
    if fbx_layer_mapping == b'ByEdge':
        if fbx_layer_ref == b'Direct':
            blen_read_geom_array_foreach_set_direct(blen_data, blen_attr, blen_dtype, fbx_layer_data, stride, item_size,
                                                    descr, xform)
            return True
        blen_read_geom_array_error_ref(descr, fbx_layer_ref, quiet)
    elif fbx_layer_mapping == b'AllSame':
        if fbx_layer_ref == b'IndexToDirect':
            assert fbx_layer_index is None
            blen_read_geom_array_foreach_set_allsame(blen_data, blen_attr, blen_dtype, fbx_layer_data, stride,
                                                     item_size, descr, xform)
            return True
        blen_read_geom_array_error_ref(descr, fbx_layer_ref, quiet)
    else:
        blen_read_geom_array_error_mapping(descr, fbx_layer_mapping, quiet)

    return False


def blen_read_geom_array_mapped_polygon(
        mesh, blen_data, blen_attr, blen_dtype,
        fbx_layer_data, fbx_layer_index,
        fbx_layer_mapping, fbx_layer_ref,
        stride, item_size, descr,
        xform=None, quiet=False,
):
    if fbx_layer_mapping == b'ByPolygon':
        if fbx_layer_ref == b'IndexToDirect':
            # XXX Looks like we often get no fbx_layer_index in this case, shall not happen but happens...
            #     We fallback to 'Direct' mapping in this case.
            # ~ assert fbx_layer_index is not None
            if fbx_layer_index is None:
                blen_read_geom_array_foreach_set_direct(blen_data, blen_attr, blen_dtype, fbx_layer_data, stride,
                                                        item_size, descr, xform)
            else:
                blen_read_geom_array_foreach_set_indexed(blen_data, blen_attr, blen_dtype, fbx_layer_data,
                                                         fbx_layer_index, stride, item_size, descr, xform)
            return True
        elif fbx_layer_ref == b'Direct':
            blen_read_geom_array_foreach_set_direct(blen_data, blen_attr, blen_dtype, fbx_layer_data, stride, item_size,
                                                    descr, xform)
            return True
        blen_read_geom_array_error_ref(descr, fbx_layer_ref, quiet)
    elif fbx_layer_mapping == b'AllSame':
        if fbx_layer_ref == b'IndexToDirect':
            assert fbx_layer_index is None
            blen_read_geom_array_foreach_set_allsame(blen_data, blen_attr, blen_dtype, fbx_layer_data, stride,
                                                     item_size, descr, xform)
            return True
        blen_read_geom_array_error_ref(descr, fbx_layer_ref, quiet)
    else:
        blen_read_geom_array_error_mapping(descr, fbx_layer_mapping, quiet)

    return False


def blen_read_geom_array_mapped_polyloop(
        mesh, blen_data, blen_attr, blen_dtype,
        fbx_layer_data, fbx_layer_index,
        fbx_layer_mapping, fbx_layer_ref,
        stride, item_size, descr,
        xform=None, quiet=False,
):
    if fbx_layer_mapping == b'ByPolygonVertex':
        if fbx_layer_ref == b'IndexToDirect':
            # XXX Looks like we often get no fbx_layer_index in this case, shall not happen but happens...
            #     We fallback to 'Direct' mapping in this case.
            # ~ assert fbx_layer_index is not None
            if fbx_layer_index is None:
                blen_read_geom_array_foreach_set_direct(blen_data, blen_attr, blen_dtype, fbx_layer_data, stride,
                                                        item_size, descr, xform)
            else:
                blen_read_geom_array_foreach_set_indexed(blen_data, blen_attr, blen_dtype, fbx_layer_data,
                                                         fbx_layer_index, stride, item_size, descr, xform)
            return True
        elif fbx_layer_ref == b'Direct':
            blen_read_geom_array_foreach_set_direct(blen_data, blen_attr, blen_dtype, fbx_layer_data, stride, item_size,
                                                    descr, xform)
            return True
        blen_read_geom_array_error_ref(descr, fbx_layer_ref, quiet)
    elif fbx_layer_mapping == b'ByVertice':
        if fbx_layer_ref == b'Direct':
            assert fbx_layer_index is None
            blen_read_geom_array_foreach_set_looptovert(mesh, blen_data, blen_attr, blen_dtype, fbx_layer_data, stride,
                                                        item_size, descr, xform)
            return True
        blen_read_geom_array_error_ref(descr, fbx_layer_ref, quiet)
    elif fbx_layer_mapping == b'AllSame':
        if fbx_layer_ref == b'IndexToDirect':
            assert fbx_layer_index is None
            blen_read_geom_array_foreach_set_allsame(blen_data, blen_attr, blen_dtype, fbx_layer_data, stride,
                                                     item_size, descr, xform)
            return True
        blen_read_geom_array_error_ref(descr, fbx_layer_ref, quiet)
    else:
        blen_read_geom_array_error_mapping(descr, fbx_layer_mapping, quiet)

    return False


def blen_read_geom_layer_material(fbx_obj, mesh):
    fbx_layer = elem_find_first(fbx_obj, b'LayerElementMaterial')

    if fbx_layer is None:
        return

    (fbx_layer_name,
     fbx_layer_mapping,
     fbx_layer_ref,
     ) = blen_read_geom_layerinfo(fbx_layer)

    layer_id = b'Materials'
    fbx_layer_data = elem_prop_first(elem_find_first(fbx_layer, layer_id))

    blen_data = MESH_ATTRIBUTE_MATERIAL_INDEX.ensure(mesh.attributes).data
    fbx_item_size = 1
    assert fbx_item_size == MESH_ATTRIBUTE_MATERIAL_INDEX.item_size
    blen_read_geom_array_mapped_polygon(
        mesh, blen_data, MESH_ATTRIBUTE_MATERIAL_INDEX.foreach_attribute, MESH_ATTRIBUTE_MATERIAL_INDEX.dtype,
        fbx_layer_data, None,
        fbx_layer_mapping, fbx_layer_ref,
        1, fbx_item_size, layer_id,
    )


def blen_read_geom_layer_uv(fbx_obj, mesh):
    for layer_id in (b'LayerElementUV',):
        for fbx_layer in elem_find_iter(fbx_obj, layer_id):
            # all should be valid
            (fbx_layer_name,
             fbx_layer_mapping,
             fbx_layer_ref,
             ) = blen_read_geom_layerinfo(fbx_layer)

            fbx_layer_data = elem_prop_first(elem_find_first(fbx_layer, b'UV'))
            fbx_layer_index = elem_prop_first(elem_find_first(fbx_layer, b'UVIndex'))

            # Always init our new layers with (0, 0) UVs.
            uv_lay = mesh.uv_layers.new(name=fbx_layer_name, do_init=False)
            if uv_lay is None:
                print("Failed to add {%r %r} UVLayer to %r (probably too many of them?)"
                      "" % (layer_id, fbx_layer_name, mesh.name))
                continue

            blen_data = uv_lay.uv

            # some valid files omit this data
            if fbx_layer_data is None:
                print("%r %r missing data" % (layer_id, fbx_layer_name))
                continue

            blen_read_geom_array_mapped_polyloop(
                mesh, blen_data, "vector", np.single,
                fbx_layer_data, fbx_layer_index,
                fbx_layer_mapping, fbx_layer_ref,
                2, 2, layer_id,
            )


def blen_read_geom_layer_color(fbx_obj, mesh, colors_type):
    if colors_type == 'NONE':
        return
    use_srgb = colors_type == 'SRGB'
    layer_type = 'BYTE_COLOR' if use_srgb else 'FLOAT_COLOR'
    color_prop_name = "color_srgb" if use_srgb else "color"
    # almost same as UVs
    for layer_id in (b'LayerElementColor',):
        for fbx_layer in elem_find_iter(fbx_obj, layer_id):
            # all should be valid
            (fbx_layer_name,
             fbx_layer_mapping,
             fbx_layer_ref,
             ) = blen_read_geom_layerinfo(fbx_layer)

            fbx_layer_data = elem_prop_first(elem_find_first(fbx_layer, b'Colors'))
            fbx_layer_index = elem_prop_first(elem_find_first(fbx_layer, b'ColorIndex'))

            color_lay = mesh.color_attributes.new(name=fbx_layer_name, type=layer_type, domain='CORNER')

            if color_lay is None:
                print("Failed to add {%r %r} vertex color layer to %r (probably too many of them?)"
                      "" % (layer_id, fbx_layer_name, mesh.name))
                continue

            blen_data = color_lay.data

            # some valid files omit this data
            if fbx_layer_data is None:
                print("%r %r missing data" % (layer_id, fbx_layer_name))
                continue

            blen_read_geom_array_mapped_polyloop(
                mesh, blen_data, color_prop_name, np.single,
                fbx_layer_data, fbx_layer_index,
                fbx_layer_mapping, fbx_layer_ref,
                4, 4, layer_id,
            )


def blen_read_geom_layer_smooth(fbx_obj, mesh):
    fbx_layer = elem_find_first(fbx_obj, b'LayerElementSmoothing')

    if fbx_layer is None:
        return

    # all should be valid
    (fbx_layer_name,
     fbx_layer_mapping,
     fbx_layer_ref,
     ) = blen_read_geom_layerinfo(fbx_layer)

    layer_id = b'Smoothing'
    fbx_layer_data = elem_prop_first(elem_find_first(fbx_layer, layer_id))

    # udk has 'Direct' mapped, with no Smoothing, not sure why, but ignore these
    if fbx_layer_data is None:
        return

    if fbx_layer_mapping == b'ByEdge':
        # some models have bad edge data, we can't use this info...
        if not mesh.edges:
            print("warning skipping sharp edges data, no valid edges...")
            return

        blen_data = MESH_ATTRIBUTE_SHARP_EDGE.ensure(mesh.attributes).data
        fbx_item_size = 1
        assert fbx_item_size == MESH_ATTRIBUTE_SHARP_EDGE.item_size
        blen_read_geom_array_mapped_edge(
            mesh, blen_data, MESH_ATTRIBUTE_SHARP_EDGE.foreach_attribute, MESH_ATTRIBUTE_SHARP_EDGE.dtype,
            fbx_layer_data, None,
            fbx_layer_mapping, fbx_layer_ref,
            1, fbx_item_size, layer_id,
            xform=np.logical_not,  # in FBX, 0 (False) is sharp, but in Blender True is sharp.
        )
    elif fbx_layer_mapping == b'ByPolygon':
        sharp_face = MESH_ATTRIBUTE_SHARP_FACE.ensure(mesh.attributes)
        blen_data = sharp_face.data
        fbx_item_size = 1
        assert fbx_item_size == MESH_ATTRIBUTE_SHARP_FACE.item_size
        sharp_face_set_successfully = blen_read_geom_array_mapped_polygon(
            mesh, blen_data, MESH_ATTRIBUTE_SHARP_FACE.foreach_attribute, MESH_ATTRIBUTE_SHARP_FACE.dtype,
            fbx_layer_data, None,
            fbx_layer_mapping, fbx_layer_ref,
            1, fbx_item_size, layer_id,
            xform=lambda s: (s == 0),  # smooth-group bit-flags, treat as booleans for now.
        )
        if not sharp_face_set_successfully:
            mesh.attributes.remove(sharp_face)
    else:
        print("warning layer %r mapping type unsupported: %r" % (fbx_layer.id, fbx_layer_mapping))


def blen_read_geom_layer_edge_crease(fbx_obj, mesh):
    fbx_layer = elem_find_first(fbx_obj, b'LayerElementEdgeCrease')

    if fbx_layer is None:
        return False

    # all should be valid
    (fbx_layer_name,
     fbx_layer_mapping,
     fbx_layer_ref,
     ) = blen_read_geom_layerinfo(fbx_layer)

    if fbx_layer_mapping != b'ByEdge':
        return False

    layer_id = b'EdgeCrease'
    fbx_layer_data = elem_prop_first(elem_find_first(fbx_layer, layer_id))

    # some models have bad edge data, we can't use this info...
    if not mesh.edges:
        print("warning skipping edge crease data, no valid edges...")
        return False

    if fbx_layer_mapping == b'ByEdge':
        # some models have bad edge data, we can't use this info...
        if not mesh.edges:
            print("warning skipping edge crease data, no valid edges...")
            return False

        blen_data = mesh.edge_creases_ensure().data
        return blen_read_geom_array_mapped_edge(
            mesh, blen_data, "value", np.single,
            fbx_layer_data, None,
            fbx_layer_mapping, fbx_layer_ref,
            1, 1, layer_id,
            # Blender squares those values before sending them to OpenSubdiv, when other software don't,
            # so we need to compensate that to get similar results through FBX...
            xform=np.sqrt,
        )
    else:
        print("warning layer %r mapping type unsupported: %r" % (fbx_layer.id, fbx_layer_mapping))
        return False


def blen_read_geom_layer_normal(fbx_obj, mesh, xform=None):
    fbx_layer = elem_find_first(fbx_obj, b'LayerElementNormal')

    if fbx_layer is None:
        return False

    (fbx_layer_name,
     fbx_layer_mapping,
     fbx_layer_ref,
     ) = blen_read_geom_layerinfo(fbx_layer)

    layer_id = b'Normals'
    fbx_layer_data = elem_prop_first(elem_find_first(fbx_layer, layer_id))
    fbx_layer_index = elem_prop_first(elem_find_first(fbx_layer, b'NormalsIndex'))

    if fbx_layer_data is None:
        print("warning %r %r missing data" % (layer_id, fbx_layer_name))
        return False

    # Normals are temporarily set here so that they can be retrieved again after a call to Mesh.validate().
    bl_norm_dtype = np.single
    item_size = 3
    # try loops, then polygons, then vertices.
    tries = ((mesh.attributes["temp_custom_normals"].data, "Loops", False, blen_read_geom_array_mapped_polyloop),
             (mesh.polygons, "Polygons", True, blen_read_geom_array_mapped_polygon),
             (mesh.vertices, "Vertices", True, blen_read_geom_array_mapped_vert))
    for blen_data, blen_data_type, is_fake, func in tries:
        bdata = np.zeros((len(blen_data), item_size), dtype=bl_norm_dtype) if is_fake else blen_data
        if func(mesh, bdata, "vector", bl_norm_dtype,
                fbx_layer_data, fbx_layer_index, fbx_layer_mapping, fbx_layer_ref, 3, item_size, layer_id, xform, True):
            if blen_data_type == "Polygons":
                # To expand to per-loop normals, repeat each per-polygon normal by the number of loops of each polygon.
                poly_loop_totals = np.empty(len(mesh.polygons), dtype=np.uintc)
                mesh.polygons.foreach_get("loop_total", poly_loop_totals)
                loop_normals = np.repeat(bdata, poly_loop_totals, axis=0)
                mesh.attributes["temp_custom_normals"].data.foreach_set("vector", loop_normals.ravel())
            elif blen_data_type == "Vertices":
                # We have to copy vnors to lnors! Far from elegant, but simple.
                loop_vertex_indices = MESH_ATTRIBUTE_CORNER_VERT.to_ndarray(mesh.attributes)
                mesh.attributes["temp_custom_normals"].data.foreach_set("vector", bdata[loop_vertex_indices].ravel())
            return True

    blen_read_geom_array_error_mapping("normal", fbx_layer_mapping)
    blen_read_geom_array_error_ref("normal", fbx_layer_ref)
    return False


def blen_read_geom(fbx_tmpl, fbx_obj, settings):
    # Vertices are in object space, but we are post-multiplying all transforms with the inverse of the
    # global matrix, so we need to apply the global matrix to the vertices to get the correct result.
    geom_mat_co = settings.global_matrix if settings.bake_space_transform else None
    # We need to apply the inverse transpose of the global matrix when transforming normals.
    geom_mat_no = Matrix(settings.global_matrix_inv_transposed) if settings.bake_space_transform else None
    if geom_mat_no is not None:
        # Remove translation & scaling!
        geom_mat_no.translation = Vector()
        geom_mat_no.normalize()

    # TODO, use 'fbx_tmpl'
    elem_name_utf8 = elem_name_ensure_class(fbx_obj, b'Geometry')

    fbx_verts = elem_prop_first(elem_find_first(fbx_obj, b'Vertices'))
    fbx_polys = elem_prop_first(elem_find_first(fbx_obj, b'PolygonVertexIndex'))
    fbx_edges = elem_prop_first(elem_find_first(fbx_obj, b'Edges'))

    # The dtypes when empty don't matter, but are set to what the fbx arrays are expected to be.
    fbx_verts = parray_as_ndarray(fbx_verts) if fbx_verts else np.empty(0, dtype=data_types.ARRAY_FLOAT64)
    fbx_polys = parray_as_ndarray(fbx_polys) if fbx_polys else np.empty(0, dtype=data_types.ARRAY_INT32)
    fbx_edges = parray_as_ndarray(fbx_edges) if fbx_edges else np.empty(0, dtype=data_types.ARRAY_INT32)

    # Each vert is a 3d vector so is made of 3 components.
    tot_verts = len(fbx_verts) // 3
    if tot_verts * 3 != len(fbx_verts):
        print("ERROR: Not a whole number of vertices. Ignoring the partial vertex!")
        # Remove any remainder.
        fbx_verts = fbx_verts[:tot_verts * 3]

    tot_loops = len(fbx_polys)
    tot_edges = len(fbx_edges)

    mesh = bpy.data.meshes.new(name=elem_name_utf8)
    attributes = mesh.attributes

    if tot_verts:
        if geom_mat_co is not None:
            fbx_verts = vcos_transformed(fbx_verts, geom_mat_co, MESH_ATTRIBUTE_POSITION.dtype)
        else:
            fbx_verts = fbx_verts.astype(MESH_ATTRIBUTE_POSITION.dtype, copy=False)

        mesh.vertices.add(tot_verts)
        MESH_ATTRIBUTE_POSITION.foreach_set(attributes, fbx_verts.ravel())

    if tot_loops:
        bl_loop_start_dtype = np.uintc

        mesh.loops.add(tot_loops)
        # The end of each polygon is specified by an inverted index.
        fbx_loop_end_idx = np.flatnonzero(fbx_polys < 0)

        tot_polys = len(fbx_loop_end_idx)

        # Un-invert the loop ends.
        fbx_polys[fbx_loop_end_idx] ^= -1
        # Set loop vertex indices, casting to the Blender C type first for performance.
        MESH_ATTRIBUTE_CORNER_VERT.foreach_set(
            attributes, astype_view_signedness(fbx_polys, MESH_ATTRIBUTE_CORNER_VERT.dtype))

        poly_loop_starts = np.empty(tot_polys, dtype=bl_loop_start_dtype)
        # The first loop is always a loop start.
        poly_loop_starts[0] = 0
        # Ignoring the last loop end, the indices after every loop end are the remaining loop starts.
        poly_loop_starts[1:] = fbx_loop_end_idx[:-1] + 1

        mesh.polygons.add(tot_polys)
        mesh.polygons.foreach_set("loop_start", poly_loop_starts)

        blen_read_geom_layer_material(fbx_obj, mesh)
        blen_read_geom_layer_uv(fbx_obj, mesh)
        blen_read_geom_layer_color(fbx_obj, mesh, settings.colors_type)

        if tot_edges:
            # edges in fact index the polygons (NOT the vertices)

            # The first vertex index of each edge is the vertex index of the corresponding loop in fbx_polys.
            edges_a = fbx_polys[fbx_edges]

            # The second vertex index of each edge is the vertex index of the next loop in the same polygon. The
            # complexity here is that if the first vertex index was the last loop of that polygon in fbx_polys, the next
            # loop in the polygon is the first loop of that polygon, which is not the next loop in fbx_polys.

            # Copy fbx_polys, but rolled backwards by 1 so that indexing the result by [fbx_edges] will get the next
            # loop of the same polygon unless the first vertex index was the last loop of the polygon.
            fbx_polys_next = np.roll(fbx_polys, -1)
            # Get the first loop of each polygon and set them into fbx_polys_next at the same indices as the last loop
            # of each polygon in fbx_polys.
            fbx_polys_next[fbx_loop_end_idx] = fbx_polys[poly_loop_starts]

            # Indexing fbx_polys_next by fbx_edges now gets the vertex index of the next loop in fbx_polys.
            edges_b = fbx_polys_next[fbx_edges]

            # edges_a and edges_b need to be combined so that the first vertex index of each edge is immediately
            # followed by the second vertex index of that same edge.
            # Stack edges_a and edges_b as individual columns like np.column_stack((edges_a, edges_b)).
            # np.concatenate is used because np.column_stack doesn't allow specifying the dtype of the returned array.
            edges_conv = np.concatenate((edges_a.reshape(-1, 1), edges_b.reshape(-1, 1)),
                                        axis=1, dtype=MESH_ATTRIBUTE_EDGE_VERTS.dtype, casting='unsafe')

            # Add the edges and set their vertex indices.
            mesh.edges.add(len(edges_conv))
            # ravel() because edges_conv must be flat and C-contiguous when passed to foreach_set.
            MESH_ATTRIBUTE_EDGE_VERTS.foreach_set(attributes, edges_conv.ravel())
    elif tot_edges:
        print("ERROR: No polygons, but edges exist. Ignoring the edges!")

    # must be after edge, face loading.
    blen_read_geom_layer_smooth(fbx_obj, mesh)

    blen_read_geom_layer_edge_crease(fbx_obj, mesh)

    ok_normals = False
    if settings.use_custom_normals:
        # Note: we store 'temp' normals in loops, since validate() may alter final mesh,
        #       we can only set custom lnors *after* calling it.
        mesh.attributes.new("temp_custom_normals", 'FLOAT_VECTOR', 'CORNER')
        if geom_mat_no is None:
            ok_normals = blen_read_geom_layer_normal(fbx_obj, mesh)
        else:
            ok_normals = blen_read_geom_layer_normal(fbx_obj, mesh,
                                                     lambda v_array: nors_transformed(v_array, geom_mat_no))

    mesh.validate(clean_customdata=False)  # *Very* important to not remove lnors here!

    if ok_normals:
        bl_nors_dtype = np.single
        clnors = np.empty(len(mesh.loops) * 3, dtype=bl_nors_dtype)
        mesh.attributes["temp_custom_normals"].data.foreach_get("vector", clnors)

        # Iterating clnors into a nested tuple first is faster than passing clnors.reshape(-1, 3) directly into
        # normals_split_custom_set. We use clnors.data since it is a memoryview, which is faster to iterate than clnors.
        mesh.normals_split_custom_set(tuple(zip(*(iter(clnors.data),) * 3)))
    if settings.use_custom_normals:
        mesh.attributes.remove(mesh.attributes["temp_custom_normals"])

    if settings.use_custom_props:
        blen_read_custom_properties(fbx_obj, mesh, settings)

    return mesh


def blen_read_shapes(fbx_tmpl, fbx_data, objects, me, scene):
    if not fbx_data:
        # No shape key data. Nothing to do.
        return

    me_vcos = MESH_ATTRIBUTE_POSITION.to_ndarray(me.attributes)
    me_vcos_vector_view = me_vcos.reshape(-1, 3)

    objects = list({node.bl_obj for node in objects})
    assert objects

    # Blender has a hard minimum and maximum shape key Value. If an imported shape key has a value outside this range it
    # will be clamped, and we'll print a warning message to the console.
    shape_key_values_in_range = True
    bc_uuid_to_keyblocks = {}
    for bc_uuid, fbx_sdata, fbx_bcdata, shapes_assigned_to_channel in fbx_data:
        num_shapes_assigned_to_channel = len(shapes_assigned_to_channel)
        if num_shapes_assigned_to_channel > 1:
            # Relevant design task: #104698
            raise RuntimeError("FBX in-between Shapes are not currently supported")  # See bug report #84111
        elem_name_utf8 = elem_name_ensure_class(fbx_sdata, b'Geometry')
        indices = elem_prop_first(elem_find_first(fbx_sdata, b'Indexes'))
        dvcos = elem_prop_first(elem_find_first(fbx_sdata, b'Vertices'))

        indices = parray_as_ndarray(indices) if indices else np.empty(0, dtype=data_types.ARRAY_INT32)
        dvcos = parray_as_ndarray(dvcos) if dvcos else np.empty(0, dtype=data_types.ARRAY_FLOAT64)

        # If there's not a whole number of vectors, trim off the remainder.
        # 3 components per vector.
        remainder = len(dvcos) % 3
        if remainder:
            dvcos = dvcos[:-remainder]
        dvcos = dvcos.reshape(-1, 3)

        # There must be the same number of indices as vertex coordinate differences.
        assert len(indices) == len(dvcos)

        # We completely ignore normals here!
        weight = elem_prop_first(elem_find_first(fbx_bcdata, b'DeformPercent'), default=100.0) / 100.0

        # The FullWeights array stores the deformation percentages of the BlendShapeChannel that fully activate each
        # Shape assigned to the BlendShapeChannel. Blender also uses this array to store Vertex Group weights, but this
        # is not part of the FBX standard.
        full_weights = elem_prop_first(elem_find_first(fbx_bcdata, b'FullWeights'))
        full_weights = parray_as_ndarray(full_weights) if full_weights else np.empty(0, dtype=data_types.ARRAY_FLOAT64)

        # Special case for Blender exported Shape Keys with a Vertex Group assigned. The Vertex Group weights are stored
        # in the FullWeights array.
        # XXX - It's possible, though very rare, to get a false positive here and create a Vertex Group when we
        #       shouldn't. This should only be possible when there are extraneous FullWeights or when there is a single
        #       FullWeight and its value is not 100.0.
        if (
                # Blender exported Shape Keys only ever export as 1 Shape per BlendShapeChannel.
                num_shapes_assigned_to_channel == 1
                # There should be one vertex weight for each vertex moved by the Shape.
                and len(full_weights) == len(indices)
                # Skip creating a Vertex Group when all the weights are 100.0 because such a Vertex Group has no effect.
                # This also avoids creating a Vertex Group for imported Shapes that only move a single vertex because
                # their BlendShapeChannel's singular FullWeight is expected to always be 100.0.
                and not np.all(full_weights == 100.0)
                # Blender vertex weights are always within the [0.0, 1.0] range (scaled to [0.0, 100.0] when saving to
                # FBX). This can eliminate imported BlendShapeChannels from Unreal that have extraneous FullWeights
                # because the extraneous values are usually negative.
                and np.all((full_weights >= 0.0) & (full_weights <= 100.0))
        ):
            # Not doing the division in-place because it's technically possible for FBX BlendShapeChannels to be used by
            # more than one FBX BlendShape, though this shouldn't be the case for Blender exported Shape Keys.
            vgweights = full_weights / 100.0
        else:
            vgweights = None
            # There must be a FullWeight for each Shape. Any extra FullWeights are ignored.
            assert len(full_weights) >= num_shapes_assigned_to_channel

        # To add shape keys to the mesh, an Object using the mesh is needed.
        if me.shape_keys is None:
            objects[0].shape_key_add(name="Basis", from_mix=False)
        kb = objects[0].shape_key_add(name=elem_name_utf8, from_mix=False)
        kb.value = 0.0
        me.shape_keys.use_relative = True  # Should already be set as such.

        # Only need to set the shape key co if there are any non-zero dvcos.
        if dvcos.any():
            shape_cos = me_vcos_vector_view.copy()
            shape_cos[indices] += dvcos
            kb.points.foreach_set("co", shape_cos.ravel())

        shape_key_values_in_range &= expand_shape_key_range(kb, weight)

        kb.value = weight

        # Add vgroup if necessary.
        if vgweights is not None:
            # VertexGroup.add only allows sequences of int indices, but iterating the indices array directly would
            # produce numpy scalars of types such as np.int32. The underlying memoryview of the indices array, however,
            # does produce standard Python ints when iterated, so pass indices.data to add_vgroup_to_objects instead of
            # indices.
            # memoryviews tend to be faster to iterate than numpy arrays anyway, so vgweights.data is passed too.
            add_vgroup_to_objects(indices.data, vgweights.data, kb.name, objects)
            kb.vertex_group = kb.name

        bc_uuid_to_keyblocks.setdefault(bc_uuid, []).append(kb)

    if not shape_key_values_in_range:
        print("WARNING: The imported Value of a Shape Key on the Mesh '%s' is beyond the minimum/maximum allowed and"
              " has been clamped." % me.name)

    return bc_uuid_to_keyblocks


# --------
# Material

def blen_read_material(fbx_tmpl, fbx_obj, settings):
    from bpy_extras import node_shader_utils
    from math import sqrt

    elem_name_utf8 = elem_name_ensure_class(fbx_obj, b'Material')

    if settings.mtl_name_collision_mode == "REFERENCE_EXISTING":
        if (ma := bpy.data.materials.get(elem_name_utf8)):
            return ma

    nodal_material_wrap_map = settings.nodal_material_wrap_map
    ma = bpy.data.materials.new(name=elem_name_utf8)

    const_color_white = 1.0, 1.0, 1.0
    const_color_black = 0.0, 0.0, 0.0

    fbx_props = (elem_find_first(fbx_obj, b'Properties70'),
                 elem_find_first(fbx_tmpl, b'Properties70', fbx_elem_nil))
    fbx_props_no_template = (fbx_props[0], fbx_elem_nil)

    ma_wrap = node_shader_utils.PrincipledBSDFWrapper(ma, is_readonly=False)
    ma_wrap.base_color = elem_props_get_color_rgb(fbx_props, b'DiffuseColor', const_color_white)
    # No specular color in Principled BSDF shader, assumed to be either white or take some tint from diffuse one...
    # TODO: add way to handle tint option (guesstimate from spec color + intensity...)?
    ma_wrap.specular = elem_props_get_number(fbx_props, b'SpecularFactor', 0.25) * 2.0
    # XXX Totally empirical conversion, trying to adapt it (and protect against invalid negative values, see T96076):
    #     From [1.0 - 0.0] Principled BSDF range to [0.0 - 100.0] FBX shininess range)...
    fbx_shininess = max(elem_props_get_number(fbx_props, b'Shininess', 20.0), 0.0)
    ma_wrap.roughness = 1.0 - (sqrt(fbx_shininess) / 10.0)
    # Sweetness... Looks like we are not the only ones to not know exactly how FBX is supposed to work (see T59850).
    # According to one of its developers, Unity uses that formula to extract alpha value:
    #
    #   alpha = 1 - TransparencyFactor
    #   if (alpha == 1 or alpha == 0):
    #       alpha = 1 - TransparentColor.r
    #
    # Until further info, let's assume this is correct way to do, hence the following code for TransparentColor.
    # However, there are some cases (from 3DSMax, see T65065), where we do have TransparencyFactor only defined
    # in the template to 0.0, and then materials defining TransparentColor to pure white (1.0, 1.0, 1.0),
    # and setting alpha value in Opacity... try to cope with that too. :((((
    alpha = 1.0 - elem_props_get_number(fbx_props, b'TransparencyFactor', 0.0)
    if (alpha == 1.0 or alpha == 0.0):
        alpha = elem_props_get_number(fbx_props_no_template, b'Opacity', None)
        if alpha is None:
            alpha = 1.0 - elem_props_get_color_rgb(fbx_props, b'TransparentColor', const_color_black)[0]
    ma_wrap.alpha = alpha
    ma_wrap.metallic = elem_props_get_number(fbx_props, b'ReflectionFactor', 0.0)
    # We have no metallic (a.k.a. reflection) color...
    # elem_props_get_color_rgb(fbx_props, b'ReflectionColor', const_color_white)
    ma_wrap.normalmap_strength = elem_props_get_number(fbx_props, b'BumpFactor', 1.0)
    # Emission strength and color
    ma_wrap.emission_strength = elem_props_get_number(fbx_props, b'EmissiveFactor', 1.0)
    ma_wrap.emission_color = elem_props_get_color_rgb(fbx_props, b'EmissiveColor', const_color_black)

    nodal_material_wrap_map[ma] = ma_wrap

    if settings.use_custom_props:
        blen_read_custom_properties(fbx_obj, ma, settings)

    return ma


# -------
# Image & Texture

def blen_read_texture_image(fbx_tmpl, fbx_obj, basedir, settings):
    import os
    from bpy_extras import image_utils

    def pack_data_from_content(image, fbx_obj):
        data = elem_find_first_bytes(fbx_obj, b'Content')
        if (data):
            data_len = len(data)
            if (data_len):
                image.pack(data=data, data_len=data_len)

    elem_name_utf8 = elem_name_ensure_classes(fbx_obj, {b'Texture', b'Video'})

    image_cache = settings.image_cache

    # Yet another beautiful logic demonstration by Master FBX:
    # * RelativeFilename in both Video and Texture nodes.
    # * FileName in texture nodes.
    # * Filename in video nodes.
    # Aaaaaaaarrrrrrrrgggggggggggg!!!!!!!!!!!!!!
    filepath = elem_find_first_string(fbx_obj, b'RelativeFilename')
    if filepath:
        # Make sure we do handle a relative path, and not an absolute one (see D5143).
        filepath = filepath.lstrip(os.path.sep).lstrip(os.path.altsep)
        filepath = os.path.join(basedir, filepath)
    else:
        filepath = elem_find_first_string(fbx_obj, b'FileName')
    if not filepath:
        filepath = elem_find_first_string(fbx_obj, b'Filename')
    if not filepath:
        print("Error, could not find any file path in ", fbx_obj)
        print("       Falling back to: ", elem_name_utf8)
        filepath = elem_name_utf8
    else:
        filepath = filepath.replace('\\', '/') if (os.sep == '/') else filepath.replace('/', '\\')

    image = image_cache.get(filepath)
    if image is not None:
        # Data is only embedded once, we may have already created the image but still be missing its data!
        if not image.has_data:
            pack_data_from_content(image, fbx_obj)
        return image

    image = image_utils.load_image(
        filepath,
        dirname=basedir,
        place_holder=True,
        recursive=settings.use_image_search,
    )

    # Try to use embedded data, if available!
    pack_data_from_content(image, fbx_obj)

    image_cache[filepath] = image
    # name can be ../a/b/c
    image.name = os.path.basename(elem_name_utf8)

    if settings.use_custom_props:
        blen_read_custom_properties(fbx_obj, image, settings)

    return image


def blen_read_camera(fbx_tmpl, fbx_obj, settings):
    # meters to inches
    M2I = 0.0393700787

    global_scale = settings.global_scale

    elem_name_utf8 = elem_name_ensure_class(fbx_obj, b'NodeAttribute')

    fbx_props = (elem_find_first(fbx_obj, b'Properties70'),
                 elem_find_first(fbx_tmpl, b'Properties70', fbx_elem_nil))

    camera = bpy.data.cameras.new(name=elem_name_utf8)

    camera.type = 'ORTHO' if elem_props_get_enum(fbx_props, b'CameraProjectionType', 0) == 1 else 'PERSP'

    camera.dof.focus_distance = elem_props_get_number(fbx_props, b'FocusDistance', 10) * global_scale
    if (elem_props_get_bool(fbx_props, b'UseDepthOfField', False)):
        camera.dof.use_dof = True

    camera.lens = elem_props_get_number(fbx_props, b'FocalLength', 35.0)
    camera.sensor_width = elem_props_get_number(fbx_props, b'FilmWidth', 32.0 * M2I) / M2I
    camera.sensor_height = elem_props_get_number(fbx_props, b'FilmHeight', 32.0 * M2I) / M2I

    camera.ortho_scale = elem_props_get_number(fbx_props, b'OrthoZoom', 1.0)

    filmaspect = camera.sensor_width / camera.sensor_height
    # film offset
    camera.shift_x = elem_props_get_number(fbx_props, b'FilmOffsetX', 0.0) / (M2I * camera.sensor_width)
    camera.shift_y = elem_props_get_number(fbx_props, b'FilmOffsetY', 0.0) / (M2I * camera.sensor_height * filmaspect)

    camera.clip_start = elem_props_get_number(fbx_props, b'NearPlane', 0.01) * global_scale
    camera.clip_end = elem_props_get_number(fbx_props, b'FarPlane', 100.0) * global_scale

    if settings.use_custom_props:
        blen_read_custom_properties(fbx_obj, camera, settings)

    return camera


def blen_read_light(fbx_tmpl, fbx_obj, settings):
    import math
    elem_name_utf8 = elem_name_ensure_class(fbx_obj, b'NodeAttribute')

    fbx_props = (elem_find_first(fbx_obj, b'Properties70'),
                 elem_find_first(fbx_tmpl, b'Properties70', fbx_elem_nil))

    light_type = {
        0: 'POINT',
        1: 'SUN',
        2: 'SPOT'}.get(elem_props_get_enum(fbx_props, b'LightType', 0), 'POINT')

    lamp = bpy.data.lights.new(name=elem_name_utf8, type=light_type)

    if light_type == 'SPOT':
        spot_size = elem_props_get_number(fbx_props, b'OuterAngle', None)
        if spot_size is None:
            # Deprecated.
            spot_size = elem_props_get_number(fbx_props, b'Cone angle', 45.0)
        lamp.spot_size = math.radians(spot_size)

        spot_blend = elem_props_get_number(fbx_props, b'InnerAngle', None)
        if spot_blend is None:
            # Deprecated.
            spot_blend = elem_props_get_number(fbx_props, b'HotSpot', 45.0)
        lamp.spot_blend = 1.0 - (spot_blend / spot_size)

    # TODO, cycles nodes???
    lamp.color = elem_props_get_color_rgb(fbx_props, b'Color', (1.0, 1.0, 1.0))
    lamp.energy = elem_props_get_number(fbx_props, b'Intensity', 100.0) / 100.0
    lamp.exposure = elem_props_get_number(fbx_props, b'Exposure', 0.0)
    lamp.use_shadow = elem_props_get_bool(fbx_props, b'CastShadow', True)
    if hasattr(lamp, "cycles"):
        lamp.cycles.cast_shadow = lamp.use_shadow
    # Removed but could be restored if the value can be applied.
    # `lamp.shadow_color = elem_props_get_color_rgb(fbx_props, b'ShadowColor', (0.0, 0.0, 0.0))`

    if settings.use_custom_props:
        blen_read_custom_properties(fbx_obj, lamp, settings)

    return lamp


# ### Import Utility class
class FbxImportHelperNode:
    """
    Temporary helper node to store a hierarchy of fbxNode objects before building Objects, Armatures and Bones.
    It tries to keep the correction data in one place so it can be applied consistently to the imported data.
    """

    __slots__ = (
        '_parent', 'anim_compensation_matrix', 'is_global_animation', 'armature_setup', 'armature', 'bind_matrix',
        'bl_bone', 'bl_data', 'bl_obj', 'bone_child_matrix', 'children', 'clusters',
        'fbx_elem', 'fbx_data_elem', 'fbx_name', 'fbx_transform_data', 'fbx_type',
        'is_armature', 'has_bone_children', 'is_bone', 'is_root', 'is_leaf',
        'matrix', 'matrix_as_parent', 'matrix_geom', 'meshes', 'post_matrix', 'pre_matrix')

    def __init__(self, fbx_elem, bl_data, fbx_transform_data, is_bone):
        self.fbx_name = elem_name_ensure_class(fbx_elem, b'Model') if fbx_elem else 'Unknown'
        self.fbx_type = fbx_elem.props[2] if fbx_elem else None
        self.fbx_elem = fbx_elem
        # FBX elem of a connected NodeAttribute/Geometry for helpers whose bl_data
        # does not exist or is yet to be created.
        self.fbx_data_elem = None
        self.bl_obj = None
        self.bl_data = bl_data
        # Name of bone if this is a bone (this may be different to fbx_name if there was a name conflict in Blender!)
        self.bl_bone = None
        self.fbx_transform_data = fbx_transform_data
        self.is_root = False
        self.is_bone = is_bone
        self.is_armature = False
        self.armature = None                    # For bones only, relevant armature node.
        # True if the hierarchy below this node contains bones, important to support mixed hierarchies.
        self.has_bone_children = False
        # True for leaf-bones added to the end of some bone chains to set the lengths.
        self.is_leaf = False
        self.pre_matrix = None                  # correction matrix that needs to be applied before the FBX transform
        self.bind_matrix = None                 # for bones this is the matrix used to bind to the skin
        if fbx_transform_data:
            self.matrix, self.matrix_as_parent, self.matrix_geom = blen_read_object_transform_do(fbx_transform_data)
        else:
            self.matrix, self.matrix_as_parent, self.matrix_geom = (None, None, None)
        self.post_matrix = None                 # correction matrix that needs to be applied after the FBX transform
        # Objects attached to a bone end not the beginning, this matrix corrects for that.
        self.bone_child_matrix = None

        # XXX Those two are to handle the fact that rigged meshes are not linked to their armature in FBX, which implies
        #     that their animation is in global space (AFAIK...).
        #     This is actually not really solvable currently, since anim_compensation_matrix is not valid if armature
        #     itself is animated (we'd have to recompute global-to-local anim_compensation_matrix for each frame,
        #     and for each armature action... beyond being an insane work).
        #     Solution for now: do not read rigged meshes animations at all! sic...
        # a mesh moved in the hierarchy may have a different local matrix. This compensates animations for this.
        self.anim_compensation_matrix = None
        self.is_global_animation = False

        self.meshes = None                      # List of meshes influenced by this bone.
        self.clusters = []                      # Deformer Cluster nodes
        self.armature_setup = {}                # mesh and armature matrix when the mesh was bound

        self._parent = None
        self.children = []

    @property
    def parent(self):
        return self._parent

    @parent.setter
    def parent(self, value):
        if self._parent is not None:
            self._parent.children.remove(self)
        self._parent = value
        if self._parent is not None:
            self._parent.children.append(self)

    @property
    def ignore(self):
        # Separating leaf status from ignore status itself.
        # Currently they are equivalent, but this may change in future.
        return self.is_leaf

    def __repr__(self):
        if self.fbx_elem:
            return self.fbx_elem.props[1].decode()
        else:
            return "None"

    def print_info(self, indent=0):
        print(" " * indent + (self.fbx_name if self.fbx_name else "(Null)")
              + ("[root]" if self.is_root else "")
              + ("[leaf]" if self.is_leaf else "")
              + ("[ignore]" if self.ignore else "")
              + ("[armature]" if self.is_armature else "")
              + ("[bone]" if self.is_bone else "")
              + ("[HBC]" if self.has_bone_children else "")
              )
        for c in self.children:
            c.print_info(indent + 1)

    def mark_leaf_bones(self):
        if self.is_bone and len(self.children) == 1:
            child = self.children[0]
            if child.is_bone and len(child.children) == 0:
                child.is_leaf = True
        for child in self.children:
            child.mark_leaf_bones()

    def do_bake_transform(self, settings):
        return (settings.bake_space_transform and self.fbx_type in (b'Mesh', b'Null') and
                not self.is_armature and not self.is_bone)

    def find_correction_matrix(self, settings, parent_correction_inv=None):
        from bpy_extras.io_utils import axis_conversion

        if self.parent and (self.parent.is_root or self.parent.do_bake_transform(settings)):
            self.pre_matrix = settings.global_matrix

        if parent_correction_inv:
            self.pre_matrix = parent_correction_inv @ (self.pre_matrix if self.pre_matrix else Matrix())

        correction_matrix = None

        if self.is_bone:
            if settings.automatic_bone_orientation:
                # find best orientation to align bone with
                bone_children = tuple(child for child in self.children if child.is_bone)
                if len(bone_children) == 0:
                    # no children, inherit the correction from parent (if possible)
                    if self.parent and self.parent.is_bone:
                        correction_matrix = parent_correction_inv.inverted() if parent_correction_inv else None
                else:
                    # else find how best to rotate the bone to align the Y axis with the children
                    best_axis = (1, 0, 0)
                    if len(bone_children) == 1:
                        vec = bone_children[0].get_bind_matrix().to_translation()
                        best_axis = Vector((0, 0, 1 if vec[2] >= 0 else -1))
                        if abs(vec[0]) > abs(vec[1]):
                            if abs(vec[0]) > abs(vec[2]):
                                best_axis = Vector((1 if vec[0] >= 0 else -1, 0, 0))
                        elif abs(vec[1]) > abs(vec[2]):
                            best_axis = Vector((0, 1 if vec[1] >= 0 else -1, 0))
                    else:
                        # get the child directions once because they may be checked several times
                        child_locs = (child.get_bind_matrix().to_translation() for child in bone_children)
                        child_locs = tuple(loc.normalized() for loc in child_locs if loc.magnitude > 0.0)

                        # I'm not sure which one I like better...
                        if False:
                            best_angle = -1.0
                            for i in range(6):
                                a = i // 2
                                s = -1 if i % 2 == 1 else 1
                                test_axis = Vector((s if a == 0 else 0, s if a == 1 else 0, s if a == 2 else 0))

                                # find max angle to children
                                max_angle = 1.0
                                for loc in child_locs:
                                    max_angle = min(max_angle, test_axis.dot(loc))

                                # is it better than the last one?
                                if best_angle < max_angle:
                                    best_angle = max_angle
                                    best_axis = test_axis
                        else:
                            best_angle = -1.0
                            for vec in child_locs:
                                test_axis = Vector((0, 0, 1 if vec[2] >= 0 else -1))
                                if abs(vec[0]) > abs(vec[1]):
                                    if abs(vec[0]) > abs(vec[2]):
                                        test_axis = Vector((1 if vec[0] >= 0 else -1, 0, 0))
                                elif abs(vec[1]) > abs(vec[2]):
                                    test_axis = Vector((0, 1 if vec[1] >= 0 else -1, 0))

                                # find max angle to children
                                max_angle = 1.0
                                for loc in child_locs:
                                    max_angle = min(max_angle, test_axis.dot(loc))

                                # is it better than the last one?
                                if best_angle < max_angle:
                                    best_angle = max_angle
                                    best_axis = test_axis

                    # convert best_axis to axis string
                    to_up = 'Z' if best_axis[2] >= 0 else '-Z'
                    if abs(best_axis[0]) > abs(best_axis[1]):
                        if abs(best_axis[0]) > abs(best_axis[2]):
                            to_up = 'X' if best_axis[0] >= 0 else '-X'
                    elif abs(best_axis[1]) > abs(best_axis[2]):
                        to_up = 'Y' if best_axis[1] >= 0 else '-Y'
                    to_forward = 'X' if to_up not in {'X', '-X'} else 'Y'

                    # Build correction matrix
                    if (to_up, to_forward) != ('Y', 'X'):
                        correction_matrix = axis_conversion(from_forward='X',
                                                            from_up='Y',
                                                            to_forward=to_forward,
                                                            to_up=to_up,
                                                            ).to_4x4()
            else:
                correction_matrix = settings.bone_correction_matrix
        else:
            # camera and light can be hard wired
            if self.fbx_type == b'Camera':
                correction_matrix = MAT_CONVERT_CAMERA
            elif self.fbx_type == b'Light':
                correction_matrix = MAT_CONVERT_LIGHT

        self.post_matrix = correction_matrix

        if self.do_bake_transform(settings):
            self.post_matrix = settings.global_matrix_inv @ (self.post_matrix if self.post_matrix else Matrix())

        # process children
        correction_matrix_inv = correction_matrix.inverted_safe() if correction_matrix else None
        for child in self.children:
            child.find_correction_matrix(settings, correction_matrix_inv)

    def find_armature_bones(self, armature):
        for child in self.children:
            if child.is_bone:
                child.armature = armature
                child.find_armature_bones(armature)

    def find_armatures(self):
        needs_armature = False
        for child in self.children:
            if child.is_bone:
                needs_armature = True
                break
        if needs_armature:
            if self.fbx_type in {b'Null', b'Root'}:
                # if empty then convert into armature
                self.is_armature = True
                armature = self
            else:
                # otherwise insert a new node
                # XXX Maybe in case self is virtual FBX root node, we should instead add one armature per bone child?
                armature = FbxImportHelperNode(None, None, None, False)
                armature.fbx_name = "Armature"
                armature.is_armature = True

                for child in tuple(self.children):
                    if child.is_bone:
                        child.parent = armature

                armature.parent = self

            armature.find_armature_bones(armature)

        for child in self.children:
            if child.is_armature or child.is_bone:
                continue
            child.find_armatures()

    def find_bone_children(self):
        has_bone_children = False
        for child in self.children:
            has_bone_children |= child.find_bone_children()
        self.has_bone_children = has_bone_children
        return self.is_bone or has_bone_children

    def find_fake_bones(self, in_armature=False):
        if in_armature and not self.is_bone and self.has_bone_children:
            self.is_bone = True
            # if we are not a null node we need an intermediate node for the data
            if self.fbx_type not in {b'Null', b'Root'}:
                node = FbxImportHelperNode(self.fbx_elem, self.bl_data, None, False)
                self.fbx_elem = None
                self.bl_data = None

                # transfer children
                for child in self.children:
                    if child.is_bone or child.has_bone_children:
                        continue
                    child.parent = node

                # attach to parent
                node.parent = self

        if self.is_armature:
            in_armature = True
        for child in self.children:
            child.find_fake_bones(in_armature)

    def get_world_matrix_as_parent(self):
        matrix = self.parent.get_world_matrix_as_parent() if self.parent else Matrix()
        if self.matrix_as_parent:
            matrix = matrix @ self.matrix_as_parent
        return matrix

    def get_world_matrix(self):
        matrix = self.parent.get_world_matrix_as_parent() if self.parent else Matrix()
        if self.matrix:
            matrix = matrix @ self.matrix
        return matrix

    def get_matrix(self):
        matrix = self.matrix if self.matrix else Matrix()
        if self.pre_matrix:
            matrix = self.pre_matrix @ matrix
        if self.post_matrix:
            matrix = matrix @ self.post_matrix
        return matrix

    def get_bind_matrix(self):
        matrix = self.bind_matrix if self.bind_matrix else Matrix()
        if self.pre_matrix:
            matrix = self.pre_matrix @ matrix
        if self.post_matrix:
            matrix = matrix @ self.post_matrix
        return matrix

    def make_bind_pose_local(self, parent_matrix=None):
        if parent_matrix is None:
            parent_matrix = Matrix()

        if self.bind_matrix:
            bind_matrix = parent_matrix.inverted_safe() @ self.bind_matrix
        else:
            bind_matrix = self.matrix.copy() if self.matrix else None

        self.bind_matrix = bind_matrix
        if bind_matrix:
            parent_matrix = parent_matrix @ bind_matrix

        for child in self.children:
            child.make_bind_pose_local(parent_matrix)

    def collect_skeleton_meshes(self, meshes):
        for _, m in self.clusters:
            meshes.update(m)
        for child in self.children:
            if not child.meshes:
                child.collect_skeleton_meshes(meshes)

    def collect_armature_meshes(self):
        if self.is_armature:
            armature_matrix_inv = self.get_world_matrix().inverted_safe()

            meshes = set()
            for child in self.children:
                # Children meshes may be linked to children armatures, in which case we do not want to link them
                # to a parent one. See T70244.
                child.collect_armature_meshes()
                if not child.meshes:
                    child.collect_skeleton_meshes(meshes)
            for m in meshes:
                old_matrix = m.matrix
                m.matrix = armature_matrix_inv @ m.get_world_matrix()
                m.anim_compensation_matrix = old_matrix.inverted_safe() @ m.matrix
                m.is_global_animation = True
                m.parent = self
            self.meshes = meshes
        else:
            for child in self.children:
                child.collect_armature_meshes()

    def build_skeleton(self, arm, parent_matrix, settings, parent_bone_size=1):
        def child_connect(par_bone, child_bone, child_head, connect_ctx):
            # child_bone or child_head may be None.
            force_connect_children, connected = connect_ctx
            if child_bone is not None:
                child_bone.parent = par_bone
                child_head = child_bone.head

            if similar_values_iter(par_bone.tail, child_head):
                if child_bone is not None:
                    child_bone.use_connect = True
                # Disallow any force-connection at this level from now on, since that child was 'really'
                # connected, we do not want to move current bone's tail anymore!
                connected = None
            elif force_connect_children and connected is not None:
                # We only store position where tail of par_bone should be in the end.
                # Actual tail moving and force connection of compatible child bones will happen
                # once all have been checked.
                if connected is ...:
                    connected = ([child_head.copy(), 1], [child_bone] if child_bone is not None else [])
                else:
                    connected[0][0] += child_head
                    connected[0][1] += 1
                    if child_bone is not None:
                        connected[1].append(child_bone)
            connect_ctx[1] = connected

        def child_connect_finalize(par_bone, connect_ctx):
            force_connect_children, connected = connect_ctx
            # Do nothing if force connection is not enabled!
            if force_connect_children and connected is not None and connected is not ...:
                # Here again we have to be wary about zero-length bones!!!
                par_tail = connected[0][0] / connected[0][1]
                if (par_tail - par_bone.head).magnitude < 1e-2:
                    par_bone_vec = (par_bone.tail - par_bone.head).normalized()
                    par_tail = par_bone.head + par_bone_vec * 0.01
                par_bone.tail = par_tail
                for child_bone in connected[1]:
                    if similar_values_iter(par_tail, child_bone.head):
                        child_bone.use_connect = True

        # Create the (edit)bone.
        bone = arm.bl_data.edit_bones.new(name=self.fbx_name)
        bone.select = True
        self.bl_obj = arm.bl_obj
        self.bl_data = arm.bl_data
        self.bl_bone = bone.name  # Could be different from the FBX name!
        # Read EditBone custom props the NodeAttribute
        if settings.use_custom_props and self.fbx_data_elem:
            blen_read_custom_properties(self.fbx_data_elem, bone, settings)

        # get average distance to children
        bone_size = 0.0
        bone_count = 0
        for child in self.children:
            if child.is_bone:
                bone_size += child.get_bind_matrix().to_translation().magnitude
                bone_count += 1
        if bone_count > 0:
            bone_size /= bone_count
        else:
            bone_size = parent_bone_size

        # So that our bone gets its final length, but still Y-aligned in armature space.
        # 0-length bones are automatically collapsed into their parent when you leave edit mode,
        # so this enforces a minimum length.
        bone_tail = Vector((0.0, 1.0, 0.0)) * max(0.01, bone_size)
        bone.tail = bone_tail

        # And rotate/move it to its final "rest pose".
        bone_matrix = parent_matrix @ self.get_bind_matrix().normalized()

        bone.matrix = bone_matrix

        force_connect_children = settings.force_connect_children

        connect_ctx = [force_connect_children, ...]
        for child in self.children:
            if child.is_leaf and force_connect_children:
                # Arggggggggggggggggg! We do not want to create this bone, but we need its 'virtual head' location
                # to orient current one!!!
                child_head = (bone_matrix @ child.get_bind_matrix().normalized()).translation
                child_connect(bone, None, child_head, connect_ctx)
            elif child.is_bone and not child.ignore:
                child_bone = child.build_skeleton(arm, bone_matrix, settings, bone_size)
                # Connection to parent.
                child_connect(bone, child_bone, None, connect_ctx)

        child_connect_finalize(bone, connect_ctx)

        # Correction for children attached to a bone. FBX expects to attach to the head of a bone, while Blender
        # attaches to the tail.
        if force_connect_children:
            # When forcefully connecting, the bone's tail position may be changed, which can change both the bone's
            # rotation and its length.
            # Set the correction matrix such that it transforms the current tail transformation back to the original
            # head transformation.
            head_to_origin = bone.matrix.inverted_safe()
            tail_to_head = Matrix.Translation(bone.head - bone.tail)
            origin_to_original_head = bone_matrix
            tail_to_original_head = head_to_origin @ tail_to_head @ origin_to_original_head
            self.bone_child_matrix = tail_to_original_head
        else:
            self.bone_child_matrix = Matrix.Translation(-bone_tail)

        return bone

    def build_node_obj(self, fbx_tmpl, settings):
        if self.bl_obj:
            return self.bl_obj

        if self.is_bone or not self.fbx_elem:
            return None

        # create when linking since we need object data
        elem_name_utf8 = self.fbx_name

        # Object data must be created already
        self.bl_obj = obj = bpy.data.objects.new(name=elem_name_utf8, object_data=self.bl_data)

        fbx_props = (elem_find_first(self.fbx_elem, b'Properties70'),
                     elem_find_first(fbx_tmpl, b'Properties70', fbx_elem_nil))

        # ----
        # Misc Attributes

        obj.color[0:3] = elem_props_get_color_rgb(fbx_props, b'Color', (0.8, 0.8, 0.8))
        obj.hide_viewport = not bool(elem_props_get_visibility(fbx_props, b'Visibility', 1.0))

        obj.matrix_basis = self.get_matrix()

        if settings.use_custom_props:
            blen_read_custom_properties(self.fbx_elem, obj, settings)

        return obj

    def build_skeleton_children(self, fbx_tmpl, settings, scene, view_layer):
        if self.is_bone:
            for child in self.children:
                if child.ignore:
                    continue
                child.build_skeleton_children(fbx_tmpl, settings, scene, view_layer)
            return None
        else:
            # child is not a bone
            obj = self.build_node_obj(fbx_tmpl, settings)

            if obj is None:
                return None

            for child in self.children:
                if child.ignore:
                    continue
                child.build_skeleton_children(fbx_tmpl, settings, scene, view_layer)

            # instance in scene
            view_layer.active_layer_collection.collection.objects.link(obj)
            obj.select_set(True)

            return obj

    def link_skeleton_children(self, fbx_tmpl, settings, scene):
        if self.is_bone:
            for child in self.children:
                if child.ignore:
                    continue
                child_obj = child.bl_obj
                if child_obj and child_obj != self.bl_obj:
                    child_obj.parent = self.bl_obj  # get the armature the bone belongs to
                    child_obj.parent_bone = self.bl_bone
                    child_obj.parent_type = 'BONE'
                    child_obj.matrix_parent_inverse = Matrix()

                    # Blender attaches to the end of a bone, while FBX attaches to the start.
                    # bone_child_matrix corrects for that.
                    if child.pre_matrix:
                        child.pre_matrix = self.bone_child_matrix @ child.pre_matrix
                    else:
                        child.pre_matrix = self.bone_child_matrix

                    child_obj.matrix_basis = child.get_matrix()
                child.link_skeleton_children(fbx_tmpl, settings, scene)
            return None
        else:
            obj = self.bl_obj

            for child in self.children:
                if child.ignore:
                    continue
                child_obj = child.link_skeleton_children(fbx_tmpl, settings, scene)
                if child_obj:
                    child_obj.parent = obj

            return obj

    def set_pose_matrix_and_custom_props(self, arm, settings):
        pose_bone = arm.bl_obj.pose.bones[self.bl_bone]
        pose_bone.matrix_basis = self.get_bind_matrix().inverted_safe() @ self.get_matrix()

        # `self.fbx_elem` can be `None` in cases where the imported hierarchy contains a mix of bone and non-bone FBX
        # Nodes parented to one another, e.g. "bone1"->"mesh1"->"bone2". In Blender, an Armature can only consist of
        # bones, so to maintain the imported hierarchy, a placeholder bone with the same name as "mesh1" is inserted
        # into the Armature and then the imported "mesh1" Object is parented to the placeholder bone. The placeholder
        # bone won't have a `self.fbx_elem` because it belongs to the "mesh1" Object instead.
        # See FbxImportHelperNode.find_fake_bones().
        if settings.use_custom_props and self.fbx_elem:
            blen_read_custom_properties(self.fbx_elem, pose_bone, settings)

        for child in self.children:
            if child.ignore:
                continue
            if child.is_bone:
                child.set_pose_matrix_and_custom_props(arm, settings)

    def merge_weights(self, combined_weights, fbx_cluster):
        indices = elem_prop_first(elem_find_first(fbx_cluster, b'Indexes', default=None), default=())
        weights = elem_prop_first(elem_find_first(fbx_cluster, b'Weights', default=None), default=())

        for index, weight in zip(indices, weights):
            w = combined_weights.get(index)
            if w is None:
                combined_weights[index] = [weight]
            else:
                w.append(weight)

    def set_bone_weights(self):
        ignored_children = tuple(child for child in self.children
                                 if child.is_bone and child.ignore and len(child.clusters) > 0)

        if len(ignored_children) > 0:
            # If we have an ignored child bone we need to merge their weights into the current bone weights.
            # This can happen both intentionally and accidentally when skinning a model. Either way, they
            # need to be moved into a parent bone or they cause animation glitches.
            for fbx_cluster, meshes in self.clusters:
                combined_weights = {}
                self.merge_weights(combined_weights, fbx_cluster)

                for child in ignored_children:
                    for child_cluster, child_meshes in child.clusters:
                        if not meshes.isdisjoint(child_meshes):
                            self.merge_weights(combined_weights, child_cluster)

                # combine child weights
                indices = []
                weights = []
                for i, w in combined_weights.items():
                    indices.append(i)
                    if len(w) > 1:
                        # Add ignored child weights to the current bone's weight.
                        # XXX - Weights that sum to more than 1.0 get clamped to 1.0 when set in the vertex group.
                        weights.append(sum(w))
                    else:
                        weights.append(w[0])

                add_vgroup_to_objects(indices, weights, self.bl_bone, [node.bl_obj for node in meshes])

            # clusters that drive meshes not included in a parent don't need to be merged
            all_meshes = set().union(*[meshes for _, meshes in self.clusters])
            for child in ignored_children:
                for child_cluster, child_meshes in child.clusters:
                    if all_meshes.isdisjoint(child_meshes):
                        indices = elem_prop_first(elem_find_first(child_cluster, b'Indexes', default=None), default=())
                        weights = elem_prop_first(elem_find_first(child_cluster, b'Weights', default=None), default=())
                        add_vgroup_to_objects(indices, weights, self.bl_bone, [node.bl_obj for node in child_meshes])
        else:
            # set the vertex weights on meshes
            for fbx_cluster, meshes in self.clusters:
                indices = elem_prop_first(elem_find_first(fbx_cluster, b'Indexes', default=None), default=())
                weights = elem_prop_first(elem_find_first(fbx_cluster, b'Weights', default=None), default=())
                add_vgroup_to_objects(indices, weights, self.bl_bone, [node.bl_obj for node in meshes])

        for child in self.children:
            if child.is_bone and not child.ignore:
                child.set_bone_weights()

    def build_hierarchy(self, fbx_tmpl, settings, scene, view_layer):
        if self.is_armature:
            # create when linking since we need object data
            elem_name_utf8 = self.fbx_name

            self.bl_data = arm_data = bpy.data.armatures.new(name=elem_name_utf8)

            # Object data must be created already
            self.bl_obj = arm = bpy.data.objects.new(name=elem_name_utf8, object_data=arm_data)

            arm.matrix_basis = self.get_matrix()

            if self.fbx_elem:
                fbx_props = (elem_find_first(self.fbx_elem, b'Properties70'),
                             elem_find_first(fbx_tmpl, b'Properties70', fbx_elem_nil))

                if settings.use_custom_props:
                    # Read Armature Object custom props from the Node
                    blen_read_custom_properties(self.fbx_elem, arm, settings)

                    if self.fbx_data_elem:
                        # Read Armature Data custom props from the NodeAttribute
                        blen_read_custom_properties(self.fbx_data_elem, arm_data, settings)

            # instance in scene
            view_layer.active_layer_collection.collection.objects.link(arm)
            arm.select_set(True)

            # Add bones:

            # Switch to Edit mode.
            view_layer.objects.active = arm
            is_hidden = arm.hide_viewport
            arm.hide_viewport = False  # Can't switch to Edit mode hidden objects...
            bpy.ops.object.mode_set(mode='EDIT')

            for child in self.children:
                if child.ignore:
                    continue
                if child.is_bone:
                    child.build_skeleton(self, Matrix(), settings)

            bpy.ops.object.mode_set(mode='OBJECT')

            arm.hide_viewport = is_hidden

            # Set pose matrix and PoseBone custom properties
            for child in self.children:
                if child.ignore:
                    continue
                if child.is_bone:
                    child.set_pose_matrix_and_custom_props(self, settings)

            # Add bone children:
            for child in self.children:
                if child.ignore:
                    continue
                child_obj = child.build_skeleton_children(fbx_tmpl, settings, scene, view_layer)

            return arm
        elif self.fbx_elem and not self.is_bone:
            obj = self.build_node_obj(fbx_tmpl, settings)

            # walk through children
            for child in self.children:
                child.build_hierarchy(fbx_tmpl, settings, scene, view_layer)

            # instance in scene
            view_layer.active_layer_collection.collection.objects.link(obj)
            obj.select_set(True)

            return obj
        else:
            for child in self.children:
                child.build_hierarchy(fbx_tmpl, settings, scene, view_layer)

            return None

    def link_hierarchy(self, fbx_tmpl, settings, scene):
        if self.is_armature:
            arm = self.bl_obj

            # Link bone children:
            for child in self.children:
                if child.ignore:
                    continue
                child_obj = child.link_skeleton_children(fbx_tmpl, settings, scene)
                if child_obj:
                    child_obj.parent = arm

            # Add armature modifiers to the meshes
            if self.meshes:
                for mesh in self.meshes:
                    (mmat, amat) = mesh.armature_setup[self]
                    me_obj = mesh.bl_obj

                    # bring global armature & mesh matrices into *Blender* global space.
                    # Note: Usage of matrix_geom (local 'diff' transform) here is quite brittle.
                    #       Among other things, why in hell isn't it taken into account by bindpose & co???
                    #       Probably because org app (max) handles it completely aside from any parenting stuff,
                    #       which we obviously cannot do in Blender. :/
                    if amat is None:
                        amat = self.bind_matrix
                    amat = settings.global_matrix @ (Matrix() if amat is None else amat)
                    if self.matrix_geom:
                        amat = amat @ self.matrix_geom
                    mmat = settings.global_matrix @ mmat
                    if mesh.matrix_geom:
                        mmat = mmat @ mesh.matrix_geom

                    # Now that we have armature and mesh in there (global) bind 'state' (matrix),
                    # we can compute inverse parenting matrix of the mesh.
                    me_obj.matrix_parent_inverse = amat.inverted_safe() @ mmat @ me_obj.matrix_basis.inverted_safe()

                    mod = mesh.bl_obj.modifiers.new(arm.name, 'ARMATURE')
                    mod.object = arm

            # Add bone weights to the deformers
            for child in self.children:
                if child.ignore:
                    continue
                if child.is_bone:
                    child.set_bone_weights()

            return arm
        elif self.bl_obj:
            obj = self.bl_obj

            # walk through children
            for child in self.children:
                child_obj = child.link_hierarchy(fbx_tmpl, settings, scene)
                if child_obj:
                    child_obj.parent = obj

            return obj
        else:
            for child in self.children:
                child.link_hierarchy(fbx_tmpl, settings, scene)

            return None


def load(operator, context, filepath="",
         use_manual_orientation=False,
         axis_forward='-Z',
         axis_up='Y',
         global_scale=1.0,
         bake_space_transform=False,
         use_custom_normals=True,
         use_image_search=False,
         use_alpha_decals=False,
         decal_offset=0.0,
         use_anim=True,
         anim_offset=1.0,
         use_subsurf=False,
         use_custom_props=True,
         use_custom_props_enum_as_string=True,
         ignore_leaf_bones=False,
         force_connect_children=False,
         automatic_bone_orientation=False,
         primary_bone_axis='Y',
         secondary_bone_axis='X',
         use_prepost_rot=True,
         colors_type='SRGB',
         mtl_name_collision_mode="MAKE_UNIQUE"):

    global fbx_elem_nil
    fbx_elem_nil = FBXElem('', (), (), ())

    import os
    import time
    from bpy_extras.io_utils import axis_conversion

    from . import parse_fbx
    from .fbx_utils import RIGHT_HAND_AXES, FBX_FRAMERATES

    start_time_proc = time.process_time()
    start_time_sys = time.time()

    perfmon = PerfMon()
    perfmon.level_up()
    perfmon.step("FBX Import: start importing %s" % filepath)
    perfmon.level_up()

    # Detect ASCII files.

    # Typically it's bad practice to fail silently on any error,
    # however the file may fail to read for many reasons,
    # and this situation is handled later in the code,
    # right now we only want to know if the file successfully reads as ascii.
    try:
        with open(filepath, 'r', encoding="utf-8") as fh:
            fh.read(24)
        is_ascii = True
    except Exception:
        is_ascii = False

    if is_ascii:
        operator.report({'ERROR'}, rpt_("ASCII FBX files are not supported %r") % filepath)
        return {'CANCELLED'}
    del is_ascii
    # End ascii detection.

    try:
        elem_root, version = parse_fbx.parse(filepath)
    except Exception as e:
        import traceback
        traceback.print_exc()

        operator.report({'ERROR'}, rpt_("Couldn't open file %r (%s)") % (filepath, e))
        return {'CANCELLED'}

    if version < 7100:
        operator.report({'ERROR'}, rpt_("Version %r unsupported, must be %r or later") % (version, 7100))
        return {'CANCELLED'}

    print("FBX version: %r" % version)

    if bpy.ops.object.mode_set.poll():
        bpy.ops.object.mode_set(mode='OBJECT', toggle=False)

    # deselect all
    if bpy.ops.object.select_all.poll():
        bpy.ops.object.select_all(action='DESELECT')

    basedir = os.path.dirname(filepath)

    nodal_material_wrap_map = {}
    image_cache = {}

    # Tables: (FBX_byte_id -> [FBX_data, None or Blender_datablock])
    fbx_table_nodes = {}

    if use_alpha_decals:
        material_decals = set()
    else:
        material_decals = None

    scene = context.scene
    view_layer = context.view_layer

    # #### Get some info from GlobalSettings.

    perfmon.step("FBX import: Prepare...")

    fbx_settings = elem_find_first(elem_root, b'GlobalSettings')
    fbx_settings_props = elem_find_first(fbx_settings, b'Properties70')
    if fbx_settings is None or fbx_settings_props is None:
        operator.report({'ERROR'}, rpt_("No 'GlobalSettings' found in file %r") % filepath)
        return {'CANCELLED'}

    # FBX default base unit seems to be the centimeter, while raw Blender Unit is equivalent to the meter...
    unit_scale = elem_props_get_number(fbx_settings_props, b'UnitScaleFactor', 1.0)
    unit_scale_org = elem_props_get_number(fbx_settings_props, b'OriginalUnitScaleFactor', 1.0)
    global_scale *= (unit_scale / units_blender_to_fbx_factor(context.scene))
    # Compute global matrix and scale.
    if not use_manual_orientation:
        axis_forward = (elem_props_get_integer(fbx_settings_props, b'FrontAxis', 1),
                        elem_props_get_integer(fbx_settings_props, b'FrontAxisSign', 1))
        axis_up = (elem_props_get_integer(fbx_settings_props, b'UpAxis', 2),
                   elem_props_get_integer(fbx_settings_props, b'UpAxisSign', 1))
        axis_coord = (elem_props_get_integer(fbx_settings_props, b'CoordAxis', 0),
                      elem_props_get_integer(fbx_settings_props, b'CoordAxisSign', 1))
        axis_key = (axis_up, axis_forward, axis_coord)
        axis_up, axis_forward = {v: k for k, v in RIGHT_HAND_AXES.items()}.get(axis_key, ('Z', 'Y'))
    global_matrix = (Matrix.Scale(global_scale, 4) @
                     axis_conversion(from_forward=axis_forward, from_up=axis_up).to_4x4())

    # To cancel out unwanted rotation/scale on nodes.
    global_matrix_inv = global_matrix.inverted()
    # For transforming mesh normals.
    global_matrix_inv_transposed = global_matrix_inv.transposed()

    # Compute bone correction matrix
    bone_correction_matrix = None  # None means no correction/identity
    if not automatic_bone_orientation:
        if (primary_bone_axis, secondary_bone_axis) != ('Y', 'X'):
            bone_correction_matrix = axis_conversion(from_forward='X',
                                                     from_up='Y',
                                                     to_forward=secondary_bone_axis,
                                                     to_up=primary_bone_axis,
                                                     ).to_4x4()

    # Compute frame-rate settings.
    custom_fps = elem_props_get_number(fbx_settings_props, b'CustomFrameRate', 25.0)
    time_mode = elem_props_get_enum(fbx_settings_props, b'TimeMode')
    real_fps = {eid: val for val, eid in FBX_FRAMERATES[1:]}.get(time_mode, custom_fps)
    if real_fps <= 0.0:
        real_fps = 25.0
    scene.render.fps = round(real_fps)
    scene.render.fps_base = scene.render.fps / real_fps

    # store global settings that need to be accessed during conversion
    settings = FBXImportSettings(
        operator.report, (axis_up, axis_forward), global_matrix, global_scale,
        bake_space_transform, global_matrix_inv, global_matrix_inv_transposed,
        use_custom_normals, use_image_search,
        use_alpha_decals, decal_offset,
        use_anim, anim_offset,
        use_subsurf,
        use_custom_props, use_custom_props_enum_as_string,
        nodal_material_wrap_map, image_cache,
        ignore_leaf_bones, force_connect_children, automatic_bone_orientation, bone_correction_matrix,
        use_prepost_rot, colors_type, mtl_name_collision_mode,
    )

    # #### And now, the "real" data.

    perfmon.step("FBX import: Templates...")

    fbx_defs = elem_find_first(elem_root, b'Definitions')  # can be None
    fbx_nodes = elem_find_first(elem_root, b'Objects')
    fbx_connections = elem_find_first(elem_root, b'Connections')

    if fbx_nodes is None:
        operator.report({'ERROR'}, rpt_("No 'Objects' found in file %r") % filepath)
        return {'CANCELLED'}
    if fbx_connections is None:
        operator.report({'ERROR'}, rpt_("No 'Connections' found in file %r") % filepath)
        return {'CANCELLED'}

    # ----
    # First load property templates
    # Load 'PropertyTemplate' values.
    # Key is a tuple, (ObjectType, FBXNodeType)
    # eg, (b'Texture', b'KFbxFileTexture')
    #     (b'Geometry', b'KFbxMesh')
    fbx_templates = {}

    def _():
        if fbx_defs is not None:
            for fbx_def in fbx_defs.elems:
                if fbx_def.id == b'ObjectType':
                    for fbx_subdef in fbx_def.elems:
                        if fbx_subdef.id == b'PropertyTemplate':
                            assert fbx_def.props_type == b'S'
                            assert fbx_subdef.props_type == b'S'
                            # (b'Texture', b'KFbxFileTexture') - eg.
                            key = fbx_def.props[0], fbx_subdef.props[0]
                            fbx_templates[key] = fbx_subdef
    _()
    del _

    def fbx_template_get(key):
        ret = fbx_templates.get(key, fbx_elem_nil)
        if ret is fbx_elem_nil:
            # Newest FBX (7.4 and above) use no more 'K' in their type names...
            key = (key[0], key[1][1:])
            return fbx_templates.get(key, fbx_elem_nil)
        return ret

    perfmon.step("FBX import: Nodes...")

    # ----
    # Build FBX node-table
    def _():
        for fbx_obj in fbx_nodes.elems:
            # TODO, investigate what other items after first 3 may be
            assert fbx_obj.props_type[:3] == b'LSS'
            fbx_uuid = elem_uuid(fbx_obj)
            fbx_table_nodes[fbx_uuid] = [fbx_obj, None]
    _()
    del _

    # ----
    # Load in the data
    # http://download.autodesk.com/us/fbx/20112/FBX_SDK_HELP/index.html?url=
    #        WS73099cc142f487551fea285e1221e4f9ff8-7fda.htm,topicNumber=d0e6388

    perfmon.step("FBX import: Connections...")

    fbx_connection_map = {}
    fbx_connection_map_reverse = {}

    def _():
        for fbx_link in fbx_connections.elems:
            c_type = fbx_link.props[0]
            if fbx_link.props_type[1:3] == b'LL':
                c_src, c_dst = fbx_link.props[1:3]
                fbx_connection_map.setdefault(c_src, []).append((c_dst, fbx_link))
                fbx_connection_map_reverse.setdefault(c_dst, []).append((c_src, fbx_link))
    _()
    del _

    perfmon.step("FBX import: Meshes...")

    # ----
    # Load mesh data
    def _():
        fbx_tmpl = fbx_template_get((b'Geometry', b'KFbxMesh'))

        for fbx_uuid, fbx_item in fbx_table_nodes.items():
            fbx_obj, blen_data = fbx_item
            if fbx_obj.id != b'Geometry':
                continue
            if fbx_obj.props[-1] == b'Mesh':
                assert blen_data is None
                fbx_item[1] = blen_read_geom(fbx_tmpl, fbx_obj, settings)
    _()
    del _

    perfmon.step("FBX import: Materials & Textures...")

    # ----
    # Load material data
    def _():
        fbx_tmpl = fbx_template_get((b'Material', b'KFbxSurfacePhong'))
        # b'KFbxSurfaceLambert'

        for fbx_uuid, fbx_item in fbx_table_nodes.items():
            fbx_obj, blen_data = fbx_item
            if fbx_obj.id != b'Material':
                continue
            assert blen_data is None
            fbx_item[1] = blen_read_material(fbx_tmpl, fbx_obj, settings)
    _()
    del _

    # ----
    # Load image & textures data
    def _():
        fbx_tmpl_tex = fbx_template_get((b'Texture', b'KFbxFileTexture'))
        fbx_tmpl_img = fbx_template_get((b'Video', b'KFbxVideo'))

        # Important to run all 'Video' ones first, embedded images are stored in those nodes.
        # XXX Note we simplify things here, assuming both matching Video and Texture will use same file path,
        #     this may be a bit weak, if issue arise we'll fallback to plain connection stuff...
        for fbx_uuid, fbx_item in fbx_table_nodes.items():
            fbx_obj, blen_data = fbx_item
            if fbx_obj.id != b'Video':
                continue
            fbx_item[1] = blen_read_texture_image(fbx_tmpl_img, fbx_obj, basedir, settings)
        for fbx_uuid, fbx_item in fbx_table_nodes.items():
            fbx_obj, blen_data = fbx_item
            if fbx_obj.id != b'Texture':
                continue
            fbx_item[1] = blen_read_texture_image(fbx_tmpl_tex, fbx_obj, basedir, settings)
    _()
    del _

    perfmon.step("FBX import: Cameras & Lamps...")

    # ----
    # Load camera data
    def _():
        fbx_tmpl = fbx_template_get((b'NodeAttribute', b'KFbxCamera'))

        for fbx_uuid, fbx_item in fbx_table_nodes.items():
            fbx_obj, blen_data = fbx_item
            if fbx_obj.id != b'NodeAttribute':
                continue
            if fbx_obj.props[-1] == b'Camera':
                assert blen_data is None
                fbx_item[1] = blen_read_camera(fbx_tmpl, fbx_obj, settings)
    _()
    del _

    # ----
    # Load lamp data
    def _():
        fbx_tmpl = fbx_template_get((b'NodeAttribute', b'KFbxLight'))

        for fbx_uuid, fbx_item in fbx_table_nodes.items():
            fbx_obj, blen_data = fbx_item
            if fbx_obj.id != b'NodeAttribute':
                continue
            if fbx_obj.props[-1] == b'Light':
                assert blen_data is None
                fbx_item[1] = blen_read_light(fbx_tmpl, fbx_obj, settings)
    _()
    del _

    # ----
    # Connections
    def connection_filter_ex(fbx_uuid, fbx_id, dct):
        return [(c_found[0], c_found[1], c_type)
                for (c_uuid, c_type) in dct.get(fbx_uuid, ())
                # 0 is used for the root node, which isn't in fbx_table_nodes
                for c_found in (() if c_uuid == 0 else (fbx_table_nodes.get(c_uuid, (None, None)),))
                if (fbx_id is None) or (c_found[0] and c_found[0].id == fbx_id)]

    def connection_filter_forward(fbx_uuid, fbx_id):
        return connection_filter_ex(fbx_uuid, fbx_id, fbx_connection_map)

    def connection_filter_reverse(fbx_uuid, fbx_id):
        return connection_filter_ex(fbx_uuid, fbx_id, fbx_connection_map_reverse)

    perfmon.step("FBX import: Objects & Armatures...")

    # -- temporary helper hierarchy to build armatures and objects from
    # lookup from uuid to helper node. Used to build parent-child relations and later to look up animated nodes.
    fbx_helper_nodes = {}

    def _():
        # We build an intermediate hierarchy used to:
        # - Calculate and store bone orientation correction matrices. The same matrices will be reused for animation.
        # - Find/insert armature nodes.
        # - Filter leaf bones.

        # create scene root
        fbx_helper_nodes[0] = root_helper = FbxImportHelperNode(None, None, None, False)
        root_helper.is_root = True

        # add fbx nodes
        fbx_tmpl = fbx_template_get((b'Model', b'KFbxNode'))
        for a_uuid, a_item in fbx_table_nodes.items():
            fbx_obj, bl_data = a_item
            if fbx_obj is None or fbx_obj.id != b'Model':
                continue

            fbx_props = (elem_find_first(fbx_obj, b'Properties70'),
                         elem_find_first(fbx_tmpl, b'Properties70', fbx_elem_nil))

            transform_data = blen_read_object_transform_preprocess(fbx_props, fbx_obj, Matrix(), use_prepost_rot)
            # Note: 'Root' "bones" are handled as (armature) objects.
            # Note: See T46912 for first FBX file I ever saw with 'Limb' bones - thought those were totally deprecated.
            is_bone = fbx_obj.props[2] in {b'LimbNode', b'Limb'}
            fbx_helper_nodes[a_uuid] = FbxImportHelperNode(fbx_obj, bl_data, transform_data, is_bone)

        # add parent-child relations and add blender data to the node
        for fbx_link in fbx_connections.elems:
            if fbx_link.props[0] != b'OO':
                continue
            if fbx_link.props_type[1:3] == b'LL':
                c_src, c_dst = fbx_link.props[1:3]
                parent = fbx_helper_nodes.get(c_dst)
                if parent is None:
                    continue

                child = fbx_helper_nodes.get(c_src)
                if child is None:
                    # add blender data (meshes, lights, cameras, etc.) to a helper node
                    fbx_sdata, bl_data = p_item = fbx_table_nodes.get(c_src, (None, None))
                    if fbx_sdata is None:
                        continue
                    if fbx_sdata.id not in {b'Geometry', b'NodeAttribute'}:
                        continue
                    parent.bl_data = bl_data
                    if bl_data is None:
                        # If there's no bl_data, add the fbx_sdata so that it can be read when creating the bl_data/bone
                        parent.fbx_data_elem = fbx_sdata
                else:
                    # set parent
                    child.parent = parent

        # find armatures (either an empty below a bone or a new node inserted at the bone
        root_helper.find_armatures()

        # mark nodes that have bone children
        root_helper.find_bone_children()

        # mark nodes that need a bone to attach child-bones to
        root_helper.find_fake_bones()

        # mark leaf nodes that are only required to mark the end of their parent bone
        if settings.ignore_leaf_bones:
            root_helper.mark_leaf_bones()

        # What a mess! Some bones have several BindPoses, some have none, clusters contain a bind pose as well,
        # and you can have several clusters per bone!
        # Maybe some conversion can be applied to put them all into the same frame of reference?

        # get the bind pose from pose elements
        for a_uuid, a_item in fbx_table_nodes.items():
            fbx_obj, bl_data = a_item
            if fbx_obj is None:
                continue
            if fbx_obj.id != b'Pose':
                continue
            if fbx_obj.props[2] != b'BindPose':
                continue
            for fbx_pose_node in fbx_obj.elems:
                if fbx_pose_node.id != b'PoseNode':
                    continue
                node_elem = elem_find_first(fbx_pose_node, b'Node')
                node = elem_uuid(node_elem)
                matrix_elem = elem_find_first(fbx_pose_node, b'Matrix')
                matrix = array_to_matrix4(matrix_elem.props[0]) if matrix_elem else None
                bone = fbx_helper_nodes.get(node)
                if bone and matrix:
                    # Store the matrix in the helper node.
                    # There may be several bind pose matrices for the same node, but in tests they seem to be identical.
                    bone.bind_matrix = matrix  # global space

        # get clusters and bind pose
        for helper_uuid, helper_node in fbx_helper_nodes.items():
            if not helper_node.is_bone:
                continue
            for cluster_uuid, cluster_link in fbx_connection_map.get(helper_uuid, ()):
                if cluster_link.props[0] != b'OO':
                    continue
                fbx_cluster, _ = fbx_table_nodes.get(cluster_uuid, (None, None))
                if fbx_cluster is None or fbx_cluster.id != b'Deformer' or fbx_cluster.props[2] != b'Cluster':
                    continue

                # Get the bind pose from the cluster:
                tx_mesh_elem = elem_find_first(fbx_cluster, b'Transform', default=None)
                tx_mesh = array_to_matrix4(tx_mesh_elem.props[0]) if tx_mesh_elem else Matrix()

                tx_bone_elem = elem_find_first(fbx_cluster, b'TransformLink', default=None)
                tx_bone = array_to_matrix4(tx_bone_elem.props[0]) if tx_bone_elem else None

                tx_arm_elem = elem_find_first(fbx_cluster, b'TransformAssociateModel', default=None)
                tx_arm = array_to_matrix4(tx_arm_elem.props[0]) if tx_arm_elem else None

                mesh_matrix = tx_mesh
                armature_matrix = tx_arm

                if tx_bone:
                    mesh_matrix = tx_bone @ mesh_matrix
                    helper_node.bind_matrix = tx_bone  # overwrite the bind matrix

                # Get the meshes driven by this cluster: (Shouldn't that be only one?)
                meshes = set()
                for skin_uuid, skin_link in fbx_connection_map.get(cluster_uuid):
                    if skin_link.props[0] != b'OO':
                        continue
                    fbx_skin, _ = fbx_table_nodes.get(skin_uuid, (None, None))
                    if fbx_skin is None or fbx_skin.id != b'Deformer' or fbx_skin.props[2] != b'Skin':
                        continue
                    skin_connection = fbx_connection_map.get(skin_uuid)
                    if skin_connection is None:
                        continue
                    for mesh_uuid, mesh_link in skin_connection:
                        if mesh_link.props[0] != b'OO':
                            continue
                        fbx_mesh, _ = fbx_table_nodes.get(mesh_uuid, (None, None))
                        if fbx_mesh is None or fbx_mesh.id != b'Geometry' or fbx_mesh.props[2] != b'Mesh':
                            continue
                        for object_uuid, object_link in fbx_connection_map.get(mesh_uuid):
                            if object_link.props[0] != b'OO':
                                continue
                            mesh_node = fbx_helper_nodes[object_uuid]
                            if mesh_node:
                                # ----
                                # If we get a valid mesh matrix (in bone space), store armature and
                                # mesh global matrices, we need them to compute mesh's matrix_parent_inverse
                                # when actually binding them via the modifier.
                                # Note we assume all bones were bound with the same mesh/armature (global) matrix,
                                # we do not support otherwise in Blender anyway!
                                mesh_node.armature_setup[helper_node.armature] = (mesh_matrix, armature_matrix)
                                meshes.add(mesh_node)

                helper_node.clusters.append((fbx_cluster, meshes))

        # convert bind poses from global space into local space
        root_helper.make_bind_pose_local()

        # collect armature meshes
        root_helper.collect_armature_meshes()

        # find the correction matrices to align FBX objects with their Blender equivalent
        root_helper.find_correction_matrix(settings)

        # build the Object/Armature/Bone hierarchy
        root_helper.build_hierarchy(fbx_tmpl, settings, scene, view_layer)

        # Link the Object/Armature/Bone hierarchy
        root_helper.link_hierarchy(fbx_tmpl, settings, scene)

        # root_helper.print_info(0)
    _()
    del _

    perfmon.step("FBX import: ShapeKeys...")

    # We can handle shapes.
    blend_shape_channels = {}  # We do not need Shapes themselves, but keyblocks, for anim.

    def _():
        fbx_tmpl = fbx_template_get((b'Geometry', b'KFbxShape'))

        # - FBX             | - Blender equivalent
        # Mesh              | `Mesh`
        # BlendShape        | `Key`
        # BlendShapeChannel | `ShapeKey`, but without its `.data`.
        # Shape             | `ShapeKey.data`, but also includes normals and the values are relative to the base Mesh
        #                   | instead of being absolute. The data is sparse, so each Shape has an "Indexes" array too.
        #                   | FBX 2020 introduced 'Modern Style' Shapes that also support tangents, binormals, vertex
        #                   | colors and UVs, and can be absolute values instead of relative, but 'Modern Style' Shapes
        #                   | are not currently supported.
        #
        # The FBX connections between Shapes and Meshes form multiple many-many relationships:
        # Mesh >-< BlendShape >-< BlendShapeChannel >-< Shape
        # In practice, the relationships are almost never many-many and are more typically 1-many or 1-1:
        #   Mesh --- BlendShape:
        #     usually 1-1 and the FBX SDK might enforce that each BlendShape is connected to at most one Mesh.
        #   BlendShape --< BlendShapeChannel:
        #     usually 1-many.
        #   BlendShapeChannel --- or uncommonly --< Shape:
        #     usually 1-1, but 1-many is a documented feature.

        def connections_gen(c_src_uuid, fbx_id, fbx_type):
            """Helper to reduce duplicate code"""
            # Rarely, an imported FBX file will have duplicate connections. For Shape Key related connections, FBX
            # appears to ignore the duplicates, or overwrite the existing duplicates such that the end result is the
            # same as ignoring them, so keep a set of the seen connections and ignore any duplicates.
            seen_connections = set()
            for c_dst_uuid, ctype in fbx_connection_map.get(c_src_uuid, ()):
                if ctype.props[0] != b'OO':
                    # 'Object-Object' connections only.
                    continue
                fbx_data, bl_data = fbx_table_nodes.get(c_dst_uuid, (None, None))
                if fbx_data is None or fbx_data.id != fbx_id or fbx_data.props[2] != fbx_type:
                    # Either `c_dst_uuid` doesn't exist, or it has a different id or type.
                    continue
                connection_key = (c_src_uuid, c_dst_uuid)
                if connection_key in seen_connections:
                    # The connection is a duplicate, skip it.
                    continue
                seen_connections.add(connection_key)
                yield c_dst_uuid, fbx_data, bl_data

        # XXX - Multiple Shapes can be assigned to a single BlendShapeChannel to create a progressive blend between the
        #       base mesh and the assigned Shapes, with the percentage at which each Shape is fully blended being stored
        #       in the BlendShapeChannel's FullWeights array. This is also known as 'in-between shapes'.
        #       We don't have any support for in-between shapes currently.
        blend_shape_channel_to_shapes = {}
        mesh_to_shapes = {}
        for s_uuid, (fbx_sdata, _bl_sdata) in fbx_table_nodes.items():
            if fbx_sdata is None or fbx_sdata.id != b'Geometry' or fbx_sdata.props[2] != b'Shape':
                continue

            # shape -> blend-shape-channel -> blend-shape -> mesh.
            for bc_uuid, fbx_bcdata, _bl_bcdata in connections_gen(s_uuid, b'Deformer', b'BlendShapeChannel'):
                # Track the Shapes connected to each BlendShapeChannel.
                shapes_assigned_to_channel = blend_shape_channel_to_shapes.setdefault(bc_uuid, [])
                shapes_assigned_to_channel.append(s_uuid)
                for bs_uuid, _fbx_bsdata, _bl_bsdata in connections_gen(bc_uuid, b'Deformer', b'BlendShape'):
                    for m_uuid, _fbx_mdata, bl_mdata in connections_gen(bs_uuid, b'Geometry', b'Mesh'):
                        # Blenmeshes are assumed already created at that time!
                        assert isinstance(bl_mdata, bpy.types.Mesh)
                        # Group shapes by mesh so that each mesh only needs to be processed once for all of its shape
                        # keys.
                        if bl_mdata not in mesh_to_shapes:
                            # And we have to find all objects using this mesh!
                            objects = []
                            for o_uuid, o_ctype in fbx_connection_map.get(m_uuid, ()):
                                if o_ctype.props[0] != b'OO':
                                    continue
                                node = fbx_helper_nodes[o_uuid]
                                if node:
                                    objects.append(node)
                            shapes_list = []
                            mesh_to_shapes[bl_mdata] = (objects, shapes_list)
                        else:
                            shapes_list = mesh_to_shapes[bl_mdata][1]
                        # Only the number of shapes assigned to each BlendShapeChannel needs to be passed through to
                        # `blen_read_shapes`, but that number isn't known until all the connections have been
                        # iterated, so pass the `shapes_assigned_to_channel` list instead.
                        shapes_list.append((bc_uuid, fbx_sdata, fbx_bcdata, shapes_assigned_to_channel))
                    # BlendShape deformers are only here to connect BlendShapeChannels to meshes, nothing else to do.

        # Iterate through each mesh and create its shape keys
        for bl_mdata, (objects, shapes) in mesh_to_shapes.items():
            for bc_uuid, keyblocks in blen_read_shapes(fbx_tmpl, shapes, objects, bl_mdata, scene).items():
                # keyblocks is a list of tuples (mesh, key-block)
                # matching that shape/blend-shape-channel, for animation.
                blend_shape_channels.setdefault(bc_uuid, []).extend(keyblocks)
    _()
    del _

    if settings.use_subsurf:
        perfmon.step("FBX import: Subdivision surfaces")

        # Look through connections for subsurf in meshes and add it to the parent object
        def _():
            for fbx_link in fbx_connections.elems:
                if fbx_link.props[0] != b'OO':
                    continue
                if fbx_link.props_type[1:3] == b'LL':
                    c_src, c_dst = fbx_link.props[1:3]
                    parent = fbx_helper_nodes.get(c_dst)
                    if parent is None:
                        continue

                    child = fbx_helper_nodes.get(c_src)
                    if child is None:
                        fbx_sdata, bl_data = fbx_table_nodes.get(c_src, (None, None))
                        if fbx_sdata.id != b'Geometry':
                            continue

                        preview_levels = elem_prop_first(elem_find_first(fbx_sdata, b'PreviewDivisionLevels'))
                        render_levels = elem_prop_first(elem_find_first(fbx_sdata, b'RenderDivisionLevels'))
                        if isinstance(preview_levels, int) and isinstance(render_levels, int):
                            mod = parent.bl_obj.modifiers.new('subsurf', 'SUBSURF')
                            mod.levels = preview_levels
                            mod.render_levels = render_levels
                            boundary_rule = elem_prop_first(elem_find_first(fbx_sdata, b'BoundaryRule'), default=1)
                            if boundary_rule == 1:
                                mod.boundary_smooth = "PRESERVE_CORNERS"
                            else:
                                mod.boundary_smooth = "ALL"

        _()
        del _

    if use_anim:
        perfmon.step("FBX import: Animations...")

        # Animation!
        def _():
            # Find the number of "ktimes" per second for this file.
            # Start with the default for this FBX version.
            fbx_ktime = FBX_KTIME_V8 if version >= 8000 else FBX_KTIME_V7
            # Try to find the value of the nested elem_root->'FBXHeaderExtension'->'OtherFlags'->'TCDefinition' element
            # and look up the "ktimes" per second for its value.
            if header := elem_find_first(elem_root, b'FBXHeaderExtension'):
                # The header version that added TCDefinition support is 1004.
                if elem_prop_first(elem_find_first(header, b'FBXHeaderVersion'), default=0) >= 1004:
                    if other_flags := elem_find_first(header, b'OtherFlags'):
                        if timecode_definition := elem_find_first(other_flags, b'TCDefinition'):
                            timecode_definition_value = elem_prop_first(timecode_definition)
                            # If its value is unknown or missing, default to FBX_KTIME_V8.
                            fbx_ktime = FBX_TIMECODE_DEFINITION_TO_KTIME_PER_SECOND.get(timecode_definition_value,
                                                                                        FBX_KTIME_V8)

            fbx_tmpl_astack = fbx_template_get((b'AnimationStack', b'FbxAnimStack'))
            fbx_tmpl_alayer = fbx_template_get((b'AnimationLayer', b'FbxAnimLayer'))
            stacks = {}

            # AnimationStacks.
            for as_uuid, fbx_asitem in fbx_table_nodes.items():
                fbx_asdata, _blen_data = fbx_asitem
                if fbx_asdata.id != b'AnimationStack' or fbx_asdata.props[2] != b'':
                    continue
                stacks[as_uuid] = (fbx_asitem, {})

            # AnimationLayers
            # (mixing is completely ignored for now, each layer results in an independent set of actions).
            def get_astacks_from_alayer(al_uuid):
                for as_uuid, as_ctype in fbx_connection_map.get(al_uuid, ()):
                    if as_ctype.props[0] != b'OO':
                        continue
                    fbx_asdata, _bl_asdata = fbx_table_nodes.get(as_uuid, (None, None))
                    if (fbx_asdata is None or fbx_asdata.id != b'AnimationStack' or
                            fbx_asdata.props[2] != b'' or as_uuid not in stacks):
                        continue
                    yield as_uuid
            for al_uuid, fbx_alitem in fbx_table_nodes.items():
                fbx_aldata, _blen_data = fbx_alitem
                if fbx_aldata.id != b'AnimationLayer' or fbx_aldata.props[2] != b'':
                    continue
                for as_uuid in get_astacks_from_alayer(al_uuid):
                    _fbx_asitem, alayers = stacks[as_uuid]
                    alayers[al_uuid] = (fbx_alitem, {})

            # AnimationCurveNodes (also the ones linked to actual animated data!).
            curvenodes = {}
            for acn_uuid, fbx_acnitem in fbx_table_nodes.items():
                fbx_acndata, _blen_data = fbx_acnitem
                if fbx_acndata.id != b'AnimationCurveNode' or fbx_acndata.props[2] != b'':
                    continue
                cnode = curvenodes[acn_uuid] = {}
                items = []
                for n_uuid, n_ctype in fbx_connection_map.get(acn_uuid, ()):
                    if n_ctype.props[0] != b'OP':
                        continue
                    lnk_prop = n_ctype.props[3]
                    if lnk_prop in {b'Lcl Translation', b'Lcl Rotation', b'Lcl Scaling'}:
                        # n_uuid can (????) be linked to root '0' node, instead of a mere object node... See T41712.
                        ob = fbx_helper_nodes.get(n_uuid, None)
                        if ob is None or ob.is_root:
                            continue
                        items.append((ob, lnk_prop))
                    elif lnk_prop == b'DeformPercent':  # Shape keys.
                        keyblocks = blend_shape_channels.get(n_uuid, None)
                        if keyblocks is None:
                            continue
                        items += [(kb, lnk_prop) for kb in keyblocks]
                    elif lnk_prop == b'FocalLength':  # Camera lens.
                        from bpy.types import Camera
                        fbx_item = fbx_table_nodes.get(n_uuid, None)
                        if fbx_item is None or not isinstance(fbx_item[1], Camera):
                            continue
                        cam = fbx_item[1]
                        items.append((cam, lnk_prop))
                    elif lnk_prop == b'FocusDistance':  # Camera focus.
                        from bpy.types import Camera
                        fbx_item = fbx_table_nodes.get(n_uuid, None)
                        if fbx_item is None or not isinstance(fbx_item[1], Camera):
                            continue
                        cam = fbx_item[1]
                        items.append((cam, lnk_prop))
                    elif lnk_prop == b'DiffuseColor':
                        from bpy.types import Material
                        fbx_item = fbx_table_nodes.get(n_uuid, None)
                        if fbx_item is None or not isinstance(fbx_item[1], Material):
                            continue
                        mat = fbx_item[1]
                        items.append((mat, lnk_prop))
                        print("WARNING! Importing material's animation is not supported for Nodal materials...")
                for al_uuid, al_ctype in fbx_connection_map.get(acn_uuid, ()):
                    if al_ctype.props[0] != b'OO':
                        continue
                    fbx_aldata, _blen_aldata = fbx_alitem = fbx_table_nodes.get(al_uuid, (None, None))
                    if fbx_aldata is None or fbx_aldata.id != b'AnimationLayer' or fbx_aldata.props[2] != b'':
                        continue
                    for as_uuid in get_astacks_from_alayer(al_uuid):
                        _fbx_alitem, anim_items = stacks[as_uuid][1][al_uuid]
                        assert _fbx_alitem == fbx_alitem
                        for item, item_prop in items:
                            # No need to keep curve-node FBX data here, contains nothing useful for us.
                            anim_items.setdefault(item, {})[acn_uuid] = (cnode, item_prop)

            # AnimationCurves (real animation data).
            for ac_uuid, fbx_acitem in fbx_table_nodes.items():
                fbx_acdata, _blen_data = fbx_acitem
                if fbx_acdata.id != b'AnimationCurve' or fbx_acdata.props[2] != b'':
                    continue
                for acn_uuid, acn_ctype in fbx_connection_map.get(ac_uuid, ()):
                    if acn_ctype.props[0] != b'OP':
                        continue
                    fbx_acndata, _bl_acndata = fbx_table_nodes.get(acn_uuid, (None, None))
                    if (fbx_acndata is None or fbx_acndata.id != b'AnimationCurveNode' or
                            fbx_acndata.props[2] != b'' or acn_uuid not in curvenodes):
                        continue
                    # Note this is an infamous simplification of the compound props stuff,
                    # seems to be standard naming but we'll probably have to be smarter to handle more exotic files?
                    channel = {
                        b'd|X': 0, b'd|Y': 1, b'd|Z': 2,
                        b'd|DeformPercent': 0,
                        b'd|FocalLength': 0,
                        b'd|FocusDistance': 0
                    }.get(acn_ctype.props[3], None)
                    if channel is None:
                        continue
                    curvenodes[acn_uuid][ac_uuid] = (fbx_acitem, channel)

            # And now that we have sorted all this, apply animations!
            blen_read_animations(fbx_tmpl_astack, fbx_tmpl_alayer, stacks, scene, settings.anim_offset, global_scale,
                                 fbx_ktime)

        _()
        del _

    perfmon.step("FBX import: Assign materials...")

    def _():
        # link Material's to Geometry (via Model's)
        processed_meshes = set()
        for helper_uuid, helper_node in fbx_helper_nodes.items():
            obj = helper_node.bl_obj
            if not obj or obj.type != 'MESH':
                continue

            # Get the Mesh corresponding to the Geometry used by this Model.
            mesh = obj.data
            processed_meshes.add(mesh)

            # Get the Materials from the Model's connections.
            material_connections = connection_filter_reverse(helper_uuid, b'Material')
            if not material_connections:
                continue

            mesh_mats = mesh.materials
            num_mesh_mats = len(mesh_mats)

            if num_mesh_mats == 0:
                # This is the first (or only) model to use this Geometry. This is the most common case when importing.
                # All the Materials can trivially be appended to the Mesh's Materials.
                mats_to_append = material_connections
                mats_to_compare = ()
            elif num_mesh_mats == len(material_connections):
                # Another Model uses the same Geometry and has already appended its Materials to the Mesh. This is the
                # second most common case when importing.
                # It's also possible that a Model could share the same Geometry and have the same number of Materials,
                # but have different Materials, though this is less common.
                # The Model Materials will need to be compared with the Mesh Materials at the same indices to check if
                # they are different.
                mats_to_append = ()
                mats_to_compare = material_connections
            else:
                # Under the assumption that only used Materials are connected to the Model, the number of Materials of
                # each Model using a specific Geometry should be the same, otherwise the Material Indices of the
                # Geometry will be out-of-bounds of the Materials of at least one of the Models using that Geometry.
                # We wouldn't expect this case to happen, but there's nothing to say it can't.
                # We'll handle a differing number of Materials by appending any extra Materials and comparing the rest.
                mats_to_append = material_connections[num_mesh_mats:]
                mats_to_compare = material_connections[:num_mesh_mats]

            for _fbx_lnk_material, material, _fbx_lnk_material_type in mats_to_append:
                mesh_mats.append(material)

            mats_to_compare_and_slots = zip(mats_to_compare, obj.material_slots)
            for (_fbx_lnk_material, material, _fbx_lnk_material_type), mat_slot in mats_to_compare_and_slots:
                if material != mat_slot.material:
                    # Material Slots default to being linked to the Mesh, so a previously processed Object is also using
                    # this Mesh, but the Mesh uses a different Material for this Material Slot.
                    # To have a different Material for this Material Slot on this Object only, the Material Slot must be
                    # linked to the Object rather than the Mesh.
                    # TODO: add an option to link all materials to objects in Blender instead?
                    mat_slot.link = 'OBJECT'
                    mat_slot.material = material

        # We have to validate mesh polygons' ma_idx, see #41015!
        # Some FBX seem to have an extra 'default' material which is not defined in FBX file.
        for mesh in processed_meshes:
            if mesh.validate_material_indices():
                print("WARNING: mesh '%s' had invalid material indices, those were reset to first material" % mesh.name)
    _()
    del _

    perfmon.step("FBX import: Assign textures...")

    def _():
        material_images = {}

        fbx_tmpl = fbx_template_get((b'Material', b'KFbxSurfacePhong'))
        # b'KFbxSurfaceLambert'

        def texture_mapping_set(fbx_obj, node_texture):
            assert fbx_obj.id == b'Texture'

            fbx_props = (elem_find_first(fbx_obj, b'Properties70'),
                         elem_find_first(fbx_tmpl, b'Properties70', fbx_elem_nil))
            loc = elem_props_get_vector_3d(fbx_props, b'Translation', (0.0, 0.0, 0.0))
            rot = tuple(-r for r in elem_props_get_vector_3d(fbx_props, b'Rotation', (0.0, 0.0, 0.0)))
            scale = tuple(((1.0 / s) if s != 0.0 else 1.0)
                          for s in elem_props_get_vector_3d(fbx_props, b'Scaling', (1.0, 1.0, 1.0)))
            clamp = (bool(elem_props_get_enum(fbx_props, b'WrapModeU', 0)) or
                     bool(elem_props_get_enum(fbx_props, b'WrapModeV', 0)))

            if (loc == (0.0, 0.0, 0.0) and
                rot == (0.0, 0.0, 0.0) and
                scale == (1.0, 1.0, 1.0) and
                    clamp == False):
                return

            node_texture.translation = loc
            node_texture.rotation = rot
            node_texture.scale = scale
            if clamp:
                node_texture.extension = 'EXTEND'

        for fbx_uuid, fbx_item in fbx_table_nodes.items():
            fbx_obj, blen_data = fbx_item
            if fbx_obj.id != b'Material':
                continue

            material = fbx_table_nodes.get(fbx_uuid, (None, None))[1]
            for (fbx_lnk,
                 image,
                 fbx_lnk_type) in connection_filter_reverse(fbx_uuid, b'Texture'):

                if fbx_lnk_type.props[0] == b'OP':
                    lnk_type = fbx_lnk_type.props[3]

                    ma_wrap = nodal_material_wrap_map[material]

                    if lnk_type in {b'DiffuseColor', b'3dsMax|maps|texmap_diffuse'}:
                        ma_wrap.base_color_texture.image = image
                        texture_mapping_set(fbx_lnk, ma_wrap.base_color_texture)
                    elif lnk_type in {b'SpecularColor', b'SpecularFactor'}:
                        # Intensity actually, not color...
                        ma_wrap.specular_texture.image = image
                        texture_mapping_set(fbx_lnk, ma_wrap.specular_texture)
                    elif lnk_type in {b'ReflectionColor', b'ReflectionFactor', b'3dsMax|maps|texmap_reflection'}:
                        # Intensity actually, not color...
                        ma_wrap.metallic_texture.image = image
                        texture_mapping_set(fbx_lnk, ma_wrap.metallic_texture)
                    elif lnk_type in {b'TransparentColor', b'TransparencyFactor'}:
                        ma_wrap.alpha_texture.image = image
                        texture_mapping_set(fbx_lnk, ma_wrap.alpha_texture)
                        if use_alpha_decals:
                            material_decals.add(material)
                    elif lnk_type == b'ShininessExponent':
                        # That is probably reversed compared to expected results? TODO...
                        ma_wrap.roughness_texture.image = image
                        texture_mapping_set(fbx_lnk, ma_wrap.roughness_texture)
                    # XXX, applications abuse bump!
                    elif lnk_type in {b'NormalMap', b'Bump', b'3dsMax|maps|texmap_bump'}:
                        ma_wrap.normalmap_texture.image = image
                        texture_mapping_set(fbx_lnk, ma_wrap.normalmap_texture)
                        """
                    elif lnk_type == b'Bump':
                        # TODO displacement...
                        """
                    elif lnk_type in {b'EmissiveColor'}:
                        ma_wrap.emission_color_texture.image = image
                        texture_mapping_set(fbx_lnk, ma_wrap.emission_color_texture)
                    elif lnk_type in {b'EmissiveFactor'}:
                        ma_wrap.emission_strength_texture.image = image
                        texture_mapping_set(fbx_lnk, ma_wrap.emission_strength_texture)
                    else:
                        print("WARNING: material link %r ignored" % lnk_type)

                    material_images.setdefault(material, {})[lnk_type] = image

        # Check if the diffuse image has an alpha channel,
        # if so, use the alpha channel.

        # Note: this could be made optional since images may have alpha but be entirely opaque
        for fbx_uuid, fbx_item in fbx_table_nodes.items():
            fbx_obj, blen_data = fbx_item
            if fbx_obj.id != b'Material':
                continue
            material = fbx_table_nodes.get(fbx_uuid, (None, None))[1]
            image = material_images.get(material, {}).get(b'DiffuseColor', None)
            # do we have alpha?
            if image and image.depth == 32:
                if use_alpha_decals:
                    material_decals.add(material)

                ma_wrap = nodal_material_wrap_map[material]
                ma_wrap.alpha_texture.use_alpha = True
                ma_wrap.alpha_texture.copy_from(ma_wrap.base_color_texture)

            # Propagate mapping from diffuse to all other channels which have none defined.
            # XXX Commenting for now, I do not really understand the logic here, why should diffuse mapping
            #     be applied to all others if not defined for them???
            # ~ ma_wrap = nodal_material_wrap_map[material]
            # ~ ma_wrap.mapping_set_from_diffuse()

    _()
    del _

    perfmon.step("FBX import: Cycles z-offset workaround...")

    def _():
        # Annoying workaround for cycles having no z-offset
        if material_decals and use_alpha_decals:
            for fbx_uuid, fbx_item in fbx_table_nodes.items():
                fbx_obj, blen_data = fbx_item
                if fbx_obj.id != b'Geometry':
                    continue
                if fbx_obj.props[-1] == b'Mesh':
                    mesh = fbx_item[1]

                    num_verts = len(mesh.vertices)
                    if decal_offset != 0.0 and num_verts > 0:
                        for material in mesh.materials:
                            if material in material_decals:
                                blen_norm_dtype = np.single
                                vcos = MESH_ATTRIBUTE_POSITION.to_ndarray(mesh.attributes)
                                vnorm = np.empty(num_verts * 3, dtype=blen_norm_dtype)
                                mesh.vertex_normals.foreach_get("vector", vnorm)

                                vcos += vnorm * decal_offset

                                MESH_ATTRIBUTE_POSITION.foreach_set(mesh.attributes, vcos)
                                break

                    for obj in (obj for obj in bpy.data.objects if obj.data == mesh):
                        obj.visible_shadow = False
    _()
    del _

    perfmon.level_down()

    perfmon.level_down("Import finished.")
    return {'FINISHED'}
