Fixed duplicate code issue

# Conflicts:
#	io_scene_psk_psa/psa/importer.py

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,34 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Versions**
+Blender: (example: 3.6.2)
+io_scene_psk_psa: (example: 5.0.0)
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Files**
+Please post attachments of the PSK and/or PSA files that you are using to encounter the bug, if any.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

README.md

@@ -1,40 +1,70 @@
-This Blender add-on allows you to import and export meshes and animations to the [PSK and PSA file formats](https://wiki.beyondunreal.com/PSK_%26_PSA_file_formats).
+[![Blender](https://img.shields.io/badge/Blender->=2.9-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 addon 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.
+
+# Compatibility
+
+| Blender Version                                            | Addon Version                                                                  | Long Term Support |
+|------------------------------------------------------------|--------------------------------------------------------------------------------|-------------------|
+| [4.1](https://www.blender.org/download/releases/4-1/)      | [latest](https://github.com/DarklightGames/io_scene_psk_psa/releases/latest)   | TBD               |
+| [4.0](https://www.blender.org/download/releases/4-0/)      | [6.2.1](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/6.2.1) | TBD               |                                      
+| [3.4 - 3.6](https://www.blender.org/download/lts/3-6/)     | [5.0.6](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/5.0.6) | ✅️ June 2025      |
+| [2.93 - 3.3](https://www.blender.org/download/releases/3-3/) | [4.3.0](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/4.3.0) | ✅️ September 2024 |
+
+Bug fixes will be issued for legacy addon versions that are under [Blender's LTS maintenance period](https://www.blender.org/download/lts/). Once the LTS period has ended, legacy addon versions will no longer be supported by the maintainers of this repository, although we will accept pull requests for bug fixes. 
+
+# Features
+* 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 collections 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) or NLA track strips, 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.
+2. Open Blender 4.0.0 or later.
-3. Navigate to the Blender Preferences (Edit > Preferences).
+3. Navigate to the Blender Preferences (`Edit` > `Preferences`).
-4. Select the "Add-ons" tab.
+4. Select the `Add-ons` tab.
-5. Click the "Install..." button.
+5. Click the `Install...` button.
-6. Select the .zip file that you downloaded earlier and click "Install Add-on".
+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.
+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)
+2. Navigate to `File` > `Export` > `Unreal PSK (.psk)`.
-4. Enter the file name and click "Export".
+3. Enter the file name and click `Export`.
 
-## Importing a PSK
+## Importing a PSK/PSKX
-1. Navigate to File > Import > Unreal PSK (.psk)
+1. Navigate to `File` > `Import` > `Unreal PSK (.psk/.pskx)`.
-2. Select the PSK file you want to import and click "Import"
+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)
+2. Navigate to `File` > `Export` > `Unreal PSA (.psa)`.
-3. Enter the file name and click "Export".
+3. Enter the file name and click `Export`.
 
 ## Importing a PSA
-1. Select the armature object that you wish you import actions to.
+1. Select an armature that you want import animations for.
-2. Navigate to the Object Data Properties tab of the Properties editor.
+2. Navigate to `File` > `Import` > `Unreal PSA (.psa)`.
-3. Navigate to the PSA Import panel.
+3. Select the PSA file you want to import.
-4. Click "Select PSA File".
+4. Select the sequences that you want to import and click `Import`.
-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.
+> Note that in order to see the imported actions applied to your armature, you must use the [Dope Sheet](https://docs.blender.org/manual/en/latest/editors/dope_sheet/introduction.html) or [Nonlinear Animation](https://docs.blender.org/manual/en/latest/editors/nla/introduction.html) editors.
-7. Click "Import".
 
 # FAQ
+
+## Why can't I see the animations imported from my PSA?
+Simply importing an animation into the scene will not automatically apply the action to the armature. This is in part because a PSA can have multiple sequences imported from it, and also that it's generally bad form for importers to modify the scene when they don't need to.
+
+The PSA importer creates [Actions](https://docs.blender.org/manual/en/latest/animation/actions.html) for each of the selected sequences in the PSA. These actions can be applied to your armature via the [Action Editor](https://docs.blender.org/manual/en/latest/editors/dope_sheet/action.html) or [NLA Editor](https://docs.blender.org/manual/en/latest/editors/nla/index.html).
+
 ## Why are the mesh normals not accurate when importing a PSK extracted from [UE Viewer](https://www.gildor.org/en/projects/umodel)?
 If preserving the mesh normals of models is important for your workflow, it is *not recommended* to export PSK files from UE Viewer. This is because UE Viewer makes no attempt to reconstruct the original [smoothing groups](https://en.wikipedia.org/wiki/Smoothing_group). As a result, the normals of imported PSK files will be incorrect when imported into Blender and will need to be manually fixed.
 
-As a workaround, it is recommended to export [glTF](https://en.wikipedia.org/wiki/GlTF) meshes out of UE Viewer instead, since the glTF format has support for explicit normals and UE Viewer can correctly preserve the mesh normals on export. Note, however, that the imported glTF armature may have it's bones oriented incorrectly when imported into blender. To mitigate this, you can combine the armature of PSK and the mesh of the glTF for best results.
+As a workaround, it is recommended to export [glTF](https://en.wikipedia.org/wiki/GlTF) meshes out of UE Viewer instead, since the glTF format has support for explicit normals and UE Viewer can correctly preserve the mesh normals on export. Note, however, that the imported glTF armature may have it's bones oriented incorrectly when imported into Blender. To mitigate this, you can combine the armature of PSK and the mesh of the glTF for best results.

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,68 +1,110 @@
+from bpy.app.handlers import persistent
+
 bl_info = {
-    "name": "PSK/PSA Importer/Exporter",
+    'name': 'PSK/PSA Importer/Exporter',
-    "author": "Colin Basnett",
+    'author': 'Colin Basnett, Yurii Ti',
-    "version": (1, 2, 0),
+    'version': (7, 0, 0),
-    "blender": (2, 80, 0),
+    'blender': (4, 1, 0),
-    # "location": "File > Export > PSK Export (.psk)",
+    'description': 'PSK/PSA Import/Export (.psk/.psa)',
-    "description": "PSK/PSA Import/Export (.psk/.psa)",
+    'warning': '',
-    "warning": "",
+    'doc_url': 'https://github.com/DarklightGames/io_scene_psk_psa',
-    "doc_url": "https://github.com/DarklightGames/io_scene_psk_psa",
+    'tracker_url': 'https://github.com/DarklightGames/io_scene_psk_psa/issues',
-    "tracker_url": "https://github.com/DarklightGames/io_scene_psk_psa/issues",
+    'category': 'Import-Export'
-    "category": "Import-Export"
 }
 
 if 'bpy' in locals():
     import importlib
+
     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_properties)
+    importlib.reload(psk_ui)
+    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_config)
-    importlib.reload(psa_exporter)
     importlib.reload(psa_reader)
+    importlib.reload(psa_writer)
+    importlib.reload(psa_builder)
     importlib.reload(psa_importer)
+    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 .psa import data as psa_data
+    from .psk import properties as psk_properties
-    from .psa import builder as psa_builder
+    from .psk import ui as psk_ui
-    from .psa import exporter as psa_exporter
+    from .psk.export import properties as psk_export_properties
-    from .psa import reader as psa_reader
+    from .psk.export import operators as psk_export_operators
-    from .psa import importer as psa_importer
+    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 config as psa_config
+    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__ + \
+classes = psx_types.classes +\
-          psk_importer.__classes__ + \
+          psk_properties.classes +\
-          psk_exporter.__classes__ + \
+          psk_ui.classes +\
-          psa_exporter.__classes__ + \
+          psk_import_operators.classes +\
-          psa_importer.__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)')
+    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 +113,40 @@ 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.TOPBAR_MT_file_import.append(psa_import_menu_func)
-    bpy.types.Scene.psa_export = PointerProperty(type=psa_exporter.PsaExportPropertyGroup)
+    bpy.types.Material.psk = PointerProperty(type=psk_properties.PSX_PG_material)
-    bpy.types.Scene.psk_export = PointerProperty(type=psk_exporter.PskExportPropertyGroup)
+    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_export
+    del bpy.types.Material.psk
     del bpy.types.Scene.psa_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)
 
 
 if __name__ == '__main__':
     register()
+
+
+@persistent
+def load_handler(dummy):
+    # Convert old `psa_sequence_fps` property to new `psa_export.fps` property.
+    # This is only needed for backwards compatibility with files that may have used older versions of the addon.
+    for action in bpy.data.actions:
+        if 'psa_sequence_fps' in action:
+            action.psa_export.fps = action['psa_sequence_fps']
+            del action['psa_sequence_fps']
+
+
+bpy.app.handlers.load_post.append(load_handler)

io_scene_psk_psa/data.py

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

io_scene_psk_psa/helpers.py

@@ -1,61 +1,168 @@
-from typing import List
+import re
+import typing
+from typing import List, Iterable
+
+import addon_utils
+import bpy.types
+from bpy.types import NlaStrip, Object, AnimData
 
 
-def populate_bone_group_list(armature_object, bone_group_list):
+def rgb_to_srgb(c: float):
-    bone_group_list.clear()
+    if c > 0.0031308:
+        return 1.055 * (pow(c, (1.0 / 2.4))) - 0.055
+    else:
+        return 12.92 * c
 
-    item = bone_group_list.add()
+
-    item.name = '(unassigned)'
+def get_nla_strips_in_frame_range(animation_data: AnimData, frame_min: float, frame_max: float) -> List[NlaStrip]:
+    if animation_data is None:
+        return []
+    strips = []
+    for nla_track in animation_data.nla_tracks:
+        if nla_track.mute:
+            continue
+        for strip in nla_track.strips:
+            if (strip.frame_start < frame_min and strip.frame_end > frame_max) or \
+                    (frame_min <= strip.frame_start < frame_max) or \
+                    (frame_min < strip.frame_end <= frame_max):
+                strips.append(strip)
+    return strips
+
+
+def populate_bone_collection_list(armature_object: Object, bone_collection_list: bpy.props.CollectionProperty) -> None:
+    '''
+    Updates the bone collections collection.
+
+    Bone collection selections are preserved between updates unless none of the groups were previously selected;
+    otherwise, all collections are selected by default.
+    '''
+    has_selected_collections = any([g.is_selected for g in bone_collection_list])
+    unassigned_collection_is_selected, selected_assigned_collection_names = True, []
+
+    if armature_object is None:
+        return
+
+    if has_selected_collections:
+        # Preserve group selections before clearing the list.
+        # We handle selections for the unassigned group separately to cover the edge case
+        # where there might be an actual group with 'Unassigned' as its name.
+        unassigned_collection_idx, unassigned_collection_is_selected = next(iter([
+            (i, g.is_selected) for i, g in enumerate(bone_collection_list) if g.index == -1]), (-1, False))
+
+        selected_assigned_collection_names = [
+            g.name for i, g in enumerate(bone_collection_list) if i != unassigned_collection_idx and g.is_selected]
+
+    bone_collection_list.clear()
+
+    armature = armature_object.data
+
+    if armature is None:
+        return
+
+    item = bone_collection_list.add()
+    item.name = 'Unassigned'
     item.index = -1
-    item.is_selected = True
+    # Count the number of bones without an assigned bone collection
+    item.count = sum(map(lambda bone: 1 if len(bone.collections) == 0 else 0, armature.bones))
+    item.is_selected = unassigned_collection_is_selected
 
-    if armature_object and armature_object.pose:
+    for bone_collection_index, bone_collection in enumerate(armature.collections):
-        for bone_group_index, bone_group in enumerate(armature_object.pose.bone_groups):
+        item = bone_collection_list.add()
-            item = bone_group_list.add()
+        item.name = bone_collection.name
-            item.name = bone_group.name
+        item.index = bone_collection_index
-            item.index = bone_group_index
+        item.count = len(bone_collection.bones)
-            item.is_selected = True
+        item.is_selected = bone_collection.name in selected_assigned_collection_names if has_selected_collections else True
 
 
-def add_bone_groups_to_layout(layout):
+def check_bone_names(bone_names: Iterable[str]):
-    pass
+    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, hyphens and underscores.\n'
+                           f'You can bypass this by disabling "Enforce Bone Name Restrictions" in the export settings.')
 
 
-def get_export_bone_indices_for_bone_groups(armature_object, bone_group_indices: List[int]) -> List[int]:
+def get_export_bone_names(armature_object: Object, bone_filter_mode: str, bone_collection_indices: List[int]) -> List[str]:
-    """
+    '''
-    Returns a sorted list of bone indices that should be exported for the given bone groups.
+    Returns a sorted list of bone indices that should be exported for the given bone filter mode and bone collections.
 
-    Note that the ancestors of bones within the bone groups will also be present in the returned list.
+    Note that the ancestors of bones within the bone collections will also be present in the returned list.
 
     :param armature_object: Blender object with type 'ARMATURE'
-    :param bone_group_indices: List of bone group indices to be exported.
+    :param bone_filter_mode: One of ['ALL', 'BONE_COLLECTIONS']
+    :param bone_collection_indices: List of bone collection indices to be exported.
     :return: A sorted list of bone indices that should be exported.
-    """
+    '''
     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)
-    pose_bones = armature_object.pose.bones
+    bones = armature_data.bones
     bone_names = [x.name for x in bones]
 
-    # Get a list of the bone indices that are explicitly part of the bone groups we are including.
+    # Get a list of the bone indices that we are explicitly including.
     bone_index_stack = []
-    is_exporting_none_bone_groups = -1 in bone_group_indices
+    is_exporting_unassigned_bone_collections = -1 in bone_collection_indices
-    for bone_index, pose_bone in enumerate(pose_bones):
+    bone_collections = list(armature_data.collections)
-        if (pose_bone.bone_group is None and is_exporting_none_bone_groups) or \
+
-                (pose_bone.bone_group is not None and pose_bone.bone_group_index in bone_group_indices):
+    for bone_index, bone in enumerate(bones):
-            bone_index_stack.append(bone_index)
+        # Check if this bone is in any of the collections in the bone collection indices list.
+        this_bone_collection_indices = set(bone_collections.index(x) for x in bone.collections)
+        is_in_exported_bone_collections = len(set(bone_collection_indices).intersection(this_bone_collection_indices)) > 0
+
+        if bone_filter_mode == 'ALL' or \
+                (len(bone.collections) == 0 and is_exporting_unassigned_bone_collections) or \
+                is_in_exported_bone_collections:
+            bone_index_stack.append((bone_index, None))
 
     # For each bone that is explicitly being added, recursively walk up the hierarchy and ensure that all of
     # those ancestor bone indices are also in the list.
-    bone_indices = set()
+    bone_indices = dict()
     while len(bone_index_stack) > 0:
-        bone_index = bone_index_stack.pop()
+        bone_index, instigator_bone_index = bone_index_stack.pop()
         bone = bones[bone_index]
         if bone.parent is not None:
             parent_bone_index = bone_names.index(bone.parent.name)
             if parent_bone_index not in bone_indices:
-                bone_index_stack.append(parent_bone_index)
+                bone_index_stack.append((parent_bone_index, bone_index))
-        bone_indices.add(bone_index)
+        bone_indices[bone_index] = instigator_bone_index
 
-    return list(sorted(list(bone_indices)))
+    # Sort the bone index list in-place.
+    bone_indices = [(x[0], x[1]) for x in bone_indices.items()]
+    bone_indices.sort(key=lambda x: x[0])
+
+    # Split out the bone indices and the instigator bone names into separate lists.
+    # We use the bone names for the return values because the bone name is a more universal way of referencing them.
+    # For example, users of this function may modify bone lists, which would invalidate the indices and require an
+    # index mapping scheme to resolve it. Using strings is more comfy and results in less code downstream.
+    instigator_bone_names = [bones[x[1]].name if x[1] is not None else None for x in bone_indices]
+    bone_names = [bones[x[0]].name for x in bone_indices]
+
+    # Ensure that the hierarchy we are sending back has a single root bone.
+    bone_indices = [x[0] for x in bone_indices]
+    root_bones = [bones[bone_index] for bone_index in bone_indices if bones[bone_index].parent is None]
+    if len(root_bones) > 1:
+        # There is more than one root bone.
+        # Print out why each root bone was included by linking it to one of the explicitly included bones.
+        root_bone_names = [bone.name for bone in root_bones]
+        for root_bone_name in root_bone_names:
+            bone_name = root_bone_name
+            while True:
+                # Traverse the instigator chain until the end to find the true instigator bone.
+                # TODO: in future, it would be preferential to have a readout of *all* instigator bones.
+                instigator_bone_name = instigator_bone_names[bone_names.index(bone_name)]
+                if instigator_bone_name is None:
+                    print(f'Root bone "{root_bone_name}" was included because {bone_name} was marked for export')
+                    break
+                bone_name = instigator_bone_name
+
+        raise RuntimeError('Exported bone hierarchy must have a single root bone.\n'
+                           f'The bone hierarchy marked for export has {len(root_bones)} root bones: {root_bone_names}.\n'
+                           f'Additional debugging information has been written to the console.')
+
+    return bone_names
+
+
+def is_bdk_addon_loaded():
+    return addon_utils.check('bdk_addon')[1]

io_scene_psk_psa/psa/builder.py

@@ -1,87 +1,122 @@
+from typing import Optional
+
+from bpy.types import Armature, Bone, Action, PoseBone
+
 from .data import *
 from ..helpers import *
 
 
-class PsaBuilderOptions(object):
+class PsaBuildSequence:
+    class NlaState:
         def __init__(self):
-        self.actions = []
+            self.action: Optional[Action] = None
-        self.bone_filter_mode = 'ALL'
+            self.frame_start: int = 0
-        self.bone_group_indices = []
+            self.frame_end: int = 0
 
-
-class PsaBuilder(object):
     def __init__(self):
-        pass
+        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 build(self, context, options: PsaBuilderOptions) -> Psa:
-        object = context.view_layer.objects.active
 
-        if object.type != 'ARMATURE':
+class PsaBuildOptions:
-            raise RuntimeError('Selected object must be an Armature')
+    def __init__(self):
+        self.animation_data: Optional[AnimData] = None
+        self.sequences: List[PsaBuildSequence] = []
+        self.bone_filter_mode: str = 'ALL'
+        self.bone_collection_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
 
-        armature = object
 
-        if armature.animation_data is None:
+def _get_pose_bone_location_and_rotation(pose_bone: PoseBone, armature_object: Object, options: PsaBuildOptions):
-            raise RuntimeError('No animation data for armature')
+    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:
+            # 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:
+            # Use the bind pose matrix for the root bone.
+            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()
+
+    return location, rotation
+
+
+def build_psa(context: bpy.types.Context, options: PsaBuildOptions) -> Psa:
+    active_object = context.view_layer.objects.active
 
     psa = Psa()
 
-        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 as a result, we need to reconstruct the list of pose bones in the same order as the
+    # 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]
-        del bone_names
     pose_bones.sort(key=lambda x: x[0])
     pose_bones = [x[1] for x in pose_bones]
 
-        bone_indices = list(range(len(bones)))
+    # Get a list of all the bone indices and instigator bones for the bone filter settings.
-
+    export_bone_names = get_export_bone_names(armature_object, options.bone_filter_mode, options.bone_collection_indices)
-        # If bone groups are specified, get only the bones that are in that specified bone groups and their ancestors.
+    bone_indices = [bone_names.index(x) for x in export_bone_names]
-        if options.bone_filter_mode == 'BONE_GROUPS':
-            bone_indices = get_export_bone_indices_for_bone_groups(armature, options.bone_group_indices)
 
     # Make the bone lists contain only the bones that are going to be exported.
     bones = [bones[bone_index] for bone_index in bone_indices]
     pose_bones = [pose_bones[bone_index] for bone_index in bone_indices]
 
-        if len(bones) == 0:
     # No bones are going to be exported.
+    if len(bones) == 0:
         raise RuntimeError('No bones available for export')
 
-        # Ensure that the exported hierarchy has a single root bone.
+    # Check that all bone names are valid.
-        root_bones = [x for x in bones if x.parent is None]
+    if options.should_enforce_bone_name_restrictions:
-        if len(root_bones) > 1:
+        check_bone_names(map(lambda bone: bone.name, bones))
-            root_bone_names = [x.name for x in bones]
-            raise RuntimeError('Exported bone hierarchy must have a single root bone.'
-                               f'The bone hierarchy marked for export has {len(root_bones)} root bones: {root_bone_names}')
         
-        for pose_bone in bones:
+    # Build list of PSA bones.
+    for bone in bones:
         psa_bone = Psa.Bone()
-            psa_bone.name = bytes(pose_bone.name, encoding='utf-8')
 
         try:
-                parent_index = bones.index(pose_bone.parent)
+            psa_bone.name = bytes(bone.name, encoding='windows-1252')
+        except UnicodeEncodeError:
+            raise RuntimeError(f'Bone name "{bone.name}" contains characters that cannot be encoded in the Windows-1252 codepage')
+
+        try:
+            parent_index = bones.index(bone.parent)
             psa_bone.parent_index = parent_index
             psa.bones[parent_index].children_count += 1
         except ValueError:
-                psa_bone.parent_index = -1
+            psa_bone.parent_index = 0
 
-            if pose_bone.parent is not None:
+        if bone.parent is not None:
-                rotation = pose_bone.matrix.to_quaternion()
+            rotation = bone.matrix.to_quaternion().conjugated()
-                rotation.x = -rotation.x
+            inverse_parent_rotation = bone.parent.matrix.to_quaternion().inverted()
-                rotation.y = -rotation.y
+            parent_head = inverse_parent_rotation @ bone.parent.head
-                rotation.z = -rotation.z
+            parent_tail = inverse_parent_rotation @ bone.parent.tail
-                quat_parent = pose_bone.parent.matrix.to_quaternion().inverted()
+            location = (parent_tail - parent_head) + bone.head
-                parent_head = quat_parent @ pose_bone.parent.head
-                parent_tail = quat_parent @ pose_bone.parent.tail
-                location = (parent_tail - parent_head) + pose_bone.head
         else:
-                location = armature.matrix_local @ pose_bone.head
+            armature_local_matrix = armature_object.matrix_local
-                rot_matrix = pose_bone.matrix @ armature.matrix_local.to_3x3()
+            location = armature_local_matrix @ bone.head
-                rotation = rot_matrix.to_quaternion()
+            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
@@ -94,44 +129,66 @@ class PsaBuilder(object):
 
         psa.bones.append(psa_bone)
 
+    # Add prefixes and suffices to the names of the export sequences and strip whitespace.
+    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 action in options.actions:
+    context.window_manager.progress_begin(0, len(options.sequences))
-            if len(action.fcurves) == 0:
-                continue
 
-            armature.animation_data.action = action
+    for export_sequence_index, export_sequence in enumerate(options.sequences):
+        # Link the action to the animation data and update view layer.
+        options.animation_data.action = export_sequence.nla_state.action
         context.view_layer.update()
 
-            frame_min, frame_max = [int(x) for x in action.frame_range]
+        frame_start = export_sequence.nla_state.frame_start
+        frame_end = export_sequence.nla_state.frame_end
 
-            sequence = Psa.Sequence()
+        # Calculate the frame step based on the compression factor.
-            sequence.name = bytes(action.name, encoding='utf-8')
+        frame_extents = abs(frame_end - frame_start)
-            sequence.frame_count = frame_max - frame_min + 1
+        frame_count_raw = frame_extents + 1
-            sequence.frame_start_index = frame_start_index
+        frame_count = max(export_sequence.key_quota, int(frame_count_raw * export_sequence.compression_ratio))
-            sequence.fps = context.scene.render.fps
 
-            frame_count = frame_max - frame_min + 1
+        try:
+            frame_step = frame_extents / (frame_count - 1)
+        except ZeroDivisionError:
+            frame_step = 0.0
 
-            for frame in range(frame_count):
+        sequence_duration = frame_count_raw / export_sequence.fps
-                context.scene.frame_set(frame_min + frame)
+
+        # 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()
+        try:
+            psa_sequence.name = bytes(export_sequence.name, encoding='windows-1252')
+        except UnicodeEncodeError:
+            raise RuntimeError(f'Sequence name "{export_sequence.name}" contains characters that cannot be encoded in the Windows-1252 codepage')
+        psa_sequence.frame_count = frame_count
+        psa_sequence.frame_start_index = frame_start_index
+        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
+
+        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()
-                    pose_bone_matrix = pose_bone.matrix
-
-                    if pose_bone.parent is not None:
-                        pose_bone_parent_matrix = pose_bone.parent.matrix
-                        pose_bone_matrix = pose_bone_parent_matrix.inverted() @ pose_bone_matrix
-
-                    location = pose_bone_matrix.to_translation()
-                    rotation = pose_bone_matrix.to_quaternion().normalized()
-
-                    if pose_bone.parent is not None:
-                        rotation.x = -rotation.x
-                        rotation.y = -rotation.y
-                        rotation.z = -rotation.z
-
                 key.location.x = location.x
                 key.location.y = location.y
                 key.location.z = location.z
@@ -139,15 +196,21 @@ class PsaBuilder(object):
                 key.rotation.y = rotation.y
                 key.rotation.z = rotation.z
                 key.rotation.w = rotation.w
-                    key.time = 1.0 / sequence.fps
+                key.time = 1.0 / psa_sequence.fps
-
                 psa.keys.append(key)
 
-                frame_start_index += 1
+            frame += frame_step
 
-                sequence.bone_count = len(pose_bones)
+        frame_start_index += frame_count
-                sequence.track_time = frame_count
 
-            psa.sequences[action.name] = sequence
+        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/config.py

@@ -0,0 +1,78 @@
+import re
+from configparser import ConfigParser
+from typing import Dict
+
+from .reader import PsaReader
+
+REMOVE_TRACK_LOCATION = (1 << 0)
+REMOVE_TRACK_ROTATION = (1 << 1)
+
+
+class PsaConfig:
+    def __init__(self):
+        self.sequence_bone_flags: Dict[str, Dict[int, int]] = dict()
+
+
+def _load_config_file(file_path: str) -> ConfigParser:
+    """
+    UEViewer exports a dialect of INI files that is not compatible with Python's ConfigParser.
+    Specifically, it allows values in this format:
+
+    [Section]
+    Key1
+    Key2
+
+    This is not allowed in Python's ConfigParser, which requires a '=' character after each key name.
+    To work around this, we'll modify the file to add the '=' character after each key name if it is missing.
+    """
+    with open(file_path, 'r') as f:
+        lines = f.read().split('\n')
+
+    lines = [re.sub(r'^\s*(\w+)\s*$', r'\1=', line) for line in lines]
+
+    contents = '\n'.join(lines)
+
+    config = ConfigParser()
+    config.read_string(contents)
+
+    return config
+
+
+def _get_bone_flags_from_value(value: str) -> int:
+    match value:
+        case 'all':
+            return REMOVE_TRACK_LOCATION | REMOVE_TRACK_ROTATION
+        case 'trans':
+            return REMOVE_TRACK_LOCATION
+        case 'rot':
+            return REMOVE_TRACK_ROTATION
+        case _:
+            return 0
+
+
+def read_psa_config(psa_reader: PsaReader, file_path: str) -> PsaConfig:
+    psa_config = PsaConfig()
+
+    config = _load_config_file(file_path)
+
+    if config.has_section('RemoveTracks'):
+        for key, value in config.items('RemoveTracks'):
+            match = re.match(f'^(.+)\.(\d+)$', key)
+            sequence_name = match.group(1)
+
+            # Map the sequence name onto the actual sequence name in the PSA file.
+            try:
+                psa_sequence_names = list(psa_reader.sequences.keys())
+                lowercase_sequence_names = [sequence_name.lower() for sequence_name in psa_sequence_names]
+                sequence_name = psa_sequence_names[lowercase_sequence_names.index(sequence_name.lower())]
+            except ValueError:
+                # Sequence name is not in the PSA file.
+                continue
+
+            if sequence_name not in psa_config.sequence_bone_flags:
+                psa_config.sequence_bone_flags[sequence_name] = dict()
+
+            bone_index = int(match.group(2))
+            psa_config.sequence_bone_flags[sequence_name][bone_index] = _get_bone_flags_from_value(value)
+
+    return psa_config

io_scene_psk_psa/psa/data.py

@@ -1,15 +1,16 @@
 import typing
-from typing import List
 from collections import OrderedDict
+from typing import List
+
 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),
@@ -59,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,530 @@
+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 .properties import PSA_PG_export, PSA_PG_export_action_list_item, filter_sequences
+from ..builder import build_psa, PsaBuildSequence, PsaBuildOptions
+from ..writer import write_psa
+from ...helpers import populate_bone_collection_list, get_nla_strips_in_frame_range
+
+
+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 action.name != '' and 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.strip() == '' or 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.strip() == '' or marker_name.startswith('#'):
+            continue
+        frame_start, frame_end = sequence_frame_ranges[marker_name]
+        sequences = get_sequences_from_name_and_frame_range(marker_name, frame_start, frame_end)
+        for (sequence_name, frame_start, frame_end) in sequences:
+            item = pg.marker_list.add()
+            item.name = sequence_name
+            item.is_selected = False
+            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:
+    match fps_source:
+        case 'SCENE':
+            return context.scene.render.fps
+        case 'CUSTOM':
+            return fps_custom
+        case 'ACTION_METADATA':
+            # Get the minimum value of action metadata FPS values.
+            return min([action.psa_export.fps for action in actions])
+        case _:
+            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.sequence_source != 'ACTIONS' and 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_COLLECTIONS':
+        armature = context.active_object.data
+        if len(armature.collections) == 0:
+            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_frame_range(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_name_and_frame_range(name: str, frame_start: int, frame_end: int) -> List[Tuple[str, int, int]]:
+    reversed_pattern = r'(.+)/(.+)'
+    reversed_match = re.match(reversed_pattern, 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 [(name, frame_start, frame_end)]
+
+
+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])
+    return get_sequences_from_name_and_frame_range(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])
+    return get_sequences_from_name_and_frame_range(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 in {'TIMELINE_MARKERS', 'NLA_TRACK_STRIPS'}:
+            # ANIMDATA SOURCE
+            layout.prop(pg, 'should_override_animation_data')
+            if pg.should_override_animation_data:
+                layout.prop(pg, 'animation_data_override', text='')
+
+        if pg.sequence_source == 'NLA_TRACK_STRIPS':
+            flow = layout.grid_flow()
+            flow.use_property_split = True
+            flow.use_property_decorate = False
+            flow.prop(pg, 'nla_track')
+
+        # 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)
+        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)
+        elif pg.sequence_source == 'NLA_TRACK_STRIPS':
+            rows = max(3, min(len(pg.nla_strip_list), 10))
+            layout.template_list('PSA_UL_export_sequences', '', pg, 'nla_strip_list', pg, 'nla_strip_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_COLLECTIONS':
+            row = layout.row(align=True)
+            row.label(text='Select')
+            row.operator(PSA_OT_export_bone_collections_select_all.bl_idname, text='All', icon='CHECKBOX_HLT')
+            row.operator(PSA_OT_export_bone_collections_deselect_all.bl_idname, text='None', icon='CHECKBOX_DEHLT')
+            rows = max(3, min(len(pg.bone_collection_list), 10))
+            layout.template_list('PSX_UL_bone_collection_list', '', pg, 'bone_collection_list', pg, 'bone_collection_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_collection_list(self.armature_object, pg.bone_collection_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_list) == 0:
+            raise RuntimeError('No timeline markers were selected for export')
+        elif pg.sequence_source == 'NLA_TRACK_STRIPS' and len(pg.nla_strip_list) == 0:
+            raise RuntimeError('No NLA track strips 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_item in filter(lambda x: x.is_selected, pg.action_list):
+                if len(action_item.action.fcurves) == 0:
+                    continue
+                export_sequence = PsaBuildSequence()
+                export_sequence.nla_state.action = action_item.action
+                export_sequence.name = action_item.name
+                export_sequence.nla_state.frame_start = action_item.frame_start
+                export_sequence.nla_state.frame_end = action_item.frame_end
+                export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, [action_item.action])
+                export_sequence.compression_ratio = action_item.action.psa_export.compression_ratio
+                export_sequence.key_quota = action_item.action.psa_export.key_quota
+                export_sequences.append(export_sequence)
+        elif pg.sequence_source == 'TIMELINE_MARKERS':
+            for marker_item in filter(lambda x: x.is_selected, pg.marker_list):
+                export_sequence = PsaBuildSequence()
+                export_sequence.name = marker_item.name
+                export_sequence.nla_state.action = None
+                export_sequence.nla_state.frame_start = marker_item.frame_start
+                export_sequence.nla_state.frame_end = marker_item.frame_end
+                nla_strips_actions = set(
+                    map(lambda x: x.action, get_nla_strips_in_frame_range(animation_data, marker_item.frame_start, marker_item.frame_end)))
+                export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, nla_strips_actions)
+                export_sequences.append(export_sequence)
+        elif pg.sequence_source == 'NLA_TRACK_STRIPS':
+            for nla_strip_item in filter(lambda x: x.is_selected, pg.nla_strip_list):
+                export_sequence = PsaBuildSequence()
+                export_sequence.name = nla_strip_item.name
+                export_sequence.nla_state.action = None
+                export_sequence.nla_state.frame_start = nla_strip_item.frame_start
+                export_sequence.nla_state.frame_end = nla_strip_item.frame_end
+                export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, [nla_strip_item.action])
+                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_collection_indices = [x.index for x in pg.bone_collection_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
+        elif pg.sequence_source == 'NLA_TRACK_STRIPS':
+            return pg.nla_strip_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
+        elif pg.sequence_source == 'NLA_TRACK_STRIPS':
+            return pg.nla_strip_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_collections_select_all(Operator):
+    bl_idname = 'psa_export.bone_collections_select_all'
+    bl_label = 'Select All'
+    bl_description = 'Select all bone collections'
+    bl_options = {'INTERNAL'}
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psa_export')
+        item_list = pg.bone_collection_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_collection_list:
+            item.is_selected = True
+        return {'FINISHED'}
+
+
+class PSA_OT_export_bone_collections_deselect_all(Operator):
+    bl_idname = 'psa_export.bone_collections_deselect_all'
+    bl_label = 'Deselect All'
+    bl_description = 'Deselect all bone collections'
+    bl_options = {'INTERNAL'}
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psa_export')
+        item_list = pg.bone_collection_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_collection_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_collections_select_all,
+    PSA_OT_export_bone_collections_deselect_all,
+)

io_scene_psk_psa/psa/export/properties.py

@@ -0,0 +1,225 @@
+import re
+import sys
+from fnmatch import fnmatch
+from typing import List, Optional
+
+from bpy.props import BoolProperty, PointerProperty, EnumProperty, FloatProperty, CollectionProperty, IntProperty, \
+    StringProperty
+from bpy.types import PropertyGroup, Object, Action, AnimData, Context
+
+from ...types import PSX_PG_bone_collection_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=True)
+    frame_start: IntProperty(options={'HIDDEN'})
+    frame_end: IntProperty(options={'HIDDEN'})
+    is_pose_marker: BoolProperty(options={'HIDDEN'})
+
+
+class PSA_PG_export_timeline_markers(PropertyGroup):  # TODO: rename this to singular
+    marker_index: IntProperty()
+    name: StringProperty()
+    is_selected: BoolProperty(default=True)
+    frame_start: IntProperty(options={'HIDDEN'})
+    frame_end: IntProperty(options={'HIDDEN'})
+
+
+class PSA_PG_export_nla_strip_list_item(PropertyGroup):
+    name: StringProperty()
+    action: PointerProperty(type=Action)
+    frame_start: FloatProperty()
+    frame_end: FloatProperty()
+    is_selected: BoolProperty(default=True)
+
+
+def nla_track_update_cb(self: 'PSA_PG_export', context: Context) -> None:
+    self.nla_strip_list.clear()
+    if context.object is None or context.object.animation_data is None:
+        return
+    match = re.match(r'^(\d+).+$', self.nla_track)
+    self.nla_track_index = int(match.group(1)) if match else -1
+    if self.nla_track_index >= 0:
+        nla_track = context.object.animation_data.nla_tracks[self.nla_track_index]
+        for nla_strip in nla_track.strips:
+            strip: PSA_PG_export_nla_strip_list_item = self.nla_strip_list.add()
+            strip.action = nla_strip.action
+            strip.name = nla_strip.name
+            strip.frame_start = nla_strip.frame_start
+            strip.frame_end = nla_strip.frame_end
+
+
+def get_animation_data(pg: 'PSA_PG_export', context: Context) -> Optional[AnimData]:
+    animation_data_object = context.object
+    if pg.should_override_animation_data:
+        animation_data_object = pg.animation_data_override
+    return animation_data_object.animation_data if animation_data_object else None
+
+
+def nla_track_search_cb(self, context: Context, edit_text: str):
+    pg = getattr(context.scene, 'psa_export')
+    animation_data = get_animation_data(pg, context)
+    if animation_data is None:
+        return
+    for index, nla_track in enumerate(animation_data.nla_tracks):
+        yield f'{index} - {nla_track.name}'
+
+
+def animation_data_override_update_cb(self: 'PSA_PG_export', context: Context):
+    # Reset NLA track selection
+    self.nla_track = ''
+
+
+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',
+        update=animation_data_override_update_cb,
+    )
+    animation_data_override: PointerProperty(
+        type=Object,
+        update=animation_data_override_update_cb,
+        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 are delineated by scene timeline markers', 'MARKER_HLT', 1),
+            ('NLA_TRACK_STRIPS', 'NLA Track Strips', 'Sequences are delineated by the start & end times of strips on the selected NLA track', 'NLA', 2)
+        )
+    )
+    nla_track: StringProperty(
+        name='NLA Track',
+        options=empty_set,
+        description='',
+        search=nla_track_search_cb,
+        update=nla_track_update_cb
+    )
+    nla_track_index: IntProperty(name='NLA Track Index', default=-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 FPS property found in the PSA Export panel.\n\nIf the Sequence Source is Timeline Markers, the lowest value of all contributing actions 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)
+    nla_strip_list: CollectionProperty(type=PSA_PG_export_nla_strip_list_item)
+    nla_strip_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_COLLECTIONS', 'Bone Collections', 'Only bones belonging to the selected bone collections and their '
+             'ancestors will be exported.'),
+        )
+    )
+    bone_collection_list: CollectionProperty(type=PSX_PG_bone_collection_list_item)
+    bone_collection_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 '
+                    'may not be able to be referenced in-engine'
+    )
+    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 is not None 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_nla_strip_list_item,
+    PSA_PG_export,
+)

io_scene_psk_psa/psa/export/ui.py

@@ -0,0 +1,52 @@
+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 is not None 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')
+
+        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 = list(range(len(actions)))
+        return flt_flags, flt_neworder
+
+
+classes = (
+    PSA_UL_export_sequences,
+)

io_scene_psk_psa/psa/exporter.py

@@ -1,253 +0,0 @@
-import bpy
-from bpy.types import Operator, PropertyGroup, Action, UIList, BoneGroup
-from bpy.props import CollectionProperty, IntProperty, PointerProperty, StringProperty, BoolProperty, EnumProperty
-from bpy_extras.io_utils import ExportHelper
-from typing import Type
-from .builder import PsaBuilder, PsaBuilderOptions
-from .data import *
-from ..types import BoneGroupListItem
-from ..helpers import *
-import re
-
-
-class PsaExporter(object):
-    def __init__(self, psa: Psa):
-        self.psa: Psa = psa
-
-    # This method is shared by both PSA/K file formats, move this?
-    @staticmethod
-    def write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None):
-        section = Section()
-        section.name = name
-        if data_type is not None and data is not None:
-            section.data_size = sizeof(data_type)
-            section.data_count = len(data)
-        fp.write(section)
-        if data is not None:
-            for datum in data:
-                fp.write(datum)
-
-    def export(self, path: str):
-        with open(path, 'wb') as fp:
-            self.write_section(fp, b'ANIMHEAD')
-            self.write_section(fp, b'BONENAMES', Psa.Bone, self.psa.bones)
-            self.write_section(fp, b'ANIMINFO', Psa.Sequence, list(self.psa.sequences.values()))
-            self.write_section(fp, b'ANIMKEYS', Psa.Key, self.psa.keys)
-
-
-class PsaExportActionListItem(PropertyGroup):
-    action: PointerProperty(type=Action)
-    action_name: StringProperty()
-    is_selected: BoolProperty(default=False)
-
-    @property
-    def name(self):
-        return self.action.name
-
-
-class PsaExportPropertyGroup(PropertyGroup):
-    action_list: CollectionProperty(type=PsaExportActionListItem)
-    action_list_index: IntProperty(default=0)
-    bone_filter_mode: EnumProperty(
-        name='Bone Filter',
-        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)
-
-
-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 = 'export.psa'
-    bl_label = 'Export'
-    __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
-
-    def draw(self, context):
-        layout = self.layout
-        property_group = context.scene.psa_export
-
-        # ACTIONS
-        box = layout.box()
-        box.label(text='Actions', icon='ACTION')
-        row = box.row()
-        row.template_list('PSA_UL_ExportActionList', 'asd', property_group, 'action_list', property_group, 'action_list_index', rows=10)
-        row = box.row(align=True)
-        row.label(text='Select')
-        row.operator('psa_export.actions_select_all', text='All')
-        row.operator('psa_export.actions_deselect_all', text='None')
-
-        # BONES
-        box = layout.box()
-        box.label(text='Bones', icon='BONE_DATA')
-        bone_filter_mode_items = property_group.bl_rna.properties['bone_filter_mode'].enum_items_static
-        row = box.row(align=True)
-        for item in bone_filter_mode_items:
-            identifier = item.identifier
-            item_layout = row.row(align=True)
-            item_layout.prop_enum(property_group, 'bone_filter_mode', item.identifier)
-            item_layout.enabled = is_bone_filter_mode_item_available(context, identifier)
-
-        if property_group.bone_filter_mode == 'BONE_GROUPS':
-            box = layout.box()
-            row = box.row()
-            rows = max(3, min(len(property_group.bone_group_list), 10))
-            row.template_list('PSX_UL_BoneGroupList', '', property_group, 'bone_group_list', property_group, 'bone_group_list_index', rows=rows)
-
-    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
-
-    def invoke(self, context, event):
-        property_group = context.scene.psa_export
-
-        if context.view_layer.objects.active is None:
-            self.report({'ERROR_INVALID_CONTEXT'}, 'An armature must be selected')
-            return {'CANCELLED'}
-
-        if context.view_layer.objects.active.type != 'ARMATURE':
-            self.report({'ERROR_INVALID_CONTEXT'}, 'The selected object must be an armature.')
-            return {'CANCELLED'}
-
-        self.armature = context.view_layer.objects.active
-
-        # Populate actions list.
-        property_group.action_list.clear()
-        for action in bpy.data.actions:
-            item = property_group.action_list.add()
-            item.action = action
-            item.action_name = action.name
-            if self.is_action_for_armature(action):
-                item.is_selected = True
-
-        if len(property_group.action_list) == 0:
-            # If there are no actions at all, we have nothing to export, so just cancel the operation.
-            self.report({'ERROR_INVALID_CONTEXT'}, 'There are no actions to export.')
-            return {'CANCELLED'}
-
-        # Populate bone groups list.
-        populate_bone_group_list(self.armature, property_group.bone_group_list)
-
-        context.window_manager.fileselect_add(self)
-
-        return {'RUNNING_MODAL'}
-
-    def execute(self, context):
-        property_group = context.scene.psa_export
-        actions = [x.action for x in property_group.action_list if x.is_selected]
-
-        if len(actions) == 0:
-            self.report({'ERROR_INVALID_CONTEXT'}, 'No actions were selected for export.')
-            return {'CANCELLED'}
-
-        options = PsaBuilderOptions()
-        options.actions = actions
-        options.bone_filter_mode = property_group.bone_filter_mode
-        options.bone_group_indices = [x.index for x in property_group.bone_group_list if x.is_selected]
-        builder = PsaBuilder()
-        try:
-            psa = builder.build(context, options)
-        except RuntimeError as e:
-            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
-            return {'CANCELLED'}
-        exporter = PsaExporter(psa)
-        exporter.export(self.filepath)
-        return {'FINISHED'}
-
-
-class PSA_UL_ExportActionList(UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
-        layout.alignment = 'LEFT'
-        layout.prop(item, 'is_selected', icon_only=True)
-        layout.label(text=item.action_name)
-
-    def filter_items(self, context, data, property):
-        actions = getattr(data, property)
-        flt_flags = []
-        flt_neworder = []
-        if self.filter_name:
-            flt_flags = bpy.types.UI_UL_list.filter_items_by_name(
-                self.filter_name,
-                self.bitflag_filter_item,
-                actions,
-                'action_name',
-                reverse=self.use_filter_invert
-            )
-        return flt_flags, flt_neworder
-
-
-class PsaExportSelectAll(bpy.types.Operator):
-    bl_idname = 'psa_export.actions_select_all'
-    bl_label = 'Select All'
-    bl_description = 'Select all actions'
-
-    @classmethod
-    def poll(cls, context):
-        property_group = context.scene.psa_export
-        action_list = property_group.action_list
-        has_unselected_actions = any(map(lambda action: not action.is_selected, action_list))
-        return len(action_list) > 0 and has_unselected_actions
-
-    def execute(self, context):
-        property_group = context.scene.psa_export
-        for action in property_group.action_list:
-            action.is_selected = True
-        return {'FINISHED'}
-
-
-class PsaExportDeselectAll(bpy.types.Operator):
-    bl_idname = 'psa_export.actions_deselect_all'
-    bl_label = 'Deselect All'
-    bl_description = 'Deselect all actions'
-
-    @classmethod
-    def poll(cls, context):
-        property_group = context.scene.psa_export
-        action_list = property_group.action_list
-        has_selected_actions = any(map(lambda action: action.is_selected, action_list))
-        return len(action_list) > 0 and has_selected_actions
-
-    def execute(self, context):
-        property_group = context.scene.psa_export
-        for action in property_group.action_list:
-            action.is_selected = False
-        return {'FINISHED'}
-
-
-__classes__ = [
-    PsaExportActionListItem,
-    PsaExportPropertyGroup,
-    PsaExportOperator,
-    PSA_UL_ExportActionList,
-    PsaExportSelectAll,
-    PsaExportDeselectAll,
-]

io_scene_psk_psa/psa/import_/operators.py

@@ -0,0 +1,277 @@
+import os
+from pathlib import Path
+
+from bpy.props import StringProperty
+from bpy.types import Operator, Event, Context, FileHandler
+from bpy_extras.io_utils import ImportHelper
+
+from .properties import get_visible_sequences
+from ..config import read_psa_config
+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'}
+
+
+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]
+
+        if len(sequence_names) == 0:
+            self.report({'ERROR_INVALID_CONTEXT'}, 'No sequences selected')
+            return {'CANCELLED'}
+
+        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
+        options.fps_source = pg.fps_source
+        options.fps_custom = pg.fps_custom
+
+        if options.should_use_config_file:
+            # Read the PSA config file if it exists.
+            config_path = Path(self.filepath).with_suffix('.config')
+            if config_path.exists():
+                try:
+                    options.psa_config = read_psa_config(psa_reader, str(config_path))
+                except Exception as e:
+                    self.report({'WARNING'}, f'Failed to read PSA config file: {e}')
+
+        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'
+            self.report({'WARNING'}, message)
+            for warning in result.warnings:
+                self.report({'WARNING'}, warning)
+        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')
+
+        sequences_header, sequences_panel = layout.panel('sequences_panel_id', default_closed=False)
+        sequences_header.label(text='Sequences')
+
+        if sequences_panel:
+            if pg.psa_error:
+                row = sequences_panel.row()
+                row.label(text='Select a PSA file', icon='ERROR')
+            else:
+                # Select buttons.
+                rows = max(3, min(len(pg.sequence_list), 10))
+
+                row = sequences_panel.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 = sequences_panel.column(heading='')
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(pg, 'fps_source')
+            if pg.fps_source == 'CUSTOM':
+                col.prop(pg, 'fps_custom')
+            col.prop(pg, 'should_overwrite')
+            col.prop(pg, 'should_use_action_name_prefix')
+            if pg.should_use_action_name_prefix:
+                col.prop(pg, 'action_name_prefix')
+
+        data_header, data_panel = layout.panel('data_panel_id', default_closed=False)
+        data_header.label(text='Data')
+
+        if data_panel:
+            col = data_panel.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')
+
+            if pg.should_write_keyframes:
+                col = col.column(heading='Keyframes')
+                col.use_property_split = True
+                col.use_property_decorate = False
+                col.prop(pg, 'should_convert_to_samples')
+
+        advanced_header, advanced_panel = layout.panel('advanced_panel_id', default_closed=True)
+        advanced_header.label(text='Advanced')
+
+        if advanced_panel:
+            col = advanced_panel.column()
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(pg, 'bone_mapping_mode')
+
+            col = advanced_panel.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_config_file')
+
+
+class PSA_FH_import(FileHandler):
+    bl_idname = 'PSA_FH_import'
+    bl_label = 'File handler for Unreal PSA import'
+    bl_import_operator = 'psa_import.import'
+    bl_file_extensions = '.psa'
+
+    @classmethod
+    def poll_drop(cls, context: Context):
+        return context.area and context.area.type == 'VIEW_3D'
+
+
+classes = (
+    PSA_OT_import_sequences_select_all,
+    PSA_OT_import_sequences_deselect_all,
+    PSA_OT_import_sequences_from_text,
+    PSA_OT_import,
+    PSA_FH_import,
+)

io_scene_psk_psa/psa/import_/properties.py

@@ -0,0 +1,142 @@
+import re
+from fnmatch import fnmatch
+from typing import List
+
+from bpy.props import StringProperty, BoolProperty, CollectionProperty, IntProperty, PointerProperty, EnumProperty, \
+    FloatProperty
+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=True, 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_use_config_file: BoolProperty(default=True, name='Use Config File',
+                                            description='Use the .config file that is sometimes generated when the PSA '
+                                                        'file is exported from UEViewer. This file contains '
+                                                        'options that can be used to filter out certain bones tracks '
+                                                        'from the imported actions',
+                                            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),
+        ),
+        default='CASE_INSENSITIVE'
+    )
+    fps_source: EnumProperty(name='FPS Source', items=(
+        ('SEQUENCE', 'Sequence', 'The sequence frame rate matches the original frame rate', 'ACTION', 0),
+        ('SCENE', 'Scene', 'The sequence is resampled to the frame rate of the scene', 'SCENE_DATA', 1),
+        ('CUSTOM', 'Custom', 'The sequence is resampled to a custom frame rate', 2),
+    ))
+    fps_custom: FloatProperty(
+        default=30.0,
+        name='Custom FPS',
+        description='The frame rate to which the imported sequences will be resampled to',
+        options=empty_set,
+        min=1.0,
+        soft_min=1.0,
+        soft_max=60.0,
+        step=100,
+    )
+
+
+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,22 +1,32 @@
+import typing
+from typing import List, Optional
+
 import bpy
-import os
 import numpy as np
-from mathutils import Vector, Quaternion, Matrix
+from bpy.types import FCurve, Object, Context
+from mathutils import Vector, Quaternion
+
+from .config import PsaConfig, REMOVE_TRACK_LOCATION, REMOVE_TRACK_ROTATION
 from .data import Psa
-from typing import List, AnyStr, Optional
-from bpy.types import Operator, Action, UIList, PropertyGroup, Panel, Armature, FileSelectParams
-from bpy_extras.io_utils import ExportHelper, ImportHelper
-from bpy.props import StringProperty, BoolProperty, CollectionProperty, PointerProperty, IntProperty
 from .reader import PsaReader
 
 
-class PsaImporter(object):
+class PsaImportOptions(object):
     def __init__(self):
-        pass
+        self.should_use_fake_user = False
+        self.should_stash = False
+        self.sequence_names = []
+        self.should_overwrite = False
+        self.should_write_keyframes = True
+        self.should_write_metadata = True
+        self.action_name_prefix = ''
+        self.should_convert_to_samples = False
+        self.bone_mapping_mode = 'CASE_INSENSITIVE'
+        self.fps_source = 'SEQUENCE'
+        self.fps_custom: float = 30.0
+        self.should_use_config_file = True
+        self.psa_config: PsaConfig = PsaConfig()
 
-    def import_psa(self, psa_reader: PsaReader, sequence_names: List[AnyStr], armature_object):
-        sequences = map(lambda x: psa_reader.sequences[x], sequence_names)
-        armature_data = armature_object.data
 
 class ImportBone(object):
     def __init__(self, psa_bone: Psa.Bone):
@@ -24,388 +34,301 @@ class PsaImporter(object):
         self.parent: Optional[ImportBone] = None
         self.armature_bone = None
         self.pose_bone = None
-                self.orig_loc: Vector = Vector()
+        self.original_location: Vector = Vector()
-                self.orig_quat: Quaternion = Quaternion()
+        self.original_rotation: Quaternion = Quaternion()
-                self.post_quat: Quaternion = Quaternion()
+        self.post_rotation: 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:])
-            q = import_bone.post_quat.copy()
+    q = import_bone.post_rotation.copy()
-            q.rotate(import_bone.orig_quat)
+    q.rotate(import_bone.original_rotation)
-            quat = q
+    rotation = q
-            q = import_bone.post_quat.copy()
+    q = import_bone.post_rotation.copy()
     if import_bone.parent is None:
         q.rotate(key_rotation.conjugated())
     else:
         q.rotate(key_rotation)
-            quat.rotate(q.conjugated())
+    rotation.rotate(q.conjugated())
-            loc = key_location - import_bone.orig_loc
+    location = key_location - import_bone.original_location
-            loc.rotate(import_bone.post_quat.conjugated())
+    location.rotate(import_bone.post_rotation.conjugated())
-            return quat.w, quat.x, quat.y, quat.z, loc.x, loc.y, loc.z
+    return rotation.w, rotation.x, rotation.y, rotation.z, location.x, location.y, location.z
+
+
+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 _get_sample_frame_times(source_frame_count: int, frame_step: float) -> typing.Iterable[float]:
+    # TODO: for correctness, we should also emit the target frame time as well (because the last frame can be a
+    #  fractional frame).
+    time = 0.0
+    while time < source_frame_count - 1:
+        yield time
+        time += frame_step
+    yield source_frame_count - 1
+
+def _resample_sequence_data_matrix(sequence_data_matrix: np.ndarray, frame_step: float = 1.0) -> np.ndarray:
+    """
+    Resamples the sequence data matrix to the target frame count.
+    @param sequence_data_matrix: FxBx7 matrix where F is the number of frames, B is the number of bones, and X is the
+    number of data elements per bone.
+    @param frame_step: The step between frames in the resampled sequence.
+    @return: The resampled sequence data matrix, or sequence_data_matrix if no resampling is necessary.
+    """
+    if frame_step == 1.0:
+        # No resampling is necessary.
+        return sequence_data_matrix
+
+    source_frame_count, bone_count = sequence_data_matrix.shape[:2]
+    sample_frame_times = list(_get_sample_frame_times(source_frame_count, frame_step))
+    target_frame_count = len(sample_frame_times)
+    resampled_sequence_data_matrix = np.zeros((target_frame_count, bone_count, 7), dtype=float)
+
+    for sample_frame_index, sample_frame_time in enumerate(sample_frame_times):
+        frame_index = int(sample_frame_time)
+        if sample_frame_time % 1.0 == 0.0:
+            # Sample time has no fractional part, so just copy the frame.
+            resampled_sequence_data_matrix[sample_frame_index, :, :] = sequence_data_matrix[frame_index, :, :]
+        else:
+            # Sample time has a fractional part, so interpolate between two frames.
+            next_frame_index = frame_index + 1
+            for bone_index in range(bone_count):
+                source_frame_1_data = sequence_data_matrix[frame_index, bone_index, :]
+                source_frame_2_data = sequence_data_matrix[next_frame_index, bone_index, :]
+                factor = sample_frame_time - frame_index
+                q = Quaternion((source_frame_1_data[:4])).slerp(Quaternion((source_frame_2_data[:4])), factor)
+                q.normalize()
+                l = Vector(source_frame_1_data[4:]).lerp(Vector(source_frame_2_data[4:]), factor)
+                resampled_sequence_data_matrix[sample_frame_index, bone_index, :] = q.w, q.x, q.y, q.z, l.x, l.y, l.z
+
+    return resampled_sequence_data_matrix
+
+
+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_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_index
+                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)
-            try:
+
-                psa_to_armature_bone_indices[psa_bone_index] = armature_bone_names.index(psa_bone_name)
+    # Warn about duplicate bone mappings.
-            except ValueError:
+    if len(duplicate_mappings) > 0:
-                pass
+        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:')
+        result.warnings.append(
-            print(list(sorted(missing_bone_names)))
+            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()
+    psa_bone_names_to_import_bones = dict()
 
-        for psa_bone_index, psa_bone in enumerate(psa_reader.bones):
+    for (psa_bone_index, psa_bone), psa_bone_name in zip(enumerate(psa_reader.bones), psa_bone_names):
-            bone_name = psa_bone.name.decode('windows-1252')
+        if psa_bone_index not in psa_to_armature_bone_indices:
-            if psa_bone_index not in psa_to_armature_bone_indices:  # TODO: replace with bone_name in armature_data.bones
             # PSA bone does not map to armature bone, skip it and leave an empty bone in its place.
             import_bones.append(None)
             continue
         import_bone = ImportBone(psa_bone)
-            import_bone.armature_bone = armature_data.bones[bone_name]
+        import_bone.armature_bone = armature_data.bones[psa_bone_name]
-            import_bone.pose_bone = armature_object.pose.bones[bone_name]
+        import_bone.pose_bone = armature_object.pose.bones[psa_bone_name]
-            import_bones_dict[bone_name] = import_bone
+        psa_bone_names_to_import_bones[psa_bone_name] = import_bone
         import_bones.append(import_bone)
 
+    bones_with_missing_parents = []
+
     for import_bone in filter(lambda x: x is not None, import_bones):
         armature_bone = import_bone.armature_bone
-            if armature_bone.parent is not None and armature_bone.parent.name in psa_bone_names:
+        has_parent = armature_bone.parent is not None
-                import_bone.parent = import_bones_dict[armature_bone.parent.name]
+        if has_parent:
+            if armature_bone.parent.name in psa_bone_names:
+                import_bone.parent = psa_bone_names_to_import_bones[armature_bone.parent.name]
+            else:
+                # Add a warning if the parent bone is not in the PSA.
+                bones_with_missing_parents.append(armature_bone)
         # Calculate the original location & rotation of each bone (in world-space maybe?)
-            if armature_bone.get('orig_quat') is not None:
+        if has_parent:
-                # TODO: ideally we don't rely on bone auxiliary data like this, the non-aux data path is incorrect (animations are flipped 180 around Z)
+            import_bone.original_location = armature_bone.matrix_local.translation - armature_bone.parent.matrix_local.translation
-                import_bone.orig_quat = Quaternion(armature_bone['orig_quat'])
+            import_bone.original_location.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
-                import_bone.orig_loc = Vector(armature_bone['orig_loc'])
+            import_bone.original_rotation = armature_bone.matrix_local.to_quaternion()
-                import_bone.post_quat = Quaternion(armature_bone['post_quat'])
+            import_bone.original_rotation.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
+            import_bone.original_rotation.conjugate()
         else:
-                if import_bone.parent is not None:
+            import_bone.original_location = armature_bone.matrix_local.translation.copy()
-                    import_bone.orig_loc = armature_bone.matrix_local.translation - armature_bone.parent.matrix_local.translation
+            import_bone.original_rotation = armature_bone.matrix_local.to_quaternion().conjugated()
-                    import_bone.orig_loc.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
+
-                    import_bone.orig_quat = armature_bone.matrix_local.to_quaternion()
+        import_bone.post_rotation = import_bone.original_rotation.conjugated()
-                    import_bone.orig_quat.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
+
-                    import_bone.orig_quat.conjugate()
+    # Warn about bones with missing parents.
-                else:
+    if len(bones_with_missing_parents) > 0:
-                    import_bone.orig_loc = armature_bone.matrix_local.translation.copy()
+        count = len(bones_with_missing_parents)
-                    import_bone.orig_quat = armature_bone.matrix_local.to_quaternion()
+        message = f'{count} bone(s) have parents that are not present in the PSA:\n' + str([x.name for x in bones_with_missing_parents])
-                import_bone.post_quat = import_bone.orig_quat.conjugated()
+        result.warnings.append(message)
+
+    context.window_manager.progress_begin(0, len(sequences))
 
     # Create and populate the data for new sequences.
-        for sequence in sequences:
+    actions = []
+    for sequence_index, sequence in enumerate(sequences):
         # Add the action.
-            action = bpy.data.actions.new(name=sequence.name.decode())
+        sequence_name = sequence.name.decode('windows-1252')
+        action_name = options.action_name_prefix + sequence_name
+
+        # Get the bone track flags for this sequence, or an empty dictionary if none exist.
+        sequence_bone_track_flags = dict()
+        if sequence_name in options.psa_config.sequence_bone_flags.keys():
+            sequence_bone_track_flags = options.psa_config.sequence_bone_flags[sequence_name]
+
+        if options.should_overwrite and action_name in bpy.data.actions:
+            action = bpy.data.actions[action_name]
+        else:
+            action = bpy.data.actions.new(name=action_name)
+
+        # Calculate the target FPS.
+        match options.fps_source:
+            case 'CUSTOM':
+                target_fps = options.fps_custom
+            case 'SCENE':
+                target_fps = context.scene.render.fps
+            case 'SEQUENCE':
+                target_fps = sequence.fps
+            case _:
+                raise ValueError(f'Unknown FPS source: {options.fps_source}')
+
+        if options.should_write_keyframes:
+            # Remove existing f-curves.
+            action.fcurves.clear()
 
             # Create f-curves for the rotation and location of each bone.
             for psa_bone_index, armature_bone_index in psa_to_armature_bone_indices.items():
+                bone_track_flags = sequence_bone_track_flags.get(psa_bone_index, 0)
                 import_bone = import_bones[psa_bone_index]
                 pose_bone = import_bone.pose_bone
                 rotation_data_path = pose_bone.path_from_id('rotation_quaternion')
                 location_data_path = pose_bone.path_from_id('location')
+                add_rotation_fcurves = (bone_track_flags & REMOVE_TRACK_ROTATION) == 0
+                add_location_fcurves = (bone_track_flags & REMOVE_TRACK_LOCATION) == 0
                 import_bone.fcurves = [
-                    action.fcurves.new(rotation_data_path, index=0),  # Qw
+                    action.fcurves.new(rotation_data_path, index=0, action_group=pose_bone.name) if add_rotation_fcurves else None,  # Qw
-                    action.fcurves.new(rotation_data_path, index=1),  # Qx
+                    action.fcurves.new(rotation_data_path, index=1, action_group=pose_bone.name) if add_rotation_fcurves else None,  # Qx
-                    action.fcurves.new(rotation_data_path, index=2),  # Qy
+                    action.fcurves.new(rotation_data_path, index=2, action_group=pose_bone.name) if add_rotation_fcurves else None,  # Qy
-                    action.fcurves.new(rotation_data_path, index=3),  # Qz
+                    action.fcurves.new(rotation_data_path, index=3, action_group=pose_bone.name) if add_rotation_fcurves else None,  # Qz
-                    action.fcurves.new(location_data_path, index=0),  # Lx
+                    action.fcurves.new(location_data_path, index=0, action_group=pose_bone.name) if add_location_fcurves else None,  # Lx
-                    action.fcurves.new(location_data_path, index=1),  # Ly
+                    action.fcurves.new(location_data_path, index=1, action_group=pose_bone.name) if add_location_fcurves else None,  # Ly
-                    action.fcurves.new(location_data_path, index=2),  # Lz
+                    action.fcurves.new(location_data_path, index=2, action_group=pose_bone.name) if add_location_fcurves else None,  # Lz
                 ]
 
-            # Read the sequence keys from the PSA file.
-            sequence_name = sequence.name.decode('windows-1252')
-
             # Read the sequence data matrix from the PSA.
             sequence_data_matrix = psa_reader.read_sequence_data_matrix(sequence_name)
-            keyframe_write_matrix = np.ones(sequence_data_matrix.shape, dtype=np.int8)
 
-            # The first step is to determine the frames at which each bone will write out a keyframe.
+            # Convert the sequence's data from world-space to local-space.
-            threshold = 0.001
+            for bone_index, import_bone in enumerate(import_bones):
+                if import_bone is None:
+                    continue
+                for frame_index in range(sequence.frame_count):
+                    # 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)
+
+            # Resample the sequence data to the target FPS.
+            # If the target frame count is the same as the source frame count, this will be a no-op.
+            resampled_sequence_data_matrix = _resample_sequence_data_matrix(sequence_data_matrix,
+                                                                            frame_step=sequence.fps / target_fps)
+
+            # Write the keyframes out.
+            # Note that the f-curve data consists of alternating time and value data.
+            target_frame_count = resampled_sequence_data_matrix.shape[0]
+            fcurve_data = np.zeros(2 * target_frame_count, dtype=float)
+            fcurve_data[0::2] = range(0, target_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):
-                    # Get all the keyframe data for the bone's f-curve data from the sequence data matrix.
+                    if fcurve is None:
-                    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 = fcurve_frame_data[frame_index]
-
-            # 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])
+                    fcurve_data[1::2] = resampled_sequence_data_matrix[:, bone_index, fcurve_index]
-                    if bone_has_writeable_keyframes:
+                    fcurve.keyframe_points.add(target_frame_count)
-                        # This bone has writeable keyframes for this frame.
+                    fcurve.keyframe_points.foreach_set('co', fcurve_data)
-                        key_data = sequence_data_matrix[frame_index, bone_index]
+                    for fcurve_keyframe in fcurve.keyframe_points:
-                        # Calculate the local-space key data for the bone.
+                        fcurve_keyframe.interpolation = 'LINEAR'
-                        fcurve_data = calculate_fcurve_data(import_bone, key_data)
-                        for fcurve, should_write, datum in zip(import_bone.fcurves, keyframe_write_matrix[frame_index, bone_index], fcurve_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)
 
-class PsaImportPsaBoneItem(PropertyGroup):
+        # Write meta-data.
-    bone_name: StringProperty()
+        if options.should_write_metadata:
+            action.psa_export.fps = target_fps
 
-    @property
+        action.use_fake_user = options.should_use_fake_user
-    def name(self):
-        return self.bone_name
 
+        actions.append(action)
 
-class PsaImportActionListItem(PropertyGroup):
+        context.window_manager.progress_update(sequence_index)
-    action_name: StringProperty()
-    frame_count: IntProperty()
-    is_selected: BoolProperty(default=False)
 
-    @property
+    # If the user specifies, store the new animations as strips on a non-contributing NLA track.
-    def name(self):
+    if options.should_stash:
-        return self.action_name
+        if armature_object.animation_data is None:
+            armature_object.animation_data_create()
+        for action in actions:
+            nla_track = armature_object.animation_data.nla_tracks.new()
+            nla_track.name = action.name
+            nla_track.mute = True
+            nla_track.strips.new(name=action.name, start=0, action=action)
 
+    context.window_manager.progress_end()
 
-def on_psa_file_path_updated(property, context):
+    return result
-    print('PATH UPDATED')
-    property_group = context.scene.psa_import
-    property_group.action_list.clear()
-    property_group.psa_bones.clear()
-    try:
-        # Read the file and populate the action list.
-        p = os.path.abspath(property_group.psa_file_path)
-        psa_reader = PsaReader(p)
-        for sequence in psa_reader.sequences.values():
-            item = property_group.action_list.add()
-            item.action_name = sequence.name.decode('windows-1252')
-            item.frame_count = sequence.frame_count
-            item.is_selected = True
-
-        for psa_bone in psa_reader.bones:
-            item = property_group.psa_bones.add()
-            item.bone_name = psa_bone.name
-    except IOError as e:
-        print('ERROR READING FILE')
-        print(e)
-        # TODO: set an error somewhere so the user knows the PSA could not be read.
-        pass
-
-
-def on_armature_object_updated(property, context):
-    # TODO: ensure that there are matching bones between the two rigs.
-    property_group = context.scene.psa_import
-    armature_object = property_group.armature_object
-    if armature_object is not None:
-        armature_bone_names = set(map(lambda bone: bone.name, armature_object.data.bones))
-        psa_bone_names = set(map(lambda psa_bone: psa_bone.name, property_group.psa_bones))
-
-
-class PsaImportPropertyGroup(bpy.types.PropertyGroup):
-    psa_file_path: StringProperty(default='', update=on_psa_file_path_updated, name='PSA File Path')
-    psa_bones: CollectionProperty(type=PsaImportPsaBoneItem)
-    # armature_object: PointerProperty(name='Object', type=bpy.types.Object, update=on_armature_object_updated)
-    action_list: CollectionProperty(type=PsaImportActionListItem)
-    action_list_index: IntProperty(name='', default=0)
-    action_filter_name: StringProperty(default='')
-
-
-class PSA_UL_ImportActionList(UIList):
-
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
-        row = layout.row(align=True)
-        split = row.split(align=True, factor=0.75)
-        action_col = split.row(align=True)
-        action_col.alignment = 'LEFT'
-        action_col.prop(item, 'is_selected', icon_only=True)
-        action_col.label(text=item.action_name)
-
-    def draw_filter(self, context, layout):
-        row = layout.row()
-        subrow = row.row(align=True)
-        subrow.prop(self, 'filter_name', text="")
-        subrow.prop(self, 'use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
-        subrow = row.row(align=True)
-        subrow.prop(self, 'use_filter_sort_reverse', text='', icon='SORT_ASC')
-
-    def filter_items(self, context, data, property):
-        actions = getattr(data, property)
-        flt_flags = []
-        flt_neworder = []
-        if self.filter_name:
-            flt_flags = bpy.types.UI_UL_list.filter_items_by_name(
-                self.filter_name,
-                self.bitflag_filter_item,
-                actions,
-                'action_name',
-                reverse=self.use_filter_invert
-            )
-        return flt_flags, flt_neworder
-
-
-class PsaImportSelectAll(bpy.types.Operator):
-    bl_idname = 'psa_import.actions_select_all'
-    bl_label = 'All'
-    bl_description = 'Select all actions'
-
-    @classmethod
-    def poll(cls, context):
-        property_group = context.scene.psa_import
-        action_list = property_group.action_list
-        has_unselected_actions = any(map(lambda action: not action.is_selected, action_list))
-        return len(action_list) > 0 and has_unselected_actions
-
-    def execute(self, context):
-        property_group = context.scene.psa_import
-        for action in property_group.action_list:
-            action.is_selected = True
-        return {'FINISHED'}
-
-
-class PsaImportDeselectAll(bpy.types.Operator):
-    bl_idname = 'psa_import.actions_deselect_all'
-    bl_label = 'None'
-    bl_description = 'Deselect all actions'
-
-    @classmethod
-    def poll(cls, context):
-        property_group = context.scene.psa_import
-        action_list = property_group.action_list
-        has_selected_actions = any(map(lambda action: action.is_selected, action_list))
-        return len(action_list) > 0 and has_selected_actions
-
-    def execute(self, context):
-        property_group = context.scene.psa_import
-        for action in property_group.action_list:
-            action.is_selected = False
-        return {'FINISHED'}
-
-
-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.object.type == 'ARMATURE'
-
-    def draw(self, context):
-        layout = self.layout
-        property_group = context.scene.psa_import
-
-        row = layout.row()
-        row.prop(property_group, 'psa_file_path', text='')
-        row.enabled = False
-        # row.enabled = property_group.psa_file_path is not ''
-        row = layout.row()
-
-        layout.separator()
-
-        row.operator('psa_import.select_file', text='Select PSA File', icon='FILEBROWSER')
-        if len(property_group.action_list) > 0:
-            box = layout.box()
-            box.label(text=f'Actions ({len(property_group.action_list)})', icon='ACTION')
-            row = box.row()
-            rows = max(3, min(len(property_group.action_list), 10))
-            row.template_list('PSA_UL_ImportActionList', '', property_group, 'action_list', property_group, 'action_list_index', rows=rows)
-            row = box.row(align=True)
-            row.label(text='Select')
-            row.operator('psa_import.actions_select_all', text='All')
-            row.operator('psa_import.actions_deselect_all', text='None')
-
-        layout.separator()
-
-        layout.operator('psa_import.import', text=f'Import')
-
-
-class PsaImportSelectFile(Operator):
-    bl_idname = 'psa_import.select_file'
-    bl_label = 'Select'
-    bl_options = {'REGISTER', 'UNDO'}
-    bl_description = 'Select a PSA file from which to import animations'
-    filepath: bpy.props.StringProperty(subtype='FILE_PATH')
-    filter_glob: bpy.props.StringProperty(default="*.psa", options={'HIDDEN'})
-
-    def execute(self, context):
-        context.scene.psa_import.psa_file_path = self.filepath
-        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'
-
-    @classmethod
-    def poll(cls, context):
-        property_group = context.scene.psa_import
-        active_object = context.view_layer.objects.active
-        action_list = property_group.action_list
-        has_selected_actions = any(map(lambda action: action.is_selected, action_list))
-        return has_selected_actions and active_object is not None and active_object.type == 'ARMATURE'
-
-    def execute(self, context):
-        property_group = context.scene.psa_import
-        psa_reader = PsaReader(property_group.psa_file_path)
-        sequence_names = [x.action_name for x in property_group.action_list if x.is_selected]
-        PsaImporter().import_psa(psa_reader, sequence_names, context.view_layer.objects.active)
-        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'
-    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):
-        property_group = context.scene.psa_import
-        property_group.psa_file_path = self.filepath
-        # Load the sequence names from the selected file
-        return {'FINISHED'}
-
-
-__classes__ = [
-    PsaImportPsaBoneItem,
-    PsaImportActionListItem,
-    PsaImportPropertyGroup,
-    PSA_UL_ImportActionList,
-    PsaImportSelectAll,
-    PsaImportDeselectAll,
-    PSA_PT_ImportPanel,
-    PsaImportOperator,
-    PsaImportFileSelectOperator,
-    PsaImportSelectFile,
-]

io_scene_psk_psa/psa/reader.py

@@ -1,14 +1,34 @@
-from .data import *
 import ctypes
+
 import numpy as np
 
+from .data import *
+
+
+def _try_fix_cue4parse_issue_103(sequences) -> bool:
+    # Detect if the file was exported from CUE4Parse prior to the fix for issue #103.
+    # https://github.com/FabianFG/CUE4Parse/issues/103
+    # The issue was that the frame_start_index was not being set correctly, and was always being set to the same value
+    # as the frame_count.
+    # This fix will eventually be deprecated as it is only necessary for files exported prior to the fix.
+    if len(sequences) > 0 and sequences[0].frame_start_index == sequences[0].frame_count:
+        # Manually set the frame_start_index for each sequence. This assumes that the sequences are in order with
+        # no shared frames between sequences (all exporters that I know of do this, so it's a safe assumption).
+        frame_start_index = 0
+        for i, sequence in enumerate(sequences):
+            sequence.frame_start_index = frame_start_index
+            frame_start_index += sequence.frame_count
+        return True
+    return False
+
 
 class PsaReader(object):
     """
-    This class will read the sequences and bone information immediately upon instantiation and hold onto a file handle.
+    This class reads the sequences and bone information immediately upon instantiation and holds onto a file handle.
-    The key data is not read into memory upon instantiation due to it's potentially very large size.
+    The keyframe data is not read into memory upon instantiation due to its potentially very large size.
-    To read the key data for a particular sequence, call `read_sequence_keys`.
+    To read the key data for a particular sequence, call :read_sequence_keys.
     """
+
     def __init__(self, path):
         self.keys_data_offset: int = 0
         self.fp = open(path, 'rb')
@@ -22,16 +42,12 @@ class PsaReader(object):
     def sequences(self):
         return self.psa.sequences
 
-    @staticmethod
+    def read_sequence_data_matrix(self, sequence_name: str) -> np.ndarray:
-    def _read_types(fp, data_class: ctypes.Structure, section: Section, data):
+        """
-        buffer_length = section.data_size * section.data_count
+        Reads and returns the data matrix for the given sequence.
-        buffer = fp.read(buffer_length)
+        @param sequence_name: The name of the sequence.
-        offset = 0
+        @return: An FxBx7 matrix where F is the number of frames, B is the number of bones.
-        for _ in range(section.data_count):
+        """
-            data.append(data_class.from_buffer_copy(buffer, offset))
-            offset += section.data_size
-
-    def read_sequence_data_matrix(self, sequence_name: str):
         sequence = self.psa.sequences[sequence_name]
         keys = self.read_sequence_keys(sequence_name)
         bone_count = len(self.bones)
@@ -44,10 +60,11 @@ class PsaReader(object):
         return matrix
 
     def read_sequence_keys(self, sequence_name: str) -> List[Psa.Key]:
-        """ Reads and returns the key data for a sequence.
+        """
+        Reads and returns the key data for a sequence.
 
-        :param sequence_name: The name of the sequence.
+        @param sequence_name: The name of the sequence.
-        :return: A list of Psa.Keys.
+        @return: A list of Psa.Keys.
         """
         # Set the file reader to the beginning of the keys data
         sequence = self.psa.sequences[sequence_name]
@@ -65,6 +82,15 @@ class PsaReader(object):
             offset += data_size
         return keys
 
+    @staticmethod
+    def _read_types(fp, data_class, section: Section, data):
+        buffer_length = section.data_size * section.data_count
+        buffer = fp.read(buffer_length)
+        offset = 0
+        for _ in range(section.data_count):
+            data.append(data_class.from_buffer_copy(buffer, offset))
+            offset += section.data_size
+
     def _read(self, fp) -> Psa:
         psa = Psa()
         while fp.read(1):
@@ -77,15 +103,15 @@ class PsaReader(object):
             elif section.name == b'ANIMINFO':
                 sequences = []
                 PsaReader._read_types(fp, Psa.Sequence, section, sequences)
+                # Try to fix CUE4Parse bug, if necessary.
+                _try_fix_cue4parse_issue_103(sequences)
                 for sequence in sequences:
                     psa.sequences[sequence.name.decode()] = sequence
             elif section.name == b'ANIMKEYS':
                 # Skip keys on this pass. We will keep this file open and read from it as needed.
                 self.keys_data_offset = fp.tell()
                 fp.seek(section.data_size * section.data_count, 1)
-            elif section.name in [b'SCALEKEYS']:
-                fp.seek(section.data_size * section.data_count, 1)
             else:
-                raise RuntimeError(f'Unrecognized section "{section.name}"')
+                fp.seek(section.data_size * section.data_count, 1)
+                print(f'Unrecognized section in PSA: "{section.name}"')
         return psa
-1

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,103 +1,108 @@
-import bpy
+from typing import Optional
+
 import bmesh
-from collections import OrderedDict
+import bpy
+import numpy as np
+from bpy.types import Armature, Material
+
 from .data import *
+from .properties import triangle_type_and_bit_flags_to_poly_flags
 from ..helpers import *
 
 
 class PskInputObjects(object):
     def __init__(self):
         self.mesh_objects = []
-        self.armature_object = None
+        self.armature_object: Optional[Object] = None
 
 
-class PskBuilderOptions(object):
+class PskBuildOptions(object):
     def __init__(self):
         self.bone_filter_mode = 'ALL'
-        self.bone_group_indices = []
+        self.bone_collection_indices: List[int] = []
+        self.use_raw_mesh_data = True
+        self.materials: List[Material] = []
+        self.should_enforce_bone_name_restrictions = False
 
 
-class PskBuilder(object):
+def get_psk_input_objects(context) -> PskInputObjects:
-    def __init__(self):
-        pass
-
-    @staticmethod
-    def get_input_objects(context) -> PskInputObjects:
     input_objects = PskInputObjects()
-        for obj in context.view_layer.objects.selected:
+    for selected_object in context.view_layer.objects.selected:
-            if obj.type != 'MESH':
+        if selected_object.type != 'MESH':
-                raise RuntimeError(f'Selected object "{obj.name}" is not a mesh')
+            raise RuntimeError(f'Selected object "{selected_object.name}" is not a mesh')
 
     input_objects.mesh_objects = context.view_layer.objects.selected
 
     if len(input_objects.mesh_objects) == 0:
         raise RuntimeError('At least one mesh must be selected')
 
-        for obj in input_objects.mesh_objects:
+    for mesh_object in input_objects.mesh_objects:
-            if len(obj.data.materials) == 0:
+        if len(mesh_object.data.materials) == 0:
-                raise RuntimeError(f'Mesh "{obj.name}" must have at least one material')
+            raise RuntimeError(f'Mesh "{mesh_object.name}" must have at least one material')
 
     # Ensure that there are either no armature modifiers (static mesh)
     # or that there is exactly one armature modifier object shared between
     # all selected meshes
     armature_modifier_objects = set()
 
-        for obj in input_objects.mesh_objects:
+    for mesh_object in input_objects.mesh_objects:
-            modifiers = [x for x in obj.modifiers if x.type == 'ARMATURE']
+        modifiers = [x for x in mesh_object.modifiers if x.type == 'ARMATURE']
         if len(modifiers) == 0:
             continue
         elif len(modifiers) > 1:
-                raise RuntimeError(f'Mesh "{obj.name}" must have only one armature modifier')
+            raise RuntimeError(f'Mesh "{mesh_object.name}" must have only one armature modifier')
         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]
 
     return input_objects
 
-    def build(self, context, options: PskBuilderOptions) -> Psk:
-        input_objects = PskBuilder.get_input_objects(context)
 
-        armature_object = input_objects.armature_object
+class PskBuildResult(object):
+    def __init__(self):
+        self.psk = None
+        self.warnings: List[str] = []
 
+
+def build_psk(context, options: PskBuildOptions) -> PskBuildResult:
+    input_objects = get_psk_input_objects(context)
+    armature_object: bpy.types.Object = input_objects.armature_object
+
+    result = PskBuildResult()
     psk = Psk()
     bones = []
-        materials = OrderedDict()
 
-        if armature_object is None:
+    if armature_object is None or len(armature_object.data.bones) == 0:
-            # If the mesh has no armature object, simply assign it a dummy bone at the root to satisfy the requirement
+        # If the mesh has no armature object or no bones, simply assign it a dummy bone at the root to satisfy the
-            # that a PSK file must have at least one bone.
+        # requirement that a PSK file must have at least one bone.
         psk_bone = Psk.Bone()
-            psk_bone.name = bytes('static', encoding='utf-8')
+        psk_bone.name = bytes('root', encoding='windows-1252')
         psk_bone.flags = 0
         psk_bone.children_count = 0
         psk_bone.parent_index = 0
-            psk_bone.location = Vector3(0, 0, 0)
+        psk_bone.location = Vector3.zero()
-            psk_bone.rotation = Quaternion(0, 0, 0, 1)
+        psk_bone.rotation = Quaternion.identity()
         psk.bones.append(psk_bone)
     else:
-            bones = list(armature_object.data.bones)
+        bone_names = get_export_bone_names(armature_object, options.bone_filter_mode, options.bone_collection_indices)
+        armature_data = typing.cast(Armature, armature_object.data)
+        bones = [armature_data.bones[bone_name] for bone_name in bone_names]
 
-            # If we are filtering by bone groups, get only the bones that are in the specified bone groups and their
+        # Check that all bone names are valid.
-            # ancestors.
+        if options.should_enforce_bone_name_restrictions:
-            if options.bone_filter_mode == 'BONE_GROUPS':
+            check_bone_names(map(lambda x: x.name, bones))
-                bone_indices = get_export_bone_indices_for_bone_groups(armature_object, options.bone_group_indices)
-                bones = [bones[bone_index] for bone_index in bone_indices]
-
-            # Ensure that the exported hierarchy has a single root bone.
-            root_bones = [x for x in bones if x.parent is None]
-            print('root bones')
-            print(root_bones)
-            if len(root_bones) > 1:
-                root_bone_names = [x.name for x in bones]
-                raise RuntimeError('Exported bone hierarchy must have a single root bone.'
-                                   f'The bone hierarchy marked for export has {len(root_bones)} root bones: {root_bone_names}')
 
         for bone in bones:
             psk_bone = Psk.Bone()
-                psk_bone.name = bytes(bone.name, encoding='utf-8')
+            try:
+                psk_bone.name = bytes(bone.name, encoding='windows-1252')
+            except UnicodeEncodeError:
+                raise RuntimeError(
+                    f'Bone name "{bone.name}" contains characters that cannot be encoded in the Windows-1252 codepage')
             psk_bone.flags = 0
             psk_bone.children_count = 0
 
@@ -109,80 +114,129 @@ class PskBuilder(object):
                 psk_bone.parent_index = 0
 
             if bone.parent is not None:
-                    rotation = bone.matrix.to_quaternion()
+                rotation = bone.matrix.to_quaternion().conjugated()
-                    rotation.x = -rotation.x
+                inverse_parent_rotation = bone.parent.matrix.to_quaternion().inverted()
-                    rotation.y = -rotation.y
+                parent_head = inverse_parent_rotation @ bone.parent.head
-                    rotation.z = -rotation.z
+                parent_tail = inverse_parent_rotation @ bone.parent.tail
-                    quat_parent = bone.parent.matrix.to_quaternion().inverted()
-                    parent_head = quat_parent @ bone.parent.head
-                    parent_tail = quat_parent @ bone.parent.tail
                 location = (parent_tail - parent_head) + bone.head
             else:
-                    location = armature_object.matrix_local @ bone.head
+                armature_local_matrix = armature_object.matrix_local
-                    rot_matrix = bone.matrix @ armature_object.matrix_local.to_3x3()
+                location = armature_local_matrix @ bone.head
-                    rotation = rot_matrix.to_quaternion()
+                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
             psk_bone.location.z = location.z
 
+            psk_bone.rotation.w = rotation.w
             psk_bone.rotation.x = rotation.x
             psk_bone.rotation.y = rotation.y
             psk_bone.rotation.z = rotation.z
-                psk_bone.rotation.w = rotation.w
 
             psk.bones.append(psk_bone)
 
-        vertex_offset = 0
+    # MATERIALS
+    for material in options.materials:
+        psk_material = Psk.Material()
+        try:
+            psk_material.name = bytes(material.name, encoding='windows-1252')
+        except UnicodeEncodeError:
+            raise RuntimeError(f'Material name "{material.name}" contains characters that cannot be encoded in the Windows-1252 codepage')
+        psk_material.texture_index = len(psk.materials)
+        psk_material.poly_flags = triangle_type_and_bit_flags_to_poly_flags(material.psk.mesh_triangle_type,
+                                                                            material.psk.mesh_triangle_bit_flags)
+        psk.materials.append(psk_material)
+
+    context.window_manager.progress_begin(0, len(input_objects.mesh_objects))
+
+    material_names = [m.name for m in options.materials]
+
+    for object_index, input_mesh_object in enumerate(input_objects.mesh_objects):
+
+        should_flip_normals = False
+
+        # MATERIALS
+        material_indices = [material_names.index(material_slot.material.name) for material_slot in input_mesh_object.material_slots]
+
+        # 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 force the armature into the rest position.
+            # We will undo this later.
+            old_pose_position = None
+            if armature_object is not None:
+                old_pose_position = armature_object.data.pose_position
+                armature_object.data.pose_position = 'REST'
+
+            depsgraph = context.evaluated_depsgraph_get()
+            bm = bmesh.new()
+            bm.from_object(input_mesh_object, depsgraph)
+            mesh_data = bpy.data.meshes.new('')
+            bm.to_mesh(mesh_data)
+            del bm
+            mesh_object = bpy.data.objects.new('', mesh_data)
+            mesh_object.matrix_world = input_mesh_object.matrix_world
+
+            scale = (input_mesh_object.scale.x, input_mesh_object.scale.y, input_mesh_object.scale.z)
+
+            # Negative scaling in Blender results in inverted normals after the scale is applied. However, if the scale
+            # is not applied, the normals will appear unaffected in the viewport. The evaluated mesh data used in the
+            # export will have the scale applied, but this behavior is not obvious to the user.
+            #
+            # In order to have the exporter be as WYSIWYG as possible, we need to check for negative scaling and invert
+            # the normals if necessary. If two axes have negative scaling and the third has positive scaling, the
+            # normals will be correct. We can detect this by checking if the number of negative scaling axes is odd. If
+            # it is, we need to invert the normals of the mesh by swapping the order of the vertices in each face.
+            should_flip_normals = sum(1 for x in scale if x < 0) % 2 == 1
+
+            # Copy the vertex groups
+            for vertex_group in input_mesh_object.vertex_groups:
+                mesh_object.vertex_groups.new(name=vertex_group.name)
+
+            # Restore the previous pose position on the armature.
+            if old_pose_position is not None:
+                armature_object.data.pose_position = old_pose_position
+
+        vertex_offset = len(psk.points)
 
-        for object in input_objects.mesh_objects:
         # VERTICES
-            for vertex in object.data.vertices:
+        for vertex in mesh_data.vertices:
             point = Vector3()
-                v = object.matrix_world @ vertex.co
+            v = mesh_object.matrix_world @ vertex.co
             point.x = v.x
             point.y = v.y
             point.z = v.z
             psk.points.append(point)
 
-            uv_layer = object.data.uv_layers.active.data
+        uv_layer = mesh_data.uv_layers.active.data
-
-            # MATERIALS
-            material_indices = []
-            for i, m in enumerate(object.data.materials):
-                if m is None:
-                    raise RuntimeError('Material cannot be empty (index ' + str(i) + ')')
-                if m.name in materials:
-                    material_index = list(materials.keys()).index(m.name)
-                else:
-                    material = Psk.Material()
-                    material.name = bytes(m.name, encoding='utf-8')
-                    material.texture_index = len(psk.materials)
-                    psk.materials.append(material)
-                    materials[m.name] = m
-                    material_index = material.texture_index
-                material_indices.append(material_index)
 
         # WEDGES
-            object.data.calc_loop_triangles()
+        mesh_data.calc_loop_triangles()
 
         # Build a list of non-unique wedges.
         wedges = []
-            for loop_index, loop in enumerate(object.data.loops):
+        for loop_index, loop in enumerate(mesh_data.loops):
-                wedge = Psk.Wedge()
+            wedges.append(Psk.Wedge(
-                wedge.point_index = loop.vertex_index + vertex_offset
+                point_index=loop.vertex_index + vertex_offset,
-                wedge.u, wedge.v = uv_layer[loop_index].uv
+                u=uv_layer[loop_index].uv[0],
-                wedge.v = 1.0 - wedge.v
+                v=1.0 - uv_layer[loop_index].uv[1]
-                wedges.append(wedge)
+            ))
 
         # Assign material indices to the wedges.
-            for triangle in object.data.loop_triangles:
+        for triangle in mesh_data.loop_triangles:
             for loop_index in triangle.loops:
                 wedges[loop_index].material_index = material_indices[triangle.material_index]
 
         # Populate the list of wedges with unique wedges & build a look-up table of loop indices to wedge indices
-            wedge_indices = {}
+        wedge_indices = dict()
-            loop_wedge_indices = [-1] * len(object.data.loops)
+        loop_wedge_indices = np.full(len(mesh_data.loops), -1)
         for loop_index, wedge in enumerate(wedges):
             wedge_hash = hash(wedge)
             if wedge_hash in wedge_indices:
@@ -194,8 +248,9 @@ class PskBuilder(object):
                 loop_wedge_indices[loop_index] = wedge_index
 
         # FACES
-            poly_groups, groups = object.data.calc_smooth_groups(use_bitflags=True)
+        poly_groups, groups = mesh_data.calc_smooth_groups(use_bitflags=True)
-            for f in object.data.loop_triangles:
+        psk_face_start_index = len(psk.faces)
+        for f in mesh_data.loop_triangles:
             face = Psk.Face()
             face.material_index = material_indices[f.material_index]
             face.wedge_indices[0] = loop_wedge_indices[f.loops[2]]
@@ -204,12 +259,18 @@ class PskBuilder(object):
             face.smoothing_groups = poly_groups[f.polygon_index]
             psk.faces.append(face)
 
+        if should_flip_normals:
+            # Invert the normals of the faces.
+            for face in psk.faces[psk_face_start_index:]:
+                face.wedge_indices[0], face.wedge_indices[2] = face.wedge_indices[2], face.wedge_indices[0]
+
         # 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]
-                vertex_group_names = [x.name for x in object.vertex_groups]
+            vertex_group_names = [x.name for x in mesh_object.vertex_groups]
             vertex_group_bone_indices = dict()
             for vertex_group_index, vertex_group_name in enumerate(vertex_group_names):
                 try:
@@ -219,8 +280,8 @@ class PskBuilder(object):
                     # 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:
+                    if vertex_group_name in armature_data.bones:
-                            bone = armature_object.data.bones[vertex_group_name]
+                        bone = armature_data.bones[vertex_group_name]
                         while bone is not None:
                             try:
                                 bone_index = bone_names.index(bone.name)
@@ -228,12 +289,12 @@ class PskBuilder(object):
                                 break
                             except ValueError:
                                 bone = bone.parent
-                for vertex_group_index, vertex_group in enumerate(object.vertex_groups):
+            for vertex_group_index, vertex_group in enumerate(mesh_object.vertex_groups):
                 if vertex_group_index not in vertex_group_bone_indices:
+                    # Vertex group has no associated bone, skip it.
                     continue
                 bone_index = vertex_group_bone_indices[vertex_group_index]
-                    # TODO: exclude vertex group if it doesn't match to a bone we are exporting
+                for vertex_index in range(len(mesh_data.vertices)):
-                    for vertex_index in range(len(object.data.vertices)):
                     try:
                         weight = vertex_group.weight(vertex_index)
                     except RuntimeError:
@@ -246,6 +307,15 @@ class PskBuilder(object):
                     w.weight = weight
                     psk.weights.append(w)
 
-            vertex_offset = len(psk.points)
+        if not options.use_raw_mesh_data:
+            bpy.data.objects.remove(mesh_object)
+            bpy.data.meshes.remove(mesh_data)
+            del mesh_data
 
-        return psk
+        context.window_manager.progress_update(object_index)
+
+    context.window_manager.progress_end()
+
+    result.psk = psk
+
+    return result

io_scene_psk_psa/psk/data.py

@@ -1,23 +1,22 @@
 from typing import List
+
 from ..data import *
 
 
 class Psk(object):
-
     class Wedge(object):
-        def __init__(self):
+        def __init__(self, point_index: int, u: float, v: float, material_index: int = 0):
-            self.point_index: int = 0
+            self.point_index: int = point_index
-            self.u: float = 0.0
+            self.u: float = u
-            self.v: float = 0.0
+            self.v: float = v
-            self.material_index: int = 0
+            self.material_index = material_index
 
         def __hash__(self):
             return hash(f'{self.point_index}-{self.u}-{self.v}-{self.material_index}')
 
     class Wedge16(Structure):
         _fields_ = [
-            ('point_index', c_uint16),
+            ('point_index', c_uint32),
-            ('padding1', c_int16),
             ('u', c_float),
             ('v', c_float),
             ('material_index', c_uint8),
@@ -41,6 +40,15 @@ class Psk(object):
             ('smoothing_groups', c_int32)
         ]
 
+    class Face32(Structure):
+        _pack_ = 1
+        _fields_ = [
+            ('wedge_indices', c_uint32 * 3),
+            ('material_index', c_uint8),
+            ('aux_material_index', c_uint8),
+            ('smoothing_groups', c_int32)
+        ]
+
     class Material(Structure):
         _fields_ = [
             ('name', c_char * 64),
@@ -71,6 +79,39 @@ 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
+
+    @property
+    def has_vertex_colors(self):
+        return len(self.vertex_colors) > 0
+
+    @property
+    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] = []
@@ -78,3 +119,9 @@ class Psk(object):
         self.materials: List[Psk.Material] = []
         self.weights: List[Psk.Weight] = []
         self.bones: List[Psk.Bone] = []
+        self.extra_uvs: List[Vector2] = []
+        self.vertex_colors: List[Color] = []
+        self.vertex_normals: List[Vector3] = []
+        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

@@ -0,0 +1,185 @@
+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 ..writer import write_psk
+from ...helpers import populate_bone_collection_list
+
+
+def is_bone_filter_mode_item_available(context, identifier):
+    input_objects = get_psk_input_objects(context)
+    armature_object = input_objects.armature_object
+    if identifier == 'BONE_COLLECTIONS':
+        if armature_object is None or armature_object.data is None or len(armature_object.data.collections) == 0:
+            return False
+    # else if... you can set up other conditions if you add more options
+    return True
+
+
+def populate_material_list(mesh_objects, material_list):
+    material_list.clear()
+
+    materials = []
+    for mesh_object in mesh_objects:
+        for i, material_slot in enumerate(mesh_object.material_slots):
+            material = material_slot.material
+            # TODO: put this in the poll arg?
+            if material is None:
+                raise RuntimeError('Material slot cannot be empty (index ' + str(i) + ')')
+            if material not in materials:
+                materials.append(material)
+
+    for index, material in enumerate(materials):
+        m = material_list.add()
+        m.material = material
+        m.index = index
+
+
+class PSK_OT_material_list_move_up(Operator):
+    bl_idname = 'psk_export.material_list_item_move_up'
+    bl_label = 'Move Up'
+    bl_options = {'INTERNAL'}
+    bl_description = 'Move the selected material up one slot'
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psk_export')
+        return pg.material_list_index > 0
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psk_export')
+        pg.material_list.move(pg.material_list_index, pg.material_list_index - 1)
+        pg.material_list_index -= 1
+        return {'FINISHED'}
+
+
+class PSK_OT_material_list_move_down(Operator):
+    bl_idname = 'psk_export.material_list_item_move_down'
+    bl_label = 'Move Down'
+    bl_options = {'INTERNAL'}
+    bl_description = 'Move the selected material down one slot'
+
+    @classmethod
+    def poll(cls, context):
+        pg = getattr(context.scene, 'psk_export')
+        return pg.material_list_index < len(pg.material_list) - 1
+
+    def execute(self, context):
+        pg = getattr(context.scene, 'psk_export')
+        pg.material_list.move(pg.material_list_index, pg.material_list_index + 1)
+        pg.material_list_index += 1
+        return {'FINISHED'}
+
+
+class PSK_OT_export(Operator, ExportHelper):
+    bl_idname = 'export.psk'
+    bl_label = 'Export'
+    bl_options = {'INTERNAL', 'UNDO'}
+    __doc__ = 'Export mesh and armature to PSK'
+    filename_ext = '.psk'
+    filter_glob: StringProperty(default='*.psk', options={'HIDDEN'})
+
+    filepath: StringProperty(
+        name='File Path',
+        description='File path used for exporting the PSK file',
+        maxlen=1024,
+        default='')
+
+    def invoke(self, context, event):
+        try:
+            input_objects = get_psk_input_objects(context)
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+            return {'CANCELLED'}
+
+        pg = getattr(context.scene, 'psk_export')
+
+        populate_bone_collection_list(input_objects.armature_object, pg.bone_collection_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)
+
+        return {'RUNNING_MODAL'}
+
+    @classmethod
+    def poll(cls, context):
+        try:
+            get_psk_input_objects(context)
+        except RuntimeError as e:
+            cls.poll_message_set(str(e))
+            return False
+        return True
+
+    def draw(self, context):
+        layout = self.layout
+        pg = getattr(context.scene, 'psk_export')
+
+        # MESH
+        box = layout.box()
+        box.label(text='Mesh', icon='MESH_DATA')
+        box.prop(pg, 'use_raw_mesh_data')
+
+        # BONES
+        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 = box.row(align=True)
+        for item in bone_filter_mode_items:
+            identifier = item.identifier
+            item_layout = row.row(align=True)
+            item_layout.prop_enum(pg, 'bone_filter_mode', item.identifier)
+            item_layout.enabled = is_bone_filter_mode_item_available(context, identifier)
+
+        if pg.bone_filter_mode == 'BONE_COLLECTIONS':
+            row = box.row()
+            rows = max(3, min(len(pg.bone_collection_list), 10))
+            row.template_list('PSX_UL_bone_collection_list', '', pg, 'bone_collection_list', pg, 'bone_collection_list_index', rows=rows)
+
+        box.prop(pg, 'should_enforce_bone_name_restrictions')
+
+        # MATERIALS
+        box = layout.box()
+        box.label(text='Materials', icon='MATERIAL')
+        row = box.row()
+        rows = max(3, min(len(pg.bone_collection_list), 10))
+        row.template_list('PSK_UL_materials', '', pg, 'material_list', pg, 'material_list_index', rows=rows)
+        col = row.column(align=True)
+        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
+        options = PskBuildOptions()
+        options.bone_filter_mode = pg.bone_filter_mode
+        options.bone_collection_indices = [x.index for x in pg.bone_collection_list if x.is_selected]
+        options.use_raw_mesh_data = pg.use_raw_mesh_data
+        options.materials = [m.material for m in pg.material_list]
+        options.should_enforce_bone_name_restrictions = pg.should_enforce_bone_name_restrictions
+        
+        try:
+            result = build_psk(context, options)
+            for warning in result.warnings:
+                self.report({'WARNING'}, warning)
+            write_psk(result.psk, self.filepath)
+            if len(result.warnings) > 0:
+                self.report({'WARNING'}, f'PSK export successful with {len(result.warnings)} warnings')
+            else:
+                self.report({'INFO'}, f'PSK export successful')
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+            return {'CANCELLED'}
+    
+        return {'FINISHED'}
+
+
+classes = (
+    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,40 @@
+from bpy.props import EnumProperty, CollectionProperty, IntProperty, BoolProperty, PointerProperty
+from bpy.types import PropertyGroup, Material
+
+from ...types import PSX_PG_bone_collection_list_item
+
+empty_set = set()
+
+class PSK_PG_material_list_item(PropertyGroup):
+    material: PointerProperty(type=Material)
+    index: IntProperty()
+
+
+class PSK_PG_export(PropertyGroup):
+    bone_filter_mode: EnumProperty(
+        name='Bone Filter',
+        options=empty_set,
+        description='',
+        items=(
+            ('ALL', 'All', 'All bones will be exported'),
+            ('BONE_COLLECTIONS', 'Bone Collections',
+             'Only bones belonging to the selected bone collections and their ancestors will be exported')
+        )
+    )
+    bone_collection_list: CollectionProperty(type=PSX_PG_bone_collection_list_item)
+    bone_collection_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.prop(item.material, 'name', text='', emboss=False, icon_value=layout.icon(item.material))
+
+
+classes = (
+    PSK_UL_materials,
+)

io_scene_psk_psa/psk/exporter.py

@@ -1,154 +0,0 @@
-from .data import *
-from ..types import BoneGroupListItem
-from ..helpers import populate_bone_group_list
-from .builder import PskBuilder, PskBuilderOptions
-from typing import Type
-from bpy.types import Operator, PropertyGroup
-from bpy_extras.io_utils import ExportHelper
-from bpy.props import StringProperty, CollectionProperty, IntProperty, BoolProperty, EnumProperty
-
-MAX_WEDGE_COUNT = 65536
-MAX_POINT_COUNT = 4294967296
-MAX_BONE_COUNT = 256
-MAX_MATERIAL_COUNT = 256
-
-
-class PskExporter(object):
-
-    def __init__(self, psk: Psk):
-        self.psk: Psk = psk
-
-    @staticmethod
-    def write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None):
-        section = Section()
-        section.name = name
-        if data_type is not None and data is not None:
-            section.data_size = sizeof(data_type)
-            section.data_count = len(data)
-        fp.write(section)
-        if data is not None:
-            for datum in data:
-                fp.write(datum)
-
-    def export(self, path: str):
-        if len(self.psk.wedges) > MAX_WEDGE_COUNT:
-            raise RuntimeError(f'Number of wedges ({len(self.psk.wedges)}) exceeds limit of {MAX_WEDGE_COUNT}')
-        if len(self.psk.bones) > MAX_BONE_COUNT:
-            raise RuntimeError(f'Number of bones ({len(self.psk.bones)}) exceeds limit of {MAX_BONE_COUNT}')
-        if len(self.psk.points) > MAX_POINT_COUNT:
-            raise RuntimeError(f'Numbers of vertices ({len(self.psk.points)}) exceeds limit of {MAX_POINT_COUNT}')
-        if len(self.psk.materials) > MAX_MATERIAL_COUNT:
-            raise RuntimeError(f'Number of materials ({len(self.psk.materials)}) exceeds limit of {MAX_MATERIAL_COUNT}')
-
-        with open(path, 'wb') as fp:
-            self.write_section(fp, b'ACTRHEAD')
-            self.write_section(fp, b'PNTS0000', Vector3, self.psk.points)
-
-            wedges = []
-            for index, w in enumerate(self.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)
-
-            self.write_section(fp, b'VTXW0000', Psk.Wedge16, wedges)
-            self.write_section(fp, b'FACE0000', Psk.Face, self.psk.faces)
-            self.write_section(fp, b'MATT0000', Psk.Material, self.psk.materials)
-            self.write_section(fp, b'REFSKELT', Psk.Bone, self.psk.bones)
-            self.write_section(fp, b'RAWWEIGHTS', Psk.Weight, self.psk.weights)
-
-
-def is_bone_filter_mode_item_available(context, identifier):
-    input_objects = PskBuilder.get_input_objects(context)
-    armature_object = input_objects.armature_object
-    if identifier == 'BONE_GROUPS':
-        if not armature_object or not armature_object.pose or not armature_object.pose.bone_groups:
-            return False
-    # else if... you can set up other conditions if you add more options
-    return True
-
-
-class PskExportOperator(Operator, ExportHelper):
-    bl_idname = 'export.psk'
-    bl_label = 'Export'
-    __doc__ = 'Export mesh and armature to PSK'
-    filename_ext = '.psk'
-    filter_glob: StringProperty(default='*.psk', options={'HIDDEN'})
-
-    filepath: StringProperty(
-        name='File Path',
-        description='File path used for exporting the PSK file',
-        maxlen=1024,
-        default='')
-
-    def invoke(self, context, event):
-        try:
-            input_objects = PskBuilder.get_input_objects(context)
-        except RuntimeError as e:
-            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
-            return {'CANCELLED'}
-
-        property_group = context.scene.psk_export
-
-        # Populate bone groups list.
-        populate_bone_group_list(input_objects.armature_object, property_group.bone_group_list)
-
-        context.window_manager.fileselect_add(self)
-
-        return {'RUNNING_MODAL'}
-
-    def draw(self, context):
-        layout = self.layout
-        scene = context.scene
-        property_group = scene.psk_export
-
-        # BONES
-        box = layout.box()
-        box.label(text='Bones', icon='BONE_DATA')
-        bone_filter_mode_items = property_group.bl_rna.properties['bone_filter_mode'].enum_items_static
-        row = box.row(align=True)
-        for item in bone_filter_mode_items:
-            identifier = item.identifier
-            item_layout = row.row(align=True)
-            item_layout.prop_enum(property_group, 'bone_filter_mode', item.identifier)
-            item_layout.enabled = is_bone_filter_mode_item_available(context, identifier)
-
-        if property_group.bone_filter_mode == 'BONE_GROUPS':
-            row = box.row()
-            rows = max(3, min(len(property_group.bone_group_list), 10))
-            row.template_list('PSX_UL_BoneGroupList', '', property_group, 'bone_group_list', property_group, 'bone_group_list_index', rows=rows)
-
-    def execute(self, context):
-        property_group = context.scene.psk_export
-        builder = PskBuilder()
-        options = PskBuilderOptions()
-        options.bone_group_indices = [x.index for x in property_group.bone_group_list if x.is_selected]
-        try:
-            psk = builder.build(context, options)
-            exporter = PskExporter(psk)
-            exporter.export(self.filepath)
-        except RuntimeError as e:
-            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
-            return {'CANCELLED'}
-        return {'FINISHED'}
-
-
-class PskExportPropertyGroup(PropertyGroup):
-    bone_filter_mode: EnumProperty(
-        name='Bone Filter',
-        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)
-
-
-__classes__ = [
-    PskExportOperator,
-    PskExportPropertyGroup
-]

io_scene_psk_psa/psk/import_/operators.py

@@ -0,0 +1,176 @@
+import os
+import sys
+
+from bpy.props import StringProperty, BoolProperty, EnumProperty, FloatProperty
+from bpy.types import Operator, FileHandler, Context
+from bpy_extras.io_utils import ImportHelper
+
+from ..importer import PskImportOptions, import_psk
+from ..reader import read_psk
+
+empty_set = set()
+
+
+class PSK_FH_import(FileHandler):
+    bl_idname = 'PSK_FH_import'
+    bl_label = 'File handler for Unreal PSK/PSKX import'
+    bl_import_operator = 'import_scene.psk'
+    bl_file_extensions = '.psk;.pskx'
+
+    @classmethod
+    def poll_drop(cls, context: Context):
+        return context.area and context.area.type == 'VIEW_3D'
+
+
+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='Import Vertex Colors',
+        description='Import vertex colors, 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='Import Vertex Normals',
+        options=empty_set,
+        description='Import vertex normals, if available'
+    )
+    should_import_extra_uvs: BoolProperty(
+        default=True,
+        name='Import 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_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,
+        subtype='DISTANCE',
+        description='Length of the bones'
+    )
+    should_import_shape_keys: BoolProperty(
+        default=True,
+        name='Import Shape Keys',
+        options=empty_set,
+        description='Import shape keys, if available'
+    )
+    scale: FloatProperty(
+        name='Scale',
+        default=1.0,
+        soft_min=0.0,
+    )
+
+    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
+        options.scale = self.scale
+
+        if not options.should_import_mesh and not options.should_import_skeleton:
+            self.report({'ERROR'}, 'Nothing to import')
+            return {'CANCELLED'}
+
+        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 ({options.name})')
+
+        return {'FINISHED'}
+
+    def draw(self, context):
+        layout = self.layout
+
+        row = layout.row()
+
+        col = row.column()
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(self, 'scale')
+
+        mesh_header, mesh_panel = layout.panel('mesh_panel_id', default_closed=False)
+        mesh_header.prop(self, 'should_import_mesh')
+
+        if mesh_panel and self.should_import_mesh:
+            row = mesh_panel.row()
+            col = row.column()
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(self, 'should_import_materials', text='Materials')
+            col.prop(self, 'should_import_vertex_normals', text='Vertex Normals')
+            col.prop(self, 'should_import_extra_uvs', text='Extra UVs')
+            col.prop(self, 'should_import_vertex_colors', text='Vertex Colors')
+            if self.should_import_vertex_colors:
+                col.prop(self, 'vertex_color_space')
+            col.prop(self, 'should_import_shape_keys', text='Shape Keys')
+
+        skeleton_header, skeleton_panel = layout.panel('skeleton_panel_id', default_closed=False)
+        skeleton_header.prop(self, 'should_import_skeleton')
+
+        if skeleton_panel and self.should_import_skeleton:
+            row = skeleton_panel.row()
+            col = row.column()
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(self, 'bone_length')
+
+
+classes = (
+    PSK_OT_import,
+    PSK_FH_import,
+)

io_scene_psk_psa/psk/importer.py

@@ -1,23 +1,64 @@
-import os
+from typing import Optional, List
-import bpy
+
 import bmesh
-from typing import Optional
+import bpy
-from .data import Psk
+import numpy as np
+from bpy.types import VertexGroup
 from mathutils import Quaternion, Vector, Matrix
-from .reader import PskReader
+
-from bpy.props import StringProperty
+from .data import Psk
-from bpy.types import Operator
+from .properties import poly_flags_to_triangle_type_and_bit_flags
-from bpy_extras.io_utils import ImportHelper
+from ..helpers import rgb_to_srgb, is_bdk_addon_loaded
 
 
-class PskImporter(object):
+class PskImportOptions:
     def __init__(self):
-        pass
+        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
+        self.scale = 1.0
 
-    def import_psk(self, psk: Psk, name: str, context):
+
+class ImportBone:
+    '''
+    Intermediate bone type for the purpose of construction.
+    '''
+    def __init__(self, index: int, psk_bone: Psk.Bone):
+        self.index: int = index
+        self.psk_bone: Psk.Bone = psk_bone
+        self.parent: Optional[ImportBone] = None
+        self.local_rotation: Quaternion = Quaternion()
+        self.local_translation: Vector = Vector()
+        self.world_rotation_matrix: Matrix = Matrix()
+        self.world_matrix: Matrix = Matrix()
+        self.vertex_group = None
+        self.original_rotation: Quaternion = Quaternion()
+        self.original_location: Vector = Vector()
+        self.post_rotation: Quaternion = Quaternion()
+
+
+class PskImportResult:
+    def __init__(self):
+        self.warnings: List[str] = []
+
+
+def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
+    result = PskImportResult()
+    armature_object = None
+    mesh_object = None
+
+    if options.should_import_skeleton:
         # ARMATURE
-        armature_data = bpy.data.armatures.new(name)
+        armature_data = bpy.data.armatures.new(options.name)
-        armature_object = bpy.data.objects.new(name, armature_data)
+        armature_object = bpy.data.objects.new(options.name, armature_data)
         armature_object.show_in_front = True
 
         context.scene.collection.objects.link(armature_object)
@@ -32,23 +73,7 @@ class PskImporter(object):
 
         bpy.ops.object.mode_set(mode='EDIT')
 
-        # Intermediate bone type for the purpose of construction.
-        class ImportBone(object):
-            def __init__(self, index: int, psk_bone: Psk.Bone):
-                self.index: int = index
-                self.psk_bone: Psk.Bone = psk_bone
-                self.parent: Optional[ImportBone] = None
-                self.local_rotation: Quaternion = Quaternion()
-                self.local_translation: Vector = Vector()
-                self.world_rotation_matrix: Matrix = Matrix()
-                self.world_matrix: Matrix = Matrix()
-                self.vertex_group = None
-                self.orig_quat: Quaternion = Quaternion()
-                self.orig_loc: Vector = Vector()
-                self.post_quat: Quaternion = Quaternion()
-
         import_bones = []
-        new_bone_size = 8.0
 
         for bone_index, psk_bone in enumerate(psk.bones):
             import_bone = ImportBone(bone_index, psk_bone)
@@ -81,28 +106,40 @@ class PskImporter(object):
             else:
                 import_bone.local_rotation.conjugate()
 
-            edit_bone.tail = Vector((0.0, new_bone_size, 0.0))
+            edit_bone.tail = Vector((0.0, options.bone_length, 0.0))
             edit_bone_matrix = import_bone.local_rotation.conjugated()
             edit_bone_matrix.rotate(import_bone.world_matrix)
             edit_bone_matrix = edit_bone_matrix.to_matrix().to_4x4()
             edit_bone_matrix.translation = import_bone.world_matrix.translation
             edit_bone.matrix = edit_bone_matrix
 
-            # Store bind pose information in the bone's custom properties.
-            # This information is used when importing animations from PSA files.
-            edit_bone['orig_quat'] = import_bone.local_rotation
-            edit_bone['orig_loc'] = import_bone.local_translation
-            edit_bone['post_quat'] = import_bone.local_rotation.conjugated()
-
     # MESH
-        mesh_data = bpy.data.meshes.new(name)
+    if options.should_import_mesh:
-        mesh_object = bpy.data.objects.new(name, mesh_data)
+        mesh_data = bpy.data.meshes.new(options.name)
+        mesh_object = bpy.data.objects.new(options.name, mesh_data)
 
         # MATERIALS
-        for material in psk.materials:
+        if options.should_import_materials:
-            # TODO: re-use of materials should be an option
+            for material_index, psk_material in enumerate(psk.materials):
-            bpy_material = bpy.data.materials.new(material.name.decode('utf-8'))
+                material_name = psk_material.name.decode('utf-8')
-            mesh_data.materials.append(bpy_material)
+                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)
+                    mesh_triangle_type, mesh_triangle_bit_flags = poly_flags_to_triangle_type_and_bit_flags(psk_material.poly_flags)
+                    material.psk.mesh_triangle_type = mesh_triangle_type
+                    material.psk.mesh_triangle_bit_flags = mesh_triangle_bit_flags
+                    material.use_nodes = True
+                mesh_data.materials.append(material)
 
         bm = bmesh.new()
 
@@ -112,78 +149,133 @@ class PskImporter(object):
 
         bm.verts.ensure_lookup_table()
 
-        degenerate_face_indices = set()
+        # FACES
+        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:
-                pass
+                # 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:
+        # TODO: Handle invalid faces better.
-            print(f'WARNING: Discarded {len(degenerate_face_indices)} degenerate face(s).')
+        if len(invalid_face_indices) > 0:
+            result.warnings.append(f'Discarded {len(invalid_face_indices)} invalid face(s).')
 
         bm.to_mesh(mesh_data)
 
         # TEXTURE COORDINATES
-        data_index = 0
+        uv_layer_data_index = 0
-        uv_layer = mesh_data.uv_layers.new()
+        uv_layer = mesh_data.uv_layers.new(name='VTXW0000')
         for face_index, face in enumerate(psk.faces):
-            if face_index in degenerate_face_indices:
+            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:
-                uv_layer.data[data_index].uv = wedge.u, 1.0 - wedge.v
+                uv_layer.data[uv_layer_data_index].uv = wedge.u, 1.0 - wedge.v
-                data_index += 1
+                uv_layer_data_index += 1
+
+        # EXTRA UVS
+        if psk.has_extra_uvs and options.should_import_extra_uvs:
+            extra_uv_channel_count = int(len(psk.extra_uvs) / len(psk.wedges))
+            wedge_index_offset = 0
+            for extra_uv_index in range(extra_uv_channel_count):
+                uv_layer_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 invalid_face_indices:
+                        continue
+                    for wedge_index in reversed(face.wedge_indices):
+                        u, v = psk.extra_uvs[wedge_index_offset + wedge_index]
+                        uv_layer.data[uv_layer_data_index].uv = u, 1.0 - v
+                        uv_layer_data_index += 1
+                wedge_index_offset += len(psk.wedges)
+
+        # VERTEX COLORS
+        if psk.has_vertex_colors and options.should_import_vertex_colors:
+            # Convert vertex colors to sRGB if necessary.
+            psk_vertex_colors = np.zeros((len(psk.vertex_colors), 4))
+            for vertex_color_index in range(len(psk.vertex_colors)):
+                psk_vertex_colors[vertex_color_index,:] = psk.vertex_colors[vertex_color_index].normalized()
+            match options.vertex_color_space:
+                case 'SRGBA':
+                    for i in range(psk_vertex_colors.shape[0]):
+                        psk_vertex_colors[i, :3] = tuple(map(lambda x: rgb_to_srgb(x), psk_vertex_colors[i, :3]))
+                case _:
+                    pass
+
+            # Map the PSK vertex colors to the face corners.
+            face_count = len(psk.faces) - len(invalid_face_indices)
+            face_corner_colors = np.full((face_count * 3, 4), 1.0)
+            face_corner_color_index = 0
+            for face_index, face in enumerate(psk.faces):
+                if face_index in invalid_face_indices:
+                    continue
+                for wedge_index in reversed(face.wedge_indices):
+                    face_corner_colors[face_corner_color_index] = psk_vertex_colors[wedge_index]
+                    face_corner_color_index += 1
+
+            # Create the vertex color attribute.
+            face_corner_color_attribute = mesh_data.attributes.new(name='VERTEXCOLOR', type='FLOAT_COLOR', domain='CORNER')
+            face_corner_color_attribute.data.foreach_set('color', face_corner_colors.flatten())
+
+        # VERTEX NORMALS
+        if psk.has_vertex_normals and options.should_import_vertex_normals:
+            mesh_data.polygons.foreach_set('use_smooth', [True] * len(mesh_data.polygons))
+            normals = []
+            for vertex_normal in psk.vertex_normals:
+                normals.append(tuple(vertex_normal))
+            mesh_data.normals_split_custom_set_from_vertices(normals)
+        else:
+            mesh_data.shade_smooth()
 
         bm.normal_update()
         bm.free()
 
-        # VERTEX WEIGHTS
+        # WEIGHTS
-
         # Get a list of all bones that have weights associated with them.
         vertex_group_bone_indices = set(map(lambda weight: weight.bone_index, psk.weights))
-        for import_bone in map(lambda x: import_bones[x], sorted(list(vertex_group_bone_indices))):
+        vertex_groups: List[Optional[VertexGroup]] = [None] * len(psk.bones)
-            import_bone.vertex_group = mesh_object.vertex_groups.new(name=import_bone.psk_bone.name.decode('windows-1252'))
+        for bone_index, psk_bone in map(lambda x: (x, psk.bones[x]), vertex_group_bone_indices):
+            vertex_groups[bone_index] = mesh_object.vertex_groups.new(name=psk_bone.name.decode('windows-1252'))
 
         for weight in psk.weights:
-            import_bones[weight.bone_index].vertex_group.add((weight.point_index,), weight.weight, 'ADD')
+            vertex_groups[weight.bone_index].add((weight.point_index,), weight.weight, 'ADD')
+
+        # 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.
+        if options.should_import_skeleton:
             armature_modifier = mesh_object.modifiers.new(name='Armature', type='ARMATURE')
             armature_modifier.object = armature_object
             mesh_object.parent = armature_object
 
-        context.scene.collection.objects.link(mesh_object)
+    root_object = armature_object if options.should_import_skeleton else mesh_object
+    root_object.scale = (options.scale, options.scale, options.scale)
 
     try:
         bpy.ops.object.mode_set(mode='OBJECT')
     except:
         pass
 
-
+    return result
-class PskImportOperator(Operator, ImportHelper):
-    bl_idname = 'import.psk'
-    bl_label = 'Export'
-    __doc__ = 'Load a PSK file'
-    filename_ext = '.psk'
-    filter_glob: StringProperty(default='*.psk', options={'HIDDEN'})
-    filepath: StringProperty(
-        name='File Path',
-        description='File path used for exporting the PSK file',
-        maxlen=1024,
-        default='')
-
-    def execute(self, context):
-        reader = PskReader()
-        psk = reader.read(self.filepath)
-        name = os.path.splitext(os.path.basename(self.filepath))[0]
-        PskImporter().import_psk(psk, name, context)
-        return {'FINISHED'}
-
-
-__classes__ = [
-    PskImportOperator
-]

io_scene_psk_psa/psk/properties.py

@@ -0,0 +1,48 @@
+from bpy.props import EnumProperty
+from bpy.types import PropertyGroup
+
+mesh_triangle_types_items = (
+    ('NORMAL', 'Normal', 'Normal one-sided', 0),
+    ('NORMAL_TWO_SIDED', 'Normal Two-Sided', 'Normal but two-sided', 1),
+    ('TRANSLUCENT', 'Translucent', 'Translucent two-sided', 2),
+    ('MASKED', 'Masked', 'Masked two-sided', 3),
+    ('MODULATE', 'Modulate', 'Modulation blended two-sided', 4),
+    ('PLACEHOLDER', 'Placeholder', 'Placeholder triangle for positioning weapon. Invisible', 8),
+)
+
+mesh_triangle_bit_flags_items = (
+    ('UNLIT', 'Unlit', 'Full brightness, no lighting', 16),
+    ('FLAT', 'Flat', 'Flat surface, don\'t do bMeshCurvy thing', 32),
+    ('ENVIRONMENT', 'Environment', 'Environment mapped', 64),
+    ('NO_SMOOTH', 'No Smooth', 'No bilinear filtering on this poly\'s texture', 128),
+)
+
+class PSX_PG_material(PropertyGroup):
+    mesh_triangle_type: EnumProperty(items=mesh_triangle_types_items, name='Triangle Type')
+    mesh_triangle_bit_flags: EnumProperty(items=mesh_triangle_bit_flags_items, name='Triangle Bit Flags',
+                                          options={'ENUM_FLAG'})
+
+mesh_triangle_types_items_dict = {item[0]: item[3] for item in mesh_triangle_types_items}
+mesh_triangle_bit_flags_items_dict = {item[0]: item[3] for item in mesh_triangle_bit_flags_items}
+
+
+def triangle_type_and_bit_flags_to_poly_flags(mesh_triangle_type: str, mesh_triangle_bit_flags: set[str]) -> int:
+    poly_flags = 0
+    poly_flags |= mesh_triangle_types_items_dict.get(mesh_triangle_type, 0)
+    for flag in mesh_triangle_bit_flags:
+        poly_flags |= mesh_triangle_bit_flags_items_dict.get(flag, 0)
+    return poly_flags
+
+
+def poly_flags_to_triangle_type_and_bit_flags(poly_flags: int) -> (str, set[str]):
+    try:
+        triangle_type = next(item[0] for item in mesh_triangle_types_items if item[3] == (poly_flags & 15))
+    except StopIteration:
+        triangle_type = 'NORMAL'
+    triangle_bit_flags = {item[0] for item in mesh_triangle_bit_flags_items if item[3] & poly_flags}
+    return triangle_type, triangle_bit_flags
+
+
+classes = (
+    PSX_PG_material,
+)

io_scene_psk_psa/psk/reader.py

@@ -1,14 +1,13 @@
-from .data import *
 import ctypes
+import os
+import re
+import warnings
+from pathlib import Path
+
+from .data import *
 
 
-class PskReader(object):
+def _read_types(fp, data_class, section: Section, data):
-
-    def __init__(self):
-        pass
-
-    @staticmethod
-    def read_types(fp, data_class: ctypes.Structure, section: Section, data):
     buffer_length = section.data_size * section.data_count
     buffer = fp.read(buffer_length)
     offset = 0
@@ -16,8 +15,23 @@ class PskReader(object):
         data.append(data_class.from_buffer_copy(buffer, offset))
         offset += section.data_size
 
-    def read(self, 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)
@@ -25,22 +39,55 @@ class PskReader(object):
             if section.name == b'ACTRHEAD':
                 pass
             elif section.name == b'PNTS0000':
-                    PskReader.read_types(fp, Vector3, section, psk.points)
+                _read_types(fp, Vector3, section, psk.points)
             elif section.name == b'VTXW0000':
                 if section.data_size == ctypes.sizeof(Psk.Wedge16):
-                        PskReader.read_types(fp, Psk.Wedge16, section, psk.wedges)
+                    _read_types(fp, Psk.Wedge16, section, psk.wedges)
                 elif section.data_size == ctypes.sizeof(Psk.Wedge32):
-                        PskReader.read_types(fp, Psk.Wedge32, section, psk.wedges)
+                    _read_types(fp, Psk.Wedge32, section, psk.wedges)
                 else:
                     raise RuntimeError('Unrecognized wedge format')
             elif section.name == b'FACE0000':
-                    PskReader.read_types(fp, Psk.Face, section, psk.faces)
+                _read_types(fp, Psk.Face, section, psk.faces)
             elif section.name == b'MATT0000':
-                    PskReader.read_types(fp, Psk.Material, section, psk.materials)
+                _read_types(fp, Psk.Material, section, psk.materials)
             elif section.name == b'REFSKELT':
-                    PskReader.read_types(fp, Psk.Bone, section, psk.bones)
+                _read_types(fp, Psk.Bone, section, psk.bones)
             elif section.name == b'RAWWEIGHTS':
-                    PskReader.read_types(fp, Psk.Weight, section, psk.weights)
+                _read_types(fp, Psk.Weight, section, psk.weights)
+            elif section.name == b'FACE3200':
+                _read_types(fp, Psk.Face32, section, psk.faces)
+            elif section.name == b'VERTEXCOLOR':
+                _read_types(fp, Color, section, psk.vertex_colors)
+            elif section.name.startswith(b'EXTRAUVS'):
+                _read_types(fp, Vector2, section, psk.extra_uvs)
+            elif section.name == b'VTXNORMS':
+                _read_types(fp, Vector3, section, psk.vertex_normals)
+            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}"')
+                # 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/ui.py

@@ -0,0 +1,28 @@
+from bpy.types import Panel
+
+
+class PSK_PT_material(Panel):
+    bl_label = 'PSK Material'
+    bl_idname = 'PSK_PT_material'
+    bl_space_type = 'PROPERTIES'
+    bl_region_type = 'WINDOW'
+    bl_context = 'material'
+    bl_options = {'DEFAULT_CLOSED'}
+
+    @classmethod
+    def poll(cls, context):
+        return context.material is not None
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False
+        material = context.material
+        layout.prop(material.psk, 'mesh_triangle_type')
+        col = layout.column()
+        col.prop(material.psk, 'mesh_triangle_bit_flags', expand=True, text='Flags')
+
+
+classes = (
+    PSK_PT_material,
+)

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 = 2147483647
+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,25 +1,55 @@
-from bpy.types import PropertyGroup, UIList
+from bpy.props import StringProperty, IntProperty, BoolProperty, FloatProperty
-from bpy.props import StringProperty, IntProperty, BoolProperty
+from bpy.types import PropertyGroup, UIList, UILayout, Context, AnyType, Panel
 
 
-class PSX_UL_BoneGroupList(UIList):
+class PSX_UL_bone_collection_list(UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
+
-        layout.alignment = 'LEFT'
+    def draw_item(self, context: Context, layout: UILayout, data: AnyType, item: AnyType, icon: int,
-        layout.prop(item, 'is_selected', icon_only=True)
+                  active_data: AnyType, active_property: str, index: int = 0, flt_flag: int = 0):
-        layout.label(text=item.name, icon='GROUP_BONE' if item.index >= 0 else 'NONE')
+        row = layout.row()
+        row.prop(item, 'is_selected', text=getattr(item, 'name'))
+        row.label(text=str(getattr(item, 'count')), icon='BONE_DATA')
 
 
-class BoneGroupListItem(PropertyGroup):
+class PSX_PG_bone_collection_list_item(PropertyGroup):
     name: StringProperty()
     index: IntProperty()
+    count: IntProperty()
     is_selected: BoolProperty(default=False)
 
-    @property
+
-    def name(self):
+class PSX_PG_action_export(PropertyGroup):
-        return self.name
+    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')
+    fps: FloatProperty(name='FPS', default=30.0, min=0.0, description='The frame rate of the exported sequence')
 
 
-__classes__ = [
+class PSX_PT_action(Panel):
-    BoneGroupListItem,
+    bl_idname = 'PSX_PT_action'
-    PSX_UL_BoneGroupList
+    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
+        flow = layout.grid_flow(columns=1)
+        flow.use_property_split = True
+        flow.use_property_decorate = False
+        flow.prop(action.psa_export, 'compression_ratio')
+        flow.prop(action.psa_export, 'key_quota')
+        flow.prop(action.psa_export, 'fps')
+
+
+classes = (
+    PSX_PG_action_export,
+    PSX_PG_bone_collection_list_item,
+    PSX_UL_bone_collection_list,
+    PSX_PT_action,
+)