Updated the README

For some reason this breaks compatibility with Blender 2.92

.github/FUNDING.yml

@@ -0,0 +1 @@
+ko_fi: cmbasnett

README.md

@@ -1,4 +1,13 @@
-This Blender add-on allows you to import and export meshes and animations to the [PSK and PSA file formats](https://wiki.beyondunreal.com/PSK_%26_PSA_file_formats).
+This Blender 2.80+ add-on allows you to import and export meshes and animations to and from the [PSK and PSA file formats](https://wiki.beyondunreal.com/PSK_%26_PSA_file_formats) used in many version of the Unreal Engine.
+
+# Features
+* Full PSK/PSA import and export capabilities
+* Non-standard PSKX file format with vertex normals, extra UV channels and vertex colors is supported for import only
+* Fine-grained PSA sequence importing for efficient workflow when working with large PSA files
+* Automatic keyframe reduction on PSA import
+* PSA sequence metadata (e.g., frame rate, sequence name) is preserved on import, allowing this data to be reused on export
+* Specific [bone groups](https://docs.blender.org/manual/en/latest/animation/armatures/properties/bone_groups.html) can be excluded from PSK/PSA export (useful for excluding non-contributing bones such as IK controllers)
+* PSA sequences can be exported directly from actions or delineated using a scene's [timeline markers](https://docs.blender.org/manual/en/latest/animation/markers.html), allowing direct use of the [NLA](https://docs.blender.org/manual/en/latest/editors/nla/index.html) when creating sequences 
 
 # Installation
 1. Download the zip file for the latest version from the [releases](https://github.com/DarklightGames/io_export_psk_psa/releases) page.
@@ -15,8 +24,8 @@ This Blender add-on allows you to import and export meshes and animations to the
 3. Navigate to File > Export > Unreal PSK (.psk)
 4. Enter the file name and click "Export".
 
-## Importing a PSK
+## Importing a PSK/PSKX
-1. Navigate to File > Import > Unreal PSK (.psk)
+1. Navigate to File > Import > Unreal PSK (.psk/.pskx)
 2. Select the PSK file you want to import and click "Import"
 
 ## Exporting a PSA
@@ -37,4 +46,4 @@ This Blender add-on allows you to import and export meshes and animations to the
 ## Why are the mesh normals not accurate when importing a PSK extracted from [UE Viewer](https://www.gildor.org/en/projects/umodel)?
 If preserving the mesh normals of models is important for your workflow, it is *not recommended* to export PSK files from UE Viewer. This is because UE Viewer makes no attempt to reconstruct the original [smoothing groups](https://en.wikipedia.org/wiki/Smoothing_group). As a result, the normals of imported PSK files will be incorrect when imported into Blender and will need to be manually fixed.
 
-As a workaround, it is recommended to export [glTF](https://en.wikipedia.org/wiki/GlTF) meshes out of UE Viewer instead, since the glTF format has support for explicit normals and UE Viewer can correctly preserve the mesh normals on export. Note, however, that the imported glTF armature may have it's bones oriented incorrectly when imported into blender. To mitigate this, you can combine the armature of PSK and the mesh of the glTF for best results.
+As a workaround, it is recommended to export [glTF](https://en.wikipedia.org/wiki/GlTF) meshes out of UE Viewer instead, since the glTF format has support for explicit normals and UE Viewer can correctly preserve the mesh normals on export. Note, however, that the imported glTF armature may have it's bones oriented incorrectly when imported into Blender. To mitigate this, you can combine the armature of PSK and the mesh of the glTF for best results.

io_scene_psk_psa/__init__.py

@@ -1,7 +1,7 @@
 bl_info = {
     "name": "PSK/PSA Importer/Exporter",
-    "author": "Colin Basnett",
+    "author": "Colin Basnett, Yurii Ti",
-    "version": (1, 2, 0),
+    "version": (4, 0, 0),
     "blender": (2, 80, 0),
     # "location": "File > Export > PSK Export (.psk)",
     "description": "PSK/PSA Import/Export (.psk/.psa)",
@@ -13,6 +13,7 @@ bl_info = {
 
 if 'bpy' in locals():
     import importlib
+
     importlib.reload(psx_data)
     importlib.reload(psx_helpers)
     importlib.reload(psx_types)
@@ -42,15 +43,14 @@ else:
     from .psa import reader as psa_reader
     from .psa import importer as psa_importer
 
-
 import bpy
 from bpy.props import PointerProperty
 
-classes = psx_types.__classes__ + \
+classes = (psx_types.classes +
-          psk_importer.__classes__ + \
+           psk_importer.classes +
-          psk_exporter.__classes__ + \
+           psk_exporter.classes +
-          psa_exporter.__classes__ + \
+           psa_exporter.classes +
-          psa_importer.__classes__
+           psa_importer.classes)
 
 
 def psk_export_menu_func(self, context):
@@ -58,7 +58,7 @@ def psk_export_menu_func(self, context):
 
 
 def psk_import_menu_func(self, context):
-    self.layout.operator(psk_importer.PskImportOperator.bl_idname, text='Unreal PSK (.psk)')
+    self.layout.operator(psk_importer.PskImportOperator.bl_idname, text='Unreal PSK (.psk/.pskx)')
 
 
 def psa_export_menu_func(self, context):
@@ -72,13 +72,16 @@ def register():
     bpy.types.TOPBAR_MT_file_import.append(psk_import_menu_func)
     bpy.types.TOPBAR_MT_file_export.append(psa_export_menu_func)
     bpy.types.Scene.psa_import = PointerProperty(type=psa_importer.PsaImportPropertyGroup)
+    bpy.types.Scene.psk_import = PointerProperty(type=psk_importer.PskImportPropertyGroup)
     bpy.types.Scene.psa_export = PointerProperty(type=psa_exporter.PsaExportPropertyGroup)
     bpy.types.Scene.psk_export = PointerProperty(type=psk_exporter.PskExportPropertyGroup)
 
 
 def unregister():
-    del bpy.types.Scene.psa_export
     del bpy.types.Scene.psa_import
+    del bpy.types.Scene.psk_import
+    del bpy.types.Scene.psa_export
+    del bpy.types.Scene.psk_export
     bpy.types.TOPBAR_MT_file_export.remove(psk_export_menu_func)
     bpy.types.TOPBAR_MT_file_import.remove(psk_import_menu_func)
     bpy.types.TOPBAR_MT_file_export.remove(psa_export_menu_func)

io_scene_psk_psa/data.py

@@ -1,4 +1,43 @@
 from ctypes import *
+from typing import Tuple
+
+
+class Color(Structure):
+    _fields_ = [
+        ('r', c_ubyte),
+        ('g', c_ubyte),
+        ('b', c_ubyte),
+        ('a', c_ubyte),
+    ]
+
+    def __iter__(self):
+        yield self.r
+        yield self.g
+        yield self.b
+        yield self.a
+
+    def __eq__(self, other):
+        return all(map(lambda x: x[0] == x[1], zip(self, other)))
+
+    def __repr__(self):
+        return repr(tuple(self))
+
+    def normalized(self) -> Tuple:
+        return tuple(map(lambda x: x / 255.0, iter(self)))
+
+
+class Vector2(Structure):
+    _fields_ = [
+        ('x', c_float),
+        ('y', c_float),
+    ]
+
+    def __iter__(self):
+        yield self.x
+        yield self.y
+
+    def __repr__(self):
+        return repr(tuple(self))
 
 
 class Vector3(Structure):
@@ -16,6 +55,10 @@ class Vector3(Structure):
     def __repr__(self):
         return repr(tuple(self))
 
+    @classmethod
+    def zero(cls):
+        return Vector3(0, 0, 0)
+
 
 class Quaternion(Structure):
     _fields_ = [
@@ -34,6 +77,10 @@ class Quaternion(Structure):
     def __repr__(self):
         return repr(tuple(self))
 
+    @classmethod
+    def identity(cls):
+        return Quaternion(0, 0, 0, 1)
+
 
 class Section(Structure):
     _fields_ = [

io_scene_psk_psa/helpers.py

@@ -1,33 +1,114 @@
-from typing import List
+import datetime
+import re
+from collections import Counter
+from typing import List, Iterable
+
+import bpy.types
+from bpy.types import NlaStrip, Object
 
 
-def populate_bone_group_list(armature_object, bone_group_list):
+class Timer:
+    def __enter__(self):
+        self.start = datetime.datetime.now()
+        self.interval = None
+        return self
+
+    def __exit__(self, *args):
+        self.end = datetime.datetime.now()
+        self.interval = self.end - self.start
+
+    @property
+    def duration(self):
+        if self.interval is not None:
+            return self.interval
+        else:
+            return datetime.datetime.now() - self.start
+
+
+def rgb_to_srgb(c):
+    if c > 0.0031308:
+        return 1.055 * (pow(c, (1.0 / 2.4))) - 0.055
+    else:
+        return 12.92 * c
+
+
+def get_nla_strips_in_timeframe(animation_data, frame_min, frame_max) -> List[NlaStrip]:
+    if animation_data is None:
+        return []
+    strips = []
+    for nla_track in animation_data.nla_tracks:
+        if nla_track.mute:
+            continue
+        for strip in nla_track.strips:
+            if (strip.frame_start < frame_min and strip.frame_end > frame_max) or \
+                    (frame_min <= strip.frame_start < frame_max) or \
+                    (frame_min < strip.frame_end <= frame_max):
+                strips.append(strip)
+    return strips
+
+
+def populate_bone_group_list(armature_object: Object, bone_group_list: bpy.types.Collection) -> None:
+    """
+    Updates the bone group collection.
+
+    Bone group selections are preserved between updates unless none of the groups were previously selected;
+    otherwise, all groups are selected by default.
+    """
+    has_selected_groups = any([g.is_selected for g in bone_group_list])
+    unassigned_group_is_selected, selected_assigned_group_names = True, []
+
+    if has_selected_groups:
+        # Preserve group selections before clearing the list.
+        # We handle selections for the unassigned group separately to cover the edge case
+        # where there might be an actual group with 'Unassigned' as its name.
+        unassigned_group_idx, unassigned_group_is_selected = next(iter([
+            (i, g.is_selected) for i, g in enumerate(bone_group_list) if g.index == -1]), (-1, False))
+
+        selected_assigned_group_names = [
+            g.name for i, g in enumerate(bone_group_list) if i != unassigned_group_idx and g.is_selected]
+
     bone_group_list.clear()
 
-    item = bone_group_list.add()
-    item.name = '(unassigned)'
-    item.index = -1
-    item.is_selected = True
-
     if armature_object and armature_object.pose:
+        bone_group_counts = Counter(map(lambda x: x.bone_group, armature_object.pose.bones))
+
+        item = bone_group_list.add()
+        item.name = 'Unassigned'
+        item.index = -1
+        item.count = 0 if None not in bone_group_counts else bone_group_counts[None]
+        item.is_selected = unassigned_group_is_selected
+
         for bone_group_index, bone_group in enumerate(armature_object.pose.bone_groups):
             item = bone_group_list.add()
             item.name = bone_group.name
             item.index = bone_group_index
-            item.is_selected = True
+            item.count = 0 if bone_group not in bone_group_counts else bone_group_counts[bone_group]
+            item.is_selected = bone_group.name in selected_assigned_group_names if has_selected_groups else True
 
 
-def add_bone_groups_to_layout(layout):
+def get_psa_sequence_name(action, should_use_original_sequence_name):
-    pass
+    if should_use_original_sequence_name and 'psa_sequence_name' in action:
+        return action['psa_sequence_name']
+    else:
+        return action.name
 
 
-def get_export_bone_indices_for_bone_groups(armature_object, bone_group_indices: List[int]) -> List[int]:
+def check_bone_names(bone_names: Iterable[str]):
+    pattern = re.compile(r'^[a-zA-Z0-9_ ]+$')
+    invalid_bone_names = [x for x in bone_names if pattern.match(x) is None]
+    if len(invalid_bone_names) > 0:
+        raise RuntimeError(f'The following bone names are invalid: {invalid_bone_names}.\n'
+                           f'Bone names must only contain letters, numbers, spaces, and underscores.')
+
+
+def get_export_bone_names(armature_object, bone_filter_mode, bone_group_indices: List[int]) -> List[str]:
     """
-    Returns a sorted list of bone indices that should be exported for the given bone groups.
+    Returns a sorted list of bone indices that should be exported for the given bone filter mode and bone groups.
 
     Note that the ancestors of bones within the bone groups will also be present in the returned list.
 
     :param armature_object: Blender object with type 'ARMATURE'
+    :param bone_filter_mode: One of ['ALL', 'BONE_GROUPS']
     :param bone_group_indices: List of bone group indices to be exported.
     :return: A sorted list of bone indices that should be exported.
     """
@@ -38,24 +119,58 @@ def get_export_bone_indices_for_bone_groups(armature_object, bone_group_indices:
     pose_bones = armature_object.pose.bones
     bone_names = [x.name for x in bones]
 
-    # Get a list of the bone indices that are explicitly part of the bone groups we are including.
+    # Get a list of the bone indices that we are explicitly including.
     bone_index_stack = []
     is_exporting_none_bone_groups = -1 in bone_group_indices
     for bone_index, pose_bone in enumerate(pose_bones):
-        if (pose_bone.bone_group is None and is_exporting_none_bone_groups) or \
+        if bone_filter_mode == 'ALL' or \
+                (pose_bone.bone_group is None and is_exporting_none_bone_groups) or \
                 (pose_bone.bone_group is not None and pose_bone.bone_group_index in bone_group_indices):
-            bone_index_stack.append(bone_index)
+            bone_index_stack.append((bone_index, None))
 
     # For each bone that is explicitly being added, recursively walk up the hierarchy and ensure that all of
     # those ancestor bone indices are also in the list.
-    bone_indices = set()
+    bone_indices = dict()
     while len(bone_index_stack) > 0:
-        bone_index = bone_index_stack.pop()
+        bone_index, instigator_bone_index = bone_index_stack.pop()
         bone = bones[bone_index]
         if bone.parent is not None:
             parent_bone_index = bone_names.index(bone.parent.name)
             if parent_bone_index not in bone_indices:
-                bone_index_stack.append(parent_bone_index)
+                bone_index_stack.append((parent_bone_index, bone_index))
-        bone_indices.add(bone_index)
+        bone_indices[bone_index] = instigator_bone_index
 
-    return list(sorted(list(bone_indices)))
+    # Sort the bone index list in-place.
+    bone_indices = [(x[0], x[1]) for x in bone_indices.items()]
+    bone_indices.sort(key=lambda x: x[0])
+
+    # Split out the bone indices and the instigator bone names into separate lists.
+    # We use the bone names for the return values because the bone name is a more universal way of referencing them.
+    # For example, users of this function may modify bone lists, which would invalidate the indices and require a
+    # index mapping scheme to resolve it. Using strings is more comfy and results in less code downstream.
+    instigator_bone_names = [bones[x[1]].name if x[1] is not None else None for x in bone_indices]
+    bone_names = [bones[x[0]].name for x in bone_indices]
+
+    # Ensure that the hierarchy we are sending back has a single root bone.
+    bone_indices = [x[0] for x in bone_indices]
+    root_bones = [bones[bone_index] for bone_index in bone_indices if bones[bone_index].parent is None]
+    if len(root_bones) > 1:
+        # There is more than one root bone.
+        # Print out why each root bone was included by linking it to one of the explicitly included bones.
+        root_bone_names = [bone.name for bone in root_bones]
+        for root_bone_name in root_bone_names:
+            bone_name = root_bone_name
+            while True:
+                # Traverse the instigator chain until the end to find the true instigator bone.
+                # TODO: in future, it would be preferential to have a readout of *all* instigator bones.
+                instigator_bone_name = instigator_bone_names[bone_names.index(bone_name)]
+                if instigator_bone_name is None:
+                    print(f'Root bone "{root_bone_name}" was included because {bone_name} was marked for export')
+                    break
+                bone_name = instigator_bone_name
+
+        raise RuntimeError('Exported bone hierarchy must have a single root bone.\n'
+                           f'The bone hierarchy marked for export has {len(root_bones)} root bones: {root_bone_names}.\n'
+                           f'Additional debugging information has been written to the console.')
+
+    return bone_names

io_scene_psk_psa/psa/builder.py

@@ -1,153 +1,283 @@
+from typing import Dict
+
+from bpy.types import Action
+
 from .data import *
 from ..helpers import *
 
 
-class PsaBuilderOptions(object):
+class PsaBuildOptions(object):
     def __init__(self):
+        self.should_override_animation_data = False
+        self.animation_data_override = None
+        self.fps_source = 'SCENE'
+        self.fps_custom = 30.0
+        self.sequence_source = 'ACTIONS'
         self.actions = []
+        self.marker_names = []
         self.bone_filter_mode = 'ALL'
         self.bone_group_indices = []
+        self.should_use_original_sequence_names = False
+        self.should_trim_timeline_marker_sequences = True
+        self.sequence_name_prefix = ''
+        self.sequence_name_suffix = ''
+        self.root_motion = False
 
 
-class PsaBuilder(object):
+def get_sequence_fps(context, options: PsaBuildOptions, actions: Iterable[Action]) -> float:
-    def __init__(self):
+    if options.fps_source == 'SCENE':
-        pass
+        return context.scene.render.fps
+    if options.fps_source == 'CUSTOM':
+        return options.fps_custom
+    elif options.fps_source == 'ACTION_METADATA':
+        # Get the minimum value of action metadata FPS values.
+        fps_list = []
+        for action in filter(lambda x: 'psa_sequence_fps' in x, actions):
+            fps = action['psa_sequence_fps']
+            if type(fps) == int or type(fps) == float:
+                fps_list.append(fps)
+        if len(fps_list) > 0:
+            return min(fps_list)
+        else:
+            # No valid action metadata to use, fallback to scene FPS
+            return context.scene.render.fps
+    else:
+        raise RuntimeError(f'Invalid FPS source "{options.fps_source}"')
 
-    def build(self, context, options: PsaBuilderOptions) -> Psa:
-        object = context.view_layer.objects.active
 
-        if object.type != 'ARMATURE':
+def get_timeline_marker_sequence_frame_ranges(animation_data, context, options: PsaBuildOptions) -> Dict:
-            raise RuntimeError('Selected object must be an Armature')
+    # Timeline markers need to be sorted so that we can determine the sequence start and end positions.
+    sequence_frame_ranges = dict()
+    sorted_timeline_markers = list(sorted(context.scene.timeline_markers, key=lambda x: x.frame))
+    sorted_timeline_marker_names = list(map(lambda x: x.name, sorted_timeline_markers))
 
-        armature = object
+    for marker_name in options.marker_names:
+        marker = context.scene.timeline_markers[marker_name]
+        frame_min = marker.frame
+        # Determine the final frame of the sequence based on the next marker.
+        # If no subsequent marker exists, use the maximum frame_end from all NLA strips.
+        marker_index = sorted_timeline_marker_names.index(marker_name)
+        next_marker_index = marker_index + 1
+        frame_max = 0
+        if next_marker_index < len(sorted_timeline_markers):
+            # There is a next marker. Use that next marker's frame position as the last frame of this sequence.
+            frame_max = sorted_timeline_markers[next_marker_index].frame
+            if options.should_trim_timeline_marker_sequences:
+                nla_strips = get_nla_strips_in_timeframe(animation_data, marker.frame, frame_max)
+                if len(nla_strips) > 0:
+                    frame_max = min(frame_max, max(map(lambda nla_strip: nla_strip.frame_end, nla_strips)))
+                    frame_min = max(frame_min, min(map(lambda nla_strip: nla_strip.frame_start, nla_strips)))
+                else:
+                    # No strips in between this marker and the next, just export this as a one-frame animation.
+                    frame_max = frame_min
+        else:
+            # There is no next marker.
+            # Find the final frame of all the NLA strips and use that as the last frame of this sequence.
+            for nla_track in animation_data.nla_tracks:
+                if nla_track.mute:
+                    continue
+                for strip in nla_track.strips:
+                    frame_max = max(frame_max, strip.frame_end)
 
-        if armature.animation_data is None:
+        if frame_min > frame_max:
-            raise RuntimeError('No animation data for armature')
+            continue
 
-        psa = Psa()
+        sequence_frame_ranges[marker_name] = int(frame_min), int(frame_max)
 
-        bones = list(armature.data.bones)
+    return sequence_frame_ranges
 
-        # The order of the armature bones and the pose bones is not guaranteed to be the same.
-        # As as a result, we need to reconstruct the list of pose bones in the same order as the
-        # armature bones.
-        bone_names = [x.name for x in bones]
-        pose_bones = [(bone_names.index(bone.name), bone) for bone in armature.pose.bones]
-        del bone_names
-        pose_bones.sort(key=lambda x: x[0])
-        pose_bones = [x[1] for x in pose_bones]
 
-        bone_indices = list(range(len(bones)))
+def build_psa(context, options: PsaBuildOptions) -> Psa:
+    active_object = context.view_layer.objects.active
 
-        # If bone groups are specified, get only the bones that are in that specified bone groups and their ancestors.
+    if active_object.type != 'ARMATURE':
-        if options.bone_filter_mode == 'BONE_GROUPS':
+        raise RuntimeError('Selected object must be an Armature')
-            bone_indices = get_export_bone_indices_for_bone_groups(armature, options.bone_group_indices)
 
-        # Make the bone lists contain only the bones that are going to be exported.
+    if options.should_override_animation_data:
-        bones = [bones[bone_index] for bone_index in bone_indices]
+        animation_data_object = options.animation_data_override
-        pose_bones = [pose_bones[bone_index] for bone_index in bone_indices]
+    else:
+        animation_data_object = active_object
 
-        if len(bones) == 0:
+    animation_data = animation_data_object.animation_data
-            # No bones are going to be exported.
-            raise RuntimeError('No bones available for export')
 
-        # Ensure that the exported hierarchy has a single root bone.
+    if animation_data is None:
-        root_bones = [x for x in bones if x.parent is None]
+        raise RuntimeError(f'No animation data for object \'{animation_data_object.name}\'')
-        if len(root_bones) > 1:
-            root_bone_names = [x.name for x in bones]
-            raise RuntimeError('Exported bone hierarchy must have a single root bone.'
-                               f'The bone hierarchy marked for export has {len(root_bones)} root bones: {root_bone_names}')
 
-        for pose_bone in bones:
+    # Ensure that we actually have items that we are going to be exporting.
-            psa_bone = Psa.Bone()
+    if options.sequence_source == 'ACTIONS' and len(options.actions) == 0:
-            psa_bone.name = bytes(pose_bone.name, encoding='utf-8')
+        raise RuntimeError('No actions were selected for export')
+    elif options.sequence_source == 'TIMELINE_MARKERS' and len(options.marker_names) == 0:
+        raise RuntimeError('No timeline markers were selected for export')
 
-            try:
+    psa = Psa()
-                parent_index = bones.index(pose_bone.parent)
-                psa_bone.parent_index = parent_index
-                psa.bones[parent_index].children_count += 1
-            except ValueError:
-                psa_bone.parent_index = -1
 
-            if pose_bone.parent is not None:
+    armature = active_object
-                rotation = pose_bone.matrix.to_quaternion()
+    bones = list(armature.data.bones)
-                rotation.x = -rotation.x
-                rotation.y = -rotation.y
-                rotation.z = -rotation.z
-                quat_parent = pose_bone.parent.matrix.to_quaternion().inverted()
-                parent_head = quat_parent @ pose_bone.parent.head
-                parent_tail = quat_parent @ pose_bone.parent.tail
-                location = (parent_tail - parent_head) + pose_bone.head
-            else:
-                location = armature.matrix_local @ pose_bone.head
-                rot_matrix = pose_bone.matrix @ armature.matrix_local.to_3x3()
-                rotation = rot_matrix.to_quaternion()
 
-            psa_bone.location.x = location.x
+    # The order of the armature bones and the pose bones is not guaranteed to be the same.
-            psa_bone.location.y = location.y
+    # As a result, we need to reconstruct the list of pose bones in the same order as the
-            psa_bone.location.z = location.z
+    # armature bones.
+    bone_names = [x.name for x in bones]
+    pose_bones = [(bone_names.index(bone.name), bone) for bone in armature.pose.bones]
+    pose_bones.sort(key=lambda x: x[0])
+    pose_bones = [x[1] for x in pose_bones]
 
-            psa_bone.rotation.x = rotation.x
+    # Get a list of all the bone indices and instigator bones for the bone filter settings.
-            psa_bone.rotation.y = rotation.y
+    export_bone_names = get_export_bone_names(armature, options.bone_filter_mode, options.bone_group_indices)
-            psa_bone.rotation.z = rotation.z
+    bone_indices = [bone_names.index(x) for x in export_bone_names]
-            psa_bone.rotation.w = rotation.w
 
-            psa.bones.append(psa_bone)
+    # Make the bone lists contain only the bones that are going to be exported.
+    bones = [bones[bone_index] for bone_index in bone_indices]
+    pose_bones = [pose_bones[bone_index] for bone_index in bone_indices]
 
-        frame_start_index = 0
+    # No bones are going to be exported.
+    if len(bones) == 0:
+        raise RuntimeError('No bones available for export')
 
+    # Check that all bone names are valid.
+    check_bone_names(map(lambda bone: bone.name, bones))
+
+    # Build list of PSA bones.
+    for bone in bones:
+        psa_bone = Psa.Bone()
+        psa_bone.name = bytes(bone.name, encoding='windows-1252')
+
+        try:
+            parent_index = bones.index(bone.parent)
+            psa_bone.parent_index = parent_index
+            psa.bones[parent_index].children_count += 1
+        except ValueError:
+            psa_bone.parent_index = -1
+
+        if bone.parent is not None:
+            rotation = bone.matrix.to_quaternion().conjugated()
+            inverse_parent_rotation = bone.parent.matrix.to_quaternion().inverted()
+            parent_head = inverse_parent_rotation @ bone.parent.head
+            parent_tail = inverse_parent_rotation @ bone.parent.tail
+            location = (parent_tail - parent_head) + bone.head
+        else:
+            location = armature.matrix_local @ bone.head
+            rot_matrix = bone.matrix @ armature.matrix_local.to_3x3()
+            rotation = rot_matrix.to_quaternion()
+
+        psa_bone.location.x = location.x
+        psa_bone.location.y = location.y
+        psa_bone.location.z = location.z
+
+        psa_bone.rotation.x = rotation.x
+        psa_bone.rotation.y = rotation.y
+        psa_bone.rotation.z = rotation.z
+        psa_bone.rotation.w = rotation.w
+
+        psa.bones.append(psa_bone)
+
+    # Populate the export sequence list.
+    class NlaState:
+        def __init__(self):
+            self.frame_min = 0
+            self.frame_max = 0
+            self.action = None
+
+    class ExportSequence:
+        def __init__(self):
+            self.name = ''
+            self.nla_state = NlaState()
+            self.fps = 30.0
+
+    export_sequences = []
+
+    if options.sequence_source == 'ACTIONS':
         for action in options.actions:
             if len(action.fcurves) == 0:
                 continue
-
+            export_sequence = ExportSequence()
-            armature.animation_data.action = action
+            export_sequence.nla_state.action = action
-            context.view_layer.update()
+            export_sequence.name = get_psa_sequence_name(action, options.should_use_original_sequence_names)
-
             frame_min, frame_max = [int(x) for x in action.frame_range]
+            export_sequence.nla_state.frame_min = frame_min
+            export_sequence.nla_state.frame_max = frame_max
+            export_sequence.fps = get_sequence_fps(context, options, [action])
+            export_sequences.append(export_sequence)
+        pass
+    elif options.sequence_source == 'TIMELINE_MARKERS':
+        sequence_frame_ranges = get_timeline_marker_sequence_frame_ranges(animation_data, context, options)
 
-            sequence = Psa.Sequence()
+        for name, (frame_min, frame_max) in sequence_frame_ranges.items():
-            sequence.name = bytes(action.name, encoding='utf-8')
+            export_sequence = ExportSequence()
-            sequence.frame_count = frame_max - frame_min + 1
+            export_sequence.name = name
-            sequence.frame_start_index = frame_start_index
+            export_sequence.nla_state.action = None
-            sequence.fps = context.scene.render.fps
+            export_sequence.nla_state.frame_min = frame_min
+            export_sequence.nla_state.frame_max = frame_max
+            nla_strips_actions = set(
+                map(lambda x: x.action, get_nla_strips_in_timeframe(animation_data, frame_min, frame_max)))
+            export_sequence.fps = get_sequence_fps(context, options, nla_strips_actions)
+            export_sequences.append(export_sequence)
+    else:
+        raise ValueError(f'Unhandled sequence source: {options.sequence_source}')
 
-            frame_count = frame_max - frame_min + 1
+    # Add prefixes and suffices to the names of the export sequences and strip whitespace.
+    for export_sequence in export_sequences:
+        export_sequence.name = f'{options.sequence_name_prefix}{export_sequence.name}{options.sequence_name_suffix}'
+        export_sequence.name = export_sequence.name.strip()
 
-            for frame in range(frame_count):
+    # Now build the PSA sequences.
-                context.scene.frame_set(frame_min + frame)
+    # We actually alter the timeline frame and simply record the resultant pose bone matrices.
+    frame_start_index = 0
 
-                for pose_bone in pose_bones:
+    for export_sequence in export_sequences:
-                    key = Psa.Key()
+        # Link the action to the animation data and update view layer.
+        animation_data.action = export_sequence.nla_state.action
+        context.view_layer.update()
+
+        frame_min = export_sequence.nla_state.frame_min
+        frame_max = export_sequence.nla_state.frame_max
+        frame_count = frame_max - frame_min + 1
+
+        psa_sequence = Psa.Sequence()
+        psa_sequence.name = bytes(export_sequence.name, encoding='windows-1252')
+        psa_sequence.frame_count = frame_count
+        psa_sequence.frame_start_index = frame_start_index
+        psa_sequence.fps = export_sequence.fps
+
+        for frame in range(frame_count):
+            context.scene.frame_set(frame_min + frame)
+
+            for pose_bone in pose_bones:
+                key = Psa.Key()
+
+                if pose_bone.parent is not None:
                     pose_bone_matrix = pose_bone.matrix
+                    pose_bone_parent_matrix = pose_bone.parent.matrix
+                    pose_bone_matrix = pose_bone_parent_matrix.inverted() @ pose_bone_matrix
+                else:
+                    if options.root_motion:
+                        # Export root motion
+                        pose_bone_matrix = armature.matrix_world @ pose_bone.matrix
+                    else:
+                        pose_bone_matrix = pose_bone.matrix
 
-                    if pose_bone.parent is not None:
+                location = pose_bone_matrix.to_translation()
-                        pose_bone_parent_matrix = pose_bone.parent.matrix
+                rotation = pose_bone_matrix.to_quaternion().normalized()
-                        pose_bone_matrix = pose_bone_parent_matrix.inverted() @ pose_bone_matrix
 
-                    location = pose_bone_matrix.to_translation()
+                if pose_bone.parent is not None:
-                    rotation = pose_bone_matrix.to_quaternion().normalized()
+                    rotation.conjugate()
 
-                    if pose_bone.parent is not None:
+                key.location.x = location.x
-                        rotation.x = -rotation.x
+                key.location.y = location.y
-                        rotation.y = -rotation.y
+                key.location.z = location.z
-                        rotation.z = -rotation.z
+                key.rotation.x = rotation.x
+                key.rotation.y = rotation.y
+                key.rotation.z = rotation.z
+                key.rotation.w = rotation.w
+                key.time = 1.0 / psa_sequence.fps
 
-                    key.location.x = location.x
+                psa.keys.append(key)
-                    key.location.y = location.y
-                    key.location.z = location.z
-                    key.rotation.x = rotation.x
-                    key.rotation.y = rotation.y
-                    key.rotation.z = rotation.z
-                    key.rotation.w = rotation.w
-                    key.time = 1.0 / sequence.fps
 
-                    psa.keys.append(key)
+            psa_sequence.bone_count = len(pose_bones)
+            psa_sequence.track_time = frame_count
 
-                frame_start_index += 1
+        frame_start_index += frame_count
 
-                sequence.bone_count = len(pose_bones)
+        psa.sequences[export_sequence.name] = psa_sequence
-                sequence.track_time = frame_count
 
-            psa.sequences[action.name] = sequence
+    return psa
-
-        return psa

io_scene_psk_psa/psa/data.py

@@ -1,6 +1,7 @@
 import typing
-from typing import List
 from collections import OrderedDict
+from typing import List
+
 from ..data import *
 
 """

io_scene_psk_psa/psa/exporter.py

@@ -1,67 +1,163 @@
-import bpy
+import fnmatch
-from bpy.types import Operator, PropertyGroup, Action, UIList, BoneGroup
+import sys
-from bpy.props import CollectionProperty, IntProperty, PointerProperty, StringProperty, BoolProperty, EnumProperty
-from bpy_extras.io_utils import ExportHelper
 from typing import Type
-from .builder import PsaBuilder, PsaBuilderOptions
+
+import bpy
+from bpy.props import BoolProperty, CollectionProperty, EnumProperty, FloatProperty, IntProperty, PointerProperty, \
+    StringProperty
+from bpy.types import Action, Operator, PropertyGroup, UIList
+from bpy_extras.io_utils import ExportHelper
+
+from .builder import PsaBuildOptions, build_psa
 from .data import *
-from ..types import BoneGroupListItem
 from ..helpers import *
-import re
+from ..types import BoneGroupListItem
 
 
-class PsaExporter(object):
+def write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None):
-    def __init__(self, psa: Psa):
+    section = Section()
-        self.psa: Psa = psa
+    section.name = name
+    if data_type is not None and data is not None:
+        section.data_size = sizeof(data_type)
+        section.data_count = len(data)
+    fp.write(section)
+    if data is not None:
+        for datum in data:
+            fp.write(datum)
 
-    # This method is shared by both PSA/K file formats, move this?
-    @staticmethod
-    def write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None):
-        section = Section()
-        section.name = name
-        if data_type is not None and data is not None:
-            section.data_size = sizeof(data_type)
-            section.data_count = len(data)
-        fp.write(section)
-        if data is not None:
-            for datum in data:
-                fp.write(datum)
 
-    def export(self, path: str):
+def export_psa(psa: Psa, path: str):
-        with open(path, 'wb') as fp:
+    with open(path, 'wb') as fp:
-            self.write_section(fp, b'ANIMHEAD')
+        write_section(fp, b'ANIMHEAD')
-            self.write_section(fp, b'BONENAMES', Psa.Bone, self.psa.bones)
+        write_section(fp, b'BONENAMES', Psa.Bone, psa.bones)
-            self.write_section(fp, b'ANIMINFO', Psa.Sequence, list(self.psa.sequences.values()))
+        write_section(fp, b'ANIMINFO', Psa.Sequence, list(psa.sequences.values()))
-            self.write_section(fp, b'ANIMKEYS', Psa.Key, self.psa.keys)
+        write_section(fp, b'ANIMKEYS', Psa.Key, psa.keys)
 
 
 class PsaExportActionListItem(PropertyGroup):
     action: PointerProperty(type=Action)
-    action_name: StringProperty()
+    name: StringProperty()
     is_selected: BoolProperty(default=False)
 
-    @property
+
-    def name(self):
+class PsaExportTimelineMarkerListItem(PropertyGroup):
-        return self.action.name
+    marker_index: IntProperty()
+    name: StringProperty()
+    is_selected: BoolProperty(default=True)
+
+
+def update_action_names(context):
+    pg = context.scene.psa_export
+    for item in pg.action_list:
+        action = item.action
+        item.action_name = get_psa_sequence_name(action, pg.should_use_original_sequence_names)
+
+
+def should_use_original_sequence_names_updated(_, context):
+    update_action_names(context)
+
+
+def psa_export_property_group_animation_data_override_poll(_context, obj):
+    return obj.animation_data is not None
+
+
+empty_set = set()
 
 
 class PsaExportPropertyGroup(PropertyGroup):
+    root_motion: BoolProperty(
+        name='Root Motion',
+        options=empty_set,
+        default=False,
+        description='The root bone will be transformed as it appears in the scene',
+    )
+    should_override_animation_data: BoolProperty(
+        name='Override Animation Data',
+        options=empty_set,
+        default=False,
+        description='Use the animation data from a different object instead of the selected object'
+    )
+    animation_data_override: PointerProperty(
+        type=bpy.types.Object,
+        poll=psa_export_property_group_animation_data_override_poll
+    )
+    sequence_source: EnumProperty(
+        name='Source',
+        options=empty_set,
+        description='',
+        items=(
+            ('ACTIONS', 'Actions', 'Sequences will be exported using actions', 'ACTION', 0),
+            ('TIMELINE_MARKERS', 'Timeline Markers', 'Sequences will be exported using timeline markers', 'MARKER_HLT',
+             1),
+        )
+    )
+    fps_source: EnumProperty(
+        name='FPS Source',
+        options=empty_set,
+        description='',
+        items=(
+            ('SCENE', 'Scene', '', 'SCENE_DATA', 0),
+            ('ACTION_METADATA', 'Action Metadata',
+             'The frame rate will be determined by action\'s "psa_sequence_fps" custom property, if it exists. If the Sequence Source is Timeline Markers, the lowest value of all contributing actions will be used. If no metadata is available, the scene\'s frame rate will be used.',
+             'PROPERTIES', 1),
+            ('CUSTOM', 'Custom', '', 2)
+        )
+    )
+    fps_custom: FloatProperty(default=30.0, min=sys.float_info.epsilon, soft_min=1.0, options=empty_set, step=100,
+                              soft_max=60.0)
     action_list: CollectionProperty(type=PsaExportActionListItem)
     action_list_index: IntProperty(default=0)
+    marker_list: CollectionProperty(type=PsaExportTimelineMarkerListItem)
+    marker_list_index: IntProperty(default=0)
     bone_filter_mode: EnumProperty(
         name='Bone Filter',
+        options=empty_set,
         description='',
         items=(
             ('ALL', 'All', 'All bones will be exported.'),
-            ('BONE_GROUPS', 'Bone Groups', 'Only bones belonging to the selected bone groups and their ancestors will be exported.')
+            ('BONE_GROUPS', 'Bone Groups', 'Only bones belonging to the selected bone groups and their ancestors will '
+                                           'be exported.'),
         )
     )
     bone_group_list: CollectionProperty(type=BoneGroupListItem)
-    bone_group_list_index: IntProperty(default=0)
+    bone_group_list_index: IntProperty(default=0, name='', description='')
+    should_use_original_sequence_names: BoolProperty(
+        default=False,
+        name='Original Names',
+        options=empty_set,
+        update=should_use_original_sequence_names_updated,
+        description='If the action was imported from the PSA Import panel, the original name of the sequence will be '
+                    'used instead of the Blender action name',
+    )
+    should_trim_timeline_marker_sequences: BoolProperty(
+        default=True,
+        name='Trim Sequences',
+        options=empty_set,
+        description='Frames without NLA track information at the boundaries of timeline markers will be excluded from '
+                    'the exported sequences '
+    )
+    sequence_name_prefix: StringProperty(name='Prefix', options=empty_set)
+    sequence_name_suffix: StringProperty(name='Suffix', options=empty_set)
+    sequence_filter_name: StringProperty(
+        default='',
+        name='Filter by Name',
+        options={'TEXTEDIT_UPDATE'},
+        description='Only show items matching this name (use \'*\' as wildcard)')
+    sequence_use_filter_invert: BoolProperty(
+        default=False,
+        name='Invert',
+        options=empty_set,
+        description='Invert filtering (show hidden items, and vice versa)')
+    sequence_filter_asset: BoolProperty(
+        default=False,
+        name='Show assets',
+        options=empty_set,
+        description='Show actions that belong to an asset library')
+    sequence_use_filter_sort_reverse: BoolProperty(default=True, options=empty_set)
 
 
 def is_bone_filter_mode_item_available(context, identifier):
-    if identifier == "BONE_GROUPS":
+    if identifier == 'BONE_GROUPS':
         obj = context.active_object
         if not obj.pose or not obj.pose.bone_groups:
             return False
@@ -69,8 +165,9 @@ def is_bone_filter_mode_item_available(context, identifier):
 
 
 class PsaExportOperator(Operator, ExportHelper):
-    bl_idname = 'export.psa'
+    bl_idname = 'psa_export.operator'
     bl_label = 'Export'
+    bl_options = {'INTERNAL', 'UNDO'}
     __doc__ = 'Export actions to PSA'
     filename_ext = '.psa'
     filter_glob: StringProperty(default='*.psa', options={'HIDDEN'})
@@ -83,43 +180,99 @@ class PsaExportOperator(Operator, ExportHelper):
     def __init__(self):
         self.armature = None
 
+    @classmethod
+    def poll(cls, context):
+        try:
+            cls._check_context(context)
+        except RuntimeError as e:
+            cls.poll_message_set(str(e))
+            return False
+        return True
+
     def draw(self, context):
         layout = self.layout
-        property_group = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
+
+        # FPS
+        layout.prop(pg, 'fps_source', text='FPS')
+        if pg.fps_source == 'CUSTOM':
+            layout.prop(pg, 'fps_custom', text='Custom')
+
+        # SOURCE
+        layout.prop(pg, 'sequence_source', text='Source')
+
+        if pg.sequence_source == 'TIMELINE_MARKERS':
+            # ANIMDATA SOURCE
+            layout.prop(pg, 'should_override_animation_data')
+            if pg.should_override_animation_data:
+                layout.prop(pg, 'animation_data_override', text='')
+
+        # SELECT ALL/NONE
+        row = layout.row(align=True)
+        row.label(text='Select')
+        row.operator(PsaExportActionsSelectAll.bl_idname, text='All', icon='CHECKBOX_HLT')
+        row.operator(PsaExportActionsDeselectAll.bl_idname, text='None', icon='CHECKBOX_DEHLT')
 
         # ACTIONS
-        box = layout.box()
+        if pg.sequence_source == 'ACTIONS':
-        box.label(text='Actions', icon='ACTION')
+            rows = max(3, min(len(pg.action_list), 10))
-        row = box.row()
+
-        row.template_list('PSA_UL_ExportActionList', 'asd', property_group, 'action_list', property_group, 'action_list_index', rows=10)
+            layout.template_list('PSA_UL_ExportSequenceList', '', pg, 'action_list', pg, 'action_list_index', rows=rows)
-        row = box.row(align=True)
+
-        row.label(text='Select')
+            col = layout.column()
-        row.operator('psa_export.actions_select_all', text='All')
+            col.use_property_split = True
-        row.operator('psa_export.actions_deselect_all', text='None')
+            col.use_property_decorate = False
+            col.prop(pg, 'should_use_original_sequence_names')
+            col.prop(pg, 'sequence_name_prefix')
+            col.prop(pg, 'sequence_name_suffix')
+
+        elif pg.sequence_source == 'TIMELINE_MARKERS':
+            rows = max(3, min(len(pg.marker_list), 10))
+            layout.template_list('PSA_UL_ExportSequenceList', '', pg, 'marker_list', pg, 'marker_list_index',
+                                 rows=rows)
+
+            col = layout.column()
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(pg, 'should_trim_timeline_marker_sequences')
+            col.prop(pg, 'sequence_name_prefix')
+            col.prop(pg, 'sequence_name_suffix')
+
+        # Determine if there is going to be a naming conflict and display an error, if so.
+        selected_items = [x for x in pg.action_list if x.is_selected]
+        action_names = [x.name for x in selected_items]
+        action_name_counts = Counter(action_names)
+        for action_name, count in action_name_counts.items():
+            if count > 1:
+                layout.label(text=f'Duplicate action: {action_name}', icon='ERROR')
+                break
+
+        layout.separator()
 
         # BONES
-        box = layout.box()
+        row = layout.row(align=True)
-        box.label(text='Bones', icon='BONE_DATA')
+        row.prop(pg, 'bone_filter_mode', text='Bones')
-        bone_filter_mode_items = property_group.bl_rna.properties['bone_filter_mode'].enum_items_static
-        row = box.row(align=True)
-        for item in bone_filter_mode_items:
-            identifier = item.identifier
-            item_layout = row.row(align=True)
-            item_layout.prop_enum(property_group, 'bone_filter_mode', item.identifier)
-            item_layout.enabled = is_bone_filter_mode_item_available(context, identifier)
 
-        if property_group.bone_filter_mode == 'BONE_GROUPS':
+        if pg.bone_filter_mode == 'BONE_GROUPS':
-            box = layout.box()
+            row = layout.row(align=True)
-            row = box.row()
+            row.label(text='Select')
-            rows = max(3, min(len(property_group.bone_group_list), 10))
+            row.operator(PsaExportBoneGroupsSelectAll.bl_idname, text='All', icon='CHECKBOX_HLT')
-            row.template_list('PSX_UL_BoneGroupList', '', property_group, 'bone_group_list', property_group, 'bone_group_list_index', rows=rows)
+            row.operator(PsaExportBoneGroupsDeselectAll.bl_idname, text='None', icon='CHECKBOX_DEHLT')
+            rows = max(3, min(len(pg.bone_group_list), 10))
+            layout.template_list('PSX_UL_BoneGroupList', '', pg, 'bone_group_list', pg, 'bone_group_list_index',
+                                 rows=rows)
+
+        layout.separator()
+
+        # ROOT MOTION
+        layout.prop(pg, 'root_motion', text='Root Motion')
 
     def is_action_for_armature(self, action):
         if len(action.fcurves) == 0:
             return False
         bone_names = set([x.name for x in self.armature.data.bones])
         for fcurve in action.fcurves:
-            match = re.match(r'pose\.bones\["(.+)"\].\w+', fcurve.data_path)
+            match = re.match(r'pose\.bones\["(.+)"].\w+', fcurve.data_path)
             if not match:
                 continue
             bone_name = match.group(1)
@@ -127,127 +280,259 @@ class PsaExportOperator(Operator, ExportHelper):
                 return True
         return False
 
-    def invoke(self, context, event):
+    @classmethod
-        property_group = context.scene.psa_export
+    def _check_context(cls, context):
-
         if context.view_layer.objects.active is None:
-            self.report({'ERROR_INVALID_CONTEXT'}, 'An armature must be selected')
+            raise RuntimeError('An armature must be selected')
-            return {'CANCELLED'}
 
         if context.view_layer.objects.active.type != 'ARMATURE':
-            self.report({'ERROR_INVALID_CONTEXT'}, 'The selected object must be an armature.')
+            raise RuntimeError('The selected object must be an armature')
-            return {'CANCELLED'}
 
+    def invoke(self, context, _event):
+        try:
+            self._check_context(context)
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+
+        pg = getattr(context.scene, 'psa_export')
         self.armature = context.view_layer.objects.active
 
         # Populate actions list.
-        property_group.action_list.clear()
+        pg.action_list.clear()
         for action in bpy.data.actions:
-            item = property_group.action_list.add()
+            if not self.is_action_for_armature(action):
+                continue
+            item = pg.action_list.add()
             item.action = action
-            item.action_name = action.name
+            item.name = action.name
-            if self.is_action_for_armature(action):
+            item.is_selected = False
-                item.is_selected = True
 
-        if len(property_group.action_list) == 0:
+        update_action_names(context)
+
+        # Populate timeline markers list.
+        pg.marker_list.clear()
+        for marker in context.scene.timeline_markers:
+            item = pg.marker_list.add()
+            item.name = marker.name
+            item.is_selected = False
+
+        if len(pg.action_list) == 0 and len(pg.marker_list) == 0:
             # If there are no actions at all, we have nothing to export, so just cancel the operation.
-            self.report({'ERROR_INVALID_CONTEXT'}, 'There are no actions to export.')
+            self.report({'ERROR_INVALID_CONTEXT'}, 'There are no actions or timeline markers to export.')
             return {'CANCELLED'}
 
         # Populate bone groups list.
-        populate_bone_group_list(self.armature, property_group.bone_group_list)
+        populate_bone_group_list(self.armature, pg.bone_group_list)
 
         context.window_manager.fileselect_add(self)
 
         return {'RUNNING_MODAL'}
 
     def execute(self, context):
-        property_group = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
-        actions = [x.action for x in property_group.action_list if x.is_selected]
 
-        if len(actions) == 0:
+        actions = [x.action for x in pg.action_list if x.is_selected]
-            self.report({'ERROR_INVALID_CONTEXT'}, 'No actions were selected for export.')
+        marker_names = [x.name for x in pg.marker_list if x.is_selected]
-            return {'CANCELLED'}
 
-        options = PsaBuilderOptions()
+        options = PsaBuildOptions()
+        options.should_override_animation_data = pg.should_override_animation_data
+        options.animation_data_override = pg.animation_data_override
+        options.fps_source = pg.fps_source
+        options.fps_custom = pg.fps_custom
+        options.sequence_source = pg.sequence_source
         options.actions = actions
-        options.bone_filter_mode = property_group.bone_filter_mode
+        options.marker_names = marker_names
-        options.bone_group_indices = [x.index for x in property_group.bone_group_list if x.is_selected]
+        options.bone_filter_mode = pg.bone_filter_mode
-        builder = PsaBuilder()
+        options.bone_group_indices = [x.index for x in pg.bone_group_list if x.is_selected]
+        options.should_use_original_sequence_names = pg.should_use_original_sequence_names
+        options.should_trim_timeline_marker_sequences = pg.should_trim_timeline_marker_sequences
+        options.sequence_name_prefix = pg.sequence_name_prefix
+        options.sequence_name_suffix = pg.sequence_name_suffix
+        options.root_motion = pg.root_motion
+
         try:
-            psa = builder.build(context, options)
+            psa = build_psa(context, options)
+            self.report({'INFO'}, f'PSA export successful')
         except RuntimeError as e:
             self.report({'ERROR_INVALID_CONTEXT'}, str(e))
             return {'CANCELLED'}
-        exporter = PsaExporter(psa)
+
-        exporter.export(self.filepath)
+        export_psa(psa, self.filepath)
+
         return {'FINISHED'}
 
 
-class PSA_UL_ExportActionList(UIList):
+def filter_sequences(pg: PsaExportPropertyGroup, sequences) -> List[int]:
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
+    bitflag_filter_item = 1 << 30
-        layout.alignment = 'LEFT'
+    flt_flags = [bitflag_filter_item] * len(sequences)
-        layout.prop(item, 'is_selected', icon_only=True)
-        layout.label(text=item.action_name)
 
-    def filter_items(self, context, data, property):
+    if pg.sequence_filter_name:
-        actions = getattr(data, property)
+        # Filter name is non-empty.
-        flt_flags = []
+        for i, sequence in enumerate(sequences):
-        flt_neworder = []
+            if not fnmatch.fnmatch(sequence.name, f'*{pg.sequence_filter_name}*'):
-        if self.filter_name:
+                flt_flags[i] &= ~bitflag_filter_item
-            flt_flags = bpy.types.UI_UL_list.filter_items_by_name(
+
-                self.filter_name,
+        # Invert filter flags for all items.
-                self.bitflag_filter_item,
+        if pg.sequence_use_filter_invert:
-                actions,
+            for i, sequence in enumerate(sequences):
-                'action_name',
+                flt_flags[i] ^= bitflag_filter_item
-                reverse=self.use_filter_invert
+
-            )
+    if not pg.sequence_filter_asset:
+        for i, sequence in enumerate(sequences):
+            if hasattr(sequence, 'action') and sequence.action.asset_data is not None:
+                flt_flags[i] &= ~bitflag_filter_item
+
+    return flt_flags
+
+
+def get_visible_sequences(pg: PsaExportPropertyGroup, sequences) -> List[PsaExportActionListItem]:
+    visible_sequences = []
+    for i, flag in enumerate(filter_sequences(pg, sequences)):
+        if bool(flag & (1 << 30)):
+            visible_sequences.append(sequences[i])
+    return visible_sequences
+
+
+class PSA_UL_ExportSequenceList(UIList):
+
+    def __init__(self):
+        super(PSA_UL_ExportSequenceList, self).__init__()
+        # Show the filtering options by default.
+        self.use_filter_show = True
+
+    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
+        layout.prop(item, 'is_selected', icon_only=True, text=item.name)
+        if hasattr(item, 'action') and item.action.asset_data is not None:
+            layout.label(text='', icon='ASSET_MANAGER')
+
+    def draw_filter(self, context, layout):
+        pg = getattr(context.scene, 'psa_export')
+        row = layout.row()
+        subrow = row.row(align=True)
+        subrow.prop(pg, 'sequence_filter_name', text="")
+        subrow.prop(pg, 'sequence_use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
+        # subrow.prop(pg, 'sequence_use_filter_sort_reverse', text='', icon='SORT_ASC')
+
+        if pg.sequence_source == 'ACTIONS':
+            subrow = row.row(align=True)
+            subrow.prop(pg, 'sequence_filter_asset', icon_only=True, icon='ASSET_MANAGER')
+
+    def filter_items(self, context, data, prop):
+        pg = getattr(context.scene, 'psa_export')
+        actions = getattr(data, prop)
+        flt_flags = filter_sequences(pg, actions)
+        flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(actions, 'name')
         return flt_flags, flt_neworder
 
 
-class PsaExportSelectAll(bpy.types.Operator):
+class PsaExportActionsSelectAll(Operator):
-    bl_idname = 'psa_export.actions_select_all'
+    bl_idname = 'psa_export.sequences_select_all'
     bl_label = 'Select All'
-    bl_description = 'Select all actions'
+    bl_description = 'Select all visible sequences'
+    bl_options = {'INTERNAL'}
+
+    @classmethod
+    def get_item_list(cls, context):
+        pg = context.scene.psa_export
+        if pg.sequence_source == 'ACTIONS':
+            return pg.action_list
+        elif pg.sequence_source == 'TIMELINE_MARKERS':
+            return pg.marker_list
+        return None
 
     @classmethod
     def poll(cls, context):
-        property_group = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
-        action_list = property_group.action_list
+        item_list = cls.get_item_list(context)
-        has_unselected_actions = any(map(lambda action: not action.is_selected, action_list))
+        visible_sequences = get_visible_sequences(pg, item_list)
-        return len(action_list) > 0 and has_unselected_actions
+        has_unselected_sequences = any(map(lambda item: not item.is_selected, visible_sequences))
+        return has_unselected_sequences
 
     def execute(self, context):
-        property_group = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
-        for action in property_group.action_list:
+        sequences = self.get_item_list(context)
-            action.is_selected = True
+        for sequence in get_visible_sequences(pg, sequences):
+            sequence.is_selected = True
         return {'FINISHED'}
 
 
-class PsaExportDeselectAll(bpy.types.Operator):
+class PsaExportActionsDeselectAll(Operator):
-    bl_idname = 'psa_export.actions_deselect_all'
+    bl_idname = 'psa_export.sequences_deselect_all'
     bl_label = 'Deselect All'
-    bl_description = 'Deselect all actions'
+    bl_description = 'Deselect all visible sequences'
+    bl_options = {'INTERNAL'}
+
+    @classmethod
+    def get_item_list(cls, context):
+        pg = context.scene.psa_export
+        if pg.sequence_source == 'ACTIONS':
+            return pg.action_list
+        elif pg.sequence_source == 'TIMELINE_MARKERS':
+            return pg.marker_list
+        return None
 
     @classmethod
     def poll(cls, context):
-        property_group = context.scene.psa_export
+        item_list = cls.get_item_list(context)
-        action_list = property_group.action_list
+        has_selected_items = any(map(lambda item: item.is_selected, item_list))
-        has_selected_actions = any(map(lambda action: action.is_selected, action_list))
+        return len(item_list) > 0 and has_selected_items
-        return len(action_list) > 0 and has_selected_actions
 
     def execute(self, context):
-        property_group = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
-        for action in property_group.action_list:
+        item_list = self.get_item_list(context)
+        for sequence in get_visible_sequences(pg, item_list):
+            sequence.is_selected = False
+        return {'FINISHED'}
+
+
+class PsaExportBoneGroupsSelectAll(Operator):
+    bl_idname = 'psa_export.bone_groups_select_all'
+    bl_label = 'Select All'
+    bl_description = 'Select all bone groups'
+    bl_options = {'INTERNAL'}
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psa_export')
+        item_list = pg.bone_group_list
+        has_unselected_items = any(map(lambda action: not action.is_selected, item_list))
+        return len(item_list) > 0 and has_unselected_items
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_export')
+        for item in pg.bone_group_list:
+            item.is_selected = True
+        return {'FINISHED'}
+
+
+class PsaExportBoneGroupsDeselectAll(Operator):
+    bl_idname = 'psa_export.bone_groups_deselect_all'
+    bl_label = 'Deselect All'
+    bl_description = 'Deselect all bone groups'
+    bl_options = {'INTERNAL'}
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psa_export')
+        item_list = pg.bone_group_list
+        has_selected_actions = any(map(lambda action: action.is_selected, item_list))
+        return len(item_list) > 0 and has_selected_actions
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_export')
+        for action in pg.bone_group_list:
             action.is_selected = False
         return {'FINISHED'}
 
 
-__classes__ = [
+classes = (
     PsaExportActionListItem,
+    PsaExportTimelineMarkerListItem,
     PsaExportPropertyGroup,
     PsaExportOperator,
-    PSA_UL_ExportActionList,
+    PSA_UL_ExportSequenceList,
-    PsaExportSelectAll,
+    PsaExportActionsSelectAll,
-    PsaExportDeselectAll,
+    PsaExportActionsDeselectAll,
-]
+    PsaExportBoneGroupsSelectAll,
+    PsaExportBoneGroupsDeselectAll,
+)

io_scene_psk_psa/psa/importer.py

@@ -1,112 +1,140 @@
-import bpy
+import fnmatch
 import os
+import re
+from typing import List, Optional
+
+import bpy
 import numpy as np
-from mathutils import Vector, Quaternion, Matrix
-from .data import Psa
-from typing import List, AnyStr, Optional
-from bpy.types import Operator, Action, UIList, PropertyGroup, Panel, Armature, FileSelectParams
-from bpy_extras.io_utils import ExportHelper, ImportHelper
 from bpy.props import StringProperty, BoolProperty, CollectionProperty, PointerProperty, IntProperty
+from bpy.types import Operator, UIList, PropertyGroup, Panel
+from bpy_extras.io_utils import ImportHelper
+from mathutils import Vector, Quaternion
+
+from .data import Psa
 from .reader import PsaReader
 
 
-class PsaImporter(object):
+class PsaImportOptions(object):
     def __init__(self):
-        pass
+        self.should_clean_keys = True
+        self.should_use_fake_user = False
+        self.should_stash = False
+        self.sequence_names = []
+        self.should_overwrite = False
+        self.should_write_keyframes = True
+        self.should_write_metadata = True
+        self.action_name_prefix = ''
 
-    def import_psa(self, psa_reader: PsaReader, sequence_names: List[AnyStr], armature_object):
-        sequences = map(lambda x: psa_reader.sequences[x], sequence_names)
-        armature_data = armature_object.data
 
-        class ImportBone(object):
+class ImportBone(object):
-            def __init__(self, psa_bone: Psa.Bone):
+    def __init__(self, psa_bone: Psa.Bone):
-                self.psa_bone: Psa.Bone = psa_bone
+        self.psa_bone: Psa.Bone = psa_bone
-                self.parent: Optional[ImportBone] = None
+        self.parent: Optional[ImportBone] = None
-                self.armature_bone = None
+        self.armature_bone = None
-                self.pose_bone = None
+        self.pose_bone = None
-                self.orig_loc: Vector = Vector()
+        self.orig_loc: Vector = Vector()
-                self.orig_quat: Quaternion = Quaternion()
+        self.orig_quat: Quaternion = Quaternion()
-                self.post_quat: Quaternion = Quaternion()
+        self.post_quat: Quaternion = Quaternion()
-                self.fcurves = []
+        self.fcurves = []
 
-        def calculate_fcurve_data(import_bone: ImportBone, key_data: []):
+
-            # Convert world-space transforms to local-space transforms.
+def calculate_fcurve_data(import_bone: ImportBone, key_data: []):
-            key_rotation = Quaternion(key_data[0:4])
+    # Convert world-space transforms to local-space transforms.
-            key_location = Vector(key_data[4:])
+    key_rotation = Quaternion(key_data[0:4])
-            q = import_bone.post_quat.copy()
+    key_location = Vector(key_data[4:])
-            q.rotate(import_bone.orig_quat)
+    q = import_bone.post_quat.copy()
-            quat = q
+    q.rotate(import_bone.orig_quat)
-            q = import_bone.post_quat.copy()
+    quat = q
-            if import_bone.parent is None:
+    q = import_bone.post_quat.copy()
-                q.rotate(key_rotation.conjugated())
+    if import_bone.parent is None:
+        q.rotate(key_rotation.conjugated())
+    else:
+        q.rotate(key_rotation)
+    quat.rotate(q.conjugated())
+    loc = key_location - import_bone.orig_loc
+    loc.rotate(import_bone.post_quat.conjugated())
+    return quat.w, quat.x, quat.y, quat.z, loc.x, loc.y, loc.z
+
+
+def import_psa(psa_reader: PsaReader, armature_object, options: PsaImportOptions):
+    sequences = map(lambda x: psa_reader.sequences[x], options.sequence_names)
+    armature_data = armature_object.data
+
+    # Create an index mapping from bones in the PSA to bones in the target armature.
+    psa_to_armature_bone_indices = {}
+    armature_bone_names = [x.name for x in armature_data.bones]
+    psa_bone_names = []
+    for psa_bone_index, psa_bone in enumerate(psa_reader.bones):
+        psa_bone_name = psa_bone.name.decode('windows-1252')
+        psa_bone_names.append(psa_bone_name)
+        try:
+            psa_to_armature_bone_indices[psa_bone_index] = armature_bone_names.index(psa_bone_name)
+        except ValueError:
+            pass
+
+    # Report if there are missing bones in the target armature.
+    missing_bone_names = set(psa_bone_names).difference(set(armature_bone_names))
+    if len(missing_bone_names) > 0:
+        print(
+            f'The armature object \'{armature_object.name}\' is missing the following bones that exist in the PSA:')
+        print(list(sorted(missing_bone_names)))
+    del armature_bone_names
+
+    # Create intermediate bone data for import operations.
+    import_bones = []
+    import_bones_dict = dict()
+
+    for psa_bone_index, psa_bone in enumerate(psa_reader.bones):
+        bone_name = psa_bone.name.decode('windows-1252')
+        if psa_bone_index not in psa_to_armature_bone_indices:  # TODO: replace with bone_name in armature_data.bones
+            # PSA bone does not map to armature bone, skip it and leave an empty bone in its place.
+            import_bones.append(None)
+            continue
+        import_bone = ImportBone(psa_bone)
+        import_bone.armature_bone = armature_data.bones[bone_name]
+        import_bone.pose_bone = armature_object.pose.bones[bone_name]
+        import_bones_dict[bone_name] = import_bone
+        import_bones.append(import_bone)
+
+    for import_bone in filter(lambda x: x is not None, import_bones):
+        armature_bone = import_bone.armature_bone
+        if armature_bone.parent is not None and armature_bone.parent.name in psa_bone_names:
+            import_bone.parent = import_bones_dict[armature_bone.parent.name]
+        # Calculate the original location & rotation of each bone (in world-space maybe?)
+        if armature_bone.get('orig_quat') is not None:
+            # TODO: ideally we don't rely on bone auxiliary data like this, the non-aux data path is incorrect
+            # (animations are flipped 180 around Z)
+            import_bone.orig_quat = Quaternion(armature_bone['orig_quat'])
+            import_bone.orig_loc = Vector(armature_bone['orig_loc'])
+            import_bone.post_quat = Quaternion(armature_bone['post_quat'])
+        else:
+            if import_bone.parent is not None:
+                import_bone.orig_loc = armature_bone.matrix_local.translation - armature_bone.parent.matrix_local.translation
+                import_bone.orig_loc.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
+                import_bone.orig_quat = armature_bone.matrix_local.to_quaternion()
+                import_bone.orig_quat.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
+                import_bone.orig_quat.conjugate()
             else:
-                q.rotate(key_rotation)
+                import_bone.orig_loc = armature_bone.matrix_local.translation.copy()
-            quat.rotate(q.conjugated())
+                import_bone.orig_quat = armature_bone.matrix_local.to_quaternion()
-            loc = key_location - import_bone.orig_loc
+            import_bone.post_quat = import_bone.orig_quat.conjugated()
-            loc.rotate(import_bone.post_quat.conjugated())
-            return quat.w, quat.x, quat.y, quat.z, loc.x, loc.y, loc.z
 
-        # Create an index mapping from bones in the PSA to bones in the target armature.
+    # Create and populate the data for new sequences.
-        psa_to_armature_bone_indices = {}
+    actions = []
-        armature_bone_names = [x.name for x in armature_data.bones]
+    for sequence in sequences:
-        psa_bone_names = []
+        # Add the action.
-        for psa_bone_index, psa_bone in enumerate(psa_reader.bones):
+        sequence_name = sequence.name.decode('windows-1252')
-            psa_bone_name = psa_bone.name.decode('windows-1252')
+        action_name = options.action_name_prefix + sequence_name
-            psa_bone_names.append(psa_bone_name)
-            try:
-                psa_to_armature_bone_indices[psa_bone_index] = armature_bone_names.index(psa_bone_name)
-            except ValueError:
-                pass
 
-        # Report if there are missing bones in the target armature.
+        if options.should_overwrite and action_name in bpy.data.actions:
-        missing_bone_names = set(psa_bone_names).difference(set(armature_bone_names))
+            action = bpy.data.actions[action_name]
-        if len(missing_bone_names) > 0:
+        else:
-            print(f'The armature object \'{armature_object.name}\' is missing the following bones that exist in the PSA:')
+            action = bpy.data.actions.new(name=action_name)
-            print(list(sorted(missing_bone_names)))
-        del armature_bone_names
 
-        # Create intermediate bone data for import operations.
+        if options.should_write_keyframes:
-        import_bones = []
+            # Remove existing f-curves (replace with action.fcurves.clear() in Blender 3.2)
-        import_bones_dict = dict()
+            while len(action.fcurves) > 0:
-
+                action.fcurves.remove(action.fcurves[-1])
-        for psa_bone_index, psa_bone in enumerate(psa_reader.bones):
-            bone_name = psa_bone.name.decode('windows-1252')
-            if psa_bone_index not in psa_to_armature_bone_indices:  # TODO: replace with bone_name in armature_data.bones
-                # PSA bone does not map to armature bone, skip it and leave an empty bone in its place.
-                import_bones.append(None)
-                continue
-            import_bone = ImportBone(psa_bone)
-            import_bone.armature_bone = armature_data.bones[bone_name]
-            import_bone.pose_bone = armature_object.pose.bones[bone_name]
-            import_bones_dict[bone_name] = import_bone
-            import_bones.append(import_bone)
-
-        for import_bone in filter(lambda x: x is not None, import_bones):
-            armature_bone = import_bone.armature_bone
-            if armature_bone.parent is not None and armature_bone.parent.name in psa_bone_names:
-                import_bone.parent = import_bones_dict[armature_bone.parent.name]
-            # Calculate the original location & rotation of each bone (in world-space maybe?)
-            if armature_bone.get('orig_quat') is not None:
-                # TODO: ideally we don't rely on bone auxiliary data like this, the non-aux data path is incorrect (animations are flipped 180 around Z)
-                import_bone.orig_quat = Quaternion(armature_bone['orig_quat'])
-                import_bone.orig_loc = Vector(armature_bone['orig_loc'])
-                import_bone.post_quat = Quaternion(armature_bone['post_quat'])
-            else:
-                if import_bone.parent is not None:
-                    import_bone.orig_loc = armature_bone.matrix_local.translation - armature_bone.parent.matrix_local.translation
-                    import_bone.orig_loc.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
-                    import_bone.orig_quat = armature_bone.matrix_local.to_quaternion()
-                    import_bone.orig_quat.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
-                    import_bone.orig_quat.conjugate()
-                else:
-                    import_bone.orig_loc = armature_bone.matrix_local.translation.copy()
-                    import_bone.orig_quat = armature_bone.matrix_local.to_quaternion()
-                import_bone.post_quat = import_bone.orig_quat.conjugated()
-
-        # Create and populate the data for new sequences.
-        for sequence in sequences:
-            # Add the action.
-            action = bpy.data.actions.new(name=sequence.name.decode())
 
             # Create f-curves for the rotation and location of each bone.
             for psa_bone_index, armature_bone_index in psa_to_armature_bone_indices.items():
@@ -115,37 +143,47 @@ class PsaImporter(object):
                 rotation_data_path = pose_bone.path_from_id('rotation_quaternion')
                 location_data_path = pose_bone.path_from_id('location')
                 import_bone.fcurves = [
-                    action.fcurves.new(rotation_data_path, index=0),  # Qw
+                    action.fcurves.new(rotation_data_path, index=0, action_group=pose_bone.name),  # Qw
-                    action.fcurves.new(rotation_data_path, index=1),  # Qx
+                    action.fcurves.new(rotation_data_path, index=1, action_group=pose_bone.name),  # Qx
-                    action.fcurves.new(rotation_data_path, index=2),  # Qy
+                    action.fcurves.new(rotation_data_path, index=2, action_group=pose_bone.name),  # Qy
-                    action.fcurves.new(rotation_data_path, index=3),  # Qz
+                    action.fcurves.new(rotation_data_path, index=3, action_group=pose_bone.name),  # Qz
-                    action.fcurves.new(location_data_path, index=0),  # Lx
+                    action.fcurves.new(location_data_path, index=0, action_group=pose_bone.name),  # Lx
-                    action.fcurves.new(location_data_path, index=1),  # Ly
+                    action.fcurves.new(location_data_path, index=1, action_group=pose_bone.name),  # Ly
-                    action.fcurves.new(location_data_path, index=2),  # Lz
+                    action.fcurves.new(location_data_path, index=2, action_group=pose_bone.name),  # Lz
                 ]
 
-            # Read the sequence keys from the PSA file.
-            sequence_name = sequence.name.decode('windows-1252')
-
             # Read the sequence data matrix from the PSA.
             sequence_data_matrix = psa_reader.read_sequence_data_matrix(sequence_name)
             keyframe_write_matrix = np.ones(sequence_data_matrix.shape, dtype=np.int8)
 
-            # The first step is to determine the frames at which each bone will write out a keyframe.
+            # Convert the sequence's data from world-space to local-space.
-            threshold = 0.001
             for bone_index, import_bone in enumerate(import_bones):
                 if import_bone is None:
                     continue
-                for fcurve_index, fcurve in enumerate(import_bone.fcurves):
+                for frame_index in range(sequence.frame_count):
-                    # Get all the keyframe data for the bone's f-curve data from the sequence data matrix.
+                    # This bone has writeable keyframes for this frame.
-                    fcurve_frame_data = sequence_data_matrix[:, bone_index, fcurve_index]
+                    key_data = sequence_data_matrix[frame_index, bone_index]
-                    last_written_datum = 0
+                    # Calculate the local-space key data for the bone.
-                    for frame_index, datum in enumerate(fcurve_frame_data):
+                    sequence_data_matrix[frame_index, bone_index] = calculate_fcurve_data(import_bone, key_data)
-                        # If the f-curve data is not different enough to the last written frame, un-mark this data for writing.
+
-                        if frame_index > 0 and abs(datum - last_written_datum) < threshold:
+            # Clean the keyframe data. This is accomplished by writing zeroes to the write matrix when there is an
-                            keyframe_write_matrix[frame_index, bone_index, fcurve_index] = 0
+            # insufficiently large change in the data from the last written frame.
-                        else:
+            if options.should_clean_keys:
-                            last_written_datum = fcurve_frame_data[frame_index]
+                threshold = 0.001
+                for bone_index, import_bone in enumerate(import_bones):
+                    if import_bone is None:
+                        continue
+                    for fcurve_index in range(len(import_bone.fcurves)):
+                        # Get all the keyframe data for the bone's f-curve data from the sequence data matrix.
+                        fcurve_frame_data = sequence_data_matrix[:, bone_index, fcurve_index]
+                        last_written_datum = 0
+                        for frame_index, datum in enumerate(fcurve_frame_data):
+                            # If the f-curve data is not different enough to the last written frame,
+                            # un-mark this data for writing.
+                            if frame_index > 0 and abs(datum - last_written_datum) < threshold:
+                                keyframe_write_matrix[frame_index, bone_index, fcurve_index] = 0
+                            else:
+                                last_written_datum = datum
 
             # Write the keyframes out!
             for frame_index in range(sequence.frame_count):
@@ -156,145 +194,282 @@ class PsaImporter(object):
                     if bone_has_writeable_keyframes:
                         # This bone has writeable keyframes for this frame.
                         key_data = sequence_data_matrix[frame_index, bone_index]
-                        # Calculate the local-space key data for the bone.
+                        for fcurve, should_write, datum in zip(import_bone.fcurves,
-                        fcurve_data = calculate_fcurve_data(import_bone, key_data)
+                                                               keyframe_write_matrix[frame_index, bone_index],
-                        for fcurve, should_write, datum in zip(import_bone.fcurves, keyframe_write_matrix[frame_index, bone_index], fcurve_data):
+                                                               key_data):
                             if should_write:
                                 fcurve.keyframe_points.insert(frame_index, datum, options={'FAST'})
 
+        # Write
+        if options.should_write_metadata:
+            action['psa_sequence_name'] = sequence_name
+            action['psa_sequence_fps'] = sequence.fps
 
-class PsaImportPsaBoneItem(PropertyGroup):
+        action.use_fake_user = options.should_use_fake_user
-    bone_name: StringProperty()
 
-    @property
+        actions.append(action)
-    def name(self):
+
-        return self.bone_name
+    # If the user specifies, store the new animations as strips on a non-contributing NLA track.
+    if options.should_stash:
+        if armature_object.animation_data is None:
+            armature_object.animation_data_create()
+        for action in actions:
+            nla_track = armature_object.animation_data.nla_tracks.new()
+            nla_track.name = action.name
+            nla_track.mute = True
+            nla_track.strips.new(name=action.name, start=0, action=action)
+
+
+empty_set = set()
 
 
 class PsaImportActionListItem(PropertyGroup):
-    action_name: StringProperty()
+    action_name: StringProperty(options=empty_set)
-    frame_count: IntProperty()
+    is_selected: BoolProperty(default=False, options=empty_set)
-    is_selected: BoolProperty(default=False)
 
-    @property
+
-    def name(self):
+def load_psa_file(context):
-        return self.action_name
+    pg = context.scene.psa_import
+    pg.sequence_list.clear()
+    pg.psa.bones.clear()
+    pg.psa_error = ''
+    try:
+        # Read the file and populate the action list.
+        p = os.path.abspath(pg.psa_file_path)
+        psa_reader = PsaReader(p)
+        for sequence in psa_reader.sequences.values():
+            item = pg.sequence_list.add()
+            item.action_name = sequence.name.decode('windows-1252')
+        for psa_bone in psa_reader.bones:
+            item = pg.psa.bones.add()
+            item.bone_name = psa_bone.name.decode('windows-1252')
+    except Exception as e:
+        pg.psa_error = str(e)
 
 
 def on_psa_file_path_updated(property, context):
-    print('PATH UPDATED')
+    load_psa_file(context)
-    property_group = context.scene.psa_import
-    property_group.action_list.clear()
-    property_group.psa_bones.clear()
-    try:
-        # Read the file and populate the action list.
-        p = os.path.abspath(property_group.psa_file_path)
-        psa_reader = PsaReader(p)
-        for sequence in psa_reader.sequences.values():
-            item = property_group.action_list.add()
-            item.action_name = sequence.name.decode('windows-1252')
-            item.frame_count = sequence.frame_count
-            item.is_selected = True
-
-        for psa_bone in psa_reader.bones:
-            item = property_group.psa_bones.add()
-            item.bone_name = psa_bone.name
-    except IOError as e:
-        print('ERROR READING FILE')
-        print(e)
-        # TODO: set an error somewhere so the user knows the PSA could not be read.
-        pass
 
 
-def on_armature_object_updated(property, context):
+class PsaBonePropertyGroup(PropertyGroup):
-    # TODO: ensure that there are matching bones between the two rigs.
+    bone_name: StringProperty(options=empty_set)
-    property_group = context.scene.psa_import
-    armature_object = property_group.armature_object
-    if armature_object is not None:
-        armature_bone_names = set(map(lambda bone: bone.name, armature_object.data.bones))
-        psa_bone_names = set(map(lambda psa_bone: psa_bone.name, property_group.psa_bones))
 
 
-class PsaImportPropertyGroup(bpy.types.PropertyGroup):
+class PsaDataPropertyGroup(PropertyGroup):
-    psa_file_path: StringProperty(default='', update=on_psa_file_path_updated, name='PSA File Path')
+    bones: CollectionProperty(type=PsaBonePropertyGroup)
-    psa_bones: CollectionProperty(type=PsaImportPsaBoneItem)
+    sequence_count: IntProperty(default=0)
-    # armature_object: PointerProperty(name='Object', type=bpy.types.Object, update=on_armature_object_updated)
-    action_list: CollectionProperty(type=PsaImportActionListItem)
-    action_list_index: IntProperty(name='', default=0)
-    action_filter_name: StringProperty(default='')
 
 
-class PSA_UL_ImportActionList(UIList):
+class PsaImportPropertyGroup(PropertyGroup):
+    psa_file_path: StringProperty(default='', options=empty_set, update=on_psa_file_path_updated, name='PSA File Path')
+    psa_error: StringProperty(default='')
+    psa: PointerProperty(type=PsaDataPropertyGroup)
+    sequence_list: CollectionProperty(type=PsaImportActionListItem)
+    sequence_list_index: IntProperty(name='', default=0)
+    should_clean_keys: BoolProperty(default=True, name='Clean Keyframes',
+                                    description='Exclude unnecessary keyframes from being written to the actions',
+                                    options=empty_set)
+    should_use_fake_user: BoolProperty(default=True, name='Fake User',
+                                       description='Assign each imported action a fake user so that the data block is saved even it has no users',
+                                       options=empty_set)
+    should_stash: BoolProperty(default=False, name='Stash',
+                               description='Stash each imported action as a strip on a new non-contributing NLA track',
+                               options=empty_set)
+    should_use_action_name_prefix: BoolProperty(default=False, name='Prefix Action Name', options=empty_set)
+    action_name_prefix: StringProperty(default='', name='Prefix', options=empty_set)
+    should_overwrite: BoolProperty(default=False, name='Reuse Existing Actions', options=empty_set,
+                                   description='If an action with a matching name already exists, the existing action will have it\'s data overwritten instead of a new action being created')
+    should_write_keyframes: BoolProperty(default=True, name='Keyframes', options=empty_set)
+    should_write_metadata: BoolProperty(default=True, name='Metadata', options=empty_set,
+                                        description='Additional data will be written to the custom properties of the Action (e.g., frame rate)')
+    sequence_filter_name: StringProperty(default='', options={'TEXTEDIT_UPDATE'})
+    sequence_filter_is_selected: BoolProperty(default=False, options=empty_set, name='Only Show Selected',
+                                              description='Only show selected sequences')
+    sequence_use_filter_invert: BoolProperty(default=False, options=empty_set)
+    sequence_use_filter_regex: BoolProperty(default=False, name='Regular Expression',
+                                            description='Filter using regular expressions', options=empty_set)
+    select_text: PointerProperty(type=bpy.types.Text)
 
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
+
+def filter_sequences(pg: PsaImportPropertyGroup, sequences) -> List[int]:
+    bitflag_filter_item = 1 << 30
+    flt_flags = [bitflag_filter_item] * len(sequences)
+
+    if pg.sequence_filter_name is not None:
+        # Filter name is non-empty.
+        if pg.sequence_use_filter_regex:
+            # Use regular expression. If regex pattern doesn't compile, just ignore it.
+            try:
+                regex = re.compile(pg.sequence_filter_name)
+                for i, sequence in enumerate(sequences):
+                    if not regex.match(sequence.action_name):
+                        flt_flags[i] &= ~bitflag_filter_item
+            except re.error:
+                pass
+        else:
+            # User regular text matching.
+            for i, sequence in enumerate(sequences):
+                if not fnmatch.fnmatch(sequence.action_name, f'*{pg.sequence_filter_name}*'):
+                    flt_flags[i] &= ~bitflag_filter_item
+
+    if pg.sequence_filter_is_selected:
+        for i, sequence in enumerate(sequences):
+            if not sequence.is_selected:
+                flt_flags[i] &= ~bitflag_filter_item
+
+    if pg.sequence_use_filter_invert:
+        # Invert filter flags for all items.
+        for i, sequence in enumerate(sequences):
+            flt_flags[i] ^= bitflag_filter_item
+
+    return flt_flags
+
+
+def get_visible_sequences(pg: PsaImportPropertyGroup, sequences) -> List[PsaImportActionListItem]:
+    bitflag_filter_item = 1 << 30
+    visible_sequences = []
+    for i, flag in enumerate(filter_sequences(pg, sequences)):
+        if bool(flag & bitflag_filter_item):
+            visible_sequences.append(sequences[i])
+    return visible_sequences
+
+
+class PSA_UL_SequenceList(UIList):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_property, index, flt_flag):
         row = layout.row(align=True)
         split = row.split(align=True, factor=0.75)
-        action_col = split.row(align=True)
+        column = split.row(align=True)
-        action_col.alignment = 'LEFT'
+        column.alignment = 'LEFT'
-        action_col.prop(item, 'is_selected', icon_only=True)
+        column.prop(item, 'is_selected', icon_only=True)
-        action_col.label(text=item.action_name)
+        column.label(text=getattr(item, 'action_name'))
 
     def draw_filter(self, context, layout):
+        pg = getattr(context.scene, 'psa_import')
         row = layout.row()
-        subrow = row.row(align=True)
+        sub_row = row.row(align=True)
-        subrow.prop(self, 'filter_name', text="")
+        sub_row.prop(pg, 'sequence_filter_name', text="")
-        subrow.prop(self, 'use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
+        sub_row.prop(pg, 'sequence_use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
-        subrow = row.row(align=True)
+        sub_row.prop(pg, 'sequence_use_filter_regex', text="", icon='SORTBYEXT')
-        subrow.prop(self, 'use_filter_sort_reverse', text='', icon='SORT_ASC')
+        sub_row.prop(pg, 'sequence_filter_is_selected', text="", icon='CHECKBOX_HLT')
 
     def filter_items(self, context, data, property):
-        actions = getattr(data, property)
+        pg = getattr(context.scene, 'psa_import')
-        flt_flags = []
+        sequences = getattr(data, property)
-        flt_neworder = []
+        flt_flags = filter_sequences(pg, sequences)
-        if self.filter_name:
+        flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(sequences, 'action_name')
-            flt_flags = bpy.types.UI_UL_list.filter_items_by_name(
-                self.filter_name,
-                self.bitflag_filter_item,
-                actions,
-                'action_name',
-                reverse=self.use_filter_invert
-            )
         return flt_flags, flt_neworder
 
 
-class PsaImportSelectAll(bpy.types.Operator):
+class PSA_UL_ImportSequenceList(PSA_UL_SequenceList, UIList):
-    bl_idname = 'psa_import.actions_select_all'
+    pass
+
+
+class PSA_UL_ImportActionList(PSA_UL_SequenceList, UIList):
+    pass
+
+
+class PsaImportSequencesFromText(Operator):
+    bl_idname = 'psa_import.sequences_select_from_text'
+    bl_label = 'Select By Text List'
+    bl_description = 'Select sequences by name from text list'
+    bl_options = {'INTERNAL', 'UNDO'}
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psa_import')
+        return len(pg.sequence_list) > 0
+
+    def invoke(self, context, event):
+        return context.window_manager.invoke_props_dialog(self, width=256)
+
+    def draw(self, context):
+        layout = self.layout
+        pg = getattr(context.scene, 'psa_import')
+        layout.label(icon='INFO', text='Each sequence name should be on a new line.')
+        layout.prop(pg, 'select_text', text='')
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_import')
+        if pg.select_text is None:
+            self.report({'ERROR_INVALID_CONTEXT'}, 'No text block selected')
+            return {'CANCELLED'}
+        contents = pg.select_text.as_string()
+        count = 0
+        for line in contents.split('\n'):
+            for sequence in pg.sequence_list:
+                if sequence.action_name == line:
+                    sequence.is_selected = True
+                    count += 1
+        self.report({'INFO'}, f'Selected {count} sequence(s)')
+        return {'FINISHED'}
+
+
+class PsaImportSequencesSelectAll(Operator):
+    bl_idname = 'psa_import.sequences_select_all'
     bl_label = 'All'
-    bl_description = 'Select all actions'
+    bl_description = 'Select all sequences'
+    bl_options = {'INTERNAL'}
 
     @classmethod
     def poll(cls, context):
-        property_group = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
-        action_list = property_group.action_list
+        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
-        has_unselected_actions = any(map(lambda action: not action.is_selected, action_list))
+        has_unselected_actions = any(map(lambda action: not action.is_selected, visible_sequences))
-        return len(action_list) > 0 and has_unselected_actions
+        return len(visible_sequences) > 0 and has_unselected_actions
 
     def execute(self, context):
-        property_group = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
-        for action in property_group.action_list:
+        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
-            action.is_selected = True
+        for sequence in visible_sequences:
+            sequence.is_selected = True
         return {'FINISHED'}
 
 
-class PsaImportDeselectAll(bpy.types.Operator):
+class PsaImportSequencesDeselectAll(Operator):
-    bl_idname = 'psa_import.actions_deselect_all'
+    bl_idname = 'psa_import.sequences_deselect_all'
     bl_label = 'None'
-    bl_description = 'Deselect all actions'
+    bl_description = 'Deselect all visible sequences'
+    bl_options = {'INTERNAL'}
 
     @classmethod
     def poll(cls, context):
-        property_group = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
-        action_list = property_group.action_list
+        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
-        has_selected_actions = any(map(lambda action: action.is_selected, action_list))
+        has_selected_sequences = any(map(lambda sequence: sequence.is_selected, visible_sequences))
-        return len(action_list) > 0 and has_selected_actions
+        return len(visible_sequences) > 0 and has_selected_sequences
 
     def execute(self, context):
-        property_group = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
-        for action in property_group.action_list:
+        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
-            action.is_selected = False
+        for sequence in visible_sequences:
+            sequence.is_selected = False
         return {'FINISHED'}
 
 
+class PSA_PT_ImportPanel_Advanced(Panel):
+    bl_space_type = 'PROPERTIES'
+    bl_region_type = 'WINDOW'
+    bl_label = 'Advanced'
+    bl_options = {'DEFAULT_CLOSED'}
+    bl_parent_id = 'PSA_PT_ImportPanel'
+
+    def draw(self, context):
+        layout = self.layout
+        pg = getattr(context.scene, 'psa_import')
+
+        col = layout.column(heading="Options")
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(pg, 'should_clean_keys')
+        col.separator()
+        col.prop(pg, 'should_use_fake_user')
+        col.prop(pg, 'should_stash')
+        col.prop(pg, 'should_use_action_name_prefix')
+
+        if pg.should_use_action_name_prefix:
+            col.prop(pg, 'action_name_prefix')
+
+
 class PSA_PT_ImportPanel(Panel):
     bl_space_type = 'PROPERTIES'
     bl_region_type = 'WINDOW'
@@ -305,47 +480,83 @@ class PSA_PT_ImportPanel(Panel):
 
     @classmethod
     def poll(cls, context):
-        return context.object.type == 'ARMATURE'
+        return context.view_layer.objects.active.type == 'ARMATURE'
 
     def draw(self, context):
         layout = self.layout
-        property_group = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
+
+        row = layout.row(align=True)
+        row.operator(PsaImportSelectFile.bl_idname, text='', icon='FILEBROWSER')
+        row.prop(pg, 'psa_file_path', text='')
+        row.operator(PsaImportFileReload.bl_idname, text='', icon='FILE_REFRESH')
+
+        if pg.psa_error != '':
+            row = layout.row()
+            row.label(text='File could not be read', icon='ERROR')
+
+        box = layout.box()
+
+        box.label(text=f'Sequences ({len(pg.sequence_list)})', icon='ARMATURE_DATA')
+
+        # select
+        rows = max(3, min(len(pg.sequence_list), 10))
+
+        row = box.row()
+        col = row.column()
+
+        row2 = col.row(align=True)
+        row2.label(text='Select')
+        row2.operator(PsaImportSequencesFromText.bl_idname, text='', icon='TEXT')
+        row2.operator(PsaImportSequencesSelectAll.bl_idname, text='All', icon='CHECKBOX_HLT')
+        row2.operator(PsaImportSequencesDeselectAll.bl_idname, text='None', icon='CHECKBOX_DEHLT')
+
+        col = col.row()
+        col.template_list('PSA_UL_ImportSequenceList', '', pg, 'sequence_list', pg, 'sequence_list_index', rows=rows)
+
+        col = layout.column(heading='')
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(pg, 'should_overwrite')
+
+        col = layout.column(heading='Write')
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(pg, 'should_write_keyframes')
+        col.prop(pg, 'should_write_metadata')
+
+        selected_sequence_count = sum(map(lambda x: x.is_selected, pg.sequence_list))
 
-        row = layout.row()
-        row.prop(property_group, 'psa_file_path', text='')
-        row.enabled = False
-        # row.enabled = property_group.psa_file_path is not ''
         row = layout.row()
 
-        layout.separator()
+        import_button_text = 'Import'
+        if selected_sequence_count > 0:
+            import_button_text = f'Import ({selected_sequence_count})'
 
-        row.operator('psa_import.select_file', text='Select PSA File', icon='FILEBROWSER')
+        row.operator(PsaImportOperator.bl_idname, text=import_button_text)
-        if len(property_group.action_list) > 0:
-            box = layout.box()
-            box.label(text=f'Actions ({len(property_group.action_list)})', icon='ACTION')
-            row = box.row()
-            rows = max(3, min(len(property_group.action_list), 10))
-            row.template_list('PSA_UL_ImportActionList', '', property_group, 'action_list', property_group, 'action_list_index', rows=rows)
-            row = box.row(align=True)
-            row.label(text='Select')
-            row.operator('psa_import.actions_select_all', text='All')
-            row.operator('psa_import.actions_deselect_all', text='None')
 
-        layout.separator()
 
-        layout.operator('psa_import.import', text=f'Import')
+class PsaImportFileReload(Operator):
+    bl_idname = 'psa_import.file_reload'
+    bl_label = 'Refresh'
+    bl_options = {'INTERNAL'}
+    bl_description = 'Refresh the PSA file'
+
+    def execute(self, context):
+        load_psa_file(context)
+        return {"FINISHED"}
 
 
 class PsaImportSelectFile(Operator):
     bl_idname = 'psa_import.select_file'
     bl_label = 'Select'
-    bl_options = {'REGISTER', 'UNDO'}
+    bl_options = {'INTERNAL'}
     bl_description = 'Select a PSA file from which to import animations'
     filepath: bpy.props.StringProperty(subtype='FILE_PATH')
     filter_glob: bpy.props.StringProperty(default="*.psa", options={'HIDDEN'})
 
     def execute(self, context):
-        context.scene.psa_import.psa_file_path = self.filepath
+        getattr(context.scene, 'psa_import').psa_file_path = self.filepath
         return {"FINISHED"}
 
     def invoke(self, context, event):
@@ -357,27 +568,42 @@ class PsaImportOperator(Operator):
     bl_idname = 'psa_import.import'
     bl_label = 'Import'
     bl_description = 'Import the selected animations into the scene as actions'
+    bl_options = {'INTERNAL', 'UNDO'}
 
     @classmethod
     def poll(cls, context):
-        property_group = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
         active_object = context.view_layer.objects.active
-        action_list = property_group.action_list
+        if active_object is None or active_object.type != 'ARMATURE':
-        has_selected_actions = any(map(lambda action: action.is_selected, action_list))
+            return False
-        return has_selected_actions and active_object is not None and active_object.type == 'ARMATURE'
+        return any(map(lambda x: x.is_selected, pg.sequence_list))
 
     def execute(self, context):
-        property_group = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
-        psa_reader = PsaReader(property_group.psa_file_path)
+        psa_reader = PsaReader(pg.psa_file_path)
-        sequence_names = [x.action_name for x in property_group.action_list if x.is_selected]
+        sequence_names = [x.action_name for x in pg.sequence_list if x.is_selected]
-        PsaImporter().import_psa(psa_reader, sequence_names, context.view_layer.objects.active)
+
+        options = PsaImportOptions()
+        options.sequence_names = sequence_names
+        options.should_clean_keys = pg.should_clean_keys
+        options.should_use_fake_user = pg.should_use_fake_user
+        options.should_stash = pg.should_stash
+        options.action_name_prefix = pg.action_name_prefix if pg.should_use_action_name_prefix else ''
+        options.should_overwrite = pg.should_overwrite
+        options.should_write_metadata = pg.should_write_metadata
+        options.should_write_keyframes = pg.should_write_keyframes
+
+        import_psa(psa_reader, context.view_layer.objects.active, options)
+
         self.report({'INFO'}, f'Imported {len(sequence_names)} action(s)')
+
         return {'FINISHED'}
 
 
 class PsaImportFileSelectOperator(Operator, ImportHelper):
     bl_idname = 'psa_import.file_select'
     bl_label = 'File Select'
+    bl_options = {'INTERNAL'}
     filename_ext = '.psa'
     filter_glob: StringProperty(default='*.psa', options={'HIDDEN'})
     filepath: StringProperty(
@@ -391,21 +617,26 @@ class PsaImportFileSelectOperator(Operator, ImportHelper):
         return {'RUNNING_MODAL'}
 
     def execute(self, context):
-        property_group = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
-        property_group.psa_file_path = self.filepath
+        pg.psa_file_path = self.filepath
-        # Load the sequence names from the selected file
         return {'FINISHED'}
 
 
-__classes__ = [
+classes = (
-    PsaImportPsaBoneItem,
     PsaImportActionListItem,
+    PsaBonePropertyGroup,
+    PsaDataPropertyGroup,
     PsaImportPropertyGroup,
+    PSA_UL_SequenceList,
+    PSA_UL_ImportSequenceList,
     PSA_UL_ImportActionList,
-    PsaImportSelectAll,
+    PsaImportSequencesSelectAll,
-    PsaImportDeselectAll,
+    PsaImportSequencesDeselectAll,
+    PsaImportSequencesFromText,
+    PsaImportFileReload,
     PSA_PT_ImportPanel,
+    PSA_PT_ImportPanel_Advanced,
     PsaImportOperator,
     PsaImportFileSelectOperator,
     PsaImportSelectFile,
-]
+)

io_scene_psk_psa/psa/reader.py

@@ -1,14 +1,17 @@
-from .data import *
 import ctypes
+
 import numpy as np
 
+from .data import *
+
 
 class PsaReader(object):
     """
-    This class will read the sequences and bone information immediately upon instantiation and hold onto a file handle.
+    This class reads the sequences and bone information immediately upon instantiation and holds onto a file handle.
-    The key data is not read into memory upon instantiation due to it's potentially very large size.
+    The keyframe data is not read into memory upon instantiation due to its potentially very large size.
-    To read the key data for a particular sequence, call `read_sequence_keys`.
+    To read the key data for a particular sequence, call :read_sequence_keys.
     """
+
     def __init__(self, path):
         self.keys_data_offset: int = 0
         self.fp = open(path, 'rb')
@@ -22,15 +25,6 @@ class PsaReader(object):
     def sequences(self):
         return self.psa.sequences
 
-    @staticmethod
-    def _read_types(fp, data_class: ctypes.Structure, section: Section, data):
-        buffer_length = section.data_size * section.data_count
-        buffer = fp.read(buffer_length)
-        offset = 0
-        for _ in range(section.data_count):
-            data.append(data_class.from_buffer_copy(buffer, offset))
-            offset += section.data_size
-
     def read_sequence_data_matrix(self, sequence_name: str):
         sequence = self.psa.sequences[sequence_name]
         keys = self.read_sequence_keys(sequence_name)
@@ -44,7 +38,8 @@ class PsaReader(object):
         return matrix
 
     def read_sequence_keys(self, sequence_name: str) -> List[Psa.Key]:
-        """ Reads and returns the key data for a sequence.
+        """
+        Reads and returns the key data for a sequence.
 
         :param sequence_name: The name of the sequence.
         :return: A list of Psa.Keys.
@@ -65,6 +60,15 @@ class PsaReader(object):
             offset += data_size
         return keys
 
+    @staticmethod
+    def _read_types(fp, data_class, section: Section, data):
+        buffer_length = section.data_size * section.data_count
+        buffer = fp.read(buffer_length)
+        offset = 0
+        for _ in range(section.data_count):
+            data.append(data_class.from_buffer_copy(buffer, offset))
+            offset += section.data_size
+
     def _read(self, fp) -> Psa:
         psa = Psa()
         while fp.read(1):
@@ -83,9 +87,8 @@ class PsaReader(object):
                 # Skip keys on this pass. We will keep this file open and read from it as needed.
                 self.keys_data_offset = fp.tell()
                 fp.seek(section.data_size * section.data_count, 1)
-            elif section.name in [b'SCALEKEYS']:
+            elif section.name == b'SCALEKEYS':
                 fp.seek(section.data_size * section.data_count, 1)
             else:
                 raise RuntimeError(f'Unrecognized section "{section.name}"')
         return psa
-1

io_scene_psk_psa/psk/builder.py

@@ -1,8 +1,10 @@
-import bpy
-import bmesh
 from collections import OrderedDict
+from typing import Dict, List
+
 from .data import *
 from ..helpers import *
+import bmesh
+import bpy
 
 
 class PskInputObjects(object):
@@ -11,241 +13,253 @@ class PskInputObjects(object):
         self.armature_object = None
 
 
-class PskBuilderOptions(object):
+class PskBuildOptions(object):
     def __init__(self):
         self.bone_filter_mode = 'ALL'
-        self.bone_group_indices = []
+        self.bone_group_indices: List[int] = []
+        self.use_raw_mesh_data = True
+        self.material_names: List[str] = []
 
 
-class PskBuilder(object):
+def get_psk_input_objects(context) -> PskInputObjects:
-    def __init__(self):
+    input_objects = PskInputObjects()
-        pass
+    for selected_object in context.view_layer.objects.selected:
+        if selected_object.type != 'MESH':
+            raise RuntimeError(f'Selected object "{selected_object.name}" is not a mesh')
 
-    @staticmethod
+    input_objects.mesh_objects = context.view_layer.objects.selected
-    def get_input_objects(context) -> PskInputObjects:
-        input_objects = PskInputObjects()
-        for obj in context.view_layer.objects.selected:
-            if obj.type != 'MESH':
-                raise RuntimeError(f'Selected object "{obj.name}" is not a mesh')
 
-        input_objects.mesh_objects = context.view_layer.objects.selected
+    if len(input_objects.mesh_objects) == 0:
+        raise RuntimeError('At least one mesh must be selected')
 
-        if len(input_objects.mesh_objects) == 0:
+    for mesh_object in input_objects.mesh_objects:
-            raise RuntimeError('At least one mesh must be selected')
+        if len(mesh_object.data.materials) == 0:
+            raise RuntimeError(f'Mesh "{mesh_object.name}" must have at least one material')
 
-        for obj in input_objects.mesh_objects:
+    # Ensure that there are either no armature modifiers (static mesh)
-            if len(obj.data.materials) == 0:
+    # or that there is exactly one armature modifier object shared between
-                raise RuntimeError(f'Mesh "{obj.name}" must have at least one material')
+    # all selected meshes
+    armature_modifier_objects = set()
 
-        # Ensure that there are either no armature modifiers (static mesh)
+    for mesh_object in input_objects.mesh_objects:
-        # or that there is exactly one armature modifier object shared between
+        modifiers = [x for x in mesh_object.modifiers if x.type == 'ARMATURE']
-        # all selected meshes
+        if len(modifiers) == 0:
-        armature_modifier_objects = set()
+            continue
+        elif len(modifiers) > 1:
+            raise RuntimeError(f'Mesh "{mesh_object.name}" must have only one armature modifier')
+        armature_modifier_objects.add(modifiers[0].object)
 
-        for obj in input_objects.mesh_objects:
+    if len(armature_modifier_objects) > 1:
-            modifiers = [x for x in obj.modifiers if x.type == 'ARMATURE']
+        raise RuntimeError('All selected meshes must have the same armature modifier')
-            if len(modifiers) == 0:
+    elif len(armature_modifier_objects) == 1:
-                continue
+        input_objects.armature_object = list(armature_modifier_objects)[0]
-            elif len(modifiers) > 1:
-                raise RuntimeError(f'Mesh "{obj.name}" must have only one armature modifier')
-            armature_modifier_objects.add(modifiers[0].object)
 
-        if len(armature_modifier_objects) > 1:
+    return input_objects
-            raise RuntimeError('All selected meshes must have the same armature modifier')
-        elif len(armature_modifier_objects) == 1:
-            input_objects.armature_object = list(armature_modifier_objects)[0]
 
-        return input_objects
 
-    def build(self, context, options: PskBuilderOptions) -> Psk:
+def build_psk(context, options: PskBuildOptions) -> Psk:
-        input_objects = PskBuilder.get_input_objects(context)
+    input_objects = get_psk_input_objects(context)
 
-        armature_object = input_objects.armature_object
+    armature_object = input_objects.armature_object
 
-        psk = Psk()
+    psk = Psk()
-        bones = []
+    bones = []
-        materials = OrderedDict()
 
-        if armature_object is None:
+    if armature_object is None:
-            # If the mesh has no armature object, simply assign it a dummy bone at the root to satisfy the requirement
+        # If the mesh has no armature object, simply assign it a dummy bone at the root to satisfy the requirement
-            # that a PSK file must have at least one bone.
+        # that a PSK file must have at least one bone.
+        psk_bone = Psk.Bone()
+        psk_bone.name = bytes('root', encoding='windows-1252')
+        psk_bone.flags = 0
+        psk_bone.children_count = 0
+        psk_bone.parent_index = 0
+        psk_bone.location = Vector3.zero()
+        psk_bone.rotation = Quaternion.identity()
+        psk.bones.append(psk_bone)
+    else:
+        bone_names = get_export_bone_names(armature_object, options.bone_filter_mode, options.bone_group_indices)
+        bones = [armature_object.data.bones[bone_name] for bone_name in bone_names]
+
+        # Check that all bone names are valid.
+        check_bone_names(map(lambda x: x.name, bones))
+
+        for bone in bones:
             psk_bone = Psk.Bone()
-            psk_bone.name = bytes('static', encoding='utf-8')
+            psk_bone.name = bytes(bone.name, encoding='windows-1252')
             psk_bone.flags = 0
             psk_bone.children_count = 0
-            psk_bone.parent_index = 0
+
-            psk_bone.location = Vector3(0, 0, 0)
+            try:
-            psk_bone.rotation = Quaternion(0, 0, 0, 1)
+                parent_index = bones.index(bone.parent)
+                psk_bone.parent_index = parent_index
+                psk.bones[parent_index].children_count += 1
+            except ValueError:
+                psk_bone.parent_index = -1
+
+            if bone.parent is not None:
+                rotation = bone.matrix.to_quaternion().conjugated()
+                quat_parent = bone.parent.matrix.to_quaternion().inverted()
+                parent_head = quat_parent @ bone.parent.head
+                parent_tail = quat_parent @ bone.parent.tail
+                location = (parent_tail - parent_head) + bone.head
+            else:
+                local_matrix = armature_object.matrix_local
+                location = local_matrix @ bone.head
+                rot_matrix = bone.matrix @ local_matrix.to_3x3()
+                rotation = rot_matrix.to_quaternion()
+
+            psk_bone.location.x = location.x
+            psk_bone.location.y = location.y
+            psk_bone.location.z = location.z
+
+            psk_bone.rotation.w = rotation.w
+            psk_bone.rotation.x = rotation.x
+            psk_bone.rotation.y = rotation.y
+            psk_bone.rotation.z = rotation.z
+
             psk.bones.append(psk_bone)
+
+    # MATERIALS
+    material_names = options.material_names
+
+    for material_name in material_names:
+        psk_material = Psk.Material()
+        psk_material.name = bytes(material_name, encoding='windows-1252')
+        psk_material.texture_index = len(psk.materials)
+        psk.materials.append(psk_material)
+
+    for input_mesh_object in input_objects.mesh_objects:
+
+        # MATERIALS
+        material_indices = [material_names.index(material.name) for material in input_mesh_object.data.materials]
+
+        if options.use_raw_mesh_data:
+            mesh_object = input_mesh_object
+            mesh_data = input_mesh_object.data
         else:
-            bones = list(armature_object.data.bones)
+            # Create a copy of the mesh object after non-armature modifiers are applied.
 
-            # If we are filtering by bone groups, get only the bones that are in the specified bone groups and their
+            # Temporarily deactivate any armature modifiers on the input mesh object.
-            # ancestors.
+            active_armature_modifiers = [x for x in filter(lambda x: x.type == 'ARMATURE' and x.is_active, input_mesh_object.modifiers)]
-            if options.bone_filter_mode == 'BONE_GROUPS':
+            for modifier in active_armature_modifiers:
-                bone_indices = get_export_bone_indices_for_bone_groups(armature_object, options.bone_group_indices)
+                modifier.show_viewport = False
-                bones = [bones[bone_index] for bone_index in bone_indices]
 
-            # Ensure that the exported hierarchy has a single root bone.
+            depsgraph = context.evaluated_depsgraph_get()
-            root_bones = [x for x in bones if x.parent is None]
+            bm = bmesh.new()
-            print('root bones')
+            bm.from_object(input_mesh_object, depsgraph)
-            print(root_bones)
+            mesh_data = bpy.data.meshes.new('')
-            if len(root_bones) > 1:
+            bm.to_mesh(mesh_data)
-                root_bone_names = [x.name for x in bones]
+            del bm
-                raise RuntimeError('Exported bone hierarchy must have a single root bone.'
+            mesh_object = bpy.data.objects.new('', mesh_data)
-                                   f'The bone hierarchy marked for export has {len(root_bones)} root bones: {root_bone_names}')
+            mesh_object.matrix_world = input_mesh_object.matrix_world
 
-            for bone in bones:
+            # Copy the vertex groups
-                psk_bone = Psk.Bone()
+            for vertex_group in input_mesh_object.vertex_groups:
-                psk_bone.name = bytes(bone.name, encoding='utf-8')
+                mesh_object.vertex_groups.new(name=vertex_group.name)
-                psk_bone.flags = 0
-                psk_bone.children_count = 0
 
+            # Reactivate previously active armature modifiers
+            for modifier in active_armature_modifiers:
+                modifier.show_viewport = True
+
+        vertex_offset = len(psk.points)
+
+        # VERTICES
+        for vertex in mesh_data.vertices:
+            point = Vector3()
+            v = mesh_object.matrix_world @ vertex.co
+            point.x = v.x
+            point.y = v.y
+            point.z = v.z
+            psk.points.append(point)
+
+        uv_layer = mesh_data.uv_layers.active.data
+
+        # WEDGES
+        mesh_data.calc_loop_triangles()
+
+        # Build a list of non-unique wedges.
+        wedges = []
+        for loop_index, loop in enumerate(mesh_data.loops):
+            wedge = Psk.Wedge()
+            wedge.point_index = loop.vertex_index + vertex_offset
+            wedge.u, wedge.v = uv_layer[loop_index].uv
+            wedge.v = 1.0 - wedge.v
+            wedges.append(wedge)
+
+        # Assign material indices to the wedges.
+        for triangle in mesh_data.loop_triangles:
+            for loop_index in triangle.loops:
+                wedges[loop_index].material_index = material_indices[triangle.material_index]
+
+        # Populate the list of wedges with unique wedges & build a look-up table of loop indices to wedge indices
+        wedge_indices = {}
+        loop_wedge_indices = [-1] * len(mesh_data.loops)
+        for loop_index, wedge in enumerate(wedges):
+            wedge_hash = hash(wedge)
+            if wedge_hash in wedge_indices:
+                loop_wedge_indices[loop_index] = wedge_indices[wedge_hash]
+            else:
+                wedge_index = len(psk.wedges)
+                wedge_indices[wedge_hash] = wedge_index
+                psk.wedges.append(wedge)
+                loop_wedge_indices[loop_index] = wedge_index
+
+        # FACES
+        poly_groups, groups = mesh_data.calc_smooth_groups(use_bitflags=True)
+        for f in mesh_data.loop_triangles:
+            face = Psk.Face()
+            face.material_index = material_indices[f.material_index]
+            face.wedge_indices[0] = loop_wedge_indices[f.loops[2]]
+            face.wedge_indices[1] = loop_wedge_indices[f.loops[1]]
+            face.wedge_indices[2] = loop_wedge_indices[f.loops[0]]
+            face.smoothing_groups = poly_groups[f.polygon_index]
+            psk.faces.append(face)
+
+        # WEIGHTS
+        if armature_object is not None:
+            # Because the vertex groups may contain entries for which there is no matching bone in the armature,
+            # we must filter them out and not export any weights for these vertex groups.
+            bone_names = [x.name for x in bones]
+            vertex_group_names = [x.name for x in mesh_object.vertex_groups]
+            vertex_group_bone_indices = dict()
+            for vertex_group_index, vertex_group_name in enumerate(vertex_group_names):
                 try:
-                    parent_index = bones.index(bone.parent)
+                    vertex_group_bone_indices[vertex_group_index] = bone_names.index(vertex_group_name)
-                    psk_bone.parent_index = parent_index
-                    psk.bones[parent_index].children_count += 1
                 except ValueError:
-                    psk_bone.parent_index = 0
+                    # The vertex group does not have a matching bone in the list of bones to be exported.
-
+                    # Check to see if there is an associated bone for this vertex group that exists in the armature.
-                if bone.parent is not None:
+                    # If there is, we can traverse the ancestors of that bone to find an alternate bone to use for
-                    rotation = bone.matrix.to_quaternion()
+                    # weighting the vertices belonging to this vertex group.
-                    rotation.x = -rotation.x
+                    if vertex_group_name in armature_object.data.bones:
-                    rotation.y = -rotation.y
+                        bone = armature_object.data.bones[vertex_group_name]
-                    rotation.z = -rotation.z
+                        while bone is not None:
-                    quat_parent = bone.parent.matrix.to_quaternion().inverted()
+                            try:
-                    parent_head = quat_parent @ bone.parent.head
+                                bone_index = bone_names.index(bone.name)
-                    parent_tail = quat_parent @ bone.parent.tail
+                                vertex_group_bone_indices[vertex_group_index] = bone_index
-                    location = (parent_tail - parent_head) + bone.head
+                                break
-                else:
+                            except ValueError:
-                    location = armature_object.matrix_local @ bone.head
+                                bone = bone.parent
-                    rot_matrix = bone.matrix @ armature_object.matrix_local.to_3x3()
+            for vertex_group_index, vertex_group in enumerate(mesh_object.vertex_groups):
-                    rotation = rot_matrix.to_quaternion()
+                if vertex_group_index not in vertex_group_bone_indices:
-
+                    # Vertex group has no associated bone, skip it.
-                psk_bone.location.x = location.x
+                    continue
-                psk_bone.location.y = location.y
+                bone_index = vertex_group_bone_indices[vertex_group_index]
-                psk_bone.location.z = location.z
+                for vertex_index in range(len(mesh_data.vertices)):
-
-                psk_bone.rotation.x = rotation.x
-                psk_bone.rotation.y = rotation.y
-                psk_bone.rotation.z = rotation.z
-                psk_bone.rotation.w = rotation.w
-
-                psk.bones.append(psk_bone)
-
-        vertex_offset = 0
-
-        for object in input_objects.mesh_objects:
-            # VERTICES
-            for vertex in object.data.vertices:
-                point = Vector3()
-                v = object.matrix_world @ vertex.co
-                point.x = v.x
-                point.y = v.y
-                point.z = v.z
-                psk.points.append(point)
-
-            uv_layer = object.data.uv_layers.active.data
-
-            # MATERIALS
-            material_indices = []
-            for i, m in enumerate(object.data.materials):
-                if m is None:
-                    raise RuntimeError('Material cannot be empty (index ' + str(i) + ')')
-                if m.name in materials:
-                    material_index = list(materials.keys()).index(m.name)
-                else:
-                    material = Psk.Material()
-                    material.name = bytes(m.name, encoding='utf-8')
-                    material.texture_index = len(psk.materials)
-                    psk.materials.append(material)
-                    materials[m.name] = m
-                    material_index = material.texture_index
-                material_indices.append(material_index)
-
-            # WEDGES
-            object.data.calc_loop_triangles()
-
-            # Build a list of non-unique wedges.
-            wedges = []
-            for loop_index, loop in enumerate(object.data.loops):
-                wedge = Psk.Wedge()
-                wedge.point_index = loop.vertex_index + vertex_offset
-                wedge.u, wedge.v = uv_layer[loop_index].uv
-                wedge.v = 1.0 - wedge.v
-                wedges.append(wedge)
-
-            # Assign material indices to the wedges.
-            for triangle in object.data.loop_triangles:
-                for loop_index in triangle.loops:
-                    wedges[loop_index].material_index = material_indices[triangle.material_index]
-
-            # Populate the list of wedges with unique wedges & build a look-up table of loop indices to wedge indices
-            wedge_indices = {}
-            loop_wedge_indices = [-1] * len(object.data.loops)
-            for loop_index, wedge in enumerate(wedges):
-                wedge_hash = hash(wedge)
-                if wedge_hash in wedge_indices:
-                    loop_wedge_indices[loop_index] = wedge_indices[wedge_hash]
-                else:
-                    wedge_index = len(psk.wedges)
-                    wedge_indices[wedge_hash] = wedge_index
-                    psk.wedges.append(wedge)
-                    loop_wedge_indices[loop_index] = wedge_index
-
-            # FACES
-            poly_groups, groups = object.data.calc_smooth_groups(use_bitflags=True)
-            for f in object.data.loop_triangles:
-                face = Psk.Face()
-                face.material_index = material_indices[f.material_index]
-                face.wedge_indices[0] = loop_wedge_indices[f.loops[2]]
-                face.wedge_indices[1] = loop_wedge_indices[f.loops[1]]
-                face.wedge_indices[2] = loop_wedge_indices[f.loops[0]]
-                face.smoothing_groups = poly_groups[f.polygon_index]
-                psk.faces.append(face)
-
-            # WEIGHTS
-            if armature_object is not None:
-                # Because the vertex groups may contain entries for which there is no matching bone in the armature,
-                # we must filter them out and not export any weights for these vertex groups.
-                bone_names = [x.name for x in bones]
-                vertex_group_names = [x.name for x in object.vertex_groups]
-                vertex_group_bone_indices = dict()
-                for vertex_group_index, vertex_group_name in enumerate(vertex_group_names):
                     try:
-                        vertex_group_bone_indices[vertex_group_index] = bone_names.index(vertex_group_name)
+                        weight = vertex_group.weight(vertex_index)
-                    except ValueError:
+                    except RuntimeError:
-                        # The vertex group does not have a matching bone in the list of bones to be exported.
-                        # Check to see if there is an associated bone for this vertex group that exists in the armature.
-                        # If there is, we can traverse the ancestors of that bone to find an alternate bone to use for
-                        # weighting the vertices belonging to this vertex group.
-                        if vertex_group_name in armature_object.data.bones:
-                            bone = armature_object.data.bones[vertex_group_name]
-                            while bone is not None:
-                                try:
-                                    bone_index = bone_names.index(bone.name)
-                                    vertex_group_bone_indices[vertex_group_index] = bone_index
-                                    break
-                                except ValueError:
-                                    bone = bone.parent
-                for vertex_group_index, vertex_group in enumerate(object.vertex_groups):
-                    if vertex_group_index not in vertex_group_bone_indices:
                         continue
-                    bone_index = vertex_group_bone_indices[vertex_group_index]
+                    if weight == 0.0:
-                    # TODO: exclude vertex group if it doesn't match to a bone we are exporting
+                        continue
-                    for vertex_index in range(len(object.data.vertices)):
+                    w = Psk.Weight()
-                        try:
+                    w.bone_index = bone_index
-                            weight = vertex_group.weight(vertex_index)
+                    w.point_index = vertex_offset + vertex_index
-                        except RuntimeError:
+                    w.weight = weight
-                            continue
+                    psk.weights.append(w)
-                        if weight == 0.0:
-                            continue
-                        w = Psk.Weight()
-                        w.bone_index = bone_index
-                        w.point_index = vertex_offset + vertex_index
-                        w.weight = weight
-                        psk.weights.append(w)
 
-            vertex_offset = len(psk.points)
+        if not options.use_raw_mesh_data:
+            bpy.data.objects.remove(mesh_object)
+            bpy.data.meshes.remove(mesh_data)
+            del mesh_data
 
-        return psk
+    return psk

io_scene_psk_psa/psk/data.py

@@ -1,9 +1,9 @@
 from typing import List
+
 from ..data import *
 
 
 class Psk(object):
-
     class Wedge(object):
         def __init__(self):
             self.point_index: int = 0
@@ -41,6 +41,15 @@ class Psk(object):
             ('smoothing_groups', c_int32)
         ]
 
+    class Face32(Structure):
+        _pack_ = 1
+        _fields_ = [
+            ('wedge_indices', c_uint32 * 3),
+            ('material_index', c_uint8),
+            ('aux_material_index', c_uint8),
+            ('smoothing_groups', c_int32)
+        ]
+
     class Material(Structure):
         _fields_ = [
             ('name', c_char * 64),
@@ -71,6 +80,18 @@ class Psk(object):
             ('bone_index', c_int32),
         ]
 
+    @property
+    def has_extra_uvs(self):
+        return len(self.extra_uvs) > 0
+
+    @property
+    def has_vertex_colors(self):
+        return len(self.vertex_colors) > 0
+
+    @property
+    def has_vertex_normals(self):
+        return len(self.vertex_normals) > 0
+
     def __init__(self):
         self.points: List[Vector3] = []
         self.wedges: List[Psk.Wedge] = []
@@ -78,3 +99,6 @@ class Psk(object):
         self.materials: List[Psk.Material] = []
         self.weights: List[Psk.Weight] = []
         self.bones: List[Psk.Bone] = []
+        self.extra_uvs: List[Vector2] = []
+        self.vertex_colors: List[Color] = []
+        self.vertex_normals: List[Vector3] = []

io_scene_psk_psa/psk/exporter.py

@@ -1,11 +1,13 @@
-from .data import *
-from ..types import BoneGroupListItem
-from ..helpers import populate_bone_group_list
-from .builder import PskBuilder, PskBuilderOptions
 from typing import Type
-from bpy.types import Operator, PropertyGroup
+
+from bpy.props import BoolProperty, StringProperty, CollectionProperty, IntProperty, EnumProperty
+from bpy.types import Operator, PropertyGroup, UIList
 from bpy_extras.io_utils import ExportHelper
-from bpy.props import StringProperty, CollectionProperty, IntProperty, BoolProperty, EnumProperty
+
+from .builder import build_psk, PskBuildOptions, get_psk_input_objects
+from .data import *
+from ..helpers import populate_bone_group_list
+from ..types import BoneGroupListItem
 
 MAX_WEDGE_COUNT = 65536
 MAX_POINT_COUNT = 4294967296
@@ -13,55 +15,50 @@ MAX_BONE_COUNT = 256
 MAX_MATERIAL_COUNT = 256
 
 
-class PskExporter(object):
+def _write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None):
+    section = Section()
+    section.name = name
+    if data_type is not None and data is not None:
+        section.data_size = sizeof(data_type)
+        section.data_count = len(data)
+    fp.write(section)
+    if data is not None:
+        for datum in data:
+            fp.write(datum)
 
-    def __init__(self, psk: Psk):
-        self.psk: Psk = psk
 
-    @staticmethod
+def export_psk(psk: Psk, path: str):
-    def write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None):
+    if len(psk.wedges) > MAX_WEDGE_COUNT:
-        section = Section()
+        raise RuntimeError(f'Number of wedges ({len(psk.wedges)}) exceeds limit of {MAX_WEDGE_COUNT}')
-        section.name = name
+    if len(psk.bones) > MAX_BONE_COUNT:
-        if data_type is not None and data is not None:
+        raise RuntimeError(f'Number of bones ({len(psk.bones)}) exceeds limit of {MAX_BONE_COUNT}')
-            section.data_size = sizeof(data_type)
+    if len(psk.points) > MAX_POINT_COUNT:
-            section.data_count = len(data)
+        raise RuntimeError(f'Numbers of vertices ({len(psk.points)}) exceeds limit of {MAX_POINT_COUNT}')
-        fp.write(section)
+    if len(psk.materials) > MAX_MATERIAL_COUNT:
-        if data is not None:
+        raise RuntimeError(f'Number of materials ({len(psk.materials)}) exceeds limit of {MAX_MATERIAL_COUNT}')
-            for datum in data:
-                fp.write(datum)
 
-    def export(self, path: str):
+    with open(path, 'wb') as fp:
-        if len(self.psk.wedges) > MAX_WEDGE_COUNT:
+        _write_section(fp, b'ACTRHEAD')
-            raise RuntimeError(f'Number of wedges ({len(self.psk.wedges)}) exceeds limit of {MAX_WEDGE_COUNT}')
+        _write_section(fp, b'PNTS0000', Vector3, psk.points)
-        if len(self.psk.bones) > MAX_BONE_COUNT:
-            raise RuntimeError(f'Number of bones ({len(self.psk.bones)}) exceeds limit of {MAX_BONE_COUNT}')
-        if len(self.psk.points) > MAX_POINT_COUNT:
-            raise RuntimeError(f'Numbers of vertices ({len(self.psk.points)}) exceeds limit of {MAX_POINT_COUNT}')
-        if len(self.psk.materials) > MAX_MATERIAL_COUNT:
-            raise RuntimeError(f'Number of materials ({len(self.psk.materials)}) exceeds limit of {MAX_MATERIAL_COUNT}')
 
-        with open(path, 'wb') as fp:
+        wedges = []
-            self.write_section(fp, b'ACTRHEAD')
+        for index, w in enumerate(psk.wedges):
-            self.write_section(fp, b'PNTS0000', Vector3, self.psk.points)
+            wedge = Psk.Wedge16()
+            wedge.material_index = w.material_index
+            wedge.u = w.u
+            wedge.v = w.v
+            wedge.point_index = w.point_index
+            wedges.append(wedge)
 
-            wedges = []
+        _write_section(fp, b'VTXW0000', Psk.Wedge16, wedges)
-            for index, w in enumerate(self.psk.wedges):
+        _write_section(fp, b'FACE0000', Psk.Face, psk.faces)
-                wedge = Psk.Wedge16()
+        _write_section(fp, b'MATT0000', Psk.Material, psk.materials)
-                wedge.material_index = w.material_index
+        _write_section(fp, b'REFSKELT', Psk.Bone, psk.bones)
-                wedge.u = w.u
+        _write_section(fp, b'RAWWEIGHTS', Psk.Weight, psk.weights)
-                wedge.v = w.v
-                wedge.point_index = w.point_index
-                wedges.append(wedge)
-
-            self.write_section(fp, b'VTXW0000', Psk.Wedge16, wedges)
-            self.write_section(fp, b'FACE0000', Psk.Face, self.psk.faces)
-            self.write_section(fp, b'MATT0000', Psk.Material, self.psk.materials)
-            self.write_section(fp, b'REFSKELT', Psk.Bone, self.psk.bones)
-            self.write_section(fp, b'RAWWEIGHTS', Psk.Weight, self.psk.weights)
 
 
 def is_bone_filter_mode_item_available(context, identifier):
-    input_objects = PskBuilder.get_input_objects(context)
+    input_objects = get_psk_input_objects(context)
     armature_object = input_objects.armature_object
     if identifier == 'BONE_GROUPS':
         if not armature_object or not armature_object.pose or not armature_object.pose.bone_groups:
@@ -70,9 +67,79 @@ def is_bone_filter_mode_item_available(context, identifier):
     return True
 
 
+class PSK_UL_MaterialList(UIList):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
+        row = layout.row()
+        row.label(text=str(getattr(item, 'material_name')), icon='MATERIAL')
+
+
+class MaterialListItem(PropertyGroup):
+    material_name: StringProperty()
+    index: IntProperty()
+
+    @property
+    def name(self):
+        return self.material_name
+
+
+def populate_material_list(mesh_objects, material_list):
+    material_list.clear()
+
+    material_names = []
+    for mesh_object in mesh_objects:
+        for i, material in enumerate(mesh_object.data.materials):
+            # TODO: put this in the poll arg?
+            if material is None:
+                raise RuntimeError('Material cannot be empty (index ' + str(i) + ')')
+            if material.name not in material_names:
+                material_names.append(material.name)
+
+    for index, material_name in enumerate(material_names):
+        m = material_list.add()
+        m.material_name = material_name
+        m.index = index
+
+
+class PskMaterialListItemMoveUp(Operator):
+    bl_idname = 'psk_export.material_list_item_move_up'
+    bl_label = 'Move Up'
+    bl_options = {'INTERNAL'}
+    bl_description = 'Move the selected material up one slot'
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psk_export')
+        return pg.material_list_index > 0
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psk_export')
+        pg.material_list.move(pg.material_list_index, pg.material_list_index - 1)
+        pg.material_list_index -= 1
+        return {"FINISHED"}
+
+
+class PskMaterialListItemMoveDown(Operator):
+    bl_idname = 'psk_export.material_list_item_move_down'
+    bl_label = 'Move Down'
+    bl_options = {'INTERNAL'}
+    bl_description = 'Move the selected material down one slot'
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psk_export')
+        return pg.material_list_index < len(pg.material_list) - 1
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psk_export')
+        pg.material_list.move(pg.material_list_index, pg.material_list_index + 1)
+        pg.material_list_index += 1
+        return {"FINISHED"}
+
+
 class PskExportOperator(Operator, ExportHelper):
     bl_idname = 'export.psk'
     bl_label = 'Export'
+    bl_options = {'INTERNAL', 'UNDO'}
     __doc__ = 'Export mesh and armature to PSK'
     filename_ext = '.psk'
     filter_glob: StringProperty(default='*.psk', options={'HIDDEN'})
@@ -85,70 +152,103 @@ class PskExportOperator(Operator, ExportHelper):
 
     def invoke(self, context, event):
         try:
-            input_objects = PskBuilder.get_input_objects(context)
+            input_objects = get_psk_input_objects(context)
         except RuntimeError as e:
             self.report({'ERROR_INVALID_CONTEXT'}, str(e))
             return {'CANCELLED'}
 
-        property_group = context.scene.psk_export
+        pg = getattr(context.scene, 'psk_export')
 
         # Populate bone groups list.
-        populate_bone_group_list(input_objects.armature_object, property_group.bone_group_list)
+        populate_bone_group_list(input_objects.armature_object, pg.bone_group_list)
+        populate_material_list(input_objects.mesh_objects, pg.material_list)
 
         context.window_manager.fileselect_add(self)
 
         return {'RUNNING_MODAL'}
 
+    @classmethod
+    def poll(cls, context):
+        try:
+            get_psk_input_objects(context)
+        except RuntimeError as e:
+            cls.poll_message_set(str(e))
+            return False
+        return True
+
     def draw(self, context):
         layout = self.layout
-        scene = context.scene
+        pg = getattr(context.scene, 'psk_export')
-        property_group = scene.psk_export
+
+        layout.prop(pg, 'use_raw_mesh_data')
 
         # BONES
-        box = layout.box()
+        layout.label(text='Bones', icon='BONE_DATA')
-        box.label(text='Bones', icon='BONE_DATA')
+        bone_filter_mode_items = pg.bl_rna.properties['bone_filter_mode'].enum_items_static
-        bone_filter_mode_items = property_group.bl_rna.properties['bone_filter_mode'].enum_items_static
+        row = layout.row(align=True)
-        row = box.row(align=True)
         for item in bone_filter_mode_items:
             identifier = item.identifier
             item_layout = row.row(align=True)
-            item_layout.prop_enum(property_group, 'bone_filter_mode', item.identifier)
+            item_layout.prop_enum(pg, 'bone_filter_mode', item.identifier)
             item_layout.enabled = is_bone_filter_mode_item_available(context, identifier)
 
-        if property_group.bone_filter_mode == 'BONE_GROUPS':
+        if pg.bone_filter_mode == 'BONE_GROUPS':
-            row = box.row()
+            row = layout.row()
-            rows = max(3, min(len(property_group.bone_group_list), 10))
+            rows = max(3, min(len(pg.bone_group_list), 10))
-            row.template_list('PSX_UL_BoneGroupList', '', property_group, 'bone_group_list', property_group, 'bone_group_list_index', rows=rows)
+            row.template_list('PSX_UL_BoneGroupList', '', pg, 'bone_group_list', pg, 'bone_group_list_index', rows=rows)
+
+        layout.separator()
+
+        # MATERIALS
+        layout.label(text='Materials', icon='MATERIAL')
+        row = layout.row()
+        rows = max(3, min(len(pg.bone_group_list), 10))
+        row.template_list('PSK_UL_MaterialList', '', pg, 'material_list', pg, 'material_list_index', rows=rows)
+        col = row.column(align=True)
+        col.operator(PskMaterialListItemMoveUp.bl_idname, text='', icon='TRIA_UP')
+        col.operator(PskMaterialListItemMoveDown.bl_idname, text='', icon='TRIA_DOWN')
 
     def execute(self, context):
-        property_group = context.scene.psk_export
+        pg = context.scene.psk_export
-        builder = PskBuilder()
+        options = PskBuildOptions()
-        options = PskBuilderOptions()
+        options.bone_filter_mode = pg.bone_filter_mode
-        options.bone_group_indices = [x.index for x in property_group.bone_group_list if x.is_selected]
+        options.bone_group_indices = [x.index for x in pg.bone_group_list if x.is_selected]
+        options.use_raw_mesh_data = pg.use_raw_mesh_data
+        options.material_names = [m.material_name for m in pg.material_list]
+
         try:
-            psk = builder.build(context, options)
+            psk = build_psk(context, options)
+            export_psk(psk, self.filepath)
+            self.report({'INFO'}, f'PSK export successful')
         except RuntimeError as e:
             self.report({'ERROR_INVALID_CONTEXT'}, str(e))
             return {'CANCELLED'}
-        exporter = PskExporter(psk)
-        exporter.export(self.filepath)
         return {'FINISHED'}
 
 
 class PskExportPropertyGroup(PropertyGroup):
     bone_filter_mode: EnumProperty(
         name='Bone Filter',
+        options=set(),
         description='',
         items=(
             ('ALL', 'All', 'All bones will be exported.'),
-            ('BONE_GROUPS', 'Bone Groups', 'Only bones belonging to the selected bone groups and their ancestors will be exported.')
+            ('BONE_GROUPS', 'Bone Groups',
+             'Only bones belonging to the selected bone groups and their ancestors will be exported.')
         )
     )
     bone_group_list: CollectionProperty(type=BoneGroupListItem)
     bone_group_list_index: IntProperty(default=0)
+    use_raw_mesh_data: BoolProperty(default=False, name='Raw Mesh Data', description='No modifiers will be evaluated as part of the exported mesh')
+    material_list: CollectionProperty(type=MaterialListItem)
+    material_list_index: IntProperty(default=0)
 
 
-__classes__ = [
+classes = (
+    MaterialListItem,
+    PSK_UL_MaterialList,
+    PskMaterialListItemMoveUp,
+    PskMaterialListItemMoveDown,
     PskExportOperator,
-    PskExportPropertyGroup
+    PskExportPropertyGroup,
-]
+)

io_scene_psk_psa/psk/importer.py

@@ -1,23 +1,58 @@
 import os
-import bpy
+import sys
+from math import inf
+from typing import Optional, List
+
 import bmesh
-from typing import Optional
+import bpy
-from .data import Psk
+import numpy as np
-from mathutils import Quaternion, Vector, Matrix
+from bpy.props import BoolProperty, EnumProperty, FloatProperty, StringProperty
-from .reader import PskReader
+from bpy.types import Operator, PropertyGroup, VertexGroup
-from bpy.props import StringProperty
-from bpy.types import Operator
 from bpy_extras.io_utils import ImportHelper
+from mathutils import Quaternion, Vector, Matrix
+
+from .data import Psk
+from .reader import read_psk
+from ..helpers import rgb_to_srgb
 
 
-class PskImporter(object):
+class PskImportOptions(object):
     def __init__(self):
-        pass
+        self.name = ''
+        self.should_import_mesh = True
+        self.should_import_vertex_colors = True
+        self.vertex_color_space = 'sRGB'
+        self.should_import_vertex_normals = True
+        self.should_import_extra_uvs = True
+        self.should_import_skeleton = True
+        self.bone_length = 1.0
 
-    def import_psk(self, psk: Psk, name: str, context):
+
+class ImportBone(object):
+    """
+    Intermediate bone type for the purpose of construction.
+    """
+    def __init__(self, index: int, psk_bone: Psk.Bone):
+        self.index: int = index
+        self.psk_bone: Psk.Bone = psk_bone
+        self.parent: Optional[ImportBone] = None
+        self.local_rotation: Quaternion = Quaternion()
+        self.local_translation: Vector = Vector()
+        self.world_rotation_matrix: Matrix = Matrix()
+        self.world_matrix: Matrix = Matrix()
+        self.vertex_group = None
+        self.orig_quat: Quaternion = Quaternion()
+        self.orig_loc: Vector = Vector()
+        self.post_quat: Quaternion = Quaternion()
+
+
+def import_psk(psk: Psk, context, options: PskImportOptions):
+    armature_object = None
+
+    if options.should_import_skeleton:
         # ARMATURE
-        armature_data = bpy.data.armatures.new(name)
+        armature_data = bpy.data.armatures.new(options.name)
-        armature_object = bpy.data.objects.new(name, armature_data)
+        armature_object = bpy.data.objects.new(options.name, armature_data)
         armature_object.show_in_front = True
 
         context.scene.collection.objects.link(armature_object)
@@ -32,23 +67,7 @@ class PskImporter(object):
 
         bpy.ops.object.mode_set(mode='EDIT')
 
-        # Intermediate bone type for the purpose of construction.
-        class ImportBone(object):
-            def __init__(self, index: int, psk_bone: Psk.Bone):
-                self.index: int = index
-                self.psk_bone: Psk.Bone = psk_bone
-                self.parent: Optional[ImportBone] = None
-                self.local_rotation: Quaternion = Quaternion()
-                self.local_translation: Vector = Vector()
-                self.world_rotation_matrix: Matrix = Matrix()
-                self.world_matrix: Matrix = Matrix()
-                self.vertex_group = None
-                self.orig_quat: Quaternion = Quaternion()
-                self.orig_loc: Vector = Vector()
-                self.post_quat: Quaternion = Quaternion()
-
         import_bones = []
-        new_bone_size = 8.0
 
         for bone_index, psk_bone in enumerate(psk.bones):
             import_bone = ImportBone(bone_index, psk_bone)
@@ -81,7 +100,7 @@ class PskImporter(object):
             else:
                 import_bone.local_rotation.conjugate()
 
-            edit_bone.tail = Vector((0.0, new_bone_size, 0.0))
+            edit_bone.tail = Vector((0.0, options.bone_length, 0.0))
             edit_bone_matrix = import_bone.local_rotation.conjugated()
             edit_bone_matrix.rotate(import_bone.world_matrix)
             edit_bone_matrix = edit_bone_matrix.to_matrix().to_4x4()
@@ -94,9 +113,10 @@ class PskImporter(object):
             edit_bone['orig_loc'] = import_bone.local_translation
             edit_bone['post_quat'] = import_bone.local_rotation.conjugated()
 
-        # MESH
+    # MESH
-        mesh_data = bpy.data.meshes.new(name)
+    if options.should_import_mesh:
-        mesh_object = bpy.data.objects.new(name, mesh_data)
+        mesh_data = bpy.data.meshes.new(options.name)
+        mesh_object = bpy.data.objects.new(options.name, mesh_data)
 
         # MATERIALS
         for material in psk.materials:
@@ -120,7 +140,6 @@ class PskImporter(object):
                 bm_face.material_index = face.material_index
             except ValueError:
                 degenerate_face_indices.add(face_index)
-                pass
 
         if len(degenerate_face_indices) > 0:
             print(f'WARNING: Discarded {len(degenerate_face_indices)} degenerate face(s).')
@@ -129,7 +148,7 @@ class PskImporter(object):
 
         # TEXTURE COORDINATES
         data_index = 0
-        uv_layer = mesh_data.uv_layers.new()
+        uv_layer = mesh_data.uv_layers.new(name='VTXW0000')
         for face_index, face in enumerate(psk.faces):
             if face_index in degenerate_face_indices:
                 continue
@@ -138,38 +157,148 @@ class PskImporter(object):
                 uv_layer.data[data_index].uv = wedge.u, 1.0 - wedge.v
                 data_index += 1
 
+        # EXTRA UVS
+        if psk.has_extra_uvs and options.should_import_extra_uvs:
+            extra_uv_channel_count = int(len(psk.extra_uvs) / len(psk.wedges))
+            wedge_index_offset = 0
+            for extra_uv_index in range(extra_uv_channel_count):
+                data_index = 0
+                uv_layer = mesh_data.uv_layers.new(name=f'EXTRAUV{extra_uv_index}')
+                for face_index, face in enumerate(psk.faces):
+                    if face_index in degenerate_face_indices:
+                        continue
+                    for wedge_index in reversed(face.wedge_indices):
+                        u, v = psk.extra_uvs[wedge_index_offset + wedge_index]
+                        uv_layer.data[data_index].uv = u, 1.0 - v
+                        data_index += 1
+                wedge_index_offset += len(psk.wedges)
+
+        # VERTEX COLORS
+        if psk.has_vertex_colors and options.should_import_vertex_colors:
+            size = (len(psk.points), 4)
+            vertex_colors = np.full(size, inf)
+            vertex_color_data = mesh_data.vertex_colors.new(name='VERTEXCOLOR')
+            ambiguous_vertex_color_point_indices = []
+
+            for wedge_index, wedge in enumerate(psk.wedges):
+                point_index = wedge.point_index
+                psk_vertex_color = psk.vertex_colors[wedge_index].normalized()
+                if vertex_colors[point_index, 0] != inf and tuple(vertex_colors[point_index]) != psk_vertex_color:
+                    ambiguous_vertex_color_point_indices.append(point_index)
+                else:
+                    vertex_colors[point_index] = psk_vertex_color
+
+            if options.vertex_color_space == 'SRGBA':
+                for i in range(vertex_colors.shape[0]):
+                    vertex_colors[i, :3] = tuple(map(lambda x: rgb_to_srgb(x), vertex_colors[i, :3]))
+
+            for loop_index, loop in enumerate(mesh_data.loops):
+                vertex_color = vertex_colors[loop.vertex_index]
+                if vertex_color is not None:
+                    vertex_color_data.data[loop_index].color = vertex_color
+                else:
+                    vertex_color_data.data[loop_index].color = 1.0, 1.0, 1.0, 1.0
+
+            if len(ambiguous_vertex_color_point_indices) > 0:
+                print(f'WARNING: {len(ambiguous_vertex_color_point_indices)} vertex(es) with ambiguous vertex colors.')
+
+        # VERTEX NORMALS
+        if psk.has_vertex_normals and options.should_import_vertex_normals:
+            mesh_data.polygons.foreach_set("use_smooth", [True] * len(mesh_data.polygons))
+            normals = []
+            for vertex_normal in psk.vertex_normals:
+                normals.append(tuple(vertex_normal))
+            mesh_data.normals_split_custom_set_from_vertices(normals)
+            mesh_data.use_auto_smooth = True
+
         bm.normal_update()
         bm.free()
 
-        # VERTEX WEIGHTS
-
         # Get a list of all bones that have weights associated with them.
         vertex_group_bone_indices = set(map(lambda weight: weight.bone_index, psk.weights))
-        for import_bone in map(lambda x: import_bones[x], sorted(list(vertex_group_bone_indices))):
+        vertex_groups: List[Optional[VertexGroup]] = [None] * len(psk.bones)
-            import_bone.vertex_group = mesh_object.vertex_groups.new(name=import_bone.psk_bone.name.decode('windows-1252'))
+        for bone_index, psk_bone in map(lambda x: (x, psk.bones[x]), vertex_group_bone_indices):
+            vertex_groups[bone_index] = mesh_object.vertex_groups.new(name=psk_bone.name.decode('windows-1252'))
 
         for weight in psk.weights:
-            import_bones[weight.bone_index].vertex_group.add((weight.point_index,), weight.weight, 'ADD')
+            vertex_groups[weight.bone_index].add((weight.point_index,), weight.weight, 'ADD')
-
-        # Add armature modifier to our mesh object.
-        armature_modifier = mesh_object.modifiers.new(name='Armature', type='ARMATURE')
-        armature_modifier.object = armature_object
-        mesh_object.parent = armature_object
 
         context.scene.collection.objects.link(mesh_object)
 
-        try:
+        # Add armature modifier to our mesh object.
-            bpy.ops.object.mode_set(mode='OBJECT')
+        if options.should_import_skeleton:
-        except:
+            armature_modifier = mesh_object.modifiers.new(name='Armature', type='ARMATURE')
-            pass
+            armature_modifier.object = armature_object
+            mesh_object.parent = armature_object
+
+    try:
+        bpy.ops.object.mode_set(mode='OBJECT')
+    except:
+        pass
+
+
+empty_set = set()
+
+
+class PskImportPropertyGroup(PropertyGroup):
+    should_import_vertex_colors: BoolProperty(
+        default=True,
+        options=empty_set,
+        name='Vertex Colors',
+        description='Import vertex colors from PSKX files, if available'
+    )
+    vertex_color_space: EnumProperty(
+        name='Vertex Color Space',
+        options=empty_set,
+        description='The source vertex color space',
+        default='SRGBA',
+        items=(
+            ('LINEAR', 'Linear', ''),
+            ('SRGBA', 'sRGBA', ''),
+        )
+    )
+    should_import_vertex_normals: BoolProperty(
+        default=True,
+        name='Vertex Normals',
+        options=empty_set,
+        description='Import vertex normals from PSKX files, if available'
+    )
+    should_import_extra_uvs: BoolProperty(
+        default=True,
+        name='Extra UVs',
+        options=empty_set,
+        description='Import extra UV maps from PSKX files, if available'
+    )
+    should_import_mesh: BoolProperty(
+        default=True,
+        name='Import Mesh',
+        options=empty_set,
+        description='Import mesh'
+    )
+    should_import_skeleton: BoolProperty(
+        default=True,
+        name='Import Skeleton',
+        options=empty_set,
+        description='Import skeleton'
+    )
+    bone_length: FloatProperty(
+        default=1.0,
+        min=sys.float_info.epsilon,
+        step=100,
+        soft_min=1.0,
+        name='Bone Length',
+        options=empty_set,
+        description='Length of the bones'
+    )
 
 
 class PskImportOperator(Operator, ImportHelper):
     bl_idname = 'import.psk'
-    bl_label = 'Export'
+    bl_label = 'Import'
+    bl_options = {'INTERNAL', 'UNDO'}
     __doc__ = 'Load a PSK file'
     filename_ext = '.psk'
-    filter_glob: StringProperty(default='*.psk', options={'HIDDEN'})
+    filter_glob: StringProperty(default='*.psk;*.pskx', options={'HIDDEN'})
     filepath: StringProperty(
         name='File Path',
         description='File path used for exporting the PSK file',
@@ -177,13 +306,46 @@ class PskImportOperator(Operator, ImportHelper):
         default='')
 
     def execute(self, context):
-        reader = PskReader()
+        pg = getattr(context.scene, 'psk_import')
-        psk = reader.read(self.filepath)
+
-        name = os.path.splitext(os.path.basename(self.filepath))[0]
+        psk = read_psk(self.filepath)
-        PskImporter().import_psk(psk, name, context)
+
+        options = PskImportOptions()
+        options.name = os.path.splitext(os.path.basename(self.filepath))[0]
+        options.should_import_mesh = pg.should_import_mesh
+        options.should_import_extra_uvs = pg.should_import_extra_uvs
+        options.should_import_vertex_colors = pg.should_import_vertex_colors
+        options.should_import_vertex_normals = pg.should_import_vertex_normals
+        options.vertex_color_space = pg.vertex_color_space
+        options.should_import_skeleton = pg.should_import_skeleton
+        options.bone_length = pg.bone_length
+
+        import_psk(psk, context, options)
+
         return {'FINISHED'}
 
+    def draw(self, context):
+        pg = getattr(context.scene, 'psk_import')
+        layout = self.layout
+        layout.prop(pg, 'should_import_mesh')
+        row = layout.column()
+        row.use_property_split = True
+        row.use_property_decorate = False
+        if pg.should_import_mesh:
+            row.prop(pg, 'should_import_vertex_normals')
+            row.prop(pg, 'should_import_extra_uvs')
+            row.prop(pg, 'should_import_vertex_colors')
+            if pg.should_import_vertex_colors:
+                row.prop(pg, 'vertex_color_space')
+        layout.prop(pg, 'should_import_skeleton')
+        row = layout.column()
+        row.use_property_split = True
+        row.use_property_decorate = False
+        if pg.should_import_skeleton:
+            row.prop(pg, 'bone_length')
 
-__classes__ = [
+
-    PskImportOperator
+classes = (
-]
+    PskImportOperator,
+    PskImportPropertyGroup,
+)

io_scene_psk_psa/psk/reader.py

@@ -1,46 +1,50 @@
-from .data import *
 import ctypes
 
+from .data import *
 
-class PskReader(object):
 
-    def __init__(self):
+def _read_types(fp, data_class, section: Section, data):
-        pass
+    buffer_length = section.data_size * section.data_count
+    buffer = fp.read(buffer_length)
+    offset = 0
+    for _ in range(section.data_count):
+        data.append(data_class.from_buffer_copy(buffer, offset))
+        offset += section.data_size
 
-    @staticmethod
-    def read_types(fp, data_class: ctypes.Structure, section: Section, data):
-        buffer_length = section.data_size * section.data_count
-        buffer = fp.read(buffer_length)
-        offset = 0
-        for _ in range(section.data_count):
-            data.append(data_class.from_buffer_copy(buffer, offset))
-            offset += section.data_size
 
-    def read(self, path) -> Psk:
+def read_psk(path) -> Psk:
-        psk = Psk()
+    psk = Psk()
-        with open(path, 'rb') as fp:
+    with open(path, 'rb') as fp:
-            while fp.read(1):
+        while fp.read(1):
-                fp.seek(-1, 1)
+            fp.seek(-1, 1)
-                section = Section.from_buffer_copy(fp.read(ctypes.sizeof(Section)))
+            section = Section.from_buffer_copy(fp.read(ctypes.sizeof(Section)))
-                if section.name == b'ACTRHEAD':
+            if section.name == b'ACTRHEAD':
-                    pass
+                pass
-                elif section.name == b'PNTS0000':
+            elif section.name == b'PNTS0000':
-                    PskReader.read_types(fp, Vector3, section, psk.points)
+                _read_types(fp, Vector3, section, psk.points)
-                elif section.name == b'VTXW0000':
+            elif section.name == b'VTXW0000':
-                    if section.data_size == ctypes.sizeof(Psk.Wedge16):
+                if section.data_size == ctypes.sizeof(Psk.Wedge16):
-                        PskReader.read_types(fp, Psk.Wedge16, section, psk.wedges)
+                    _read_types(fp, Psk.Wedge16, section, psk.wedges)
-                    elif section.data_size == ctypes.sizeof(Psk.Wedge32):
+                elif section.data_size == ctypes.sizeof(Psk.Wedge32):
-                        PskReader.read_types(fp, Psk.Wedge32, section, psk.wedges)
+                    _read_types(fp, Psk.Wedge32, section, psk.wedges)
-                    else:
-                        raise RuntimeError('Unrecognized wedge format')
-                elif section.name == b'FACE0000':
-                    PskReader.read_types(fp, Psk.Face, section, psk.faces)
-                elif section.name == b'MATT0000':
-                    PskReader.read_types(fp, Psk.Material, section, psk.materials)
-                elif section.name == b'REFSKELT':
-                    PskReader.read_types(fp, Psk.Bone, section, psk.bones)
-                elif section.name == b'RAWWEIGHTS':
-                    PskReader.read_types(fp, Psk.Weight, section, psk.weights)
                 else:
-                    raise RuntimeError(f'Unrecognized section "{section.name}"')
+                    raise RuntimeError('Unrecognized wedge format')
-        return psk
+            elif section.name == b'FACE0000':
+                _read_types(fp, Psk.Face, section, psk.faces)
+            elif section.name == b'MATT0000':
+                _read_types(fp, Psk.Material, section, psk.materials)
+            elif section.name == b'REFSKELT':
+                _read_types(fp, Psk.Bone, section, psk.bones)
+            elif section.name == b'RAWWEIGHTS':
+                _read_types(fp, Psk.Weight, section, psk.weights)
+            elif section.name == b'FACE3200':
+                _read_types(fp, Psk.Face32, section, psk.faces)
+            elif section.name == b'VERTEXCOLOR':
+                _read_types(fp, Color, section, psk.vertex_colors)
+            elif section.name.startswith(b'EXTRAUVS'):
+                _read_types(fp, Vector2, section, psk.extra_uvs)
+            elif section.name == b'VTXNORMS':
+                _read_types(fp, Vector3, section, psk.vertex_normals)
+            else:
+                raise RuntimeError(f'Unrecognized section "{section.name} at position {15:fp.tell()}"')
+    return psk

io_scene_psk_psa/types.py

@@ -1,25 +1,24 @@
-from bpy.types import PropertyGroup, UIList
 from bpy.props import StringProperty, IntProperty, BoolProperty
+from bpy.types import PropertyGroup, UIList, UILayout, Context, AnyType
 
 
 class PSX_UL_BoneGroupList(UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
+
-        layout.alignment = 'LEFT'
+    def draw_item(self, context: Context, layout: UILayout, data: AnyType, item: AnyType, icon: int,
-        layout.prop(item, 'is_selected', icon_only=True)
+                  active_data: AnyType, active_property: str, index: int = 0, flt_flag: int = 0):
-        layout.label(text=item.name, icon='GROUP_BONE' if item.index >= 0 else 'NONE')
+        row = layout.row()
+        row.prop(item, 'is_selected', text=getattr(item, 'name'))
+        row.label(text=str(getattr(item, 'count')), icon='BONE_DATA')
 
 
 class BoneGroupListItem(PropertyGroup):
     name: StringProperty()
     index: IntProperty()
+    count: IntProperty()
     is_selected: BoolProperty(default=False)
 
-    @property
-    def name(self):
-        return self.name
 
-
+classes = (
-__classes__ = [
     BoneGroupListItem,
-    PSX_UL_BoneGroupList
+    PSX_UL_BoneGroupList,
-]
+)