rebase after accidental push of another repo

.gitignore

···
+*/source
+*/backup
+
+*/update_staging
+
+XNALara-io-Tools_updater_status.json
+XNALara-io-Tools.zip
+
+
+*.zip
+
+
+
+
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+$RECYCLE.BIN/
+
+
+*.cab
+*.msi
+*.msm
+*.msp
+*.lnk
+.DS_Store
+.AppleDouble
+.LSOverride
+._*
+
+
+.Spotlight-V100
+.Trashes
+
+
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+
+__pycache__/
+webspynner/__pychache__/
+*.py[cod]
+*.pyc
+
+
+.pydevproject
+.project
+.settings/
+
+
+*~
+
+
+XNALara-io-Tools/modules/addon_updater_system/xnalara-io-tools.modules.addon_updater_system_updater/XNALara-io-Tools.modules.addon_updater_system_updater_status.json
+XNALara-io-Tools/modules/addon_updater_system/_updater/XNALara-io-Tools.modules.addon_updater_system_updater_status.json

.gitmodules

···
+[submodule "XNALara-io-Tools/modules/ALXModuleManager"]
+	path = XNALara-io-Tools/modules/ALXModuleManager
+	url = https://tangled.sh/@valerie-bosco.tngl.sh/ALXModuleManager.git
+[submodule "XNALara-io-Tools/modules/ALXAddonUpdater"]
+	path = XNALara-io-Tools/modules/ALXAddonUpdater
+	url = https://tangled.sh/@valerie-bosco.tngl.sh/ALXAddonUpdater.git

ALXAddonUpdater/ALX_AddonUpdater.py xnalara_io_Tools/modules/ALXAddonUpdater/ALXAddonUpdater/ALX_AddonUpdater.py

···
                     bpy.utils.register_class(addon_class)
 
             except Exception as error:
-                print(error)
+                if (mute == False):
+                    print(error)
 
     def unregister_addon_updater(self):
 

addon_zipper.py

···
+import pathlib
+import re
+import shutil
+from os import sep as os_separator
+
+
+def main():
+    zip_addon()
+
+
+def zip_addon(zip_name_includes_version: bool = False):
+    path = pathlib.Path("".join([folder if (folder[-1] == os_separator) else (f"{folder}{os_separator}") for folder in pathlib.Path(__file__).parts[:-1]]))
+
+    parent_path = path
+    folder_name = path.name
+
+    if (parent_path.is_dir()):
+        zip_source_path = pathlib.Path.joinpath(parent_path, folder_name)
+        zip_target_path = ""
+
+        if (zip_name_includes_version):
+            with zip_source_path.joinpath("__init__.py").open() as init_file:
+                init_content = init_file.read()
+            init_file.close()
+
+            addon_version_match = re.search(r"([\"\']version[\"\']\s*:\s*(\(\s*[0-9]*\,\s*[0-9]*\,\s*[0-9]*\)))", init_content)
+            if (addon_version_match is not None):
+
+                addon_version = str(
+                    re.sub(
+                        r"[\(*\)*]|\s*",
+                        "",
+                        str(
+                            re.search(
+                                r"(\(\s*[0-9]*\,\s*[0-9]*\,\s*[0-9]*\))",
+                                str(addon_version_match)
+                            ).group()
+                        )
+                    )
+                ).replace(",", ".")
+
+                zip_target_path = parent_path.joinpath(f"{folder_name}v{addon_version}")
+            else:
+                raise ValueError(f"Addon version not found Value is: {addon_version_match}")
+        else:
+            zip_target_path = parent_path.joinpath(f"{folder_name}")
+
+        shutil.copytree(zip_source_path, parent_path.joinpath("temp", folder_name))
+        temp_folder = parent_path.joinpath("temp")
+
+        zipfile = shutil.make_archive(zip_target_path, "zip", temp_folder)
+        shutil.rmtree(temp_folder)
+
+    else:
+        raise ValueError(f"Parent_Path is not a directory: {parent_path}")
+
+
+if __name__ == '__main__':
+    main()

xnalara_io_Tools/__init__.py

···
+from . import xps_tools
+from .modules.ALXAddonUpdater.ALXAddonUpdater.ALX_AddonUpdater import \
+    Alx_Addon_Updater
+from .modules.ALXInfoSystem.ALXInfoSystem import ALX_InfoSystem
+from .modules.ALXModuleManager.ALXModuleManager.ALX_ModuleManager import \
+    Alx_Module_Manager
+
+bl_info = {
+    "name": "XNALara-io-Tools",
+    "author": "Valerie Bosco[Valy Arhal], johnzero7[Original Developer]",
+    "description": "Import-Export for XNALara/XPS files",
+    "version": (1, 2, 4),
+    "blender": (3, 6, 0),
+    "category": "Import-Export",
+    "location": "File > Import-Export > XNALara/XPS",
+    "doc_url": "https://github.com/Valerie-Bosco/XNALara-io-Tools/wiki",
+    "tracker_url": "https://github.com/Valerie-Bosco/XNALara-io-Tools/issues",
+}
+
+
+module_manager = Alx_Module_Manager(
+    path=__path__,
+    globals=globals(),
+    mute=True
+)
+addon_updater = Alx_Addon_Updater(
+    path=__path__,
+    bl_info=bl_info,
+    engine="Github",
+    engine_user_name="Valerie-Bosco",
+    engine_repo_name="XNALara-io-Tools",
+    manual_download_website="https://github.com/Valerie-Bosco/XNALara-io-Tools/releases/tag/main_branch_latest"
+)
+
+
+def register():
+    module_manager.developer_register_modules()
+    addon_updater.register_addon_updater(True)
+
+    # ALX_InfoSystem.register_info()
+
+    xps_tools.register()
+
+
+def unregister():
+    module_manager.developer_unregister_modules()
+    addon_updater.unregister_addon_updater()
+
+    # ALX_InfoSystem.unregister_info()
+
+    xps_tools.unregister()
+
+
+if __name__ == "__main__":
+    register()

xnalara_io_Tools/armature_tools/xnal_armature_utilities.py

···
+from typing import Iterable
+
+import bpy
+
+from ..utilities.color_utilities import random_color_rgb
+
+xnal_model_bone_names = []
+
+
+def Xnal_CreateArmatureObject(name="Armature"):
+    armature_da = bpy.data.armatures.new(name)
+    armature_da.display_type = 'STICK'
+    armature_obj = bpy.data.objects.new(name, armature_da)
+    return armature_obj
+
+
+def XnaL_AddRegisterBoneName(name: str):
+    xnal_model_bone_names.append(name)
+
+
+def XnaL_ShowHideBones(bones: Iterable[bpy.types.Bone], visibility: bool):
+    try:
+        bones[0]
+        for bone in bones:
+            bone.hide = visibility
+    except:
+        pass
+
+
+def XnaL_GetBoneNameByIndex(original_index: int):
+    try:
+        return xnal_model_bone_names[original_index]
+    except:
+        return None
+
+
+def XnaL_CreateBoneCollection(armature_object: bpy.types.Object, mesh_object: bpy.types.Object):
+    armature: bpy.types.Armature = armature_object.data
+    pose_bone_normal_color = random_color_rgb()
+    pose_bone_select_color = random_color_rgb()
+    pose_bone_active_color = random_color_rgb()
+
+    if (bpy.app.version[0:2] in [(3, 6)]):
+        bone_group = armature.pose.bone_groups.new(name=mesh_object.name)
+        bone_group.color_set = "CUSTOM"
+        bone_group.colors.normal = pose_bone_normal_color
+        bone_group.colors.select = pose_bone_select_color
+        bone_group.colors.active = pose_bone_active_color
+
+        for bone_vertex_group_name in mesh_object.vertex_groups.keys():
+            pose_bone = armature.pose.bones.get(bone_vertex_group_name)
+
+            if (pose_bone is not None):
+                pose_bone.bone_group = bone_group
+
+    if (bpy.app.version[0:2] in [(4, 0), (4, 1), (4, 2), (4, 3), (4, 4)]):
+        bone_collection = armature.collections.new(name=mesh_object.name)
+
+        for bone_vertex_group_name in mesh_object.vertex_groups.keys():
+            pose_bone = armature_object.pose.bones.get(bone_vertex_group_name)
+
+            if (pose_bone is not None):
+                bone_collection.assign(pose_bone)
+                pose_bone.color.palette = "CUSTOM"
+                pose_bone.color.custom.normal = pose_bone_normal_color
+                pose_bone.color.custom.select = pose_bone_select_color
+                pose_bone.color.custom.active = pose_bone_active_color

xnalara_io_Tools/ascii_ops.py

···
+def readline(file):
+    """Read a line and strip spaces."""
+    line = file.readline()
+    line = line.strip()
+    return line
+
+
+def getFloat(value):
+    """Read value and returns a float. If error return NaN."""
+    if value:
+        try:
+            return float(value)
+        except ValueError:
+            return float('NaN')
+    return value
+
+
+def getInt(value):
+    """Read value and returns a int. If error return None."""
+    try:
+        return int(value)
+    except ValueError:
+        return None
+
+
+def ignoreComment(line):
+    """Read line. Ignore comment."""
+    line = line.replace('#', ' ')
+    line = line.split()[0]
+    return line
+
+
+def ignoreStringComment(line):
+    """Read line. Ignore comment."""
+    line = line.split('#')[0].strip()
+    return line
+
+
+def readInt(file):
+    """Read line. Return Int."""
+    line = readline(file)
+    value = ignoreComment(line)
+    number = getInt(value)
+    return number
+
+
+def readString(file):
+    """Read line. Ignore Comments."""
+    # String Lenght
+    line = readline(file)
+    string = ignoreStringComment(line)
+    return string
+
+
+def splitValues(line):
+    """Read line. Return value list."""
+    line = line.replace('#', ' ')
+    values = line.split()
+    return values

xnalara_io_Tools/bin_ops.py

···
+import struct
+
+from . import xps_const
+
+
+# Format
+class TypeFormat:
+    SByte = '<b'
+    Byte = '<B'
+    Int16 = '<h'
+    UInt16 = '<H'
+    Int32 = '<i'
+    UInt32 = '<I'
+    Int64 = '<l'
+    UInt64 = '<L'
+    Single = '<f'
+    Double = '<d'
+
+
+def roundToMultiple(numToRound, multiple):
+    return (numToRound + multiple - 1) // multiple * multiple
+
+
+def readByte(file):
+    numberBin = file.read(1)
+    number = struct.unpack(TypeFormat.Byte, numberBin)[0]
+    return number
+
+
+def writeByte(number):
+    bytesBin = struct.pack(TypeFormat.Byte, number)
+    return bytesBin
+
+
+def readUInt16(file):
+    numberBin = file.read(2)
+    number = struct.unpack(TypeFormat.UInt16, numberBin)[0]
+    return number
+
+
+def writeUInt16(number):
+    uInt16 = struct.pack(TypeFormat.UInt16, number)
+    return uInt16
+
+
+def readInt16(file):
+    numberBin = file.read(2)
+    number = struct.unpack(TypeFormat.Int16, numberBin)[0]
+    return number
+
+
+def writeInt16(number):
+    int16 = struct.pack(TypeFormat.Int16, number)
+    return int16
+
+
+def readUInt32(file):
+    numberBin = file.read(4)
+    number = struct.unpack(TypeFormat.UInt32, numberBin)[0]
+    return number
+
+
+def writeUInt32(number):
+    uInt32 = struct.pack(TypeFormat.UInt32, number)
+    return uInt32
+
+
+def readSingle(file):
+    numberBin = file.read(4)
+    single = struct.unpack(TypeFormat.Single, numberBin)[0]
+    return single
+
+
+def writeSingle(number):
+    single = struct.pack(TypeFormat.Single, number)
+    return single
+
+
+def readString(file, length):
+    try:
+        pos1 = file.tell()
+        byteString = file.read(length)
+        pos2 = file.tell()
+        string = ''
+        string = decodeBytes(byteString)
+    except Exception:
+        print('*' * 40)
+        print('pos len', pos1)
+        print('pos str', pos2)
+        print('pos', file.tell())
+        print('len', length)
+        print('str', byteString)
+        string = decodeBytes(byteString)
+    return string
+
+
+def writeString(string):
+    # String Lenght
+    byteString = encodeString(string)
+    return byteString
+
+
+def decodeBytes(bytes):
+    # print(bytes)
+    return bytes.decode(xps_const.ENCODING_READ)
+
+
+def encodeString(string):
+    # print(string)
+    return string.encode(xps_const.ENCODING_WRITE)
+
+
+def hasHeader(fileformat='.xps'):
+    return fileformat == '.xps'
+
+
+def hasTangentVersion(verMayor, verMinor, hasHeader=True):
+    return (verMinor <= 12 and verMayor <= 2) if hasHeader else True
+
+
+def hasVariableWeights(verMayor, verMinor, hasHeader=True):
+    return (verMayor >= 3) if hasHeader else False

xnalara_io_Tools/export_obj.py

···
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+import operator
+import os
+
+import bpy
+import bpy_extras.io_utils
+import mathutils
+from bpy_extras.wm_utils.progress_report import (ProgressReport,
+                                                 ProgressReportSubstep)
+
+
+def name_compat(name):
+    if name is None:
+        return 'None'
+    else:
+        return name.replace(' ', '_')
+
+
+def mesh_triangulate(me):
+    import bmesh
+    bm = bmesh.new()
+    bm.from_mesh(me)
+    bmesh.ops.triangulate(bm, faces=bm.faces)
+    bm.to_mesh(me)
+    bm.free()
+
+
+def write_arl(scene, filepath, path_mode, copy_set, mtl_dict, armatures):
+    source_dir = os.path.dirname(bpy.data.filepath)
+    dest_dir = os.path.dirname(filepath)
+
+    armature_ob, ob_mat, EXPORT_GLOBAL_MATRIX = armatures[0]
+
+    if armature_ob:
+        with open(filepath, "w", encoding="utf8", newline="\n") as f:
+            fw = f.write
+            fw('# XPS NGFF ARL Blender Exporter file: %r\n' %
+                (os.path.basename(bpy.data.filepath) or "None"))
+            fw('# Version: %g\n' % (0.1))
+            fw('%i # bone Count\n' % len(armature_ob.data.bones))
+
+            armature_data = armature_ob.data.copy()
+            armature_data.transform(EXPORT_GLOBAL_MATRIX * ob_mat)
+
+            bones = armature_data.bones
+            for bone in bones:
+                fw('%s\n' % bone.name)
+                parent_bone_id = -1
+                if bone.parent:
+                    parent_bone_name = bone.parent.name
+                    parent_bone_id = bones.find(parent_bone_name)
+                fw('%i\n' % parent_bone_id)
+                fw('%g %g %g\n' % bone.head_local[:])
+
+
+def write_mtl(scene, filepath, path_mode, copy_set, mtl_dict):
+    from mathutils import Color, Vector
+
+    world = scene.world
+    if world:
+        world_amb = world.ambient_color
+    else:
+        world_amb = Color((0.0, 0.0, 0.0))
+
+    source_dir = os.path.dirname(bpy.data.filepath)
+    dest_dir = os.path.dirname(filepath)
+
+    with open(filepath, "w", encoding="utf8", newline="\n") as f:
+        fw = f.write
+
+        fw('# Blender MTL File: %r\n' %
+            (os.path.basename(bpy.data.filepath) or "None"))
+        fw('# Material Count: %i\n' % len(mtl_dict))
+
+        mtl_dict_values = list(mtl_dict.values())
+        mtl_dict_values.sort(key=lambda m: m[0])
+
+        # Write material/image combinations we have used.
+        # Using mtl_dict.values() directly gives un-predictable order.
+        for mtl_mat_name, mat, face_img in mtl_dict_values:
+            # Get the Blender data for the material and the image.
+            # Having an image named None will make a bug, dont do it :)
+
+            # Define a new material: matname_imgname
+            fw('\nnewmtl %s\n' % mtl_mat_name)
+
+            if mat:
+                use_mirror = mat.raytrace_mirror.use and mat.raytrace_mirror.reflect_factor != 0.0
+
+                # convert from blenders spec to 0 - 1000 range.
+                if mat.specular_shader == 'WARDISO':
+                    tspec = (0.4 - mat.specular_slope) / 0.0004
+                else:
+                    tspec = (mat.specular_hardness - 1) / 0.51
+                fw('Ns %.6f\n' % tspec)
+                del tspec
+
+                # Ambient
+                if use_mirror:
+                    fw('Ka %.6f %.6f %.6f\n' % (mat.raytrace_mirror.reflect_factor * mat.mirror_color)[:])
+                else:
+                    fw('Ka %.6f %.6f %.6f\n' % (mat.ambient, mat.ambient, mat.ambient))  # Do not use world color!
+                fw('Kd %.6f %.6f %.6f\n' % (mat.diffuse_intensity * mat.diffuse_color)[:])  # Diffuse
+                fw('Ks %.6f %.6f %.6f\n' % (mat.specular_intensity * mat.specular_color)[:])  # Specular
+                # Emission, not in original MTL standard but seems pretty common, see T45766.
+                # XXX Blender has no color emission, it's using diffuse color instead...
+                fw('Ke %.6f %.6f %.6f\n' % (mat.emit * mat.diffuse_color)[:])
+                if hasattr(mat, "raytrace_transparency") and hasattr(mat.raytrace_transparency, "ior"):
+                    fw('Ni %.6f\n' % mat.raytrace_transparency.ior)  # Refraction index
+                else:
+                    fw('Ni %.6f\n' % 1.0)
+                fw('d %.6f\n' % mat.alpha)  # Alpha (obj uses 'd' for dissolve)
+
+                # See http://en.wikipedia.org/wiki/Wavefront_.obj_file for whole list of values...
+                # Note that mapping is rather fuzzy sometimes, trying to do our best here.
+                if mat.use_shadeless:
+                    fw('illum 0\n')  # ignore lighting
+                elif mat.specular_intensity == 0:
+                    fw('illum 1\n')  # no specular.
+                elif use_mirror:
+                    if mat.use_transparency and mat.transparency_method == 'RAYTRACE':
+                        if mat.raytrace_mirror.fresnel != 0.0:
+                            fw('illum 7\n')  # Reflection, Transparency, Ray trace and Fresnel
+                        else:
+                            fw('illum 6\n')  # Reflection, Transparency, Ray trace
+                    elif mat.raytrace_mirror.fresnel != 0.0:
+                        fw('illum 5\n')  # Reflection, Ray trace and Fresnel
+                    else:
+                        fw('illum 3\n')  # Reflection and Ray trace
+                elif mat.use_transparency and mat.transparency_method == 'RAYTRACE':
+                    fw('illum 9\n')  # 'Glass' transparency and no Ray trace reflection... fuzzy matching, but...
+                else:
+                    fw('illum 2\n')  # light normaly
+
+            else:
+                # Write a dummy material here?
+                fw('Ns 0\n')
+                fw('Ka %.6f %.6f %.6f\n' % world_amb[:])  # Ambient, uses mirror color,
+                fw('Kd 0.8 0.8 0.8\n')
+                fw('Ks 0.8 0.8 0.8\n')
+                fw('d 1\n')  # No alpha
+                fw('illum 2\n')  # light normaly
+
+            # Write images!
+            if face_img:  # We have an image on the face!
+                filepath = face_img.filepath
+                if filepath:  # may be '' for generated images
+                    # write relative image path
+                    filepath = bpy_extras.io_utils.path_reference(
+                        filepath, source_dir, dest_dir,
+                        path_mode, "", copy_set, face_img.library)
+                    fw('map_Kd %s\n' % filepath)  # Diffuse mapping image
+                    del filepath
+                else:
+                    # so we write the materials image.
+                    face_img = None
+
+            if mat:  # No face image. if we havea material search for MTex image.
+                image_map = {}
+                # backwards so topmost are highest priority
+                for mtex in reversed(mat.texture_slots):
+                    if mtex and mtex.texture and mtex.texture.type == 'IMAGE':
+                        image = mtex.texture.image
+                        if image:
+                            # texface overrides others
+                            if (mtex.use_map_color_diffuse and
+                                    (face_img is None) and
+                                    (mtex.use_map_warp is False) and
+                                    (mtex.texture_coords != 'REFLECTION')):
+                                image_map["map_Kd"] = (mtex, image)
+                            if mtex.use_map_ambient:
+                                image_map["map_Ka"] = (mtex, image)
+                            # this is the Spec intensity channel but Ks stands for specular Color
+                            '''
+                            if mtex.use_map_specular:
+                                image_map["map_Ks"] = (mtex, image)
+                            '''
+                            if mtex.use_map_color_spec:  # specular color
+                                image_map["map_Ks"] = (mtex, image)
+                            if mtex.use_map_hardness:  # specular hardness/glossiness
+                                image_map["map_Ns"] = (mtex, image)
+                            if mtex.use_map_alpha:
+                                image_map["map_d"] = (mtex, image)
+                            if mtex.use_map_translucency:
+                                image_map["map_Tr"] = (mtex, image)
+                            if mtex.use_map_normal:
+                                image_map["map_Bump"] = (mtex, image)
+                            if mtex.use_map_displacement:
+                                image_map["disp"] = (mtex, image)
+                            if mtex.use_map_color_diffuse and (mtex.texture_coords == 'REFLECTION'):
+                                image_map["refl"] = (mtex, image)
+                            if mtex.use_map_emit:
+                                image_map["map_Ke"] = (mtex, image)
+
+                for key, (mtex, image) in sorted(image_map.items()):
+                    filepath = bpy_extras.io_utils.path_reference(
+                        image.filepath, source_dir, dest_dir,
+                        path_mode, "", copy_set, image.library)
+                    options = []
+                    if key == "map_Bump":
+                        if mtex.normal_factor != 1.0:
+                            options.append('-bm %.6f' % mtex.normal_factor)
+                    if mtex.offset != Vector((0.0, 0.0, 0.0)):
+                        options.append('-o %.6f %.6f %.6f' % mtex.offset[:])
+                    if mtex.scale != Vector((1.0, 1.0, 1.0)):
+                        options.append('-s %.6f %.6f %.6f' % mtex.scale[:])
+                    fw('%s %s %s\n' % (key, " ".join(options), repr(filepath)[1:-1]))
+
+
+def test_nurbs_compat(ob):
+    if ob.type != 'CURVE':
+        return False
+
+    for nu in ob.data.splines:
+        if nu.point_count_v == 1 and nu.type != 'BEZIER':  # not a surface and not bezier
+            return True
+
+    return False
+
+
+def write_nurb(fw, ob, ob_mat):
+    tot_verts = 0
+    cu = ob.data
+
+    # use negative indices
+    for nu in cu.splines:
+        if nu.type == 'POLY':
+            DEG_ORDER_U = 1
+        else:
+            DEG_ORDER_U = nu.order_u - 1  # odd but tested to be correct
+
+        if nu.type == 'BEZIER':
+            print("\tWarning, bezier curve:", ob.name, "only poly and nurbs curves supported")
+            continue
+
+        if nu.point_count_v > 1:
+            print("\tWarning, surface:", ob.name, "only poly and nurbs curves supported")
+            continue
+
+        if len(nu.points) <= DEG_ORDER_U:
+            print("\tWarning, order_u is lower then vert count, skipping:", ob.name)
+            continue
+
+        pt_num = 0
+        do_closed = nu.use_cyclic_u
+        do_endpoints = (do_closed == 0) and nu.use_endpoint_u
+
+        for pt in nu.points:
+            fw('v %.6f %.6f %.6f\n' % (ob_mat * pt.co.to_3d())[:])
+            pt_num += 1
+        tot_verts += pt_num
+
+        fw('g %s\n' % (name_compat(ob.name)))  # name_compat(ob.getData(1)) could use the data name too
+        fw('cstype bspline\n')  # not ideal, hard coded
+        fw('deg %d\n' % DEG_ORDER_U)  # not used for curves but most files have it still
+
+        curve_ls = [-(i + 1) for i in range(pt_num)]
+
+        # 'curv' keyword
+        if do_closed:
+            if DEG_ORDER_U == 1:
+                pt_num += 1
+                curve_ls.append(-1)
+            else:
+                pt_num += DEG_ORDER_U
+                curve_ls = curve_ls + curve_ls[0:DEG_ORDER_U]
+
+        fw('curv 0.0 1.0 %s\n' % (" ".join([str(i) for i in curve_ls])))  # Blender has no U and V values for the curve
+
+        # 'parm' keyword
+        tot_parm = (DEG_ORDER_U + 1) + pt_num
+        tot_parm_div = float(tot_parm - 1)
+        parm_ls = [(i / tot_parm_div) for i in range(tot_parm)]
+
+        if do_endpoints:  # end points, force param
+            for i in range(DEG_ORDER_U + 1):
+                parm_ls[i] = 0.0
+                parm_ls[-(1 + i)] = 1.0
+
+        fw("parm u %s\n" % " ".join(["%.6f" % i for i in parm_ls]))
+
+        fw('end\n')
+
+    return tot_verts
+
+
+def write_file(filepath, objects, scene,
+               EXPORT_TRI=False,
+               EXPORT_EDGES=False,
+               EXPORT_SMOOTH_GROUPS=False,
+               EXPORT_SMOOTH_GROUPS_BITFLAGS=False,
+               EXPORT_NORMALS=False,
+               EXPORT_VCOLORS=False,
+               EXPORT_UV=True,
+               EXPORT_MTL=True,
+               EXPORT_APPLY_MODIFIERS=True,
+               EXPORT_BLEN_OBS=True,
+               EXPORT_GROUP_BY_OB=False,
+               EXPORT_GROUP_BY_MAT=False,
+               EXPORT_KEEP_VERT_ORDER=False,
+               EXPORT_POLYGROUPS=False,
+               EXPORT_CURVE_AS_NURBS=True,
+               EXPORT_GLOBAL_MATRIX=None,
+               EXPORT_PATH_MODE='AUTO',
+               progress=ProgressReport(),
+               ):
+    """
+    Basic write function. The context and options must be already set
+    This can be accessed externaly
+    eg.
+    write( 'c:\\test\\foobar.obj', Blender.Object.GetSelected() ) # Using default options.
+    """
+    if EXPORT_GLOBAL_MATRIX is None:
+        EXPORT_GLOBAL_MATRIX = mathutils.Matrix()
+
+    def veckey3d(v):
+        return round(v.x, 4), round(v.y, 4), round(v.z, 4)
+
+    def colkey4d(v):
+        return round(v[0], 4), round(v[1], 4), round(v[2], 4), 1
+
+    def veckey2d(v):
+        return round(v[0], 4), round(v[1], 4)
+
+    def findVertexGroupName(face, vWeightMap):
+        """
+        Searches the vertexDict to see what groups is assigned to a given face.
+        We use a frequency system in order to sort out the name because a given vetex can
+        belong to two or more groups at the same time. To find the right name for the face
+        we list all the possible vertex group names with their frequency and then sort by
+        frequency in descend order. The top element is the one shared by the highest number
+        of vertices is the face's group
+        """
+        weightDict = {}
+        for vert_index in face.vertices:
+            vWeights = vWeightMap[vert_index]
+            for vGroupName, weight in vWeights:
+                weightDict[vGroupName] = weightDict.get(vGroupName, 0.0) + weight
+
+        if weightDict:
+            return max((weight, vGroupName) for vGroupName, weight in weightDict.items())[1]
+        else:
+            return '(null)'
+
+    with ProgressReportSubstep(progress, 2, "OBJ Export path: %r" % filepath, "OBJ Export Finished") as subprogress1:
+        with open(filepath, "w", encoding="utf8", newline="\n") as f:
+            fw = f.write
+
+            # Write Header
+            fw('# Blender v%s OBJ File: %r\n' % (bpy.app.version_string, os.path.basename(bpy.data.filepath)))
+            fw('# www.blender.org\n')
+
+            # Tell the obj file what material file to use.
+            if EXPORT_MTL:
+                mtlfilepath = os.path.splitext(filepath)[0] + ".mtl"
+                # filepath can contain non utf8 chars, use repr
+                fw('mtllib %s\n' % repr(os.path.basename(mtlfilepath))[1:-1])
+
+            # Tell the obj file what armature file to use.
+            EXPORT_ARL = True
+            if EXPORT_ARL:
+                arlfilepath = os.path.splitext(filepath)[0] + ".arl"
+                # filepath can contain non utf8 chars, use repr
+                fw('arllib %s\n' % repr(os.path.basename(arlfilepath))[1:-1])
+
+            # Initialize totals, these are updated each object
+            totverts = totuvco = totno = totvcol = 1
+
+            face_vert_index = 1
+
+            # A Dict of Materials
+            # (material.name, image.name):matname_imagename # matname_imagename has gaps removed.
+            mtl_dict = {}
+            # Used to reduce the usage of matname_texname materials, which can become annoying in case of
+            # repeated exports/imports, yet keeping unique mat names per keys!
+            # mtl_name: (material.name, image.name)
+            mtl_rev_dict = {}
+
+            copy_set = set()
+
+            # Get all meshes
+            subprogress1.enter_substeps(len(objects))
+            armatures = []
+            for i, ob_main in enumerate(sorted(objects, key=operator.attrgetter('name'))):
+                armature = ob_main.find_armature()
+                if armature:
+                    armatures += [[armature, armature.matrix_world, EXPORT_GLOBAL_MATRIX]]
+                # ignore dupli children
+                if ob_main.parent and ob_main.parent.dupli_type in {'VERTS', 'FACES'}:
+                    # XXX
+                    subprogress1.step("Ignoring %s, dupli child..." % ob_main.name)
+                    continue
+
+                obs = [(ob_main, ob_main.matrix_world)]
+                if ob_main.dupli_type != 'NONE':
+                    # XXX
+                    print('creating dupli_list on', ob_main.name)
+                    ob_main.dupli_list_create(scene)
+
+                    obs += [(dob.object, dob.matrix) for dob in ob_main.dupli_list]
+
+                    # XXX debug print
+                    print(ob_main.name, 'has', len(obs) - 1, 'dupli children')
+
+                subprogress1.enter_substeps(len(obs))
+                for ob, ob_mat in obs:
+                    with ProgressReportSubstep(subprogress1, 6) as subprogress2:
+                        uv_unique_count = no_unique_count = vc_unique_count = 0
+
+                        # Nurbs curve support
+                        if EXPORT_CURVE_AS_NURBS and test_nurbs_compat(ob):
+                            ob_mat = EXPORT_GLOBAL_MATRIX * ob_mat
+                            totverts += write_nurb(fw, ob, ob_mat)
+                            continue
+                        # END NURBS
+
+                        try:
+                            me = ob.to_mesh(scene, EXPORT_APPLY_MODIFIERS, 'PREVIEW', calc_tessface=False)
+                        except RuntimeError:
+                            me = None
+
+                        if me is None:
+                            continue
+
+                        me.transform(EXPORT_GLOBAL_MATRIX * ob_mat)
+
+                        if EXPORT_TRI:
+                            # _must_ do this first since it re-allocs arrays
+                            mesh_triangulate(me)
+
+                        if EXPORT_UV:
+                            faceuv = len(me.uv_textures) > 0
+                            if faceuv:
+                                uv_texture = me.uv_textures.active.data[:]
+                                uv_layer = me.uv_layers.active.data[:]
+                        else:
+                            faceuv = False
+
+                        me_verts = me.vertices[:]
+
+                        # Make our own list so it can be sorted to reduce context switching
+                        face_index_pairs = [(face, index) for index, face in enumerate(me.polygons)]
+                        # faces = [ f for f in me.tessfaces ]
+
+                        if EXPORT_EDGES:
+                            edges = me.edges
+                        else:
+                            edges = []
+
+                        if not (len(face_index_pairs) + len(edges) + len(me.vertices)):  # Make sure there is something to write
+                            # clean up
+                            bpy.data.meshes.remove(me)
+                            continue  # dont bother with this mesh.
+
+                        if (bpy.app.version[0:2] in [(3, 6), (4, 0)]):
+                            if EXPORT_NORMALS and face_index_pairs:
+                                me.calc_normals_split()
+                            # No need to call me.free_normals_split later, as this mesh is deleted anyway!
+
+                        loops = me.loops
+                        vcolors = []
+                        if me.vertex_colors:
+                            vcolors = me.vertex_colors[0]
+
+                        if (EXPORT_SMOOTH_GROUPS or EXPORT_SMOOTH_GROUPS_BITFLAGS) and face_index_pairs:
+                            smooth_groups, smooth_groups_tot = me.calc_smooth_groups(EXPORT_SMOOTH_GROUPS_BITFLAGS)
+                            if smooth_groups_tot <= 1:
+                                smooth_groups, smooth_groups_tot = (), 0
+                        else:
+                            smooth_groups, smooth_groups_tot = (), 0
+
+                        materials = me.materials[:]
+                        material_names = [m.name if m else None for m in materials]
+
+                        # avoid bad index errors
+                        if not materials:
+                            materials = [None]
+                            material_names = [name_compat(None)]
+
+                        # Sort by Material, then images
+                        # so we dont over context switch in the obj file.
+                        if EXPORT_KEEP_VERT_ORDER:
+                            pass
+                        else:
+                            if faceuv:
+                                if smooth_groups:
+                                    def sort_func(a): return (a[0].material_index,
+                                                              hash(uv_texture[a[1]].image),
+                                                              smooth_groups[a[1]] if a[0].use_smooth else False)
+                                else:
+                                    def sort_func(a): return (a[0].material_index,
+                                                              hash(uv_texture[a[1]].image),
+                                                              a[0].use_smooth)
+                            elif len(materials) > 1:
+                                if smooth_groups:
+                                    def sort_func(a): return (a[0].material_index,
+                                                              smooth_groups[a[1]] if a[0].use_smooth else False)
+                                else:
+                                    def sort_func(a): return (a[0].material_index,
+                                                              a[0].use_smooth)
+                            else:
+                                # no materials
+                                if smooth_groups:
+                                    def sort_func(a): return smooth_groups[a[1] if a[0].use_smooth else False]
+                                else:
+                                    def sort_func(a): return a[0].use_smooth
+
+                            face_index_pairs.sort(key=sort_func)
+
+                            del sort_func
+
+                        # Set the default mat to no material and no image.
+                        contextMat = 0, 0  # Can never be this, so we will label a new material the first chance we get.
+                        contextSmooth = None  # Will either be true or false,  set bad to force initialization switch.
+
+                        if EXPORT_BLEN_OBS or EXPORT_GROUP_BY_OB:
+                            name1 = ob.name
+                            name2 = ob.data.name
+                            if name1 == name2:
+                                obnamestring = name_compat(name1)
+                            else:
+                                obnamestring = '%s_%s' % (name_compat(name1), name_compat(name2))
+
+                            if EXPORT_BLEN_OBS:
+                                fw('o %s\n' % obnamestring)  # Write Object name
+                            else:  # if EXPORT_GROUP_BY_OB:
+                                fw('g %s\n' % obnamestring)
+
+                        subprogress2.step()
+
+                        # Vert
+                        for v in me_verts:
+                            fw('v %.6f %.6f %.6f\n' % v.co[:])
+
+                        subprogress2.step()
+
+                        # UV
+                        if faceuv:
+                            # in case removing some of these dont get defined.
+                            uv = f_index = uv_index = uv_key = uv_val = uv_ls = None
+
+                            uv_face_mapping = [None] * len(face_index_pairs)
+
+                            uv_dict = {}
+                            uv_get = uv_dict.get
+                            for f, f_index in face_index_pairs:
+                                uv_ls = uv_face_mapping[f_index] = []
+                                for uv_index, l_index in enumerate(f.loop_indices):
+                                    uv = uv_layer[l_index].uv
+                                    # include the vertex index in the key so we don't share UV's between vertices,
+                                    # allowed by the OBJ spec but can cause issues for other importers, see: T47010.
+
+                                    # this works too, shared UV's for all verts
+                                    # ~ uv_key = veckey2d(uv)
+                                    uv_key = loops[l_index].vertex_index, veckey2d(uv)
+
+                                    uv_val = uv_get(uv_key)
+                                    if uv_val is None:
+                                        uv_val = uv_dict[uv_key] = uv_unique_count
+                                        fw('vt %.4f %.4f\n' % uv[:])
+                                        uv_unique_count += 1
+                                    uv_ls.append(uv_val)
+
+                            del uv_dict, uv, f_index, uv_index, uv_ls, uv_get, uv_key, uv_val
+                            # Only need uv_unique_count and uv_face_mapping
+
+                        subprogress2.step()
+
+                        # NORMAL, Smooth/Non smoothed.
+                        if EXPORT_NORMALS:
+                            no_key = no_val = None
+                            normals_to_idx = {}
+                            no_get = normals_to_idx.get
+                            loops_to_normals = [0] * len(loops)
+                            for f, f_index in face_index_pairs:
+                                for l_idx in f.loop_indices:
+                                    no_key = veckey3d(loops[l_idx].normal)
+                                    no_val = no_get(no_key)
+                                    if no_val is None:
+                                        no_val = normals_to_idx[no_key] = no_unique_count
+                                        fw('vn %.4f %.4f %.4f\n' % no_key)
+                                        no_unique_count += 1
+                                    loops_to_normals[l_idx] = no_val
+                            del normals_to_idx, no_get, no_key, no_val
+                        else:
+                            loops_to_normals = []
+
+                        # Vertex Color
+                        if EXPORT_VCOLORS and vcolors:
+                            no_key = no_val = None
+                            vcolors_to_idx = {}
+                            no_get = vcolors_to_idx.get
+                            loops_to_vcolors = [0] * len(vcolors.data)
+                            for f, f_index in face_index_pairs:
+                                for l_idx in f.loop_indices:
+                                    no_key = colkey4d(vcolors.data[l_idx].color)
+                                    no_val = no_get(no_key)
+                                    if no_val is None:
+                                        no_val = vcolors_to_idx[no_key] = vc_unique_count
+                                        fw('vc %.4f %.4f %.4f %.4f\n' % no_key)
+                                        vc_unique_count += 1
+                                    loops_to_vcolors[l_idx] = no_val
+                            del vcolors_to_idx, no_get, no_key, no_val
+                        else:
+                            loops_to_vcolors = []
+
+                        # Vertex wights
+                        EXPORT_ARL = True
+                        vweights = ob.vertex_groups
+                        armature_ob = ob.find_armature()
+                        armature_data = armature_ob.data
+                        if EXPORT_ARL and armature:
+                            for v in me_verts:
+                                weights = [[armature_data.bones.find(vweights[g.group].name), g.weight] for g in v.groups]
+                                weights += [[0, 0]] * (4 - len(weights))
+                                weights.sort(key=operator.itemgetter(1), reverse=True)
+                                fw('bw [%s]\n' % ', '.join('[%i,%g]' % tuple(pair) for pair in weights))
+
+                        if not faceuv:
+                            f_image = None
+
+                        subprogress2.step()
+
+                        # XXX
+                        if EXPORT_POLYGROUPS:
+                            # Retrieve the list of vertex groups
+                            vertGroupNames = ob.vertex_groups.keys()
+                            if vertGroupNames:
+                                currentVGroup = ''
+                                # Create a dictionary keyed by face id and listing, for each vertex, the vertex groups it belongs to
+                                vgroupsMap = [[] for _i in range(len(me_verts))]
+                                for v_idx, v_ls in enumerate(vgroupsMap):
+                                    v_ls[:] = [(vertGroupNames[g.group], g.weight) for g in me_verts[v_idx].groups]
+
+                        for f, f_index in face_index_pairs:
+                            f_smooth = f.use_smooth
+                            if f_smooth and smooth_groups:
+                                f_smooth = smooth_groups[f_index]
+                            f_mat = min(f.material_index, len(materials) - 1)
+
+                            if faceuv:
+                                tface = uv_texture[f_index]
+                                f_image = tface.image
+
+                            # MAKE KEY
+                            if faceuv and f_image:  # Object is always true.
+                                key = material_names[f_mat], f_image.name
+                            else:
+                                key = material_names[f_mat], None  # No image, use None instead.
+
+                            # Write the vertex group
+                            if EXPORT_POLYGROUPS:
+                                if vertGroupNames:
+                                    # find what vertext group the face belongs to
+                                    vgroup_of_face = findVertexGroupName(f, vgroupsMap)
+                                    if vgroup_of_face != currentVGroup:
+                                        currentVGroup = vgroup_of_face
+                                        fw('g %s\n' % vgroup_of_face)
+
+                            # CHECK FOR CONTEXT SWITCH
+                            if key == contextMat:
+                                pass  # Context already switched, dont do anything
+                            else:
+                                if key[0] is None and key[1] is None:
+                                    # Write a null material, since we know the context has changed.
+                                    if EXPORT_GROUP_BY_MAT:
+                                        # can be mat_image or (null)
+                                        fw("g %s_%s\n" % (name_compat(ob.name), name_compat(ob.data.name)))
+                                    if EXPORT_MTL:
+                                        fw("usemtl (null)\n")  # mat, image
+
+                                else:
+                                    mat_data = mtl_dict.get(key)
+                                    if not mat_data:
+                                        # First add to global dict so we can export to mtl
+                                        # Then write mtl
+
+                                        # Make a new names from the mat and image name,
+                                        # converting any spaces to underscores with name_compat.
+
+                                        # If none image dont bother adding it to the name
+                                        # Try to avoid as much as possible adding texname (or other things)
+                                        # to the mtl name (see [#32102])...
+                                        mtl_name = "%s" % name_compat(key[0])
+                                        if mtl_rev_dict.get(mtl_name, None) not in {key, None}:
+                                            if key[1] is None:
+                                                tmp_ext = "_NONE"
+                                            else:
+                                                tmp_ext = "_%s" % name_compat(key[1])
+                                            i = 0
+                                            while mtl_rev_dict.get(mtl_name + tmp_ext, None) not in {key, None}:
+                                                i += 1
+                                                tmp_ext = "_%3d" % i
+                                            mtl_name += tmp_ext
+                                        mat_data = mtl_dict[key] = mtl_name, materials[f_mat], f_image
+                                        mtl_rev_dict[mtl_name] = key
+
+                                    if EXPORT_GROUP_BY_MAT:
+                                        # can be mat_image or (null)
+                                        fw("g %s_%s_%s\n" % (name_compat(ob.name), name_compat(ob.data.name), mat_data[0]))
+                                    if EXPORT_MTL:
+                                        fw("usemtl %s\n" % mat_data[0])  # can be mat_image or (null)
+
+                            contextMat = key
+                            if f_smooth != contextSmooth:
+                                if f_smooth:  # on now off
+                                    if smooth_groups:
+                                        f_smooth = smooth_groups[f_index]
+                                        fw('s %d\n' % f_smooth)
+                                    else:
+                                        fw('s 1\n')
+                                else:  # was off now on
+                                    fw('s off\n')
+                                contextSmooth = f_smooth
+
+                            f_v = [(vi, me_verts[v_idx], l_idx)
+                                   for vi, (v_idx, l_idx) in enumerate(zip(f.vertices, f.loop_indices))]
+
+                            fw('f')
+                            if faceuv:
+                                if EXPORT_NORMALS:
+                                    for vi, v, li in f_v:
+                                        fw(" %d/%d/%d" % (totverts + v.index,
+                                                          totuvco + uv_face_mapping[f_index][vi],
+                                                          totno + loops_to_normals[li],
+                                                          ))  # vert, uv, normal
+                                        if EXPORT_VCOLORS and vcolors:
+                                            fw("/%d" % (totvcol + loops_to_vcolors[li]))  # add vcolor
+                                else:  # No Normals
+                                    for vi, v, li in f_v:
+                                        fw(" %d/%d" % (totverts + v.index,
+                                                       totuvco + uv_face_mapping[f_index][vi],
+                                                       ))  # vert, uv
+                                        if EXPORT_VCOLORS and vcolors:
+                                            fw("//%d" % (totvcol + loops_to_vcolors[li]))  # add vcolor
+
+                                face_vert_index += len(f_v)
+
+                            else:  # No UV's
+                                if EXPORT_NORMALS:
+                                    for vi, v, li in f_v:
+                                        fw(" %d//%d" % (totverts + v.index, totno + loops_to_normals[li]))
+                                        if EXPORT_VCOLORS and vcolors:
+                                            fw("/%d" % (totvcol + loops_to_vcolors[li]))  # add vcolor
+                                else:  # No Normals
+                                    for vi, v, li in f_v:
+                                        fw(" %d" % (totverts + v.index))
+                                        if EXPORT_VCOLORS and vcolors:
+                                            fw("///%d" % (totvcol + loops_to_vcolors[li]))  # add vcolor
+                            fw('\n')
+
+                        subprogress2.step()
+
+                        # Write edges.
+                        if EXPORT_EDGES:
+                            for ed in edges:
+                                if ed.is_loose:
+                                    fw('l %d %d\n' % (totverts + ed.vertices[0], totverts + ed.vertices[1]))
+
+                        # Make the indices global rather then per mesh
+                        totverts += len(me_verts)
+                        totuvco += uv_unique_count
+                        totno += no_unique_count
+                        totvcol += vc_unique_count
+
+                        # clean up
+                        bpy.data.meshes.remove(me)
+
+                if ob_main.dupli_type != 'NONE':
+                    ob_main.dupli_list_clear()
+
+                subprogress1.leave_substeps("Finished writing geometry of '%s'." % ob_main.name)
+            subprogress1.leave_substeps()
+
+        subprogress1.step("Finished exporting geometry, now exporting materials")
+
+        # Now we have all our materials, save them
+        if EXPORT_MTL:
+            write_mtl(scene, mtlfilepath, EXPORT_PATH_MODE, copy_set, mtl_dict)
+
+        # Save the armature
+        if EXPORT_ARL:
+            write_arl(scene, arlfilepath, EXPORT_PATH_MODE, copy_set, mtl_dict, armatures)
+
+        # copy all collected files.
+        bpy_extras.io_utils.path_reference_copy(copy_set)
+
+
+def _write(context, filepath,
+           EXPORT_TRI,  # ok
+           EXPORT_EDGES,
+           EXPORT_SMOOTH_GROUPS,
+           EXPORT_SMOOTH_GROUPS_BITFLAGS,
+           EXPORT_NORMALS,  # ok
+           EXPORT_VCOLORS,  # ok
+           EXPORT_UV,  # ok
+           EXPORT_MTL,
+           EXPORT_APPLY_MODIFIERS,  # ok
+           EXPORT_BLEN_OBS,
+           EXPORT_GROUP_BY_OB,
+           EXPORT_GROUP_BY_MAT,
+           EXPORT_KEEP_VERT_ORDER,
+           EXPORT_POLYGROUPS,
+           EXPORT_CURVE_AS_NURBS,
+           EXPORT_SEL_ONLY,  # ok
+           EXPORT_ANIMATION,
+           EXPORT_GLOBAL_MATRIX,
+           EXPORT_PATH_MODE,  # Not used
+           ):
+
+    with ProgressReport(context.window_manager) as progress:
+        base_name, ext = os.path.splitext(filepath)
+        context_name = [base_name, '', '', ext]  # Base name, scene name, frame number, extension
+
+        scene = context.scene
+
+        # Exit edit mode before exporting, so current object states are exported properly.
+        if bpy.ops.object.mode_set.poll():
+            bpy.ops.object.mode_set(mode='OBJECT')
+
+        orig_frame = scene.frame_current
+
+        # Export an animation?
+        if EXPORT_ANIMATION:
+            scene_frames = range(scene.frame_start, scene.frame_end + 1)  # Up to and including the end frame.
+        else:
+            scene_frames = [orig_frame]  # Dont export an animation.
+
+        # Loop through all frames in the scene and export.
+        progress.enter_substeps(len(scene_frames))
+        for frame in scene_frames:
+            if EXPORT_ANIMATION:  # Add frame to the filepath.
+                context_name[2] = '_%.6d' % frame
+
+            scene.frame_set(frame, 0.0)
+            if EXPORT_SEL_ONLY:
+                objects = context.selected_objects
+            else:
+                objects = scene.objects
+
+            full_path = ''.join(context_name)
+
+            # erm... bit of a problem here, this can overwrite files when exporting frames. not too bad.
+            # EXPORT THE FILE.
+            progress.enter_substeps(1)
+            write_file(full_path, objects, scene,
+                       EXPORT_TRI,
+                       EXPORT_EDGES,
+                       EXPORT_SMOOTH_GROUPS,
+                       EXPORT_SMOOTH_GROUPS_BITFLAGS,
+                       EXPORT_NORMALS,
+                       EXPORT_VCOLORS,
+                       EXPORT_UV,
+                       EXPORT_MTL,
+                       EXPORT_APPLY_MODIFIERS,
+                       EXPORT_BLEN_OBS,
+                       EXPORT_GROUP_BY_OB,
+                       EXPORT_GROUP_BY_MAT,
+                       EXPORT_KEEP_VERT_ORDER,
+                       EXPORT_POLYGROUPS,
+                       EXPORT_CURVE_AS_NURBS,
+                       EXPORT_GLOBAL_MATRIX,
+                       EXPORT_PATH_MODE,
+                       progress,
+                       )
+            progress.leave_substeps()
+
+        scene.frame_set(orig_frame, 0.0)
+        progress.leave_substeps()
+
+
+"""
+Currently the exporter lacks these features:
+* multiple scene export (only active scene is written)
+* particles
+"""
+
+
+def save(context,
+         filepath,
+         *,
+         use_triangles=False,
+         use_edges=True,
+         use_normals=False,
+         use_vcolors=False,
+         use_smooth_groups=False,
+         use_smooth_groups_bitflags=False,
+         use_uvs=True,
+         use_materials=True,
+         use_mesh_modifiers=True,
+         use_blen_objects=True,
+         group_by_object=False,
+         group_by_material=False,
+         keep_vertex_order=False,
+         use_vertex_groups=False,
+         use_nurbs=True,
+         use_selection=True,
+         use_animation=False,
+         global_matrix=None,
+         path_mode='AUTO'
+         ):
+
+    _write(context, filepath,
+           EXPORT_TRI=use_triangles,
+           EXPORT_EDGES=use_edges,
+           EXPORT_SMOOTH_GROUPS=use_smooth_groups,
+           EXPORT_SMOOTH_GROUPS_BITFLAGS=use_smooth_groups_bitflags,
+           EXPORT_NORMALS=use_normals,
+           EXPORT_VCOLORS=use_vcolors,
+           EXPORT_UV=use_uvs,
+           EXPORT_MTL=use_materials,
+           EXPORT_APPLY_MODIFIERS=use_mesh_modifiers,
+           EXPORT_BLEN_OBS=use_blen_objects,
+           EXPORT_GROUP_BY_OB=group_by_object,
+           EXPORT_GROUP_BY_MAT=group_by_material,
+           EXPORT_KEEP_VERT_ORDER=keep_vertex_order,
+           EXPORT_POLYGROUPS=use_vertex_groups,
+           EXPORT_CURVE_AS_NURBS=use_nurbs,
+           EXPORT_SEL_ONLY=use_selection,
+           EXPORT_ANIMATION=use_animation,
+           EXPORT_GLOBAL_MATRIX=global_matrix,
+           EXPORT_PATH_MODE=path_mode,
+           )
+
+    return {'FINISHED'}

xnalara_io_Tools/export_xnalara_model.py

···
+import os
+from collections import Counter
+
+import bpy
+from mathutils import Vector
+
+from . import (bin_ops, export_xnalara_pose, import_xnalara_pose,
+               mock_xps_data, node_shader_utils, write_ascii_xps,
+               write_bin_xps, xps_material, xps_types)
+from .timing import timing
+
+# imported XPS directory
+rootDir = ''
+
+
+def coordTransform(coords):
+    x, y, z = coords
+    y = -y
+    return (x, z, y)
+
+
+def faceTransform(face):
+    return [face[0], face[2], face[1]]
+
+
+def uvTransform(uv):
+    u = uv[0] + xpsSettings.uvDisplX
+    v = 1 - xpsSettings.uvDisplY - uv[1]
+    return [u, v]
+
+
+def rangeFloatToByte(float):
+    return int(float * 255) % 256
+
+
+def rangeByteToFloat(byte):
+    return byte / 255
+
+
+def uvTransformLayers(uvLayers):
+    return list(map(uvTransform, uvLayers))
+
+
+def getArmature(selected_obj):
+    armature_obj = next((obj for obj in selected_obj
+                         if obj.type == 'ARMATURE'), None)
+    return armature_obj
+
+
+def fillArray(array, minLen, value):
+    # Complete the array with selected value
+    filled = array + [value] * (minLen - len(array))
+    return filled
+
+
+def getOutputFilename(xpsSettingsAux):
+    global xpsSettings
+    xpsSettings = xpsSettingsAux
+
+    blenderExportSetup()
+    xpsExport()
+    blenderExportFinalize()
+
+
+def blenderExportSetup():
+    # switch to object mode and deselect all
+    objectMode()
+
+
+def blenderExportFinalize():
+    pass
+
+
+def objectMode():
+    current_mode = bpy.context.mode
+    if bpy.context.view_layer.objects.active and current_mode != 'OBJECT':
+        bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
+
+
+def saveXpsFile(filename, xpsData):
+    dirpath, file = os.path.split(filename)
+    basename, ext = os.path.splitext(file)
+    if ext.lower() in ('.mesh', '.xps'):
+        write_bin_xps.writeXpsModel(xpsSettings, filename, xpsData)
+    elif ext.lower() in ('.ascii'):
+        write_ascii_xps.writeXpsModel(xpsSettings, filename, xpsData)
+
+
+@timing
+def xpsExport():
+    global rootDir
+    global xpsData
+
+    print("------------------------------------------------------------")
+    print("---------------EXECUTING XPS PYTHON EXPORTER----------------")
+    print("------------------------------------------------------------")
+    print("Exporting file: ", xpsSettings.filename)
+
+    if xpsSettings.exportOnlySelected:
+        exportObjects = bpy.context.selected_objects
+    else:
+        exportObjects = bpy.context.visible_objects
+
+    selectedArmature, selectedMeshes = exportSelected(exportObjects)
+
+    xpsBones = exportArmature(selectedArmature)
+    xpsMeshes = exportMeshes(selectedArmature, selectedMeshes)
+
+    poseString = ''
+    if (xpsSettings.expDefPose):
+        xpsPoseData = export_xnalara_pose.xpsPoseData(selectedArmature)
+        poseString = write_ascii_xps.writePose(xpsPoseData).read()
+
+    header = None
+    hasHeader = bin_ops.hasHeader(xpsSettings.format)
+    if hasHeader:
+        header = mock_xps_data.buildHeader(poseString)
+        header.version_mayor = xpsSettings.versionMayor
+        header.version_minor = xpsSettings.versionMinor
+    xpsData = xps_types.XpsData(header=header, bones=xpsBones,
+                                meshes=xpsMeshes)
+
+    saveXpsFile(xpsSettings.filename, xpsData)
+
+
+def exportSelected(objects):
+    meshes = []
+    armatures = []
+    armature = None
+    for object in objects:
+        if object.type == 'ARMATURE':
+            armatures.append(object)
+        elif object.type == 'MESH':
+            meshes.append(object)
+        armature = object.find_armature() or armature
+    # armature = getArmature(objects)
+    return armature, meshes
+
+
+def exportArmature(armature):
+    xpsBones = []
+    if armature:
+        bones = armature.data.bones
+        print('Exporting Armature', len(bones), 'Bones')
+        # activebones = [bone for bone in bones if bone.layers[0]]
+        activebones = bones
+        for bone in activebones:
+            objectMatrix = armature.matrix_local
+            id = bones.find(bone.name)
+            name = bone.name
+            co = coordTransform(objectMatrix @ bone.head_local.xyz)
+            parentId = None
+            if bone.parent:
+                parentId = bones.find(bone.parent.name)
+            xpsBone = xps_types.XpsBone(id, name, co, parentId)
+            xpsBones.append(xpsBone)
+    if not xpsBones:
+        xpsBone = xps_types.XpsBone(0, 'root', (0, 0, 0), -1)
+        xpsBones.append(xpsBone)
+
+    return xpsBones
+
+
+def exportMeshes(selectedArmature, selectedMeshes):
+    xpsMeshes = []
+    for mesh in selectedMeshes:
+        print('Exporting Mesh:', mesh.name)
+        meshName = makeNamesFromMesh(mesh)
+        # meshName = makeNamesFromMaterials(mesh)
+        meshTextures = getXpsMatTextures(mesh)
+        meshVerts, meshFaces = getXpsVertices(selectedArmature, mesh)
+        meshUvCount = len(mesh.data.uv_layers)
+
+        materialsCount = len(mesh.data.materials)
+        if (materialsCount > 0):
+            for idx in range(materialsCount):
+                xpsMesh = xps_types.XpsMesh(meshName[idx], meshTextures[idx],
+                                            meshVerts[idx], meshFaces[idx],
+                                            meshUvCount)
+                xpsMeshes.append(xpsMesh)
+        else:
+            dummyTexture = [xps_types.XpsTexture(0, 'dummy.png', 0)]
+            xpsMesh = xps_types.XpsMesh(meshName[0], dummyTexture,
+                                        meshVerts[0], meshFaces[0],
+                                        meshUvCount)
+            xpsMeshes.append(xpsMesh)
+
+    return xpsMeshes
+
+
+def makeNamesFromMaterials(mesh):
+    separatedMeshNames = []
+    materials = mesh.data.materials
+    for material in materials:
+        separatedMeshNames.append(material.name)
+    return separatedMeshNames
+
+
+def makeNamesFromMesh(mesh):
+    meshFullName = mesh.name
+    renderType = xps_material.makeRenderType(meshFullName)
+    meshName = renderType.meshName
+
+    separatedMeshNames = []
+    separatedMeshNames.append(xps_material.makeRenderTypeName(renderType))
+
+    materialsCount = len(mesh.data.materials)
+    # separate mesh by materials
+    for mat_idx in range(1, materialsCount):
+        partName = '{0}.material{1:02d}'.format(meshName, mat_idx)
+        renderType.meshName = partName
+        fullName = xps_material.makeRenderTypeName(renderType)
+        separatedMeshNames.append(fullName)
+    return separatedMeshNames
+
+
+def addTexture(tex_dic, texture_type, texture):
+    if texture is not None:
+        tex_dic[texture_type] = texture
+
+
+def getTextureFilename(texture):
+    textureFile = None
+    if texture and texture.image is not None:
+        texFilePath = texture.image.filepath
+        absFilePath = bpy.path.abspath(texFilePath)
+        texturePath, textureFile = os.path.split(absFilePath)
+    return textureFile
+
+
+def makeXpsTexture(mesh, material):
+    active_uv = mesh.data.uv_layers.active
+    active_uv_index = mesh.data.uv_layers.active_index
+    xpsShaderWrapper = node_shader_utils.XPSShaderWrapper(material)
+
+    tex_dic = {}
+    texture = getTextureFilename(xpsShaderWrapper.diffuse_texture)
+    addTexture(tex_dic, xps_material.TextureType.DIFFUSE, texture)
+    texture = getTextureFilename(xpsShaderWrapper.lightmap_texture)
+    addTexture(tex_dic, xps_material.TextureType.LIGHT, texture)
+    texture = getTextureFilename(xpsShaderWrapper.normalmap_texture)
+    addTexture(tex_dic, xps_material.TextureType.BUMP, texture)
+    texture = getTextureFilename(xpsShaderWrapper.normal_mask_texture)
+    addTexture(tex_dic, xps_material.TextureType.MASK, texture)
+    texture = getTextureFilename(xpsShaderWrapper.microbump1_texture)
+    addTexture(tex_dic, xps_material.TextureType.BUMP1, texture)
+    texture = getTextureFilename(xpsShaderWrapper.microbump2_texture)
+    addTexture(tex_dic, xps_material.TextureType.BUMP2, texture)
+    texture = getTextureFilename(xpsShaderWrapper.specular_texture)
+    addTexture(tex_dic, xps_material.TextureType.SPECULAR, texture)
+    texture = getTextureFilename(xpsShaderWrapper.environment_texture)
+    addTexture(tex_dic, xps_material.TextureType.ENVIRONMENT, texture)
+    texture = getTextureFilename(xpsShaderWrapper.emission_texture)
+    addTexture(tex_dic, xps_material.TextureType.EMISSION, texture)
+
+    renderType = xps_material.makeRenderType(mesh.name)
+    renderGroup = xps_material.RenderGroup(renderType)
+    rgTextures = renderGroup.rgTexType
+
+    texutre_list = []
+    for tex_type in rgTextures:
+        texture = tex_dic.get(tex_type, 'missing.png')
+        texutre_list.append(texture)
+
+    xpsTextures = []
+    for id, textute in enumerate(texutre_list):
+        xpsTexture = xps_types.XpsTexture(id, textute, 0)
+        xpsTextures.append(xpsTexture)
+
+    return xpsTextures
+
+
+def getTextures(mesh, material):
+    textures = []
+    xpsTextures = makeXpsTexture(mesh, material)
+    return xpsTextures
+
+
+def getXpsMatTextures(mesh):
+    xpsMatTextures = []
+    for material_slot in mesh.material_slots:
+        material = material_slot.material
+        xpsTextures = getTextures(mesh, material)
+        xpsMatTextures.append(xpsTextures)
+    return xpsMatTextures
+
+
+def generateVertexKey(vertex, uvCoord, seamSideId):
+    # Generate a unique key for vertex using coords,normal,
+    # first UV and side of seam
+    key = '{}{}{}{}'.format(vertex.co, vertex.normal, uvCoord, seamSideId)
+    return key
+
+
+def getXpsVertices(selectedArmature, mesh):
+    mapMatVertexKeys = []  # remap vertex index
+    xpsMatVertices = []  # Vertices separated by material
+    xpsMatFaces = []  # Faces separated by material
+    # xpsVertices = []  # list of vertices for a single material
+    # xpsFaces = []  # list of faces for a single material
+
+    exportVertColors = xpsSettings.vColors
+    armature = mesh.find_armature()
+    objectMatrix = mesh.matrix_world
+    rotQuaternion = mesh.matrix_world.to_quaternion()
+
+    verts_nor = xpsSettings.exportNormals
+
+    # Calculates tesselated faces and normal split to make them available for export
+    if (bpy.app.version[0:2] in [(3, 6), (4, 0)]):
+        mesh.data.calc_normals_split()
+    mesh.data.calc_loop_triangles()
+    mesh.data.update(calc_edges=True)
+    mesh.data.calc_loop_triangles()
+
+    matCount = len(mesh.data.materials)
+    if (matCount > 0):
+        for idx in range(matCount):
+            xpsMatVertices.append([])  # Vertices separated by material
+            xpsMatFaces.append([])  # Faces separated by material
+            mapMatVertexKeys.append({})
+    else:
+        xpsMatVertices.append([])  # Vertices separated by material
+        xpsMatFaces.append([])  # Faces separated by material
+        mapMatVertexKeys.append({})
+
+    meshVerts = mesh.data.vertices
+    meshEdges = mesh.data.edges
+    # tessface accelerator
+    hasSeams = any(edge.use_seam for edge in meshEdges)
+    tessFaces = mesh.data.loop_triangles[:]
+    # tessFaces = mesh.data.tessfaces
+    tessface_uv_tex = mesh.data.uv_layers
+    tessface_vert_color = mesh.data.vertex_colors
+    meshEdgeKeys = mesh.data.edge_keys
+
+    vertEdges = [[] for x in range(len(meshVerts))]
+    tessEdgeFaces = {}
+
+    preserveSeams = xpsSettings.preserveSeams
+    if (preserveSeams and hasSeams):
+        # Count edges for faces
+        tessEdgeCount = Counter(tessEdgeKey for tessFace in tessFaces for tessEdgeKey in tessFace.edge_keys)
+
+        # create dictionary. faces for each edge
+        for tessface in tessFaces:
+            for tessEdgeKey in tessface.edge_keys:
+                if tessEdgeFaces.get(tessEdgeKey) is None:
+                    tessEdgeFaces[tessEdgeKey] = []
+                tessEdgeFaces[tessEdgeKey].append(tessface.index)
+
+        # use Dict to speedup search
+        edgeKeyIndex = {val: index for index, val in enumerate(meshEdgeKeys)}
+
+        # create dictionary. Edges connected to each Vert
+        for key in meshEdgeKeys:
+            meshEdge = meshEdges[edgeKeyIndex[key]]
+            vert1, vert2 = key
+            vertEdges[vert1].append(meshEdge)
+            vertEdges[vert2].append(meshEdge)
+
+    faceEdges = []
+    faceSeams = []
+
+    for face in tessFaces:
+        # faceIdx = face.index
+        material_index = face.material_index
+        xpsVertices = xpsMatVertices[material_index]
+        xpsFaces = xpsMatFaces[material_index]
+        mapVertexKeys = mapMatVertexKeys[material_index]
+        faceVerts = []
+        seamSideId = ''
+        faceVertIndices = face.vertices[:]
+        faceUvIndices = face.loops[:]
+
+        for vertEnum, vertIndex in enumerate(faceVertIndices):
+            vertex = meshVerts[vertIndex]
+
+            if (preserveSeams and hasSeams):
+                connectedFaces = set()
+                faceEdges = vertEdges[vertIndex]
+                faceSeams = [edge for edge in faceEdges if edge.use_seam]
+
+                if (len(faceSeams) >= 1):
+                    vertIsBorder = any(tessEdgeCount[edge.index] != 2 for edge in faceEdges)
+                    if (len(faceSeams) > 1) or (len(faceSeams) == 1 and vertIsBorder):
+
+                        oldFacesList = set()
+                        connectedFaces = set([face])
+                        while oldFacesList != connectedFaces:
+
+                            oldFacesList = connectedFaces
+
+                            allEdgeKeys = set(connEdgeKey for connface in connectedFaces for connEdgeKey in connface.edge_keys)
+                            connEdgesKeys = [edge.key for edge in faceEdges]
+                            connEdgesNotSeamsKeys = [seam.key for seam in faceSeams]
+
+                            connectedEdges = allEdgeKeys.intersection(connEdgesKeys).difference(connEdgesNotSeamsKeys)
+                            connectedFaces = set(tessFaces[connFace] for connEdge in connectedEdges for connFace in tessEdgeFaces[connEdge])
+
+                            connectedFaces.add(face)
+
+                faceIndices = [face.index for face in connectedFaces]
+                seamSideId = '|'.join(str(faceIdx) for faceIdx in sorted(faceIndices))
+
+            uvs = getUvs(tessface_uv_tex, faceUvIndices[vertEnum])
+            vertexKey = generateVertexKey(vertex, uvs, seamSideId)
+
+            if vertexKey in mapVertexKeys:
+                vertexID = mapVertexKeys[vertexKey]
+            else:
+                vCoord = coordTransform(objectMatrix @ vertex.co)
+                if verts_nor:
+                    normal = Vector(face.split_normals[vertEnum])
+                else:
+                    normal = vertex.normal
+                norm = coordTransform(rotQuaternion @ normal)
+                vColor = getVertexColor(exportVertColors, tessface_vert_color, faceUvIndices[vertEnum])
+                boneId, boneWeight = getBoneWeights(mesh, vertex, armature)
+
+                boneWeights = []
+                for idx in range(len(boneId)):
+                    boneWeights.append(xps_types.BoneWeight(boneId[idx],
+                                                            boneWeight[idx]))
+                vertexID = len(xpsVertices)
+                mapVertexKeys[vertexKey] = vertexID
+                xpsVertex = xps_types.XpsVertex(vertexID, vCoord, norm, vColor, uvs,
+                                                boneWeights)
+                xpsVertices.append(xpsVertex)
+            faceVerts.append(vertexID)
+
+        meshFaces = getXpsFace(faceVerts)
+        xpsFaces.extend(meshFaces)
+
+    return xpsMatVertices, xpsMatFaces
+
+
+def getUvs(tessface_uv_tex, uvIndex):
+    uvs = []
+    for tessface_uv_layer in tessface_uv_tex:
+        uvCoord = tessface_uv_layer.data[uvIndex].uv
+        uvCoord = uvTransform(uvCoord)
+        uvs.append(uvCoord)
+    return uvs
+
+
+def getVertexColor(exportVertColors, tessface_vert_color, vColorIndex):
+    vColor = None
+    if exportVertColors and tessface_vert_color:
+        vColor = tessface_vert_color[0].data[vColorIndex].color[:]
+    else:
+        vColor = [1, 1, 1, 1]
+
+    vColor = list(map(rangeFloatToByte, vColor))
+    return vColor
+
+
+def getBoneWeights(mesh, vertice, armature):
+    boneId = []
+    boneWeight = []
+    if armature:
+        for vertGroup in vertice.groups:
+            # Vertex Group
+            groupIdx = vertGroup.group
+            boneName = mesh.vertex_groups[groupIdx].name
+            boneIdx = armature.data.bones.find(boneName)
+            weight = vertGroup.weight
+            if boneIdx < 0:
+                boneIdx = 0
+                weight = 0
+            boneId.append(boneIdx)
+            boneWeight.append(weight)
+    boneId = fillArray(boneId, 4, 0)
+    boneWeight = fillArray(boneWeight, 4, 0)
+    return boneId, boneWeight
+
+
+def getXpsFace(faceVerts):
+    xpsFaces = []
+
+    if len(faceVerts) == 3:
+        xpsFaces.append(faceTransform(faceVerts))
+    elif len(faceVerts) == 4:
+        v1, v2, v3, v4 = faceVerts
+        xpsFaces.append(faceTransform((v1, v2, v3)))
+        xpsFaces.append(faceTransform((v3, v4, v1)))
+
+    return xpsFaces
+
+
+def boneDictGenerate(filepath, armatureObj):
+    boneNames = sorted([import_xnalara_pose.renameBoneToXps(name) for name in armatureObj.data.bones.keys()])
+    boneDictList = '\n'.join(';'.join((name,) * 2) for name in boneNames)
+    write_ascii_xps.writeBoneDict(filepath, boneDictList)
+
+
+if __name__ == "__main__":
+    uvDisplX = 0
+    uvDisplY = 0
+    exportOnlySelected = True
+    exportPose = False
+    modProtected = False
+    filename1 = (r'G:\3DModeling\XNALara\XNALara_XPS\data\TESTING5\Drake\RECB '
+                 r'DRAKE Pack_By DamianHandy\DRAKE Sneaking Suit - Open_by '
+                 r'DamianHandy\Generic_Item - BLENDER pose.mesh')
+
+    filename = r'C:\XPS Tutorial\Yaiba MOMIJIII\momi.mesh.ascii'
+
+    xpsSettings = xps_types.XpsImportSettings(filename, uvDisplX, uvDisplY,
+                                              exportOnlySelected, exportPose,
+                                              modProtected)
+
+    getOutputFilename(xpsSettings)

xnalara_io_Tools/export_xnalara_pose.py

···
+from math import degrees
+import os
+import re
+
+from . import write_ascii_xps
+from . import xps_types
+from .timing import timing
+import bpy
+from mathutils import Vector
+
+
+def getOutputPoseSequence(filename):
+    filepath, file = os.path.split(filename)
+    basename, ext = os.path.splitext(file)
+    poseSuffix = re.sub(r'\d+$', '', basename)
+
+    startFrame = bpy.context.scene.frame_start
+    endFrame = bpy.context.scene.frame_end
+    initialFrame = bpy.context.scene.frame_current
+
+    for currFrame in range(startFrame, endFrame + 1):
+        bpy.context.scene.frame_set(currFrame)
+        numSuffix = '{:0>3d}'.format(currFrame)
+        name = poseSuffix + numSuffix + ext
+
+        newPoseFilename = os.path.join(filepath, name)
+        getOutputFilename(newPoseFilename)
+
+    bpy.context.scene.frame_current = initialFrame
+
+
+def getOutputFilename(filename):
+    blenderExportSetup()
+    xpsExport(filename)
+    blenderExportFinalize()
+
+
+def blenderExportSetup():
+    pass
+
+
+def blenderExportFinalize():
+    pass
+
+
+def saveXpsFile(filename, xpsPoseData):
+    # dirpath, file = os.path.split(filename)
+    # basename, ext = os.path.splitext(file)
+    write_ascii_xps.writeXpsPose(filename, xpsPoseData)
+
+
+@timing
+def xpsExport(filename):
+    global rootDir
+    global xpsData
+
+    print("------------------------------------------------------------")
+    print("---------------EXECUTING XPS PYTHON EXPORTER----------------")
+    print("------------------------------------------------------------")
+    print("Exporting Pose: ", filename)
+
+    rootDir, file = os.path.split(filename)
+    print('rootDir: {}'.format(rootDir))
+
+    xpsPoseData = exportPose()
+
+    saveXpsFile(filename, xpsPoseData)
+
+
+def exportPose():
+    armature = next((obj for obj in bpy.context.selected_objects
+                     if obj.type == 'ARMATURE'), None)
+    boneCount = len(armature.data.bones)
+    print('Exporting Pose', str(boneCount), 'bones')
+
+    return xpsPoseData(armature)
+
+
+def xpsPoseData(armature):
+    context = bpy.context
+    currentMode = bpy.context.mode
+    currentObj = bpy.context.active_object
+    context.view_layer.objects.active = armature
+    bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
+
+    bpy.ops.object.mode_set(mode='POSE')
+    bpy.ops.pose.select_all(action='DESELECT')
+    bones = armature.pose.bones
+    objectMatrix = armature.matrix_world
+
+    xpsPoseData = {}
+    for poseBone in bones:
+        boneName = poseBone.name
+        boneData = xpsPoseBone(poseBone, objectMatrix)
+        xpsPoseData[boneName] = boneData
+
+    bpy.ops.object.posemode_toggle()
+    context.view_layer.objects.active = currentObj
+    bpy.ops.object.mode_set(mode=currentMode)
+
+    return xpsPoseData
+
+
+def xpsPoseBone(poseBone, objectMatrix):
+    boneName = poseBone.name
+    boneRotDelta = xpsBoneRotate(poseBone)
+    boneCoordDelta = xpsBoneTranslate(poseBone, objectMatrix)
+    boneScale = xpsBoneScale(poseBone)
+    boneData = xps_types.XpsBonePose(boneName, boneCoordDelta, boneRotDelta,
+                                     boneScale)
+    return boneData
+
+
+def eulerToXpsBoneRot(rotEuler):
+    xDeg = degrees(rotEuler.x)
+    yDeg = degrees(rotEuler.y)
+    zDeg = degrees(rotEuler.z)
+    return Vector((xDeg, yDeg, zDeg))
+
+
+def vectorTransform(vec):
+    x = vec.x
+    y = vec.y
+    z = vec.z
+    y = -y
+    newVec = Vector((x, z, y))
+    return newVec
+
+
+def vectorTransformTranslate(vec):
+    x = vec.x
+    y = vec.y
+    z = vec.z
+    y = -y
+    newVec = Vector((x, z, y))
+    return newVec
+
+
+def vectorTransformScale(vec):
+    x = vec.x
+    y = vec.y
+    z = vec.z
+    newVec = Vector((x, y, z))
+    return newVec
+
+
+def xpsBoneRotate(poseBone):
+    # LOCAL PoseBone
+    poseMatGlobal = poseBone.matrix_basis.to_quaternion()
+    # LOCAL EditBoneRot
+    editMatLocal = poseBone.bone.matrix_local.to_quaternion()
+
+    rotQuat = editMatLocal @ poseMatGlobal @ editMatLocal.inverted()
+    rotEuler = rotQuat.to_euler('YXZ')
+    xpsRot = eulerToXpsBoneRot(rotEuler)
+    rot = vectorTransform(xpsRot)
+    return rot
+
+
+def xpsBoneTranslate(poseBone, objectMatrix):
+    translate = poseBone.location
+    # LOCAL EditBoneRot
+    editMatLocal = poseBone.bone.matrix_local.to_quaternion()
+    vector = editMatLocal @ translate
+    return vectorTransformTranslate(objectMatrix.to_3x3() @ vector)
+
+
+def xpsBoneScale(poseBone):
+    scale = poseBone.scale
+    return vectorTransformScale(scale)
+
+
+if __name__ == "__main__":
+    writePosefilename0 = (r"G:\3DModeling\XNALara\XNALara_XPS\dataTest\Models"
+                          r"\Queen's Blade\echidna pose - copy.pose")
+
+    getOutputFilename(writePosefilename0)

xnalara_io_Tools/import_obj.py

···
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# Script copyright (C) Campbell Barton
+# Contributors: Campbell Barton, Jiri Hnidek, Paolo Ciccone
+
+"""
+This script imports a Wavefront OBJ files to Blender.
+
+Usage:
+Run this script from "File->Import" menu and then load the desired OBJ file.
+Note, This loads mesh objects and materials only, nurbs and curves are not supported.
+
+http://wiki.blender.org/index.php/Scripts/Manual/Import/wavefront_obj
+"""
+import ast
+import array
+import os
+import bpy
+import mathutils
+from bpy_extras.io_utils import unpack_list
+from bpy_extras.image_utils import load_image
+
+from bpy_extras.wm_utils.progress_report import (
+    ProgressReport,
+    ProgressReportSubstep,
+)
+
+
+def line_value(line_split):
+    """
+    Returns 1 string representing the value for this line
+    None will be returned if theres only 1 word
+    """
+    length = len(line_split)
+    if length == 1:
+        return None
+
+    elif length == 2:
+        return line_split[1]
+
+    elif length > 2:
+        return b' '.join(line_split[1:])
+
+
+def obj_image_load(imagepath, DIR, recursive, relpath):
+    """
+    Mainly uses comprehensiveImageLoad
+    but tries to replace '_' with ' ' for Max's exporter replaces spaces with underscores.
+    """
+    if "_" in imagepath:
+        image = load_image(imagepath.replace("_", " "), DIR, recursive=recursive, relpath=relpath)
+        if image:
+            return image
+
+    return load_image(imagepath, DIR, recursive=recursive, place_holder=True, relpath=relpath)
+
+
+def create_materials(filepath, relpath,
+                     material_libs, unique_materials, unique_material_images,
+                     use_image_search, float_func):
+    """
+    Create all the used materials in this obj,
+    assign colors and images to the materials from all referenced material libs
+    """
+    DIR = os.path.dirname(filepath)
+    context_material_vars = set()
+
+    # Don't load the same image multiple times
+    context_imagepath_map = {}
+
+    def load_material_image(blender_material, context_material_name, img_data, type):
+        """
+        Set textures defined in .mtl file.
+        """
+        imagepath = os.fsdecode(img_data[-1])
+        map_options = {}
+
+        curr_token = []
+        for token in img_data[:-1]:
+            if token.startswith(b'-'):
+                if curr_token:
+                    map_options[curr_token[0]] = curr_token[1:]
+                curr_token[:] = []
+            curr_token.append(token)
+
+        texture = bpy.data.textures.new(name=type, type='IMAGE')
+
+        # Absolute path - c:\.. etc would work here
+        image = context_imagepath_map.get(imagepath, ...)
+        if image == ...:
+            image = context_imagepath_map[imagepath] = \
+                    obj_image_load(imagepath, DIR, use_image_search, relpath)
+
+        if image is not None:
+            texture.image = image
+
+        # Adds textures for materials (rendering)
+        if type == 'Kd':
+            mtex = blender_material.texture_slots.add()
+            mtex.texture = texture
+            mtex.texture_coords = 'UV'
+            mtex.use_map_color_diffuse = True
+
+            # adds textures to faces (Textured/Alt-Z mode)
+            # Only apply the diffuse texture to the face if the image has not been set with the inline usemat func.
+            unique_material_images[context_material_name] = image  # set the texface image
+
+        elif type == 'Ka':
+            mtex = blender_material.texture_slots.add()
+            mtex.use_map_color_diffuse = False
+
+            mtex.texture = texture
+            mtex.texture_coords = 'UV'
+            mtex.use_map_ambient = True
+
+        elif type == 'Ks':
+            mtex = blender_material.texture_slots.add()
+            mtex.use_map_color_diffuse = False
+
+            mtex.texture = texture
+            mtex.texture_coords = 'UV'
+            mtex.use_map_color_spec = True
+
+        elif type == 'Ke':
+            mtex = blender_material.texture_slots.add()
+            mtex.use_map_color_diffuse = False
+
+            mtex.texture = texture
+            mtex.texture_coords = 'UV'
+            mtex.use_map_emit = True
+
+        elif type == 'Bump':
+            mtex = blender_material.texture_slots.add()
+            mtex.use_map_color_diffuse = False
+
+            mtex.texture = texture
+            mtex.texture.use_normal_map = True
+            mtex.texture_coords = 'UV'
+            mtex.use_map_normal = True
+
+            bump_mult = map_options.get(b'-bm')
+            if bump_mult:
+                mtex.normal_factor = bump_mult[0]
+
+        elif type == 'D':
+            mtex = blender_material.texture_slots.add()
+            mtex.use_map_color_diffuse = False
+
+            mtex.texture = texture
+            mtex.texture_coords = 'UV'
+            mtex.use_map_alpha = True
+            blender_material.use_transparency = True
+            blender_material.transparency_method = 'Z_TRANSPARENCY'
+            if "alpha" not in context_material_vars:
+                blender_material.alpha = 0.0
+            # Todo, unset deffuse material alpha if it has an alpha channel
+
+        elif type == 'disp':
+            mtex = blender_material.texture_slots.add()
+            mtex.use_map_color_diffuse = False
+
+            mtex.texture = texture
+            mtex.texture_coords = 'UV'
+            mtex.use_map_displacement = True
+
+        elif type == 'refl':
+            mtex = blender_material.texture_slots.add()
+            mtex.use_map_color_diffuse = False
+
+            mtex.texture = texture
+            mtex.texture_coords = 'REFLECTION'
+            mtex.use_map_color_diffuse = True
+
+            map_type = map_options.get(b'-type')
+            if map_type and map_type != [b'sphere']:
+                print("WARNING, unsupported reflection type '%s', defaulting to 'sphere'"
+                      "" % ' '.join(i.decode() for i in map_type))
+            mtex.mapping = 'SPHERE'
+        else:
+            raise Exception("invalid type %r" % type)
+
+        map_offset = map_options.get(b'-o')
+        map_scale = map_options.get(b'-s')
+        if map_offset:
+            mtex.offset.x = float(map_offset[0])
+            if len(map_offset) >= 2:
+                mtex.offset.y = float(map_offset[1])
+            if len(map_offset) >= 3:
+                mtex.offset.z = float(map_offset[2])
+        if map_scale:
+            mtex.scale.x = float(map_scale[0])
+            if len(map_scale) >= 2:
+                mtex.scale.y = float(map_scale[1])
+            if len(map_scale) >= 3:
+                mtex.scale.z = float(map_scale[2])
+
+    # Add an MTL with the same name as the obj if no MTLs are spesified.
+    temp_mtl = os.path.splitext((os.path.basename(filepath)))[0] + ".mtl"
+
+    if os.path.exists(os.path.join(DIR, temp_mtl)):
+        material_libs.add(temp_mtl)
+    del temp_mtl
+
+    # Create new materials
+    for name in unique_materials:  # .keys()
+        if name is not None:
+            unique_materials[name] = bpy.data.materials.new(name.decode('utf-8', "replace"))
+            unique_material_images[name] = None  # assign None to all material images to start with, add to later.
+
+    # XXX Why was this needed? Cannot find any good reason, and adds stupid empty matslot in case we do not separate
+    # mesh (see T44947).
+    # ~ unique_materials[None] = None
+    # ~ unique_material_images[None] = None
+
+    for libname in sorted(material_libs):
+        # print(libname)
+        mtlpath = os.path.join(DIR, libname)
+        if not os.path.exists(mtlpath):
+            print("\tMaterial not found MTL: %r" % mtlpath)
+        else:
+            do_ambient = True
+            do_highlight = False
+            do_reflection = False
+            do_transparency = False
+            do_glass = False
+            do_fresnel = False
+            do_raytrace = False
+            emit_colors = [0.0, 0.0, 0.0]
+
+            # print('\t\tloading mtl: %e' % mtlpath)
+            context_material = None
+            mtl = open(mtlpath, 'rb')
+            for line in mtl:  # .readlines():
+                line = line.strip()
+                if not line or line.startswith(b'#'):
+                    continue
+
+                line_split = line.split()
+                line_id = line_split[0].lower()
+
+                if line_id == b'newmtl':
+                    # Finalize previous mat, if any.
+                    if context_material:
+                        emit_value = sum(emit_colors) / 3.0
+                        if emit_value > 1e-6:
+                            # We have to adapt it to diffuse color too...
+                            emit_value /= sum(context_material.diffuse_color) / 3.0
+                        context_material.emit = emit_value
+
+                        if not do_ambient:
+                            context_material.ambient = 0.0
+
+                        if do_highlight:
+                            # FIXME, how else to use this?
+                            context_material.specular_intensity = 1.0
+
+                        if do_reflection:
+                            context_material.raytrace_mirror.use = True
+                            context_material.raytrace_mirror.reflect_factor = 1.0
+
+                        if do_transparency:
+                            context_material.use_transparency = True
+                            context_material.transparency_method = 'RAYTRACE' if do_raytrace else 'Z_TRANSPARENCY'
+                            if "alpha" not in context_material_vars:
+                                context_material.alpha = 0.0
+
+                        if do_glass:
+                            if "ior" not in context_material_vars:
+                                context_material.raytrace_transparency.ior = 1.5
+
+                        if do_fresnel:
+                            context_material.raytrace_mirror.fresnel = 1.0  # could be any value for 'ON'
+
+                        """
+                        if do_raytrace:
+                            context_material.use_raytrace = True
+                        else:
+                            context_material.use_raytrace = False
+                        """
+                        # XXX, this is not following the OBJ spec, but this was
+                        # written when raytracing wasnt default, annoying to disable for blender users.
+                        context_material.use_raytrace = True
+
+                    context_material_name = line_value(line_split)
+                    context_material = unique_materials.get(context_material_name)
+                    context_material_vars.clear()
+
+                    emit_colors[:] = [0.0, 0.0, 0.0]
+                    do_ambient = True
+                    do_highlight = False
+                    do_reflection = False
+                    do_transparency = False
+                    do_glass = False
+                    do_fresnel = False
+                    do_raytrace = False
+
+                elif context_material:
+                    # we need to make a material to assign properties to it.
+                    if line_id == b'ka':
+                        context_material.mirror_color = (
+                            float_func(line_split[1]), float_func(line_split[2]), float_func(line_split[3]))
+                        # This is highly approximated, but let's try to stick as close from exporter as possible... :/
+                        context_material.ambient = sum(context_material.mirror_color) / 3
+                    elif line_id == b'kd':
+                        context_material.diffuse_color = (
+                            float_func(line_split[1]), float_func(line_split[2]), float_func(line_split[3]))
+                        context_material.diffuse_intensity = 1.0
+                    elif line_id == b'ks':
+                        context_material.specular_color = (
+                            float_func(line_split[1]), float_func(line_split[2]), float_func(line_split[3]))
+                        context_material.specular_intensity = 1.0
+                    elif line_id == b'ke':
+                        # We cannot set context_material.emit right now, we need final diffuse color as well for this.
+                        emit_colors[:] = [
+                            float_func(line_split[1]), float_func(line_split[2]), float_func(line_split[3])]
+                    elif line_id == b'ns':
+                        context_material.specular_hardness = int((float_func(line_split[1]) * 0.51) + 1)
+                    elif line_id == b'ni':  # Refraction index (between 1 and 3).
+                        context_material.raytrace_transparency.ior = max(1, min(float_func(line_split[1]), 3))
+                        context_material_vars.add("ior")
+                    elif line_id == b'd':  # dissolve (transparency)
+                        context_material.alpha = float_func(line_split[1])
+                        context_material.use_transparency = True
+                        context_material.transparency_method = 'Z_TRANSPARENCY'
+                        context_material_vars.add("alpha")
+                    elif line_id == b'tr':  # translucency
+                        context_material.translucency = float_func(line_split[1])
+                    elif line_id == b'tf':
+                        # rgb, filter color, blender has no support for this.
+                        pass
+                    elif line_id == b'illum':
+                        illum = int(line_split[1])
+
+                        # inline comments are from the spec, v4.2
+                        if illum == 0:
+                            # Color on and Ambient off
+                            do_ambient = False
+                        elif illum == 1:
+                            # Color on and Ambient on
+                            pass
+                        elif illum == 2:
+                            # Highlight on
+                            do_highlight = True
+                        elif illum == 3:
+                            # Reflection on and Ray trace on
+                            do_reflection = True
+                            do_raytrace = True
+                        elif illum == 4:
+                            # Transparency: Glass on
+                            # Reflection: Ray trace on
+                            do_transparency = True
+                            do_reflection = True
+                            do_glass = True
+                            do_raytrace = True
+                        elif illum == 5:
+                            # Reflection: Fresnel on and Ray trace on
+                            do_reflection = True
+                            do_fresnel = True
+                            do_raytrace = True
+                        elif illum == 6:
+                            # Transparency: Refraction on
+                            # Reflection: Fresnel off and Ray trace on
+                            do_transparency = True
+                            do_reflection = True
+                            do_raytrace = True
+                        elif illum == 7:
+                            # Transparency: Refraction on
+                            # Reflection: Fresnel on and Ray trace on
+                            do_transparency = True
+                            do_reflection = True
+                            do_fresnel = True
+                            do_raytrace = True
+                        elif illum == 8:
+                            # Reflection on and Ray trace off
+                            do_reflection = True
+                        elif illum == 9:
+                            # Transparency: Glass on
+                            # Reflection: Ray trace off
+                            do_transparency = True
+                            do_reflection = True
+                            do_glass = True
+                        elif illum == 10:
+                            # Casts shadows onto invisible surfaces
+
+                            # blender can't do this
+                            pass
+
+                    elif line_id == b'map_ka':
+                        img_data = line.split()[1:]
+                        if img_data:
+                            load_material_image(context_material, context_material_name, img_data, 'Ka')
+                    elif line_id == b'map_ks':
+                        img_data = line.split()[1:]
+                        if img_data:
+                            load_material_image(context_material, context_material_name, img_data, 'Ks')
+                    elif line_id == b'map_kd':
+                        img_data = line.split()[1:]
+                        if img_data:
+                            load_material_image(context_material, context_material_name, img_data, 'Kd')
+                    elif line_id == b'map_ke':
+                        img_data = line.split()[1:]
+                        if img_data:
+                            load_material_image(context_material, context_material_name, img_data, 'Ke')
+                    elif line_id in {b'map_kn', b'map_bump', b'bump'}:  # 'bump' is incorrect but some files use it.
+                        img_data = line.split()[1:]
+                        if img_data:
+                            load_material_image(context_material, context_material_name, img_data, 'Bump')
+                    elif line_id in {b'map_d', b'map_tr'}:  # Alpha map - Dissolve
+                        img_data = line.split()[1:]
+                        if img_data:
+                            load_material_image(context_material, context_material_name, img_data, 'D')
+
+                    elif line_id in {b'map_disp', b'disp'}:  # displacementmap
+                        img_data = line.split()[1:]
+                        if img_data:
+                            load_material_image(context_material, context_material_name, img_data, 'disp')
+
+                    elif line_id in {b'map_refl', b'refl'}:  # reflectionmap
+                        img_data = line.split()[1:]
+                        if img_data:
+                            load_material_image(context_material, context_material_name, img_data, 'refl')
+                    else:
+                        print("\t%r:%r (ignored)" % (filepath, line))
+            mtl.close()
+
+
+def hideBone(bone):
+    bone.layers[1] = True
+    bone.layers[0] = False
+
+
+def showBone(bone):
+    bone.layers[0] = True
+    bone.layers[1] = False
+
+
+def visibleBone(bone):
+    return bone.layers[0]
+
+
+def setMinimumLenght(bone):
+    default_length = 0.005
+    if bone.length == 0:
+        bone.tail = bone.head - mathutils.Vector((0, .01, 0))
+    if bone.length < default_length:
+        bone.length = default_length
+
+
+def create_armatures(filepath, relpath,
+                     armature_libs, unique_materials, unique_material_images,
+                     use_image_search, float_func, new_armatures, new_objects, bone_names):
+    """
+    Create armatures in this obj,
+    """
+    DIR = os.path.dirname(filepath)
+
+    # Add an MTL with the same name as the obj if no MTLs are spesified.
+    temp_arl = os.path.splitext((os.path.basename(filepath)))[0] + ".arl"
+
+    if os.path.exists(os.path.join(DIR, temp_arl)):
+        armature_libs.add(temp_arl)
+    del temp_arl
+
+    for libname in sorted(armature_libs):
+        # print(libname)
+        arlpath = os.path.join(DIR, libname)
+        if not os.path.exists(arlpath):
+            print("\tArmature not found ARL: %r" % arlpath)
+        else:
+            # context_multi_line = b''
+            # line_start = b''
+            line_split = []
+            vec = []
+            # bone_names = []
+            bone_parents = []
+            bone_heads = []
+
+            # print('\t\tloading armature: %e' % arlpath)
+            with open(arlpath, 'rb') as mtl:
+
+                bone_count = None
+                read_b_name = read_b_head = read_b_parent = False
+                for line in mtl:  # .readlines():
+
+                    line = line.strip()
+                    if not line or line.startswith(b'#'):
+                        continue
+
+                    line_split = line.split()
+
+                    if not bone_count:
+                        bone_count = int(line_split[0])
+                        read_b_name = read_b_parent = read_b_head = False
+                        read_b_name = True
+                    elif read_b_name:
+                        bone_names.append(line)
+                        read_b_name = read_b_parent = read_b_head = False
+                        read_b_parent = True
+                    elif read_b_parent:
+                        bone_parents.append(int(line_split[0]))
+                        read_b_name = read_b_parent = read_b_head = False
+                        read_b_head = True
+                    elif read_b_head:
+                        bone_heads.append([float_func(line_split[0]), float_func(line_split[1]), float_func(line_split[2])])
+                        read_b_name = read_b_parent = read_b_head = False
+                        read_b_name = True
+
+            # Create the armature object
+            me = bpy.data.armatures.new('Armature')
+            me.draw_type = 'STICK'
+            ob = bpy.data.objects.new(me.name, me)
+            ob.show_x_ray = True
+
+            bpy.context.scene.collection.objects.link(ob)
+            bpy.context.view_layer.objects.active = ob
+            bpy.ops.object.mode_set(mode='EDIT')
+
+            # Create all bones
+            for bone_id, bone_name in enumerate(bone_names):
+                bone = me.edit_bones.new(bone_name.decode('utf-8', 'replace'))
+                bone.head = bone_heads[bone_id]
+                bone.tail = bone.head  # + mathutils.Vector((0,.01,0))
+
+            # Set bone heirarchy
+            for bone_id, bone_parent_id in enumerate(bone_parents):
+                if bone_parent_id >= 0:
+                    me.edit_bones[bone_id].parent = me.edit_bones[bone_parent_id]
+
+            # Set calculate bone tails
+            for edit_bone in me.edit_bones:
+                if visibleBone(edit_bone):
+                    childBones = [childBone for childBone in edit_bone.children
+                                  if visibleBone(childBone)]
+                else:
+                    childBones = [childBone for childBone in edit_bone.children]
+
+                if childBones:
+                    # Set tail to children middle
+                    edit_bone.tail = mathutils.Vector(map(sum, zip(*(childBone.head.xyz for childBone in childBones))))/len(childBones)
+                else:
+                    if edit_bone.parent:
+                        vec = edit_bone.parent.tail - edit_bone.head
+                        if (vec.length < .001):
+                            edit_bone.tail = edit_bone.parent.vector + edit_bone.head
+                            edit_bone.length = edit_bone.parent.length
+                        else:
+                            edit_bone.tail = (edit_bone.head - edit_bone.parent.tail) + edit_bone.head
+                            edit_bone.length = 0.1
+
+            for edit_bone in me.edit_bones:
+                setMinimumLenght(edit_bone)
+
+            # Must add before creating the bones
+            bpy.ops.object.mode_set(mode='OBJECT')
+            new_armatures.append(ob)
+
+
+def getVert(new_objects):
+    return [vert for obj in new_objects for vert in obj.data.vertices]
+
+
+def split_mesh(verts_loc, faces, unique_materials, filepath, SPLIT_OB_OR_GROUP, verts_bw):
+    """
+    Takes vert_loc and faces, and separates into multiple sets of
+    (verts_loc, faces, unique_materials, dataname)
+    """
+
+    filename = os.path.splitext((os.path.basename(filepath)))[0]
+
+    if not SPLIT_OB_OR_GROUP or not faces:
+        use_verts_nor = any((False if f[1] is ... else True) for f in faces)
+        use_verts_tex = any((False if f[2] is ... else True) for f in faces)
+        use_verts_col = any((False if f[3] is ... else True) for f in faces)
+        # use the filename for the object name since we aren't chopping up the mesh.
+        return [(verts_loc, faces, unique_materials, filename, use_verts_nor, use_verts_tex, use_verts_col, verts_bw)]
+
+    def key_to_name(key):
+        # if the key is a tuple, join it to make a string
+        if not key:
+            return filename  # assume its a string. make sure this is true if the splitting code is changed
+        else:
+            return key.decode('utf-8', 'replace')
+
+    # Return a key that makes the faces unique.
+    face_split_dict = {}
+
+    oldkey = -1  # initialize to a value that will never match the key
+
+    for face in faces:
+        key = face[6]
+
+        if oldkey != key:
+            # Check the key has changed.
+            (verts_split, faces_split, unique_materials_split, vert_remap,
+             use_verts_nor, use_verts_tex, use_verts_col, verts_bw_split) = face_split_dict.setdefault(key, ([], [], {}, {}, [], [], [], []))
+            oldkey = key
+
+        face_vert_loc_indices = face[0]
+
+        if not use_verts_nor and face[1] is not ...:
+            use_verts_nor.append(True)
+
+        if not use_verts_tex and face[2] is not ...:
+            use_verts_tex.append(True)
+
+        if not use_verts_col and face[3] is not ...:
+            use_verts_col.append(True)
+
+        # Remap verts to new vert list and add where needed
+        for enum, i in enumerate(face_vert_loc_indices):
+            map_index = vert_remap.get(i)
+            if map_index is None:
+                map_index = len(verts_split)
+                vert_remap[i] = map_index  # set the new remapped index so we only add once and can reference next time.
+                verts_split.append(verts_loc[i])  # add the vert to the local verts
+                if verts_bw:
+                    verts_bw_split.append(verts_bw[i])  # add the vertex weight
+
+            face_vert_loc_indices[enum] = map_index  # remap to the local index
+
+            matname = face[4]
+            if matname and matname not in unique_materials_split:
+                unique_materials_split[matname] = unique_materials[matname]
+
+        faces_split.append(face)
+
+    # remove one of the items and reorder
+    return [(verts_split, faces_split, unique_materials_split, key_to_name(key), bool(use_vnor), bool(use_vtex), bool(use_vcol), verts_bw_split)
+            for key, (verts_split, faces_split, unique_materials_split, _, use_vnor, use_vtex, use_vcol, verts_bw_split)
+            in face_split_dict.items()]
+
+
+def create_mesh(new_objects,
+                use_edges,
+                verts_loc,
+                verts_nor,
+                verts_tex,
+                verts_col,
+                faces,
+                unique_materials,
+                unique_material_images,
+                unique_smooth_groups,
+                vertex_groups,
+                dataname,
+                verts_bw,
+                new_armatures,
+                bone_names
+                ):
+    """
+    Takes all the data gathered and generates a mesh, adding the new object to new_objects
+    deals with ngons, sharp edges and assigning materials
+    """
+
+    if unique_smooth_groups:
+        sharp_edges = set()
+        smooth_group_users = {context_smooth_group: {} for context_smooth_group in unique_smooth_groups.keys()}
+        context_smooth_group_old = -1
+
+    fgon_edges = set()  # Used for storing fgon keys when we need to tesselate/untesselate them (ngons with hole).
+    edges = []
+    tot_loops = 0
+
+    context_object = None
+
+    # reverse loop through face indices
+    for f_idx in range(len(faces) - 1, -1, -1):
+        (face_vert_loc_indices,
+         face_vert_nor_indices,
+         face_vert_tex_indices,
+         face_vert_col_indices,
+         context_material,
+         context_smooth_group,
+         context_object,
+         face_invalid_blenpoly,
+         ) = faces[f_idx]
+
+        len_face_vert_loc_indices = len(face_vert_loc_indices)
+
+        if len_face_vert_loc_indices == 1:
+            faces.pop(f_idx)  # cant add single vert faces
+
+        # Face with a single item in face_vert_nor_indices is actually a polyline!
+        elif len(face_vert_nor_indices) == 1 or len_face_vert_loc_indices == 2:
+            if use_edges:
+                edges.extend((face_vert_loc_indices[i], face_vert_loc_indices[i + 1])
+                             for i in range(len_face_vert_loc_indices - 1))
+            faces.pop(f_idx)
+
+        else:
+            # Smooth Group
+            if unique_smooth_groups and context_smooth_group:
+                # Is a part of of a smooth group and is a face
+                if context_smooth_group_old is not context_smooth_group:
+                    edge_dict = smooth_group_users[context_smooth_group]
+                    context_smooth_group_old = context_smooth_group
+
+                prev_vidx = face_vert_loc_indices[-1]
+                for vidx in face_vert_loc_indices:
+                    edge_key = (prev_vidx, vidx) if (prev_vidx < vidx) else (vidx, prev_vidx)
+                    prev_vidx = vidx
+                    edge_dict[edge_key] = edge_dict.get(edge_key, 0) + 1
+
+            # NGons into triangles
+            if face_invalid_blenpoly:
+                # ignore triangles with invalid indices
+                if len(face_vert_loc_indices) > 3:
+                    from bpy_extras.mesh_utils import ngon_tessellate
+                    ngon_face_indices = ngon_tessellate(verts_loc, face_vert_loc_indices)
+                    faces.extend([(
+                                [face_vert_loc_indices[ngon[0]],
+                                    face_vert_loc_indices[ngon[1]],
+                                    face_vert_loc_indices[ngon[2]],
+                                    ],
+                                [face_vert_nor_indices[ngon[0]],
+                                    face_vert_nor_indices[ngon[1]],
+                                    face_vert_nor_indices[ngon[2]],
+                                    ] if face_vert_nor_indices else [],
+                                [face_vert_tex_indices[ngon[0]],
+                                    face_vert_tex_indices[ngon[1]],
+                                    face_vert_tex_indices[ngon[2]],
+                                    ] if face_vert_tex_indices else [],
+                                [face_vert_col_indices[ngon[0]],
+                                    face_vert_col_indices[ngon[1]],
+                                    face_vert_col_indices[ngon[2]],
+                                    ] if face_vert_col_indices else [],
+                                context_material,
+                                context_smooth_group,
+                                context_object,
+                                [],
+                                )
+                                for ngon in ngon_face_indices]
+                                )
+                    tot_loops += 3 * len(ngon_face_indices)
+
+                    # edges to make ngons
+                    if len(ngon_face_indices) > 1:
+                        edge_users = set()
+                        for ngon in ngon_face_indices:
+                            prev_vidx = face_vert_loc_indices[ngon[-1]]
+                            for ngidx in ngon:
+                                vidx = face_vert_loc_indices[ngidx]
+                                if vidx == prev_vidx:
+                                    continue  # broken OBJ... Just skip.
+                                edge_key = (prev_vidx, vidx) if (prev_vidx < vidx) else (vidx, prev_vidx)
+                                prev_vidx = vidx
+                                if edge_key in edge_users:
+                                    fgon_edges.add(edge_key)
+                                else:
+                                    edge_users.add(edge_key)
+
+                faces.pop(f_idx)
+            else:
+                tot_loops += len_face_vert_loc_indices
+
+    # Build sharp edges
+    if unique_smooth_groups:
+        for edge_dict in smooth_group_users.values():
+            for key, users in edge_dict.items():
+                if users == 1:  # This edge is on the boundry of a group
+                    sharp_edges.add(key)
+
+    # map the material names to an index
+    material_mapping = {name: i for i, name in enumerate(unique_materials)}  # enumerate over unique_materials keys()
+
+    materials = [None] * len(unique_materials)
+
+    for name, index in material_mapping.items():
+        materials[index] = unique_materials[name]
+
+    me = bpy.data.meshes.new(dataname)
+
+    # make sure the list isnt too big
+    for material in materials:
+        me.materials.append(material)
+
+    me.vertices.add(len(verts_loc))
+    me.loops.add(tot_loops)
+    me.polygons.add(len(faces))
+
+    # verts_loc is a list of (x, y, z) tuples
+    me.vertices.foreach_set("co", unpack_list(verts_loc))
+
+    loops_vert_idx = []
+    faces_loop_start = []
+    faces_loop_total = []
+    lidx = 0
+    for f in faces:
+        vidx = f[0]
+        nbr_vidx = len(vidx)
+        loops_vert_idx.extend(vidx)
+        faces_loop_start.append(lidx)
+        faces_loop_total.append(nbr_vidx)
+        lidx += nbr_vidx
+
+    me.loops.foreach_set("vertex_index", loops_vert_idx)
+    me.polygons.foreach_set("loop_start", faces_loop_start)
+    me.polygons.foreach_set("loop_total", faces_loop_total)
+
+    if verts_nor and me.loops:
+        # Note: we store 'temp' normals in loops, since validate() may alter final mesh,
+        # we can only set custom lnors *after* calling it.
+        me.create_normals_split()
+
+    if verts_tex and me.polygons:
+        me.uv_layers.new()
+
+    if verts_col and me.polygons:
+        me.vertex_colors.new()
+
+    context_material_old = -1  # avoid a dict lookup
+    mat = 0  # rare case it may be un-initialized.
+
+    for i, (face, blen_poly) in enumerate(zip(faces, me.polygons)):
+        if len(face[0]) < 3:
+            raise Exception("bad face")  # Shall not happen, we got rid of those earlier!
+
+        (face_vert_loc_indices,
+         face_vert_nor_indices,
+         face_vert_tex_indices,
+         face_vert_col_indices,
+         context_material,
+         context_smooth_group,
+         context_object,
+         face_invalid_blenpoly,
+         ) = face
+
+        if context_smooth_group:
+            blen_poly.use_smooth = True
+
+        if context_material:
+            if context_material_old is not context_material:
+                mat = material_mapping[context_material]
+                context_material_old = context_material
+            blen_poly.material_index = mat
+
+        if verts_nor and face_vert_nor_indices:
+            for face_noidx, lidx in zip(face_vert_nor_indices, blen_poly.loop_indices):
+                me.loops[lidx].normal[:] = verts_nor[0 if (face_noidx is ...) else face_noidx]
+
+        if verts_col and face_vert_col_indices:
+            for face_colidx, lidx in zip(face_vert_col_indices, blen_poly.loop_indices):
+                me.vertex_colors[0].data[lidx].color[:] = verts_col[0 if (face_colidx is ...) else face_colidx][:3]
+
+        if verts_tex and face_vert_tex_indices:
+            if context_material:
+                image = unique_material_images[context_material]
+                if image:  # Can be none if the material dosnt have an image.
+                    me.uv_textures[0].data[i].image = image
+
+            blen_uvs = me.uv_layers[0]
+            for face_uvidx, lidx in zip(face_vert_tex_indices, blen_poly.loop_indices):
+                blen_uvs.data[lidx].uv = verts_tex[0 if (face_uvidx is ...) else face_uvidx]
+
+    use_edges = use_edges and bool(edges)
+    if use_edges:
+        me.edges.add(len(edges))
+        # edges should be a list of (a, b) tuples
+        me.edges.foreach_set("vertices", unpack_list(edges))
+
+    me.validate(clean_customdata=False)  # *Very* important to not remove lnors here!
+    me.update(calc_edges=use_edges)
+
+    # Un-tessellate as much as possible, in case we had to triangulate some ngons...
+    if fgon_edges:
+        import bmesh
+        bm = bmesh.new()
+        bm.from_mesh(me)
+        verts = bm.verts[:]
+        get = bm.edges.get
+        edges = [get((verts[vidx1], verts[vidx2])) for vidx1, vidx2 in fgon_edges]
+        try:
+            bmesh.ops.dissolve_edges(bm, edges=edges, use_verts=False)
+        except:
+            # Possible dissolve fails for some edges, but don't fail silently in case this is a real bug.
+            import traceback
+            traceback.print_exc()
+
+        bm.to_mesh(me)
+        bm.free()
+
+    # XXX If validate changes the geometry, this is likely to be broken...
+    if unique_smooth_groups and sharp_edges:
+        for e in me.edges:
+            if e.key in sharp_edges:
+                e.use_edge_sharp = True
+        me.show_edge_sharp = True
+
+    if verts_nor:
+        clnors = array.array('f', [0.0] * (len(me.loops) * 3))
+        me.loops.foreach_get("normal", clnors)
+
+        if not unique_smooth_groups:
+            me.polygons.foreach_set("use_smooth", [True] * len(me.polygons))
+
+        me.normals_split_custom_set(tuple(zip(*(iter(clnors),) * 3)))
+        me.use_auto_smooth = True
+        me.show_edge_sharp = True
+
+    ob = bpy.data.objects.new(me.name, me)
+    armature_ob = None
+    if new_armatures:
+        armature_ob = new_armatures[0]
+
+    if armature_ob:
+        # Assingn vertex weights
+        mod = ob.modifiers.new(type="ARMATURE", name="Armature")
+        mod.use_vertex_groups = True
+        mod.object = armature_ob
+
+        parent_armature = True
+        if parent_armature:
+            ob.parent = armature_ob
+
+        for vert_id, bws in enumerate(verts_bw):
+            for bw in bws:
+                bone_idx, bone_weight = bw
+                # print('----')
+                # print('bone_idx', bone_idx)
+                # print('bone_names', bone_names)
+                bone_name = bone_names[bone_idx].decode('utf-8', "replace")
+                if bone_weight == 0.0 or bone_name == 'root groud':
+                    continue
+
+                if bone_name:
+                    vert_group = ob.vertex_groups.get(bone_name)
+                    if not vert_group:
+                        vert_group = ob.vertex_groups.new(bone_name)
+                    vert_group.add([vert_id], bone_weight, 'REPLACE')
+
+    new_objects.append(ob)
+
+    # Create the vertex groups. No need to have the flag passed here since we test for the
+    # content of the vertex_groups. If the user selects to NOT have vertex groups saved then
+    # the following test will never run
+    for group_name, group_indices in vertex_groups.items():
+        group = ob.vertex_groups.new(group_name.decode('utf-8', "replace"))
+        group.add(group_indices, 1.0, 'REPLACE')
+
+
+def create_nurbs(context_nurbs, vert_loc, new_objects):
+    """
+    Add nurbs object to blender, only support one type at the moment
+    """
+    deg = context_nurbs.get(b'deg', (3,))
+    curv_range = context_nurbs.get(b'curv_range')
+    curv_idx = context_nurbs.get(b'curv_idx', [])
+    parm_u = context_nurbs.get(b'parm_u', [])
+    parm_v = context_nurbs.get(b'parm_v', [])
+    name = context_nurbs.get(b'name', b'ObjNurb')
+    cstype = context_nurbs.get(b'cstype')
+
+    if cstype is None:
+        print('\tWarning, cstype not found')
+        return
+    if cstype != b'bspline':
+        print('\tWarning, cstype is not supported (only bspline)')
+        return
+    if not curv_idx:
+        print('\tWarning, curv argument empty or not set')
+        return
+    if len(deg) > 1 or parm_v:
+        print('\tWarning, surfaces not supported')
+        return
+
+    cu = bpy.data.curves.new(name.decode('utf-8', "replace"), 'CURVE')
+    cu.dimensions = '3D'
+
+    nu = cu.splines.new('NURBS')
+    nu.points.add(len(curv_idx) - 1)  # a point is added to start with
+    nu.points.foreach_set("co", [co_axis for vt_idx in curv_idx for co_axis in (vert_loc[vt_idx] + (1.0,))])
+
+    nu.order_u = deg[0] + 1
+
+    # get for endpoint flag from the weighting
+    if curv_range and len(parm_u) > deg[0] + 1:
+        do_endpoints = True
+        for i in range(deg[0] + 1):
+
+            if abs(parm_u[i] - curv_range[0]) > 0.0001:
+                do_endpoints = False
+                break
+
+            if abs(parm_u[-(i + 1)] - curv_range[1]) > 0.0001:
+                do_endpoints = False
+                break
+
+    else:
+        do_endpoints = False
+
+    if do_endpoints:
+        nu.use_endpoint_u = True
+
+    # close
+    '''
+    do_closed = False
+    if len(parm_u) > deg[0]+1:
+        for i in xrange(deg[0]+1):
+            # print curv_idx[i], curv_idx[-(i+1)]
+
+            if curv_idx[i]==curv_idx[-(i+1)]:
+                do_closed = True
+                break
+
+    if do_closed:
+        nu.use_cyclic_u = True
+    '''
+
+    ob = bpy.data.objects.new(name.decode('utf-8', "replace"), cu)
+
+    new_objects.append(ob)
+
+
+def strip_slash(line_split):
+    if line_split[-1][-1] == 92:  # '\' char
+        if len(line_split[-1]) == 1:
+            line_split.pop()  # remove the \ item
+        else:
+            line_split[-1] = line_split[-1][:-1]  # remove the \ from the end last number
+        return True
+    return False
+
+
+def get_float_func(filepath):
+    """
+    find the float function for this obj file
+    - whether to replace commas or not
+    """
+    file = open(filepath, 'rb')
+    for line in file:  # .readlines():
+        line = line.lstrip()
+        if line.startswith(b'v'):  # vn vt v
+            if b',' in line:
+                file.close()
+                return lambda f: float(f.replace(b',', b'.'))
+            elif b'.' in line:
+                file.close()
+                return float
+
+    file.close()
+    # in case all vert values were ints
+    return float
+
+
+def load(context,
+         filepath,
+         *,
+         global_clamp_size=0.0,
+         use_smooth_groups=True,
+         use_edges=True,
+         use_split_objects=True,
+         use_split_groups=True,
+         use_image_search=True,
+         use_groups_as_vgroups=False,
+         relpath=None,
+         global_matrix=None
+         ):
+    """
+    Called by the user interface or another script.
+    load_obj(path) - should give acceptable results.
+    This function passes the file and sends the data off
+        to be split into objects and then converted into mesh objects
+    """
+
+    def handle_vec(line_start, context_multi_line, line_split, tag, data, vec, vec_len):
+        ret_context_multi_line = tag if strip_slash(line_split) else b''
+        if line_start == tag:
+            vec[:] = [float_func(v) for v in line_split[1:]]
+        elif context_multi_line == tag:
+            vec += [float_func(v) for v in line_split]
+        if not ret_context_multi_line:
+            data.append(tuple(vec[:vec_len]))
+        return ret_context_multi_line
+
+    def handle_bw_vec(line_start, context_multi_line, line_split, line, tag, data, vec, vec_len):
+        str_line = [line]
+        ret_context_multi_line = tag if strip_slash(str_line) else b''
+        if line_start == tag:
+            vec[:] = str_line
+        elif context_multi_line == tag:
+            vec[:] = [vec[0] + str_line[0]]
+        if not ret_context_multi_line:
+            str_vec = b''.join(vec)
+            str_str = str_vec.decode("utf-8", "ignore")
+            str_data = str_str.split(' ', 1)[1]
+            data.append(ast.literal_eval(str_data)[:vec_len])
+        return ret_context_multi_line
+
+    def create_face(context_material, context_smooth_group, context_object):
+        face_vert_loc_indices = []
+        face_vert_nor_indices = []
+        face_vert_tex_indices = []
+        face_vert_col_indices = []
+        return (
+            face_vert_loc_indices,  # face item 0
+            face_vert_nor_indices,  # face item 1
+            face_vert_tex_indices,  # face item 2
+            face_vert_col_indices,  # face item 3
+            context_material,       # face item 4
+            context_smooth_group,   # face item 5
+            context_object,         # face item 6
+            [],  # If non-empty, that face is a Blender-invalid ngon (holes...), need a mutable object for that...
+            )
+
+    with ProgressReport(context.window_manager) as progress:
+        progress.enter_substeps(1, "Importing OBJ %r..." % filepath)
+
+        if global_matrix is None:
+            global_matrix = mathutils.Matrix()
+
+        if use_split_objects or use_split_groups:
+            use_groups_as_vgroups = False
+
+        verts_loc = []
+        verts_nor = []
+        verts_tex = []
+        verts_col = []
+        verts_bw = []
+        faces = []  # tuples of the faces
+        material_libs = set()  # filenames to material libs this OBJ uses
+        armature_libs = set()  # filenames to armature libs this OBJ uses
+        vertex_groups = {}  # when use_groups_as_vgroups is true
+
+        # Get the string to float conversion func for this file- is 'float' for almost all files.
+        float_func = get_float_func(filepath)
+
+        # Context variables
+        context_material = None
+        context_smooth_group = None
+        context_object = None
+        context_vgroup = None
+
+        # Nurbs
+        context_nurbs = {}
+        nurbs = []
+        context_parm = b''  # used by nurbs too but could be used elsewhere
+
+        # Until we can use sets
+        unique_materials = {}
+        unique_material_images = {}
+        unique_smooth_groups = {}
+        # unique_obects= {} - no use for this variable since the objects are stored in the face.
+
+        # when there are faces that end with \
+        # it means they are multiline-
+        # since we use xreadline we cant skip to the next line
+        # so we need to know whether
+        context_multi_line = b''
+
+        # Per-face handling data.
+        face_vert_loc_indices = None
+        face_vert_nor_indices = None
+        face_vert_tex_indices = None
+        face_vert_col_indices = None
+        face_vert_nor_valid = face_vert_tex_valid = face_vert_col_valid = False
+        face_items_usage = set()
+        face_invalid_blenpoly = None
+        prev_vidx = None
+        face = None
+        vec = []
+
+        progress.enter_substeps(3, "Parsing OBJ file...")
+        with open(filepath, 'rb') as f:
+            for line in f:  # .readlines():
+                line_split = line.split()
+
+                if not line_split:
+                    continue
+
+                line_start = line_split[0]  # we compare with this a _lot_
+
+                if line_start == b'v' or context_multi_line == b'v':
+                    context_multi_line = handle_vec(line_start, context_multi_line, line_split, b'v', verts_loc, vec, 3)
+
+                elif line_start == b'vn' or context_multi_line == b'vn':
+                    context_multi_line = handle_vec(line_start, context_multi_line, line_split, b'vn', verts_nor, vec, 3)
+
+                elif line_start == b'vt' or context_multi_line == b'vt':
+                    context_multi_line = handle_vec(line_start, context_multi_line, line_split, b'vt', verts_tex, vec, 2)
+
+                elif line_start == b'vc' or context_multi_line == b'vc':
+                    context_multi_line = handle_vec(line_start, context_multi_line, line_split, b'vc', verts_col, vec, 4)
+
+                elif line_start == b'bw' or context_multi_line == b'bw':
+                    context_multi_line = handle_bw_vec(line_start, context_multi_line, line_split, line, b'bw', verts_bw, vec, 4)
+
+                # Handle faces lines (as faces) and the second+ lines of fa multiline face here
+                # use 'f' not 'f ' because some objs (very rare have 'fo ' for faces)
+                elif line_start == b'f' or context_multi_line == b'f':
+                    if not context_multi_line:
+                        line_split = line_split[1:]
+                        # Instantiate a face
+                        face = create_face(context_material, context_smooth_group, context_object)
+                        (face_vert_loc_indices, face_vert_nor_indices, face_vert_tex_indices, face_vert_col_indices,
+                         _1, _2, _3, face_invalid_blenpoly) = face
+                        faces.append(face)
+                        face_items_usage.clear()
+                    # Else, use face_vert_loc_indices and face_vert_tex_indices and face_vert_col_indices previously defined and used the obj_face
+
+                    context_multi_line = b'f' if strip_slash(line_split) else b''
+
+                    for v in line_split:
+                        obj_vert = v.split(b'/')
+                        # obj_vert[0] coordinate index
+                        # obj_vert[1] texture mapping index
+                        # obj_vert[2] normal index
+                        # obj_vert[3] color index
+
+                        idx = int(obj_vert[0]) - 1
+                        vert_loc_index = (idx + len(verts_loc) + 1) if (idx < 0) else idx
+                        # Add the vertex to the current group
+                        # *warning*, this wont work for files that have groups defined around verts
+                        if use_groups_as_vgroups and context_vgroup:
+                            vertex_groups[context_vgroup].append(vert_loc_index)
+                        # This a first round to quick-detect ngons that *may* use a same edge more than once.
+                        # Potential candidate will be re-checked once we have done parsing the whole face.
+                        if not face_invalid_blenpoly:
+                            # If we use more than once a same vertex, invalid ngon is suspected.
+                            if vert_loc_index in face_items_usage:
+                                face_invalid_blenpoly.append(True)
+                            else:
+                                face_items_usage.add(vert_loc_index)
+                        face_vert_loc_indices.append(vert_loc_index)
+
+                        # formatting for faces with normals and textures and vert color is
+                        # loc_index/tex_index/nor_index/vcol_index
+                        if len(obj_vert) > 1 and obj_vert[1] and obj_vert[1] != b'0':
+                            idx = int(obj_vert[1]) - 1
+                            face_vert_tex_indices.append((idx + len(verts_tex) + 1) if (idx < 0) else idx)
+                            face_vert_tex_valid = True
+                        else:
+                            face_vert_tex_indices.append(...)
+
+                        if len(obj_vert) > 2 and obj_vert[2] and obj_vert[2] != b'0':
+                            idx = int(obj_vert[2]) - 1
+                            face_vert_nor_indices.append((idx + len(verts_nor) + 1) if (idx < 0) else idx)
+                            face_vert_nor_valid = True
+                        else:
+                            face_vert_nor_indices.append(...)
+
+                        if len(obj_vert) > 3 and obj_vert[3] and obj_vert[3] != b'0':
+                            idx = int(obj_vert[3]) - 1
+                            face_vert_col_indices.append((idx + len(verts_col) + 1) if (idx < 0) else idx)
+                            face_vert_col_valid = True
+                        else:
+                            face_vert_col_indices.append(...)
+
+                    if not context_multi_line:
+                        # Clear nor/tex indices in case we had none defined for this face.
+                        if not face_vert_nor_valid:
+                            face_vert_nor_indices.clear()
+                        if not face_vert_tex_valid:
+                            face_vert_tex_indices.clear()
+                        if not face_vert_col_valid:
+                            face_vert_col_indices.clear()
+                        face_vert_nor_valid = face_vert_tex_valid = face_vert_col_valid = False
+
+                        # Means we have finished a face, we have to do final check if ngon is suspected to be blender-invalid...
+                        if face_invalid_blenpoly:
+                            face_invalid_blenpoly.clear()
+                            face_items_usage.clear()
+                            prev_vidx = face_vert_loc_indices[-1]
+                            for vidx in face_vert_loc_indices:
+                                edge_key = (prev_vidx, vidx) if (prev_vidx < vidx) else (vidx, prev_vidx)
+                                if edge_key in face_items_usage:
+                                    face_invalid_blenpoly.append(True)
+                                    break
+                                face_items_usage.add(edge_key)
+                                prev_vidx = vidx
+
+                elif use_edges and (line_start == b'l' or context_multi_line == b'l'):
+                    # very similar to the face load function above with some parts removed
+                    if not context_multi_line:
+                        line_split = line_split[1:]
+                        # Instantiate a face
+                        face = create_face(context_material, context_smooth_group, context_object)
+                        face_vert_loc_indices = face[0]
+                        # XXX A bit hackish, we use special 'value' of face_vert_nor_indices (a single True item) to tag this
+                        # as a polyline, and not a regular face...
+                        face[1][:] = [True]
+                        faces.append(face)
+                    # Else, use face_vert_loc_indices previously defined and used the obj_face
+
+                    context_multi_line = b'l' if strip_slash(line_split) else b''
+
+                    for v in line_split:
+                        obj_vert = v.split(b'/')
+                        idx = int(obj_vert[0]) - 1
+                        face_vert_loc_indices.append((idx + len(verts_loc) + 1) if (idx < 0) else idx)
+
+                elif line_start == b's':
+                    if use_smooth_groups:
+                        context_smooth_group = line_value(line_split)
+                        if context_smooth_group == b'off':
+                            context_smooth_group = None
+                        elif context_smooth_group:  # is not None
+                            unique_smooth_groups[context_smooth_group] = None
+
+                elif line_start == b'o':
+                    if use_split_objects:
+                        context_object = line_value(line_split)
+                        # unique_obects[context_object]= None
+
+                elif line_start == b'g':
+                    if use_split_groups:
+                        context_object = line_value(line.split())
+                        # print 'context_object', context_object
+                        # unique_obects[context_object]= None
+                    elif use_groups_as_vgroups:
+                        context_vgroup = line_value(line.split())
+                        if context_vgroup and context_vgroup != b'(null)':
+                            vertex_groups.setdefault(context_vgroup, [])
+                        else:
+                            context_vgroup = None  # dont assign a vgroup
+
+                elif line_start == b'usemtl':
+                    context_material = line_value(line.split())
+                    unique_materials[context_material] = None
+                elif line_start == b'mtllib':  # usemap or usemat
+                    # can have multiple mtllib filenames per line, mtllib can appear more than once,
+                    # so make sure only occurrence of material exists
+                    material_libs |= {os.fsdecode(f) for f in line.split()[1:]}
+                elif line_start == b'arllib':  # armature
+                    # can have multiple arllib filenames per line, arllib can appear more than once
+                    armature_libs |= {os.fsdecode(f) for f in line.split()[1:]}
+
+                    # Nurbs support
+                elif line_start == b'cstype':
+                    context_nurbs[b'cstype'] = line_value(line.split())  # 'rat bspline' / 'bspline'
+                elif line_start == b'curv' or context_multi_line == b'curv':
+                    curv_idx = context_nurbs[b'curv_idx'] = context_nurbs.get(b'curv_idx', [])  # in case were multiline
+
+                    if not context_multi_line:
+                        context_nurbs[b'curv_range'] = float_func(line_split[1]), float_func(line_split[2])
+                        line_split[0:3] = []  # remove first 3 items
+
+                    if strip_slash(line_split):
+                        context_multi_line = b'curv'
+                    else:
+                        context_multi_line = b''
+
+                    for i in line_split:
+                        vert_loc_index = int(i) - 1
+
+                        if vert_loc_index < 0:
+                            vert_loc_index = len(verts_loc) + vert_loc_index + 1
+
+                        curv_idx.append(vert_loc_index)
+
+                elif line_start == b'parm' or context_multi_line == b'parm':
+                    if context_multi_line:
+                        context_multi_line = b''
+                    else:
+                        context_parm = line_split[1]
+                        line_split[0:2] = []  # remove first 2
+
+                    if strip_slash(line_split):
+                        context_multi_line = b'parm'
+                    else:
+                        context_multi_line = b''
+
+                    if context_parm.lower() == b'u':
+                        context_nurbs.setdefault(b'parm_u', []).extend([float_func(f) for f in line_split])
+                    elif context_parm.lower() == b'v':  # surfaces not supported yet
+                        context_nurbs.setdefault(b'parm_v', []).extend([float_func(f) for f in line_split])
+                    # else: # may want to support other parm's ?
+
+                elif line_start == b'deg':
+                    context_nurbs[b'deg'] = [int(i) for i in line.split()[1:]]
+                elif line_start == b'end':
+                    # Add the nurbs curve
+                    if context_object:
+                        context_nurbs[b'name'] = context_object
+                    nurbs.append(context_nurbs)
+                    context_nurbs = {}
+                    context_parm = b''
+
+                ''' # How to use usemap? depricated?
+                elif line_start == b'usema': # usemap or usemat
+                    context_image= line_value(line_split)
+                '''
+
+        progress.step("Done, loading materials and images...")
+
+        create_materials(filepath, relpath, material_libs, unique_materials,
+                         unique_material_images, use_image_search, float_func)
+
+        progress.step("Done, building geometries (verts:%i faces:%i materials: %i smoothgroups:%i) ..." %
+                      (len(verts_loc), len(faces), len(unique_materials), len(unique_smooth_groups)))
+
+        # deselect all
+        if bpy.ops.object.select_all.poll():
+            bpy.ops.object.select_all(action='DESELECT')
+
+        scene = context.scene
+        new_objects = []  # put new objects here
+        new_armatures = []  # put new armatures here
+        bone_names = []
+
+        create_armatures(filepath, relpath, armature_libs, unique_materials,
+                         unique_material_images, use_image_search, float_func, new_armatures, new_objects, bone_names)
+
+        # Split the mesh by objects/materials, may
+        SPLIT_OB_OR_GROUP = bool(use_split_objects or use_split_groups)
+
+        for data in split_mesh(verts_loc, faces, unique_materials, filepath, SPLIT_OB_OR_GROUP, verts_bw):
+            verts_loc_split, faces_split, unique_materials_split, dataname, use_vnor, use_vtex, use_vcol, verts_bw_split = data
+            # Create meshes from the data, warning 'vertex_groups' wont support splitting
+            # ~ print(dataname, use_vnor, use_vtex, use_vcol)
+            create_mesh(new_objects,
+                        use_edges,
+                        verts_loc_split,
+                        verts_nor if use_vnor else [],
+                        verts_tex if use_vtex else [],
+                        verts_col if use_vcol else [],
+                        faces_split,
+                        unique_materials_split,
+                        unique_material_images,
+                        unique_smooth_groups,
+                        vertex_groups,
+                        dataname,
+                        verts_bw_split,
+                        new_armatures,
+                        bone_names,
+                        )
+
+        # nurbs support
+        for context_nurbs in nurbs:
+            create_nurbs(context_nurbs, verts_loc, new_objects)
+
+        for obj in new_armatures:
+            obj.select_set(state=True)
+
+            # we could apply this anywhere before scaling.
+            # Child object inherit world_matrix, so only apply it to the parent
+            parent_obj = obj
+            while parent_obj.parent is not None:
+                parent_obj = parent_obj.parent
+
+            parent_obj.matrix_world = global_matrix
+
+        # Create new obj
+        for obj in new_objects:
+            base = scene.objects.link(obj)
+            base.select_set(state=True)
+
+            # we could apply this anywhere before scaling.
+            # Child object inherit world_matrix, so only apply it to the parent
+            parent_obj = obj
+            while parent_obj.parent is not None:
+                parent_obj = parent_obj.parent
+
+            parent_obj.matrix_world = global_matrix
+
+        scene.update()
+
+        axis_min = [1000000000] * 3
+        axis_max = [-1000000000] * 3
+
+        if global_clamp_size:
+            # Get all object bounds
+            for ob in new_objects:
+                for v in ob.bound_box:
+                    for axis, value in enumerate(v):
+                        if axis_min[axis] > value:
+                            axis_min[axis] = value
+                        if axis_max[axis] < value:
+                            axis_max[axis] = value
+
+            # Scale objects
+            max_axis = max(axis_max[0] - axis_min[0], axis_max[1] - axis_min[1], axis_max[2] - axis_min[2])
+            scale = 1.0
+
+            while global_clamp_size < max_axis * scale:
+                scale = scale / 10.0
+
+            for obj in new_objects:
+                obj.scale = scale, scale, scale
+
+        progress.leave_substeps("Done.")
+        progress.leave_substeps("Finished importing: %r" % filepath)
+
+    return {'FINISHED'}

xnalara_io_Tools/import_xnalara_model.py

···
+import copy
+import operator
+import os
+import re
+
+import bpy
+from mathutils import Vector
+
+from . import (import_xnalara_pose, material_creator, read_ascii_xps,
+               read_bin_xps, xps_types)
+from .armature_tools.xnal_armature_utilities import (XnaL_AddRegisterBoneName,
+                                                     Xnal_CreateArmatureObject,
+                                                     XnaL_CreateBoneCollection,
+                                                     XnaL_GetBoneNameByIndex,
+                                                     XnaL_ShowHideBones)
+from .utilities.mesh_utilities import create_split_normals
+
+# imported XPS directory
+rootDir = ''
+MIN_BONE_LENGHT = 0.005
+
+
+def coordTransform(coords):
+    x, y, z = coords
+    z = -z
+    return (x, z, y)
+
+
+def faceTransform(face):
+    return [face[0], face[2], face[1]]
+
+
+def faceTransformList(faces):
+    return map(faceTransform, faces)
+
+
+def uvTransform(uv):
+    u = uv[0] + xpsSettings.uvDisplX
+    v = 1 + xpsSettings.uvDisplY - uv[1]
+    return [u, v]
+
+
+def rangeFloatToByte(float):
+    return int(float * 255) % 256
+
+
+def rangeByteToFloat(byte):
+    return byte / 255
+
+
+def uvTransformLayers(uvLayers):
+    return list(map(uvTransform, uvLayers))
+
+
+# profile
+def getInputFilename(xpsSettingsAux):
+    global xpsSettings
+    xpsSettings = xpsSettingsAux
+
+    blenderImportSetup()
+    status = xpsImport()
+    blenderImportFinalize()
+    return status
+
+
+def blenderImportSetup():
+    # switch to object mode and deselect all
+    objectMode()
+    bpy.ops.object.select_all(action='DESELECT')
+
+
+def blenderImportFinalize():
+    # switch to object mode
+    objectMode()
+
+
+def objectMode():
+    current_mode = bpy.context.mode
+    if bpy.context.view_layer.objects.active and current_mode != 'OBJECT':
+        bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
+
+
+def loadXpsFile(filename):
+    dirpath, file = os.path.split(filename)
+    basename, ext = os.path.splitext(file)
+    if ext.lower() in ('.mesh', '.xps'):
+        xpsData = read_bin_xps.readXpsModel(filename)
+    elif ext.lower() in ('.ascii'):
+        xpsData = read_ascii_xps.readXpsModel(filename)
+    else:
+        xpsData = None
+
+    return xpsData
+
+
+def makeMesh(meshFullName):
+    mesh_data = bpy.data.meshes.new(meshFullName)
+    mesh_object = bpy.data.objects.new(mesh_data.name, mesh_data)
+    print(f"Created Mesh: {meshFullName}")
+    print(f"New Mesh = {mesh_data.name}")
+    # bpy.context.scene.update()
+    # mesh_da.update()
+    return mesh_object
+
+
+def linkToCollection(collection, obj):
+    # Link Object to collection
+    collection.objects.link(obj)
+
+
+def xpsImport():
+    global rootDir
+    global xpsData
+
+    print("------------------------------------------------------------")
+    print("---------------EXECUTING XPS PYTHON IMPORTER----------------")
+    print("------------------------------------------------------------")
+    print("Importing file: ", xpsSettings.filename)
+
+    rootDir, file = os.path.split(xpsSettings.filename)
+    print('rootDir: {}'.format(rootDir))
+
+    xpsData = loadXpsFile(xpsSettings.filename)
+    if not xpsData:
+        return '{NONE}'
+
+    # Create New Collection
+    fname, fext = os.path.splitext(file)
+    xps_collection = bpy.data.collections.get("XPS IMPORT") if (bpy.data.collections.get("XPS IMPORT") is not None) else bpy.data.collections.new("XPS IMPORT")
+    if (xps_collection.name not in bpy.context.scene.collection.children):
+        bpy.context.scene.collection.children.link(xps_collection)
+
+    xps_model_collection = bpy.data.collections.new(fname)
+    xps_model_optional_objects_collection = bpy.data.collections.new(f"{fname} | OPTIONAL")
+
+    xps_collection.children.link(xps_model_collection)
+    xps_model_collection.children.link(xps_model_optional_objects_collection)
+
+    # imports the armature
+    armature_object = Xnal_CreateArmatureObject()
+    if armature_object is not None:
+        linkToCollection(xps_model_collection, armature_object)
+        XnaL_ImportModelBones(bpy.context, armature_object)
+        armature_object.select_set(True)
+
+    # imports all the meshes
+    meshe_objects = importMeshesList(armature_object)
+
+    if (xpsSettings.separate_optional_objects):
+        for mesh_object in meshe_objects:
+            object_name = mesh_object.name
+            object_name_regions = re.split(r"[1234567890]+_", mesh_object.name, 1)
+
+            if (len(object_name_regions) > 1):
+                object_name = object_name_regions[1]
+
+            if (object_name[0] in ["+", "-"]) or ("|" in mesh_object.name):
+                linkToCollection(xps_model_optional_objects_collection, mesh_object)
+            else:
+                linkToCollection(xps_model_collection, mesh_object)
+            mesh_object.select_set(True)
+        else:
+            for mesh_object in meshe_objects:
+                if (mesh_object.name in xps_model_optional_objects_collection.objects) and (mesh_object.name in xps_model_collection.objects):
+                    xps_model_collection.objects.unlink(mesh_object)
+    else:
+        for mesh_object in meshe_objects:
+            linkToCollection(xps_model_collection, mesh_object)
+            mesh_object.select_set(True)
+
+    if armature_object:
+        armature_object.pose.use_auto_ik = xpsSettings.autoIk
+        hideUnusedBones([armature_object])
+        boneTailMiddleObject(armature_object, xpsSettings.connectBones)
+
+    # Import default pose
+    if (xpsSettings.importDefaultPose and armature_object):
+        if (xpsData.header and xpsData.header.pose):
+            import_xnalara_pose.setXpsPose(armature_object, xpsData.header.pose)
+    return '{FINISHED}'
+
+
+def setMinimumLenght(bone):
+    default_length = MIN_BONE_LENGHT
+    if bone.length == 0:
+        bone.tail = bone.head - Vector((0, .001, 0))
+    if bone.length < default_length:
+        bone.length = default_length
+
+
+def boneTailMiddleObject(armature_ob, connectBones):
+    bpy.context.view_layer.objects.active = armature_ob
+
+    bpy.ops.object.mode_set(mode='EDIT', toggle=False)
+    editBones = armature_ob.data.edit_bones
+    boneTailMiddle(editBones, connectBones)
+    bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
+
+
+def setBoneConnect(connectBones):
+    currMode = bpy.context.mode
+    bpy.ops.object.mode_set(mode='EDIT', toggle=False)
+    editBones = bpy.context.view_layer.objects.active.data.edit_bones
+    connectEditBones(editBones, connectBones)
+    bpy.ops.object.mode_set(mode=currMode, toggle=False)
+
+
+def connectEditBones(editBones, connectBones):
+    for bone in editBones:
+        if bone.parent:
+            if bone.head == bone.parent.tail:
+                bone.use_connect = connectBones
+
+
+def hideBonesByName(armature_objs):
+    """Hide bones that do not affect any mesh."""
+    for armature in armature_objs:
+        for bone in armature.data.bones:
+            if bone.name.lower().startswith('unused'):
+                XnaL_ShowHideBones([bone], False)
+
+
+def hideBonesByVertexGroup(armature_objs):
+    """Hide bones that do not affect any mesh."""
+    for armature in armature_objs:
+        objs = [obj for obj in armature.children
+                if obj.type == 'MESH' and obj.modifiers and [
+                    modif for modif in obj.modifiers if modif
+                    and modif.type == 'ARMATURE' and modif.object == armature]]
+
+        # cycle objects and get all vertex groups
+        vertexgroups = set(
+            [vg.name for obj in objs if obj.type == 'MESH'
+                for vg in obj.vertex_groups])
+
+        bones = armature.data.bones
+        # leafBones = [bone for bone in bones if not bone.children]
+        rootBones = [bone for bone in bones if not bone.parent]
+
+        for bone in rootBones:
+            recurBones(bone, vertexgroups, '')
+
+
+def recurBones(bone, vertexgroups, name):
+    visibleChild = False
+    for childBone in bone.children:
+        aux = recurBones(childBone, vertexgroups, '{} '.format(name))
+        visibleChild = visibleChild or aux
+
+    visibleChain = bone.name in vertexgroups or visibleChild
+    if not visibleChain:
+        XnaL_ShowHideBones([bone], False)
+    return visibleChain
+
+
+def hideUnusedBones(armature_objs):
+    hideBonesByVertexGroup(armature_objs)
+    hideBonesByName(armature_objs)
+
+
+def boneDictRename(filepath, armatureObj):
+    boneDictDataRename, boneDictDataRestore = read_ascii_xps.readBoneDict(filepath)
+    renameBonesUsingDict(armatureObj, boneDictDataRename)
+
+
+def boneDictRestore(filepath, armatureObj):
+    boneDictDataRename, boneDictDataRestore = read_ascii_xps.readBoneDict(filepath)
+    renameBonesUsingDict(armatureObj, boneDictDataRestore)
+
+
+def renameBonesUsingDict(armatureObj, boneDict):
+    getbone = armatureObj.data.bones.get
+    for key, value in boneDict.items():
+        boneRenamed = getbone(import_xnalara_pose.renameBoneToBlender(key))
+        if boneRenamed:
+            boneRenamed.name = value
+        else:
+            boneOriginal = getbone(key)
+            if boneOriginal:
+                boneOriginal.name = value
+
+
+def XnaL_ImportModelBones(context: bpy.types.Context, armature_object: bpy.types.Object):
+    xps_bones = xpsData.bones
+
+    if (armature_object is not None) and (armature_object.data is not None) and (armature_object.type == "ARMATURE"):
+        armature: bpy.types.Armature = armature_object.data
+
+        context.view_layer.objects.active = armature_object
+        bpy.ops.object.mode_set(mode='EDIT')
+
+        xps_bone: xps_types.XpsBone
+        for xps_bone in xps_bones:
+            editBone = armature.edit_bones.new(xps_bone.name)
+            XnaL_AddRegisterBoneName(editBone.name)
+
+            transformedBone = coordTransform(xps_bone.co)
+            editBone.head = Vector(transformedBone)
+            editBone.tail = Vector(editBone.head) + Vector((0, 0, -.1))
+            setMinimumLenght(editBone)
+
+        for xps_bone in xps_bones:
+            editBone: bpy.types.EditBone = armature.edit_bones[xps_bone.id]
+            editBone.parent = armature.edit_bones[xps_bone.parentId]
+
+        context.view_layer.objects.active = armature_object
+        bpy.ops.object.mode_set(mode='OBJECT')
+    return armature_object
+
+
+def boneTailMiddle(editBones, connectBones):
+    """Move bone tail to children middle point."""
+    twistboneRegex = r'\b(hip)?(twist|ctr|root|adj)\d*\b'
+    for bone in editBones:
+        if (bone.name.lower() == "root ground" or not bone.parent):
+            bone.tail = bone.head.xyz + Vector((0, -.5, 0))
+        # elif (bone.name.lower() == "root hips"):
+        #    bone.tail = bone.head.xyz + Vector((0, .2, 0))
+        else:
+            childBones = [childBone for childBone in bone.children
+                          if not (re.search(twistboneRegex, childBone.name))]
+
+            if childBones:
+                # Set tail to children middle
+                bone.tail = Vector(map(sum, zip(*(childBone.head.xyz for childBone in childBones)))) / len(childBones)
+            else:
+                # if no child, set tail acording to parent
+                if bone.parent is not None:
+                    if bone.head.xyz != bone.parent.tail.xyz:
+                        # Tail to diference between bone and parent
+                        delta = bone.head.xyz - bone.parent.tail.xyz
+                    else:
+                        # Tail to same lenght/direction than parent
+                        delta = bone.parent.tail.xyz - bone.parent.head.xyz
+                    bone.tail = bone.head.xyz + delta
+
+    # Set minimum bone length
+    for bone in editBones:
+        setMinimumLenght(bone)
+
+    # Connect Bones to parent
+    connectEditBones(editBones, connectBones)
+
+
+def makeUvs(mesh_da, faces, uvData, vertColors):
+    # Create UVLayers
+    for i in range(len(uvData[0])):
+        mesh_da.uv_layers.new(name="UV{}".format(str(i + 1)))
+    if xpsSettings.vColors:
+        mesh_da.vertex_colors.new()
+
+    # Assign UVCoords
+    for faceId, face in enumerate(faces):
+        for vertId, faceVert in enumerate(face):
+            loopdId = (faceId * 3) + vertId
+            if xpsSettings.vColors:
+                mesh_da.vertex_colors[0].data[loopdId].color = vertColors[faceVert]
+            for layerIdx, uvLayer in enumerate(mesh_da.uv_layers):
+                uvCoor = uvData[faceVert][layerIdx]
+                uvLayer.data[loopdId].uv = Vector(uvCoor)
+
+
+def createJoinedMeshes():
+    meshPartRegex = re.compile(r'(!.*)*([\d]+nPart)*!')
+    sortedMeshesList = sorted(xpsData.meshes, key=operator.attrgetter('name'))
+    joinedMeshesNames = list(
+        {meshPartRegex.sub('', mesh.name, 0) for mesh in sortedMeshesList})
+    joinedMeshesNames.sort()
+    newMeshes = []
+    for joinedMeshName in joinedMeshesNames:
+        # for each joinedMeshName generate a list of meshes to join
+        meshesToJoin = [mesh for mesh in sortedMeshesList if meshPartRegex.sub(
+            '', mesh.name, 0) == joinedMeshName]
+
+        totalVertexCount = 0
+        vertexCount = 0
+        meshCount = 0
+
+        meshName = None
+        textures = None
+        vertex = None
+        faces = None
+
+        # new name for the unified mesh
+        meshName = meshPartRegex.sub('', meshesToJoin[0].name, 0)
+        # all the meshses share the same textures
+        textures = meshesToJoin[0].textures
+        # all the meshses share the uv layers count
+        uvCount = meshesToJoin[0].uvCount
+        # all the new joined mesh names
+        vertex = []
+        faces = []
+        for mesh in meshesToJoin:
+            vertexCount = 0
+            meshCount = meshCount + 1
+
+            if len(meshesToJoin) > 1 or meshesToJoin[0] not in sortedMeshesList:
+                # unify vertex
+                for vert in mesh.vertices:
+                    vertexCount = vertexCount + 1
+                    newVertice = xps_types.XpsVertex(
+                        vert.id + totalVertexCount, vert.co, vert.norm, vert.vColor, vert.uv, vert.boneWeights)
+                    vertex.append(newVertice)
+                # unify faces
+                for face in mesh.faces:
+                    newFace = [face[0] + totalVertexCount, face[1]
+                               + totalVertexCount, face[2] + totalVertexCount]
+                    faces.append(newFace)
+            else:
+                vertex = mesh.vertices
+                faces = mesh.faces
+            totalVertexCount = totalVertexCount + vertexCount
+
+        # Creates the nuw unified mesh
+        xpsMesh = xps_types.XpsMesh(meshName, textures, vertex, faces, uvCount)
+        newMeshes.append(xpsMesh)
+    return newMeshes
+
+
+def importMeshesList(armature_ob):
+    if xpsSettings.joinMeshParts:
+        newMeshes = createJoinedMeshes()
+    else:
+        newMeshes = xpsData.meshes
+    importedMeshes = [importMesh(armature_ob, meshInfo)
+                      for meshInfo in newMeshes]
+    return [mesh for mesh in importedMeshes if mesh]
+
+
+def generateVertexKey(vertex):
+    if xpsSettings.joinMeshRips:
+        key = str(vertex.co) + str(vertex.norm)
+    else:
+        key = str(vertex.id) + str(vertex.co) + str(vertex.norm)
+    return key
+
+
+def getVertexId(vertex, mapVertexKeys, mergedVertList):
+    vertexKey = generateVertexKey(vertex)
+    vertexID = mapVertexKeys.get(vertexKey)
+    if vertexID is None:
+        vertexID = len(mergedVertList)
+        mapVertexKeys[vertexKey] = vertexID
+        newVert = copy.copy(vertex)
+        newVert.id = vertexID
+        mergedVertList.append(newVert)
+    else:
+        mergedVertList[vertexID].merged = True
+    return vertexID
+
+
+def makeVertexDict(vertexDict, mergedVertList, uvLayers, vertColor, vertices):
+    mapVertexKeys = {}
+    uvLayerAppend = uvLayers.append
+    vertColorAppend = vertColor.append
+    vertexDictAppend = vertexDict.append
+
+    for vertex in vertices:
+        vColor = vertex.vColor
+        uvLayerAppend(list(map(uvTransform, vertex.uv)))
+        vertColorAppend(list(map(rangeByteToFloat, vColor)))
+        vertexID = getVertexId(vertex, mapVertexKeys, mergedVertList)
+        # old ID to new ID
+        vertexDictAppend(vertexID)
+
+
+def importMesh(armature_object, meshInfo):
+    # boneCount = len(xpsData.bones)
+    useSeams = xpsSettings.markSeams
+    # Create Mesh
+    meshFullName = meshInfo.name
+    print()
+    print('---*** Importing Mesh {} ***---'.format(meshFullName))
+
+    # Load UV Layers Count
+    uvLayerCount = meshInfo.uvCount
+    print('UV Layer Count: {}'.format(str(uvLayerCount)))
+
+    # Load Textures Count
+    textureCount = len(meshInfo.textures)
+    print('Texture Count: {}'.format(str(textureCount)))
+
+    mesh_object = None
+    vertCount = len(meshInfo.vertices)
+    if vertCount >= 3:
+        vertexDict = []
+        mergedVertList = []
+        uvLayers = []
+        vertColors = []
+        makeVertexDict(vertexDict, mergedVertList, uvLayers, vertColors, meshInfo.vertices)
+
+        # new ID to riginal ID
+        vertexOrig = [[] for x in range(len(mergedVertList))]
+        for vertId, vert in enumerate(vertexDict):
+            vertexOrig[vert].append(vertId)
+
+        mergedVertices = {}
+        seamEdgesDict = {}
+        facesData = []
+        for face in meshInfo.faces:
+            v1Old = face[0]
+            v2Old = face[1]
+            v3Old = face[2]
+            v1New = vertexDict[v1Old]
+            v2New = vertexDict[v2Old]
+            v3New = vertexDict[v3Old]
+            oldFace = ((v1Old, v2Old, v3Old))
+            facesData.append((v1New, v2New, v3New))
+
+            if (useSeams):
+                if (mergedVertList[v1New].merged
+                        or mergedVertList[v2New].merged
+                        or mergedVertList[v3New].merged):
+
+                    findMergedEdges(seamEdgesDict, vertexDict, mergedVertList, mergedVertices, oldFace)
+
+        # merge Vertices of same coord and normal?
+        mergeByNormal = True
+        if mergeByNormal:
+            vertices = mergedVertList
+            facesList = facesData
+        else:
+            vertices = meshInfo.vertices
+            facesList = meshInfo.faces
+
+        # Create Mesh
+        mesh_object = makeMesh(meshFullName)
+        mesh_data: bpy.types.Mesh = mesh_object.data
+
+        coords = []
+        normals = []
+        # vrtxList = []
+        # nbVrtx = []
+
+        for vertex in vertices:
+            unitnormal = Vector(vertex.norm).normalized()
+            coords.append(coordTransform(vertex.co))
+            normals.append(coordTransform(unitnormal))
+            # vertColors.append(vertex.vColor)
+            # uvLayers.append(uvTransformLayers(vertex.uv))
+
+        # Create Faces
+        faces = list(faceTransformList(facesList))
+        mesh_data.from_pydata(coords, [], faces)
+        mesh_data.polygons.foreach_set(
+            "use_smooth", [True] * len(mesh_data.polygons))
+
+        # speedup!!!!
+        if xpsSettings.markSeams:
+            markSeams(mesh_data, seamEdgesDict)
+
+        # Make UVLayers
+        origFaces = faceTransformList(meshInfo.faces)
+        makeUvs(mesh_data, origFaces, uvLayers, vertColors)
+
+        if (xpsData.header):
+            flags = xpsData.header.flags
+        else:
+            flags = read_bin_xps.flagsDefault()
+
+        # Make Material
+        material_creator.makeMaterial(xpsSettings, rootDir, mesh_data, meshInfo, flags)
+
+        if (armature_object is not None) and (mesh_object is not None):
+            setArmatureModifier(armature_object, mesh_object)
+            setParent(armature_object, mesh_object)
+
+        makeVertexGroups(mesh_object, vertices)
+
+        if (armature_object is not None) and (mesh_object is not None):
+            XnaL_CreateBoneCollection(armature_object, mesh_object)
+
+        # import custom normals
+        b_import_vertex_normals = xpsSettings.importNormals
+
+        # unique_smooth_groups = True
+
+        if (b_import_vertex_normals):
+            b_mesh_was_corrected = create_split_normals(mesh_object, normals)
+
+        print("Geometry Corrected:", b_mesh_was_corrected)
+
+    return mesh_object
+
+
+def markSeams(mesh_da, seamEdgesDict):
+    # use Dict to speedup search
+    edge_keys = {val: index for index, val in enumerate(mesh_da.edge_keys)}
+    # mesh_da.show_edge_seams = True
+    for vert1, list in seamEdgesDict.items():
+        for vert2 in list:
+            edgeIdx = None
+            if vert1 < vert2:
+                edgeIdx = edge_keys[(vert1, vert2)]
+            elif vert2 < vert1:
+                edgeIdx = edge_keys[(vert2, vert1)]
+            if edgeIdx:
+                mesh_da.edges[edgeIdx].use_seam = True
+
+
+def findMergedEdges(seamEdgesDict, vertexDict, mergedVertList, mergedVertices, oldFace):
+    findMergedVert(seamEdgesDict, vertexDict, mergedVertList, mergedVertices, oldFace, oldFace[0])
+    findMergedVert(seamEdgesDict, vertexDict, mergedVertList, mergedVertices, oldFace, oldFace[1])
+    findMergedVert(seamEdgesDict, vertexDict, mergedVertList, mergedVertices, oldFace, oldFace[2])
+
+
+def findMergedVert(seamEdgesDict, vertexDict, mergedVertList, mergedVertices, oldFace, mergedVert):
+    v1Old = oldFace[0]
+    v2Old = oldFace[1]
+    v3Old = oldFace[2]
+    # v1New = vertexDict[v1Old]
+    # v2New = vertexDict[v2Old]
+    # v3New = vertexDict[v3Old]
+    vertX = vertexDict[mergedVert]
+    if (mergedVertList[vertX].merged):
+        # List Merged vertices original Create
+        if (mergedVertices.get(vertX) is None):
+            mergedVertices[vertX] = []
+
+        # List Merged vertices original Loop
+        for facesList in mergedVertices[vertX]:
+            # Check if original vertices merge
+
+            i = 0
+            matchV1 = False
+            while not matchV1 and i < 3:
+                if ((vertX == vertexDict[facesList[i]]) and mergedVert != facesList[i]):
+                    if (mergedVert != v1Old):
+                        checkEdgePairForSeam(i, seamEdgesDict, vertexDict, vertX, v1Old, facesList)
+                    if (mergedVert != v2Old):
+                        checkEdgePairForSeam(i, seamEdgesDict, vertexDict, vertX, v2Old, facesList)
+                    if (mergedVert != v3Old):
+                        checkEdgePairForSeam(i, seamEdgesDict, vertexDict, vertX, v3Old, facesList)
+                    matchV1 = True
+                i = i + 1
+
+        # List Merged vertices original Append
+        mergedVertices[vertX].append((v1Old, v2Old, v3Old))
+
+
+def checkEdgePairForSeam(i, seamEdgesDict, vertexDict, mergedVert, vert, facesList):
+    if (i != 0):
+        makeSeamEdgeDict(0, seamEdgesDict, vertexDict, mergedVert, vert, facesList)
+    if (i != 1):
+        makeSeamEdgeDict(1, seamEdgesDict, vertexDict, mergedVert, vert, facesList)
+    if (i != 2):
+        makeSeamEdgeDict(2, seamEdgesDict, vertexDict, mergedVert, vert, facesList)
+
+
+def makeSeamEdgeDict(i, seamEdgesDict, vertexDict, mergedVert, vert, facesList):
+    if (vertexDict[vert] == vertexDict[facesList[i]]):
+        if (seamEdgesDict.get(mergedVert) is None):
+            seamEdgesDict[mergedVert] = []
+        seamEdgesDict[mergedVert].append(vertexDict[vert])
+
+
+def setArmatureModifier(armature_ob, mesh_ob):
+    mod = mesh_ob.modifiers.new(type="ARMATURE", name="Armature")
+    mod.use_vertex_groups = True
+    mod.object = armature_ob
+
+
+def setParent(armature_ob, mesh_ob):
+    mesh_ob.parent = armature_ob
+
+
+def makeVertexGroups(mesh_ob, vertices):
+    """Make vertex groups and assign weights."""
+    # blender limits vertexGroupNames to 63 chars
+    # armatures = [mesh_ob.find_armature()]
+    armatures = mesh_ob.find_armature()
+    for vertex in vertices:
+        assignVertexGroup(vertex, armatures, mesh_ob)
+
+
+def assignVertexGroup(vert, armature, mesh_ob):
+    for i in range(len(vert.boneWeights)):
+        vertBoneWeight = vert.boneWeights[i]
+        boneIdx = vertBoneWeight.id
+        vertexWeight = vertBoneWeight.weight
+        if vertexWeight != 0:
+            # use original index to get current bone name in blender
+            boneName = XnaL_GetBoneNameByIndex(boneIdx)
+            if boneName:
+                vertGroup = mesh_ob.vertex_groups.get(boneName)
+                if not vertGroup:
+                    vertGroup = mesh_ob.vertex_groups.new(name=boneName)
+                vertGroup.add([vert.id], vertexWeight, 'REPLACE')
+
+
+if __name__ == "__main__":
+
+    readfilename = r'C:\XPS Tutorial\Yaiba MOMIJIII\momi3.mesh.mesh'
+    uvDisplX = 0
+    uvDisplY = 0
+    impDefPose = True
+    joinMeshRips = True
+    joinMeshParts = True
+    vColors = True
+    connectBones = True
+    autoIk = True
+    importNormals = True
+    separate_optional_objects = True
+
+    xpsSettings = xps_types.XpsImportSettings(
+        readfilename, uvDisplX, uvDisplY, impDefPose, joinMeshRips,
+        markSeams, vColors,
+        joinMeshParts, connectBones, autoIk, importNormals, separate_optional_objects)
+    getInputFilename(xpsSettings)

xnalara_io_Tools/import_xnalara_pose.py

···
+from math import radians
+import os
+import re
+
+from . import read_ascii_xps
+from .timing import timing
+import bpy
+from mathutils import Euler, Matrix, Vector
+
+
+PLACE_HOLDER = r'*side*'
+RIGHT_BLENDER_SUFFIX = r'.R'
+LEFT_BLENDER_SUFFIX = r'.L'
+RIGHT_XPS_SUFFIX = r'right'
+LEFT_XPS_SUFFIX = r'left'
+
+
+def changeBoneNameToBlender(boneName, xpsSuffix, blenderSuffix):
+    ''' '''
+    # replace suffix with place holder
+    newName = re.sub(xpsSuffix, PLACE_HOLDER, boneName, flags=re.I)
+    # remove doble spaces
+    newName = re.sub(r'\s+', ' ', newName, flags=re.I)
+    newName = str.strip(newName)
+    if boneName != newName:
+        newName = '{0}{1}'.format(newName, blenderSuffix)
+
+    return newName.strip()
+
+
+def renameBoneToBlender(oldName):
+    newName = oldName
+    if PLACE_HOLDER not in oldName.lower():
+        if re.search(LEFT_XPS_SUFFIX, oldName, flags=re.I):
+            newName = changeBoneNameToBlender(oldName, LEFT_XPS_SUFFIX, LEFT_BLENDER_SUFFIX)
+
+        if re.search(RIGHT_XPS_SUFFIX, oldName, flags=re.I):
+            newName = changeBoneNameToBlender(oldName, RIGHT_XPS_SUFFIX, RIGHT_BLENDER_SUFFIX)
+
+    return newName
+
+
+def renameBonesToBlender(armatures_obs):
+    # currActive = bpy.context.active_object
+    for armature in armatures_obs:
+        for bone in armature.data.bones:
+            bone.name = renameBoneToBlender(bone.name)
+
+
+def changeBoneNameToXps(oldName, blenderSuffix, xpsSuffix):
+    # remove '.R' '.L' from the end of the name
+    newName = re.sub('{0}{1}'.format(re.escape(blenderSuffix), '$'), '', oldName, flags=re.I)
+    # remove doble spaces
+    newName = re.sub(r'\s+', ' ', newName, flags=re.I)
+    # replcace place holder
+    newName = re.sub(re.escape(PLACE_HOLDER), xpsSuffix, newName, flags=re.I)
+    return newName
+
+
+def renameBoneToXps(oldName):
+    newName = oldName
+    if PLACE_HOLDER in oldName.lower():
+        if re.search(re.escape(LEFT_BLENDER_SUFFIX), oldName, re.I):
+            newName = changeBoneNameToXps(oldName, LEFT_BLENDER_SUFFIX, LEFT_XPS_SUFFIX)
+
+        if re.search(re.escape(RIGHT_BLENDER_SUFFIX), oldName, re.I):
+            newName = changeBoneNameToXps(oldName, RIGHT_BLENDER_SUFFIX, RIGHT_XPS_SUFFIX)
+
+    return newName.strip()
+
+
+def renameBonesToXps(armatures_obs):
+    for armature in armatures_obs:
+        for bone in armature.data.bones:
+            bone.name = renameBoneToXps(bone.name)
+
+
+def getInputPoseSequence(filename):
+    filepath, file = os.path.split(filename)
+    basename, ext = os.path.splitext(file)
+    poseSuffix = re.sub(r'\d+$', '', basename)
+
+    files = []
+    for f in [file for file in os.listdir(filepath) if os.path.splitext(file)[1] == '.pose']:
+        fName, fExt = os.path.splitext(f)
+        fPoseSuffix = re.sub(r'\d+$', '', fName)
+        if poseSuffix == fPoseSuffix:
+            files.append(f)
+
+    files.sort()
+
+    initialFrame = bpy.context.scene.frame_current
+    for poseFile in files:
+        frame = bpy.context.scene.frame_current
+        poseFilename = os.path.join(filepath, poseFile)
+        importPoseAsKeyframe(poseFilename)
+        bpy.context.scene.frame_current = frame + 1
+
+    bpy.context.scene.frame_current = initialFrame
+
+
+def importPoseAsKeyframe(filename):
+    getInputFilename(filename)
+
+
+def getInputFilename(filename):
+
+    blenderImportSetup()
+    xpsImport(filename)
+    blenderImportFinalize()
+
+
+def blenderImportSetup():
+    pass
+
+
+def blenderImportFinalize():
+    pass
+
+
+def loadXpsFile(filename):
+    # dirpath, file = os.path.split(filename)
+    # basename, ext = os.path.splitext(file)
+    xpsData = read_ascii_xps.readXpsPose(filename)
+
+    return xpsData
+
+
+@timing
+def xpsImport(filename):
+    global rootDir
+    global xpsData
+
+    print("------------------------------------------------------------")
+    print("---------------EXECUTING XPS PYTHON IMPORTER----------------")
+    print("------------------------------------------------------------")
+    print("Importing Pose: ", filename)
+
+    rootDir, file = os.path.split(filename)
+    print('rootDir: {}'.format(rootDir))
+
+    xpsData = loadXpsFile(filename)
+
+    importPose()
+
+
+def importPose():
+    boneCount = len(xpsData)
+    print('Importing Pose', str(boneCount), 'bones')
+
+    armature = bpy.context.active_object
+    setXpsPose(armature, xpsData)
+
+
+def resetPose(armature):
+    for poseBone in armature.pose.bones:
+        poseBone.matrix_basis = Matrix()
+
+
+def setXpsPose(armature, xpsData):
+    currentMode = bpy.context.mode
+    currentObj = bpy.context.active_object
+    bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
+
+    context = bpy.context
+    rigobj = armature
+    context.view_layer.objects.active = rigobj
+    rigobj.select_set(state=True)
+
+    bpy.ops.object.mode_set(mode='POSE')
+    bpy.ops.pose.select_all(action='DESELECT')
+    for boneData in xpsData.items():
+        xpsBoneData = boneData[1]
+        boneName = xpsBoneData.boneName
+        poseBone = rigobj.pose.bones.get(boneName)
+        if poseBone is None:
+            poseBone = rigobj.pose.bones.get(renameBoneToBlender(boneName))
+
+        if poseBone:
+            xpsPoseBone(poseBone, xpsBoneData)
+            poseBone.bone.select = True
+
+    bpy.ops.anim.keyframe_insert(type='LocRotScale')
+    bpy.ops.object.posemode_toggle()
+    context.view_layer.objects.active = currentObj
+    bpy.ops.object.mode_set(mode=currentMode)
+
+
+def xpsPoseBone(poseBone, xpsBoneData):
+    xpsBoneRotate(poseBone, xpsBoneData.rotDelta)
+    xpsBoneTranslate(poseBone, xpsBoneData.coordDelta)
+    xpsBoneScale(poseBone, xpsBoneData.scale)
+
+
+def xpsBoneRotToEuler(rotDelta):
+    xRad = radians(rotDelta.x)
+    yRad = radians(rotDelta.y)
+    zRad = radians(rotDelta.z)
+    return Euler((xRad, yRad, zRad), 'YXZ')
+
+
+def vectorTransform(vec):
+    x = vec.x
+    y = vec.y
+    z = vec.z
+    z = -z
+    newVec = Vector((x, z, y))
+    return newVec
+
+
+def vectorTransformTranslate(vec):
+    x = vec.x
+    y = vec.y
+    z = vec.z
+    z = -z
+    newVec = Vector((x, z, y))
+    return newVec
+
+
+def vectorTransformScale(vec):
+    x = vec.x
+    y = vec.y
+    z = vec.z
+    newVec = Vector((x, y, z))
+    return newVec
+
+
+def xpsBoneRotate(poseBone, rotDelta):
+    current_rottion_mode = poseBone.rotation_mode
+    poseBone.rotation_mode = 'QUATERNION'
+    rotation = vectorTransform(rotDelta)
+    eulerRot = xpsBoneRotToEuler(rotation)
+    origRot = poseBone.bone.matrix_local.to_quaternion()  # LOCAL EditBone
+
+    rotation = eulerRot.to_quaternion()
+    poseBone.rotation_quaternion = origRot.inverted() @ rotation @ origRot
+    poseBone.rotation_mode = current_rottion_mode
+
+
+def xpsBoneTranslate(poseBone, coordsDelta):
+    translate = coordsDelta
+    translate = vectorTransformTranslate(coordsDelta)
+    origRot = poseBone.bone.matrix_local.to_quaternion()  # LOCAL EditBone
+
+    poseBone.location = origRot.inverted() @ translate
+
+
+def xpsBoneScale(poseBone, scale):
+    newScale = vectorTransformScale(scale)
+    poseBone.scale = newScale
+
+
+if __name__ == "__main__":
+    readPosefilename1 = r"G:\3DModeling\XNALara\XNALara_XPS\dataTest\Models\Queen's Blade\hide Kelta.pose"
+
+    getInputFilename(readPosefilename1)

xnalara_io_Tools/material_creator.py

···
+import os
+import random
+
+import bpy
+from mathutils import Vector
+
+from . import xps_const, xps_material
+
+ALPHA_MODE_CHANNEL = 'CHANNEL_PACKED'
+# Nodes Layout
+NODE_FRAME = 'NodeFrame'
+
+# Nodes Shaders
+BSDF_DIFFUSE_NODE = 'ShaderNodeBsdfDiffuse'
+BSDF_EMISSION_NODE = 'ShaderNodeEmission'
+BSDF_GLOSSY_NODE = 'ShaderNodeBsdfGlossy'
+PRINCIPLED_SHADER_NODE = 'ShaderNodeBsdfPrincipled'
+BSDF_TRANSPARENT_NODE = 'ShaderNodeBsdfTransparent'
+BSDF_GLASS_NODE = 'ShaderNodeBsdfGlass'
+SHADER_ADD_NODE = 'ShaderNodeAddShader'
+SHADER_MIX_NODE = 'ShaderNodeMixShader'
+
+# Nodes Color
+RGB_MIX_NODE = 'ShaderNodeMixRGB'
+INVERT_NODE = 'ShaderNodeInvert'
+
+# Nodes Input
+TEXTURE_IMAGE_NODE = 'ShaderNodeTexImage'
+ENVIRONMENT_IMAGE_NODE = 'ShaderNodeTexEnvironment'
+COORD_NODE = 'ShaderNodeTexCoord'
+
+# Nodes Outputs
+OUTPUT_NODE = 'ShaderNodeOutputMaterial'
+
+# Nodes Vector
+MAPPING_NODE = 'ShaderNodeMapping'
+NORMAL_MAP_NODE = 'ShaderNodeNormalMap'
+
+# Nodes Convert
+SHADER_NODE_MATH = 'ShaderNodeMath'
+RGB_TO_BW_NODE = 'ShaderNodeRGBToBW'
+SHADER_NODE_SEPARATE_RGB = 'ShaderNodeSeparateRGB'
+SHADER_NODE_COMBINE_RGB = 'ShaderNodeCombineRGB'
+
+# Node Groups
+NODE_GROUP = 'ShaderNodeGroup'
+NODE_GROUP_INPUT = 'NodeGroupInput'
+NODE_GROUP_OUTPUT = 'NodeGroupOutput'
+SHADER_NODE_TREE = 'ShaderNodeTree'
+
+# Node Custom Groups
+INVERT_CHANNEL_NODE = 'Invert Channel'
+MIX_NORMAL_NODE = 'Normal Mix'
+NORMAL_MASK_NODE = 'Normal Mask'
+XPS_SHADER_NODE = 'XPS Shader'
+
+# Sockets
+NODE_SOCKET_COLOR = 'NodeSocketColor'
+NODE_SOCKET_FLOAT = 'NodeSocketFloat'
+NODE_SOCKET_FLOAT_FACTOR = 'NodeSocketFloatFactor'
+NODE_SOCKET_SHADER = 'NodeSocketShader'
+NODE_SOCKET_VECTOR = 'NodeSocketVector'
+
+# Colors
+DIFFUSE_COLOR = (0.9, 0.9, 0.9, 1)
+SPECULAR_COLOR = (0.707, 0.707, 0.707, 1)
+LIGHTMAP_COLOR = (1, 1, 1, 1)
+NORMAL_COLOR = (0.5, 0.5, 1, 1)
+GREY_COLOR = (0.5, 0.5, 0.5, 1)
+
+# TODO
+
+
+def makeMaterialOutputNode(node_tree):
+    node = node_tree.nodes.new(OUTPUT_NODE)
+    node.location = 600, 0
+    return node
+
+
+def makeImageNode(node_tree):
+    node = node_tree.nodes.new(TEXTURE_IMAGE_NODE)
+    node.location = -400, 0
+    return node
+
+
+def makeEnvironmentNode(node_tree):
+    node = node_tree.nodes.new(ENVIRONMENT_IMAGE_NODE)
+    node.location = -400, 0
+    return node
+
+
+def makeTransparencyNode(node_tree):
+    node = node_tree.nodes.new(BSDF_TRANSPARENT_NODE)
+    node.location = -400, -200
+    return node
+
+
+def makeShaderMixNode(node_tree):
+    node = node_tree.nodes.new(SHADER_MIX_NODE)
+    node.location = -400, -400
+    return node
+
+
+def randomColor():
+    randomR = random.random()
+    randomG = random.random()
+    randomB = random.random()
+    return (randomR, randomG, randomB)
+
+# TODO missing version check
+
+
+def setNodeScale(node, value):
+    # Change from 2.80 to 2.81
+    if 'Scale' in node.inputs:
+        node.inputs['Scale'].default_value = (value, value, value)
+    else:
+        node.scale = (value, value, value)
+
+
+def getNodeGroup(node_tree, group):
+    node = node_tree.nodes.new(NODE_GROUP)
+    node.node_tree = bpy.data.node_groups[group]
+    return node
+
+# TODO make platform independent
+
+
+def makeImageFilepath(rootDir, textureFilename):
+    return os.path.join(rootDir, textureFilename)
+
+# TODO make platform independent
+
+
+def loadImage(textureFilepath):
+    textureFilename = os.path.basename(textureFilepath)
+    fileRoot, fileExt = os.path.splitext(textureFilename)
+
+    if (os.path.isfile(textureFilepath)):
+        print("Loading Texture: " + textureFilename)
+        image = bpy.data.images.load(filepath=textureFilepath, check_existing=True)
+    else:
+        print("Warning. Texture not found " + textureFilename)
+        image = bpy.data.images.new(
+            name=textureFilename, width=1024, height=1024, alpha=True,
+            float_buffer=False)
+        image.source = 'FILE'
+        image.filepath = textureFilepath
+    image.alpha_mode = ALPHA_MODE_CHANNEL
+
+    return image
+
+
+def newTextureSlot(materialData):
+    textureSlot = materialData.texture_slots.add()
+    textureSlot.texture_coords = "UV"
+    # textureSlot.texture = imgTex
+    textureSlot.use_map_alpha = True
+    textureSlot.alpha_factor = 1.0
+    return textureSlot
+
+
+def makeMaterial(xpsSettings, rootDir, mesh_da, meshInfo, flags):
+    # Create the material for Nodes
+    meshFullName = meshInfo.name
+    materialData = bpy.data.materials.new(meshFullName)
+    mesh_da.materials.append(materialData)
+
+    # Create
+    makeNodesMaterial(xpsSettings, materialData, rootDir, mesh_da, meshInfo, flags)
+
+
+def makeNodesMaterial(xpsSettings, material: bpy.types.Material, rootDir, mesh_da, meshInfo, flags):
+    textureFilepaths = meshInfo.textures
+    material.use_nodes = True
+    node_tree = material.node_tree
+    node_tree.nodes.clear()
+
+    meshFullName = material.name
+    renderType = xps_material.makeRenderType(meshFullName)
+    renderGroup = xps_material.RenderGroup(renderType)
+    param1 = renderType.texRepeater1
+    param2 = renderType.texRepeater2
+    strengthFac = renderType.specularity
+
+    bUseAlpha = renderGroup.rgAlpha
+
+    # Nodes
+    ouputNode = makeMaterialOutputNode(node_tree)
+    xpsShadeNode = getNodeGroup(node_tree, XPS_SHADER_NODE)
+    ouputNode.location = xpsShadeNode.location + Vector((700, 400))
+    coordNode = node_tree.nodes.new(COORD_NODE)
+    coordNode.location = xpsShadeNode.location + Vector((-2500, 400))
+
+    if (bUseAlpha == True):
+        if (bpy.app.version[:2] in [(4, 0), (4, 1)]):
+            material.blend_method = "HASHED"
+        if (bpy.app.version[:2] in [(4, 2), (4, 3), (4, 4)]):
+            material.surface_render_method = "DITHERED"
+
+    node_tree.links.new(xpsShadeNode.outputs['Shader'], ouputNode.inputs['Surface'])
+
+    bump1Image = None
+    bump2Image = None
+    maskGroupNode = None
+    normalMixNode = None
+    diffuseImgNode = None
+    normalMapNode = None
+
+    col_width = 200
+    imagesPosX = -col_width * 6
+    imagesPosY = 400
+
+# TODO make platform independent
+    imageFilepath = None
+    for texIndex, textureInfo in enumerate(textureFilepaths):
+        textureFilename = textureInfo.file
+        # textureUvLayer = textureInfo.uvLayer
+        textureBasename = os.path.basename(textureFilename)
+
+        # image mapping node
+        mappingCoordNode = node_tree.nodes.new(MAPPING_NODE)
+        # load image
+        imageFilepath = makeImageFilepath(rootDir, textureBasename)
+        imageNode = makeImageNode(node_tree)
+        imageNode.image = loadImage(imageFilepath)
+        node_tree.links.new(mappingCoordNode.outputs['Vector'], imageNode.inputs['Vector'])
+        imageNode.location = xpsShadeNode.location + Vector((imagesPosX, imagesPosY * 0))
+        mappingCoordNode.location = imageNode.location + Vector((-400, 0))
+        node_tree.links.new(coordNode.outputs['UV'], mappingCoordNode.inputs['Vector'])
+
+        if texIndex >= len(renderGroup.rgTexType):
+            continue
+
+        texType = xps_material.TextureType(renderGroup.rgTexType[texIndex])
+        if (texType == xps_material.TextureType.DIFFUSE):
+            imageNode.label = 'Diffuse'
+            node_tree.links.new(imageNode.outputs['Color'], xpsShadeNode.inputs['Diffuse'])
+            imageNode.location = xpsShadeNode.location + Vector((imagesPosX, imagesPosY * 1))
+            mappingCoordNode.location = imageNode.location + Vector((-400, 0))
+            diffuseImgNode = imageNode
+            if (bUseAlpha == True):
+                node_tree.links.new(imageNode.outputs['Alpha'], xpsShadeNode.inputs['Alpha'])
+        elif (texType == xps_material.TextureType.LIGHT):
+            imageNode.label = 'Light Map'
+            imageNode.location = xpsShadeNode.location + Vector((imagesPosX, imagesPosY * 0))
+            mappingCoordNode.location = imageNode.location + Vector((-400, 0))
+            node_tree.links.new(imageNode.outputs['Color'], xpsShadeNode.inputs['Lightmap'])
+        elif (texType == xps_material.TextureType.BUMP):
+            imageNode.label = 'Bump Map'
+            imageNode.image.colorspace_settings.is_data = True
+            node_tree.links.new(imageNode.outputs['Color'], xpsShadeNode.inputs['Bump Map'])
+            imageNode.location = xpsShadeNode.location + Vector((imagesPosX, imagesPosY * -2))
+            mappingCoordNode.location = imageNode.location + Vector((-400, 0))
+        elif (texType == xps_material.TextureType.SPECULAR):
+            imageNode.label = 'Specular'
+            imageNode.image.colorspace_settings.is_data = True
+            node_tree.links.new(imageNode.outputs['Color'], xpsShadeNode.inputs['Specular'])
+            imageNode.location = xpsShadeNode.location + Vector((imagesPosX, imagesPosY * -1))
+            mappingCoordNode.location = imageNode.location + Vector((-400, 0))
+        elif (texType == xps_material.TextureType.ENVIRONMENT):
+            imageNode.label = 'Reflection'
+            environmentNode = makeEnvironmentNode(node_tree)
+            environmentNode.image = imageNode.image
+            node_tree.nodes.remove(imageNode)
+            imageNode = environmentNode
+            imageNode.location = xpsShadeNode.location + Vector((imagesPosX, imagesPosY * 2))
+            mappingCoordNode.location = imageNode.location + Vector((-400, 0))
+            node_tree.links.new(coordNode.outputs['Reflection'], mappingCoordNode.inputs['Vector'])
+            node_tree.links.new(mappingCoordNode.outputs['Vector'], environmentNode.inputs['Vector'])
+            node_tree.links.new(imageNode.outputs['Color'], xpsShadeNode.inputs['Environment'])
+        elif (texType == xps_material.TextureType.MASK):
+            imageNode.label = 'Bump Mask'
+            imageNode.image.colorspace_settings.is_data = True
+            imageNode.location = xpsShadeNode.location + Vector((imagesPosX, imagesPosY * -3))
+            mappingCoordNode.location = imageNode.location + Vector((-400, 0))
+            node_tree.links.new(imageNode.outputs['Color'], xpsShadeNode.inputs['Bump Mask'])
+        elif (texType == xps_material.TextureType.BUMP1):
+            imageNode.label = 'Micro Bump 1'
+            imageNode.image.colorspace_settings.is_data = True
+            texRepeater = None
+            if renderGroup.renderGroupNum in (28, 29):
+                texRepeater = renderType.texRepeater2
+            else:
+                texRepeater = renderType.texRepeater1
+            setNodeScale(mappingCoordNode, texRepeater)
+            node_tree.links.new(coordNode.outputs['UV'], mappingCoordNode.inputs['Vector'])
+            node_tree.links.new(mappingCoordNode.outputs['Vector'], imageNode.inputs['Vector'])
+            node_tree.links.new(imageNode.outputs['Color'], xpsShadeNode.inputs['MicroBump 1'])
+            imageNode.location = xpsShadeNode.location + Vector((imagesPosX, imagesPosY * -4))
+            mappingCoordNode.location = imageNode.location + Vector((-400, 0))
+        elif (texType == xps_material.TextureType.BUMP2):
+            imageNode.label = 'Micro Bump 2'
+            imageNode.image.colorspace_settings.is_data = True
+            texRepeater = renderType.texRepeater2
+            setNodeScale(mappingCoordNode, texRepeater)
+            node_tree.links.new(coordNode.outputs['UV'], mappingCoordNode.inputs['Vector'])
+            node_tree.links.new(mappingCoordNode.outputs['Vector'], imageNode.inputs['Vector'])
+            node_tree.links.new(imageNode.outputs['Color'], xpsShadeNode.inputs['MicroBump 2'])
+            imageNode.location = xpsShadeNode.location + Vector((imagesPosX, imagesPosY * -5))
+            mappingCoordNode.location = imageNode.location + Vector((-400, 0))
+        elif (texType == xps_material.TextureType.EMISSION):
+            imageNode.label = 'Emission Map'
+            imageNode.location = xpsShadeNode.location + Vector((imagesPosX, imagesPosY * 2))
+            mappingCoordNode.location = imageNode.location + Vector((-400, 0))
+            if renderGroup.renderGroupNum in (36, 37):
+                setNodeScale(mappingCoordNode, param1)
+            node_tree.links.new(imageNode.outputs['Color'], xpsShadeNode.inputs['Emission'])
+        elif (texType == xps_material.TextureType.EMISSION_MINI):
+            imageNode.label = 'Mini Emission'
+            imageNode.location = xpsShadeNode.location + Vector((imagesPosX, imagesPosY * -6))
+            mappingCoordNode.location = imageNode.location + Vector((-400, 0))
+            setNodeScale(mappingCoordNode, param1)
+            node_tree.links.new(imageNode.outputs['Color'], xpsShadeNode.inputs['Emission'])
+
+
+def mix_normal_group():
+    # create a group
+    if MIX_NORMAL_NODE in bpy.data.node_groups:
+        return bpy.data.node_groups[MIX_NORMAL_NODE]
+    node_tree = bpy.data.node_groups.new(name=MIX_NORMAL_NODE, type=SHADER_NODE_TREE)
+    node_tree.nodes.clear()
+
+    mainNormalSeparateNode = node_tree.nodes.new(SHADER_NODE_SEPARATE_RGB)
+    mainNormalSeparateNode.location = Vector((0, 0))
+    detailNormalSeparateNode = node_tree.nodes.new(SHADER_NODE_SEPARATE_RGB)
+    detailNormalSeparateNode.location = mainNormalSeparateNode.location + Vector((0, -200))
+    mainNormalCombineNode = node_tree.nodes.new(SHADER_NODE_COMBINE_RGB)
+    mainNormalCombineNode.location = mainNormalSeparateNode.location + Vector((200, 0))
+    detailNormalCombineNode = node_tree.nodes.new(SHADER_NODE_COMBINE_RGB)
+    detailNormalCombineNode.location = mainNormalSeparateNode.location + Vector((200, -200))
+
+    multiplyBlueNode = node_tree.nodes.new(SHADER_NODE_MATH)
+    multiplyBlueNode.operation = 'MULTIPLY'
+    multiplyBlueNode.inputs[1].default_value = 1
+    multiplyBlueNode.location = mainNormalSeparateNode.location + Vector((200, -400))
+
+    addRGBNode = node_tree.nodes.new(RGB_MIX_NODE)
+    addRGBNode.blend_type = 'ADD'
+    addRGBNode.inputs['Fac'].default_value = 1
+    addRGBNode.location = mainNormalSeparateNode.location + Vector((400, 0))
+
+    subsRGBNode = node_tree.nodes.new(RGB_MIX_NODE)
+    subsRGBNode.blend_type = 'SUBTRACT'
+    subsRGBNode.inputs['Fac'].default_value = 1
+    subsRGBNode.location = mainNormalSeparateNode.location + Vector((600, -100))
+
+    separateRedBlueNode = node_tree.nodes.new(SHADER_NODE_SEPARATE_RGB)
+    separateRedBlueNode.location = mainNormalSeparateNode.location + Vector((800, -100))
+    combineFinalNode = node_tree.nodes.new(SHADER_NODE_COMBINE_RGB)
+    combineFinalNode.location = mainNormalSeparateNode.location + Vector((1000, -200))
+
+# TODO accidental node group wipes
+    # Input/Output
+    group_inputs = node_tree.nodes.new(NODE_GROUP_INPUT)
+    group_inputs.location = mainNormalSeparateNode.location + Vector((-200, -100))
+    group_outputs = node_tree.nodes.new(NODE_GROUP_OUTPUT)
+    group_outputs.location = mainNormalSeparateNode.location + Vector((1200, -100))
+    node_tree.interface.clear()
+
+    # Input Sockets
+    main_normal_socket = node_tree.interface.new_socket("Main", in_out="INPUT", socket_type="NodeSocketColor")
+    main_normal_socket.default_value = NORMAL_COLOR
+    detail_normal_socket = node_tree.interface.new_socket("Detail", in_out="INPUT", socket_type="NodeSocketColor")
+    detail_normal_socket.default_value = NORMAL_COLOR
+
+    # Output Sockets
+    output_value = node_tree.interface.new_socket("Color", in_out="OUTPUT", socket_type="NodeSocketColor")
+
+    # Links Input
+    links = node_tree.links
+    links.new(group_inputs.outputs['Main'], mainNormalSeparateNode.inputs['Image'])
+    links.new(group_inputs.outputs['Detail'], detailNormalSeparateNode.inputs['Image'])
+
+    links.new(mainNormalSeparateNode.outputs['R'], mainNormalCombineNode.inputs['R'])
+    links.new(mainNormalSeparateNode.outputs['G'], mainNormalCombineNode.inputs['G'])
+    links.new(mainNormalSeparateNode.outputs['B'], multiplyBlueNode.inputs[0])
+    links.new(detailNormalSeparateNode.outputs['R'], detailNormalCombineNode.inputs['R'])
+    links.new(detailNormalSeparateNode.outputs['G'], detailNormalCombineNode.inputs['G'])
+    links.new(detailNormalSeparateNode.outputs['B'], multiplyBlueNode.inputs[1])
+
+    links.new(mainNormalCombineNode.outputs['Image'], addRGBNode.inputs[1])
+    links.new(detailNormalCombineNode.outputs['Image'], addRGBNode.inputs[2])
+    links.new(addRGBNode.outputs['Color'], subsRGBNode.inputs[1])
+
+    links.new(subsRGBNode.outputs['Color'], separateRedBlueNode.inputs['Image'])
+
+    links.new(separateRedBlueNode.outputs['R'], combineFinalNode.inputs['R'])
+    links.new(separateRedBlueNode.outputs['G'], combineFinalNode.inputs['G'])
+    links.new(multiplyBlueNode.outputs['Value'], combineFinalNode.inputs['B'])
+
+    links.new(combineFinalNode.outputs['Image'], group_outputs.inputs['Color'])
+
+    return node_tree
+
+
+def invert_channel_group():
+    # create a group
+    if INVERT_CHANNEL_NODE in bpy.data.node_groups:
+        return bpy.data.node_groups[INVERT_CHANNEL_NODE]
+    node_tree = bpy.data.node_groups.new(name=INVERT_CHANNEL_NODE, type=SHADER_NODE_TREE)
+    node_tree.nodes.clear()
+
+    separateRgbNode = node_tree.nodes.new(SHADER_NODE_SEPARATE_RGB)
+    separateRgbNode.location = Vector((0, 0))
+
+    invertRNode = node_tree.nodes.new(INVERT_NODE)
+    invertRNode.inputs[0].default_value = 0
+    invertRNode.location = separateRgbNode.location + Vector((200, 40))
+    invertGNode = node_tree.nodes.new(INVERT_NODE)
+    invertGNode.inputs[0].default_value = 1
+    invertGNode.location = separateRgbNode.location + Vector((200, -60))
+    invertBNode = node_tree.nodes.new(INVERT_NODE)
+    invertBNode.inputs[0].default_value = 0
+    invertBNode.location = separateRgbNode.location + Vector((200, -160))
+
+    combineRgbNode = node_tree.nodes.new(SHADER_NODE_COMBINE_RGB)
+    combineRgbNode.location = separateRgbNode.location + Vector((600, 0))
+
+    # Input/Output
+    group_inputs = node_tree.nodes.new(NODE_GROUP_INPUT)
+    group_inputs.location = separateRgbNode.location + Vector((-200, -100))
+    group_outputs = node_tree.nodes.new(NODE_GROUP_OUTPUT)
+    group_outputs.location = combineRgbNode.location + Vector((200, 0))
+    node_tree.interface.clear()
+
+    # Input/Output Sockets
+    input_color = node_tree.interface.new_socket("Color", in_out="INPUT", socket_type="NodeSocketColor")
+    input_color.default_value = GREY_COLOR
+    invert_r = node_tree.interface.new_socket("R", in_out="INPUT", socket_type="NodeSocketFloat")
+    invert_r.subtype = "FACTOR"
+    invert_r.default_value = 0
+    invert_r.min_value = 0
+    invert_r.max_value = 1
+    invert_g = node_tree.interface.new_socket("G", in_out="INPUT", socket_type="NodeSocketFloat")
+    invert_g.subtype = "FACTOR"
+    invert_g.default_value = 0
+    invert_g.min_value = 0
+    invert_g.max_value = 1
+    invert_b = node_tree.interface.new_socket("B", in_out="INPUT", socket_type="NodeSocketFloat")
+    invert_b.subtype = "FACTOR"
+    invert_b.default_value = 0
+    invert_b.min_value = 0
+    invert_b.max_value = 1
+
+    output_value = node_tree.interface.new_socket("Color", in_out="OUTPUT", socket_type="NodeSocketColor")
+
+    # Links Input
+    links = node_tree.links
+    links.new(group_inputs.outputs['Color'], separateRgbNode.inputs['Image'])
+    links.new(group_inputs.outputs['R'], invertRNode.inputs['Fac'])
+    links.new(group_inputs.outputs['G'], invertGNode.inputs['Fac'])
+    links.new(group_inputs.outputs['B'], invertBNode.inputs['Fac'])
+    links.new(separateRgbNode.outputs['R'], invertRNode.inputs['Color'])
+    links.new(separateRgbNode.outputs['G'], invertGNode.inputs['Color'])
+    links.new(separateRgbNode.outputs['B'], invertBNode.inputs['Color'])
+
+    links.new(invertRNode.outputs['Color'], combineRgbNode.inputs['R'])
+    links.new(invertGNode.outputs['Color'], combineRgbNode.inputs['G'])
+    links.new(invertBNode.outputs['Color'], combineRgbNode.inputs['B'])
+
+    links.new(combineRgbNode.outputs['Image'], group_outputs.inputs['Color'])
+
+    return node_tree
+
+
+def normal_mask_group():
+    # create a group
+    if NORMAL_MASK_NODE in bpy.data.node_groups:
+        return bpy.data.node_groups[NORMAL_MASK_NODE]
+    node_tree = bpy.data.node_groups.new(name=NORMAL_MASK_NODE, type=SHADER_NODE_TREE)
+    node_tree.nodes.clear()
+
+    maskSeparateNode = node_tree.nodes.new(SHADER_NODE_SEPARATE_RGB)
+
+    # Mask Red Channel
+    maskRedPowerNode = node_tree.nodes.new(SHADER_NODE_MATH)
+    maskRedPowerNode.operation = 'POWER'
+    maskRedPowerNode.inputs[1].default_value = 1
+    maskRedPowerNode.location = maskSeparateNode.location + Vector((200, 100))
+
+    maskMixRedNode = node_tree.nodes.new(RGB_MIX_NODE)
+    maskMixRedNode.blend_type = 'MIX'
+    maskMixRedNode.inputs[1].default_value = (NORMAL_COLOR)
+    maskMixRedNode.location = maskRedPowerNode.location + Vector((200, 100))
+
+    # Mask Green Channel
+    maskGreenPowerNode = node_tree.nodes.new(SHADER_NODE_MATH)
+    maskGreenPowerNode.operation = 'POWER'
+    maskGreenPowerNode.inputs[1].default_value = 1
+    maskGreenPowerNode.location = maskSeparateNode.location + Vector((200, -100))
+
+    maskMixGreenNode = node_tree.nodes.new(RGB_MIX_NODE)
+    maskMixGreenNode.blend_type = 'MIX'
+    maskMixGreenNode.inputs[1].default_value = (NORMAL_COLOR)
+    maskMixGreenNode.location = maskGreenPowerNode.location + Vector((200, -100))
+
+    # Mix Masked Normals
+    normalMixNode = getNodeGroup(node_tree, MIX_NORMAL_NODE)
+    normalMixNode.location = maskSeparateNode.location + Vector((600, 0))
+
+    node_tree.links.new(maskSeparateNode.outputs['R'], maskRedPowerNode.inputs[0])
+    node_tree.links.new(maskSeparateNode.outputs['G'], maskGreenPowerNode.inputs[0])
+    node_tree.links.new(maskRedPowerNode.outputs['Value'], maskMixRedNode.inputs[0])
+    node_tree.links.new(maskGreenPowerNode.outputs['Value'], maskMixGreenNode.inputs[0])
+    node_tree.links.new(maskMixRedNode.outputs['Color'], normalMixNode.inputs['Main'])
+    node_tree.links.new(maskMixGreenNode.outputs['Color'], normalMixNode.inputs['Detail'])
+
+    # Input/Output
+    group_inputs = node_tree.nodes.new(NODE_GROUP_INPUT)
+    group_inputs.location = maskSeparateNode.location + Vector((-200, -100))
+    group_outputs = node_tree.nodes.new(NODE_GROUP_OUTPUT)
+    group_outputs.location = normalMixNode.location + Vector((200, 0))
+    node_tree.interface.clear()
+
+    # Input/Output Sockets
+    mask_color = node_tree.interface.new_socket("Mask", in_out="INPUT", socket_type="NodeSocketColor")
+    mask_color.default_value = LIGHTMAP_COLOR
+    normalMain_color = node_tree.interface.new_socket("Normal1", in_out="INPUT", socket_type="NodeSocketColor")
+    normalMain_color.default_value = NORMAL_COLOR
+    normalDetail_color = node_tree.interface.new_socket("Normal2", in_out="INPUT", socket_type="NodeSocketColor")
+    normalDetail_color.default_value = NORMAL_COLOR
+
+    output_value = node_tree.interface.new_socket("Normal", in_out="OUTPUT", socket_type="NodeSocketColor")
+
+    # Link Inputs/Output
+    node_tree.links.new(group_inputs.outputs['Mask'], maskSeparateNode.inputs['Image'])
+    node_tree.links.new(group_inputs.outputs['Normal1'], maskMixRedNode.inputs[2])
+    node_tree.links.new(group_inputs.outputs['Normal2'], maskMixGreenNode.inputs[2])
+    node_tree.links.new(normalMixNode.outputs['Color'], group_outputs.inputs['Normal'])
+
+
+def create_group_nodes():
+    mix_normal_group()
+    invert_channel_group()
+    normal_mask_group()
+    xps_shader_group()
+
+
+def xps_shader_group():
+    # create a group
+    if XPS_SHADER_NODE in bpy.data.node_groups:
+        return bpy.data.node_groups[XPS_SHADER_NODE]
+    shader = bpy.data.node_groups.new(name=XPS_SHADER_NODE, type=SHADER_NODE_TREE)
+
+    # Group inputs
+    group_input = shader.nodes.new(NODE_GROUP_INPUT)
+    group_input.location += Vector((-1200, 0))
+
+    group_output = shader.nodes.new(NODE_GROUP_OUTPUT)
+    group_output.location += Vector((600, 0))
+
+    output_diffuse = shader.interface.new_socket("Diffuse", in_out="INPUT", socket_type="NodeSocketColor")
+    output_diffuse.default_value = (DIFFUSE_COLOR)
+    output_lightmap = shader.interface.new_socket("Lightmap", in_out="INPUT", socket_type="NodeSocketColor")
+    output_lightmap.default_value = (LIGHTMAP_COLOR)
+    output_specular = shader.interface.new_socket("Specular", in_out="INPUT", socket_type="NodeSocketColor")
+    output_specular.default_value = (SPECULAR_COLOR)
+    output_emission = shader.interface.new_socket("Emission", in_out="INPUT", socket_type="NodeSocketColor")
+    output_normal = shader.interface.new_socket("Bump Map", in_out="INPUT", socket_type="NodeSocketColor")
+    output_normal.default_value = (NORMAL_COLOR)
+    output_bump_mask = shader.interface.new_socket("Bump Mask", in_out="INPUT", socket_type="NodeSocketColor")
+    output_microbump1 = shader.interface.new_socket("MicroBump 1", in_out="INPUT", socket_type="NodeSocketColor")
+    output_microbump1.default_value = (NORMAL_COLOR)
+    output_microbump2 = shader.interface.new_socket("MicroBump 2", in_out="INPUT", socket_type="NodeSocketColor")
+    output_microbump2.default_value = (NORMAL_COLOR)
+    output_environment = shader.interface.new_socket("Environment", in_out="INPUT", socket_type="NodeSocketColor")
+    output_alpha = shader.interface.new_socket("Alpha", in_out="INPUT", socket_type="NodeSocketFloat")
+    output_alpha.subtype = "FACTOR"
+    output_alpha.min_value = 0
+    output_alpha.max_value = 1
+    output_alpha.default_value = 1
+
+    # Group outputs
+    shader.interface.new_socket("Shader", in_out="OUTPUT", socket_type="NodeSocketShader")
+
+    principled = shader.nodes.new(PRINCIPLED_SHADER_NODE)
+
+    # Diffuse and Lightmap
+    mix_rgb = shader.nodes.new(RGB_MIX_NODE)
+    mix_rgb.location += Vector((-800, 100))
+    mix_rgb.inputs[0].default_value = 1
+    mix_rgb.blend_type = 'MULTIPLY'
+
+    shader.links.new(group_input.outputs['Diffuse'], mix_rgb.inputs[1])
+    shader.links.new(group_input.outputs['Lightmap'], mix_rgb.inputs[2])
+    shader.links.new(mix_rgb.outputs['Color'], principled.inputs['Base Color'])
+
+    # Specular
+    bw = shader.nodes.new(RGB_TO_BW_NODE)
+    bw.location += Vector((-800, -100))
+    pow = shader.nodes.new(SHADER_NODE_MATH)
+    pow.location += Vector((-600, -100))
+    pow.inputs[1].default_value = 2
+    pow.operation = 'POWER'
+    inv = shader.nodes.new(INVERT_NODE)
+    inv.location += Vector((-400, -100))
+
+    shader.links.new(group_input.outputs['Specular'], bw.inputs['Color'])
+    shader.links.new(bw.outputs['Val'], pow.inputs[0])
+    shader.links.new(pow.outputs['Value'], inv.inputs['Color'])
+    shader.links.new(inv.outputs['Color'], principled.inputs['Roughness'])
+
+    # Alpha & Emission
+    shader.links.new(group_input.outputs['Alpha'], principled.inputs['Alpha'])
+    shader.links.new(group_input.outputs['Emission'], principled.inputs['Emission Color'])
+
+    # Normals
+    normal_invert_channel = getNodeGroup(shader, INVERT_CHANNEL_NODE)
+    normal_invert_channel.location += Vector((-800, -500))
+    # normal_invert_channel.inputs['R'].default_value = flags[xps_const.TANGENT_SPACE_RED]
+    # normal_invert_channel.inputs['G'].default_value = flags[xps_const.TANGENT_SPACE_GREEN]
+    # normal_invert_channel.inputs['B'].default_value = flags[xps_const.TANGENT_SPACE_BLUE]
+    shader.links.new(group_input.outputs['Bump Map'], normal_invert_channel.inputs['Color'])
+
+    microbump1_invert_channel = getNodeGroup(shader, INVERT_CHANNEL_NODE)
+    microbump1_invert_channel.location += Vector((-800, -700))
+    # microbump1_invert_channel.inputs['R'].default_value = flags[xps_const.TANGENT_SPACE_RED]
+    # microbump1_invert_channel.inputs['G'].default_value = flags[xps_const.TANGENT_SPACE_GREEN]
+    # microbump1_invert_channel.inputs['B'].default_value = flags[xps_const.TANGENT_SPACE_BLUE]
+    shader.links.new(group_input.outputs['MicroBump 1'], microbump1_invert_channel.inputs['Color'])
+
+    microbump2_invert_channel = getNodeGroup(shader, INVERT_CHANNEL_NODE)
+    microbump2_invert_channel.location += Vector((-800, -900))
+    # microbump2_invert_channel.inputs['R'].default_value = flags[xps_const.TANGENT_SPACE_RED]
+    # microbump2_invert_channel.inputs['G'].default_value = flags[xps_const.TANGENT_SPACE_GREEN]
+    # microbump2_invert_channel.inputs['B'].default_value = flags[xps_const.TANGENT_SPACE_BLUE]
+    shader.links.new(group_input.outputs['MicroBump 2'], microbump2_invert_channel.inputs['Color'])
+
+    normal_mask = getNodeGroup(shader, NORMAL_MASK_NODE)
+    normal_mask.location += Vector((-600, -600))
+    shader.links.new(group_input.outputs['Bump Mask'], normal_mask.inputs['Mask'])
+
+    normal_mix = getNodeGroup(shader, MIX_NORMAL_NODE)
+    normal_mix.location += Vector((-400, -500))
+
+    normal_map = shader.nodes.new(NORMAL_MAP_NODE)
+    normal_map.location += Vector((-200, -500))
+
+    shader.links.new(microbump1_invert_channel.outputs['Color'], normal_mask.inputs['Normal1'])
+    shader.links.new(microbump2_invert_channel.outputs['Color'], normal_mask.inputs['Normal2'])
+
+    shader.links.new(normal_mask.outputs['Normal'], normal_mix.inputs['Detail'])
+    shader.links.new(normal_invert_channel.outputs['Color'], normal_mix.inputs['Main'])
+    shader.links.new(normal_mix.outputs['Color'], normal_map.inputs['Color'])
+    shader.links.new(normal_map.outputs['Normal'], principled.inputs['Normal'])
+
+    # Emission
+    emission_shader = shader.nodes.new(BSDF_EMISSION_NODE)
+    emission_shader.location += Vector((100, 200))
+    shader_add = shader.nodes.new(SHADER_ADD_NODE)
+    shader_add.location += Vector((300, 100))
+
+    shader.links.new(group_input.outputs['Environment'], emission_shader.inputs['Color'])
+    shader.links.new(emission_shader.outputs['Emission'], shader_add.inputs[0])
+    shader.links.new(principled.outputs['BSDF'], shader_add.inputs[1])
+    shader.links.new(shader_add.outputs['Shader'], group_output.inputs[0])
+
+    return shader

xnalara_io_Tools/mock_xps_data.py

···
+from getpass import getuser
+from socket import gethostname
+
+from . import bin_ops
+from . import xps_const
+from . import xps_types
+import bpy
+
+
+def mockData():
+    xpsHeader = buildHeader()
+    bones = buildBones()
+    meshes = buildMeshes()
+    xpsData = xps_types.XpsData(xpsHeader, bones, meshes)
+
+    return xpsData
+
+
+def fillPoseString(poseBytes):
+    poseLenghtUnround = len(poseBytes)
+    poseLenght = bin_ops.roundToMultiple(
+        poseLenghtUnround, xps_const.ROUND_MULTIPLE)
+    emptyFill = b'0' * (poseLenght - poseLenghtUnround)
+    return poseBytes + emptyFill
+
+
+def getPoseStringLength(poseString):
+    return len(poseString)
+
+
+def bonePoseCount(poseString):
+    boneList = poseString.split('\n')
+    return len(boneList) - 1
+
+
+def buildHeader(poseString=''):
+    invertUserName = getuser()[::-1]
+    invertHostName = gethostname()[::-1]
+    header = xps_types.XpsHeader()
+    header.magic_number = xps_const.MAGIC_NUMBER
+    header.version_mayor = xps_const.XPS_VERSION_MAYOR
+    header.version_minor = xps_const.XPS_VERSION_MINOR
+    header.xna_aral = xps_const.XNA_ARAL
+    header.machine = invertHostName
+    header.user = invertUserName
+    header.files = f'{invertUserName}@{bpy.data.filepath}'
+    # header.settings = bytes([0])*
+    #     (xps_const.SETTINGS_LEN * xps_const.ROUND_MULTIPLE)
+
+    boneCount = bonePoseCount(poseString)
+    poseBytes = poseString.encode(xps_const.ENCODING_WRITE)
+    default_pose = fillPoseString(poseBytes)
+    poseLengthUnround = getPoseStringLength(poseString)
+
+    var_1 = bin_ops.writeUInt32(180)  # Hash
+    var_2 = bin_ops.writeUInt32(3)  # Items
+
+    var_3 = bin_ops.writeUInt32(1)  # Type
+    var_4 = bin_ops.writeUInt32(poseLengthUnround)  # Pose Lenght Unround
+    var_5 = bin_ops.writeUInt32(boneCount)  # Pose Bone Counts
+    # POSE DATA
+    var_6 = bin_ops.writeUInt32(2)  # Type
+    var_7 = bin_ops.writeUInt32(4)  # Count
+    var_8 = bin_ops.writeUInt32(4)  # Info
+    var_9 = bin_ops.writeUInt32(2)  # Count N1
+    var_10 = bin_ops.writeUInt32(1)  # Count N2
+    var_11 = bin_ops.writeUInt32(3)  # Count N3
+    var_12 = bin_ops.writeUInt32(0)  # Count N4
+    var_13 = bin_ops.writeUInt32(4)  # Type
+    var_14 = bin_ops.writeUInt32(3)  # Count
+    var_15 = bin_ops.writeUInt32(5)  # Info
+    var_16 = bin_ops.writeUInt32(4)
+    var_17 = bin_ops.writeUInt32(0)
+    var_18 = bin_ops.writeUInt32(256)
+
+    header_empty = b''
+    header_empty += var_6
+    header_empty += var_7
+    header_empty += var_8
+    header_empty += var_9
+    header_empty += var_10
+    header_empty += var_11
+    header_empty += var_12
+    header_empty += var_13
+    header_empty += var_14
+    header_empty += var_15
+    header_empty += var_16
+    header_empty += var_17
+    header_empty += var_18
+
+    header_unk = var_1 + var_2 + var_3
+    header_pose = var_4 + var_5 + default_pose
+    empty_count = ((xps_const.SETTINGS_LEN - len(header_empty)) // 4)
+    header_empty += bin_ops.writeUInt32(0) * empty_count
+
+    settings = header_unk + header_pose + header_empty
+    header.settingsLen = len(settings) // 4
+    header.settings = settings
+
+    # logHeader(header)
+    return header
+
+
+def buildBones():
+    bones = []
+
+    id = 0
+    name = 'bone1'
+    co = [0, 0, 0]
+    parentId = -1
+    bone = xps_types.XpsBone(id, name, co, parentId)
+    bones.append(bone)
+
+    id = 1
+    name = 'bone2'
+    co = [0.5, 0.5, 0.5]
+    parentId = 0
+    bone = xps_types.XpsBone(id, name, co, parentId)
+    bones.append(bone)
+    return bones
+
+
+def buildMeshes():
+    meshes = []
+    meshName = 'Mesh1'
+    uvLayerCount = 1
+
+    # Textures
+    textures = []
+    texId = 0
+    textureFile = 'textutefile1.png'
+    uvLayerId = 0
+    xpsTexture = xps_types.XpsTexture(texId, textureFile, uvLayerId)
+    textures.append(xpsTexture)
+
+    texId = 1
+    textureFile = 'textutefile2.png'
+    uvLayerId = 0
+    xpsTexture = xps_types.XpsTexture(texId, textureFile, uvLayerId)
+    textures.append(xpsTexture)
+
+    # Vertices
+    vertex = []
+
+    # Vertex1
+    vertexId = 0
+    coord = (1, 0, 0)
+    normal = (0, 0, 1)
+    vertexColor = (255, 255, 255, 0)
+    uvs = []
+    uvs.append((.2, .4))
+    boneWeights = (
+        xps_types.BoneWeight(0, 0),
+        xps_types.BoneWeight(0, 0),
+        xps_types.BoneWeight(0, 0),
+        xps_types.BoneWeight(0, 0))
+    xpsVertex = xps_types.XpsVertex(
+        vertexId, coord, normal, vertexColor, uvs, boneWeights)
+
+    # Vertex2
+    vertexId = 1
+    coord = (0, 1, 0)
+    normal = (0, 1, 0)
+    vertexColor = (255, 255, 255, 0)
+    uvs = []
+    uvs.append((.3, .5))
+    boneWeights = (
+        xps_types.BoneWeight(0, 0),
+        xps_types.BoneWeight(0, 0),
+        xps_types.BoneWeight(0, 0),
+        xps_types.BoneWeight(0, 0))
+    xpsVertex = xps_types.XpsVertex(
+        vertexId, coord, normal, vertexColor, uvs, boneWeights)
+    vertex.append(xpsVertex)
+
+    # Vertex3
+    vertexId = 2
+    coord = (0, 0, 1)
+    normal = (1, 0, 0)
+    vertexColor = (255, 255, 255, 0)
+    uvs = []
+    uvs.append((.3, .9))
+    boneWeights = (
+        xps_types.BoneWeight(0, 0),
+        xps_types.BoneWeight(0, 0),
+        xps_types.BoneWeight(0, 0),
+        xps_types.BoneWeight(0, 0))
+    xpsVertex = xps_types.XpsVertex(
+        vertexId, coord, normal, vertexColor, uvs, boneWeights)
+    vertex.append(xpsVertex)
+
+    faces = []
+    face = (0, 1, 2)
+    faces.append(face)
+
+    xpsMesh = xps_types.XpsMesh(
+        meshName, textures, vertex, faces, uvLayerCount)
+    meshes.append(xpsMesh)
+
+    return meshes
+
+
+if __name__ == "__main__":
+    print('BUILD')
+    xx = mockData()
+    print('FINISH')

xnalara_io_Tools/modules/ALXAddonUpdater/.github/FUNDING.yml

···
+ko_fi: housearhal

xnalara_io_Tools/modules/ALXAddonUpdater/.gitignore

···
+__pycache__
+*updater_status.json

xnalara_io_Tools/modules/ALXAddonUpdater/LICENSE

···
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

xnalara_io_Tools/modules/ALXAddonUpdater/README.md

···
+# [ALX - Addon Updater]
+Forked from CG-Cookie's original addon-updater
+
+Supported Blender versions by the system [ 4.0/4.1/4.2/4.3/4.4 ]

xnalara_io_Tools/modules/ALXInfoSystem/ALXInfoSystem/ALX_InfoSystem.py

···
+# import bpy
+
+
+# class ALX_OT_Operator_Modal_InfoPopupAwaitCompletion(bpy.types.Operator):
+#     """"""
+
+#     bl_label = ""
+#     bl_idname = "alx.operator_modal_info_popup_await_completion"
+
+#     @classmethod
+#     def poll(self, context):
+#         return True
+
+#     def execute(self, context: bpy.types.Context):
+#         return {"FINISHED"}
+
+#     def modal(self, context: bpy.types.Context, event: bpy.types.Event):
+#         return {"RUNNING_MODAL"}
+
+#     def draw(self, context: bpy.types.Context):
+#         template_list
+
+#     def invoke(self, context: bpy.types.Context, event: bpy.types.Event):
+#         wm: bpy.types.WindowManager = context.window_manager
+#         return wm.invoke_popup(self, width=180)
+
+
+# def register_info():
+#     bpy.types.WindowManager
+
+
+# def unregister_info():

xnalara_io_Tools/modules/ALXModuleManager/.github/FUNDING.yml

···
+ko_fi: housearhal

xnalara_io_Tools/modules/ALXModuleManager/.gitignore

···
+__pycache__

xnalara_io_Tools/modules/ALXModuleManager/ALXModuleManager/ALX_ModuleManager.py

···
+import os
+from contextlib import redirect_stdout
+from inspect import getmembers, isclass
+from os import sep as os_separator
+from pathlib import Path
+from typing import Any, Optional
+
+import bpy
+import bpy.utils.previews as previews
+
+
+class Alx_Module_Manager():
+
+    __init_globals: dict[str, Any]
+
+    __module_path: str = ""
+    __module_folders: set[Path] = set()
+    __module_files: dict[str, Path] = dict()
+    __module_classes: set[str] = set()
+
+    __folder_blacklist: set[str] = set()
+    __file_blacklist: set[str] = set()
+
+    __resources: previews.ImagePreviewCollection = None
+
+    __mute: bool = True
+
+    def __init__(self, path: str, globals: dict[str, Any], mute: Optional[bool] = True):
+        self.__mute = mute
+
+        self.__folder_blacklist.update({"__pycache__"})
+        self.__file_blacklist.update({"__init__"})
+
+        self.__module_path = path[0]
+        self.__init_globals = globals
+
+    def developer_register_modules(self):
+        self.__module_folders = self.__gather_addon_folders(self.__module_path, self.__folder_blacklist)
+        self.__module_files = self.__gather_addon_files(self.__module_folders, self.__file_blacklist)
+        self.__execute_locals_update(self.__module_path, self.__module_files)
+        self.__module_classes = self.__gather_classes_from_files(self.__module_files)
+        self.__register_addon_classes(self.__module_classes)
+
+    def developer_unregister_modules(self):
+        self.__unregister_addon_classes(self.__module_classes)
+
+    def developer_blacklist_folder(self, folders: set[str]):
+        self.__folder_blacklist.add(*folders)
+
+    def developer_blacklist_file(self, files: set[str]):
+        self.__file_blacklist.add(*files)
+
+    def developer_load_resources(self, icons_definitions: list[dict["name":str, "path":str, "resource_type":str]]):
+        """
+        name : str [MUST BE UNIQUE]\n
+        path : str\n [MUST BE RELATIVE TO THE FOLDER CONTAINING THE ADDON'S INIT FILE]
+        resource_type : str ['IMAGE', 'MOVIE', 'BLEND', 'FONT']\n
+        """
+        if (self.__resources is None):
+            self.__resources = previews.new()
+
+        name_id_pairs = {}
+        for entry in icons_definitions:
+
+            if ({"name", "path", "resource_type"}.issubset(set(entry.keys()))):
+                path_object = Path(f"{self.__module_path}{os_separator if self.__module_path[-1] != os_separator else ''}{entry['path']}")
+                if (path_object.exists()) and (path_object.is_file()):
+                    self.__resources.load(
+                        entry["name"],
+                        str(path_object),
+                        entry["resource_type"],
+                        True
+                    )
+
+                name_id_pairs.update({entry["name"]: self.__resources[entry["name"]].icon_id})
+
+        icons_path_object = Path(f"{self.__module_path}\\icons.py")
+
+        icons_path_object.parent.mkdir(exist_ok=True, parents=True)
+        with icons_path_object.open('w') as icon_file:
+            text = "icons_dictionary={\n"
+
+            for string in [*[f"\"{entry_name}\" : {entry_id},\n" for entry_name, entry_id in name_id_pairs.items()], "\n}"]:
+                text += string
+
+            icon_file.write(text)
+
+    def __gather_addon_folders(self, path: str, folder_blacklist: set[str] = {}):
+        """
+        IN path: __path__[0] from __init__ \n
+        IN folder_blacklist: set[str] \n
+
+        RETURN addon_folders: set[Path] \n
+        """
+
+        path_object: Path = Path(path)
+        addon_folders: set[Path] = set()
+
+        if (path_object.exists()) and (path_object.is_dir()):
+            path_iter_queue: list[Path] = [path_object]
+
+            for folder_path in path_iter_queue:
+                if (folder_path.is_dir()) and (folder_path.exists()) and (folder_path not in addon_folders) and (folder_path.name not in folder_blacklist):
+                    addon_folders.add(folder_path)
+
+                    for subfolder_path in folder_path.iterdir():
+                        if (subfolder_path.is_dir()) and (subfolder_path.exists()) and (subfolder_path not in addon_folders) and (subfolder_path.name not in folder_blacklist):
+                            path_iter_queue.append(subfolder_path)
+                            addon_folders.add(subfolder_path)
+
+        return addon_folders
+
+    def __gather_addon_files(self, folder_paths: set[Path], file_blacklist: set[str] = {}):
+        """
+        IN folder_paths: set[Path] \n
+        IN file_blacklist: set[str] \n
+
+        RETRUN addon_files: set[str] \n
+        """
+
+        addon_files: dict[str, Path] = dict()
+
+        for folder_path in folder_paths:
+            for file in folder_path.iterdir():
+                if (file.is_file()) and (file.name not in file_blacklist) and (file.suffix == ".py"):
+                    addon_files.update({file.name[0:-3]: folder_path})
+
+        return addon_files
+
+    def __gather_classes_from_files(self, addon_files: dict[str, Path] = None):
+        addon_classes: set[str] = set()
+
+        for file_name in addon_files.keys():
+            if (file_name != __file__) and (file_name not in self.__file_blacklist):
+                for addon_class in getmembers(eval(file_name, self.__init_globals), isclass):
+                    addon_classes.add(addon_class[1])
+
+        return addon_classes
+
+    def __execute_locals_update(self, path: str, addon_files: dict[str, Path]):
+        for file_name in addon_files.keys():
+            if (file_name != __name__.split(".")[-1]) and (file_name not in self.__file_blacklist):
+                try:
+                    if ("importlib" not in self.__init_globals):
+                        exec("import importlib", self.__init_globals)
+
+                    if (file_name not in self.__init_globals):
+                        relative_path = str(addon_files.get(file_name).relative_to(path)).replace(os_separator, ".")
+
+                        import_line = f"from . {relative_path if relative_path != '.' else ''} import {file_name}"
+                        exec(import_line, self.__init_globals)
+                    else:
+                        reload_line = f"{file_name} = importlib.reload({file_name})"
+                        exec(reload_line, self.__init_globals)
+                except Exception as error:
+                    if (self.__mute == False):
+                        print(f"[{file_name}] {error}")
+
+    def __register_addon_classes(self, addon_classes: list[object]):
+        for addon_class in addon_classes:
+            try:
+                if (self.__mute):
+                    with open(os.devnull, 'w') as print_discard_bin:
+                        with redirect_stdout(print_discard_bin):
+                            if ("WorkSpaceTool" in [base.__name__ for base in addon_class.__bases__]):
+                                bpy.utils.register_tool(addon_class,
+                                                        after=eval(addon_class.after, self.__init_globals),
+                                                        separator=addon_class.separator,
+                                                        group=addon_class.group)
+                            else:
+                                bpy.utils.register_class(addon_class)
+                else:
+                    if ("WorkSpaceTool" in [base.__name__ for base in addon_class.__bases__]):
+                        bpy.utils.register_tool(addon_class,
+                                                after=eval(addon_class.after, self.__init_globals),
+                                                separator=addon_class.separator,
+                                                group=addon_class.group)
+                    else:
+                        bpy.utils.register_class(addon_class)
+
+            except Exception as error:
+                if (self.__mute == False):
+                    print(error)
+
+    def __unregister_addon_classes(self, addon_classes: list[object]):
+        for addon_class in addon_classes:
+            try:
+                if ("WorkSpaceTool" in [base.__name__ for base in addon_class.__bases__]):
+                    bpy.utils.unregister_tool(addon_class)
+                else:
+                    bpy.utils.unregister_class(addon_class)
+
+            except Exception as error:
+                if (self.__mute == False):
+                    print(error)
+
+        if (self.__resources is not None):
+            previews.remove(self.__resources)

xnalara_io_Tools/modules/ALXModuleManager/LICENSE

···
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

xnalara_io_Tools/modules/ALXModuleManager/README.md

···
+# [ALX - Module Manager]
+
+Supported Blender versions by the system [ 4.0/4.1/4.2/4.3/4.4 ]

xnalara_io_Tools/node_shader_utils.py

···
+import bpy
+from bpy_extras import node_shader_utils
+from mathutils import Vector
+
+
+class XPSShaderWrapper(node_shader_utils.ShaderWrapper):
+    """
+    Hard coded shader setup, based in XPS Shader.
+    Should cover most common cases on import, and gives a basic nodal shaders support for export.
+    """
+    NODES_LIST = (
+        "node_out",
+        "node_principled_bsdf",
+
+        "_node_normalmap",
+        "_node_texcoords",
+    )
+
+    __slots__ = (
+        "is_readonly",
+        "material",
+        *NODES_LIST,
+    )
+
+    NODES_LIST = node_shader_utils.ShaderWrapper.NODES_LIST + NODES_LIST
+
+    def __init__(self, material, is_readonly=True, use_nodes=True):
+        super(XPSShaderWrapper, self).__init__(material, is_readonly, use_nodes)
+
+    def update(self):
+        super(XPSShaderWrapper, self).update()
+
+        if not self.use_nodes:
+            return
+
+        tree = self.material.node_tree
+
+        nodes = tree.nodes
+        links = tree.links
+
+        # --------------------------------------------------------------------
+        # Main output and shader.
+        node_out = None
+        node_principled = None
+        for n in nodes:
+            # print("loop:",n.name)
+            if n.bl_idname == 'ShaderNodeOutputMaterial' and n.inputs[0].is_linked:
+                # print("output found:")
+                node_out = n
+                node_principled = n.inputs[0].links[0].from_node
+            elif n.bl_idname == 'ShaderNodeGroup' and n.node_tree.name == 'XPS Shader' and n.outputs[0].is_linked:
+                # print("xps shader found")
+                node_principled = n
+                for lnk in n.outputs[0].links:
+                    node_out = lnk.to_node
+                    if node_out.bl_idname == 'ShaderNodeOutputMaterial':
+                        break
+            if (
+                node_out is not None and node_principled is not None
+                and node_out.bl_idname == 'ShaderNodeOutputMaterial'
+                and node_principled.bl_idname == 'ShaderNodeGroup'
+                and node_principled.node_tree.name == 'XPS Shader'
+            ):
+                break
+            node_out = node_principled = None  # Could not find a valid pair, let's try again
+
+        if node_out is not None:
+            self._grid_to_location(0, 0, ref_node=node_out)
+        elif not self.is_readonly:
+            node_out = nodes.new(type='ShaderNodeOutputMaterial')
+            node_out.label = "Material Out"
+            node_out.target = 'ALL'
+            self._grid_to_location(1, 1, dst_node=node_out)
+        self.node_out = node_out
+
+        if node_principled is not None:
+            self._grid_to_location(0, 0, ref_node=node_principled)
+        elif not self.is_readonly:
+            node_principled = nodes.new(type='XPS Shader')
+            node_principled.label = "Principled BSDF"
+            self._grid_to_location(0, 1, dst_node=node_principled)
+            # Link
+            links.new(node_principled.outputs["BSDF"], self.node_out.inputs["Surface"])
+        self.node_principled_bsdf = node_principled
+
+        # --------------------------------------------------------------------
+        # Normal Map, lazy initialization...
+        self._node_normalmap = ...
+
+        # --------------------------------------------------------------------
+        # Tex Coords, lazy initialization...
+        self._node_texcoords = ...
+
+    # --------------------------------------------------------------------
+    # Get Image wrapper.
+
+    def node_texture_get(self, inputName):
+        if not self.use_nodes or self.node_principled_bsdf is None:
+            return None
+        return node_shader_utils.ShaderImageTextureWrapper(
+            self, self.node_principled_bsdf,
+            self.node_principled_bsdf.inputs[inputName],
+            grid_row_diff=1,
+        )
+
+    # --------------------------------------------------------------------
+    # Get Environment wrapper.
+
+    def node_environment_get(self, inputName):
+        if not self.use_nodes or self.node_principled_bsdf is None:
+            return None
+        return ShaderEnvironmentTextureWrapper(
+            self, self.node_principled_bsdf,
+            self.node_principled_bsdf.inputs[inputName],
+            grid_row_diff=1,
+        )
+
+    # --------------------------------------------------------------------
+    # Diffuse Texture.
+
+    def diffuse_texture_get(self):
+        return self.node_texture_get("Diffuse")
+
+    diffuse_texture = property(diffuse_texture_get)
+
+    # --------------------------------------------------------------------
+    # Light Map.
+
+    def lightmap_texture_get(self):
+        return self.node_texture_get("Lightmap")
+
+    lightmap_texture = property(lightmap_texture_get)
+
+    # --------------------------------------------------------------------
+    # Specular.
+
+    def specular_texture_get(self):
+        return self.node_texture_get("Specular")
+
+    specular_texture = property(specular_texture_get)
+
+    # --------------------------------------------------------------------
+    # Emission texture.
+
+    def emission_texture_get(self):
+        return self.node_texture_get("Emission")
+
+    emission_texture = property(emission_texture_get)
+
+    # --------------------------------------------------------------------
+    # Normal map.
+
+    def normalmap_texture_get(self):
+        return self.node_texture_get("Bump Map")
+
+    normalmap_texture = property(normalmap_texture_get)
+
+    # --------------------------------------------------------------------
+    # Normal Mask.
+
+    def normal_mask_texture_get(self):
+        return self.node_texture_get("Bump Mask")
+
+    normal_mask_texture = property(normal_mask_texture_get)
+
+    # --------------------------------------------------------------------
+    # Micro Bump 1.
+
+    def microbump1_texture_get(self):
+        return self.node_texture_get("MicroBump 1")
+
+    microbump1_texture = property(microbump1_texture_get)
+
+    # --------------------------------------------------------------------
+    # Micro Bump 2.
+
+    def microbump2_texture_get(self):
+        return self.node_texture_get("MicroBump 2")
+
+    microbump2_texture = property(microbump2_texture_get)
+
+    # --------------------------------------------------------------------
+    # Environment
+
+    def environment_texture_get(self):
+        return self.node_environment_get("Environment")
+
+    environment_texture = property(environment_texture_get)
+
+
+class ShaderEnvironmentTextureWrapper():
+    """
+    Generic 'environment texture'-like wrapper, handling image node
+    """
+
+    # Note: this class assumes we are using nodes, otherwise it should never be used...
+
+    NODES_LIST = (
+        "node_dst",
+        "socket_dst",
+
+        "_node_image",
+        "_node_mapping",
+    )
+
+    __slots__ = (
+        "owner_shader",
+        "is_readonly",
+        "grid_row_diff",
+        "use_alpha",
+        "colorspace_is_data",
+        "colorspace_name",
+        *NODES_LIST,
+    )
+
+    def __new__(cls, owner_shader: node_shader_utils.ShaderWrapper, node_dst, socket_dst, *_args, **_kwargs):
+        instance = owner_shader._textures.get((node_dst, socket_dst), None)
+        if instance is not None:
+            return instance
+        instance = super(ShaderEnvironmentTextureWrapper, cls).__new__(cls)
+        owner_shader._textures[(node_dst, socket_dst)] = instance
+        return instance
+
+    def __init__(self, owner_shader: node_shader_utils.ShaderWrapper, node_dst, socket_dst, grid_row_diff=0,
+                 use_alpha=False, colorspace_is_data=..., colorspace_name=...):
+        self.owner_shader = owner_shader
+        self.is_readonly = owner_shader.is_readonly
+        self.node_dst = node_dst
+        self.socket_dst = socket_dst
+        self.grid_row_diff = grid_row_diff
+        self.use_alpha = use_alpha
+        self.colorspace_is_data = colorspace_is_data
+        self.colorspace_name = colorspace_name
+
+        self._node_image = ...
+        self._node_mapping = ...
+
+        # tree = node_dst.id_data
+        # nodes = tree.nodes
+        # links = tree.links
+
+        if socket_dst.is_linked:
+            from_node = socket_dst.links[0].from_node
+            if from_node.bl_idname == 'ShaderNodeTexEnvironment':
+                self._node_image = from_node
+
+        if self.node_image is not None:
+            socket_dst = self.node_image.inputs["Vector"]
+            if socket_dst.is_linked:
+                from_node = socket_dst.links[0].from_node
+                if from_node.bl_idname == 'ShaderNodeMapping':
+                    self._node_mapping = from_node
+
+    def copy_from(self, tex):
+        # Avoid generating any node in source texture.
+        is_readonly_back = tex.is_readonly
+        tex.is_readonly = True
+
+        if tex.node_image is not None:
+            self.image = tex.image
+            self.projection = tex.projection
+            self.texcoords = tex.texcoords
+            self.copy_mapping_from(tex)
+
+        tex.is_readonly = is_readonly_back
+
+    def copy_mapping_from(self, tex):
+        # Avoid generating any node in source texture.
+        is_readonly_back = tex.is_readonly
+        tex.is_readonly = True
+
+        if tex.node_mapping is None:  # Used to actually remove mapping node.
+            if self.has_mapping_node():
+                # We assume node_image can never be None in that case...
+                # Find potential existing link into image's Vector input.
+                socket_dst = socket_src = None
+                if self.node_mapping.inputs["Vector"].is_linked:
+                    socket_dst = self.node_image.inputs["Vector"]
+                    socket_src = self.node_mapping.inputs["Vector"].links[0].from_socket
+
+                tree = self.owner_shader.material.node_tree
+                tree.nodes.remove(self.node_mapping)
+                self._node_mapping = None
+
+                # If previously existing, re-link texcoords -> image
+                if socket_src is not None:
+                    tree.links.new(socket_src, socket_dst)
+        elif self.node_mapping is not None:
+            self.translation = tex.translation
+            self.rotation = tex.rotation
+            self.scale = tex.scale
+
+        tex.is_readonly = is_readonly_back
+
+    # --------------------------------------------------------------------
+    # Image.
+
+    def node_image_get(self):
+        if self._node_image is ...:
+            # Running only once, trying to find a valid image node.
+            if self.socket_dst.is_linked:
+                node_image = self.socket_dst.links[0].from_node
+                if node_image.bl_idname == 'ShaderNodeTexImage':
+                    self._node_image = node_image
+                    self.owner_shader._grid_to_location(0, 0, ref_node=node_image)
+            if self._node_image is ...:
+                self._node_image = None
+        if self._node_image is None and not self.is_readonly:
+            tree = self.owner_shader.material.node_tree
+
+            node_image = tree.nodes.new(type='ShaderNodeTexImage')
+            self.owner_shader._grid_to_location(-1, 0 + self.grid_row_diff, dst_node=node_image, ref_node=self.node_dst)
+
+            tree.links.new(node_image.outputs["Alpha" if self.use_alpha else "Color"], self.socket_dst)
+
+            self._node_image = node_image
+        return self._node_image
+
+    node_image = property(node_image_get)
+
+    def image_get(self):
+        return self.node_image.image if self.node_image is not None else None
+
+    @node_shader_utils._set_check
+    def image_set(self, image):
+        if self.colorspace_is_data is not ...:
+            if image.colorspace_settings.is_data != self.colorspace_is_data and image.users >= 1:
+                image = image.copy()
+            image.colorspace_settings.is_data = self.colorspace_is_data
+        if self.colorspace_name is not ...:
+            if image.colorspace_settings.is_data != self.colorspace_is_data and image.users >= 1:
+                image = image.copy()
+            image.colorspace_settings.name = self.colorspace_name
+        self.node_image.image = image
+
+    image = property(image_get, image_set)
+
+    def projection_get(self):
+        return self.node_image.projection if self.node_image is not None else 'EQUIRECTANGULAR'
+
+    @node_shader_utils._set_check
+    def projection_set(self, projection):
+        self.node_image.projection = projection
+
+    projection = property(projection_get, projection_set)
+
+    def texcoords_get(self):
+        if self.node_image is not None:
+            socket = (self.node_mapping if self.has_mapping_node() else self.node_image).inputs["Vector"]
+            if socket.is_linked:
+                return socket.links[0].from_socket.name
+        return 'UV'
+
+    @node_shader_utils._set_check
+    def texcoords_set(self, texcoords):
+        # Image texture node already defaults to UVs, no extra node needed.
+        # ONLY in case we do not have any texcoords mapping!!!
+        if texcoords == 'UV' and not self.has_mapping_node():
+            return
+        tree = self.node_image.id_data
+        links = tree.links
+        node_dst = self.node_mapping if self.has_mapping_node() else self.node_image
+        socket_src = self.owner_shader.node_texcoords.outputs[texcoords]
+        links.new(socket_src, node_dst.inputs["Vector"])
+
+    texcoords = property(texcoords_get, texcoords_set)
+
+    # --------------------------------------------------------------------
+    # Mapping.
+
+    def has_mapping_node(self):
+        return self._node_mapping not in {None, ...}
+
+    def node_mapping_get(self):
+        if self._node_mapping is ...:
+            # Running only once, trying to find a valid mapping node.
+            if self.node_image is None:
+                return None
+            if self.node_image.inputs["Vector"].is_linked:
+                node_mapping = self.node_image.inputs["Vector"].links[0].from_node
+                if node_mapping.bl_idname == 'ShaderNodeMapping':
+                    self._node_mapping = node_mapping
+                    self.owner_shader._grid_to_location(0, 0 + self.grid_row_diff, ref_node=node_mapping)
+            if self._node_mapping is ...:
+                self._node_mapping = None
+        if self._node_mapping is None and not self.is_readonly:
+            # Find potential existing link into image's Vector input.
+            socket_dst = self.node_image.inputs["Vector"]
+            # If not already existing, we need to create texcoords -> mapping link (from UV).
+            socket_src = (
+                socket_dst.links[0].from_socket if socket_dst.is_linked
+                else self.owner_shader.node_texcoords.outputs['UV']
+            )
+
+            tree = self.owner_shader.material.node_tree
+            node_mapping = tree.nodes.new(type='ShaderNodeMapping')
+            node_mapping.vector_type = 'TEXTURE'
+            self.owner_shader._grid_to_location(-1, 0, dst_node=node_mapping, ref_node=self.node_image)
+
+            # Link mapping -> image node.
+            tree.links.new(node_mapping.outputs["Vector"], socket_dst)
+            # Link texcoords -> mapping.
+            tree.links.new(socket_src, node_mapping.inputs["Vector"])
+
+            self._node_mapping = node_mapping
+        return self._node_mapping
+
+    node_mapping = property(node_mapping_get)
+
+    def translation_get(self):
+        if self.node_mapping is None:
+            return Vector((0.0, 0.0, 0.0))
+        return self.node_mapping.inputs['Location'].default_value
+
+    @node_shader_utils._set_check
+    def translation_set(self, translation):
+        self.node_mapping.inputs['Location'].default_value = translation
+
+    translation = property(translation_get, translation_set)
+
+    def rotation_get(self):
+        if self.node_mapping is None:
+            return Vector((0.0, 0.0, 0.0))
+        return self.node_mapping.inputs['Rotation'].default_value
+
+    @node_shader_utils._set_check
+    def rotation_set(self, rotation):
+        self.node_mapping.inputs['Rotation'].default_value = rotation
+
+    rotation = property(rotation_get, rotation_set)
+
+    def scale_get(self):
+        if self.node_mapping is None:
+            return Vector((1.0, 1.0, 1.0))
+        return self.node_mapping.inputs['Scale'].default_value
+
+    @node_shader_utils._set_check
+    def scale_set(self, scale):
+        self.node_mapping.inputs['Scale'].default_value = scale
+
+    scale = property(scale_get, scale_set)

xnalara_io_Tools/read_ascii_xps.py

···
+import io
+import ntpath
+
+from mathutils import Vector
+
+from . import ascii_ops, xps_const, xps_types
+
+
+def readUvVert(file):
+    line = ascii_ops.readline(file)
+    values = ascii_ops.splitValues(line)
+    x = (ascii_ops.getFloat(values[0]))  # X pos
+    y = (ascii_ops.getFloat(values[1]))  # Y pos
+    coords = [x, y]
+    return coords
+
+
+def readXYZ(file):
+    line = ascii_ops.readline(file)
+    values = ascii_ops.splitValues(line)
+
+    x = (ascii_ops.getFloat(values[0]))  # X pos
+    y = (ascii_ops.getFloat(values[1]))  # Y pos
+    z = (ascii_ops.getFloat(values[2]))  # Z pos
+    coords = [x, y, z]
+    return coords
+
+
+def fillArray(array, minLen, value):
+    # Complete the array with selected value
+    filled = array + [value] * (minLen - len(array))
+    return filled
+
+
+def read4Float(file):
+    line = ascii_ops.readline(file)
+    values = ascii_ops.splitValues(line)
+    values = fillArray(values, 4, 0)
+    x = (ascii_ops.getFloat(values[0]))
+    y = (ascii_ops.getFloat(values[1]))
+    z = (ascii_ops.getFloat(values[2]))
+    w = (ascii_ops.getFloat(values[3]))
+    coords = [x, y, z, w]
+    return coords
+
+
+def readBoneWeight(file):
+    line = ascii_ops.readline(file)
+    values = ascii_ops.splitValues(line)
+    values = fillArray(values, 4, 0)
+    weights = [ascii_ops.getFloat(val) for val in values]
+    return weights
+
+
+def readBoneId(file):
+    line = ascii_ops.readline(file)
+    values = ascii_ops.splitValues(line)
+    values = fillArray(values, 4, 0)
+    ids = [ascii_ops.getInt(val) for val in values]
+    return ids
+
+
+def read4Int(file):
+    line = ascii_ops.readline(file)
+    values = ascii_ops.splitValues(line)
+    values = fillArray(values, 4, 0)
+    r = ascii_ops.getInt(values[0])
+    g = ascii_ops.getInt(values[1])
+    b = ascii_ops.getInt(values[2])
+    a = ascii_ops.getInt(values[3])
+    vertexColor = [r, g, b, a]
+    return vertexColor
+
+
+def readTriIdxs(file):
+    line = ascii_ops.readline(file)
+    values = ascii_ops.splitValues(line)
+    face1 = ascii_ops.getInt(values[0])
+    face2 = ascii_ops.getInt(values[1])
+    face3 = ascii_ops.getInt(values[2])
+    faceLoop = [face1, face2, face3]
+    return faceLoop
+
+
+def readBones(file):
+    bones = []
+    # Bone Count
+    boneCount = ascii_ops.readInt(file)
+    for boneId in range(boneCount):
+        boneName = ascii_ops.readString(file)
+        parentId = ascii_ops.readInt(file)
+        coords = readXYZ(file)
+
+        xpsBone = xps_types.XpsBone(boneId, boneName, coords, parentId)
+        bones.append(xpsBone)
+    return bones
+
+
+def readMeshes(file, hasBones):
+    meshes = []
+    meshCount = ascii_ops.readInt(file)
+
+    for meshId in range(meshCount):
+        # Name
+        meshName = ascii_ops.readString(file)
+        if not meshName:
+            meshName = 'xxx'
+        # print('Mesh Name:', meshName)
+        # uv Count
+        uvLayerCount = ascii_ops.readInt(file)
+        # Textures
+        textures = []
+        textureCount = ascii_ops.readInt(file)
+        for texId in range(textureCount):
+            textureFile = ntpath.basename(ascii_ops.readString(file))
+            # print('Texture file', textureFile)
+            uvLayerId = ascii_ops.readInt(file)
+
+            xpsTexture = xps_types.XpsTexture(texId, textureFile, uvLayerId)
+            textures.append(xpsTexture)
+
+        # Vertices
+        vertex = []
+        vertexCount = ascii_ops.readInt(file)
+        for vertexId in range(vertexCount):
+            coord = readXYZ(file)
+            normal = readXYZ(file)
+            vertexColor = read4Int(file)
+
+            uvs = []
+            for uvLayerId in range(uvLayerCount):
+                uvVert = readUvVert(file)
+                uvs.append(uvVert)
+                # if ????
+                # tangent????
+                # tangent = read4float(file)
+
+            boneWeights = []
+            if hasBones:
+                # if cero bones dont have weights to read
+                boneIdx = readBoneId(file)
+                boneWeight = readBoneWeight(file)
+
+                for idx in range(len(boneIdx)):
+                    boneWeights.append(
+                        xps_types.BoneWeight(boneIdx[idx], boneWeight[idx]))
+            xpsVertex = xps_types.XpsVertex(
+                vertexId, coord, normal, vertexColor, uvs, boneWeights)
+            vertex.append(xpsVertex)
+
+        # Faces
+        faces = []
+        triCount = ascii_ops.readInt(file)
+        for i in range(triCount):
+            triIdxs = readTriIdxs(file)
+            faces.append(triIdxs)
+        xpsMesh = xps_types.XpsMesh(
+            meshName, textures, vertex, faces, uvLayerCount)
+        meshes.append(xpsMesh)
+    return meshes
+
+
+def readPoseFile(file):
+    return file.read()
+
+
+def poseData(string):
+    poseData = {}
+    poseList = string.split('\n')
+    for bonePose in poseList:
+        if bonePose:
+            pose = bonePose.split(':')
+
+            boneName = pose[0]
+            dataList = fillArray(pose[1].split(), 9, 1)
+            rotDelta = Vector((
+                ascii_ops.getFloat(dataList[0]),
+                ascii_ops.getFloat(dataList[1]),
+                ascii_ops.getFloat(dataList[2])))
+            coordDelta = Vector((
+                ascii_ops.getFloat(dataList[3]),
+                ascii_ops.getFloat(dataList[4]),
+                ascii_ops.getFloat(dataList[5])))
+            scale = Vector((
+                ascii_ops.getFloat(dataList[6]),
+                ascii_ops.getFloat(dataList[7]),
+                ascii_ops.getFloat(dataList[8])))
+
+            bonePose = xps_types.XpsBonePose(
+                boneName, coordDelta, rotDelta, scale)
+            poseData[boneName] = bonePose
+    return poseData
+
+
+def boneDictData(string):
+    boneDictRename = {}
+    boneDictRestore = {}
+    poseList = string.split('\n')
+    for bonePose in poseList:
+        if bonePose:
+            pose = bonePose.split(';')
+            if len(pose) == 2:
+                oldName, newName = pose
+                boneDictRename[oldName] = newName
+                boneDictRestore[newName] = oldName
+    return boneDictRename, boneDictRestore
+
+
+def readIoStream(filename):
+    with open(filename, "r", encoding=xps_const.ENCODING_READ) as a_file:
+        ioStream = io.StringIO(a_file.read())
+    return ioStream
+
+
+def readXpsModel(filename):
+    ioStream = readIoStream(filename)
+    # print('Reading Header')
+    # xpsHeader = readHeader(ioStream)
+    print('Reading Bones')
+    bones = readBones(ioStream)
+    hasBones = bool(bones)
+    print('Reading Meshes')
+    meshes = readMeshes(ioStream, hasBones)
+    xpsModelData = xps_types.XpsData(bones=bones, meshes=meshes)
+    return xpsModelData
+
+
+def readXpsPose(filename):
+    ioStream = readIoStream(filename)
+    # print('Import Pose')
+    poseString = readPoseFile(ioStream)
+    bonesPose = poseData(poseString)
+    return bonesPose
+
+
+def readBoneDict(filename):
+    ioStream = readIoStream(filename)
+    boneDictString = readPoseFile(ioStream)
+    boneDictRename, boneDictRestore = boneDictData(boneDictString)
+    return boneDictRename, boneDictRestore
+
+
+if __name__ == "__main__":
+    readModelfilename = r'G:\3DModeling\XNALara\XNALara_XPS\data\TESTING2\Tekken\Tekken - Lili Bride\generic_item.mesh.ascii'
+    readPosefilename = r'G:\3DModeling\XNALara\XNALara_XPS\data\TESTING2\Tekken\Tekken - Lili Bride\Lili 1.pose'
+
+    print('----READ START----')
+    xpsData = readXpsModel(readModelfilename)
+    xpsData = readXpsPose(readPosefilename)
+    print('----READ END----')

xnalara_io_Tools/read_bin_xps.py

···
+import io
+import ntpath
+
+from . import bin_ops
+from . import read_ascii_xps
+from . import xps_const
+from . import xps_types
+
+
+def flagName(flag):
+    flagList = {
+        0: xps_const.BACK_FACE_CULLING,
+        1: xps_const.ALWAYS_FORCE_CULLING,
+        2: xps_const.MODEL_CAST_SHADOWS,
+        3: xps_const.TANGENT_SPACE_RED,
+        4: xps_const.TANGENT_SPACE_GREEN,
+        5: xps_const.TANGENT_SPACE_BLUE,
+        6: xps_const.GLOSS,
+        7: xps_const.HAS_BONE_DIRECTIONS,
+    }
+    return flagList.get(flag, flag)
+
+
+def flagsDefault():
+    flags = {
+        xps_const.BACK_FACE_CULLING: False,
+        xps_const.ALWAYS_FORCE_CULLING: False,
+        xps_const.MODEL_CAST_SHADOWS: True,
+        xps_const.TANGENT_SPACE_RED: 0,  # Straight X channel
+        xps_const.TANGENT_SPACE_GREEN: 1,  # Invert Y channel
+        xps_const.TANGENT_SPACE_BLUE: 0,  # Straight Z channel
+        xps_const.GLOSS: 10,
+        xps_const.HAS_BONE_DIRECTIONS: False,
+    }
+    return flags
+
+
+def flagValue(flag, value):
+    # Flags
+    # 00: Backface culling
+    # 01: Always force culling
+    # 02: Model cast shadows
+    # 06: Save current bump specular gloss
+
+    if flag in (0, 1, 2, 6, 7):
+        return bool(value)
+    # Flags
+    # 03: X space
+    # 04: Y space
+    # 05: Z space
+    elif flag in (3, 4, 5):
+        return (value % 2)
+    else:
+        return value
+
+
+def intToCoords(flag):
+    flagValue = {
+        0: '+',
+        1: '-',
+    }
+    return flagValue.get(flag, 'Uk')
+
+
+def printNormalMapSwizzel(tangentSpaceRed, tangentSpaceGreen, tangentSpaceBlue):
+    # Default XPS NormalMapTangentSpace == 0 1 0 == X+ Y- Z+
+    print('Tangent Space Normal Map Swizzel Coordinates:')
+    print('X{} Y{} Z{}'.format(intToCoords(tangentSpaceRed), intToCoords(tangentSpaceGreen), intToCoords(tangentSpaceBlue)))
+    print('')
+
+
+def readFilesString(file):
+    lengthByte2 = 0
+
+    lengthByte1 = bin_ops.readByte(file)
+
+    if (lengthByte1 >= xps_const.LIMIT):
+        lengthByte2 = bin_ops.readByte(file)
+    length = (lengthByte1 % xps_const.LIMIT) + (lengthByte2 * xps_const.LIMIT)
+
+    string = bin_ops.readString(file, length)
+    return string
+
+
+def readVertexColor(file):
+    r = bin_ops.readByte(file)
+    g = bin_ops.readByte(file)
+    b = bin_ops.readByte(file)
+    a = bin_ops.readByte(file)
+    vertexColor = [r, g, b, a]
+    return vertexColor
+
+
+def readUvVert(file):
+    x = bin_ops.readSingle(file)  # X pos
+    y = bin_ops.readSingle(file)  # Y pos
+    coords = [x, y]
+    return coords
+
+
+def readXYZ(file):
+    x = bin_ops.readSingle(file)  # X pos
+    y = bin_ops.readSingle(file)  # Y pos
+    z = bin_ops.readSingle(file)  # Z pos
+    coords = [x, y, z]
+    return coords
+
+
+def read4Float(file):
+    x = bin_ops.readSingle(file)
+    y = bin_ops.readSingle(file)
+    z = bin_ops.readSingle(file)
+    w = bin_ops.readSingle(file)
+    coords = [x, y, z, w]
+    return coords
+
+
+def read4Int16(file):
+    r = bin_ops.readInt16(file)
+    g = bin_ops.readInt16(file)
+    b = bin_ops.readInt16(file)
+    a = bin_ops.readInt16(file)
+    vertexColor = [r, g, b, a]
+    return vertexColor
+
+
+def readTriIdxs(file):
+    face1 = bin_ops.readUInt32(file)
+    face2 = bin_ops.readUInt32(file)
+    face3 = bin_ops.readUInt32(file)
+    faceLoop = [face1, face2, face3]
+    return faceLoop
+
+
+def readHeader(file):
+    xpsHeader = xps_types.XpsHeader()
+    flags = flagsDefault()
+
+    # MagicNumber
+    magic_number = bin_ops.readUInt32(file)
+    # XPS Version
+    version_mayor = bin_ops.readUInt16(file)
+    version_minor = bin_ops.readUInt16(file)
+    # XNAaral Name
+    xna_aral = readFilesString(file)
+    # Settings Length
+    settingsLen = bin_ops.readUInt32(file)
+    # MachineName
+    machineName = readFilesString(file)
+    # UserName
+    userName = readFilesString(file)
+    # File-->File
+    filesString = readFilesString(file)
+    xpsPoseData = None
+
+    # print('*'*80)
+    hasTangent = bin_ops.hasTangentVersion(version_mayor, version_minor)
+    if (hasTangent):
+        # print('OLD Format')
+        settingsStream = io.BytesIO(file.read(settingsLen * 4))
+    else:
+        # print('NEW Format')
+        valuesRead = 0
+        hash = bin_ops.readUInt32(file)
+        valuesRead += 1 * 4
+        items = bin_ops.readUInt32(file)
+        valuesRead += 1 * 4
+        # print('hash', hash)
+        # print('items', items)
+        for i in range(items):
+            # print('valuesRead', valuesRead)
+            optType = bin_ops.readUInt32(file)
+            valuesRead += 1 * 4
+            optcount = bin_ops.readUInt32(file)
+            valuesRead += 1 * 4
+            optInfo = bin_ops.readUInt32(file)
+            valuesRead += 1 * 4
+
+            # print('------')
+            # print('count',i)
+            # print('optType',optType)
+            # print('optcount',optcount)
+            # print('optInfo',optInfo)
+
+            if (optType == 0):
+                # print('Read None')
+                readNone(file, optcount)
+                valuesRead += optcount * 2
+            elif (optType == 1):
+                # print('Read Pose')
+                xpsPoseData = readDefaultPose(file, optcount, optInfo)
+                readCount = bin_ops.roundToMultiple(optcount, xps_const.ROUND_MULTIPLE)
+                valuesRead += readCount
+            elif (optType == 2):
+                # print('Read Flags')
+                flags = readFlags(file, optcount)
+                valuesRead += optcount * 2 * 4
+            else:
+                # print('Read Waste')
+                loopStart = valuesRead // 4
+                loopFinish = settingsLen
+                # print (loopStart, loopFinish)
+                for j in range(loopStart, loopFinish):
+                    # print('waste',j - loopStart)
+                    waste = bin_ops.readUInt32(file)
+
+    xpsHeader.magic_number = magic_number
+    xpsHeader.version_mayor = version_mayor
+    xpsHeader.version_minor = version_minor
+    xpsHeader.xna_aral = xna_aral
+    xpsHeader.settingsLen = settingsLen
+    xpsHeader.machine = machineName
+    xpsHeader.user = userName
+    xpsHeader.files = filesString
+    xpsHeader.pose = xpsPoseData
+    xpsHeader.flags = flags
+    return xpsHeader
+
+
+def findHeader(file):
+    header = None
+
+    # Check for MAGIC_NUMBER
+    number = bin_ops.readUInt32(file)
+    file.seek(0)
+
+    if (number == xps_const.MAGIC_NUMBER):
+        print('Header Found')
+        header = readHeader(file)
+
+    # logHeader(header)
+    return header
+
+
+def readNone(file, optcount):
+    for i in range(optcount):
+        waste = bin_ops.readUInt32(file)
+
+
+def readFlags(file, optcount):
+    flags = {}
+    for i in range(optcount):
+        flag = bin_ops.readUInt32(file)
+        value = bin_ops.readUInt32(file)
+        flags[flagName(flag)] = flagValue(flag, value)
+    printNormalMapSwizzel(flags[flagName(3)], flags[flagName(4)], flags[flagName(5)])
+    return flags
+
+
+def logHeader(xpsHeader):
+    print("MAGIX:", xpsHeader.magic_number)
+    print('VER MAYOR:', xpsHeader.version_mayor)
+    print('VER MINOR:', xpsHeader.version_minor)
+    print('NAME:', xpsHeader.xna_aral)
+    print('SETTINGS LEN:', xpsHeader.settingsLen)
+    print('MACHINE:', xpsHeader.machine)
+    print('USR:', xpsHeader.user)
+    print('FILES:', xpsHeader.files)
+    print('SETTING:', xpsHeader.settings)
+    print('DEFAULT POSE:', xpsHeader.pose)
+
+
+def readBones(file, header):
+    bones = []
+    # Bone Count
+    boneCount = bin_ops.readUInt32(file)
+
+    for boneId in range(boneCount):
+        boneName = readFilesString(file)
+        parentId = bin_ops.readInt16(file)
+        coords = readXYZ(file)
+
+        xpsBone = xps_types.XpsBone(boneId, boneName, coords, parentId)
+        bones.append(xpsBone)
+    return bones
+
+
+def readMeshes(file, xpsHeader, hasBones):
+    meshes = []
+    meshCount = bin_ops.readUInt32(file)
+
+    hasHeader = bool(xpsHeader)
+
+    verMayor = xpsHeader.version_mayor if hasHeader else 0
+    verMinor = xpsHeader.version_minor if hasHeader else 0
+
+    hasTangent = bin_ops.hasTangentVersion(verMayor, verMinor, hasHeader)
+    hasVariableWeights = bin_ops.hasVariableWeights(verMayor, verMinor, hasHeader)
+
+    for meshId in range(meshCount):
+        # Name
+        meshName = readFilesString(file)
+        if not meshName:
+            meshName = 'unnamed'
+        # print('Mesh Name:', meshName)
+        # uv Count
+        uvLayerCount = bin_ops.readUInt32(file)
+        # Textures
+        textures = []
+        textureCount = bin_ops.readUInt32(file)
+        for texId in range(textureCount):
+            textureFile = ntpath.basename(readFilesString(file))
+            # print('Texture file', textureFile)
+            uvLayerId = bin_ops.readUInt32(file)
+
+            xpsTexture = xps_types.XpsTexture(texId, textureFile, uvLayerId)
+            textures.append(xpsTexture)
+
+        # Vertices
+        vertex = []
+        vertexCount = bin_ops.readUInt32(file)
+
+        for vertexId in range(vertexCount):
+            coord = readXYZ(file)
+            normal = readXYZ(file)
+            vertexColor = readVertexColor(file)
+
+            uvs = []
+            for uvLayerId in range(uvLayerCount):
+                uvVert = readUvVert(file)
+                uvs.append(uvVert)
+                if hasTangent:
+                    tangent = read4Float(file)
+
+            boneWeights = []
+            if hasBones:
+                # if cero bones dont have weights to read
+
+                boneIdx = []
+                boneWeight = []
+                if hasVariableWeights:
+                    weightsCount = bin_ops.readInt16(file)
+                else:
+                    weightsCount = 4
+
+                for x in range(weightsCount):
+                    boneIdx.append(bin_ops.readInt16(file))
+                for x in range(weightsCount):
+                    boneWeight.append(bin_ops.readSingle(file))
+
+                for idx in range(len(boneIdx)):
+                    boneWeights.append(
+                        xps_types.BoneWeight(boneIdx[idx], boneWeight[idx]))
+            xpsVertex = xps_types.XpsVertex(
+                vertexId, coord, normal, vertexColor, uvs, boneWeights)
+            vertex.append(xpsVertex)
+
+        # Faces
+        faces = []
+        triCount = bin_ops.readUInt32(file)
+        for i in range(triCount):
+            triIdxs = readTriIdxs(file)
+            faces.append(triIdxs)
+        xpsMesh = xps_types.XpsMesh(
+            meshName, textures, vertex, faces, uvLayerCount)
+        meshes.append(xpsMesh)
+    return meshes
+
+
+def readIoStream(filename):
+    with open(filename, "rb") as a_file:
+        ioStream = io.BytesIO(a_file.read())
+    return ioStream
+
+
+def readXpsModel(filename):
+    print('File:', filename)
+
+    ioStream = readIoStream(filename)
+    print('Reading Header')
+    xpsHeader = findHeader(ioStream)
+    print('Reading Bones')
+    bones = readBones(ioStream, xpsHeader)
+    hasBones = bool(bones)
+    print('Read', len(bones), 'Bones')
+    print('Reading Meshes')
+    meshes = readMeshes(ioStream, xpsHeader, hasBones)
+    print('Read', len(meshes), 'Meshes')
+
+    xpsData = xps_types.XpsData(xpsHeader, bones, meshes)
+    return xpsData
+
+
+def readDefaultPose(file, poseLenghtUnround, poseBones):
+    # print('Import Pose')
+    poseBytes = b''
+    if poseLenghtUnround:
+        for i in range(0, poseBones):
+            poseBytes += file.readline()
+
+    poseLenght = bin_ops.roundToMultiple(
+        poseLenghtUnround, xps_const.ROUND_MULTIPLE)
+    emptyBytes = poseLenght - poseLenghtUnround
+    file.read(emptyBytes)
+    poseString = bin_ops.decodeBytes(poseBytes)
+    bonesPose = read_ascii_xps.poseData(poseString)
+    return bonesPose
+
+
+if __name__ == "__main__":
+    readfilename = r'G:\3DModeling\XNALara\XNALara_XPS\Young Samus\Generic_Item.mesh'
+
+    print('----READ START----')
+    xpsData = readXpsModel(readfilename)
+    print('----READ END----')

xnalara_io_Tools/timing.py

···
+import time
+
+import io
+import cProfile
+import pstats
+
+
+def profile(fnc):
+    """Create decorator function that uses cProfile to profile a function."""
+    def inner(*args, **kwargs):
+
+        pr = cProfile.Profile()
+        pr.enable()
+        retval = fnc(*args, **kwargs)
+        pr.disable()
+        s = io.StringIO()
+        sortby = 'cumulative'
+        ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
+        ps.print_stats()
+        print(s.getvalue())
+        return retval
+
+    return inner
+
+
+def timing(f):
+    def wrap(*args):
+        time1 = time.time()
+        ret = f(*args)
+        time2 = time.time()
+        print('%s function took %0.3f ms' % (f.__name__,
+                                             (time2 - time1) * 1000.0))
+        return ret
+    return wrap

xnalara_io_Tools/utilities/color_utilities.py

···
+import random
+
+
+def random_color_rgb() -> tuple[float, float, float]:
+    return (1 / random.randint(1, 255), 1 / random.randint(1, 255), 1 / random.randint(1, 255))

xnalara_io_Tools/utilities/mesh_utilities.py

···
+import bpy
+
+
+def create_split_normals(mesh_object: bpy.types.Object, normals: list[tuple[float, float, float]]):
+    mesh_data: bpy.types.Mesh = mesh_object.data
+    b_mesh_was_corrected = False
+
+    if (bpy.app.version[:2] in [(3, 6), (4, 0)]):
+        mesh_data.create_normals_split()
+        b_mesh_was_corrected = mesh_data.validate(clean_customdata=False)
+        mesh_data.update(calc_edges=True)
+        mesh_data.normals_split_custom_set_from_vertices(normals)
+        mesh_data.use_auto_smooth = True
+
+    else:
+        b_mesh_was_corrected = mesh_data.validate(clean_customdata=False)
+        mesh_data.update(calc_edges=True)
+        mesh_data.normals_split_custom_set_from_vertices(normals)
+
+    return b_mesh_was_corrected

xnalara_io_Tools/write_ascii_xps.py

···
+import io
+import operator
+
+from . import read_ascii_xps
+from . import xps_const
+from mathutils import Vector
+
+
+def writeBones(xpsSettings, bones):
+    bonesString = io.StringIO()
+    if bones:
+        bonesString.write('{:d} # bones\n'.format(len(bones)))
+
+        for bone in bones:
+            name = bone.name
+            parentId = bone.parentId
+            co = bone.co
+            if parentId is None:
+                parentId = -1
+            bonesString.write('{}\n'.format(name))
+            bonesString.write('{:d} # parent index\n'.format(parentId))
+            bonesString.write('{:.7G} {:.7G} {:.7G}\n'.format(*co))
+    bonesString.seek(0)
+    return bonesString
+
+
+def writeMeshes(xpsSettings, meshes):
+    meshesString = io.StringIO()
+    meshesString.write('{:d} # meshes\n'.format(len(meshes)))
+    sortedMeshes = sorted(meshes, key=operator.attrgetter('name'))
+
+    for mesh in sortedMeshes:
+        # Name
+        meshesString.write(mesh.name + '\n')
+        # uv Count
+        meshesString.write('{:d} # uv layers\n'.format(mesh.uvCount))
+        # Textures
+        meshesString.write('{:d} # textures\n'.format(len(mesh.textures)))
+        for texture in mesh.textures:
+            meshesString.write(texture.file + '\n')
+            meshesString.write(
+                '{:d} # uv layer index\n'.format(texture.uvLayer))
+
+        # Vertices
+        meshesString.write('{:d} # vertices\n'.format(len(mesh.vertices)))
+        for vertex in mesh.vertices:
+            meshesString.write(
+                '{:.7G} {:.7G} {:.7G} # Coords\n'.format(*vertex.co))
+            meshesString.write('{:.7G} {:.7G} {:.7G}\n'.format(*vertex.norm))
+            meshesString.write('{:d} {:d} {:d} {:d}\n'.format(*vertex.vColor))
+
+            for uv in vertex.uv:
+                meshesString.write('{:.7G} {:.7G}\n'.format(*uv))
+                # if ????
+                # tangent????
+                # meshesString.write(write4float(xxx))
+
+            length = len(vertex.boneWeights)
+            idFormatString = ' '.join(['{:d}', ] * length)
+            weightFormatString = ' '.join(['{:.7G}', ] * length)
+
+            # Sort first the biggest weights
+            boneWeights = sorted(
+                vertex.boneWeights,
+                key=lambda bw: bw.weight,
+                reverse=True)
+
+            meshesString.write(
+                (idFormatString + '\n').format(*[bw.id for bw in boneWeights]))
+            meshesString.write(
+                (weightFormatString + '\n').format(*[bw.weight for bw in boneWeights]))
+
+        # Faces
+        meshesString.write('{:d} # faces\n'.format(len(mesh.faces)))
+        for face in mesh.faces:
+            meshesString.write('{:d} {:d} {:d}\n'.format(*face))
+
+    meshesString.seek(0)
+    return meshesString
+
+
+def writePose(xpsData):
+    poseString = io.StringIO()
+    sortedPose = sorted(xpsData.items(), key=operator.itemgetter(0))
+
+    for boneData in sortedPose:
+        xpsBoneData = boneData[1]
+        boneName = xpsBoneData.boneName
+        rotDelta = roundRot(xpsBoneData.rotDelta)
+        coordDelta = roundTrans(xpsBoneData.coordDelta)
+        scale = roundScale(xpsBoneData.scale)
+
+        x1 = '{}: '.format(boneName)
+        x2 = '{:G} {:G} {:G} '.format(*rotDelta)
+        x3 = '{:G} {:G} {:G} '.format(*coordDelta)
+        x4 = '{:G} {:G} {:G} '.format(*scale)
+
+        poseString.write(x1)
+        poseString.write(x2)
+        poseString.write(x3)
+        poseString.write(x4)
+        poseString.write('\n')
+
+    poseString.seek(0)
+    return poseString
+
+
+def writeXpsPose(filename, xpsData):
+    ioStream = io.StringIO()
+    print('Export Pose')
+    ioStream.write(writePose(xpsData).read())
+    ioStream.seek(0)
+    writeIoStream(filename, ioStream)
+
+
+def roundRot(vector):
+    x = round(vector.x, 1) + 0
+    y = round(vector.y, 1) + 0
+    z = round(vector.z, 1) + 0
+    return Vector((x, y, z))
+
+
+def roundTrans(vector):
+    x = round(vector.x, 4) + 0
+    y = round(vector.y, 4) + 0
+    z = round(vector.z, 4) + 0
+    return Vector((x, y, z))
+
+
+def roundScale(vector):
+    x = round(vector.x, 3) + 0
+    y = round(vector.y, 3) + 0
+    z = round(vector.z, 3) + 0
+    return Vector((x, y, z))
+
+
+def writeIoStream(filename, ioStream):
+    with open(filename, "w", encoding=xps_const.ENCODING_WRITE) as a_file:
+        a_file.write(ioStream.read())
+
+
+def writeBoneDict(filename, boneDictList):
+    ioStream = io.StringIO()
+    ioStream.write(boneDictList)
+    ioStream.seek(0)
+    writeIoStream(filename, ioStream)
+
+
+def writeXpsModel(xpsSettings, filename, xpsData):
+    ioStream = io.StringIO()
+    print('Writing Bones')
+    ioStream.write(writeBones(xpsSettings, xpsData.bones).read())
+    print('Writing Meshes')
+    ioStream.write(writeMeshes(xpsSettings, xpsData.meshes).read())
+    ioStream.seek(0)
+    writeIoStream(filename, ioStream)
+
+
+if __name__ == "__main__":
+    readfilename = r'G:\3DModeling\XNALara\XNALara_XPS\data\TESTING\Alice Returns - Mods\Alice 001 Fetish Cat\generic_item2.mesh.ascii'
+    writefilename = r'G:\3DModeling\XNALara\XNALara_XPS\data\TESTING\Alice Returns - Mods\Alice 001 Fetish Cat\generic_item3.mesh.ascii'
+
+    # Simulate XPS Data
+    # from . import mock_xps_data
+    # xpsData = mock_xps_data.mockData()
+
+    # import XPS File
+    xpsData = read_ascii_xps.readXpsModel(readfilename)
+
+    print('----WRITE START----')
+    writeXpsModel(writefilename, xpsData)
+    print('----WRITE END----')

xnalara_io_Tools/write_bin_xps.py

···
+import io
+import operator
+
+from . import bin_ops
+from . import read_bin_xps
+from . import xps_const
+
+
+def writeFilesString(string):
+    byteString = bytearray()
+    length1 = 0
+
+    stringBin = bin_ops.writeString(string)
+    length = len(stringBin)
+    divQuot, divRem = divmod(length, xps_const.LIMIT)
+
+    if (length >= xps_const.LIMIT):
+        length1 += xps_const.LIMIT
+
+    # First Lenght Byte
+    length1 += divRem
+    byteString.append(length1)
+
+    if (divQuot):
+        # Second Lenght Byte
+        length2 = divQuot
+        byteString.append(length2)
+    byteString.extend(stringBin)
+    return byteString
+
+
+def writeVertexColor(co):
+    r = bin_ops.writeByte(co[0])
+    g = bin_ops.writeByte(co[1])
+    b = bin_ops.writeByte(co[2])
+    a = bin_ops.writeByte(co[3])
+    vertexColor = bytearray()
+    vertexColor.extend(r)
+    vertexColor.extend(g)
+    vertexColor.extend(b)
+    vertexColor.extend(a)
+    return vertexColor
+
+
+def writeUvVert(co):
+    x = bin_ops.writeSingle(co[0])  # X pos
+    y = bin_ops.writeSingle(co[1])  # Y pos
+    coords = bytearray()
+    coords.extend(x)
+    coords.extend(y)
+    return coords
+
+
+def writeXYZ(co):
+    x = bin_ops.writeSingle(co[0])  # X pos
+    y = bin_ops.writeSingle(co[1])  # Y pos
+    z = bin_ops.writeSingle(co[2])  # Z pos
+    coords = bytearray()
+    coords.extend(x)
+    coords.extend(y)
+    coords.extend(z)
+    return coords
+
+
+def write4Float(co):
+    x = bin_ops.writeSingle(co[0])  # X pos
+    y = bin_ops.writeSingle(co[1])  # Y pos
+    z = bin_ops.writeSingle(co[2])  # Z pos
+    w = bin_ops.writeSingle(co[3])  # W pos
+    coords = bytearray()
+    coords.extend(x)
+    coords.extend(y)
+    coords.extend(z)
+    coords.extend(w)
+    return coords
+
+
+def write4UInt16(co):
+    r = bin_ops.writeInt16(co[0])
+    g = bin_ops.writeInt16(co[1])
+    b = bin_ops.writeInt16(co[2])
+    a = bin_ops.writeInt16(co[3])
+    vertexColor = bytearray()
+    vertexColor.extend(r)
+    vertexColor.extend(g)
+    vertexColor.extend(b)
+    vertexColor.extend(a)
+    return vertexColor
+
+
+def writeTriIdxs(co):
+    face1 = bin_ops.writeUInt32(co[0])
+    face2 = bin_ops.writeUInt32(co[1])
+    face3 = bin_ops.writeUInt32(co[2])
+    faceLoop = bytearray()
+    faceLoop.extend(face1)
+    faceLoop.extend(face2)
+    faceLoop.extend(face3)
+    return faceLoop
+
+
+def logHeader(xpsHeader):
+    print("MAGIX:", xpsHeader.magic_number)
+    print('VER MAYOR:', xpsHeader.version_mayor)
+    print('VER MINOR:', xpsHeader.version_minor)
+    print('NAME:', xpsHeader.xna_aral)
+    print('SETTINGS LEN:', xpsHeader.settingsLen)
+    print('MACHINE:', xpsHeader.machine)
+    print('USR:', xpsHeader.user)
+    print('FILES:', xpsHeader.files)
+    print('SETTING:', xpsHeader.settings)
+    print('DEFAULT POSE:', xpsHeader.pose)
+
+
+def writeHeader(xpsSettings, header):
+    headerArray = bytearray()
+    if header:
+        # MagicNumber
+        headerArray.extend(bin_ops.writeUInt32(header.magic_number))
+        # XPS Model Version
+        headerArray.extend(bin_ops.writeUInt16(header.version_mayor))
+        headerArray.extend(bin_ops.writeUInt16(header.version_minor))
+        # XNAaral Name
+        headerArray.extend(writeFilesString(header.xna_aral))
+        # Settings Len (unit32*4)
+        headerArray.extend(bin_ops.writeUInt32(header.settingsLen))
+        # MachineName
+        headerArray.extend(writeFilesString(header.machine))
+        # UserName
+        headerArray.extend(writeFilesString(header.user))
+        # File-->File
+        headerArray.extend(writeFilesString(header.files))
+        # settings
+        headerArray.extend(header.settings)
+
+    return headerArray
+
+
+def writeBones(xpsSettings, bones):
+    bonesArray = bytearray()
+    if bones:
+        bonesArray.extend(bin_ops.writeUInt32(len(bones)))
+
+        for bone in bones:
+            name = bone.name
+            parentId = bone.parentId
+            co = bone.co
+            if parentId is None:
+                parentId = -1
+            bonesArray.extend(writeFilesString(name))
+            bonesArray.extend(bin_ops.writeInt16(parentId))
+            bonesArray.extend(writeXYZ(co))
+    return bonesArray
+
+
+def writeMeshes(xpsSettings, meshes):
+    meshCount = len(meshes)
+    meshesArray = bytearray(bin_ops.writeUInt32(meshCount))
+    sortedMeshes = sorted(meshes, key=operator.attrgetter('name'))
+
+    verMayor = xpsSettings.versionMayor
+    verMinor = xpsSettings.versionMinor
+    hasHeader = bin_ops.hasHeader(xpsSettings.format)
+
+    hasTangent = bin_ops.hasTangentVersion(verMayor, verMinor, hasHeader)
+    hasVariableWeights = bin_ops.hasVariableWeights(verMayor, verMinor, hasHeader)
+
+    for mesh in sortedMeshes:
+        # Name
+        meshesArray.extend(writeFilesString(mesh.name))
+        # uv Count
+        meshesArray.extend(bin_ops.writeUInt32(mesh.uvCount))
+        # Textures
+        meshesArray.extend(bin_ops.writeUInt32(len(mesh.textures)))
+        for texture in mesh.textures:
+            meshesArray.extend(writeFilesString(texture.file))
+            meshesArray.extend(bin_ops.writeUInt32(texture.uvLayer))
+
+        # Vertices
+        meshesArray.extend(bin_ops.writeUInt32(len(mesh.vertices)))
+        for vertex in mesh.vertices:
+            meshesArray.extend(writeXYZ(vertex.co))
+            meshesArray.extend(writeXYZ(vertex.norm))
+            meshesArray.extend(writeVertexColor(vertex.vColor))
+
+            for uv in vertex.uv:
+                meshesArray.extend(writeUvVert(uv))
+            if hasTangent:
+                meshesArray.extend(write4Float([1, 0, 0, 0]))
+
+            # Sort first the biggest weights
+            boneWeights = sorted(
+                vertex.boneWeights,
+                key=lambda bw: bw.weight,
+                reverse=True)
+
+            if hasVariableWeights:
+                weightCount = len(boneWeights)
+                meshesArray.extend(bin_ops.writeUInt16(weightCount))
+                [meshesArray.extend(bin_ops.writeUInt16(bw.id)) for bw in boneWeights]
+                [meshesArray.extend(bin_ops.writeSingle(bw.weight)) for bw in boneWeights]
+            else:
+                meshesArray.extend(write4UInt16([bw.id for bw in boneWeights]))
+                meshesArray.extend(write4Float([bw.weight for bw in boneWeights]))
+
+        # Faces
+        meshesArray.extend(bin_ops.writeUInt32(len(mesh.faces)))
+        for face in mesh.faces:
+            meshesArray.extend(writeTriIdxs(face))
+
+    return meshesArray
+
+
+def writeIoStream(filename, ioStream):
+    with open(filename, "wb") as a_file:
+        a_file.write(ioStream.read())
+
+
+def writeXpsModel(xpsSettings, filename, xpsData):
+    ioStream = io.BytesIO()
+    print('Writing Header')
+    ioStream.write(writeHeader(xpsSettings, xpsData.header))
+    print('Writing Bones')
+    ioStream.write(writeBones(xpsSettings, xpsData.bones))
+    print('Writing Meshes')
+    ioStream.write(writeMeshes(xpsSettings, xpsData.meshes))
+    ioStream.seek(0)
+
+    writeIoStream(filename, ioStream)
+
+
+if __name__ == "__main__":
+    readfilename1 = r'G:\3DModeling\XNALara\XNALara_XPS\data\TESTING5\Drake\RECB DRAKE Pack_By DamianHandy\DRAKE Sneaking Suitxxz\Generic_Item - XPS pose.mesh'
+    writefilename1 = r'G:\3DModeling\XNALara\XNALara_XPS\data\TESTING5\Drake\RECB DRAKE Pack_By DamianHandy\DRAKE Sneaking Suitxxz\Generic_Item - BLENDER pose.mesh'
+
+    # Simulate XPS Data
+    # from . import mock_xps_data
+    # xpsData = mock_xps_data.mockData()
+
+    # import XPS File
+    xpsData = read_bin_xps.readXpsModel(readfilename1)
+
+    print('----WRITE START----')
+    writeXpsModel(writefilename1, xpsData)
+    print('----WRITE END----')

xnalara_io_Tools/xnal_preferences.py

···
+import bpy
+
+from .modules.ALXAddonUpdater.ALXAddonUpdater.ALX_AddonUpdaterUI import \
+    update_settings_ui
+
+
+class XNAlaraMesh4X_AddonPreferences(bpy.types.AddonPreferences):
+
+    bl_idname = __package__
+
+    auto_check_update: bpy.props.BoolProperty(name="Auto-check for Update", description="If enabled, auto-check for updates using an interval", default=False)  # type:ignore
+
+    updater_interval_months: bpy.props.IntProperty(name='Months', description="Number of months between checking for updates", default=0, min=0)  # type:ignore
+    updater_interval_days: bpy.props.IntProperty(name='Days', description="Number of days between checking for updates", default=7, min=0, max=31)  # type:ignore
+    updater_interval_hours: bpy.props.IntProperty(name='Hours', description="Number of hours between checking for updates", default=0, min=0, max=23)  # type:ignore
+    updater_interval_minutes: bpy.props.IntProperty(name='Minutes', description="Number of minutes between checking for updates", default=0, min=0, max=59)  # type:ignore
+
+    def draw(self, context: bpy.types.Context):
+        layout = self.layout
+
+        update_settings_ui(context, layout)

xnalara_io_Tools/xps_const.py

···
+MAGIC_NUMBER = 323232
+XPS_VERSION_MAYOR = 3
+XPS_VERSION_MINOR = 15
+XNA_ARAL = 'XNAaraL'
+SETTINGS_LEN = 1080
+LIMIT = 128
+STRLEN = 275
+
+ROUND_MULTIPLE = 4
+
+ENCODING_READ = 'utf-8-sig'
+ENCODING_WRITE = 'utf-8'
+
+# Flags
+BACK_FACE_CULLING = 'backFaceCulling'
+ALWAYS_FORCE_CULLING = 'alwaysForceCulling'
+MODEL_CAST_SHADOWS = 'modelCastShadows'
+TANGENT_SPACE_RED = 'TangentSpaceRed'
+TANGENT_SPACE_GREEN = 'TangentSpaceGreen'
+TANGENT_SPACE_BLUE = 'TangentSpaceBlue'
+GLOSS = 'gloss'
+HAS_BONE_DIRECTIONS = 'hasBoneDirections'

xnalara_io_Tools/xps_material.py

···
+import math
+
+from . import ascii_ops
+from enum import Enum
+
+
+# All available texture types:
+class TextureType(Enum):
+    DIFFUSE = 'diffuse'                     # 1
+    LIGHT = 'lightmap'                      # 2
+    BUMP = 'bump'                           # 3
+    MASK = 'mask'                           # 4
+    BUMP1 = 'bump1'                         # 5
+    BUMP2 = 'bump2'                         # 6
+    SPECULAR = 'specular'                   # 7
+    ENVIRONMENT = 'environment'             # 8
+    EMISSION = 'emission'                   # 9
+
+
+class RenderType():
+
+    def __init__(self):
+        self.renderGroupNum = None
+        self.meshName = None
+        self.specularity = None
+        self.texRepeater1 = None
+        self.texRepeater2 = None
+        self.val4 = None
+
+
+class RenderGroup:
+
+    def __init__(self, renderType):
+        self.renderType = renderType
+        self.renderGroupNum = renderType.renderGroupNum
+        self.rgShadding = 'Yes'
+        self.rgAlpha = False
+        self.rgPosable = True
+        self.rgSpecular = 'Yes'
+        self.rgBump1Rep = True
+        self.rgBump2Rep = True
+        self.rgSpec1Rep = False
+        self.rgTexCount = 6
+        self.rgTexType = [
+            TextureType.DIFFUSE,
+            TextureType.MASK,
+            TextureType.MASK,
+            TextureType.MASK,
+            TextureType.MASK,
+            TextureType.MASK]
+
+        if self.renderGroupNum == 1:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = True
+            self.rgBump2Rep = True
+            self.rgTexCount = 6
+            self.rgTexType = [
+                TextureType.DIFFUSE,
+                TextureType.LIGHT,
+                TextureType.BUMP,
+                TextureType.MASK,
+                TextureType.BUMP1,
+                TextureType.BUMP2]
+        if self.renderGroupNum == 2:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 3
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.LIGHT, TextureType.BUMP]
+        if self.renderGroupNum == 3:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'No'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 2
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.LIGHT]
+        if self.renderGroupNum == 4:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 2
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.BUMP]
+        if self.renderGroupNum == 5:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'No'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 1
+            self.rgTexType = [TextureType.DIFFUSE]
+        if self.renderGroupNum == 6:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 2
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.BUMP]
+        if self.renderGroupNum == 7:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'No'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 1
+            self.rgTexType = [TextureType.DIFFUSE]
+        if self.renderGroupNum == 8:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 3
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.LIGHT, TextureType.BUMP]
+        if self.renderGroupNum == 9:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'No'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 2
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.LIGHT]
+        if self.renderGroupNum == 10:
+            self.rgShadding = False
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'No'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 1
+            self.rgTexType = [TextureType.DIFFUSE]
+        if self.renderGroupNum == 11:
+            self.rgShadding = 'Vertex'
+            self.rgAlpha = False
+            self.rgPosable = False
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 2
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.BUMP]
+        if self.renderGroupNum == 12:
+            self.rgShadding = 'Vertex'
+            self.rgAlpha = True
+            self.rgPosable = False
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 2
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.BUMP]
+        if self.renderGroupNum == 13:
+            self.rgShadding = False
+            self.rgAlpha = False
+            self.rgPosable = False
+            self.rgSpecular = 'No'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 1
+            self.rgTexType = [TextureType.DIFFUSE]
+        if self.renderGroupNum == 14:
+            self.rgShadding = False
+            self.rgAlpha = False
+            self.rgPosable = False
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 2
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.BUMP]
+        if self.renderGroupNum == 15:
+            self.rgShadding = False
+            self.rgAlpha = True
+            self.rgPosable = False
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 2
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.BUMP]
+        if self.renderGroupNum == 16:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = False
+            self.rgPosable = False
+            self.rgSpecular = 'No'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 1
+            self.rgTexType = [TextureType.DIFFUSE]
+        if self.renderGroupNum == 17:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = False
+            self.rgPosable = False
+            self.rgSpecular = 'No'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 2
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.LIGHT]
+        if self.renderGroupNum == 18:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = True
+            self.rgPosable = False
+            self.rgSpecular = 'No'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 1
+            self.rgTexType = [TextureType.DIFFUSE]
+        if self.renderGroupNum == 19:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = True
+            self.rgPosable = False
+            self.rgSpecular = 'No'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 2
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.LIGHT]
+        if self.renderGroupNum == 20:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = True
+            self.rgBump2Rep = True
+            self.rgTexCount = 6
+            self.rgTexType = [
+                TextureType.DIFFUSE,
+                TextureType.LIGHT,
+                TextureType.BUMP,
+                TextureType.MASK,
+                TextureType.BUMP1,
+                TextureType.BUMP2]
+        if self.renderGroupNum == 21:
+            self.rgShadding = False
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'No'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 1
+            self.rgTexType = [TextureType.DIFFUSE]
+        if self.renderGroupNum == 22:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = True
+            self.rgBump2Rep = True
+            self.rgTexCount = 7
+            self.rgTexType = [
+                TextureType.DIFFUSE,
+                TextureType.LIGHT,
+                TextureType.BUMP,
+                TextureType.MASK,
+                TextureType.BUMP1,
+                TextureType.BUMP2,
+                TextureType.SPECULAR]
+        if self.renderGroupNum == 23:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = True
+            self.rgBump2Rep = True
+            self.rgTexCount = 7
+            self.rgTexType = [
+                TextureType.DIFFUSE,
+                TextureType.LIGHT,
+                TextureType.BUMP,
+                TextureType.MASK,
+                TextureType.BUMP1,
+                TextureType.BUMP2,
+                TextureType.SPECULAR]
+        if self.renderGroupNum == 24:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 4
+            self.rgTexType = [
+                TextureType.DIFFUSE,
+                TextureType.LIGHT,
+                TextureType.BUMP,
+                TextureType.SPECULAR]
+        if self.renderGroupNum == 25:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 4
+            self.rgTexType = [
+                TextureType.DIFFUSE,
+                TextureType.LIGHT,
+                TextureType.BUMP,
+                TextureType.SPECULAR]
+        if self.renderGroupNum == 26:
+            self.rgShadding = 'Yes/No'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'Yes intensity'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 4
+            self.rgTexType = [
+                TextureType.DIFFUSE,
+                TextureType.BUMP,
+                TextureType.ENVIRONMENT,
+                TextureType.MASK]
+        if self.renderGroupNum == 27:
+            self.rgShadding = 'Yes/No'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'Yes intensity'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 4
+            self.rgTexType = [
+                TextureType.DIFFUSE,
+                TextureType.BUMP,
+                TextureType.ENVIRONMENT,
+                TextureType.MASK]
+        if self.renderGroupNum == 28:
+            self.rgShadding = 'Yes/No'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'Yes intensity'
+            self.rgBump1Rep = True
+            self.rgBump2Rep = True
+            self.rgTexCount = 6
+            self.rgTexType = [
+                TextureType.DIFFUSE,
+                TextureType.BUMP,
+                TextureType.MASK,
+                TextureType.BUMP1,
+                TextureType.BUMP2,
+                TextureType.ENVIRONMENT]
+        if self.renderGroupNum == 29:
+            self.rgShadding = 'Yes/No'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'Yes intensity'
+            self.rgBump1Rep = True
+            self.rgBump2Rep = True
+            self.rgTexCount = 6
+            self.rgTexType = [
+                TextureType.DIFFUSE,
+                TextureType.BUMP,
+                TextureType.MASK,
+                TextureType.BUMP1,
+                TextureType.BUMP2,
+                TextureType.ENVIRONMENT]
+        if self.renderGroupNum == 30:
+            self.rgShadding = 'Yes/No'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'Yes intensity'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 3
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.BUMP, TextureType.EMISSION]
+        if self.renderGroupNum == 31:
+            self.rgShadding = 'Yes/No'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'Yes intensity'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 3
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.BUMP, TextureType.EMISSION]
+        if self.renderGroupNum == 32:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 1
+            self.rgTexType = [TextureType.DIFFUSE]
+        if self.renderGroupNum == 33:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 1
+            self.rgTexType = [TextureType.DIFFUSE]
+        if self.renderGroupNum == 34:
+            self.rgTexType = [
+                TextureType.DIFFUSE,
+                TextureType.BUMP,
+                TextureType.MASK,
+                TextureType.SPECULAR]
+        if self.renderGroupNum == 35:
+            self.rgTexType = [
+                TextureType.DIFFUSE,
+                TextureType.BUMP,
+                TextureType.MASK,
+                TextureType.SPECULAR]
+        if self.renderGroupNum == 36:
+            self.rgShadding = 'Yes/No'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'Yes intensity'
+            self.rgBump1Rep = True
+            self.rgBump2Rep = False
+            self.rgTexCount = 3
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.BUMP, TextureType.EMISSION]
+        if self.renderGroupNum == 37:
+            self.rgShadding = 'Yes/No'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'Yes intensity'
+            self.rgBump1Rep = True
+            self.rgBump2Rep = False
+            self.rgTexCount = 3
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.BUMP, TextureType.EMISSION]
+        if self.renderGroupNum == 38:
+            self.rgShadding = 'Yes/No'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'Yes intensity'
+            self.rgBump1Rep = True
+            self.rgBump2Rep = False
+            self.rgTexCount = 4
+            self.rgTexType = [
+                TextureType.DIFFUSE,
+                TextureType.BUMP,
+                TextureType.SPECULAR,
+                TextureType.EMISSION]
+        if self.renderGroupNum == 39:
+            self.rgShadding = 'Yes/No'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'Yes intensity'
+            self.rgBump1Rep = True
+            self.rgBump2Rep = False
+            self.rgTexCount = 4
+            self.rgTexType = [
+                TextureType.DIFFUSE,
+                TextureType.BUMP,
+                TextureType.SPECULAR,
+                TextureType.EMISSION]
+        if self.renderGroupNum == 40:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 3
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.BUMP, TextureType.SPECULAR]
+        if self.renderGroupNum == 41:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgTexCount = 3
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.BUMP, TextureType.SPECULAR]
+        if self.renderGroupNum == 42:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = False
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgSpec1Rep = True
+            self.rgTexCount = 3
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.BUMP, TextureType.SPECULAR]
+        if self.renderGroupNum == 43:
+            self.rgShadding = 'Yes'
+            self.rgAlpha = True
+            self.rgPosable = True
+            self.rgSpecular = 'Yes'
+            self.rgBump1Rep = False
+            self.rgBump2Rep = False
+            self.rgSpec1Rep = True
+            self.rgTexCount = 3
+            self.rgTexType = [TextureType.DIFFUSE, TextureType.BUMP, TextureType.SPECULAR]
+
+
+def makeRenderType(meshFullName):
+    mat = meshFullName.split("_")
+    maxLen = 8
+    # Complete the array with None
+    mat = mat + [None] * (maxLen - len(mat))
+
+    renderType = RenderType()
+
+    renderGroupNum = 5
+    meshName = 'mesh'
+    specularity = 1
+    texRepeater1 = 0
+    texRepeater2 = 0
+
+    renderGroupFloat = ascii_ops.getFloat(mat[0])
+    # meshName = mat[1]
+    # specularityFloat = ascii_ops.getFloat(mat[2])
+    # texRepeater1Float = ascii_ops.getFloat(mat[3])
+    # texRepeater2Float = ascii_ops.getFloat(mat[4])
+
+    if math.isnan(renderGroupFloat):
+        meshName = mat[0]
+        specularityFloat = ascii_ops.getFloat(mat[1])
+        texRepeater1Float = ascii_ops.getFloat(mat[2])
+        texRepeater2Float = ascii_ops.getFloat(mat[3])
+    else:
+        renderGroupNum = int(renderGroupFloat)
+        meshName = mat[1]
+        specularityFloat = ascii_ops.getFloat(mat[2])
+        texRepeater1Float = ascii_ops.getFloat(mat[3])
+        texRepeater2Float = ascii_ops.getFloat(mat[4])
+
+    if specularityFloat and not math.isnan(specularityFloat):
+        specularity = specularityFloat
+    if texRepeater1Float and not math.isnan(texRepeater1Float):
+        texRepeater1 = texRepeater1Float
+    if texRepeater2Float and not math.isnan(texRepeater2Float):
+        texRepeater2 = texRepeater2Float
+    if mat[5]:
+        renderType.val4 = mat[5]
+
+    renderType.renderGroupNum = renderGroupNum
+    renderType.meshName = meshName
+    renderType.specularity = specularity
+    renderType.texRepeater1 = texRepeater1
+    renderType.texRepeater2 = texRepeater2
+
+    return renderType
+
+
+def makeRenderTypeName(renderType):
+    nameList = []
+
+    if renderType.renderGroupNum:
+        nameList.append(str(renderType.renderGroupNum))
+    if renderType.meshName is not None:
+        nameList.append(renderType.meshName)
+    if renderType.specularity is not None:
+        nameList.append(str(renderType.specularity))
+    if renderType.texRepeater1 is not None:
+        nameList.append(str(renderType.texRepeater1))
+    if renderType.texRepeater2 is not None:
+        nameList.append(str(renderType.texRepeater2))
+    if renderType.val4 is not None:
+        nameList.append(str(renderType.val4))
+
+    name = "_".join(nameList)
+    return name
+
+
+def texScaleOffset(scale):
+    offset = (scale / 2.0) - ((int(scale) - 1) // 2) - .5
+    return offset
+
+
+def scaleTex(textureSlot, texScale):
+    textureSlot.scale = (texScale, texScale, 1)
+    offset = texScaleOffset(texScale)
+    textureSlot.offset = (offset, -offset, 1)
+
+
+if __name__ == "__main__":
+    rt = RenderType()
+    xx = RenderGroup(rt)
+    print(xx.__dict__)
+    print(xx.rgTexType)

xnalara_io_Tools/xps_panels.py

···
+import bpy
+
+
+class _XpsPanels():
+    """All XPS panel inherit from this."""
+
+    bl_space_type = 'VIEW_3D'
+    bl_region_type = 'UI'
+    bl_category = 'XPS'
+    bl_context = 'objectmode'
+
+
+class XPSToolsObjectPanel(_XpsPanels, bpy.types.Panel):
+    bl_idname = 'XPS_PT_xps_tools_object'
+    bl_label = 'XPS Tools'
+
+    def draw(self, context):
+        layout = self.layout
+        col = layout.column()
+
+        col.label(text='Import:')
+        # c = col.column()
+        r = col.row(align=True)
+        r1c1 = r.column(align=True)
+        r1c1.operator("xps_tools.import_model", text='Model', icon='NONE')
+        r1c2 = r.column(align=True)
+        r1c2.operator('xps_tools.import_pose', text='Pose')
+
+        # col.separator()
+        col = layout.column()
+
+        col.label(text="Export:")
+        c = col.column()
+        r = c.row(align=True)
+        r2c1 = r.column(align=True)
+        r2c1.operator('xps_tools.export_model', text='Model')
+        r2c2 = r.column(align=True)
+        r2c2.operator('xps_tools.export_pose', text='Pose')
+
+
+class XPSToolsBonesPanel(_XpsPanels, bpy.types.Panel):
+    bl_idname = 'XPS_PT_xps_tools_bones'
+    bl_label = 'XPS Bones'
+
+    @classmethod
+    def poll(cls, context):
+        return bool(
+            next(
+                (obj for obj in context.selected_objects if obj.type == 'ARMATURE'),
+                None))
+
+    def draw(self, context):
+        layout = self.layout
+        col = layout.column()
+
+        # col.separator()
+        col = layout.column()
+
+        col.label(text='Hide Bones:')
+        c = col.column(align=True)
+        r = c.row(align=True)
+        r.operator('xps_tools.bones_hide_by_name', text='Unused')
+        r.operator('xps_tools.bones_hide_by_vertex_group', text='Vertex Group')
+        r = c.row(align=True)
+        r.operator('xps_tools.bones_show_all', text='Show All')
+
+        # col.separator()
+        col = layout.column()
+
+        col.label(text='BoneDict:')
+        c = col.column(align=True)
+        r = c.row(align=True)
+        r.operator('xps_tools.bones_dictionary_generate', text='Generate BoneDict')
+        r = c.row(align=True)
+        r.operator('xps_tools.bones_dictionary_rename', text='Rename Bones')
+        r = c.row(align=True)
+        r.operator('xps_tools.bones_dictionary_restore_name', text='Restore Names')
+
+        # col.separator()
+        col = layout.column()
+
+        col.label(text='Rename Bones:')
+        c = col.column(align=True)
+        r = c.row(align=True)
+        r.operator('xps_tools.bones_rename_to_blender', text='XPS to Blender')
+        r = c.row(align=True)
+        r.operator('xps_tools.bones_rename_to_xps', text='Blender To XPS')
+
+        col = layout.column()
+
+        col.label(text='Connect Bones:')
+        c = col.column(align=True)
+        r = c.row(align=True)
+        r.operator(
+            'xps_tools.bones_connect',
+            text='Connect All').connectBones = True
+        r = c.row(align=True)
+        r.operator(
+            'xps_tools.bones_connect',
+            text='Disconnect All').connectBones = False
+        col.label(text='New Rest Pose:')
+        c = col.column(align=True)
+        r = c.row(align=True)
+        r.operator(
+            'xps_tools.new_rest_pose',
+            text='New Rest Pose')
+
+
+class XPSToolsAnimPanel(_XpsPanels, bpy.types.Panel):
+    bl_idname = 'XPS_PT_xps_tools_anim'
+    bl_label = 'XPS Anim'
+
+    @classmethod
+    def poll(cls, context):
+        return bool(
+            next(
+                (obj for obj in context.selected_objects if obj.type == 'ARMATURE'),
+                None))
+
+    def draw(self, context):
+        layout = self.layout
+        col = layout.column()
+
+        # col.separator()
+        col = layout.column()
+
+        col.label(text='Import:')
+        c = col.column(align=True)
+        r = c.row(align=True)
+        r.operator(
+            'xps_tools.import_poses_to_keyframes',
+            text='Poses to Keyframes')
+
+        # col.separator()
+        col = layout.column()
+
+        col.label(text='Export:')
+        c = col.column(align=True)
+        r = c.row(align=True)
+        r.operator('xps_tools.export_frames_to_poses', text='Frames to Poses')

xnalara_io_Tools/xps_tools.py

···
+import os
+
+import bpy
+import bpy.utils.previews as previews
+from bpy_extras.io_utils import (ExportHelper, ImportHelper,
+                                 _check_axis_conversion, axis_conversion,
+                                 orientation_helper, path_reference_mode)
+
+from . import (export_xnalara_model, export_xnalara_pose, import_xnalara_model,
+               import_xnalara_pose, material_creator, xps_types)
+
+uv_x_displace = 0
+uv_y_displace = 0
+
+
+class CustomExportHelper(ExportHelper):
+
+    def check(self, context):
+        import os
+        change_ext = False
+        change_axis = _check_axis_conversion(self)
+
+        check_extension = self.check_extension
+
+        if check_extension is not None:
+            filepath = self.filepath
+            if os.path.basename(filepath):
+                filepath = bpy.path.ensure_ext(filepath,
+                                               self.filename_ext
+                                               if check_extension
+                                               else "")
+
+                if filepath != self.filepath:
+
+                    head, tail = os.path.split(self.filepath)
+                    filepath = os.path.splitext(tail)[0]
+                    filepath = bpy.path.ensure_ext(filepath,
+                                                   self.filename_ext
+                                                   if check_extension
+                                                   else "")
+                    self.filepath = os.path.join(head, filepath)
+                    change_ext = True
+
+        return (change_ext or change_axis)
+
+
+class Import_Xps_Model_Op(bpy.types.Operator, ImportHelper):
+    """Load an XNALara model File."""
+
+    bl_idname = "xps_tools.import_model"
+    bl_label = "Import XNALara/XPS Model"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_options = {'REGISTER', 'UNDO'}
+
+    filename_ext = ".mesh"
+
+    # List of operator properties, the attributes will be assigned
+    # to the class instance from the operator settings before calling.
+
+    # filter File Extension
+    filter_glob: bpy.props.StringProperty(
+        default="*.ascii;*.mesh;*.xps",
+        options={'HIDDEN'},
+    )  # type:ignore
+
+    uvDisplX: bpy.props.IntProperty(
+        name="X",
+        description="Displace UV X axis",
+        default=uv_x_displace,
+    )  # type:ignore
+
+    uvDisplY: bpy.props.IntProperty(
+        name="Y",
+        description="Displace UV Y axis",
+        default=uv_y_displace,
+    )  # type:ignore
+
+    impDefPose: bpy.props.BoolProperty(
+        name="Default Pose",
+        description="Import Default Pose",
+        default=False,
+    )  # type:ignore
+
+    markSeams: bpy.props.BoolProperty(
+        name="Mark Seams",
+        description="Mark as Seams the edged merged by the addon",
+        default=True,
+    )  # type:ignore
+
+    vColors: bpy.props.BoolProperty(
+        name="Vertex Colors",
+        description="Import Vertex Colors",
+        default=True,
+    )  # type:ignore
+
+    joinMeshRips: bpy.props.BoolProperty(
+        name="Merge Doubles by Normal",
+        description="Merge vertices with the same position and normal",
+        default=True,
+    )  # type:ignore
+
+    joinMeshParts: bpy.props.BoolProperty(
+        name="Join MeshParts",
+        description="Join MeshParts (meshes that contain 'nPart!' in the name)",
+        default=True,
+    )  # type:ignore
+
+    connectBones: bpy.props.BoolProperty(
+        name="Connect Bones",
+        description="Connect Bones all bones",
+        default=True,
+    )  # type:ignore
+
+    autoIk: bpy.props.BoolProperty(
+        name="AutoIK",
+        description="Set AutoIK",
+        default=True,
+    )  # type:ignore
+
+    importNormals: bpy.props.BoolProperty(
+        name="Import Normals",
+        description="Import Custom Normals",
+        default=True,
+    )  # type:ignore
+
+    separate_optional_objects: bpy.props.BoolProperty(
+        name="Separate Optional Objects",
+        description="Separate into collection object marked as optional",
+        default=True
+    )  # type:ignore
+
+    # Only needed if you want to add into a dynamic menu
+    def menu_func(self, context):
+        self.layout.operator_context = 'INVOKE_DEFAULT'
+        self.layout.operator(
+            Import_Xps_Model_Op.bl_idname,
+            text="Text Export Operator")
+
+    @classmethod
+    def poll(cls, context):
+        # Always can import
+        return True
+
+    def execute(self, context):
+        xpsSettings = xps_types.XpsImportSettings(
+            self.filepath,
+            self.uvDisplX,
+            self.uvDisplY,
+            self.impDefPose,
+            self.joinMeshRips,
+            self.joinMeshParts,
+            self.markSeams and self.joinMeshRips,
+            self.vColors,
+            self.connectBones,
+            self.autoIk,
+            self.importNormals,
+            self.separate_optional_objects
+        )
+        material_creator.create_group_nodes()
+        status = import_xnalara_model.getInputFilename(xpsSettings)
+        if status == '{NONE}':
+            # self.report({'DEBUG'}, "DEBUG File Format unrecognized")
+            # self.report({'INFO'}, "INFO File Format unrecognized")
+            # self.report({'OPERATOR'}, "OPERATOR File Format unrecognized")
+            # self.report({'WARNING'}, "WARNING File Format unrecognized")
+            # self.report({'ERROR'}, "ERROR File Format unrecognized")
+            self.report({'ERROR'}, "ERROR File Format unrecognized")
+        return {'FINISHED'}
+
+    def draw(self, context):
+        layout = self.layout
+        col = layout.column(align=True)
+        col.label(text='UV Displace')
+        col.prop(self, "uvDisplX")
+        col.prop(self, "uvDisplY")
+
+        col = layout.column(align=True)
+        col.label(text='Mesh')
+        col.prop(self, "joinMeshParts")
+        col.prop(self, "joinMeshRips")
+        col.prop(self, "separate_optional_objects")
+
+        sub = col.row()
+        col.prop(self, "importNormals")
+        sub.prop(self, "markSeams")
+        col.prop(self, "vColors")
+
+        sub.enabled = self.joinMeshRips
+        self.markSeams = self.joinMeshRips and self.markSeams
+
+        col = layout.column(align=True)
+        col.label(text='Armature')
+        col.prop(self, "impDefPose")
+        col.prop(self, "connectBones")
+        col.prop(self, "autoIk")
+
+
+class Export_Xps_Model_Op(bpy.types.Operator, CustomExportHelper):
+    """Save an XNALara model File."""
+
+    bl_idname = "xps_tools.export_model"
+    bl_label = "Export XNALara/XPS Model"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_options = {'REGISTER'}
+
+    filename_ext: bpy.props.EnumProperty(
+        name='Format',
+        description='Choose Export Format',
+        items=(
+            ('.xps', 'XPS', 'Export as XPS Binary format (.xps)'),
+            ('.mesh', 'MESH', 'Export as XnaLara/XPS Binary format (.mesh)'),
+            ('.ascii', 'ASCII', 'Export as XnaLara/XPS Ascii format (.ascii)'),
+        ),
+        default='.xps',
+    )  # type:ignore
+
+    xps_version_mayor: bpy.props.EnumProperty(
+        name='FormatVersion',
+        description='Fixed 4 bone weights or unlimited formats',
+        items=(
+            ('3', 'V3', 'Supports Unlimited Bone Weights (compatibli with XPS 1.8.9)'),
+            ('2', 'V2', 'Supports 4 Bone Weights'),
+        ),
+        default='3',
+    )  # type:ignore
+
+    xps_version_minor: bpy.props.EnumProperty(
+        name='FormatVersionMinor',
+        description='Fixed 4 bone weights or unlimited formats',
+        items=(
+            ('15', '15', 'XPS version minor'),
+        ),
+        default='15',
+        options={'HIDDEN'},
+    )  # type:ignore
+
+    # List of operator properties, the attributes will be assigned
+    # to the class instance from the operator settings before calling.
+
+    # filter File Extension
+    filter_glob: bpy.props.StringProperty(
+        default="*.ascii;*.mesh;*.xps",
+        options={'HIDDEN'},
+    )  # type:ignore
+
+    uvDisplX: bpy.props.IntProperty(
+        name="X",
+        description="Displace UV X axis",
+        default=uv_x_displace,
+    )  # type:ignore
+
+    uvDisplY: bpy.props.IntProperty(
+        name="Y",
+        description="Displace UV Y axis",
+        default=uv_y_displace,
+    )  # type:ignore
+
+    expDefPose: bpy.props.BoolProperty(
+        name="Default Pose",
+        description="Export Default Pose",
+        default=False,
+    )  # type:ignore
+
+    exportOnlySelected: bpy.props.BoolProperty(
+        name="Export Only Selected",
+        description="Export only selected objects",
+        default=True,
+    )  # type:ignore
+
+    exportNormals: bpy.props.BoolProperty(
+        name="Export Normals",
+        description="Export Custom Normals",
+        default=True,
+    )  # type:ignore
+
+    preserveSeams: bpy.props.BoolProperty(
+        name="Preserve Seams",
+        description="Split Edges marked as seams. They are marked as seams when imported back",
+        default=True,
+    )  # type:ignore
+
+    vColors: bpy.props.BoolProperty(
+        name="Vertex Colors",
+        description="Export Vertex Colors",
+        default=True,
+    )  # type:ignore
+
+    @classmethod
+    def poll(cls, context):
+        return bool(
+            next(
+                (obj for obj in context.selected_objects if obj.type == 'MESH'),
+                None))
+
+    def execute(self, context):
+        xpsSettings = xps_types.XpsExportSettings(
+            filename=self.filepath,
+            format=self.filename_ext,
+            uvDisplX=self.uvDisplX,
+            uvDisplY=self.uvDisplY,
+            exportOnlySelected=self.exportOnlySelected,
+            expDefPose=self.expDefPose,
+            preserveSeams=self.preserveSeams,
+            vColors=self.vColors,
+            exportNormals=self.exportNormals,
+            versionMayor=int(self.xps_version_mayor),
+            versionMinor=int(self.xps_version_minor),
+        )
+        export_xnalara_model.getOutputFilename(xpsSettings)
+        return {'FINISHED'}
+
+    def draw(self, context):
+        layout = self.layout
+
+        layout.prop(self, "exportOnlySelected")
+
+        layout.label(text="File Format:")
+        layout.prop(self, "filename_ext", expand=True)
+        if (self.filename_ext == '.xps'):
+            layout.prop(self, "xps_version_mayor", expand=True)
+
+        col = layout.column(align=True)
+        col.label(text='Mesh')
+        col.prop(self, "preserveSeams")
+        col.prop(self, "exportNormals")
+        col.prop(self, "vColors")
+
+        col = layout.column(align=True)
+        col.label(text='UV Displace')
+        col.prop(self, "uvDisplX")
+        col.prop(self, "uvDisplY")
+
+        layout.prop(self, "expDefPose")
+
+
+class Import_Xps_Pose_Op(bpy.types.Operator, ImportHelper):
+    """Load an XNALara pose File."""
+
+    bl_idname = "xps_tools.import_pose"
+    bl_label = "Import XNALara/XPS Pose"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_options = {'REGISTER', 'UNDO'}
+
+    filename_ext = '.pose'
+
+    # List of operator properties, the attributes will be assigned
+    # to the class instance from the operator settings before calling.
+
+    # filter File Extension
+    filter_glob: bpy.props.StringProperty(
+        default="*.pose",
+        options={'HIDDEN'},
+    )  # type:ignore
+
+    @classmethod
+    def poll(cls, context):
+        return context.active_object and context.active_object.type == 'ARMATURE'
+
+    def execute(self, context):
+        import_xnalara_pose.getInputFilename(self.filepath)
+        return {'FINISHED'}
+
+
+class Export_Xps_Pose_Op(bpy.types.Operator, ExportHelper):
+    """Save an XNALara pose File."""
+
+    bl_idname = "xps_tools.export_pose"
+    bl_label = "Export XNALara/XPS Pose"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_options = {'REGISTER'}
+
+    filename_ext = '.pose'
+
+    # List of operator properties, the attributes will be assigned
+    # to the class instance from the operator settings before calling.
+
+    # filter File Extension
+    filter_glob: bpy.props.StringProperty(
+        default="*.pose",
+        options={'HIDDEN'},
+    )  # type:ignore
+
+    @classmethod
+    def poll(cls, context):
+        return context.active_object and context.active_object.type == 'ARMATURE'
+
+    def execute(self, context):
+        export_xnalara_pose.getOutputFilename(self.filepath)
+        return {'FINISHED'}
+
+
+class Import_Poses_To_Keyframes_Op(bpy.types.Operator, ImportHelper):
+    """Load a sequence of posese as keyframes."""
+
+    bl_idname = "xps_tools.import_poses_to_keyframes"
+    bl_label = "Import poses to keyframes"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_options = {'REGISTER', 'UNDO'}
+
+    filename_ext = '.pose'
+
+    # List of operator properties, the attributes will be assigned
+    # to the class instance from the operator settings before calling.
+
+    # filter File Extension
+    filter_glob: bpy.props.StringProperty(
+        default="*.pose",
+        options={'HIDDEN'},
+    )  # type:ignore
+
+    @classmethod
+    def poll(cls, context):
+        return context.active_object and context.active_object.type == 'ARMATURE'
+
+    def execute(self, context):
+        import_xnalara_pose.getInputPoseSequence(self.filepath)
+        return {'FINISHED'}
+
+
+class Export_Frames_To_Poses_Op(bpy.types.Operator, CustomExportHelper):
+    """Save frames as poses."""
+
+    bl_idname = "xps_tools.export_frames_to_poses"
+    bl_label = "Export frames to poses"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_options = {'REGISTER'}
+
+    filename_ext = '.pose'
+
+    # List of operator properties, the attributes will be assigned
+    # to the class instance from the operator settings before calling.
+
+    # filter File Extension
+    filter_glob: bpy.props.StringProperty(
+        default="*.pose",
+        options={'HIDDEN'},
+    )  # type:ignore
+
+    @classmethod
+    def poll(cls, context):
+        return context.active_object and context.active_object.type == 'ARMATURE'
+
+    def execute(self, context):
+        export_xnalara_pose.getOutputPoseSequence(self.filepath)
+        return {'FINISHED'}
+
+
+class ArmatureBoneDictGenerate_Op(bpy.types.Operator):
+    """Generate a BoneDict from armature."""
+
+    bl_idname = 'xps_tools.bones_dictionary_generate'
+    bl_label = 'Generate BoneDict'
+    bl_description = 'Generate a BoneDict from active armature'
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_options = {'REGISTER'}
+
+    filename_ext = '.txt'
+    check_extension = True
+
+    # List of operator properties, the attributes will be assigned
+    # to the class instance from the operator settings before calling.
+    filepath: bpy.props.StringProperty(
+        name="File Path",
+        description="Bone Dictionary File",
+        maxlen=1024,
+        subtype='FILE_PATH',
+    )  # type:ignore
+
+    # filter File Extension
+    filter_glob: bpy.props.StringProperty(
+        default="*.txt",
+        options={'HIDDEN'},
+    )  # type:ignore
+
+    @classmethod
+    def poll(cls, context):
+        if context.active_object:
+            return context.active_object.type == 'ARMATURE'
+
+    def execute(self, context):
+        armatureObj = context.active_object
+        export_xnalara_model.boneDictGenerate(self.filepath, armatureObj)
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        if not self.filepath:
+            self.filepath = 'BoneDict.txt'
+        context.window_manager.fileselect_add(self)
+        return {'RUNNING_MODAL'}
+
+    def check(self, context):
+        import os
+        change_ext = False
+        check_extension = self.check_extension
+
+        if check_extension is not None:
+            filepath = self.filepath
+            if os.path.basename(filepath):
+                filepath = bpy.path.ensure_ext(filepath,
+                                               self.filename_ext
+                                               if check_extension
+                                               else "")
+
+                if filepath != self.filepath:
+                    self.filepath = filepath
+                    change_ext = True
+
+        return (change_ext)
+
+
+class ArmatureBoneDictRename_Op(bpy.types.Operator):
+    bl_idname = 'xps_tools.bones_dictionary_rename'
+    bl_label = 'Dictionary Rename'
+    bl_description = 'Use BoneDict to Rename Bones'
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_options = {'REGISTER', 'UNDO'}
+
+    filename_ext = '.txt'
+    check_extension = True
+
+    # List of operator properties, the attributes will be assigned
+    # to the class instance from the operator settings before calling.
+    filepath: bpy.props.StringProperty(
+        name="File Path",
+        description="Bone Dictionary File",
+        maxlen=1024,
+        subtype='FILE_PATH',
+    )  # type:ignore
+
+    # filter File Extension
+    filter_glob: bpy.props.StringProperty(
+        default="*.txt",
+        options={'HIDDEN'},
+    )  # type:ignore
+
+    @classmethod
+    def poll(cls, context):
+        return bool(
+            next(
+                (obj for obj in context.selected_objects if obj.type == 'ARMATURE'),
+                None))
+
+    def execute(self, context):
+        armatureObj = next((obj for obj in context.selected_objects if obj.type == 'ARMATURE'), None)
+        import_xnalara_model.boneDictRename(self.filepath, armatureObj)
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        if not self.filepath:
+            self.filepath = 'BoneDict.txt'
+        context.window_manager.fileselect_add(self)
+        return {'RUNNING_MODAL'}
+
+    def check(self, context):
+        import os
+        change_ext = False
+        check_extension = self.check_extension
+
+        if check_extension is not None:
+            filepath = self.filepath
+            if os.path.basename(filepath):
+                filepath = bpy.path.ensure_ext(filepath,
+                                               self.filename_ext
+                                               if check_extension
+                                               else "")
+
+                if filepath != self.filepath:
+                    self.filepath = filepath
+                    change_ext = True
+
+        return (change_ext)
+
+
+class ArmatureBoneDictRestore_Op(bpy.types.Operator):
+    bl_idname = 'xps_tools.bones_dictionary_restore_name'
+    bl_label = 'Dictionary Restore Names'
+    bl_description = 'Use BoneDict to Restore Bone Names'
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_options = {'REGISTER', 'UNDO'}
+
+    filename_ext = '.txt'
+    check_extension = True
+
+    # List of operator properties, the attributes will be assigned
+    # to the class instance from the operator settings before calling.
+    filepath: bpy.props.StringProperty(
+        name="File Path",
+        description="Bone Dictionary File",
+        maxlen=1024,
+        subtype='FILE_PATH',
+    )  # type:ignore
+
+    # filter File Extension
+    filter_glob: bpy.props.StringProperty(
+        default="*.txt",
+        options={'HIDDEN'},
+    )  # type:ignore
+
+    @classmethod
+    def poll(cls, context):
+        return bool(
+            next(
+                (obj for obj in context.selected_objects if obj.type == 'ARMATURE'),
+                None))
+
+    def execute(self, context):
+        armatureObj = next((obj for obj in context.selected_objects if obj.type == 'ARMATURE'), None)
+        import_xnalara_model.boneDictRestore(self.filepath, armatureObj)
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        if not self.filepath:
+            self.filepath = 'BoneDict.txt'
+        context.window_manager.fileselect_add(self)
+        return {'RUNNING_MODAL'}
+
+    def check(self, context):
+        import os
+        change_ext = False
+        check_extension = self.check_extension
+
+        if check_extension is not None:
+            filepath = self.filepath
+            if os.path.basename(filepath):
+                filepath = bpy.path.ensure_ext(filepath,
+                                               self.filename_ext
+                                               if check_extension
+                                               else "")
+
+                if filepath != self.filepath:
+                    self.filepath = filepath
+                    change_ext = True
+
+        return (change_ext)
+
+
+@orientation_helper(axis_forward='-Z', axis_up='Y')
+class ImportXpsNgff(bpy.types.Operator, ImportHelper):
+    """Load a Wavefront OBJ File."""
+
+    bl_idname = "import_xps_ngff.obj"
+    bl_label = "Import XPS NGFF"
+    bl_options = {'PRESET', 'UNDO'}
+
+    filename_ext = ".obj"
+    filter_glob: bpy.props.StringProperty(
+        default="*.obj;*.mtl;*.arl",
+        options={'HIDDEN'},
+    )  # type:ignore
+
+    use_edges: bpy.props.BoolProperty(
+        name="Lines",
+        description="Import lines and faces with 2 verts as edge",
+        default=True,
+    )  # type:ignore
+
+    use_smooth_groups: bpy.props.BoolProperty(
+        name="Smooth Groups",
+        description="Surround smooth groups by sharp edges",
+        default=True,
+    )  # type:ignore
+
+    use_split_objects: bpy.props.BoolProperty(
+        name="Object",
+        description="Import OBJ Objects into Blender Objects",
+        default=True,
+    )  # type:ignore
+
+    use_split_groups: bpy.props.BoolProperty(
+        name="Group",
+        description="Import OBJ Groups into Blender Objects",
+        default=True,
+    )  # type:ignore
+
+    use_groups_as_vgroups: bpy.props.BoolProperty(
+        name="Poly Groups",
+        description="Import OBJ groups as vertex groups",
+        default=False,
+    )  # type:ignore
+
+    use_image_search: bpy.props.BoolProperty(
+        name="Image Search",
+        description="Search subdirs for any associated images "
+                    "(Warning, may be slow)",
+        default=True,
+    )  # type:ignore
+
+    split_mode: bpy.props.EnumProperty(
+        name="Split",
+        items=(
+            ('ON', "Split", "Split geometry, omits unused verts"),
+            ('OFF', "Keep Vert Order", "Keep vertex order from file"),
+        )
+    )  # type:ignore
+
+    global_clamp_size: bpy.props.FloatProperty(
+        name="Clamp Size",
+        description="Clamp bounds under this value (zero to disable)",
+        min=0.0, max=1000.0,
+        soft_min=0.0, soft_max=1000.0,
+        default=0.0,
+    )  # type:ignore
+
+    def execute(self, context):
+        # print("Selected: " + context.active_object.name)
+        from . import import_obj
+
+        if self.split_mode == 'OFF':
+            self.use_split_objects = False
+            self.use_split_groups = False
+        else:
+            self.use_groups_as_vgroups = False
+
+        keywords = self.as_keywords(ignore=("axis_forward",
+                                            "axis_up",
+                                            "filter_glob",
+                                            "split_mode",
+                                            ))
+
+        global_matrix = axis_conversion(from_forward=self.axis_forward,
+                                        from_up=self.axis_up,
+                                        ).to_4x4()
+        keywords["global_matrix"] = global_matrix
+
+        if bpy.data.is_saved and context.user_preferences.filepaths.use_relative_paths:
+            import os
+            keywords["relpath"] = os.path.dirname(bpy.data.filepath)
+
+        return import_obj.load(context, **keywords)
+
+    def draw(self, context):
+        layout = self.layout
+
+        row = layout.row(align=True)
+        row.prop(self, "use_smooth_groups")
+        row.prop(self, "use_edges")
+
+        box = layout.box()
+        row = box.row()
+        row.prop(self, "split_mode", expand=True)
+
+        row = box.row()
+        if self.split_mode == 'ON':
+            row.label(text="Split by:")
+            row.prop(self, "use_split_objects")
+            row.prop(self, "use_split_groups")
+        else:
+            row.prop(self, "use_groups_as_vgroups")
+
+        row = layout.split(percentage=0.67)
+        row.prop(self, "global_clamp_size")
+        layout.prop(self, "axis_forward")
+        layout.prop(self, "axis_up")
+
+        layout.prop(self, "use_image_search")
+
+
+@orientation_helper(axis_forward='-Z', axis_up='Y')
+class ExportXpsNgff(bpy.types.Operator, ExportHelper):
+    """Save a Wavefront OBJ File."""
+
+    bl_idname = "export_xps_ngff.obj"
+    bl_label = 'Export XPS NGFF'
+    bl_options = {'PRESET'}
+
+    filename_ext = ".obj"
+    filter_glob: bpy.props.StringProperty(
+        default="*.obj;*.mtl;*.arl",
+        options={'HIDDEN'},
+    )  # type:ignore
+
+    # context group
+    use_selection: bpy.props.BoolProperty(
+        name="Selection Only",
+        description="Export selected objects only",
+        default=False,
+    )  # type:ignore
+    use_animation: bpy.props.BoolProperty(
+        name="Animation",
+        description="Write out an OBJ for each frame",
+        default=False,
+    )  # type:ignore
+
+    # object group
+    use_mesh_modifiers: bpy.props.BoolProperty(
+        name="Apply Modifiers",
+        description="Apply modifiers (preview resolution)",
+        default=True,
+    )  # type:ignore
+
+    # extra data group
+    use_edges: bpy.props.BoolProperty(
+        name="Include Edges",
+        description="",
+        default=True,
+    )  # type:ignore
+    use_smooth_groups: bpy.props.BoolProperty(
+        name="Smooth Groups",
+        description="Write sharp edges as smooth groups",
+        default=False,
+    )  # type:ignore
+    use_smooth_groups_bitflags: bpy.props.BoolProperty(
+        name="Bitflag Smooth Groups",
+        description="Same as 'Smooth Groups', but generate smooth groups IDs as bitflags "
+                    "(produces at most 32 different smooth groups, usually much less)",
+        default=False,
+    )  # type:ignore
+    use_normals: bpy.props.BoolProperty(
+        name="Write Normals",
+        description="Export one normal per vertex and per face, to represent flat faces and sharp edges",
+        default=True,
+    )  # type:ignore
+    use_vcolors: bpy.props.BoolProperty(
+        name="Write Vert Colors",
+        description="Export Vertex Color",
+        default=True,
+    )  # type:ignore
+    use_uvs: bpy.props.BoolProperty(
+        name="Include UVs",
+        description="Write out the active UV coordinates",
+        default=True,
+    )  # type:ignore
+    use_materials: bpy.props.BoolProperty(
+        name="Write Materials",
+        description="Write out the MTL file",
+        default=True,
+    )  # type:ignore
+    use_triangles: bpy.props.BoolProperty(
+        name="Triangulate Faces",
+        description="Convert all faces to triangles",
+        default=False,
+    )  # type:ignore
+    use_nurbs: bpy.props.BoolProperty(
+        name="Write Nurbs",
+        description="Write nurbs curves as OBJ nurbs rather than "
+                    "converting to geometry",
+        default=False,
+    )  # type:ignore
+    use_vertex_groups: bpy.props.BoolProperty(
+        name="Polygroups",
+        description="",
+        default=False,
+    )  # type:ignore
+
+    # grouping group
+    use_blen_objects: bpy.props.BoolProperty(
+        name="Objects as OBJ Objects",
+        description="",
+        default=True,
+    )  # type:ignore
+    group_by_object: bpy.props.BoolProperty(
+        name="Objects as OBJ Groups ",
+        description="",
+        default=False,
+    )  # type:ignore
+    group_by_material: bpy.props.BoolProperty(
+        name="Material Groups",
+        description="",
+        default=False,
+    )  # type:ignore
+    keep_vertex_order: bpy.props.BoolProperty(
+        name="Keep Vertex Order",
+        description="",
+        default=False,
+    )  # type:ignore
+    global_scale: bpy.props.FloatProperty(
+        name="Scale",
+        min=0.01, max=1000.0,
+        default=1.0,
+    )  # type:ignore
+
+    path_mode = path_reference_mode
+
+    check_extension = True
+
+    def execute(self, context):
+        from mathutils import Matrix
+
+        from . import export_obj
+        keywords = self.as_keywords(ignore=("axis_forward",
+                                            "axis_up",
+                                            "global_scale",
+                                            "check_existing",
+                                            "filter_glob",
+                                            ))
+
+        global_matrix = (Matrix.Scale(self.global_scale, 4)
+                         * axis_conversion(to_forward=self.axis_forward,
+                                           to_up=self.axis_up
+                                           ).to_4x4())
+
+        keywords["global_matrix"] = global_matrix
+        return export_obj.save(context, **keywords)
+
+
+class XpsImportSubMenu(bpy.types.Menu):
+    bl_idname = "OBJECT_MT_xnalara_import_submenu"
+    bl_label = "XNALara / XPS"
+
+    def draw(self, context):
+        layout = self.layout
+        layout.operator(Import_Xps_Model_Op.bl_idname, text="XNALara/XPS Model (.ascii/.mesh/.xps)")
+        layout.operator(Import_Xps_Pose_Op.bl_idname, text="XNALara/XPS Pose (.pose)")
+        layout.operator(ImportXpsNgff.bl_idname, text="XPS NGFF (.obj)")
+
+
+class XpsExportSubMenu(bpy.types.Menu):
+    bl_idname = "OBJECT_MT_xnalara_export_submenu"
+    bl_label = "XNALara / XPS"
+
+    def draw(self, context):
+        layout = self.layout
+        layout.operator(Export_Xps_Model_Op.bl_idname, text="XNALara/XPS Model (.ascii/.mesh/.xps)")
+        layout.operator(Export_Xps_Pose_Op.bl_idname, text="XNALara/XPS Pose (.pose)")
+        layout.operator(ExportXpsNgff.bl_idname, text="XPS NGFF (.obj)")
+
+
+#
+# Registration
+#
+def menu_func_import(self, context):
+    my_icon = custom_icons["main"]["xps_icon"]
+    self.layout.menu(XpsImportSubMenu.bl_idname, icon_value=my_icon.icon_id)
+
+
+def menu_func_export(self, context):
+    my_icon = custom_icons["main"]["xps_icon"]
+    self.layout.menu(XpsExportSubMenu.bl_idname, icon_value=my_icon.icon_id)
+
+
+# --------------------------------------------------------------------------------
+#  Custom Icons
+# --------------------------------------------------------------------------------
+custom_icons = {}
+
+
+def registerCustomIcon():
+
+    pcoll = previews.new()
+    script_path = os.path.dirname(__file__)
+    icons_dir = os.path.join(script_path, "icons")
+    pcoll.load("xps_icon", os.path.join(icons_dir, "icon.png"), 'IMAGE')
+    custom_icons["main"] = pcoll
+
+
+def unregisterCustomIcon():
+    for pcoll in custom_icons.values():
+        previews.remove(pcoll)
+    custom_icons.clear()
+
+
+def register():
+    bpy.types.TOPBAR_MT_file_import.append(menu_func_import)
+    bpy.types.TOPBAR_MT_file_export.append(menu_func_export)
+    registerCustomIcon()
+
+
+def unregister():
+    bpy.types.TOPBAR_MT_file_import.remove(menu_func_import)
+    bpy.types.TOPBAR_MT_file_export.remove(menu_func_export)
+    unregisterCustomIcon()
+
+
+if __name__ == "__main__":
+    register()

xnalara_io_Tools/xps_toolshelf.py

···
+import bpy
+
+from . import import_xnalara_model, import_xnalara_pose
+
+
+class ArmatureBonesHideByName_Op(bpy.types.Operator):
+    bl_idname = 'xps_tools.bones_hide_by_name'
+    bl_label = 'Hide bones by name'
+    bl_description = 'Move bones starting with "unused" to the armature layer 2'
+    bl_options = {'PRESET'}
+
+    @classmethod
+    def poll(cls, context):
+        return bool(
+            next(
+                (obj for obj in context.selected_objects if obj.type == 'ARMATURE'),
+                None))
+
+    def execute(self, context):
+        import_xnalara_model.hideBonesByName(self.armature_objs)
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        self.armature_objs = [
+            obj for obj in context.selected_objects if obj.type == 'ARMATURE']
+        return self.execute(context)
+
+    def check(self, context):
+        print('CHECK')
+        return {'RUNNING_MODAL'}
+
+
+class ArmatureBonesHideByVertexGroup_Op(bpy.types.Operator):
+    bl_idname = 'xps_tools.bones_hide_by_vertex_group'
+    bl_label = 'Hide bones by weight'
+    bl_description = 'Move bones that do not alter any mesh to the armature layer 2'
+    bl_options = {'PRESET'}
+
+    @classmethod
+    def poll(cls, context):
+        return bool(
+            next(
+                (obj for obj in context.selected_objects if obj.type == 'ARMATURE'),
+                None))
+
+    def execute(self, context):
+        import_xnalara_model.hideBonesByVertexGroup(self.armature_objs)
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        self.armature_objs = [
+            obj for obj in context.selected_objects if obj.type == 'ARMATURE']
+        return self.execute(context)
+
+    def check(self, context):
+        print('CHECK')
+        return {'RUNNING_MODAL'}
+
+
+class ArmatureBonesShowAll_Op(bpy.types.Operator):
+    bl_idname = 'xps_tools.bones_show_all'
+    bl_label = 'Show all Bones'
+    bl_description = 'Move all bones to the armature layer 1'
+    bl_options = {'PRESET'}
+
+    @classmethod
+    def poll(cls, context):
+        return bool(
+            next(
+                (obj for obj in context.selected_objects if obj.type == 'ARMATURE'),
+                None))
+
+    def execute(self, context):
+        import_xnalara_model.showAllBones(self.armature_objs)
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        self.armature_objs = [
+            obj for obj in context.selected_objects if obj.type == 'ARMATURE']
+        return self.execute(context)
+
+    def check(self, context):
+        print('CHECK')
+        return {'RUNNING_MODAL'}
+
+
+class ArmatureBonesRenameToBlender_Op(bpy.types.Operator):
+    bl_idname = 'xps_tools.bones_rename_to_blender'
+    bl_label = 'Rename Bones'
+    bl_description = 'Rename bones to Blender bone name convention (left -> .L)'
+    bl_options = {'PRESET'}
+
+    @classmethod
+    def poll(cls, context):
+        return bool(
+            next(
+                (obj for obj in context.selected_objects if obj.type == 'ARMATURE'),
+                None))
+
+    def execute(self, context):
+        armatures_obs = filter(
+            lambda obj: obj.type == 'ARMATURE',
+            context.selected_objects)
+        import_xnalara_pose.renameBonesToBlender(armatures_obs)
+        return {'FINISHED'}
+
+
+class ArmatureBonesRenameToXps_Op(bpy.types.Operator):
+    bl_idname = 'xps_tools.bones_rename_to_xps'
+    bl_label = 'Rename Bones'
+    bl_description = 'Rename bones back to XPS (.L -> left)'
+    bl_options = {'PRESET'}
+
+    @classmethod
+    def poll(cls, context):
+        return bool(
+            next(
+                (obj for obj in context.selected_objects if obj.type == 'ARMATURE'),
+                None))
+
+    def execute(self, context):
+        armatures_obs = filter(
+            lambda obj: obj.type == 'ARMATURE',
+            context.selected_objects)
+        import_xnalara_pose.renameBonesToXps(armatures_obs)
+        return {'FINISHED'}
+
+
+class ArmatureBonesConnect_Op(bpy.types.Operator):
+    bl_idname = 'xps_tools.bones_connect'
+    bl_label = 'Set Bones Connection'
+    bl_description = 'Set Bones Connection'
+    bl_options = {'PRESET'}
+
+    connectBones: bpy.props.BoolProperty()  # type:ignore
+
+    @classmethod
+    def poll(cls, context):
+        return bool(
+            next(
+                (obj for obj in context.selected_objects if obj.type == 'ARMATURE'),
+                None))
+
+    def execute(self, context):
+        armatures_obs = filter(
+            lambda obj: obj.type == 'ARMATURE',
+            context.selected_objects)
+        activeObj = bpy.context.active_object
+        for armature_ob in armatures_obs:
+            bpy.context.view_layer.objects.active = armature_ob
+            import_xnalara_model.setBoneConnect(self.connectBones)
+        bpy.context.view_layer.objects.active = activeObj
+        return {'FINISHED'}
+
+
+class NewRestPose_Op(bpy.types.Operator):
+    bl_idname = 'xps_tools.new_rest_pose'
+    bl_label = 'New Rest Pose'
+    bl_description = 'Set Current Pose as The New Rest Pose'
+    bl_options = {"PRESET"}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.active_object and context.active_object.type == 'ARMATURE'
+                and bool(next((obj for obj in context.selected_objects if obj.type == 'MESH'), None)))
+
+    def action_common(self, context):
+        meshes_obs = filter(lambda obj: obj.type == 'MESH', context.selected_objects)
+        activeArmature = context.active_object
+        for obj in meshes_obs:
+            if (obj.find_armature() == activeArmature):
+                sourceModif = obj.modifiers[-1]
+                if (sourceModif and sourceModif.type == 'ARMATURE'):
+                    destModif = obj.modifiers.new(sourceModif.name, sourceModif.type)
+
+                    # collect names of writable properties
+                    properties = [p.identifier for p in destModif.bl_rna.properties
+                                  if not p.is_readonly]
+
+                    # copy those properties
+                    for prop in properties:
+                        setattr(destModif, prop, getattr(sourceModif, prop))
+
+                    print(destModif.name)
+                    bpy.context.view_layer.objects.active = obj
+                    bpy.ops.object.modifier_apply(modifier=destModif.name)
+
+        bpy.context.view_layer.objects.active = activeArmature
+        bpy.ops.object.mode_set(mode='POSE')
+        bpy.ops.pose.armature_apply()
+        bpy.ops.object.mode_set(mode='OBJECT')
+
+    def execute(self, context):
+        self.action_common(context)
+        return {"FINISHED"}
+
+    def invoke(self, context, event):
+        self.action_common(context)
+        return {"FINISHED"}

xnalara_io_Tools/xps_types.py

···
+from . import xps_const
+
+
+class XpsBone:
+
+    def __init__(self, id, name, co, parentId):
+        self.id = id
+        self.name = name
+        self.co = co
+        self.parentId = parentId
+
+# change name, too confusing
+
+
+class XpsBonePose:
+
+    def __init__(self, boneName, coordDelta, rotDelta, scale):
+        self.boneName = boneName
+        self.coordDelta = coordDelta
+        self.rotDelta = rotDelta
+        self.scale = scale
+
+
+class XpsMesh:
+
+    def __init__(self, name, textures, vertices, faces, uvCount):
+        self.name = name
+        self.textures = textures
+        self.vertices = vertices
+        self.faces = faces
+        self.uvCount = uvCount
+
+
+class BoneWeight:
+
+    def __init__(self, id, weight):
+        self.id = id
+        self.weight = weight
+
+
+class XpsVertex:
+
+    def __init__(self, id, co, norm, vColor, uv, boneWeights):
+        self.id = id
+        self.co = co
+        self.norm = norm
+        self.vColor = vColor
+        self.uv = uv
+        self.boneWeights = boneWeights
+        self.merged = False
+
+    def __copy__(self):
+        return XpsVertex(
+            self.id,
+            self.co[:],
+            self.norm[:],
+            self.vColor[:],
+            self.uv[:],
+            self.boneWeights
+        )
+
+# change file to filepath
+
+
+class XpsTexture:
+
+    def __init__(self, id, file, uvLayer):
+        self.id = id
+        self.file = file
+        self.uvLayer = uvLayer
+
+# change type, to explicit typing
+
+
+class XpsData:
+
+    def __init__(self, header='', bones=[], meshes=[]):
+        self.header = header
+        self.bones = bones
+        self.meshes = meshes
+
+# rename to XPS file definition
+
+
+class XpsHeader:
+
+    def __init__(
+            self,
+            magic_number=xps_const.MAGIC_NUMBER,
+            version_mayor=xps_const.XPS_VERSION_MAYOR,
+            version_minor=xps_const.XPS_VERSION_MINOR,
+            xna_aral=xps_const.XNA_ARAL,
+            settingsLen=xps_const.STRLEN,
+            machine='',
+            user='',
+            files='',
+            settings='',
+            pose=''):
+        self.magic_number = magic_number
+        self.version_mayor = version_mayor
+        self.version_minor = version_minor
+        self.xna_aral = xna_aral
+        self.settingsLen = settingsLen
+        self.machine = machine
+        self.user = user
+        self.files = files
+        self.settings = settings
+        self.pose = pose
+
+
+class XpsImportSettings:
+
+    def __init__(
+            self,
+            filename,
+            uvDisplX,
+            uvDisplY,
+            importDefaultPose,
+            joinMeshRips,
+            joinMeshParts,
+            markSeams,
+            vColors,
+            connectBones,
+            autoIk,
+            importNormals,
+            separate_optional_objects):
+        self.filename = filename
+        self.uvDisplX = uvDisplX
+        self.uvDisplY = uvDisplY
+        self.importDefaultPose = importDefaultPose
+        self.joinMeshRips = joinMeshRips
+        self.joinMeshParts = joinMeshParts
+        self.markSeams = markSeams
+        self.vColors = vColors
+        self.connectBones = connectBones
+        self.autoIk = autoIk
+        self.importNormals = importNormals
+        self.separate_optional_objects = separate_optional_objects
+
+
+class XpsExportSettings:
+
+    def __init__(
+            self,
+            filename,
+            format,
+            uvDisplX,
+            uvDisplY,
+            exportOnlySelected,
+            expDefPose,
+            preserveSeams,
+            vColors,
+            exportNormals,
+            versionMayor,
+            versionMinor):
+        self.filename = filename
+        self.format = format
+        self.uvDisplX = uvDisplX
+        self.uvDisplY = uvDisplY
+        self.exportOnlySelected = exportOnlySelected
+        self.expDefPose = expDefPose
+        self.preserveSeams = preserveSeams
+        self.vColors = vColors
+        self.exportNormals = exportNormals
+        self.versionMayor = versionMayor
+        self.versionMinor = versionMinor