Incremented version to 5.0.3

This is because a face can still be rejected by being a duplicate, but it doesn't necessarily have to be degenerate (i.e., a line or point).

README.md

@@ -1,46 +1,50 @@
-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.
+[![Blender](https://img.shields.io/badge/Blender->=3.4-blue?logo=blender&logoColor=white)](https://www.blender.org/download/ "Download Blender")
+[![GitHub release](https://img.shields.io/github/release/DarklightGames/io_scene_psk_psa?include_prereleases=&sort=semver&color=blue)](https://github.com/DarklightGames/io_scene_psk_psa/releases/)
+
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/L4L3853VR)
+
+This Blender 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 versions of the Unreal Engine.
+
+> **NOTE**: This addon requires Blender 3.4+. If this is not available to you, install version [4.3.0](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/4.3.0), as it has a minimum Blender version of 2.9, but is no longer receiving new features.
 
 # 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 
+* Full PSK/PSA import and export capabilities.
+* Non-standard file section data is supported for import only (vertex normals, extra UV channels, vertex colors, shape keys).
+* Fine-grained PSA sequence importing for efficient workflow when working with large PSA files.
+* 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.
+* Manual re-ordering of material slots when exporting multiple mesh objects.
 
 # Installation
 1. Download the zip file for the latest version from the [releases](https://github.com/DarklightGames/io_export_psk_psa/releases) page.
-2. Open Blender 2.80 or later.
-3. Navigate to the Blender Preferences (Edit > Preferences).
-4. Select the "Add-ons" tab.
-5. Click the "Install..." button.
-6. Select the .zip file that you downloaded earlier and click "Install Add-on".
-7. Enable the newly added "Import-Export: PSK/PSA Importer/Exporter" addon.
+2. Open Blender 3.4.0 or later.
+3. Navigate to the Blender Preferences (`Edit` > `Preferences`).
+4. Select the `Add-ons` tab.
+5. Click the `Install...` button.
+6. Select the .zip file that you downloaded earlier and click `Install Add-on`.
+7. Enable the newly added `Import-Export: PSK/PSA Importer/Exporter` addon.
 
 # Usage
 ## Exporting a PSK
 1. Select the mesh objects you wish to export.
-3. Navigate to File > Export > Unreal PSK (.psk)
-4. Enter the file name and click "Export".
+2. Navigate to `File` > `Export` > `Unreal PSK (.psk)`.
+3. Enter the file name and click `Export`.
 
 ## Importing a PSK/PSKX
-1. Navigate to File > Import > Unreal PSK (.psk/.pskx)
-2. Select the PSK file you want to import and click "Import"
+1. Navigate to `File` > `Import` > `Unreal PSK (.psk/.pskx)`.
+2. Select the PSK file you want to import and click `Import`.
 
 ## Exporting a PSA
 1. Select the armature objects you wish to export.
-2. Navigate to File > Export > Unreal PSA (.psa)
-3. Enter the file name and click "Export".
+2. Navigate to `File` > `Export` > `Unreal PSA (.psa)`.
+3. Enter the file name and click `Export`.
 
 ## Importing a PSA
-1. Select the armature object that you wish you import actions to.
-2. Navigate to the Object Data Properties tab of the Properties editor.
-3. Navigate to the PSA Import panel.
-4. Click "Select PSA File".
-5. Select the PSA file that you want to import animations from and click "Select".
-6. In the Actions box, select which animations you want to import.
-7. Click "Import".
+1. Select an armature that you want import animations for.
+2. Navigate to `File` > `Import` > `Unreal PSA (.psa)`.
+3. Select the PSA file you want to import.
+4. Select the sequences that you want to import and click `Import`.
 
 # FAQ
 ## Why are the mesh normals not accurate when importing a PSK extracted from [UE Viewer](https://www.gildor.org/en/projects/umodel)?

build.py

@@ -0,0 +1,41 @@
+import os
+import subprocess
+from fnmatch import fnmatch
+from zipfile import ZipFile, ZIP_DEFLATED
+
+ignore_patterns = [
+    '*/__pycache__/*',
+    '*/.git/*',
+    '*/.github/*',
+    '*/.idea/*',
+    '*/venv/*',
+    '*/.gitignore',
+    '*/.gitattributes',
+    '*/build/*',
+    '*/build.py',
+]
+
+
+def zipdir(path, zip_file: ZipFile):
+    for root, dirs, files in os.walk(path):
+        for file in files:
+            if file != zip_file.filename and not any(fnmatch(os.path.join(root, file), pattern) for pattern in ignore_patterns):
+                zip_file.write(os.path.join(root, file))
+
+# Get the branch name.
+branch = subprocess.check_output(['git', 'rev-parse', '--abbrev-ref', 'HEAD']).decode('utf-8').strip()
+
+# Get the most recent tag.
+tag = subprocess.check_output(['git', 'describe', '--tags', '--abbrev=0']).decode('utf-8').strip()
+
+# Create a zip file of the current directory.
+
+zip_path = f'./build/io_scene_psk_psa-{branch}-{tag}.zip'
+
+# Check that the directory exists, if it doesn't, create it.
+if not os.path.exists('./build'):
+    os.makedirs('./build')
+
+zipf = ZipFile(zip_path, 'w', ZIP_DEFLATED)
+zipdir('.', zipf)
+zipf.close()

io_scene_psk_psa/__init__.py

@@ -1,9 +1,8 @@
 bl_info = {
     "name": "PSK/PSA Importer/Exporter",
     "author": "Colin Basnett, Yurii Ti",
-    "version": (4, 0, 1),
-    "blender": (2, 80, 0),
-    # "location": "File > Export > PSK Export (.psk)",
+    "version": (5, 0, 3),
+    "blender": (3, 4, 0),
     "description": "PSK/PSA Import/Export (.psk/.psa)",
     "warning": "",
     "doc_url": "https://github.com/DarklightGames/io_scene_psk_psa",
@@ -17,52 +16,84 @@ if 'bpy' in locals():
     importlib.reload(psx_data)
     importlib.reload(psx_helpers)
     importlib.reload(psx_types)
+
     importlib.reload(psk_data)
-    importlib.reload(psk_builder)
-    importlib.reload(psk_exporter)
-    importlib.reload(psk_importer)
     importlib.reload(psk_reader)
+    importlib.reload(psk_writer)
+    importlib.reload(psk_builder)
+    importlib.reload(psk_importer)
+    importlib.reload(psk_export_properties)
+    importlib.reload(psk_export_operators)
+    importlib.reload(psk_export_ui)
+    importlib.reload(psk_import_operators)
+
     importlib.reload(psa_data)
-    importlib.reload(psa_builder)
-    importlib.reload(psa_exporter)
     importlib.reload(psa_reader)
-    importlib.reload(psa_importer)
+    importlib.reload(psa_writer)
+    importlib.reload(psa_builder)
+    importlib.reload(psa_export_properties)
+    importlib.reload(psa_export_operators)
+    importlib.reload(psa_export_ui)
+    importlib.reload(psa_import_properties)
+    importlib.reload(psa_import_operators)
+    importlib.reload(psa_import_ui)
 else:
     # if i remove this line, it can be enabled just fine
     from . import data as psx_data
     from . import helpers as psx_helpers
     from . import types as psx_types
     from .psk import data as psk_data
-    from .psk import builder as psk_builder
-    from .psk import exporter as psk_exporter
     from .psk import reader as psk_reader
+    from .psk import writer as psk_writer
+    from .psk import builder as psk_builder
     from .psk import importer as psk_importer
+    from .psk.export import properties as psk_export_properties
+    from .psk.export import operators as psk_export_operators
+    from .psk.export import ui as psk_export_ui
+    from .psk.import_ import operators as psk_import_operators
+
     from .psa import data as psa_data
-    from .psa import builder as psa_builder
-    from .psa import exporter as psa_exporter
     from .psa import reader as psa_reader
+    from .psa import writer as psa_writer
+    from .psa import builder as psa_builder
     from .psa import importer as psa_importer
+    from .psa.export import properties as psa_export_properties
+    from .psa.export import operators as psa_export_operators
+    from .psa.export import ui as psa_export_ui
+    from .psa.import_ import properties as psa_import_properties
+    from .psa.import_ import operators as psa_import_operators
+    from .psa.import_ import ui as psa_import_ui
 
 import bpy
 from bpy.props import PointerProperty
 
-classes = (psx_types.classes +
-           psk_importer.classes +
-           psk_exporter.classes +
-           psa_exporter.classes +
-           psa_importer.classes)
+classes = psx_types.classes +\
+          psk_import_operators.classes +\
+          psk_export_properties.classes +\
+          psk_export_operators.classes +\
+          psk_export_ui.classes + \
+          psa_export_properties.classes +\
+          psa_export_operators.classes +\
+          psa_export_ui.classes + \
+          psa_import_properties.classes +\
+          psa_import_operators.classes +\
+          psa_import_ui.classes
 
 
 def psk_export_menu_func(self, context):
-    self.layout.operator(psk_exporter.PskExportOperator.bl_idname, text='Unreal PSK (.psk)')
+    self.layout.operator(psk_export_operators.PSK_OT_export.bl_idname, text='Unreal PSK (.psk)')
 
 
 def psk_import_menu_func(self, context):
-    self.layout.operator(psk_importer.PskImportOperator.bl_idname, text='Unreal PSK (.psk/.pskx)')
+    self.layout.operator(psk_import_operators.PSK_OT_import.bl_idname, text='Unreal PSK (.psk/.pskx)')
 
 
 def psa_export_menu_func(self, context):
-    self.layout.operator(psa_exporter.PsaExportOperator.bl_idname, text='Unreal PSA (.psa)')
+    self.layout.operator(psa_export_operators.PSA_OT_export.bl_idname, text='Unreal PSA (.psa)')
+
+
+def psa_import_menu_func(self, context):
+    self.layout.operator(psa_import_operators.PSA_OT_import.bl_idname, text='Unreal PSA (.psa)')
 
 
 def register():
@@ -71,20 +102,22 @@ def register():
     bpy.types.TOPBAR_MT_file_export.append(psk_export_menu_func)
     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)
+    bpy.types.TOPBAR_MT_file_import.append(psa_import_menu_func)
+    bpy.types.Scene.psa_import = PointerProperty(type=psa_import_properties.PSA_PG_import)
+    bpy.types.Scene.psa_export = PointerProperty(type=psa_export_properties.PSA_PG_export)
+    bpy.types.Scene.psk_export = PointerProperty(type=psk_export_properties.PSK_PG_export)
+    bpy.types.Action.psa_export = PointerProperty(type=psx_types.PSX_PG_action_export)
 
 
 def unregister():
     del bpy.types.Scene.psa_import
-    del bpy.types.Scene.psk_import
     del bpy.types.Scene.psa_export
     del bpy.types.Scene.psk_export
+    del bpy.types.Action.psa_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)
+    bpy.types.TOPBAR_MT_file_import.remove(psa_import_menu_func)
     for cls in reversed(classes):
         bpy.utils.unregister_class(cls)
 

io_scene_psk_psa/helpers.py

@@ -1,10 +1,12 @@
 import datetime
 import re
+import typing
 from collections import Counter
 from typing import List, Iterable
 
+import addon_utils
 import bpy.types
-from bpy.types import NlaStrip, Object
+from bpy.types import NlaStrip, Object, AnimData
 
 
 class Timer:
@@ -25,14 +27,14 @@ class Timer:
             return datetime.datetime.now() - self.start
 
 
-def rgb_to_srgb(c):
+def rgb_to_srgb(c: float):
     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]:
+def get_nla_strips_in_timeframe(animation_data: AnimData, frame_min: float, frame_max: float) -> List[NlaStrip]:
     if animation_data is None:
         return []
     strips = []
@@ -47,7 +49,7 @@ def get_nla_strips_in_timeframe(animation_data, frame_min, frame_max) -> List[Nl
     return strips
 
 
-def populate_bone_group_list(armature_object: Object, bone_group_list: bpy.types.Collection) -> None:
+def populate_bone_group_list(armature_object: Object, bone_group_list: bpy.props.CollectionProperty) -> None:
     """
     Updates the bone group collection.
 
@@ -86,22 +88,16 @@ def populate_bone_group_list(armature_object: Object, bone_group_list: bpy.types
             item.is_selected = bone_group.name in selected_assigned_group_names if has_selected_groups else True
 
 
-def get_psa_sequence_name(action, should_use_original_sequence_name):
-    if should_use_original_sequence_name and 'psa_sequence_name' in action:
-        return action['psa_sequence_name']
-    else:
-        return action.name
-
-
 def check_bone_names(bone_names: Iterable[str]):
-    pattern = re.compile(r'^[a-zA-Z0-9_\- ]+$')
+    pattern = re.compile(r'^[a-zA-Z\d_\- ]+$')
     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.')
+                           f'Bone names must only contain letters, numbers, spaces, hyphens and underscores.\n'
+                           f'You can bypass this by disabling "Enforce Bone Name Restrictions" in the export settings.')
 
 
-def get_export_bone_names(armature_object, bone_filter_mode, bone_group_indices: List[int]) -> List[str]:
+def get_export_bone_names(armature_object: Object, bone_filter_mode: str, bone_group_indices: List[int]) -> List[str]:
     """
     Returns a sorted list of bone indices that should be exported for the given bone filter mode and bone groups.
 
@@ -115,7 +111,8 @@ def get_export_bone_names(armature_object, bone_filter_mode, bone_group_indices:
     if armature_object is None or armature_object.type != 'ARMATURE':
         raise ValueError('An armature object must be supplied')
 
-    bones = armature_object.data.bones
+    armature_data = typing.cast(bpy.types.Armature, armature_object.data)
+    bones = armature_data.bones
     pose_bones = armature_object.pose.bones
     bone_names = [x.name for x in bones]
 
@@ -174,3 +171,7 @@ def get_export_bone_names(armature_object, bone_filter_mode, bone_group_indices:
                            f'Additional debugging information has been written to the console.')
 
     return bone_names
+
+
+def is_bdk_addon_loaded():
+    return addon_utils.check('bdk_addon')[1]

io_scene_psk_psa/psa/builder.py

@@ -1,129 +1,79 @@
-from typing import Dict
+from typing import Optional
 
-from bpy.types import Action
+from bpy.types import Armature, Bone, Action, PoseBone
 
 from .data import *
 from ..helpers import *
 
 
-class PsaBuildOptions(object):
+class PsaBuildSequence:
+    class NlaState:
+        def __init__(self):
+            self.action: Optional[Action] = None
+            self.frame_start: int = 0
+            self.frame_end: int = 0
+
     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
+        self.name: str = ''
+        self.nla_state: PsaBuildSequence.NlaState = PsaBuildSequence.NlaState()
+        self.compression_ratio: float = 1.0
+        self.key_quota: int = 0
+        self.fps: float = 30.0
 
 
-def get_sequence_fps(context, options: PsaBuildOptions, actions: Iterable[Action]) -> float:
-    if options.fps_source == 'SCENE':
-        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
+class PsaBuildOptions:
+    def __init__(self):
+        self.animation_data: Optional[AnimData] = None
+        self.sequences: List[PsaBuildSequence] = []
+        self.bone_filter_mode: str = 'ALL'
+        self.bone_group_indices: List[int] = []
+        self.should_enforce_bone_name_restrictions: bool = False
+        self.sequence_name_prefix: str = ''
+        self.sequence_name_suffix: str = ''
+        self.root_motion: bool = False
+
+
+def _get_pose_bone_location_and_rotation(pose_bone: PoseBone, armature_object: Object, options: PsaBuildOptions):
+    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:
-        raise RuntimeError(f'Invalid FPS source "{options.fps_source}"')
-
-
-def get_timeline_marker_sequence_frame_ranges(animation_data, context, options: PsaBuildOptions) -> Dict:
-    # 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))
-
-    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
+        if options.root_motion:
+            # Get the bone's pose matrix, taking the armature object's world matrix into account.
+            pose_bone_matrix = armature_object.matrix_world @ pose_bone.matrix
         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)
+            # Use the bind pose matrix for the root bone.
+            pose_bone_matrix = pose_bone.matrix
 
-        if frame_min > frame_max:
-            continue
+    location = pose_bone_matrix.to_translation()
+    rotation = pose_bone_matrix.to_quaternion().normalized()
 
-        sequence_frame_ranges[marker_name] = int(frame_min), int(frame_max)
+    if pose_bone.parent is not None:
+        rotation.conjugate()
 
-    return sequence_frame_ranges
+    return location, rotation
 
 
-def build_psa(context, options: PsaBuildOptions) -> Psa:
+def build_psa(context: bpy.types.Context, options: PsaBuildOptions) -> Psa:
     active_object = context.view_layer.objects.active
 
-    if active_object.type != 'ARMATURE':
-        raise RuntimeError('Selected object must be an Armature')
-
-    if options.should_override_animation_data:
-        animation_data_object = options.animation_data_override
-    else:
-        animation_data_object = active_object
-
-    animation_data = animation_data_object.animation_data
-
-    if animation_data is None:
-        raise RuntimeError(f'No animation data for object \'{animation_data_object.name}\'')
-
-    # Ensure that we actually have items that we are going to be exporting.
-    if options.sequence_source == 'ACTIONS' and len(options.actions) == 0:
-        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')
-
     psa = Psa()
 
-    armature = active_object
-    bones = list(armature.data.bones)
+    armature_object = active_object
+    armature_data = typing.cast(Armature, armature_object.data)
+    bones: List[Bone] = list(iter(armature_data.bones))
 
     # The order of the armature bones and the pose bones is not guaranteed to be the same.
     # 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]
+    pose_bones = [(bone_names.index(bone.name), bone) for bone in armature_object.pose.bones]
     pose_bones.sort(key=lambda x: x[0])
     pose_bones = [x[1] for x in pose_bones]
 
     # Get a list of all the bone indices and instigator bones for the bone filter settings.
-    export_bone_names = get_export_bone_names(armature, options.bone_filter_mode, options.bone_group_indices)
+    export_bone_names = get_export_bone_names(armature_object, options.bone_filter_mode, options.bone_group_indices)
     bone_indices = [bone_names.index(x) for x in export_bone_names]
 
     # Make the bone lists contain only the bones that are going to be exported.
@@ -135,8 +85,9 @@ def build_psa(context, options: PsaBuildOptions) -> Psa:
         raise RuntimeError('No bones available for export')
 
     # Check that all bone names are valid.
-    check_bone_names(map(lambda bone: bone.name, bones))
-
+    if options.should_enforce_bone_name_restrictions:
+        check_bone_names(map(lambda bone: bone.name, bones))
+        
     # Build list of PSA bones.
     for bone in bones:
         psa_bone = Psa.Bone()
@@ -147,7 +98,7 @@ def build_psa(context, options: PsaBuildOptions) -> Psa:
             psa_bone.parent_index = parent_index
             psa.bones[parent_index].children_count += 1
         except ValueError:
-            psa_bone.parent_index = -1
+            psa_bone.parent_index = 0
 
         if bone.parent is not None:
             rotation = bone.matrix.to_quaternion().conjugated()
@@ -156,9 +107,12 @@ def build_psa(context, options: PsaBuildOptions) -> Psa:
             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()
+            armature_local_matrix = armature_object.matrix_local
+            location = armature_local_matrix @ bone.head
+            bone_rotation = bone.matrix.to_quaternion().conjugated()
+            local_rotation = armature_local_matrix.to_3x3().to_quaternion().conjugated()
+            rotation = bone_rotation @ local_rotation
+            rotation.conjugate()
 
         psa_bone.location.x = location.x
         psa_bone.location.y = location.y
@@ -171,97 +125,63 @@ def build_psa(context, options: PsaBuildOptions) -> Psa:
 
         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()
-            export_sequence.nla_state.action = action
-            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)
-
-        for name, (frame_min, frame_max) in sequence_frame_ranges.items():
-            export_sequence = ExportSequence()
-            export_sequence.name = name
-            export_sequence.nla_state.action = None
-            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}')
-
     # Add prefixes and suffices to the names of the export sequences and strip whitespace.
-    for export_sequence in export_sequences:
+    for export_sequence in options.sequences:
         export_sequence.name = f'{options.sequence_name_prefix}{export_sequence.name}{options.sequence_name_suffix}'
         export_sequence.name = export_sequence.name.strip()
 
+    # Save the current action and frame so that we can restore the state once we are done.
+    saved_frame_current = context.scene.frame_current
+    saved_action = options.animation_data.action
+
     # Now build the PSA sequences.
     # We actually alter the timeline frame and simply record the resultant pose bone matrices.
     frame_start_index = 0
 
-    for export_sequence in export_sequences:
+    context.window_manager.progress_begin(0, len(options.sequences))
+
+    for export_sequence_index, export_sequence in enumerate(options.sequences):
         # Link the action to the animation data and update view layer.
-        animation_data.action = export_sequence.nla_state.action
+        options.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
+        frame_start = export_sequence.nla_state.frame_start
+        frame_end = export_sequence.nla_state.frame_end
+
+        # Calculate the frame step based on the compression factor.
+        frame_extents = abs(frame_end - frame_start)
+        frame_count_raw = frame_extents + 1
+        frame_count = max(export_sequence.key_quota, int(frame_count_raw * export_sequence.compression_ratio))
+
+        try:
+            frame_step = frame_extents / (frame_count - 1)
+        except ZeroDivisionError:
+            frame_step = 0.0
+
+        sequence_duration = frame_count_raw / export_sequence.fps
+
+        # If this is a reverse sequence, we need to reverse the frame step.
+        if frame_start > frame_end:
+            frame_step = -frame_step
 
         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
+        psa_sequence.fps = frame_count / sequence_duration
+        psa_sequence.bone_count = len(pose_bones)
+        psa_sequence.track_time = frame_count
+        psa_sequence.key_reduction = 1.0
 
-        for frame in range(frame_count):
-            context.scene.frame_set(frame_min + frame)
+        frame = float(frame_start)
+
+        for _ in range(frame_count):
+            context.scene.frame_set(frame=int(frame), subframe=frame % 1.0)
 
             for pose_bone in pose_bones:
+                location, rotation = _get_pose_bone_location_and_rotation(pose_bone, armature_object, options)
+
                 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
-
-                location = pose_bone_matrix.to_translation()
-                rotation = pose_bone_matrix.to_quaternion().normalized()
-
-                if pose_bone.parent is not None:
-                    rotation.conjugate()
-
                 key.location.x = location.x
                 key.location.y = location.y
                 key.location.z = location.z
@@ -270,14 +190,20 @@ def build_psa(context, options: PsaBuildOptions) -> Psa:
                 key.rotation.z = rotation.z
                 key.rotation.w = rotation.w
                 key.time = 1.0 / psa_sequence.fps
-
                 psa.keys.append(key)
 
-            psa_sequence.bone_count = len(pose_bones)
-            psa_sequence.track_time = frame_count
+            frame += frame_step
 
         frame_start_index += frame_count
 
         psa.sequences[export_sequence.name] = psa_sequence
 
+        context.window_manager.progress_update(export_sequence_index)
+
+    # Restore the previous action & frame.
+    options.animation_data.action = saved_action
+    context.scene.frame_set(saved_frame_current)
+
+    context.window_manager.progress_end()
+
     return psa

io_scene_psk_psa/psa/data.py

@@ -6,11 +6,11 @@ from ..data import *
 
 """
 Note that keys are not stored within the Psa object.
-Use the PsaReader::get_sequence_keys to get a the keys for a sequence.
+Use the PsaReader::get_sequence_keys to get the keys for a sequence.
 """
 
 
-class Psa(object):
+class Psa:
     class Bone(Structure):
         _fields_ = [
             ('name', c_char * 64),
@@ -60,5 +60,5 @@ class Psa(object):
 
     def __init__(self):
         self.bones: List[Psa.Bone] = []
-        self.sequences: typing.OrderedDict[Psa.Sequence] = OrderedDict()
+        self.sequences: typing.OrderedDict[str, Psa.Sequence] = OrderedDict()
         self.keys: List[Psa.Key] = []

io_scene_psk_psa/psa/export/operators.py

@@ -0,0 +1,528 @@
+import re
+from collections import Counter
+from typing import List, Iterable, Dict, Tuple
+
+import bpy
+from bpy.props import StringProperty
+from bpy.types import Context, Armature, Action, Object, AnimData, TimelineMarker
+from bpy_extras.io_utils import ExportHelper
+from bpy_types import Operator
+
+from ..builder import build_psa, PsaBuildSequence, PsaBuildOptions
+from ..export.properties import PSA_PG_export, PSA_PG_export_action_list_item, filter_sequences
+from ..writer import write_psa
+from ...helpers import populate_bone_group_list, get_nla_strips_in_timeframe
+
+
+def is_action_for_armature(armature: Armature, action: Action):
+    if len(action.fcurves) == 0:
+        return False
+    bone_names = set([x.name for x in armature.bones])
+    for fcurve in action.fcurves:
+        match = re.match(r'pose\.bones\[\"([^\"]+)\"](\[\"([^\"]+)\"])?', fcurve.data_path)
+        if not match:
+            continue
+        bone_name = match.group(1)
+        if bone_name in bone_names:
+            return True
+    return False
+
+
+def update_actions_and_timeline_markers(context: Context, armature: Armature):
+    pg = getattr(context.scene, 'psa_export')
+
+    # Clear actions and markers.
+    pg.action_list.clear()
+    pg.marker_list.clear()
+
+    # Get animation data.
+    animation_data_object = get_animation_data_object(context)
+    animation_data = animation_data_object.animation_data if animation_data_object else None
+
+    if animation_data is None:
+        return
+
+    # Populate actions list.
+    for action in bpy.data.actions:
+        if not is_action_for_armature(armature, action):
+            continue
+
+        if not action.name.startswith('#'):
+            for (name, frame_start, frame_end) in get_sequences_from_action(action):
+                item = pg.action_list.add()
+                item.action = action
+                item.name = name
+                item.is_selected = False
+                item.is_pose_marker = False
+                item.frame_start = frame_start
+                item.frame_end = frame_end
+
+        # Pose markers are not guaranteed to be in frame-order, so make sure that they are.
+        pose_markers = sorted(action.pose_markers, key=lambda x: x.frame)
+        for pose_marker_index, pose_marker in enumerate(pose_markers):
+            if pose_marker.name.startswith('#'):
+                continue
+            for (name, frame_start, frame_end) in get_sequences_from_action_pose_marker(action, pose_markers, pose_marker, pose_marker_index):
+                item = pg.action_list.add()
+                item.action = action
+                item.name = name
+                item.is_selected = False
+                item.is_pose_marker = True
+                item.frame_start = frame_start
+                item.frame_end = frame_end
+
+    # Populate timeline markers list.
+    marker_names = [x.name for x in context.scene.timeline_markers]
+    sequence_frame_ranges = get_timeline_marker_sequence_frame_ranges(animation_data, context, marker_names)
+
+    for marker_name in marker_names:
+        if marker_name not in sequence_frame_ranges:
+            continue
+        if marker_name.startswith('#'):
+            continue
+        item = pg.marker_list.add()
+        item.name = marker_name
+        item.is_selected = False
+        frame_start, frame_end = sequence_frame_ranges[marker_name]
+        item.frame_start = frame_start
+        item.frame_end = frame_end
+
+
+def get_sequence_fps(context: Context, fps_source: str, fps_custom: float, actions: Iterable[Action]) -> float:
+    if fps_source == 'SCENE':
+        return context.scene.render.fps
+    elif fps_source == 'CUSTOM':
+        return fps_custom
+    elif 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 "{fps_source}"')
+
+
+def get_animation_data_object(context: Context) -> Object:
+    pg: PSA_PG_export = getattr(context.scene, 'psa_export')
+
+    active_object = context.view_layer.objects.active
+
+    if active_object.type != 'ARMATURE':
+        raise RuntimeError('Selected object must be an Armature')
+
+    if pg.should_override_animation_data:
+        animation_data_object = pg.animation_data_override
+    else:
+        animation_data_object = active_object
+
+    return animation_data_object
+
+
+def is_bone_filter_mode_item_available(context, identifier):
+    if identifier == 'BONE_GROUPS':
+        obj = context.active_object
+        if not obj.pose or not obj.pose.bone_groups:
+            return False
+    return True
+
+
+def get_timeline_marker_sequence_frame_ranges(animation_data: AnimData, context: Context, marker_names: List[str]) -> Dict:
+    # 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))
+
+    for marker_name in marker_names:
+        marker = context.scene.timeline_markers[marker_name]
+        frame_start = 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_end = 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_end = sorted_timeline_markers[next_marker_index].frame
+            nla_strips = get_nla_strips_in_timeframe(animation_data, marker.frame, frame_end)
+            if len(nla_strips) > 0:
+                frame_end = min(frame_end, max(map(lambda nla_strip: nla_strip.frame_end, nla_strips)))
+                frame_start = max(frame_start, 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_end = frame_start
+        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_end = max(frame_end, strip.frame_end)
+
+        if frame_start > frame_end:
+            continue
+
+        sequence_frame_ranges[marker_name] = int(frame_start), int(frame_end)
+
+    return sequence_frame_ranges
+
+
+def get_sequences_from_action(action: Action) -> List[Tuple[str, int, int]]:
+    frame_start = int(action.frame_range[0])
+    frame_end = int(action.frame_range[1])
+    reversed_pattern = r'(.+)/(.+)'
+    reversed_match = re.match(reversed_pattern, action.name)
+    if reversed_match:
+        forward_name = reversed_match.group(1)
+        backwards_name = reversed_match.group(2)
+        return [
+            (forward_name, frame_start, frame_end),
+            (backwards_name, frame_end, frame_start)
+        ]
+    else:
+        return [(action.name, frame_start, frame_end)]
+
+
+def get_sequences_from_action_pose_marker(action: Action, pose_markers: List[TimelineMarker], pose_marker: TimelineMarker, pose_marker_index: int) -> List[Tuple[str, int, int]]:
+    frame_start = pose_marker.frame
+    if pose_marker_index + 1 < len(pose_markers):
+        frame_end = pose_markers[pose_marker_index + 1].frame
+    else:
+        frame_end = int(action.frame_range[1])
+    reversed_pattern = r'(.+)/(.+)'
+    reversed_match = re.match(reversed_pattern, pose_marker.name)
+    if reversed_match:
+        forward_name = reversed_match.group(1)
+        backwards_name = reversed_match.group(2)
+        return [
+            (forward_name, frame_start, frame_end),
+            (backwards_name, frame_end, frame_start)
+        ]
+    else:
+        return [(pose_marker.name, frame_start, frame_end)]
+
+
+def get_visible_sequences(pg: PSA_PG_export, sequences) -> List[PSA_PG_export_action_list_item]:
+    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_OT_export(Operator, ExportHelper):
+    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'})
+    filepath: StringProperty(
+        name='File Path',
+        description='File path used for exporting the PSA file',
+        maxlen=1024,
+        default='')
+
+    def __init__(self):
+        self.armature_object = 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
+        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(PSA_OT_export_actions_select_all.bl_idname, text='All', icon='CHECKBOX_HLT')
+        row.operator(PSA_OT_export_actions_deselect_all.bl_idname, text='None', icon='CHECKBOX_DEHLT')
+
+        # ACTIONS
+        if pg.sequence_source == 'ACTIONS':
+            rows = max(3, min(len(pg.action_list), 10))
+
+            layout.template_list('PSA_UL_export_sequences', '', pg, 'action_list', pg, 'action_list_index', rows=rows)
+
+            col = layout.column()
+            col.use_property_split = True
+            col.use_property_decorate = False
+            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_export_sequences', '', 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, '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
+        row = layout.row(align=True)
+        row.prop(pg, 'bone_filter_mode', text='Bones')
+
+        if pg.bone_filter_mode == 'BONE_GROUPS':
+            row = layout.row(align=True)
+            row.label(text='Select')
+            row.operator(PSA_OT_export_bone_groups_select_all.bl_idname, text='All', icon='CHECKBOX_HLT')
+            row.operator(PSA_OT_export_bone_groups_deselect_all.bl_idname, text='None', icon='CHECKBOX_DEHLT')
+            rows = max(3, min(len(pg.bone_group_list), 10))
+            layout.template_list('PSX_UL_bone_group_list', '', pg, 'bone_group_list', pg, 'bone_group_list_index',
+                                 rows=rows)
+
+        layout.prop(pg, 'should_enforce_bone_name_restrictions')
+
+        layout.separator()
+
+        # ROOT MOTION
+        layout.prop(pg, 'root_motion', text='Root Motion')
+
+    @classmethod
+    def _check_context(cls, context):
+        if context.view_layer.objects.active is None:
+            raise RuntimeError('An armature must be selected')
+
+        if context.view_layer.objects.active.type != 'ARMATURE':
+            raise RuntimeError('The selected object must be an armature')
+
+    def invoke(self, context, _event):
+        try:
+            self._check_context(context)
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+
+        pg: PSA_PG_export = getattr(context.scene, 'psa_export')
+
+        self.armature_object = context.view_layer.objects.active
+
+        if self.armature_object.animation_data is None:
+            # This is required otherwise the action list will be empty if the armature has never had its animation
+            # data created before (i.e. if no action was ever assigned to it).
+            self.armature_object.animation_data_create()
+
+        update_actions_and_timeline_markers(context, self.armature_object.data)
+
+        # Populate bone groups list.
+        populate_bone_group_list(self.armature_object, pg.bone_group_list)
+
+        context.window_manager.fileselect_add(self)
+
+        return {'RUNNING_MODAL'}
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_export')
+
+        # Ensure that we actually have items that we are going to be exporting.
+        if pg.sequence_source == 'ACTIONS' and len(pg.action_list) == 0:
+            raise RuntimeError('No actions were selected for export')
+        elif pg.sequence_source == 'TIMELINE_MARKERS' and len(pg.marker_names) == 0:
+            raise RuntimeError('No timeline markers were selected for export')
+
+        # Populate the export sequence list.
+        animation_data_object = get_animation_data_object(context)
+        animation_data = animation_data_object.animation_data
+
+        if animation_data is None:
+            raise RuntimeError(f'No animation data for object \'{animation_data_object.name}\'')
+
+        export_sequences: List[PsaBuildSequence] = []
+
+        if pg.sequence_source == 'ACTIONS':
+            for action in filter(lambda x: x.is_selected, pg.action_list):
+                if len(action.action.fcurves) == 0:
+                    continue
+                export_sequence = PsaBuildSequence()
+                export_sequence.nla_state.action = action.action
+                export_sequence.name = action.name
+                export_sequence.nla_state.frame_start = action.frame_start
+                export_sequence.nla_state.frame_end = action.frame_end
+                export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, [action.action])
+                export_sequence.compression_ratio = action.action.psa_export.compression_ratio
+                export_sequence.key_quota = action.action.psa_export.key_quota
+                export_sequences.append(export_sequence)
+        elif pg.sequence_source == 'TIMELINE_MARKERS':
+            for marker in pg.marker_list:
+                export_sequence = PsaBuildSequence()
+                export_sequence.name = marker.name
+                export_sequence.nla_state.action = None
+                export_sequence.nla_state.frame_start = marker.frame_start
+                export_sequence.nla_state.frame_end = marker.frame_end
+                nla_strips_actions = set(
+                    map(lambda x: x.action, get_nla_strips_in_timeframe(animation_data, marker.frame_start, marker.frame_end)))
+                export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, nla_strips_actions)
+                export_sequences.append(export_sequence)
+        else:
+            raise ValueError(f'Unhandled sequence source: {pg.sequence_source}')
+
+        options = PsaBuildOptions()
+        options.animation_data = animation_data
+        options.sequences = export_sequences
+        options.bone_filter_mode = pg.bone_filter_mode
+        options.bone_group_indices = [x.index for x in pg.bone_group_list if x.is_selected]
+        options.should_ignore_bone_name_restrictions = pg.should_enforce_bone_name_restrictions
+        options.sequence_name_prefix = pg.sequence_name_prefix
+        options.sequence_name_suffix = pg.sequence_name_suffix
+        options.root_motion = pg.root_motion
+
+        try:
+            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'}
+
+        write_psa(psa, self.filepath)
+
+        return {'FINISHED'}
+
+
+class PSA_OT_export_actions_select_all(Operator):
+    bl_idname = 'psa_export.sequences_select_all'
+    bl_label = 'Select All'
+    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):
+        pg = getattr(context.scene, 'psa_export')
+        item_list = cls.get_item_list(context)
+        visible_sequences = get_visible_sequences(pg, item_list)
+        has_unselected_sequences = any(map(lambda item: not item.is_selected, visible_sequences))
+        return has_unselected_sequences
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_export')
+        sequences = self.get_item_list(context)
+        for sequence in get_visible_sequences(pg, sequences):
+            sequence.is_selected = True
+        return {'FINISHED'}
+
+
+class PSA_OT_export_actions_deselect_all(Operator):
+    bl_idname = 'psa_export.sequences_deselect_all'
+    bl_label = 'Deselect All'
+    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):
+        item_list = cls.get_item_list(context)
+        has_selected_items = any(map(lambda item: item.is_selected, item_list))
+        return len(item_list) > 0 and has_selected_items
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_export')
+        item_list = self.get_item_list(context)
+        for sequence in get_visible_sequences(pg, item_list):
+            sequence.is_selected = False
+        return {'FINISHED'}
+
+
+class PSA_OT_export_bone_groups_select_all(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 PSA_OT_export_bone_groups_deselect_all(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 = (
+    PSA_OT_export,
+    PSA_OT_export_actions_select_all,
+    PSA_OT_export_actions_deselect_all,
+    PSA_OT_export_bone_groups_select_all,
+    PSA_OT_export_bone_groups_deselect_all,
+)

io_scene_psk_psa/psa/export/properties.py

@@ -0,0 +1,168 @@
+import sys
+from fnmatch import fnmatch
+from typing import List
+
+from bpy.props import BoolProperty, PointerProperty, EnumProperty, FloatProperty, CollectionProperty, IntProperty, \
+    StringProperty
+from bpy.types import PropertyGroup, Object, Action
+
+from ...types import PSX_PG_bone_group_list_item
+
+
+def psa_export_property_group_animation_data_override_poll(_context, obj):
+    return obj.animation_data is not None
+
+
+empty_set = set()
+
+
+class PSA_PG_export_action_list_item(PropertyGroup):
+    action: PointerProperty(type=Action)
+    name: StringProperty()
+    is_selected: BoolProperty(default=False)
+    frame_start: IntProperty(options={'HIDDEN'})
+    frame_end: IntProperty(options={'HIDDEN'})
+    is_pose_marker: BoolProperty(options={'HIDDEN'})
+
+
+class PSA_PG_export_timeline_markers(PropertyGroup):
+    marker_index: IntProperty()
+    name: StringProperty()
+    is_selected: BoolProperty(default=True)
+    frame_start: IntProperty(options={'HIDDEN'})
+    frame_end: IntProperty(options={'HIDDEN'})
+
+
+class PSA_PG_export(PropertyGroup):
+    root_motion: BoolProperty(
+        name='Root Motion',
+        options=empty_set,
+        default=False,
+        description='When enabled, the root bone will be transformed as it appears in the scene.\n\n'
+                    'You might want to disable this if you are exporting an animation for an armature that is '
+                    'attached to another object, such as a weapon or a shield',
+    )
+    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=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=PSA_PG_export_action_list_item)
+    action_list_index: IntProperty(default=0)
+    marker_list: CollectionProperty(type=PSA_PG_export_timeline_markers)
+    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_group_list: CollectionProperty(type=PSX_PG_bone_group_list_item)
+    bone_group_list_index: IntProperty(default=0, name='', description='')
+    should_enforce_bone_name_restrictions: BoolProperty(
+        default=False,
+        name='Enforce Bone Name Restrictions',
+        description='Bone names restrictions will be enforced. Note that bone names without properly formatted names '
+                    'cannot be referenced in scripts'
+    )
+    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_filter_pose_marker: BoolProperty(
+        default=True,
+        name='Show pose markers',
+        options=empty_set)
+    sequence_use_filter_sort_reverse: BoolProperty(default=True, options=empty_set)
+    sequence_filter_reversed: BoolProperty(
+        default=True,
+        options=empty_set,
+        name='Show Reversed',
+        description='Show reversed sequences'
+    )
+
+
+def filter_sequences(pg: PSA_PG_export, sequences) -> List[int]:
+    bitflag_filter_item = 1 << 30
+    flt_flags = [bitflag_filter_item] * len(sequences)
+
+    if pg.sequence_filter_name:
+        # Filter name is non-empty.
+        for i, sequence in enumerate(sequences):
+            if not fnmatch(sequence.name, f'*{pg.sequence_filter_name}*'):
+                flt_flags[i] &= ~bitflag_filter_item
+
+        # Invert filter flags for all items.
+        if pg.sequence_use_filter_invert:
+            for i, sequence in enumerate(sequences):
+                flt_flags[i] ^= bitflag_filter_item
+
+    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
+
+    if not pg.sequence_filter_pose_marker:
+        for i, sequence in enumerate(sequences):
+            if hasattr(sequence, 'is_pose_marker') and sequence.is_pose_marker:
+                flt_flags[i] &= ~bitflag_filter_item
+
+    if not pg.sequence_filter_reversed:
+        for i, sequence in enumerate(sequences):
+            if sequence.frame_start > sequence.frame_end:
+                flt_flags[i] &= ~bitflag_filter_item
+
+    return flt_flags
+
+
+classes = (
+    PSA_PG_export_action_list_item,
+    PSA_PG_export_timeline_markers,
+    PSA_PG_export,
+)

io_scene_psk_psa/psa/export/ui.py

@@ -0,0 +1,54 @@
+from typing import cast
+
+from bpy.types import UIList
+
+from .properties import PSA_PG_export_action_list_item, filter_sequences
+
+
+class PSA_UL_export_sequences(UIList):
+
+    def __init__(self):
+        super(PSA_UL_export_sequences, 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):
+        item = cast(PSA_PG_export_action_list_item, item)
+        is_pose_marker = hasattr(item, 'is_pose_marker') and item.is_pose_marker
+        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')
+
+        row = layout.row(align=True)
+        row.alignment = 'RIGHT'
+        if item.frame_end < item.frame_start:
+            row.label(text='', icon='FRAME_PREV')
+        if is_pose_marker:
+            row.label(text=item.action.name, icon='PMARKER')
+
+    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')
+            subrow.prop(pg, 'sequence_filter_pose_marker', icon_only=True, icon='PMARKER')
+            subrow.prop(pg, 'sequence_filter_reversed', text="", icon='FRAME_PREV')
+
+    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')
+        flt_neworder = list(range(len(actions)))
+        return flt_flags, flt_neworder
+
+
+classes = (
+    PSA_UL_export_sequences,
+)

io_scene_psk_psa/psa/exporter.py

@@ -1,538 +0,0 @@
-import fnmatch
-import sys
-from typing import Type
-
-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 ..helpers import *
-from ..types import BoneGroupListItem
-
-
-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_psa(psa: Psa, path: str):
-    with open(path, 'wb') as fp:
-        write_section(fp, b'ANIMHEAD')
-        write_section(fp, b'BONENAMES', Psa.Bone, psa.bones)
-        write_section(fp, b'ANIMINFO', Psa.Sequence, list(psa.sequences.values()))
-        write_section(fp, b'ANIMKEYS', Psa.Key, psa.keys)
-
-
-class PsaExportActionListItem(PropertyGroup):
-    action: PointerProperty(type=Action)
-    name: StringProperty()
-    is_selected: BoolProperty(default=False)
-
-
-class PsaExportTimelineMarkerListItem(PropertyGroup):
-    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_group_list: CollectionProperty(type=BoneGroupListItem)
-    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':
-        obj = context.active_object
-        if not obj.pose or not obj.pose.bone_groups:
-            return False
-    return True
-
-
-class PsaExportOperator(Operator, ExportHelper):
-    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'})
-    filepath: StringProperty(
-        name='File Path',
-        description='File path used for exporting the PSA file',
-        maxlen=1024,
-        default='')
-
-    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
-        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
-        if pg.sequence_source == 'ACTIONS':
-            rows = max(3, min(len(pg.action_list), 10))
-
-            layout.template_list('PSA_UL_ExportSequenceList', '', pg, 'action_list', pg, 'action_list_index', rows=rows)
-
-            col = layout.column()
-            col.use_property_split = True
-            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
-        row = layout.row(align=True)
-        row.prop(pg, 'bone_filter_mode', text='Bones')
-
-        if pg.bone_filter_mode == 'BONE_GROUPS':
-            row = layout.row(align=True)
-            row.label(text='Select')
-            row.operator(PsaExportBoneGroupsSelectAll.bl_idname, text='All', icon='CHECKBOX_HLT')
-            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)
-            if not match:
-                continue
-            bone_name = match.group(1)
-            if bone_name in bone_names:
-                return True
-        return False
-
-    @classmethod
-    def _check_context(cls, context):
-        if context.view_layer.objects.active is None:
-            raise RuntimeError('An armature must be selected')
-
-        if context.view_layer.objects.active.type != 'ARMATURE':
-            raise RuntimeError('The selected object must be an armature')
-
-    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.
-        pg.action_list.clear()
-        for action in bpy.data.actions:
-            if not self.is_action_for_armature(action):
-                continue
-            item = pg.action_list.add()
-            item.action = action
-            item.name = action.name
-            item.is_selected = False
-
-        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 or timeline markers to export.')
-            return {'CANCELLED'}
-
-        # Populate bone groups list.
-        populate_bone_group_list(self.armature, pg.bone_group_list)
-
-        context.window_manager.fileselect_add(self)
-
-        return {'RUNNING_MODAL'}
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_export')
-
-        actions = [x.action for x in pg.action_list if x.is_selected]
-        marker_names = [x.name for x in pg.marker_list if x.is_selected]
-
-        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.marker_names = marker_names
-        options.bone_filter_mode = pg.bone_filter_mode
-        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 = build_psa(context, options)
-            self.report({'INFO'}, f'PSA export successful')
-        except RuntimeError as e:
-            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
-            return {'CANCELLED'}
-
-        export_psa(psa, self.filepath)
-
-        return {'FINISHED'}
-
-
-def filter_sequences(pg: PsaExportPropertyGroup, sequences) -> List[int]:
-    bitflag_filter_item = 1 << 30
-    flt_flags = [bitflag_filter_item] * len(sequences)
-
-    if pg.sequence_filter_name:
-        # Filter name is non-empty.
-        for i, sequence in enumerate(sequences):
-            if not fnmatch.fnmatch(sequence.name, f'*{pg.sequence_filter_name}*'):
-                flt_flags[i] &= ~bitflag_filter_item
-
-        # Invert filter flags for all items.
-        if pg.sequence_use_filter_invert:
-            for i, sequence in enumerate(sequences):
-                flt_flags[i] ^= bitflag_filter_item
-
-    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 PsaExportActionsSelectAll(Operator):
-    bl_idname = 'psa_export.sequences_select_all'
-    bl_label = 'Select All'
-    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):
-        pg = getattr(context.scene, 'psa_export')
-        item_list = cls.get_item_list(context)
-        visible_sequences = get_visible_sequences(pg, item_list)
-        has_unselected_sequences = any(map(lambda item: not item.is_selected, visible_sequences))
-        return has_unselected_sequences
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_export')
-        sequences = self.get_item_list(context)
-        for sequence in get_visible_sequences(pg, sequences):
-            sequence.is_selected = True
-        return {'FINISHED'}
-
-
-class PsaExportActionsDeselectAll(Operator):
-    bl_idname = 'psa_export.sequences_deselect_all'
-    bl_label = 'Deselect All'
-    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):
-        item_list = cls.get_item_list(context)
-        has_selected_items = any(map(lambda item: item.is_selected, item_list))
-        return len(item_list) > 0 and has_selected_items
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_export')
-        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 = (
-    PsaExportActionListItem,
-    PsaExportTimelineMarkerListItem,
-    PsaExportPropertyGroup,
-    PsaExportOperator,
-    PSA_UL_ExportSequenceList,
-    PsaExportActionsSelectAll,
-    PsaExportActionsDeselectAll,
-    PsaExportBoneGroupsSelectAll,
-    PsaExportBoneGroupsDeselectAll,
-)

io_scene_psk_psa/psa/import_/operators.py

@@ -0,0 +1,255 @@
+import os
+
+from bpy.props import StringProperty
+from bpy.types import Operator, Event, Context
+from bpy_extras.io_utils import ImportHelper
+
+from .properties import get_visible_sequences
+from ..importer import import_psa, PsaImportOptions
+from ..reader import PsaReader
+
+
+class PSA_OT_import_sequences_from_text(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 PSA_OT_import_sequences_select_all(Operator):
+    bl_idname = 'psa_import.sequences_select_all'
+    bl_label = 'All'
+    bl_description = 'Select all sequences'
+    bl_options = {'INTERNAL'}
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psa_import')
+        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
+        has_unselected_actions = any(map(lambda action: not action.is_selected, visible_sequences))
+        return len(visible_sequences) > 0 and has_unselected_actions
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_import')
+        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
+        for sequence in visible_sequences:
+            sequence.is_selected = True
+        return {'FINISHED'}
+
+
+class PSA_OT_import_sequences_deselect_all(Operator):
+    bl_idname = 'psa_import.sequences_deselect_all'
+    bl_label = 'None'
+    bl_description = 'Deselect all visible sequences'
+    bl_options = {'INTERNAL'}
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psa_import')
+        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
+        has_selected_sequences = any(map(lambda sequence: sequence.is_selected, visible_sequences))
+        return len(visible_sequences) > 0 and has_selected_sequences
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_import')
+        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
+        for sequence in visible_sequences:
+            sequence.is_selected = False
+        return {'FINISHED'}
+
+
+class PSA_OT_import_select_file(Operator):
+    bl_idname = 'psa_import.select_file'
+    bl_label = 'Select'
+    bl_options = {'INTERNAL'}
+    bl_description = 'Select a PSA file from which to import animations'
+    filepath: StringProperty(subtype='FILE_PATH')
+    filter_glob: StringProperty(default="*.psa", options={'HIDDEN'})
+
+    def execute(self, context):
+        getattr(context.scene, 'psa_import').psa_file_path = self.filepath
+        return {"FINISHED"}
+
+    def invoke(self, context, event):
+        context.window_manager.fileselect_add(self)
+        return {"RUNNING_MODAL"}
+
+
+def load_psa_file(context, filepath: str):
+    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(filepath)
+        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(cls, context):
+    load_psa_file(context, cls.filepath)
+
+
+class PSA_OT_import(Operator, ImportHelper):
+    bl_idname = 'psa_import.import'
+    bl_label = 'Import'
+    bl_description = 'Import the selected animations into the scene as actions'
+    bl_options = {'INTERNAL', 'UNDO'}
+
+    filename_ext = '.psa'
+    filter_glob: StringProperty(default='*.psa', options={'HIDDEN'})
+    filepath: StringProperty(
+        name='File Path',
+        description='File path used for importing the PSA file',
+        maxlen=1024,
+        default='',
+        update=on_psa_file_path_updated)
+
+    @classmethod
+    def poll(cls, context):
+        active_object = context.view_layer.objects.active
+        if active_object is None or active_object.type != 'ARMATURE':
+            cls.poll_message_set('The active object must be an armature')
+            return False
+        return True
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psa_import')
+        psa_reader = PsaReader(self.filepath)
+        sequence_names = [x.action_name for x in pg.sequence_list if x.is_selected]
+
+        options = PsaImportOptions()
+        options.sequence_names = sequence_names
+        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
+        options.should_convert_to_samples = pg.should_convert_to_samples
+        options.bone_mapping_mode = pg.bone_mapping_mode
+
+        result = import_psa(context, psa_reader, context.view_layer.objects.active, options)
+
+        if len(result.warnings) > 0:
+            message = f'Imported {len(sequence_names)} action(s) with {len(result.warnings)} warning(s)\n'
+            message += '\n'.join(result.warnings)
+            self.report({'WARNING'}, message)
+        else:
+            self.report({'INFO'}, f'Imported {len(sequence_names)} action(s)')
+
+        return {'FINISHED'}
+
+    def invoke(self, context: Context, event: Event):
+        # Attempt to load the PSA file for the pre-selected file.
+        load_psa_file(context, self.filepath)
+
+        context.window_manager.fileselect_add(self)
+        return {'RUNNING_MODAL'}
+
+    def draw(self, context: Context):
+        layout = self.layout
+        pg = getattr(context.scene, 'psa_import')
+
+        if pg.psa_error:
+            row = layout.row()
+            row.label(text='Select a PSA file', icon='ERROR')
+        else:
+            box = layout.box()
+
+            box.label(text=f'Sequences ({len(pg.sequence_list)})', icon='ARMATURE_DATA')
+
+            # Select buttons.
+            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(PSA_OT_import_sequences_from_text.bl_idname, text='', icon='TEXT')
+            row2.operator(PSA_OT_import_sequences_select_all.bl_idname, text='All', icon='CHECKBOX_HLT')
+            row2.operator(PSA_OT_import_sequences_deselect_all.bl_idname, text='None', icon='CHECKBOX_DEHLT')
+
+            col = col.row()
+            col.template_list('PSA_UL_import_sequences', '', 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')
+
+        col = layout.column()
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(pg, 'bone_mapping_mode')
+
+        if pg.should_write_keyframes:
+            col = layout.column(heading='Keyframes')
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(pg, 'should_convert_to_samples')
+            col.separator()
+
+        col = layout.column(heading='Options')
+        col.use_property_split = True
+        col.use_property_decorate = False
+        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')
+
+
+classes = (
+    PSA_OT_import_sequences_select_all,
+    PSA_OT_import_sequences_deselect_all,
+    PSA_OT_import_sequences_from_text,
+    PSA_OT_import,
+    PSA_OT_import_select_file,
+)

io_scene_psk_psa/psa/import_/properties.py

@@ -0,0 +1,119 @@
+import re
+from fnmatch import fnmatch
+from typing import List
+
+from bpy.props import StringProperty, BoolProperty, CollectionProperty, IntProperty, PointerProperty, EnumProperty
+from bpy.types import PropertyGroup, Text
+
+empty_set = set()
+
+
+class PSA_PG_import_action_list_item(PropertyGroup):
+    action_name: StringProperty(options=empty_set)
+    is_selected: BoolProperty(default=False, options=empty_set)
+
+
+class PSA_PG_bone(PropertyGroup):
+    bone_name: StringProperty(options=empty_set)
+
+
+class PSA_PG_data(PropertyGroup):
+    bones: CollectionProperty(type=PSA_PG_bone)
+    sequence_count: IntProperty(default=0)
+
+
+class PSA_PG_import(PropertyGroup):
+    psa_error: StringProperty(default='')
+    psa: PointerProperty(type=PSA_PG_data)
+    sequence_list: CollectionProperty(type=PSA_PG_import_action_list_item)
+    sequence_list_index: IntProperty(name='', default=0)
+    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='Overwrite', 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=Text)
+    should_convert_to_samples: BoolProperty(
+        default=False,
+        name='Convert to Samples',
+        description='Convert keyframes to read-only samples. '
+                    'Recommended if you do not plan on editing the actions directly'
+    )
+    bone_mapping_mode: EnumProperty(
+        name='Bone Mapping',
+        options=empty_set,
+        description='The method by which bones from the incoming PSA file are mapped to the armature',
+        items=(
+            ('EXACT', 'Exact', 'Bone names must match exactly.', 'EXACT', 0),
+            ('CASE_INSENSITIVE', 'Case Insensitive', 'Bones names must match, ignoring case (e.g., the bone PSA bone '
+             '\'root\' can be mapped to the armature bone \'Root\')', 'CASE_INSENSITIVE', 1),
+        )
+    )
+
+
+def filter_sequences(pg: PSA_PG_import, 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(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: PSA_PG_import, sequences) -> List[PSA_PG_import_action_list_item]:
+    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
+
+
+classes = (
+    PSA_PG_import_action_list_item,
+    PSA_PG_bone,
+    PSA_PG_data,
+    PSA_PG_import,
+)

io_scene_psk_psa/psa/import_/ui.py

@@ -0,0 +1,45 @@
+import bpy
+from bpy.types import UIList
+
+from .properties import filter_sequences
+
+
+class PSA_UL_sequences(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)
+        column = split.row(align=True)
+        column.alignment = 'LEFT'
+        column.prop(item, 'is_selected', icon_only=True)
+        column.label(text=getattr(item, 'action_name'))
+
+    def draw_filter(self, context, layout):
+        pg = getattr(context.scene, 'psa_import')
+        row = layout.row()
+        sub_row = row.row(align=True)
+        sub_row.prop(pg, 'sequence_filter_name', text="")
+        sub_row.prop(pg, 'sequence_use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
+        sub_row.prop(pg, 'sequence_use_filter_regex', text="", icon='SORTBYEXT')
+        sub_row.prop(pg, 'sequence_filter_is_selected', text="", icon='CHECKBOX_HLT')
+
+    def filter_items(self, context, data, property_):
+        pg = getattr(context.scene, 'psa_import')
+        sequences = getattr(data, property_)
+        flt_flags = filter_sequences(pg, sequences)
+        flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(sequences, 'action_name')
+        return flt_flags, flt_neworder
+
+
+class PSA_UL_import_sequences(PSA_UL_sequences, UIList):
+    pass
+
+
+class PSA_UL_import_actions(PSA_UL_sequences, UIList):
+    pass
+
+
+classes = (
+    PSA_UL_sequences,
+    PSA_UL_import_sequences,
+    PSA_UL_import_actions,
+)

io_scene_psk_psa/psa/importer.py

@@ -1,13 +1,9 @@
-import fnmatch
-import os
-import re
+import typing
 from typing import List, Optional
 
 import bpy
-import numpy as np
-from bpy.props import StringProperty, BoolProperty, CollectionProperty, PointerProperty, IntProperty
-from bpy.types import Operator, UIList, PropertyGroup, Panel
-from bpy_extras.io_utils import ImportHelper
+import numpy
+from bpy.types import FCurve, Object, Context
 from mathutils import Vector, Quaternion
 
 from .data import Psa
@@ -16,7 +12,6 @@ from .reader import PsaReader
 
 class PsaImportOptions(object):
     def __init__(self):
-        self.should_clean_keys = True
         self.should_use_fake_user = False
         self.should_stash = False
         self.sequence_names = []
@@ -24,6 +19,8 @@ class PsaImportOptions(object):
         self.should_write_keyframes = True
         self.should_write_metadata = True
         self.action_name_prefix = ''
+        self.should_convert_to_samples = False
+        self.bone_mapping_mode = 'CASE_INSENSITIVE'
 
 
 class ImportBone(object):
@@ -35,10 +32,10 @@ class ImportBone(object):
         self.orig_loc: Vector = Vector()
         self.orig_quat: Quaternion = Quaternion()
         self.post_quat: Quaternion = Quaternion()
-        self.fcurves = []
+        self.fcurves: List[FCurve] = []
 
 
-def calculate_fcurve_data(import_bone: ImportBone, key_data: []):
+def _calculate_fcurve_data(import_bone: ImportBone, key_data: typing.Iterable[float]):
     # Convert world-space transforms to local-space transforms.
     key_rotation = Quaternion(key_data[0:4])
     key_location = Vector(key_data[4:])
@@ -56,44 +53,86 @@ def calculate_fcurve_data(import_bone: ImportBone, key_data: []):
     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
+class PsaImportResult:
+    def __init__(self):
+        self.warnings: List[str] = []
+
+
+def _get_armature_bone_index_for_psa_bone(psa_bone_name: str, armature_bone_names: List[str], bone_mapping_mode: str = 'EXACT') -> Optional[int]:
+    """
+    @param psa_bone_name: The name of the PSA bone.
+    @param armature_bone_names: The names of the bones in the armature.
+    @param bone_mapping_mode: One of 'EXACT' or 'CASE_INSENSITIVE'.
+    @return: The index of the armature bone that corresponds to the given PSA bone, or None if no such bone exists.
+    """
+    for armature_bone_index, armature_bone_name in enumerate(armature_bone_names):
+        if bone_mapping_mode == 'CASE_INSENSITIVE':
+            if armature_bone_name.lower() == psa_bone_name.lower():
+                return armature_bone_index
+        else:
+            if armature_bone_name == psa_bone_name:
+                return armature_bone_index
+    return None
+
+
+def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object, options: PsaImportOptions) -> PsaImportResult:
+    result = PsaImportResult()
+    sequences = [psa_reader.sequences[x] for x in options.sequence_names]
+    armature_data = typing.cast(bpy.types.Armature, armature_object.data)
 
     # Create an index mapping from bones in the PSA to bones in the target armature.
     psa_to_armature_bone_indices = {}
+    armature_to_psa_bone_indices = {}
     armature_bone_names = [x.name for x in armature_data.bones]
     psa_bone_names = []
+    duplicate_mappings = []
+
     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
+        psa_bone_name: str = psa_bone.name.decode('windows-1252')
+        armature_bone_index = _get_armature_bone_index_for_psa_bone(psa_bone_name, armature_bone_names, options.bone_mapping_mode)
+        if armature_bone_index is not None:
+            # Ensure that no other PSA bone has been mapped to this armature bone yet.
+            if armature_bone_index not in armature_to_psa_bone_indices:
+                psa_to_armature_bone_indices[psa_bone_index] = armature_bone_names.index(psa_bone_name)
+                armature_to_psa_bone_indices[armature_bone_index] = psa_bone_index
+            else:
+                # This armature bone has already been mapped to a PSA bone.
+                duplicate_mappings.append((psa_bone_index, armature_bone_index, armature_to_psa_bone_indices[armature_bone_index]))
+            psa_bone_names.append(armature_bone_names[armature_bone_index])
+        else:
+            psa_bone_names.append(psa_bone_name)
+
+    # Warn about duplicate bone mappings.
+    if len(duplicate_mappings) > 0:
+        for (psa_bone_index, armature_bone_index, mapped_psa_bone_index) in duplicate_mappings:
+            psa_bone_name = psa_bone_names[psa_bone_index]
+            armature_bone_name = armature_bone_names[armature_bone_index]
+            mapped_psa_bone_name = psa_bone_names[mapped_psa_bone_index]
+            result.warnings.append(f'PSA bone {psa_bone_index} ({psa_bone_name}) could not be mapped to armature bone {armature_bone_index} ({armature_bone_name}) because the armature bone is already mapped to PSA bone {mapped_psa_bone_index} ({mapped_psa_bone_name})')
 
     # 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)))
+        result.warnings.append(
+            f'The armature \'{armature_object.name}\' is missing {len(missing_bone_names)} bones that exist in '
+            'the PSA:\n' +
+            str(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
+    for (psa_bone_index, psa_bone), psa_bone_name in zip(enumerate(psa_reader.bones), psa_bone_names):
+        if psa_bone_index not in psa_to_armature_bone_indices:
             # 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_bone.armature_bone = armature_data.bones[psa_bone_name]
+        import_bone.pose_bone = armature_object.pose.bones[psa_bone_name]
+        import_bones_dict[psa_bone_name] = import_bone
         import_bones.append(import_bone)
 
     for import_bone in filter(lambda x: x is not None, import_bones):
@@ -119,9 +158,11 @@ def import_psa(psa_reader: PsaReader, armature_object, options: PsaImportOptions
                 import_bone.orig_quat = armature_bone.matrix_local.to_quaternion()
             import_bone.post_quat = import_bone.orig_quat.conjugated()
 
+    context.window_manager.progress_begin(0, len(sequences))
+
     # Create and populate the data for new sequences.
     actions = []
-    for sequence in sequences:
+    for sequence_index, sequence in enumerate(sequences):
         # Add the action.
         sequence_name = sequence.name.decode('windows-1252')
         action_name = options.action_name_prefix + sequence_name
@@ -154,7 +195,6 @@ def import_psa(psa_reader: PsaReader, armature_object, options: PsaImportOptions
 
             # 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)
 
             # Convert the sequence's data from world-space to local-space.
             for bone_index, import_bone in enumerate(import_bones):
@@ -164,51 +204,34 @@ def import_psa(psa_reader: PsaReader, armature_object, options: PsaImportOptions
                     # 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.
-                    sequence_data_matrix[frame_index, bone_index] = calculate_fcurve_data(import_bone, key_data)
+                    sequence_data_matrix[frame_index, bone_index] = _calculate_fcurve_data(import_bone, key_data)
 
-            # Clean the keyframe data. This is accomplished by writing zeroes to the write matrix when there is an
-            # insufficiently large change in the data from the last written frame.
-            if options.should_clean_keys:
-                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.
+            fcurve_data = numpy.zeros(2 * sequence.frame_count, dtype=float)
+            fcurve_data[0::2] = range(sequence.frame_count)
+            for bone_index, import_bone in enumerate(import_bones):
+                if import_bone is None:
+                    continue
+                for fcurve_index, fcurve in enumerate(import_bone.fcurves):
+                    fcurve_data[1::2] = sequence_data_matrix[:, bone_index, fcurve_index]
+                    fcurve.keyframe_points.add(sequence.frame_count)
+                    fcurve.keyframe_points.foreach_set('co', fcurve_data)
 
-            # Write the keyframes out!
-            for frame_index in range(sequence.frame_count):
-                for bone_index, import_bone in enumerate(import_bones):
-                    if import_bone is None:
-                        continue
-                    bone_has_writeable_keyframes = any(keyframe_write_matrix[frame_index, bone_index])
-                    if bone_has_writeable_keyframes:
-                        # This bone has writeable keyframes for this frame.
-                        key_data = sequence_data_matrix[frame_index, bone_index]
-                        for fcurve, should_write, datum in zip(import_bone.fcurves,
-                                                               keyframe_write_matrix[frame_index, bone_index],
-                                                               key_data):
-                            if should_write:
-                                fcurve.keyframe_points.insert(frame_index, datum, options={'FAST'})
+            if options.should_convert_to_samples:
+                # Bake the curve to samples.
+                for fcurve in action.fcurves:
+                    fcurve.convert_to_samples(start=0, end=sequence.frame_count)
 
-        # Write
+        # Write meta-data.
         if options.should_write_metadata:
-            action['psa_sequence_name'] = sequence_name
             action['psa_sequence_fps'] = sequence.fps
 
         action.use_fake_user = options.should_use_fake_user
 
         actions.append(action)
 
+        context.window_manager.progress_update(sequence_index)
+
     # 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:
@@ -219,424 +242,6 @@ def import_psa(psa_reader: PsaReader, armature_object, options: PsaImportOptions
             nla_track.mute = True
             nla_track.strips.new(name=action.name, start=0, action=action)
 
+    context.window_manager.progress_end()
 
-empty_set = set()
-
-
-class PsaImportActionListItem(PropertyGroup):
-    action_name: StringProperty(options=empty_set)
-    is_selected: BoolProperty(default=False, options=empty_set)
-
-
-def load_psa_file(context):
-    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):
-    load_psa_file(context)
-
-
-class PsaBonePropertyGroup(PropertyGroup):
-    bone_name: StringProperty(options=empty_set)
-
-
-class PsaDataPropertyGroup(PropertyGroup):
-    bones: CollectionProperty(type=PsaBonePropertyGroup)
-    sequence_count: IntProperty(default=0)
-
-
-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 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)
-        column = split.row(align=True)
-        column.alignment = 'LEFT'
-        column.prop(item, 'is_selected', icon_only=True)
-        column.label(text=getattr(item, 'action_name'))
-
-    def draw_filter(self, context, layout):
-        pg = getattr(context.scene, 'psa_import')
-        row = layout.row()
-        sub_row = row.row(align=True)
-        sub_row.prop(pg, 'sequence_filter_name', text="")
-        sub_row.prop(pg, 'sequence_use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
-        sub_row.prop(pg, 'sequence_use_filter_regex', text="", icon='SORTBYEXT')
-        sub_row.prop(pg, 'sequence_filter_is_selected', text="", icon='CHECKBOX_HLT')
-
-    def filter_items(self, context, data, property):
-        pg = getattr(context.scene, 'psa_import')
-        sequences = getattr(data, property)
-        flt_flags = filter_sequences(pg, sequences)
-        flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(sequences, 'action_name')
-        return flt_flags, flt_neworder
-
-
-class PSA_UL_ImportSequenceList(PSA_UL_SequenceList, UIList):
-    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 sequences'
-    bl_options = {'INTERNAL'}
-
-    @classmethod
-    def poll(cls, context):
-        pg = getattr(context.scene, 'psa_import')
-        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
-        has_unselected_actions = any(map(lambda action: not action.is_selected, visible_sequences))
-        return len(visible_sequences) > 0 and has_unselected_actions
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_import')
-        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
-        for sequence in visible_sequences:
-            sequence.is_selected = True
-        return {'FINISHED'}
-
-
-class PsaImportSequencesDeselectAll(Operator):
-    bl_idname = 'psa_import.sequences_deselect_all'
-    bl_label = 'None'
-    bl_description = 'Deselect all visible sequences'
-    bl_options = {'INTERNAL'}
-
-    @classmethod
-    def poll(cls, context):
-        pg = getattr(context.scene, 'psa_import')
-        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
-        has_selected_sequences = any(map(lambda sequence: sequence.is_selected, visible_sequences))
-        return len(visible_sequences) > 0 and has_selected_sequences
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_import')
-        visible_sequences = get_visible_sequences(pg, pg.sequence_list)
-        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'
-    bl_label = 'PSA Import'
-    bl_context = 'data'
-    bl_category = 'PSA Import'
-    bl_options = {'DEFAULT_CLOSED'}
-
-    @classmethod
-    def poll(cls, context):
-        return context.view_layer.objects.active.type == 'ARMATURE'
-
-    def draw(self, context):
-        layout = self.layout
-        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()
-
-        import_button_text = 'Import'
-        if selected_sequence_count > 0:
-            import_button_text = f'Import ({selected_sequence_count})'
-
-        row.operator(PsaImportOperator.bl_idname, text=import_button_text)
-
-
-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 = {'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):
-        getattr(context.scene, 'psa_import').psa_file_path = self.filepath
-        return {"FINISHED"}
-
-    def invoke(self, context, event):
-        context.window_manager.fileselect_add(self)
-        return {"RUNNING_MODAL"}
-
-
-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):
-        pg = getattr(context.scene, 'psa_import')
-        active_object = context.view_layer.objects.active
-        if active_object is None or active_object.type != 'ARMATURE':
-            return False
-        return any(map(lambda x: x.is_selected, pg.sequence_list))
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_import')
-        psa_reader = PsaReader(pg.psa_file_path)
-        sequence_names = [x.action_name for x in pg.sequence_list if x.is_selected]
-
-        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(
-        name='File Path',
-        description='File path used for importing the PSA file',
-        maxlen=1024,
-        default='')
-
-    def invoke(self, context, event):
-        context.window_manager.fileselect_add(self)
-        return {'RUNNING_MODAL'}
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_import')
-        pg.psa_file_path = self.filepath
-        return {'FINISHED'}
-
-
-classes = (
-    PsaImportActionListItem,
-    PsaBonePropertyGroup,
-    PsaDataPropertyGroup,
-    PsaImportPropertyGroup,
-    PSA_UL_SequenceList,
-    PSA_UL_ImportSequenceList,
-    PSA_UL_ImportActionList,
-    PsaImportSequencesSelectAll,
-    PsaImportSequencesDeselectAll,
-    PsaImportSequencesFromText,
-    PsaImportFileReload,
-    PSA_PT_ImportPanel,
-    PSA_PT_ImportPanel_Advanced,
-    PsaImportOperator,
-    PsaImportFileSelectOperator,
-    PsaImportSelectFile,
-)
+    return result

io_scene_psk_psa/psa/reader.py

@@ -25,7 +25,12 @@ class PsaReader(object):
     def sequences(self):
         return self.psa.sequences
 
-    def read_sequence_data_matrix(self, sequence_name: str):
+    def read_sequence_data_matrix(self, sequence_name: str) -> np.ndarray:
+        """
+        Reads and returns the data matrix for the given sequence.
+        @param sequence_name: The name of the sequence.
+        @return: An FxBx7 matrix where F is the number of frames, B is the number of bones.
+        """
         sequence = self.psa.sequences[sequence_name]
         keys = self.read_sequence_keys(sequence_name)
         bone_count = len(self.bones)
@@ -41,8 +46,8 @@ class PsaReader(object):
         """
         Reads and returns the key data for a sequence.
 
-        :param sequence_name: The name of the sequence.
-        :return: A list of Psa.Keys.
+        @param sequence_name: The name of the sequence.
+        @return: A list of Psa.Keys.
         """
         # Set the file reader to the beginning of the keys data
         sequence = self.psa.sequences[sequence_name]

io_scene_psk_psa/psa/writer.py

@@ -0,0 +1,25 @@
+from ctypes import Structure, sizeof
+from typing import Type
+
+from .data import Psa
+from ..data import Section
+
+
+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 write_psa(psa: Psa, path: str):
+    with open(path, 'wb') as fp:
+        write_section(fp, b'ANIMHEAD')
+        write_section(fp, b'BONENAMES', Psa.Bone, psa.bones)
+        write_section(fp, b'ANIMINFO', Psa.Sequence, list(psa.sequences.values()))
+        write_section(fp, b'ANIMKEYS', Psa.Key, psa.keys)

io_scene_psk_psa/psk/builder.py

@@ -1,10 +1,9 @@
-from collections import OrderedDict
-from typing import Dict, List
+import bmesh
+import bpy
+from bpy.types import Armature
 
 from .data import *
 from ..helpers import *
-import bmesh
-import bpy
 
 
 class PskInputObjects(object):
@@ -19,6 +18,7 @@ class PskBuildOptions(object):
         self.bone_group_indices: List[int] = []
         self.use_raw_mesh_data = True
         self.material_names: List[str] = []
+        self.should_enforce_bone_name_restrictions = False
 
 
 def get_psk_input_objects(context) -> PskInputObjects:
@@ -50,7 +50,8 @@ def get_psk_input_objects(context) -> PskInputObjects:
         armature_modifier_objects.add(modifiers[0].object)
 
     if len(armature_modifier_objects) > 1:
-        raise RuntimeError('All selected meshes must have the same armature modifier')
+        armature_modifier_names = [x.name for x in armature_modifier_objects]
+        raise RuntimeError(f'All selected meshes must have the same armature modifier, encountered {len(armature_modifier_names)} ({", ".join(armature_modifier_names)})')
     elif len(armature_modifier_objects) == 1:
         input_objects.armature_object = list(armature_modifier_objects)[0]
 
@@ -60,7 +61,7 @@ def get_psk_input_objects(context) -> PskInputObjects:
 def build_psk(context, options: PskBuildOptions) -> Psk:
     input_objects = get_psk_input_objects(context)
 
-    armature_object = input_objects.armature_object
+    armature_object: bpy.types.Object = input_objects.armature_object
 
     psk = Psk()
     bones = []
@@ -78,10 +79,12 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
         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]
+        armature_data = typing.cast(Armature, armature_object.data)
+        bones = [armature_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))
+        if options.should_enforce_bone_name_restrictions:
+            check_bone_names(map(lambda x: x.name, bones))
 
         for bone in bones:
             psk_bone = Psk.Bone()
@@ -94,19 +97,21 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
                 psk_bone.parent_index = parent_index
                 psk.bones[parent_index].children_count += 1
             except ValueError:
-                psk_bone.parent_index = -1
+                psk_bone.parent_index = 0
 
             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
+                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:
-                local_matrix = armature_object.matrix_local
-                location = local_matrix @ bone.head
-                rot_matrix = bone.matrix @ local_matrix.to_3x3()
-                rotation = rot_matrix.to_quaternion()
+                armature_local_matrix = armature_object.matrix_local
+                location = armature_local_matrix @ bone.head
+                bone_rotation = bone.matrix.to_quaternion().conjugated()
+                local_rotation = armature_local_matrix.to_3x3().to_quaternion().conjugated()
+                rotation = bone_rotation @ local_rotation
+                rotation.conjugate()
 
             psk_bone.location.x = location.x
             psk_bone.location.y = location.y
@@ -133,16 +138,17 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
         # MATERIALS
         material_indices = [material_names.index(material.name) for material in input_mesh_object.data.materials]
 
+        # MESH DATA
         if options.use_raw_mesh_data:
             mesh_object = input_mesh_object
             mesh_data = input_mesh_object.data
         else:
             # Create a copy of the mesh object after non-armature modifiers are applied.
 
-            # Temporarily deactivate any armature modifiers on the input mesh object.
-            active_armature_modifiers = [x for x in filter(lambda x: x.type == 'ARMATURE' and x.is_active, input_mesh_object.modifiers)]
-            for modifier in active_armature_modifiers:
-                modifier.show_viewport = False
+            # Temporarily force the armature into the rest position.
+            # We will undo this later.
+            old_pose_position = armature_object.data.pose_position
+            armature_object.data.pose_position = 'REST'
 
             depsgraph = context.evaluated_depsgraph_get()
             bm = bmesh.new()
@@ -157,9 +163,8 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
             for vertex_group in input_mesh_object.vertex_groups:
                 mesh_object.vertex_groups.new(name=vertex_group.name)
 
-            # Reactivate previously active armature modifiers
-            for modifier in active_armature_modifiers:
-                modifier.show_viewport = True
+            # Restore the previous pose position on the armature.
+            armature_object.data.pose_position = old_pose_position
 
         vertex_offset = len(psk.points)
 
@@ -217,6 +222,7 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
 
         # WEIGHTS
         if armature_object is not None:
+            armature_data = typing.cast(Armature, armature_object.data)
             # 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]
@@ -230,8 +236,8 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
                     # 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]
+                    if vertex_group_name in armature_data.bones:
+                        bone = armature_data.bones[vertex_group_name]
                         while bone is not None:
                             try:
                                 bone_index = bone_names.index(bone.name)

io_scene_psk_psa/psk/data.py

@@ -16,8 +16,7 @@ class Psk(object):
 
     class Wedge16(Structure):
         _fields_ = [
-            ('point_index', c_uint16),
-            ('padding1', c_int16),
+            ('point_index', c_uint32),
             ('u', c_float),
             ('v', c_float),
             ('material_index', c_uint8),
@@ -80,6 +79,19 @@ class Psk(object):
             ('bone_index', c_int32),
         ]
 
+    class MorphInfo(Structure):
+        _fields_ = [
+            ('name', c_char * 64),
+            ('vertex_count', c_int32)
+        ]
+
+    class MorphData(Structure):
+        _fields_ = [
+            ('position_delta', Vector3),
+            ('tangent_z_delta', Vector3),
+            ('point_index', c_int32)
+        ]
+
     @property
     def has_extra_uvs(self):
         return len(self.extra_uvs) > 0
@@ -92,6 +104,14 @@ class Psk(object):
     def has_vertex_normals(self):
         return len(self.vertex_normals) > 0
 
+    @property
+    def has_material_references(self):
+        return len(self.material_references) > 0
+
+    @property
+    def has_morph_data(self):
+        return len(self.morph_infos) > 0
+    
     def __init__(self):
         self.points: List[Vector3] = []
         self.wedges: List[Psk.Wedge] = []
@@ -102,3 +122,6 @@ class Psk(object):
         self.extra_uvs: List[Vector2] = []
         self.vertex_colors: List[Color] = []
         self.vertex_normals: List[Vector3] = []
+        self.morph_infos: List[Psk.MorphInfo] = []
+        self.morph_data: List[Psk.MorphData] = []
+        self.material_references: List[str] = []

io_scene_psk_psa/psk/export/operators.py

@@ -1,60 +1,10 @@
-from typing import Type
-
-from bpy.props import BoolProperty, StringProperty, CollectionProperty, IntProperty, EnumProperty
-from bpy.types import Operator, PropertyGroup, UIList
+from bpy.props import StringProperty
+from bpy.types import Operator
 from bpy_extras.io_utils import ExportHelper
 
-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
-MAX_BONE_COUNT = 256
-MAX_MATERIAL_COUNT = 256
-
-
-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_psk(psk: Psk, path: str):
-    if len(psk.wedges) > MAX_WEDGE_COUNT:
-        raise RuntimeError(f'Number of wedges ({len(psk.wedges)}) exceeds limit of {MAX_WEDGE_COUNT}')
-    if len(psk.bones) > MAX_BONE_COUNT:
-        raise RuntimeError(f'Number of bones ({len(psk.bones)}) exceeds limit of {MAX_BONE_COUNT}')
-    if len(psk.points) > MAX_POINT_COUNT:
-        raise RuntimeError(f'Numbers of vertices ({len(psk.points)}) exceeds limit of {MAX_POINT_COUNT}')
-    if len(psk.materials) > MAX_MATERIAL_COUNT:
-        raise RuntimeError(f'Number of materials ({len(psk.materials)}) exceeds limit of {MAX_MATERIAL_COUNT}')
-
-    with open(path, 'wb') as fp:
-        _write_section(fp, b'ACTRHEAD')
-        _write_section(fp, b'PNTS0000', Vector3, psk.points)
-
-        wedges = []
-        for index, w in enumerate(psk.wedges):
-            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)
-
-        _write_section(fp, b'VTXW0000', Psk.Wedge16, wedges)
-        _write_section(fp, b'FACE0000', Psk.Face, psk.faces)
-        _write_section(fp, b'MATT0000', Psk.Material, psk.materials)
-        _write_section(fp, b'REFSKELT', Psk.Bone, psk.bones)
-        _write_section(fp, b'RAWWEIGHTS', Psk.Weight, psk.weights)
+from ..builder import build_psk, PskBuildOptions, get_psk_input_objects
+from ..writer import write_psk
+from ...helpers import populate_bone_group_list
 
 
 def is_bone_filter_mode_item_available(context, identifier):
@@ -67,21 +17,6 @@ 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()
 
@@ -100,7 +35,7 @@ def populate_material_list(mesh_objects, material_list):
         m.index = index
 
 
-class PskMaterialListItemMoveUp(Operator):
+class PSK_OT_material_list_move_up(Operator):
     bl_idname = 'psk_export.material_list_item_move_up'
     bl_label = 'Move Up'
     bl_options = {'INTERNAL'}
@@ -118,7 +53,7 @@ class PskMaterialListItemMoveUp(Operator):
         return {"FINISHED"}
 
 
-class PskMaterialListItemMoveDown(Operator):
+class PSK_OT_material_list_move_down(Operator):
     bl_idname = 'psk_export.material_list_item_move_down'
     bl_label = 'Move Down'
     bl_options = {'INTERNAL'}
@@ -136,7 +71,7 @@ class PskMaterialListItemMoveDown(Operator):
         return {"FINISHED"}
 
 
-class PskExportOperator(Operator, ExportHelper):
+class PSK_OT_export(Operator, ExportHelper):
     bl_idname = 'export.psk'
     bl_label = 'Export'
     bl_options = {'INTERNAL', 'UNDO'}
@@ -161,7 +96,12 @@ class PskExportOperator(Operator, ExportHelper):
 
         # Populate bone groups list.
         populate_bone_group_list(input_objects.armature_object, pg.bone_group_list)
-        populate_material_list(input_objects.mesh_objects, pg.material_list)
+
+        try:
+            populate_material_list(input_objects.mesh_objects, pg.material_list)
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+            return {'CANCELLED'}
 
         context.window_manager.fileselect_add(self)
 
@@ -180,12 +120,16 @@ class PskExportOperator(Operator, ExportHelper):
         layout = self.layout
         pg = getattr(context.scene, 'psk_export')
 
-        layout.prop(pg, 'use_raw_mesh_data')
+        # MESH
+        box = layout.box()
+        box.label(text='Mesh', icon='MESH_DATA')
+        box.prop(pg, 'use_raw_mesh_data')
 
         # BONES
-        layout.label(text='Bones', icon='BONE_DATA')
+        box = layout.box()
+        box.label(text='Bones', icon='BONE_DATA')
         bone_filter_mode_items = pg.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)
@@ -193,20 +137,21 @@ class PskExportOperator(Operator, ExportHelper):
             item_layout.enabled = is_bone_filter_mode_item_available(context, identifier)
 
         if pg.bone_filter_mode == 'BONE_GROUPS':
-            row = layout.row()
+            row = box.row()
             rows = max(3, min(len(pg.bone_group_list), 10))
-            row.template_list('PSX_UL_BoneGroupList', '', pg, 'bone_group_list', pg, 'bone_group_list_index', rows=rows)
+            row.template_list('PSX_UL_bone_group_list', '', pg, 'bone_group_list', pg, 'bone_group_list_index', rows=rows)
 
-        layout.separator()
+        box.prop(pg, 'should_enforce_bone_name_restrictions')
 
         # MATERIALS
-        layout.label(text='Materials', icon='MATERIAL')
-        row = layout.row()
+        box = layout.box()
+        box.label(text='Materials', icon='MATERIAL')
+        row = box.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)
+        row.template_list('PSK_UL_materials', '', 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')
+        col.operator(PSK_OT_material_list_move_up.bl_idname, text='', icon='TRIA_UP')
+        col.operator(PSK_OT_material_list_move_down.bl_idname, text='', icon='TRIA_DOWN')
 
     def execute(self, context):
         pg = context.scene.psk_export
@@ -215,10 +160,11 @@ class PskExportOperator(Operator, ExportHelper):
         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]
+        options.should_enforce_bone_name_restrictions = pg.should_enforce_bone_name_restrictions
 
         try:
             psk = build_psk(context, options)
-            export_psk(psk, self.filepath)
+            write_psk(psk, self.filepath)
             self.report({'INFO'}, f'PSK export successful')
         except RuntimeError as e:
             self.report({'ERROR_INVALID_CONTEXT'}, str(e))
@@ -226,29 +172,8 @@ class PskExportOperator(Operator, ExportHelper):
         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_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 = (
-    MaterialListItem,
-    PSK_UL_MaterialList,
-    PskMaterialListItemMoveUp,
-    PskMaterialListItemMoveDown,
-    PskExportOperator,
-    PskExportPropertyGroup,
+    PSK_OT_material_list_move_up,
+    PSK_OT_material_list_move_down,
+    PSK_OT_export,
 )

io_scene_psk_psa/psk/export/properties.py

@@ -0,0 +1,39 @@
+from bpy.props import EnumProperty, CollectionProperty, IntProperty, BoolProperty, StringProperty
+from bpy.types import PropertyGroup
+
+from ...types import PSX_PG_bone_group_list_item
+
+
+class PSK_PG_material_list_item(PropertyGroup):
+    material_name: StringProperty()
+    index: IntProperty()
+
+
+class PSK_PG_export(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_group_list: CollectionProperty(type=PSX_PG_bone_group_list_item)
+    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=PSK_PG_material_list_item)
+    material_list_index: IntProperty(default=0)
+    should_enforce_bone_name_restrictions: BoolProperty(
+        default=False,
+        name='Enforce Bone Name Restrictions',
+        description='Enforce that bone names must only contain letters, numbers, spaces, hyphens and underscores.\n\n'
+                    'Depending on the engine, improper bone names might not be referenced correctly by scripts'
+    )
+
+
+classes = (
+    PSK_PG_material_list_item,
+    PSK_PG_export,
+)

io_scene_psk_psa/psk/export/ui.py

@@ -0,0 +1,12 @@
+from bpy.types import UIList
+
+
+class PSK_UL_materials(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')
+
+
+classes = (
+    PSK_UL_materials,
+)

io_scene_psk_psa/psk/import_/operators.py

@@ -0,0 +1,144 @@
+import os
+import sys
+
+from bpy.props import StringProperty, BoolProperty, EnumProperty, FloatProperty
+from bpy.types import Operator
+from bpy_extras.io_utils import ImportHelper
+
+from ..importer import PskImportOptions, import_psk
+from ..reader import read_psk
+
+empty_set = set()
+
+
+class PSK_OT_import(Operator, ImportHelper):
+    bl_idname = 'import_scene.psk'
+    bl_label = 'Import'
+    bl_options = {'INTERNAL', 'UNDO', 'PRESET'}
+    __doc__ = 'Load a PSK file'
+    filename_ext = '.psk'
+    filter_glob: StringProperty(default='*.psk;*.pskx', options={'HIDDEN'})
+    filepath: StringProperty(
+        name='File Path',
+        description='File path used for exporting the PSK file',
+        maxlen=1024,
+        default='')
+
+    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, if available'
+    )
+    should_import_extra_uvs: BoolProperty(
+        default=True,
+        name='Extra UVs',
+        options=empty_set,
+        description='Import extra UV maps, if available'
+    )
+    should_import_mesh: BoolProperty(
+        default=True,
+        name='Import Mesh',
+        options=empty_set,
+        description='Import mesh'
+    )
+    should_import_materials: BoolProperty(
+        default=True,
+        name='Import Materials',
+        options=empty_set,
+    )
+    should_reuse_materials: BoolProperty(
+        default=True,
+        name='Reuse Materials',
+        options=empty_set,
+        description='Existing materials with matching names will be reused when available'
+    )
+    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'
+    )
+    should_import_shape_keys: BoolProperty(
+        default=True,
+        name='Shape Keys',
+        options=empty_set,
+        description='Import shape keys, if available'
+    )
+
+    def execute(self, context):
+        psk = read_psk(self.filepath)
+
+        options = PskImportOptions()
+        options.name = os.path.splitext(os.path.basename(self.filepath))[0]
+        options.should_import_mesh = self.should_import_mesh
+        options.should_import_extra_uvs = self.should_import_extra_uvs
+        options.should_import_vertex_colors = self.should_import_vertex_colors
+        options.should_import_vertex_normals = self.should_import_vertex_normals
+        options.vertex_color_space = self.vertex_color_space
+        options.should_import_skeleton = self.should_import_skeleton
+        options.bone_length = self.bone_length
+        options.should_import_materials = self.should_import_materials
+        options.should_import_shape_keys = self.should_import_shape_keys
+
+        result = import_psk(psk, context, options)
+
+        if len(result.warnings):
+            message = f'PSK imported with {len(result.warnings)} warning(s)\n'
+            message += '\n'.join(result.warnings)
+            self.report({'WARNING'}, message)
+        else:
+            self.report({'INFO'}, f'PSK imported')
+
+        return {'FINISHED'}
+
+    def draw(self, context):
+        layout = self.layout
+        layout.prop(self, 'should_import_materials')
+        layout.prop(self, 'should_import_mesh')
+        row = layout.column()
+        row.use_property_split = True
+        row.use_property_decorate = False
+        if self.should_import_mesh:
+            row.prop(self, 'should_import_vertex_normals')
+            row.prop(self, 'should_import_extra_uvs')
+            row.prop(self, 'should_import_vertex_colors')
+            if self.should_import_vertex_colors:
+                row.prop(self, 'vertex_color_space')
+            row.prop(self, 'should_import_shape_keys')
+        layout.prop(self, 'should_import_skeleton')
+        row = layout.column()
+        row.use_property_split = True
+        row.use_property_decorate = False
+        if self.should_import_skeleton:
+            row.prop(self, 'bone_length')
+
+
+classes = (
+    PSK_OT_import,
+)

io_scene_psk_psa/psk/importer.py

@@ -1,34 +1,32 @@
-import os
-import sys
 from math import inf
 from typing import Optional, List
 
 import bmesh
 import bpy
 import numpy as np
-from bpy.props import BoolProperty, EnumProperty, FloatProperty, StringProperty
-from bpy.types import Operator, PropertyGroup, VertexGroup
-from bpy_extras.io_utils import ImportHelper
+from bpy.types import VertexGroup
 from mathutils import Quaternion, Vector, Matrix
 
 from .data import Psk
-from .reader import read_psk
-from ..helpers import rgb_to_srgb
+from ..helpers import rgb_to_srgb, is_bdk_addon_loaded
 
 
-class PskImportOptions(object):
+class PskImportOptions:
     def __init__(self):
         self.name = ''
         self.should_import_mesh = True
+        self.should_reuse_materials = 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.should_import_shape_keys = True
         self.bone_length = 1.0
+        self.should_import_materials = True
 
 
-class ImportBone(object):
+class ImportBone:
     """
     Intermediate bone type for the purpose of construction.
     """
@@ -46,7 +44,13 @@ class ImportBone(object):
         self.post_quat: Quaternion = Quaternion()
 
 
-def import_psk(psk: Psk, context, options: PskImportOptions):
+class PskImportResult:
+    def __init__(self):
+        self.warnings: List[str] = []
+
+
+def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
+    result = PskImportResult()
     armature_object = None
 
     if options.should_import_skeleton:
@@ -119,10 +123,24 @@ def import_psk(psk: Psk, context, options: PskImportOptions):
         mesh_object = bpy.data.objects.new(options.name, mesh_data)
 
         # MATERIALS
-        for material in psk.materials:
-            # TODO: re-use of materials should be an option
-            bpy_material = bpy.data.materials.new(material.name.decode('utf-8'))
-            mesh_data.materials.append(bpy_material)
+        if options.should_import_materials:
+            for material_index, psk_material in enumerate(psk.materials):
+                material_name = psk_material.name.decode('utf-8')
+                material = None
+                if options.should_reuse_materials and material_name in bpy.data.materials:
+                    # Material already exists, just re-use it.
+                    material = bpy.data.materials[material_name]
+                elif is_bdk_addon_loaded() and psk.has_material_references:
+                    # Material does not yet exist and we have the BDK addon installed.
+                    # Attempt to load it using BDK addon's operator.
+                    material_reference = psk.material_references[material_index]
+                    if material_reference and bpy.ops.bdk.link_material(reference=material_reference) == {'FINISHED'}:
+                        material = bpy.data.materials[material_name]
+                else:
+                    # Just create a blank material.
+                    material = bpy.data.materials.new(material_name)
+                    material.use_nodes = True
+                mesh_data.materials.append(material)
 
         bm = bmesh.new()
 
@@ -132,17 +150,22 @@ def import_psk(psk: Psk, context, options: PskImportOptions):
 
         bm.verts.ensure_lookup_table()
 
-        degenerate_face_indices = set()
+        invalid_face_indices = set()
         for face_index, face in enumerate(psk.faces):
-            point_indices = [bm.verts[psk.wedges[i].point_index] for i in reversed(face.wedge_indices)]
+            point_indices = map(lambda i: psk.wedges[i].point_index, reversed(face.wedge_indices))
+            points = [bm.verts[i] for i in point_indices]
             try:
-                bm_face = bm.faces.new(point_indices)
+                bm_face = bm.faces.new(points)
                 bm_face.material_index = face.material_index
             except ValueError:
-                degenerate_face_indices.add(face_index)
+                # This happens for two reasons:
+                # 1. Two or more of the face's points are the same. (i.e, point indices of [0, 0, 1])
+                # 2. The face is a duplicate of another face. (i.e., point indices of [0, 1, 2] and [0, 1, 2])
+                invalid_face_indices.add(face_index)
 
-        if len(degenerate_face_indices) > 0:
-            print(f'WARNING: Discarded {len(degenerate_face_indices)} degenerate face(s).')
+        # TODO: Handle invalid faces better.
+        if len(invalid_face_indices) > 0:
+            result.warnings.append(f'Discarded {len(invalid_face_indices)} invalid face(s).')
 
         bm.to_mesh(mesh_data)
 
@@ -150,7 +173,7 @@ def import_psk(psk: Psk, context, options: PskImportOptions):
         data_index = 0
         uv_layer = mesh_data.uv_layers.new(name='VTXW0000')
         for face_index, face in enumerate(psk.faces):
-            if face_index in degenerate_face_indices:
+            if face_index in invalid_face_indices:
                 continue
             face_wedges = [psk.wedges[i] for i in reversed(face.wedge_indices)]
             for wedge in face_wedges:
@@ -165,7 +188,7 @@ def import_psk(psk: Psk, context, options: PskImportOptions):
                 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:
+                    if face_index in invalid_face_indices:
                         continue
                     for wedge_index in reversed(face.wedge_indices):
                         u, v = psk.extra_uvs[wedge_index_offset + wedge_index]
@@ -200,7 +223,8 @@ def import_psk(psk: Psk, context, options: PskImportOptions):
                     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.')
+                result.warnings.append(
+                    f'{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:
@@ -214,6 +238,7 @@ def import_psk(psk: Psk, context, options: PskImportOptions):
         bm.normal_update()
         bm.free()
 
+        # 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))
         vertex_groups: List[Optional[VertexGroup]] = [None] * len(psk.bones)
@@ -223,6 +248,21 @@ def import_psk(psk: Psk, context, options: PskImportOptions):
         for weight in psk.weights:
             vertex_groups[weight.bone_index].add((weight.point_index,), weight.weight, 'ADD')
 
+        # MORPHS (SHAPE KEYS)
+        if options.should_import_shape_keys:
+            morph_data_iterator = iter(psk.morph_data)
+
+            if psk.has_morph_data:
+                mesh_object.shape_key_add(name='MORPH_BASE', from_mix=False)
+
+            for morph_info in psk.morph_infos:
+                shape_key = mesh_object.shape_key_add(name=morph_info.name.decode('windows-1252'), from_mix=False)
+
+                for _ in range(morph_info.vertex_count):
+                    morph_data = next(morph_data_iterator)
+                    x, y, z = morph_data.position_delta
+                    shape_key.data[morph_data.point_index].co += Vector((x, -y, z))
+
         context.scene.collection.objects.link(mesh_object)
 
         # Add armature modifier to our mesh object.
@@ -236,116 +276,4 @@ def import_psk(psk: Psk, context, options: PskImportOptions):
     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 = 'Import'
-    bl_options = {'INTERNAL', 'UNDO'}
-    __doc__ = 'Load a PSK file'
-    filename_ext = '.psk'
-    filter_glob: StringProperty(default='*.psk;*.pskx', options={'HIDDEN'})
-    filepath: StringProperty(
-        name='File Path',
-        description='File path used for exporting the PSK file',
-        maxlen=1024,
-        default='')
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psk_import')
-
-        psk = read_psk(self.filepath)
-
-        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,
-    PskImportPropertyGroup,
-)
+    return result

io_scene_psk_psa/psk/reader.py

@@ -1,4 +1,8 @@
 import ctypes
+import os
+import re
+import warnings
+from pathlib import Path
 
 from .data import *
 
@@ -12,8 +16,22 @@ def _read_types(fp, data_class, section: Section, data):
         offset += section.data_size
 
 
-def read_psk(path) -> Psk:
+def _read_material_references(path: str) -> List[str]:
+    property_file_path = Path(path).with_suffix('.props.txt')
+    if not property_file_path.is_file():
+        # Property file does not exist.
+        return []
+    # Do a crude regex match to find the Material list entries.
+    contents = property_file_path.read_text()
+    pattern = r"Material\s*=\s*([^\s^,]+)"
+    return re.findall(pattern, contents)
+
+
+def read_psk(path: str) -> Psk:
+
     psk = Psk()
+
+    # Read the PSK file sections.
     with open(path, 'rb') as fp:
         while fp.read(1):
             fp.seek(-1, 1)
@@ -45,6 +63,31 @@ def read_psk(path) -> Psk:
                 _read_types(fp, Vector2, section, psk.extra_uvs)
             elif section.name == b'VTXNORMS':
                 _read_types(fp, Vector3, section, psk.vertex_normals)
+            elif section.name == b'MRPHINFO':
+                _read_types(fp, Psk.MorphInfo, section, psk.morph_infos)
+            elif section.name == b'MRPHDATA':
+                _read_types(fp, Psk.MorphData, section, psk.morph_data)
             else:
-                raise RuntimeError(f'Unrecognized section "{section.name} at position {15:fp.tell()}"')
+                # Section is not handled, skip it.
+                fp.seek(section.data_size * section.data_count, os.SEEK_CUR)
+                warnings.warn(f'Unrecognized section "{section.name} at position {fp.tell():15}"')
+
+    '''
+    UEViewer exports a sidecar file (*.props.txt) with fully-qualified reference paths for each material
+    (e.g., Texture'Package.Group.Object').
+    '''
+    psk.material_references = _read_material_references(path)
+
+    '''
+    Tools like UEViewer and CUE4Parse write the point index as a 32-bit integer, exploiting the fact that due to struct
+    alignment, there were 16-bits of padding following the original 16-bit point index in the wedge struct.
+    However, this breaks compatibility with PSK files that were created with older tools that treated the
+    point index as a 16-bit integer and might have junk data written to the padding bits.
+    To work around this, we check if each point is still addressable using a 16-bit index, and if it is, assume the
+    point index is a 16-bit integer and truncate the high bits.
+    '''
+    if len(psk.points) <= 65536:
+        for wedge in psk.wedges:
+            wedge.point_index &= 0xFFFF
+
     return psk

io_scene_psk_psa/psk/writer.py

@@ -0,0 +1,54 @@
+from ctypes import Structure, sizeof
+from typing import Type
+
+from .data import Psk
+from ..data import Section, Vector3
+
+MAX_WEDGE_COUNT = 65536
+MAX_POINT_COUNT = 4294967296
+MAX_BONE_COUNT = 256
+MAX_MATERIAL_COUNT = 256
+
+
+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 write_psk(psk: Psk, path: str):
+    if len(psk.wedges) > MAX_WEDGE_COUNT:
+        raise RuntimeError(f'Number of wedges ({len(psk.wedges)}) exceeds limit of {MAX_WEDGE_COUNT}')
+    if len(psk.points) > MAX_POINT_COUNT:
+        raise RuntimeError(f'Numbers of vertices ({len(psk.points)}) exceeds limit of {MAX_POINT_COUNT}')
+    if len(psk.materials) > MAX_MATERIAL_COUNT:
+        raise RuntimeError(f'Number of materials ({len(psk.materials)}) exceeds limit of {MAX_MATERIAL_COUNT}')
+    if len(psk.bones) > MAX_BONE_COUNT:
+        raise RuntimeError(f'Number of bones ({len(psk.bones)}) exceeds limit of {MAX_BONE_COUNT}')
+    elif len(psk.bones) == 0:
+        raise RuntimeError(f'At least one bone must be marked for export')
+
+    with open(path, 'wb') as fp:
+        _write_section(fp, b'ACTRHEAD')
+        _write_section(fp, b'PNTS0000', Vector3, psk.points)
+
+        wedges = []
+        for index, w in enumerate(psk.wedges):
+            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)
+
+        _write_section(fp, b'VTXW0000', Psk.Wedge16, wedges)
+        _write_section(fp, b'FACE0000', Psk.Face, psk.faces)
+        _write_section(fp, b'MATT0000', Psk.Material, psk.materials)
+        _write_section(fp, b'REFSKELT', Psk.Bone, psk.bones)
+        _write_section(fp, b'RAWWEIGHTS', Psk.Weight, psk.weights)

io_scene_psk_psa/types.py

@@ -1,8 +1,8 @@
-from bpy.props import StringProperty, IntProperty, BoolProperty
-from bpy.types import PropertyGroup, UIList, UILayout, Context, AnyType
+from bpy.props import StringProperty, IntProperty, BoolProperty, FloatProperty
+from bpy.types import PropertyGroup, UIList, UILayout, Context, AnyType, Panel
 
 
-class PSX_UL_BoneGroupList(UIList):
+class PSX_UL_bone_group_list(UIList):
 
     def draw_item(self, context: Context, layout: UILayout, data: AnyType, item: AnyType, icon: int,
                   active_data: AnyType, active_property: str, index: int = 0, flt_flag: int = 0):
@@ -11,14 +11,40 @@ class PSX_UL_BoneGroupList(UIList):
         row.label(text=str(getattr(item, 'count')), icon='BONE_DATA')
 
 
-class BoneGroupListItem(PropertyGroup):
+class PSX_PG_bone_group_list_item(PropertyGroup):
     name: StringProperty()
     index: IntProperty()
     count: IntProperty()
     is_selected: BoolProperty(default=False)
 
 
+class PSX_PG_action_export(PropertyGroup):
+    compression_ratio: FloatProperty(name='Compression Ratio', default=1.0, min=0.0, max=1.0, subtype='FACTOR', description='The key sampling ratio of the exported sequence.\n\nA compression ratio of 1.0 will export all frames, while a compression ratio of 0.5 will export half of the frames')
+    key_quota: IntProperty(name='Key Quota', default=0, min=1, description='The minimum number of frames to be exported')
+
+
+class PSX_PT_action(Panel):
+    bl_idname = 'PSX_PT_action'
+    bl_label = 'PSA Export'
+    bl_space_type = 'DOPESHEET_EDITOR'
+    bl_region_type = 'UI'
+    bl_context = 'action'
+    bl_category = 'Action'
+
+    @classmethod
+    def poll(cls, context: 'Context'):
+        return context.active_object and context.active_object.type == 'ARMATURE' and context.active_action is not None
+
+    def draw(self, context: 'Context'):
+        action = context.active_action
+        layout = self.layout
+        layout.prop(action.psa_export, 'compression_ratio')
+        layout.prop(action.psa_export, 'key_quota')
+
+
 classes = (
-    BoneGroupListItem,
-    PSX_UL_BoneGroupList,
+    PSX_PG_action_export,
+    PSX_PG_bone_group_list_item,
+    PSX_UL_bone_group_list,
+    PSX_PT_action
 )