Blender AMF2.py

bl_info = {
    "name": "AMF format",
    "description": "Import AMF files created by Reclaimer.",
    "author": "Gravemind2401",
    "version": (2, 0, 8),
    "blender": (2, 80, 0),
    "location": "File > Import > AMF",
    "category": "Import-Export",
}

import struct
import io
import bpy
import bmesh
import math
import os.path as ospath
import itertools
import bpy_extras

from pathlib import Path, PureWindowsPath
from dataclasses import dataclass
from mathutils import Matrix, Quaternion, Vector
from bpy.props import BoolProperty, FloatProperty, StringProperty, EnumProperty, CollectionProperty
from bpy.types import OperatorFileListElement

@dataclass
class FileReader:
    __stream: io.BufferedReader

    def __init__(self, file_name):
        print(f"open file: {file_name}")
        self.__stream = open(file_name, "rb") # "rb" - open for reading in binary mode

    def tell(self):
        return self.__stream.tell()

    def seek(self, dest, start = 0):
        self.__stream.seek(dest, start)

    def close(self):
        print(f"closed file")
        self.__stream.close()

    def read_byte(self, endian = "<"):
        return struct.unpack(endian + "B", self.__stream.read(1))[0]

    def read_ushort(self, endian = "<"):
        return struct.unpack(endian + "H", self.__stream.read(2))[0]

    def read_short(self, endian = "<"):
        return struct.unpack(endian + "h", self.__stream.read(2))[0]

    def read_uint(self, endian = "<"):
        return struct.unpack(endian + "I", self.__stream.read(4))[0]

    def read_int(self, endian = "<"):
        return struct.unpack(endian + "i", self.__stream.read(4))[0]

    def read_float(self, endian = "<"):
        return struct.unpack(endian + "f", self.__stream.read(4))[0]

    def read_vec2(self, endian = "<"):
        return Vector([self.read_float(endian), self.read_float(endian)])

    def read_vec3(self, endian = "<"):
        return Vector([self.read_float(endian), self.read_float(endian), self.read_float(endian)])

    def read_vec4(self, endian = "<"):
        return Vector([self.read_float(endian), self.read_float(endian), self.read_float(endian), self.read_float(endian)])

    def read_quat(self, endian = "<"):
        vec = self.read_vec4(endian)
        return Quaternion([vec.w, vec.x, vec.y, vec.z])

    def read_string(self):
        chars = []
        next = self.__stream.read(1).decode()
        while next != chr(0):
            chars.append(next)
            next = self.__stream.read(1).decode()
        return "".join(chars)

@dataclass
class Vertex:
    position: Vector
    normal: Vector
    texcoords: Vector
    indices: Vector
    weights: Vector

    def __init__(self, reader, vertex_format):
        self.position = reader.read_vec3()
        self.normal = reader.read_vec3()
        self.texcoords = reader.read_vec2()

        ##these normals arent normal enough for Blender
        #self.normal.normalize()

        #the vertex may be affected by 0 to 4 bones
        #the file stores the index of each relevant bone,
        #terminated by a 0xFF if not all bones were used

        # 0 = no skinning
        # 1 = weighted skinning
        # 2 = rigid skinning
        if vertex_format == 0:
            self.indices = None
            self.weights = None
        else:
            temp = [reader.read_byte(), reader.read_byte()]
            if temp[1] != 255:
                temp.append(reader.read_byte())
                if temp[2] != 255:
                    temp.append(reader.read_byte())
            count = len(temp)
            if temp[count - 1] == 255: # dont count trailing terminators
                count -= 1
            if count == 1:
                self.indices = Vector([float(temp[0]), 0])
                if vertex_format == 1:
                    self.weights = Vector([reader.read_float(), 0])
                else:
                    self.weights = Vector([1, 0])
            elif count == 2:
                self.indices = Vector([float(temp[0]), float(temp[1])])
                if vertex_format == 1:
                    self.weights = reader.read_vec2()
                else:
                    self.weights = Vector([1, 1])
            elif count == 3:
                self.indices = Vector([float(temp[0]), float(temp[1]), float(temp[2])])
                if vertex_format == 1:
                    self.weights = reader.read_vec3()
                else:
                    self.weights = Vector([1, 1, 1])
            else: #count == 4:
                self.indices = Vector([float(temp[0]), float(temp[1]), float(temp[2]), float(temp[3])])
                if vertex_format == 1:
                    self.weights = reader.read_vec4()
                else:
                    self.weights = Vector([1, 1, 1, 1])

@dataclass
class AmfModel:
    header: int
    version: float
    name: str
    nodes: []
    markers: []
    regions: []
    materials: []
    vertex_buffers: dict
    index_buffers: dict

    def __init__(self, reader):
        self.__read_header(reader)
        self.__read_nodes(reader)
        self.__read_markers(reader)
        self.__read_regions(reader)
        self.__read_materials(reader)

        self.vertex_buffers = dict()
        self.index_buffers = dict()

        print("reading mesh data")
        for region in self.regions:
            for perm in region.permutations:
                if perm.vert_address not in self.vertex_buffers:
                    self.vertex_buffers[perm.vert_address] = self.__read_vertices(reader, perm)
                if perm.face_address not in self.index_buffers:
                    self.index_buffers[perm.face_address] = self.__read_indices(reader, perm)

    def __read_header(self, reader):
        print("reading header")
        self.header = reader.read_int()
        self.version = reader.read_float()
        self.name = reader.read_string()

        if self.version < 2.0:
            raise Exception("AMF files must be v2.0 or newer.")

    def __read_nodes(self, reader):
        print("reading nodes")
        self.nodes = []
        nodes_count = reader.read_int()
        nodes_address = reader.read_int()
        pos = reader.tell()
        reader.seek(nodes_address)
        for i in range(nodes_count):
            self.nodes.append(Node(reader))
        reader.seek(pos)

    def __read_markers(self, reader):
        print("reading markers")
        self.markers = []
        groups_count = reader.read_int()
        groups_address = reader.read_int()
        pos = reader.tell()
        reader.seek(groups_address)
        for i in range(groups_count):
            self.markers.append(MarkerGroup(reader))
        reader.seek(pos)

    def __read_regions(self, reader):
        print("reading regions")
        self.regions = []
        regions_count = reader.read_int()
        regions_address = reader.read_int()
        pos = reader.tell()
        reader.seek(regions_address)
        for i in range(regions_count):
            self.regions.append(Region(reader))
        reader.seek(pos)

    def __read_materials(self, reader):
        print("reading materials")
        self.materials = []
        mat_count = reader.read_int()
        mat_address = reader.read_int()
        pos = reader.tell()
        reader.seek(mat_address)
        for i in range(mat_count):
            self.materials.append(Material(reader))
        reader.seek(pos)

    def __read_vertices(self, reader, permutation):
        vertices = []
        pos = reader.tell()
        reader.seek(permutation.vert_address)
        for i in range(permutation.vert_count):
            vertices.append(Vertex(reader, permutation.vert_format))
        reader.seek(pos)
        return vertices

    def __read_indices(self, reader, permutation):
        indices = []
        pos = reader.tell()
        reader.seek(permutation.face_address)
        for i in range(permutation.face_count):
            if permutation.vert_count > 65535:
                indices.append([reader.read_int(), reader.read_int(), reader.read_int()])
            else:
                indices.append([reader.read_ushort(), reader.read_ushort(), reader.read_ushort()])
        reader.seek(pos)
        return indices

@dataclass
class Node:
    name: str
    parent_index: int
    child_index: int
    sibling_index: int
    position: Vector
    rotation: Quaternion

    def __init__(self, reader):
        self.name = reader.read_string()
        self.parent_index = reader.read_short()
        self.child_index = reader.read_short()
        self.sibling_index = reader.read_short()
        self.position = reader.read_vec3()
        self.rotation = reader.read_quat()

@dataclass
class MarkerGroup:
    name: str
    markers: []

    def __init__(self, reader):
        self.name = reader.read_string()
        child_count = reader.read_int()
        child_address = reader.read_int()
        pos = reader.tell()
        reader.seek(child_address)
        self.markers = []
        for i in range(child_count):
            self.markers.append(Marker(reader))
        reader.seek(pos)

@dataclass
class Marker:
    region_index: int
    permutation_index: int
    node_index: int
    position: Vector
    rotation: Quaternion

    def __init__(self, reader):
        self.region_index = reader.read_byte()
        self.permutation_index = reader.read_byte()
        self.node_index = reader.read_short()
        self.position = reader.read_vec3()
        self.rotation = reader.read_quat()

@dataclass
class Region:
    name: str
    permutations: []

    def __init__(self, reader):
        self.name = reader.read_string()
        child_count = reader.read_int()
        child_address = reader.read_int()
        pos = reader.tell()
        reader.seek(child_address)
        self.permutations = []
        for i in range(child_count):
            self.permutations.append(Permutation(reader))
        reader.seek(pos)

@dataclass
class Permutation:
    name: str
    vert_format: int
    node_index: int
    vert_count: int
    vert_address: int
    face_count: int
    face_address: int
    submeshes: []
    scale: float
    transform: Matrix

    def __init__(self, reader):
        self.name = reader.read_string()
        self.vert_format = reader.read_byte()
        self.node_index = reader.read_byte()
        self.vert_count = reader.read_int()
        self.vert_address = reader.read_int()
        self.face_count = reader.read_int()
        self.face_address = reader.read_int()
        child_count = reader.read_int()
        child_address = reader.read_int()
        self.scale = reader.read_float()

        if not math.isnan(self.scale):
            row1 = [reader.read_float(), reader.read_float(), reader.read_float(), 0]
            row2 = [reader.read_float(), reader.read_float(), reader.read_float(), 0]
            row3 = [reader.read_float(), reader.read_float(), reader.read_float(), 0]
            row4 = [reader.read_float(), reader.read_float(), reader.read_float(), 1]
            self.transform = Matrix([row1, row2, row3, row4]).transposed()
        else: self.transform = Matrix()

        pos = reader.tell()
        reader.seek(child_address)
        self.submeshes = []
        for i in range(child_count):
            self.submeshes.append(Submesh(reader))
        reader.seek(pos)


@dataclass
class Submesh:
    mat_index: int
    face_start: int
    face_count: int

    def __init__(self, reader):
        self.mat_index = reader.read_short()
        self.face_start = reader.read_int()
        self.face_count = reader.read_int()

#@dataclass
#class TextureType:
#    diffuse: str = "diffuse"
#    detail: str = "detail"
#    colour_change: str = "colour_change"
#    bump: str = "bump"
#    detail_bump: str = "detail_bump"
#    illum: str = "illum"
#    specular: str = "specular"
#    reflection: str = "reflection"
#
#    @staticmethod
#    def enumerate():
#        return [TextureType.diffuse, TextureType.detail, TextureType.colour_change, TextureType.bump, TextureType.detail_bump, TextureType.illum, TextureType.specular, TextureType.reflection]

@dataclass
class Material:
    name: str
    is_terrain: bool
    is_transparent: bool
    cc_only: bool
    textures: []
    tints: []

    def __init__(self, reader):
        self.name = reader.read_string()
        self.is_terrain = self.name[0] == '*'

        self.is_transparent = False
        self.cc_only = False
        self.textures = []
        self.tints = []

        if not self.is_terrain:
            for i in range(8):
                name = reader.read_string()
                tiles = Vector([0, 0])
                if name != "null":
                    tiles = reader.read_vec2()
                self.textures.append(Submaterial(name, tiles))

            for i in range(4):
                self.tints.append([reader.read_byte(), reader.read_byte(), reader.read_byte(), reader.read_byte()])

            self.is_transparent = reader.read_byte() == 1
            self.cc_only = reader.read_byte() == 1
        else:
            self.name = self.name[1:]
            blend_path = reader.read_string()
            blend_tile = Vector([0, 0])
            if blend_path != "null":
                blend_tile = Vector([reader.read_float(), reader.read_float()])

            base_count = reader.read_byte()
            bump_count = reader.read_byte()
            detail_count = reader.read_byte()

            base_maps = []
            base_tiles = []
            bump_maps = []
            bump_tiles = []
            detail_maps = []
            detail_tiles = []

            for i in range(base_count):
                base_maps.append(reader.read_string())
                base_tiles.append(Vector([reader.read_float(), reader.read_float()]))

            for i in range(bump_count):
                bump_maps.append(reader.read_string())
                bump_tiles.append(Vector([reader.read_float(), reader.read_float()]))

            for i in range(detail_count):
                detail_maps.append(reader.read_string())
                detail_tiles.append(Vector([reader.read_float(), reader.read_float()]))

            self.textures.append(Submaterial(base_maps[0], base_tiles[0]))

@dataclass
class Submaterial:
    texture_path: str
    uv_tiles: Vector
    is_null: bool

    def __init__(self, texture_path, uv_tiles):
        self.texture_path = texture_path
        self.uv_tiles = uv_tiles
        self.is_null = texture_path == "null"

    def get_full_path(self, root_dir, ext):
        return Path(root_dir) / Path(PureWindowsPath(self.texture_path + "." + ext))

    def get_texture_name(self):
        return PureWindowsPath(self.texture_path).name

@dataclass
class ImportOptions:
    IMPORT_SCALE: float = 1.0
    IMPORT_BONES: bool = True
    IMPORT_MARKERS: bool = True
    IMPORT_MESHES: bool = True
    IMPORT_MATERIALS: bool = True

    PREFIX_MARKER: str = "#"
    PREFIX_BONE: str = ""

    DIRECTORY_BITMAP: str = ""
    SUFFIX_BITMAP: str = "tif"

    MODE_SCALE = 'METERS'
    MODE_MARKERS = 'EMPTY'
    MODE_MESHES = 'JOIN'

    def get_scale_multiplier(self):
        if self.MODE_SCALE == 'METERS':
            return self.IMPORT_SCALE * 0.03048
        elif self.MODE_SCALE == 'HALO':
            return self.IMPORT_SCALE * 0.01
        else: # self.MODE_SCALE == 'MAX'
            return self.IMPORT_SCALE

    def get_node_transforms(self, nodes, scale_fix = 1.0):
        transforms = []
        for i, node in enumerate(nodes):
            pos = Matrix.Translation(node.position * self.get_scale_multiplier() * scale_fix)
            rot = node.rotation.to_matrix().to_4x4()
            transform = pos @ rot
            if node.parent_index >= 0:
                transform = transforms[node.parent_index] @ transform
            transforms.append(transform)
        return transforms

    def get_perm_transform(self, perm):
        if not math.isnan(perm.scale):
            #in amf files geometry is stored as 100x the halo units with the exception of instanced geometry
            #this scales up to match the rest of the geometry and corrects the translation to match the unit settings
            offset_scale = self.get_scale_multiplier() / 0.01
            pos, rot, scale = perm.transform.decompose()
            return Matrix.Translation(pos * offset_scale) @ rot.to_matrix().to_4x4() @ Matrix.Diagonal(scale).to_4x4() @ Matrix.Scale(100 * perm.scale, 4)
        else:
            return Matrix()

###############################################################################################################################

def clean_scene():

    for item in bpy.data.objects:
        if item.type == 'MESH' or item.type == 'EMPTY':
            bpy.data.objects.remove(item)

    check_users = False
    for collection in (bpy.data.meshes, bpy.data.armatures, bpy.data.materials, bpy.data.textures, bpy.data.images):
        for item in collection:
            if item.users == 0 or not check_users:
                collection.remove(item)

def main(context, import_filename, options):
    print("execute amf import")

    IMPORT_SCALE = options.get_scale_multiplier()
    print(f"importing at scale {IMPORT_SCALE}")

    bitmapsDir = ospath.split(import_filename)[0]
    if len(options.DIRECTORY_BITMAP) > 0:
        bitmapsDir = options.DIRECTORY_BITMAP

    reader = FileReader(import_filename)

    model = AmfModel(reader)

    arm_obj = None
    armature = None
    model_nodes = []
    model_materials = []

    if options.IMPORT_BONES and len(model.nodes) > 0:
        print("creating bones")
        bpy.ops.object.add(type = 'ARMATURE', enter_editmode = True)
        arm_obj = context.object
        armature = arm_obj.data
        armature.name = model.name + " armature"

        node_abs_transforms = options.get_node_transforms(model.nodes, 1)
        for i, node in enumerate(model.nodes):
            bone = armature.edit_bones.new(options.PREFIX_BONE + node.name)
            if node.parent_index >= 0:
                bone.parent = model_nodes[node.parent_index]
            bone.tail = Vector([0,5,0]) * IMPORT_SCALE

            bone.matrix = node_abs_transforms[i]
            model_nodes.append(bone)

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

    if options.IMPORT_MARKERS and len(model.markers) > 0:
        print("creating markers")
        for mg in model.markers:
            marker_name = options.PREFIX_MARKER + mg.name
            node_abs_transforms = options.get_node_transforms(model.nodes)
            for m in mg.markers:
                if options.MODE_MARKERS == 'MESH':
                    mesh = bpy.data.meshes.new(marker_name)
                    marker_obj = bpy.data.objects.new(marker_name, mesh)

                    bm = bmesh.new()
                    bmesh.ops.create_uvsphere(bm, u_segments = 16, v_segments = 16, diameter = IMPORT_SCALE)
                    bm.to_mesh(mesh)
                    bm.free()

                    context.collection.objects.link(marker_obj)
                else: # MODE_MARKERS == 'EMPTY'
                    #it says 'radius' but it comes out the same size as uvsphere's diameter
                    bpy.ops.object.empty_add(type = 'SPHERE', radius = IMPORT_SCALE)
                    marker_obj = context.object
                    marker_obj.name = marker_name

                marker_transform = Matrix.Translation(m.position * IMPORT_SCALE) @ m.rotation.to_matrix().to_4x4()
                if m.node_index >= 0:
                    marker_transform = node_abs_transforms[m.node_index] @ marker_transform
                    if options.IMPORT_BONES:
                        marker_obj.parent = arm_obj
                        marker_obj.parent_type = 'BONE'
                        marker_obj.parent_bone = options.PREFIX_BONE + model.nodes[m.node_index].name

                marker_obj.hide_render = True
                marker_obj.matrix_world = marker_transform

    if options.IMPORT_MATERIALS and len(model.materials) > 0:
        print("creating materials")
        for mat in model.materials:
            material = bpy.data.materials.new(mat.name)
            material.use_nodes = True

            bsdf = material.node_tree.nodes["Principled BSDF"]

            texture = material.node_tree.nodes.new('ShaderNodeTexImage')
            texture_path = mat.textures[0].get_full_path(bitmapsDir, options.SUFFIX_BITMAP)
            if not mat.textures[0].is_null and texture_path.exists():
                texture.image = bpy.data.images.load(str(texture_path))
                if not mat.is_transparent:
                    texture.image.alpha_mode = 'CHANNEL_PACKED'
                    spec_input = bsdf.inputs['Specular'] if bpy.app.version[0] < 4 else bsdf.inputs['Specular IOR Level']
                    material.node_tree.links.new(spec_input, texture.outputs['Alpha'])

            material.node_tree.links.new(bsdf.inputs['Base Color'], texture.outputs['Color'])
            bsdf.location = [0, 300]
            texture.location = [-300, 300]

#           texture.repeat_x = mat.textures[0].uv_tiles[0]
#           texture.repeat_y = mat.textures[0].uv_tiles[1]

            if not mat.is_terrain and not mat.textures[3].is_null:
                texture = material.node_tree.nodes.new('ShaderNodeTexImage')
                texture_path = mat.textures[3].get_full_path(bitmapsDir, options.SUFFIX_BITMAP)
                if texture_path.exists():
                    texture.image = bpy.data.images.load(str(texture_path))
                    texture.image.alpha_mode = 'NONE'
                    texture.image.colorspace_settings.name = 'Non-Color'

                # inverting green channel is necessary to convert from DirectX coordsys to OpenGL

                bump = material.node_tree.nodes.new('ShaderNodeNormalMap')
                split = material.node_tree.nodes.new('ShaderNodeSeparateRGB')
                invert = material.node_tree.nodes.new('ShaderNodeInvert')
                merge = material.node_tree.nodes.new('ShaderNodeCombineRGB')

                texture.location = [-1100, -100]
                split.location = [-800, -100]
                invert.location = [-600, -200]
                merge.location = [-400, -100]
                bump.location = [-200, -100]

                material.node_tree.links.new(split.inputs['Image'], texture.outputs['Color'])
                material.node_tree.links.new(invert.inputs['Color'], split.outputs['G'])
                material.node_tree.links.new(merge.inputs['R'], split.outputs['R'])
                material.node_tree.links.new(merge.inputs['G'], invert.outputs['Color'])
                material.node_tree.links.new(merge.inputs['B'], split.outputs['B'])
                material.node_tree.links.new(bump.inputs['Color'], merge.outputs['Image'])
                material.node_tree.links.new(bsdf.inputs['Normal'], bump.outputs['Normal'])

            model_materials.append(material)

    if options.IMPORT_MESHES and len(model.regions) > 0:
        print("creating meshes")
        instance_lookup = dict()
        for region in model.regions:
            for perm in region.permutations:
                index_buffer = model.index_buffers[perm.face_address]
                position_buffer = [v.position for v in model.vertex_buffers[perm.vert_address]]
                texcoord_buffer = [v.texcoords for v in model.vertex_buffers[perm.vert_address]]
                normal_buffer = [v.normal for v in model.vertex_buffers[perm.vert_address]]
                node_index_buffer = [v.indices for v in model.vertex_buffers[perm.vert_address]]
                node_weight_buffer = [v.weights for v in model.vertex_buffers[perm.vert_address]]

                for sub_index, sub in enumerate(perm.submeshes):
                    instance_key = f"{perm.vert_address}_{sub_index:03d}"
                    root_obj = instance_lookup.get(instance_key, None)
                    if root_obj is not None:
                        mesh_obj = root_obj.copy()
                        #this makes a deep copy rather than a linked copy
                        #mesh_obj.data = root_obj.data.copy()
                        mesh_obj.matrix_world = options.get_perm_transform(perm)
                        context.collection.objects.link(mesh_obj)

                        if options.MODE_MESHES == 'JOIN':
                            break #skip the rest of the submeshes
                        else:
                            continue

                    if options.MODE_MESHES == 'JOIN':
                        mesh_name = f"{region.name}:{perm.name}"
                        mesh_verts = position_buffer
                        mesh_faces = index_buffer
                        mesh_coords = [texcoord_buffer[i] for i in itertools.chain(*mesh_faces)] #blender wants 3 uvs per tri, rather than one per vertex
                        mesh_norms = normal_buffer
                        mesh_nodes = node_index_buffer
                        mesh_weights = node_weight_buffer
                        mat_ranges = [(s.face_start, s.face_count, s.mat_index) for s in perm.submeshes]
                    else:
                        mesh_name = f"{region.name}:{perm.name}.{sub_index:03d}"
                        mesh_faces = [index_buffer[i] for i in range(sub.face_start, sub.face_start + sub.face_count)]
                        mesh_coords = [texcoord_buffer[i] for i in itertools.chain(*mesh_faces)] #blender wants 3 uvs per tri, rather than one per vertex

                        min_index = min(itertools.chain(*mesh_faces))
                        max_index = max(itertools.chain(*mesh_faces))

                        mesh_verts = [position_buffer[i] for i in range(min_index, max_index + 1)] #only need verts referenced by the current faces
                        mesh_norms = [normal_buffer[i] for i in range(min_index, max_index + 1)]

                        if perm.vert_format > 0:
                            mesh_nodes = [node_index_buffer[i] for i in range(min_index, max_index + 1)]
                            mesh_weights = [node_weight_buffer[i] for i in range(min_index, max_index + 1)]

                        mat_ranges = [(0, sub.face_count, sub.mat_index)] #split meshes are offset to always start at 0

                        # translate the face indices to start at 0 since we are only using a subset of the vertices now
                        for face in mesh_faces:
                            face[0] -= min_index
                            face[1] -= min_index
                            face[2] -= min_index

                    mesh = bpy.data.meshes.new(mesh_name)
                    mesh.from_pydata(mesh_verts, [], mesh_faces)
                    mesh_obj = bpy.data.objects.new(mesh_name, mesh)

                    for p in mesh.polygons:
                        p.use_smooth = True

                    mesh.normals_split_custom_set_from_vertices(mesh_norms)
                    if hasattr(mesh, 'use_auto_smooth'):
                        mesh.use_auto_smooth = True #required for custom normals to take effect pre blender 4.1

                    if options.IMPORT_MATERIALS:
                        mat_lookup = dict()
                        for i, mat_index in enumerate(set(t[2] for t in mat_ranges)):
                            mat_lookup[mat_index] = i

                        for i in mat_lookup.keys():
                            mesh.materials.append(model_materials[i])

                        for face_start, face_count, mat_index in mat_ranges:
                            for i in range(face_start, face_start + face_count):
                                mesh.polygons[i].material_index = mat_lookup[mat_index]

                    uvmap = mesh.uv_layers.new()
                    for i in range(len(mesh_coords)):
                        uvmap.data[i].uv = mesh_coords[i]

                    if options.IMPORT_BONES and perm.vert_format > 0:
                        mesh_obj.parent = arm_obj
                        mod = mesh_obj.modifiers.new("armature", 'ARMATURE')
                        mod.object = arm_obj

                        for node in model.nodes:
                            mesh_obj.vertex_groups.new(name = node.name)

                        if perm.node_index != 255:
                            for i in range(len(mesh_verts)):
                                mesh_obj.vertex_groups[perm.node_index].add([i], 1.0, 'ADD')
                        else:
                            for i in range(len(mesh_nodes)):
                                indices = mesh_nodes[i]
                                weights = mesh_weights[i]
                                for j in range(len(indices)):
                                    if weights[j] == 0:
                                        continue
                                    mesh_obj.vertex_groups[int(indices[j])].add([i], weights[j], 'ADD')

                    if not math.isnan(perm.scale):
                        mesh_obj.matrix_world = options.get_perm_transform(perm)
                        instance_lookup[instance_key] = mesh_obj

                    mesh.transform(Matrix.Scale(IMPORT_SCALE, 4))
                    context.collection.objects.link(mesh_obj)

                    if options.MODE_MESHES == 'JOIN':
                        break #skip the rest of the submeshes

    reader.close()

###############################################################################################################################

class IMPORT_SCENE_OT_amf(bpy.types.Operator, bpy_extras.io_utils.ImportHelper):
    """Import an AMF file"""
    bl_idname = "import_scene.amf"
    bl_label = "Import AMF"
    bl_options = {'PRESET', 'UNDO'}

    filename_ext = ".amf"
    filter_glob: StringProperty(
        default = "*.amf",
        options = {'HIDDEN'},
    )

    import_units: EnumProperty(
        name = "Units",
        items = (
            ('METERS', "Meters", "Import using meters"),
            ('HALO', "Halo", "Import using Halo's world units"),
            ('MAX', "3DS Max", "Import using 3DS Max units (100x Halo)"),
        )
    )

    import_scale: FloatProperty(
        name = "Multiplier",
        description = "Sets the size of the imported model",
        default = 1.0,
        min = 0.0
    )

    import_nodes: BoolProperty(
        name = "Import Bones",
        description = "Determines if an armature and bones will be created, when applicable",
        default = True
    )

    node_prefix: StringProperty(
        name = "Prefix",
        description = "Adds a custom prefix in front of bone names",
        default = ""
    )

    import_markers: BoolProperty(
        name = "Import Markers",
        description = "Determines if marker spheres will be created, when applicable",
        default = True
    )

    marker_mode: EnumProperty(
        name = "Type",
        items = (
            ('EMPTY', "Empty Sphere", "Create markers using empty spheres"),
            ('MESH', "Mesh Sphere", "Create markers using UVSpheres"),
        )
    )

    marker_prefix: StringProperty(
        name = "Prefix",
        description = "Adds a custom prefix in front of marker names",
        default = "#"
    )

    import_meshes: BoolProperty(
        name = "Import Meshes",
        description = "Determines if mesh geometry will be created",
        default = True
    )

    mesh_mode: EnumProperty(
        name = "Group by",
        items = (
            ('JOIN', "Permutation", "Create one mesh per permutation"),
            ('SPLIT', "Material", "Create one mesh per material index"),
        )
    )

    import_materials: BoolProperty(
        name = "Import Materials",
        description = "Determines if materials will be created and applied",
        default = True
    )

    bitmap_dir: StringProperty(
        name = "Folder",
        description = "The root folder where bitmaps are saved",
        default = "",
#        subtype = 'DIR_PATH' # blender will not allow us to open a browser dilaog while the import dialog is open
    )

    bitmap_ext: StringProperty(
        name = "Extension",
        description = "The file extension of the source bitmap files",
        default = "tif"
    )

    files: CollectionProperty(
        name="AMF Files",
        type=OperatorFileListElement
    )
    
    directory: StringProperty(
        subtype='DIR_PATH'
    )

    def execute(self, context):
        options = ImportOptions()
        options.IMPORT_SCALE = self.import_scale
        options.IMPORT_BONES = self.import_nodes
        options.IMPORT_MARKERS = self.import_markers
        options.IMPORT_MESHES = self.import_meshes
        options.IMPORT_MATERIALS = self.import_materials

        options.PREFIX_MARKER = self.marker_prefix
        options.PREFIX_BONE = self.node_prefix

        options.DIRECTORY_BITMAP = self.bitmap_dir
        options.SUFFIX_BITMAP = self.bitmap_ext.lstrip(" .").rstrip()

        options.MODE_SCALE = self.import_units
        options.MODE_MARKERS = self.marker_mode
        options.MODE_MESHES = self.mesh_mode

        for file in self.files:
            path = Path(self.directory) / file.name
            main(context, path, options)

        return {'FINISHED'}

    def draw(self, context):
        layout = self.layout

        box = layout.box()
        box.label(icon = 'WORLD_DATA', text = "Scale")
        box.prop(self, "import_units")
        box.prop(self, "import_scale")

        box = layout.box()
        row = box.row()
        row.label(icon = 'BONE_DATA', text = "Bones")
        row.prop(self, "import_nodes")
        if self.import_nodes:
            box.prop(self, "node_prefix")

        box = layout.box()
        row = box.row()
        row.label(icon = 'MESH_CIRCLE', text = "Markers")
        row.prop(self, "import_markers")
        if self.import_markers:
            box.prop(self, "marker_mode")
            box.prop(self, "marker_prefix")

        box = layout.box()
        row = box.row()
        row.label(icon = 'MATERIAL_DATA', text = "Materials")
        row.prop(self, "import_materials")
        if self.import_materials:
            box.prop(self, "bitmap_dir")
            box.prop(self, "bitmap_ext")

        box = layout.box()
        row = box.row()
        row.label(icon = 'MESH_DATA', text = "Meshes")
        row.prop(self, "import_meshes")
        if self.import_meshes:
            box.prop(self, "mesh_mode")

# dont seem to be able to have a different value for menu label/dialog label within a single operator
# work around this by having one operator for the menu, and one for the dialog
class IMPORT_SCENE_MT_amf(bpy.types.Operator):
    """Import an AMF file"""
    bl_idname = "menu_import.amf"
    bl_label = "AMF (.amf)"

    def execute(self, context):
        bpy.ops.import_scene.amf('INVOKE_DEFAULT')
        return {'FINISHED'}

def draw_operator(self, context):
    self.layout.operator(IMPORT_SCENE_MT_amf.bl_idname)

def register():
    bpy.utils.register_class(IMPORT_SCENE_OT_amf)
    bpy.utils.register_class(IMPORT_SCENE_MT_amf)
    bpy.types.TOPBAR_MT_file_import.append(draw_operator)

def unregister():
    bpy.types.TOPBAR_MT_file_import.remove(draw_operator)
    bpy.utils.unregister_class(IMPORT_SCENE_MT_amf)
    bpy.utils.unregister_class(IMPORT_SCENE_OT_amf)

###############################################################################################################################

if __name__ == "__main__":
    try:
        unregister()
    finally:
        clean_scene()
        register()
        bpy.ops.import_scene.amf('INVOKE_DEFAULT')