restored repo after bug-induced push from 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

README.md

···
-# XPS Tools 
-
-ℹ️NOTE: <br>
-**THERE IS ONLY ONE RELEASE <br>
-IT'S DATE DOES NOT REFLECT THE VERSION AND FILES ARE BEING UPDATED OVER IT TO KEEP LINK INTEGRITY OUTSIDE OF GITHUB**
-
-
-### Patched and improved to support 3.6 - 4.5 <br>
-**[ The Original version has been fully discontinued by it's developer ]** <br>
-**[Only Blender Releases are supported, alpha/beta versions of Blender are not and will not be supported]**
-
-<br>
-
-Check out [Issues](https://github.com/Valerie-Bosco/XNALara-io-Tools/issues) and [Discussions](https://github.com/Valerie-Bosco/XNALara-io-Tools/discussions) for bug reports or feedback/feature requests <br>
-Discord Server: https://discord.gg/44fSbYrzZd
-
-<br>
+# [ALX - Addon Updater]
 
-### Installation:
-- Download the [XNALara-io-Tools.zip ](https://github.com/Valerie-Bosco/XNALara-io-Tools/releases/download/main_branch_latest/XNALara-io-Tools.zip) available from the [releases](https://github.com/Valerie-Bosco/XNALara-io-Tools/releases/tag/main_branch_latest) page, 
-- In blender [4.1-]: preferences -> addons -> install addon -> select the [XNALara-io-Tools.zip] -> click install 
-- In blender [4.2+]: preferences -> addons -> top right dropdown -> install from disk -> select the [XNALara-io-Tools.zip] -> click install from disk
+Forked from CG-Cookie's original addon-updater
 
-<br>
-
-### Features:
-- Import/Export for XPS/XNALara:
-  - meshes and skeletons
-  - animations and poses
-  - meshes with custom normals
-  - override skeletons rest pose
-
-- Automatic On Import for XPS/XNALara:
-  - mesh materials will be translated into blender materials
-
-- New Features:
-  - repaired the addon updater **|** re-written functionality to work again and be less error prone
-  - repaired armature import/export **|** now bones keep the correct structure
-  - repaired material import **|** now material code uses the correct api calls based on the blender version it's running in
-  - added import setting **|** split objects marked as optional into their own collection `model_name_here | OPTIONAL`
-  
-### Feedback:
-for any feedback you can create an issue with one of these three tags `feedback` | `improvement` | `feature request`
-
-### Language:
-Adicionalmente, lo idioma español es permitido para reportar problemas y para pedir mejoramientos
+Supported Blender versions by the system [ 4.0/4.1/4.2/4.3/4.4 ]

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/ALXAddonUpdater/ALX_AddonUpdater.py ALXAddonUpdater/ALX_AddonUpdater.py

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

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