import_fbx.py

                    elif lnk_type == b'TransparentColor':  # alpha
                        ma_wrap.alpha_image_set(image)
                        if use_mapping:
                            ma_wrap.alpha_mapping_set(**tex_map_kw)
                        if use_alpha_decals:
                            material_decals.add(material)
                    elif lnk_type == b'DiffuseFactor':
                        pass  # TODO
                    elif lnk_type == b'ShininessExponent':
                        ma_wrap.hardness_image_set(image)
                        if use_mapping:
                            ma_wrap.hardness_mapping_set(**tex_map_kw)
                    # XXX, applications abuse bump!
                    elif lnk_type in {b'NormalMap', b'Bump', b'3dsMax|maps|texmap_bump'}:
                        ma_wrap.normal_image_set(image)
                        ma_wrap.normal_factor_set(texture_bumpfac_get(fbx_obj))
                        if use_mapping:
                            ma_wrap.normal_mapping_set(**tex_map_kw)
                        """
                    elif lnk_type == b'Bump':
                        ma_wrap.bump_image_set(image)
                        ma_wrap.bump_factor_set(texture_bumpfac_get(fbx_obj))
                        if use_mapping:
                            ma_wrap.bump_mapping_set(**tex_map_kw)
                        """
                    else:
                        print("WARNING: material link %r ignored" % lnk_type)

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

        # 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, tex_map = material_images.get(material, {}).get(b'DiffuseColor', (None, None))
            # do we have alpha?
            if image and image.depth == 32:
                if use_alpha_decals:
                    material_decals.add(material)

                ma_wrap = cycles_material_wrap_map[material]
                if ma_wrap.node_bsdf_alpha.mute:
                    ma_wrap.alpha_image_set_from_diffuse()

            # propagate mapping from diffuse to all other channels which have none defined.
            ma_wrap = cycles_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]

                    if decal_offset != 0.0:
                        for material in mesh.materials:
                            if material in material_decals:
                                for v in mesh.vertices:
                                    v.co += v.normal * decal_offset
                                break

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

    perfmon.level_down()

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