Fix issue #37

https://github.com/DarklightGames/io_scene_psk_psa/issues/37

README.md

@@ -1,46 +1,50 @@
-This Blender 2.80+ add-on allows you to import and export meshes and animations to and from the [PSK and PSA file formats](https://wiki.beyondunreal.com/PSK_%26_PSA_file_formats) used in many version of the Unreal Engine.
+[![Blender](https://img.shields.io/badge/Blender->=3.4-blue?logo=blender&logoColor=white)](https://www.blender.org/download/ "Download Blender")
+[![GitHub release](https://img.shields.io/github/release/DarklightGames/io_scene_psk_psa?include_prereleases=&sort=semver&color=blue)](https://github.com/DarklightGames/io_scene_psk_psa/releases/)
+
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/L4L3853VR)
+
+This Blender add-on allows you to import and export meshes and animations to and from the [PSK and PSA file formats](https://wiki.beyondunreal.com/PSK_%26_PSA_file_formats) used in many version of the Unreal Engine.
+
+> **NOTE**: This addon requires Blender 3.4+. If this is not available to you, install version [4.3.0](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/4.3.0), as it has a minimum Blender version of 2.9, but is no longer receiving new features.
 
 # Features
-* Full PSK/PSA import and export capabilities
+* Full PSK/PSA import and export capabilities.
-* Non-standard PSKX file format with vertex normals, extra UV channels and vertex colors is supported for import only
+* 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
+* Fine-grained PSA sequence importing for efficient workflow when working with large PSA files.
-* Automatic keyframe reduction on PSA import
+* PSA sequence metadata (e.g., frame rate, sequence name) is preserved on import, allowing this data to be reused on export.
-* PSA sequence metadata (e.g., frame rate, sequence name) is preserved on import, allowing this data to be reused on export
+* Specific [bone groups](https://docs.blender.org/manual/en/latest/animation/armatures/properties/bone_groups.html) can be excluded from PSK/PSA export (useful for excluding non-contributing bones such as IK controllers).
-* Specific [bone groups](https://docs.blender.org/manual/en/latest/animation/armatures/properties/bone_groups.html) can be excluded from PSK/PSA export (useful for excluding non-contributing bones such as IK controllers)
+* PSA sequences can be exported directly from actions or delineated using a scene's [timeline markers](https://docs.blender.org/manual/en/latest/animation/markers.html), allowing direct use of the [NLA](https://docs.blender.org/manual/en/latest/editors/nla/index.html) when creating sequences.
-* PSA sequences can be exported directly from actions or delineated using a scene's [timeline markers](https://docs.blender.org/manual/en/latest/animation/markers.html), allowing direct use of the [NLA](https://docs.blender.org/manual/en/latest/editors/nla/index.html) when creating sequences 
+* Manual re-ordering of material slots when exporting multiple mesh objects.
 
 # Installation
 1. Download the zip file for the latest version from the [releases](https://github.com/DarklightGames/io_export_psk_psa/releases) page.
-2. Open Blender 2.80 or later.
+2. Open Blender 3.4.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/PSKX
-1. Navigate to File > Import > Unreal PSK (.psk/.pskx)
+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.
-7. Click "Import".
 
 # FAQ
 ## Why are the mesh normals not accurate when importing a PSK extracted from [UE Viewer](https://www.gildor.org/en/projects/umodel)?

io_scene_psk_psa/__init__.py

@@ -1,9 +1,8 @@
 bl_info = {
     "name": "PSK/PSA Importer/Exporter",
     "author": "Colin Basnett, Yurii Ti",
-    "version": (4, 0, 0),
+    "version": (5, 0, 0),
-    "blender": (2, 80, 0),
+    "blender": (3, 4, 0),
-    # "location": "File > Export > PSK Export (.psk)",
     "description": "PSK/PSA Import/Export (.psk/.psa)",
     "warning": "",
     "doc_url": "https://github.com/DarklightGames/io_scene_psk_psa",
@@ -46,11 +45,11 @@ else:
 import bpy
 from bpy.props import PointerProperty
 
-classes = (psx_types.classes +
+classes = psx_types.classes +\
-           psk_importer.classes +
+           psk_importer.classes +\
-           psk_exporter.classes +
+           psk_exporter.classes +\
-           psa_exporter.classes +
+           psa_exporter.classes +\
-           psa_importer.classes)
+           psa_importer.classes
 
 
 def psk_export_menu_func(self, context):
@@ -65,26 +64,32 @@ def psa_export_menu_func(self, context):
     self.layout.operator(psa_exporter.PsaExportOperator.bl_idname, text='Unreal PSA (.psa)')
 
 
+def psa_import_menu_func(self, context):
+    self.layout.operator(psa_importer.PsaImportOperator.bl_idname, text='Unreal PSA (.psa)')
+
+
 def register():
     for cls in classes:
         bpy.utils.register_class(cls)
     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.TOPBAR_MT_file_import.append(psa_import_menu_func)
     bpy.types.Scene.psa_import = PointerProperty(type=psa_importer.PsaImportPropertyGroup)
-    bpy.types.Scene.psk_import = PointerProperty(type=psk_importer.PskImportPropertyGroup)
     bpy.types.Scene.psa_export = PointerProperty(type=psa_exporter.PsaExportPropertyGroup)
     bpy.types.Scene.psk_export = PointerProperty(type=psk_exporter.PskExportPropertyGroup)
+    bpy.types.Action.psa_export = PointerProperty(type=psx_types.PSX_PG_ActionExportPropertyGroup)
 
 
 def unregister():
     del bpy.types.Scene.psa_import
-    del bpy.types.Scene.psk_import
     del bpy.types.Scene.psa_export
     del bpy.types.Scene.psk_export
+    del bpy.types.Action.psa_export
     bpy.types.TOPBAR_MT_file_export.remove(psk_export_menu_func)
     bpy.types.TOPBAR_MT_file_import.remove(psk_import_menu_func)
     bpy.types.TOPBAR_MT_file_export.remove(psa_export_menu_func)
+    bpy.types.TOPBAR_MT_file_import.remove(psa_import_menu_func)
     for cls in reversed(classes):
         bpy.utils.unregister_class(cls)
 

io_scene_psk_psa/bdk.py

@@ -0,0 +1,39 @@
+import re
+from typing import Optional
+
+
+class UReference:
+    type_name: str
+    package_name: str
+    group_name: Optional[str]
+    object_name: str
+
+    def __init__(self, type_name: str, package_name: str, object_name: str, group_name: Optional[str] = None):
+        self.type_name = type_name
+        self.package_name = package_name
+        self.object_name = object_name
+        self.group_name = group_name
+
+    @staticmethod
+    def from_string(string: str) -> Optional['UReference']:
+        if string == 'None':
+            return None
+        pattern = r'(\w+)\'([\w\.\d\-\_]+)\''
+        match = re.match(pattern, string)
+        if match is None:
+            print(f'BAD REFERENCE STRING: {string}')
+            return None
+        type_name = match.group(1)
+        object_name = match.group(2)
+        pattern = r'([\w\d\-\_]+)'
+        values = re.findall(pattern, object_name)
+        package_name = values[0]
+        object_name = values[-1]
+        return UReference(type_name, package_name, object_name, group_name=None)
+
+    def __repr__(self):
+        s = f'{self.type_name}\'{self.package_name}'
+        if self.group_name:
+            s += f'.{self.group_name}'
+        s += f'.{self.object_name}'
+        return s

io_scene_psk_psa/helpers.py

@@ -1,10 +1,12 @@
 import datetime
 import re
+import typing
 from collections import Counter
 from typing import List, Iterable
 
+import addon_utils
 import bpy.types
-from bpy.types import NlaStrip, Object
+from bpy.types import NlaStrip, Object, AnimData
 
 
 class Timer:
@@ -25,14 +27,14 @@ class Timer:
             return datetime.datetime.now() - self.start
 
 
-def rgb_to_srgb(c):
+def rgb_to_srgb(c: float):
     if c > 0.0031308:
         return 1.055 * (pow(c, (1.0 / 2.4))) - 0.055
     else:
         return 12.92 * c
 
 
-def get_nla_strips_in_timeframe(animation_data, frame_min, frame_max) -> List[NlaStrip]:
+def get_nla_strips_in_timeframe(animation_data: AnimData, frame_min: float, frame_max: float) -> List[NlaStrip]:
     if animation_data is None:
         return []
     strips = []
@@ -47,7 +49,7 @@ def get_nla_strips_in_timeframe(animation_data, frame_min, frame_max) -> List[Nl
     return strips
 
 
-def populate_bone_group_list(armature_object: Object, bone_group_list: bpy.types.Collection) -> None:
+def populate_bone_group_list(armature_object: Object, bone_group_list: bpy.props.CollectionProperty) -> None:
     """
     Updates the bone group collection.
 
@@ -86,22 +88,15 @@ def populate_bone_group_list(armature_object: Object, bone_group_list: bpy.types
             item.is_selected = bone_group.name in selected_assigned_group_names if has_selected_groups else True
 
 
-def get_psa_sequence_name(action, should_use_original_sequence_name):
-    if should_use_original_sequence_name and 'psa_sequence_name' in action:
-        return action['psa_sequence_name']
-    else:
-        return action.name
-
-
 def check_bone_names(bone_names: Iterable[str]):
-    pattern = re.compile(r'^[a-zA-Z0-9_ ]+$')
+    pattern = re.compile(r'^[a-zA-Z\d_\- ]+$')
     invalid_bone_names = [x for x in bone_names if pattern.match(x) is None]
     if len(invalid_bone_names) > 0:
         raise RuntimeError(f'The following bone names are invalid: {invalid_bone_names}.\n'
-                           f'Bone names must only contain letters, numbers, spaces, and underscores.')
+                           f'Bone names must only contain letters, numbers, spaces, hyphens and underscores.')
 
 
-def get_export_bone_names(armature_object, bone_filter_mode, bone_group_indices: List[int]) -> List[str]:
+def get_export_bone_names(armature_object: Object, bone_filter_mode: str, bone_group_indices: List[int]) -> List[str]:
     """
     Returns a sorted list of bone indices that should be exported for the given bone filter mode and bone groups.
 
@@ -115,7 +110,8 @@ def get_export_bone_names(armature_object, bone_filter_mode, bone_group_indices:
     if armature_object is None or armature_object.type != 'ARMATURE':
         raise ValueError('An armature object must be supplied')
 
-    bones = armature_object.data.bones
+    armature_data = typing.cast(bpy.types.Armature, armature_object.data)
+    bones = armature_data.bones
     pose_bones = armature_object.pose.bones
     bone_names = [x.name for x in bones]
 
@@ -174,3 +170,7 @@ def get_export_bone_names(armature_object, bone_filter_mode, bone_group_indices:
                            f'Additional debugging information has been written to the console.')
 
     return bone_names
+
+
+def is_bdk_addon_loaded():
+    return addon_utils.check('bdk_addon')[1]

io_scene_psk_psa/psa/builder.py

@@ -1,129 +1,79 @@
-from typing import Dict
+from typing import Optional
 
-from bpy.types import Action
+from bpy.types import Armature, Bone, Action, PoseBone
 
 from .data import *
 from ..helpers import *
 
 
-class PsaBuildOptions(object):
+class PsaExportSequence:
+    class NlaState:
+        def __init__(self):
+            self.action: Optional[Action] = None
+            self.frame_start: int = 0
+            self.frame_end: int = 0
+
     def __init__(self):
-        self.should_override_animation_data = False
+        self.name: str = ''
-        self.animation_data_override = None
+        self.nla_state: PsaExportSequence.NlaState = PsaExportSequence.NlaState()
-        self.fps_source = 'SCENE'
+        self.compression_ratio: float = 1.0
-        self.fps_custom = 30.0
+        self.key_quota: int = 0
-        self.sequence_source = 'ACTIONS'
+        self.fps: float = 30.0
-        self.actions = []
-        self.marker_names = []
-        self.bone_filter_mode = 'ALL'
-        self.bone_group_indices = []
-        self.should_use_original_sequence_names = False
-        self.should_trim_timeline_marker_sequences = True
-        self.sequence_name_prefix = ''
-        self.sequence_name_suffix = ''
-        self.root_motion = False
 
 
-def get_sequence_fps(context, options: PsaBuildOptions, actions: Iterable[Action]) -> float:
+class PsaBuildOptions:
-    if options.fps_source == 'SCENE':
+    def __init__(self):
-        return context.scene.render.fps
+        self.animation_data: Optional[AnimData] = None
-    if options.fps_source == 'CUSTOM':
+        self.sequences: List[PsaExportSequence] = []
-        return options.fps_custom
+        self.bone_filter_mode: str = 'ALL'
-    elif options.fps_source == 'ACTION_METADATA':
+        self.bone_group_indices: List[int] = []
-        # Get the minimum value of action metadata FPS values.
+        self.should_ignore_bone_name_restrictions: bool = False
-        fps_list = []
+        self.sequence_name_prefix: str = ''
-        for action in filter(lambda x: 'psa_sequence_fps' in x, actions):
+        self.sequence_name_suffix: str = ''
-            fps = action['psa_sequence_fps']
+        self.root_motion: bool = False
-            if type(fps) == int or type(fps) == float:
+
-                fps_list.append(fps)
+
-        if len(fps_list) > 0:
+def get_pose_bone_location_and_rotation(pose_bone: PoseBone, armature_object: Object, options: PsaBuildOptions):
-            return min(fps_list)
+    if pose_bone.parent is not None:
-        else:
+        pose_bone_matrix = pose_bone.matrix
-            # No valid action metadata to use, fallback to scene FPS
+        pose_bone_parent_matrix = pose_bone.parent.matrix
-            return context.scene.render.fps
+        pose_bone_matrix = pose_bone_parent_matrix.inverted() @ pose_bone_matrix
     else:
-        raise RuntimeError(f'Invalid FPS source "{options.fps_source}"')
+        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
-def get_timeline_marker_sequence_frame_ranges(animation_data, context, options: PsaBuildOptions) -> Dict:
-    # Timeline markers need to be sorted so that we can determine the sequence start and end positions.
-    sequence_frame_ranges = dict()
-    sorted_timeline_markers = list(sorted(context.scene.timeline_markers, key=lambda x: x.frame))
-    sorted_timeline_marker_names = list(map(lambda x: x.name, sorted_timeline_markers))
-
-    for marker_name in options.marker_names:
-        marker = context.scene.timeline_markers[marker_name]
-        frame_min = marker.frame
-        # Determine the final frame of the sequence based on the next marker.
-        # If no subsequent marker exists, use the maximum frame_end from all NLA strips.
-        marker_index = sorted_timeline_marker_names.index(marker_name)
-        next_marker_index = marker_index + 1
-        frame_max = 0
-        if next_marker_index < len(sorted_timeline_markers):
-            # There is a next marker. Use that next marker's frame position as the last frame of this sequence.
-            frame_max = sorted_timeline_markers[next_marker_index].frame
-            if options.should_trim_timeline_marker_sequences:
-                nla_strips = get_nla_strips_in_timeframe(animation_data, marker.frame, frame_max)
-                if len(nla_strips) > 0:
-                    frame_max = min(frame_max, max(map(lambda nla_strip: nla_strip.frame_end, nla_strips)))
-                    frame_min = max(frame_min, min(map(lambda nla_strip: nla_strip.frame_start, nla_strips)))
-                else:
-                    # No strips in between this marker and the next, just export this as a one-frame animation.
-                    frame_max = frame_min
         else:
-            # There is no next marker.
+            # Use the bind pose matrix for the root bone.
-            # Find the final frame of all the NLA strips and use that as the last frame of this sequence.
+            pose_bone_matrix = pose_bone.matrix
-            for nla_track in animation_data.nla_tracks:
-                if nla_track.mute:
-                    continue
-                for strip in nla_track.strips:
-                    frame_max = max(frame_max, strip.frame_end)
 
-        if frame_min > frame_max:
+    location = pose_bone_matrix.to_translation()
-            continue
+    rotation = pose_bone_matrix.to_quaternion().normalized()
 
-        sequence_frame_ranges[marker_name] = int(frame_min), int(frame_max)
+    if pose_bone.parent is not None:
+        rotation.conjugate()
 
-    return sequence_frame_ranges
+    return location, rotation
 
 
-def build_psa(context, options: PsaBuildOptions) -> Psa:
+def build_psa(context: bpy.types.Context, options: PsaBuildOptions) -> Psa:
     active_object = context.view_layer.objects.active
 
-    if active_object.type != 'ARMATURE':
-        raise RuntimeError('Selected object must be an Armature')
-
-    if options.should_override_animation_data:
-        animation_data_object = options.animation_data_override
-    else:
-        animation_data_object = active_object
-
-    animation_data = animation_data_object.animation_data
-
-    if animation_data is None:
-        raise RuntimeError(f'No animation data for object \'{animation_data_object.name}\'')
-
-    # Ensure that we actually have items that we are going to be exporting.
-    if options.sequence_source == 'ACTIONS' and len(options.actions) == 0:
-        raise RuntimeError('No actions were selected for export')
-    elif options.sequence_source == 'TIMELINE_MARKERS' and len(options.marker_names) == 0:
-        raise RuntimeError('No timeline markers were selected for export')
-
     psa = Psa()
 
-    armature = active_object
+    armature_object = active_object
-    bones = list(armature.data.bones)
+    armature_data = typing.cast(Armature, armature_object.data)
+    bones: List[Bone] = list(iter(armature_data.bones))
 
     # The order of the armature bones and the pose bones is not guaranteed to be the same.
     # As a result, we need to reconstruct the list of pose bones in the same order as the
     # armature bones.
     bone_names = [x.name for x in bones]
-    pose_bones = [(bone_names.index(bone.name), bone) for bone in armature.pose.bones]
+    pose_bones = [(bone_names.index(bone.name), bone) for bone in armature_object.pose.bones]
     pose_bones.sort(key=lambda x: x[0])
     pose_bones = [x[1] for x in pose_bones]
 
     # Get a list of all the bone indices and instigator bones for the bone filter settings.
-    export_bone_names = get_export_bone_names(armature, options.bone_filter_mode, options.bone_group_indices)
+    export_bone_names = get_export_bone_names(armature_object, options.bone_filter_mode, options.bone_group_indices)
     bone_indices = [bone_names.index(x) for x in export_bone_names]
 
     # Make the bone lists contain only the bones that are going to be exported.
@@ -135,7 +85,8 @@ def build_psa(context, options: PsaBuildOptions) -> Psa:
         raise RuntimeError('No bones available for export')
 
     # Check that all bone names are valid.
-    check_bone_names(map(lambda bone: bone.name, bones))
+    if not options.should_ignore_bone_name_restrictions:
+        check_bone_names(map(lambda bone: bone.name, bones))
 
     # Build list of PSA bones.
     for bone in bones:
@@ -156,9 +107,12 @@ def build_psa(context, options: PsaBuildOptions) -> Psa:
             parent_tail = inverse_parent_rotation @ bone.parent.tail
             location = (parent_tail - parent_head) + bone.head
         else:
-            location = armature.matrix_local @ bone.head
+            armature_local_matrix = armature_object.matrix_local
-            rot_matrix = 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
@@ -171,97 +125,60 @@ def build_psa(context, options: PsaBuildOptions) -> Psa:
 
         psa.bones.append(psa_bone)
 
-    # Populate the export sequence list.
-    class NlaState:
-        def __init__(self):
-            self.frame_min = 0
-            self.frame_max = 0
-            self.action = None
-
-    class ExportSequence:
-        def __init__(self):
-            self.name = ''
-            self.nla_state = NlaState()
-            self.fps = 30.0
-
-    export_sequences = []
-
-    if options.sequence_source == 'ACTIONS':
-        for action in options.actions:
-            if len(action.fcurves) == 0:
-                continue
-            export_sequence = ExportSequence()
-            export_sequence.nla_state.action = action
-            export_sequence.name = get_psa_sequence_name(action, options.should_use_original_sequence_names)
-            frame_min, frame_max = [int(x) for x in action.frame_range]
-            export_sequence.nla_state.frame_min = frame_min
-            export_sequence.nla_state.frame_max = frame_max
-            export_sequence.fps = get_sequence_fps(context, options, [action])
-            export_sequences.append(export_sequence)
-        pass
-    elif options.sequence_source == 'TIMELINE_MARKERS':
-        sequence_frame_ranges = get_timeline_marker_sequence_frame_ranges(animation_data, context, options)
-
-        for name, (frame_min, frame_max) in sequence_frame_ranges.items():
-            export_sequence = ExportSequence()
-            export_sequence.name = name
-            export_sequence.nla_state.action = None
-            export_sequence.nla_state.frame_min = frame_min
-            export_sequence.nla_state.frame_max = frame_max
-            nla_strips_actions = set(
-                map(lambda x: x.action, get_nla_strips_in_timeframe(animation_data, frame_min, frame_max)))
-            export_sequence.fps = get_sequence_fps(context, options, nla_strips_actions)
-            export_sequences.append(export_sequence)
-    else:
-        raise ValueError(f'Unhandled sequence source: {options.sequence_source}')
-
     # Add prefixes and suffices to the names of the export sequences and strip whitespace.
-    for export_sequence in export_sequences:
+    for export_sequence in options.sequences:
         export_sequence.name = f'{options.sequence_name_prefix}{export_sequence.name}{options.sequence_name_suffix}'
         export_sequence.name = export_sequence.name.strip()
 
+    # Save the current action and frame so that we can restore the state once we are done.
+    saved_frame_current = context.scene.frame_current
+    saved_action = options.animation_data.action
+
     # Now build the PSA sequences.
     # We actually alter the timeline frame and simply record the resultant pose bone matrices.
     frame_start_index = 0
 
-    for export_sequence in export_sequences:
+    for export_sequence in options.sequences:
         # Link the action to the animation data and update view layer.
-        animation_data.action = export_sequence.nla_state.action
+        options.animation_data.action = export_sequence.nla_state.action
         context.view_layer.update()
 
-        frame_min = export_sequence.nla_state.frame_min
+        frame_start = export_sequence.nla_state.frame_start
-        frame_max = export_sequence.nla_state.frame_max
+        frame_end = export_sequence.nla_state.frame_end
-        frame_count = frame_max - frame_min + 1
+
+        # Calculate the frame step based on the compression factor.
+        frame_extents = abs(frame_end - frame_start)
+        frame_count_raw = frame_extents + 1
+        frame_count = max(export_sequence.key_quota, int(frame_count_raw * export_sequence.compression_ratio))
+
+        try:
+            frame_step = frame_extents / (frame_count - 1)
+        except ZeroDivisionError:
+            frame_step = 0.0
+
+        sequence_duration = frame_count_raw / export_sequence.fps
+
+        # If this is a reverse sequence, we need to reverse the frame step.
+        if frame_start > frame_end:
+            frame_step = -frame_step
 
         psa_sequence = Psa.Sequence()
         psa_sequence.name = bytes(export_sequence.name, encoding='windows-1252')
         psa_sequence.frame_count = frame_count
         psa_sequence.frame_start_index = frame_start_index
-        psa_sequence.fps = export_sequence.fps
+        psa_sequence.fps = frame_count / sequence_duration
+        psa_sequence.bone_count = len(pose_bones)
+        psa_sequence.track_time = frame_count
 
-        for frame in range(frame_count):
+        frame = float(frame_start)
-            context.scene.frame_set(frame_min + frame)
+
+        for _ in range(frame_count):
+            context.scene.frame_set(frame=int(frame), subframe=frame % 1.0)
 
             for pose_bone in pose_bones:
+                location, rotation = get_pose_bone_location_and_rotation(pose_bone, armature_object, options)
+
                 key = Psa.Key()
-
-                if pose_bone.parent is not None:
-                    pose_bone_matrix = pose_bone.matrix
-                    pose_bone_parent_matrix = pose_bone.parent.matrix
-                    pose_bone_matrix = pose_bone_parent_matrix.inverted() @ pose_bone_matrix
-                else:
-                    if options.root_motion:
-                        # Export root motion
-                        pose_bone_matrix = armature.matrix_world @ pose_bone.matrix
-                    else:
-                        pose_bone_matrix = pose_bone.matrix
-
-                location = pose_bone_matrix.to_translation()
-                rotation = pose_bone_matrix.to_quaternion().normalized()
-
-                if pose_bone.parent is not None:
-                    rotation.conjugate()
-
                 key.location.x = location.x
                 key.location.y = location.y
                 key.location.z = location.z
@@ -270,14 +187,16 @@ def build_psa(context, options: PsaBuildOptions) -> Psa:
                 key.rotation.z = rotation.z
                 key.rotation.w = rotation.w
                 key.time = 1.0 / psa_sequence.fps
-
                 psa.keys.append(key)
 
-            psa_sequence.bone_count = len(pose_bones)
+            frame += frame_step
-            psa_sequence.track_time = frame_count
 
         frame_start_index += frame_count
 
         psa.sequences[export_sequence.name] = psa_sequence
 
+    # Restore the previous action & frame.
+    options.animation_data.action = saved_action
+    context.scene.frame_set(saved_frame_current)
+
     return psa

io_scene_psk_psa/psa/data.py

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

io_scene_psk_psa/psa/exporter.py

@@ -1,14 +1,14 @@
 import fnmatch
 import sys
-from typing import Type
+from typing import Type, Dict
 
 import bpy
 from bpy.props import BoolProperty, CollectionProperty, EnumProperty, FloatProperty, IntProperty, PointerProperty, \
     StringProperty
-from bpy.types import Action, Operator, PropertyGroup, UIList
+from bpy.types import Action, Operator, PropertyGroup, UIList, Context, Armature, TimelineMarker
 from bpy_extras.io_utils import ExportHelper
 
-from .builder import PsaBuildOptions, build_psa
+from .builder import PsaBuildOptions, PsaExportSequence, build_psa
 from .data import *
 from ..helpers import *
 from ..types import BoneGroupListItem
@@ -38,23 +38,17 @@ class PsaExportActionListItem(PropertyGroup):
     action: PointerProperty(type=Action)
     name: StringProperty()
     is_selected: BoolProperty(default=False)
+    frame_start: IntProperty(options={'HIDDEN'})
+    frame_end: IntProperty(options={'HIDDEN'})
+    is_pose_marker: BoolProperty(options={'HIDDEN'})
 
 
 class PsaExportTimelineMarkerListItem(PropertyGroup):
     marker_index: IntProperty()
     name: StringProperty()
     is_selected: BoolProperty(default=True)
-
+    frame_start: IntProperty(options={'HIDDEN'})
-
+    frame_end: IntProperty(options={'HIDDEN'})
-def update_action_names(context):
-    pg = context.scene.psa_export
-    for item in pg.action_list:
-        action = item.action
-        item.action_name = get_psa_sequence_name(action, pg.should_use_original_sequence_names)
-
-
-def should_use_original_sequence_names_updated(_, context):
-    update_action_names(context)
 
 
 def psa_export_property_group_animation_data_override_poll(_context, obj):
@@ -69,7 +63,9 @@ class PsaExportPropertyGroup(PropertyGroup):
         name='Root Motion',
         options=empty_set,
         default=False,
-        description='The root bone will be transformed as it appears in the scene',
+        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',
@@ -121,20 +117,11 @@ class PsaExportPropertyGroup(PropertyGroup):
     )
     bone_group_list: CollectionProperty(type=BoneGroupListItem)
     bone_group_list_index: IntProperty(default=0, name='', description='')
-    should_use_original_sequence_names: BoolProperty(
+    should_ignore_bone_name_restrictions: BoolProperty(
         default=False,
-        name='Original Names',
+        name='Ignore Bone Name Restrictions',
-        options=empty_set,
+        description='Bone names restrictions will be ignored. Note that bone names without properly formatted names '
-        update=should_use_original_sequence_names_updated,
+                    'cannot be referenced in scripts'
-        description='If the action was imported from the PSA Import panel, the original name of the sequence will be '
-                    'used instead of the Blender action name',
-    )
-    should_trim_timeline_marker_sequences: BoolProperty(
-        default=True,
-        name='Trim Sequences',
-        options=empty_set,
-        description='Frames without NLA track information at the boundaries of timeline markers will be excluded from '
-                    'the exported sequences '
     )
     sequence_name_prefix: StringProperty(name='Prefix', options=empty_set)
     sequence_name_suffix: StringProperty(name='Suffix', options=empty_set)
@@ -153,6 +140,10 @@ class PsaExportPropertyGroup(PropertyGroup):
         name='Show assets',
         options=empty_set,
         description='Show actions that belong to an asset library')
+    sequence_filter_pose_marker: BoolProperty(
+        default=False,
+        name='Show pose markers',
+        options=empty_set)
     sequence_use_filter_sort_reverse: BoolProperty(default=True, options=empty_set)
 
 
@@ -164,6 +155,193 @@ def is_bone_filter_mode_item_available(context, identifier):
     return True
 
 
+def get_timeline_marker_sequence_frame_ranges(animation_data: AnimData, context: Context, marker_names: List[str]) -> Dict:
+    # Timeline markers need to be sorted so that we can determine the sequence start and end positions.
+    sequence_frame_ranges = dict()
+    sorted_timeline_markers = list(sorted(context.scene.timeline_markers, key=lambda x: x.frame))
+    sorted_timeline_marker_names = list(map(lambda x: x.name, sorted_timeline_markers))
+
+    for marker_name in marker_names:
+        marker = context.scene.timeline_markers[marker_name]
+        frame_start = marker.frame
+        # Determine the final frame of the sequence based on the next marker.
+        # If no subsequent marker exists, use the maximum frame_end from all NLA strips.
+        marker_index = sorted_timeline_marker_names.index(marker_name)
+        next_marker_index = marker_index + 1
+        frame_end = 0
+        if next_marker_index < len(sorted_timeline_markers):
+            # There is a next marker. Use that next marker's frame position as the last frame of this sequence.
+            frame_end = sorted_timeline_markers[next_marker_index].frame
+            nla_strips = get_nla_strips_in_timeframe(animation_data, marker.frame, frame_end)
+            if len(nla_strips) > 0:
+                frame_end = min(frame_end, max(map(lambda nla_strip: nla_strip.frame_end, nla_strips)))
+                frame_start = max(frame_start, min(map(lambda nla_strip: nla_strip.frame_start, nla_strips)))
+            else:
+                # No strips in between this marker and the next, just export this as a one-frame animation.
+                frame_end = frame_start
+        else:
+            # There is no next marker.
+            # Find the final frame of all the NLA strips and use that as the last frame of this sequence.
+            for nla_track in animation_data.nla_tracks:
+                if nla_track.mute:
+                    continue
+                for strip in nla_track.strips:
+                    frame_end = max(frame_end, strip.frame_end)
+
+        if frame_start > frame_end:
+            continue
+
+        sequence_frame_ranges[marker_name] = int(frame_start), int(frame_end)
+
+    return sequence_frame_ranges
+
+
+def get_sequence_fps(context: Context, fps_source: str, fps_custom: float, actions: Iterable[Action]) -> float:
+    if fps_source == 'SCENE':
+        return context.scene.render.fps
+    elif fps_source == 'CUSTOM':
+        return fps_custom
+    elif fps_source == 'ACTION_METADATA':
+        # Get the minimum value of action metadata FPS values.
+        fps_list = []
+        for action in filter(lambda x: 'psa_sequence_fps' in x, actions):
+            fps = action['psa_sequence_fps']
+            if type(fps) == int or type(fps) == float:
+                fps_list.append(fps)
+        if len(fps_list) > 0:
+            return min(fps_list)
+        else:
+            # No valid action metadata to use, fallback to scene FPS
+            return context.scene.render.fps
+    else:
+        raise RuntimeError(f'Invalid FPS source "{fps_source}"')
+
+
+def 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 get_animation_data_object(context: Context) -> Object:
+    pg: PsaExportPropertyGroup = getattr(context.scene, 'psa_export')
+
+    active_object = context.view_layer.objects.active
+
+    if active_object.type != 'ARMATURE':
+        raise RuntimeError('Selected object must be an Armature')
+
+    if pg.should_override_animation_data:
+        animation_data_object = pg.animation_data_override
+    else:
+        animation_data_object = active_object
+
+    return animation_data_object
+
+
+def get_sequences_from_action(action: Action) -> List[Tuple[str, int, int]]:
+    frame_start = int(action.frame_range[0])
+    frame_end = int(action.frame_range[1])
+    reversed_pattern = r'(.+)/(.+)'
+    reversed_match = re.match(reversed_pattern, action.name)
+    if reversed_match:
+        forward_name = reversed_match.group(1)
+        backwards_name = reversed_match.group(2)
+        return [
+            (forward_name, frame_start, frame_end),
+            (backwards_name, frame_end, frame_start)
+        ]
+    else:
+        return [(action.name, frame_start, frame_end)]
+
+
+def get_sequences_from_action_pose_marker(action: Action, pose_markers: List[TimelineMarker], pose_marker: TimelineMarker, pose_marker_index: int) -> List[Tuple[str, int, int]]:
+    frame_start = pose_marker.frame
+    if pose_marker_index + 1 < len(pose_markers):
+        frame_end = pose_markers[pose_marker_index + 1].frame
+    else:
+        frame_end = int(action.frame_range[1])
+    reversed_pattern = r'(.+)/(.+)'
+    reversed_match = re.match(reversed_pattern, pose_marker.name)
+    if reversed_match:
+        forward_name = reversed_match.group(1)
+        backwards_name = reversed_match.group(2)
+        return [
+            (forward_name, frame_start, frame_end),
+            (backwards_name, frame_end, frame_start)
+        ]
+    else:
+        return [(pose_marker.name, frame_start, frame_end)]
+
+
+def update_actions_and_timeline_markers(context: Context, armature: Armature):
+    pg = getattr(context.scene, 'psa_export')
+
+    # Clear actions and markers.
+    pg.action_list.clear()
+    pg.marker_list.clear()
+
+    # Get animation data.
+    animation_data_object = get_animation_data_object(context)
+    animation_data = animation_data_object.animation_data if animation_data_object else None
+
+    if animation_data is None:
+        return
+
+    # Populate actions list.
+    for action in bpy.data.actions:
+        if not is_action_for_armature(armature, action):
+            continue
+
+        if not action.name.startswith('#'):
+            for (name, frame_start, frame_end) in get_sequences_from_action(action):
+                item = pg.action_list.add()
+                item.action = action
+                item.name = name
+                item.is_selected = False
+                item.is_pose_marker = False
+                item.frame_start = frame_start
+                item.frame_end = frame_end
+
+        # Pose markers are not guaranteed to be in frame-order, so make sure that they are.
+        pose_markers = sorted(action.pose_markers, key=lambda x: x.frame)
+        for pose_marker_index, pose_marker in enumerate(pose_markers):
+            if pose_marker.name.startswith('#'):
+                continue
+            for (name, frame_start, frame_end) in get_sequences_from_action_pose_marker(action, pose_markers, pose_marker, pose_marker_index):
+                item = pg.action_list.add()
+                item.action = action
+                item.name = name
+                item.is_selected = False
+                item.is_pose_marker = True
+                item.frame_start = frame_start
+                item.frame_end = frame_end
+
+    # Populate timeline markers list.
+    marker_names = [x.name for x in context.scene.timeline_markers]
+    sequence_frame_ranges = get_timeline_marker_sequence_frame_ranges(animation_data, context, marker_names)
+
+    for marker_name in marker_names:
+        if marker_name not in sequence_frame_ranges:
+            continue
+        if marker_name.startswith('#'):
+            continue
+        item = pg.marker_list.add()
+        item.name = marker_name
+        item.is_selected = False
+        frame_start, frame_end = sequence_frame_ranges[marker_name]
+        item.frame_start = frame_start
+        item.frame_end = frame_end
+
+
 class PsaExportOperator(Operator, ExportHelper):
     bl_idname = 'psa_export.operator'
     bl_label = 'Export'
@@ -178,7 +356,7 @@ class PsaExportOperator(Operator, ExportHelper):
         default='')
 
     def __init__(self):
-        self.armature = None
+        self.armature_object = None
 
     @classmethod
     def poll(cls, context):
@@ -222,7 +400,6 @@ class PsaExportOperator(Operator, ExportHelper):
             col = layout.column()
             col.use_property_split = True
             col.use_property_decorate = False
-            col.prop(pg, 'should_use_original_sequence_names')
             col.prop(pg, 'sequence_name_prefix')
             col.prop(pg, 'sequence_name_suffix')
 
@@ -234,7 +411,6 @@ class PsaExportOperator(Operator, ExportHelper):
             col = layout.column()
             col.use_property_split = True
             col.use_property_decorate = False
-            col.prop(pg, 'should_trim_timeline_marker_sequences')
             col.prop(pg, 'sequence_name_prefix')
             col.prop(pg, 'sequence_name_suffix')
 
@@ -262,24 +438,13 @@ class PsaExportOperator(Operator, ExportHelper):
             layout.template_list('PSX_UL_BoneGroupList', '', pg, 'bone_group_list', pg, 'bone_group_list_index',
                                  rows=rows)
 
+        layout.prop(pg, 'should_ignore_bone_name_restrictions')
+
         layout.separator()
 
         # ROOT MOTION
         layout.prop(pg, 'root_motion', text='Root Motion')
 
-    def is_action_for_armature(self, action):
-        if len(action.fcurves) == 0:
-            return False
-        bone_names = set([x.name for x in self.armature.data.bones])
-        for fcurve in action.fcurves:
-            match = re.match(r'pose\.bones\["(.+)"].\w+', fcurve.data_path)
-            if not match:
-                continue
-            bone_name = match.group(1)
-            if bone_name in bone_names:
-                return True
-        return False
-
     @classmethod
     def _check_context(cls, context):
         if context.view_layer.objects.active is None:
@@ -294,35 +459,14 @@ class PsaExportOperator(Operator, ExportHelper):
         except RuntimeError as e:
             self.report({'ERROR_INVALID_CONTEXT'}, str(e))
 
-        pg = getattr(context.scene, 'psa_export')
+        pg: PsaExportPropertyGroup = getattr(context.scene, 'psa_export')
-        self.armature = context.view_layer.objects.active
 
-        # Populate actions list.
+        self.armature_object = context.view_layer.objects.active
-        pg.action_list.clear()
-        for action in bpy.data.actions:
-            if not self.is_action_for_armature(action):
-                continue
-            item = pg.action_list.add()
-            item.action = action
-            item.name = action.name
-            item.is_selected = False
 
-        update_action_names(context)
+        update_actions_and_timeline_markers(context, self.armature_object.data)
-
-        # Populate timeline markers list.
-        pg.marker_list.clear()
-        for marker in context.scene.timeline_markers:
-            item = pg.marker_list.add()
-            item.name = marker.name
-            item.is_selected = False
-
-        if len(pg.action_list) == 0 and len(pg.marker_list) == 0:
-            # If there are no actions at all, we have nothing to export, so just cancel the operation.
-            self.report({'ERROR_INVALID_CONTEXT'}, 'There are no actions or timeline markers to export.')
-            return {'CANCELLED'}
 
         # Populate bone groups list.
-        populate_bone_group_list(self.armature, pg.bone_group_list)
+        populate_bone_group_list(self.armature_object, pg.bone_group_list)
 
         context.window_manager.fileselect_add(self)
 
@@ -331,21 +475,54 @@ class PsaExportOperator(Operator, ExportHelper):
     def execute(self, context):
         pg = getattr(context.scene, 'psa_export')
 
-        actions = [x.action for x in pg.action_list if x.is_selected]
+        # Ensure that we actually have items that we are going to be exporting.
-        marker_names = [x.name for x in pg.marker_list if x.is_selected]
+        if pg.sequence_source == 'ACTIONS' and len(pg.action_list) == 0:
+            raise RuntimeError('No actions were selected for export')
+        elif pg.sequence_source == 'TIMELINE_MARKERS' and len(pg.marker_names) == 0:
+            raise RuntimeError('No timeline markers were selected for export')
+
+        # Populate the export sequence list.
+        animation_data_object = get_animation_data_object(context)
+        animation_data = animation_data_object.animation_data
+
+        if animation_data is None:
+            raise RuntimeError(f'No animation data for object \'{animation_data_object.name}\'')
+
+        export_sequences: List[PsaExportSequence] = []
+
+        if pg.sequence_source == 'ACTIONS':
+            for action in filter(lambda x: x.is_selected, pg.action_list):
+                if len(action.action.fcurves) == 0:
+                    continue
+                export_sequence = PsaExportSequence()
+                export_sequence.nla_state.action = action.action
+                export_sequence.name = action.name
+                export_sequence.nla_state.frame_start = action.frame_start
+                export_sequence.nla_state.frame_end = action.frame_end
+                export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, [action.action])
+                export_sequence.compression_ratio = action.action.psa_export.compression_ratio
+                export_sequence.key_quota = action.action.psa_export.key_quota
+                export_sequences.append(export_sequence)
+        elif pg.sequence_source == 'TIMELINE_MARKERS':
+            for marker in pg.marker_list:
+                export_sequence = PsaExportSequence()
+                export_sequence.name = marker.name
+                export_sequence.nla_state.action = None
+                export_sequence.nla_state.frame_start = marker.frame_start
+                export_sequence.nla_state.frame_end = marker.frame_end
+                nla_strips_actions = set(
+                    map(lambda x: x.action, get_nla_strips_in_timeframe(animation_data, marker.frame_start, marker.frame_end)))
+                export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, nla_strips_actions)
+                export_sequences.append(export_sequence)
+        else:
+            raise ValueError(f'Unhandled sequence source: {pg.sequence_source}')
 
         options = PsaBuildOptions()
-        options.should_override_animation_data = pg.should_override_animation_data
+        options.animation_data = animation_data
-        options.animation_data_override = pg.animation_data_override
+        options.sequences = export_sequences
-        options.fps_source = pg.fps_source
-        options.fps_custom = pg.fps_custom
-        options.sequence_source = pg.sequence_source
-        options.actions = actions
-        options.marker_names = marker_names
         options.bone_filter_mode = pg.bone_filter_mode
         options.bone_group_indices = [x.index for x in pg.bone_group_list if x.is_selected]
-        options.should_use_original_sequence_names = pg.should_use_original_sequence_names
+        options.should_ignore_bone_name_restrictions = pg.should_ignore_bone_name_restrictions
-        options.should_trim_timeline_marker_sequences = pg.should_trim_timeline_marker_sequences
         options.sequence_name_prefix = pg.sequence_name_prefix
         options.sequence_name_suffix = pg.sequence_name_suffix
         options.root_motion = pg.root_motion
@@ -382,6 +559,11 @@ def filter_sequences(pg: PsaExportPropertyGroup, sequences) -> List[int]:
             if hasattr(sequence, 'action') and sequence.action.asset_data is not None:
                 flt_flags[i] &= ~bitflag_filter_item
 
+    if not pg.sequence_filter_pose_marker:
+        for i, sequence in enumerate(sequences):
+            if hasattr(sequence, 'is_pose_marker') and sequence.is_pose_marker:
+                flt_flags[i] &= ~bitflag_filter_item
+
     return flt_flags
 
 
@@ -401,10 +583,19 @@ class PSA_UL_ExportSequenceList(UIList):
         self.use_filter_show = True
 
     def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
+        item = typing.cast(PsaExportActionListItem, item)
+        is_pose_marker = hasattr(item, 'is_pose_marker') and item.is_pose_marker
         layout.prop(item, 'is_selected', icon_only=True, text=item.name)
         if hasattr(item, 'action') and item.action.asset_data is not None:
             layout.label(text='', icon='ASSET_MANAGER')
 
+        row = layout.row(align=True)
+        row.alignment = 'RIGHT'
+        if item.frame_end < item.frame_start:
+            row.label(text='', icon='FRAME_PREV')
+        if is_pose_marker:
+            row.label(text=item.action.name, icon='PMARKER')
+
     def draw_filter(self, context, layout):
         pg = getattr(context.scene, 'psa_export')
         row = layout.row()
@@ -416,12 +607,14 @@ class PSA_UL_ExportSequenceList(UIList):
         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')
 
     def filter_items(self, context, data, prop):
         pg = getattr(context.scene, 'psa_export')
         actions = getattr(data, prop)
         flt_flags = filter_sequences(pg, actions)
-        flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(actions, 'name')
+        # flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(actions, 'name')
+        flt_neworder = list(range(len(actions)))
         return flt_flags, flt_neworder
 
 

io_scene_psk_psa/psa/importer.py

@@ -1,12 +1,14 @@
 import fnmatch
 import os
 import re
+import typing
+from collections import Counter
 from typing import List, Optional
 
 import bpy
-import numpy as np
+import numpy
-from bpy.props import StringProperty, BoolProperty, CollectionProperty, PointerProperty, IntProperty
+from bpy.props import StringProperty, BoolProperty, CollectionProperty, PointerProperty, IntProperty, EnumProperty
-from bpy.types import Operator, UIList, PropertyGroup, Panel
+from bpy.types import Operator, UIList, PropertyGroup, FCurve
 from bpy_extras.io_utils import ImportHelper
 from mathutils import Vector, Quaternion
 
@@ -16,7 +18,6 @@ from .reader import PsaReader
 
 class PsaImportOptions(object):
     def __init__(self):
-        self.should_clean_keys = True
         self.should_use_fake_user = False
         self.should_stash = False
         self.sequence_names = []
@@ -24,6 +25,8 @@ class PsaImportOptions(object):
         self.should_write_keyframes = True
         self.should_write_metadata = True
         self.action_name_prefix = ''
+        self.should_convert_to_samples = False
+        self.bone_mapping_mode = 'CASE_INSENSITIVE'
 
 
 class ImportBone(object):
@@ -35,10 +38,10 @@ class ImportBone(object):
         self.orig_loc: Vector = Vector()
         self.orig_quat: Quaternion = Quaternion()
         self.post_quat: Quaternion = Quaternion()
-        self.fcurves = []
+        self.fcurves: List[FCurve] = []
 
 
-def calculate_fcurve_data(import_bone: ImportBone, key_data: []):
+def calculate_fcurve_data(import_bone: ImportBone, key_data: typing.Iterable[float]):
     # Convert world-space transforms to local-space transforms.
     key_rotation = Quaternion(key_data[0:4])
     key_location = Vector(key_data[4:])
@@ -56,44 +59,73 @@ def calculate_fcurve_data(import_bone: ImportBone, key_data: []):
     return quat.w, quat.x, quat.y, quat.z, loc.x, loc.y, loc.z
 
 
-def import_psa(psa_reader: PsaReader, armature_object, options: PsaImportOptions):
+class PsaImportResult:
+    def __init__(self):
+        self.warnings: List[str] = []
+
+
+def import_psa(psa_reader: PsaReader, armature_object: bpy.types.Object, options: PsaImportOptions) -> PsaImportResult:
+    result = PsaImportResult()
     sequences = map(lambda x: psa_reader.sequences[x], options.sequence_names)
-    armature_data = armature_object.data
+    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_bone_names = [x.name for x in armature_data.bones]
     psa_bone_names = []
     for psa_bone_index, psa_bone in enumerate(psa_reader.bones):
-        psa_bone_name = psa_bone.name.decode('windows-1252')
+        psa_bone_name: str = psa_bone.name.decode('windows-1252')
-        psa_bone_names.append(psa_bone_name)
         try:
             psa_to_armature_bone_indices[psa_bone_index] = armature_bone_names.index(psa_bone_name)
         except ValueError:
-            pass
+            # PSA bone could not be mapped directly to an armature bone by name.
+            # Attempt to create a bone mapping by ignoring the case of the names.
+            if options.bone_mapping_mode == 'CASE_INSENSITIVE':
+                for armature_bone_index, armature_bone_name in enumerate(armature_bone_names):
+                    if armature_bone_name.upper() == psa_bone_name.upper():
+                        psa_to_armature_bone_indices[psa_bone_index] = armature_bone_index
+                        psa_bone_name = armature_bone_name
+                        break
+        psa_bone_names.append(psa_bone_name)
+
+    # Remove ambiguous bone mappings (where multiple PSA bones correspond to the same armature bone).
+    armature_bone_index_counts = Counter(psa_to_armature_bone_indices.values())
+    for armature_bone_index, count in armature_bone_index_counts.items():
+        if count > 1:
+            psa_bone_indices = []
+            for psa_bone_index, mapped_bone_index in psa_to_armature_bone_indices:
+                if mapped_bone_index == armature_bone_index:
+                    psa_bone_indices.append(psa_bone_index)
+            ambiguous_psa_bone_names = list(sorted([psa_bone_names[x] for x in psa_bone_indices]))
+            result.warnings.append(
+                f'Ambiguous mapping for bone {armature_bone_names[armature_bone_index]}!\n'
+                f'The following PSA bones all map to the same armature bone: {ambiguous_psa_bone_names}\n'
+                f'These bones will be ignored.'
+            )
 
     # 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(
+        result.warnings.append(
-            f'The armature object \'{armature_object.name}\' is missing the following bones that exist in the PSA:')
+            f'The armature \'{armature_object.name}\' is missing {len(missing_bone_names)} bones that exist in '
-        print(list(sorted(missing_bone_names)))
+            'the PSA:\n' +
+            str(list(sorted(missing_bone_names)))
+        )
     del armature_bone_names
 
     # Create intermediate bone data for import operations.
     import_bones = []
     import_bones_dict = dict()
 
-    for psa_bone_index, psa_bone in enumerate(psa_reader.bones):
+    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
+        import_bones_dict[psa_bone_name] = import_bone
         import_bones.append(import_bone)
 
     for import_bone in filter(lambda x: x is not None, import_bones):
@@ -154,7 +186,6 @@ def import_psa(psa_reader: PsaReader, armature_object, options: PsaImportOptions
 
             # Read the sequence data matrix from the PSA.
             sequence_data_matrix = psa_reader.read_sequence_data_matrix(sequence_name)
-            keyframe_write_matrix = np.ones(sequence_data_matrix.shape, dtype=np.int8)
 
             # Convert the sequence's data from world-space to local-space.
             for bone_index, import_bone in enumerate(import_bones):
@@ -166,43 +197,24 @@ def import_psa(psa_reader: PsaReader, armature_object, options: PsaImportOptions
                     # Calculate the local-space key data for the bone.
                     sequence_data_matrix[frame_index, bone_index] = calculate_fcurve_data(import_bone, key_data)
 
-            # Clean the keyframe data. This is accomplished by writing zeroes to the write matrix when there is an
+            # Write the keyframes out.
-            # insufficiently large change in the data from the last written frame.
+            fcurve_data = numpy.zeros(2 * sequence.frame_count, dtype=float)
-            if options.should_clean_keys:
+            fcurve_data[0::2] = range(sequence.frame_count)
-                threshold = 0.001
+            for bone_index, import_bone in enumerate(import_bones):
-                for bone_index, import_bone in enumerate(import_bones):
+                if import_bone is None:
-                    if import_bone is None:
+                    continue
-                        continue
+                for fcurve_index, fcurve in enumerate(import_bone.fcurves):
-                    for fcurve_index in range(len(import_bone.fcurves)):
+                    fcurve_data[1::2] = sequence_data_matrix[:, bone_index, fcurve_index]
-                        # Get all the keyframe data for the bone's f-curve data from the sequence data matrix.
+                    fcurve.keyframe_points.add(sequence.frame_count)
-                        fcurve_frame_data = sequence_data_matrix[:, bone_index, fcurve_index]
+                    fcurve.keyframe_points.foreach_set('co', fcurve_data)
-                        last_written_datum = 0
-                        for frame_index, datum in enumerate(fcurve_frame_data):
-                            # If the f-curve data is not different enough to the last written frame,
-                            # un-mark this data for writing.
-                            if frame_index > 0 and abs(datum - last_written_datum) < threshold:
-                                keyframe_write_matrix[frame_index, bone_index, fcurve_index] = 0
-                            else:
-                                last_written_datum = datum
 
-            # Write the keyframes out!
+            if options.should_convert_to_samples:
-            for frame_index in range(sequence.frame_count):
+                # Bake the curve to samples.
-                for bone_index, import_bone in enumerate(import_bones):
+                for fcurve in action.fcurves:
-                    if import_bone is None:
+                    fcurve.convert_to_samples(start=0, end=sequence.frame_count)
-                        continue
-                    bone_has_writeable_keyframes = any(keyframe_write_matrix[frame_index, bone_index])
-                    if bone_has_writeable_keyframes:
-                        # This bone has writeable keyframes for this frame.
-                        key_data = sequence_data_matrix[frame_index, bone_index]
-                        for fcurve, should_write, datum in zip(import_bone.fcurves,
-                                                               keyframe_write_matrix[frame_index, bone_index],
-                                                               key_data):
-                            if should_write:
-                                fcurve.keyframe_points.insert(frame_index, datum, options={'FAST'})
 
-        # Write
+        # Write meta-data.
         if options.should_write_metadata:
-            action['psa_sequence_name'] = sequence_name
             action['psa_sequence_fps'] = sequence.fps
 
         action.use_fake_user = options.should_use_fake_user
@@ -219,6 +231,8 @@ def import_psa(psa_reader: PsaReader, armature_object, options: PsaImportOptions
             nla_track.mute = True
             nla_track.strips.new(name=action.name, start=0, action=action)
 
+    return result
+
 
 empty_set = set()
 
@@ -228,14 +242,14 @@ class PsaImportActionListItem(PropertyGroup):
     is_selected: BoolProperty(default=False, options=empty_set)
 
 
-def load_psa_file(context):
+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(pg.psa_file_path)
+        p = os.path.abspath(filepath)
         psa_reader = PsaReader(p)
         for sequence in psa_reader.sequences.values():
             item = pg.sequence_list.add()
@@ -247,8 +261,8 @@ def load_psa_file(context):
         pg.psa_error = str(e)
 
 
-def on_psa_file_path_updated(property, context):
+def on_psa_file_path_updated(cls, context):
-    load_psa_file(context)
+    load_psa_file(context, cls.filepath)
 
 
 class PsaBonePropertyGroup(PropertyGroup):
@@ -261,27 +275,26 @@ class PsaDataPropertyGroup(PropertyGroup):
 
 
 class PsaImportPropertyGroup(PropertyGroup):
-    psa_file_path: StringProperty(default='', options=empty_set, update=on_psa_file_path_updated, name='PSA File Path')
     psa_error: StringProperty(default='')
     psa: PointerProperty(type=PsaDataPropertyGroup)
     sequence_list: CollectionProperty(type=PsaImportActionListItem)
     sequence_list_index: IntProperty(name='', default=0)
-    should_clean_keys: BoolProperty(default=True, name='Clean Keyframes',
-                                    description='Exclude unnecessary keyframes from being written to the actions',
-                                    options=empty_set)
     should_use_fake_user: BoolProperty(default=True, name='Fake User',
-                                       description='Assign each imported action a fake user so that the data block is saved even it has no users',
+                                       description='Assign each imported action a fake user so that the data block is '
+                                                   'saved even it has no users',
                                        options=empty_set)
     should_stash: BoolProperty(default=False, name='Stash',
                                description='Stash each imported action as a strip on a new non-contributing NLA track',
                                options=empty_set)
     should_use_action_name_prefix: BoolProperty(default=False, name='Prefix Action Name', options=empty_set)
     action_name_prefix: StringProperty(default='', name='Prefix', options=empty_set)
-    should_overwrite: BoolProperty(default=False, name='Reuse Existing Actions', options=empty_set,
+    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')
+                                   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)')
+                                        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')
@@ -289,6 +302,22 @@ class PsaImportPropertyGroup(PropertyGroup):
     sequence_use_filter_regex: BoolProperty(default=False, name='Regular Expression',
                                             description='Filter using regular expressions', options=empty_set)
     select_text: PointerProperty(type=bpy.types.Text)
+    should_convert_to_samples: BoolProperty(
+        default=False,
+        name='Convert to Samples',
+        description='Convert keyframes to read-only samples. '
+                    'Recommended if you do not plan on editing the actions directly'
+    )
+    bone_mapping_mode: EnumProperty(
+        name='Bone Mapping',
+        options=empty_set,
+        description='The method by which bones from the incoming PSA file are mapped to the armature',
+        items=(
+            ('EXACT', 'Exact', 'Bone names must match exactly.', 'EXACT', 0),
+            ('CASE_INSENSITIVE', 'Case Insensitive', 'Bones names must match, ignoring case (e.g., the bone PSA bone '
+             '\'root\' can be mapped to the armature bone \'Root\')', 'CASE_INSENSITIVE', 1),
+        )
+    )
 
 
 def filter_sequences(pg: PsaImportPropertyGroup, sequences) -> List[int]:
@@ -352,9 +381,9 @@ class PSA_UL_SequenceList(UIList):
         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):
+    def filter_items(self, context, data, property_):
         pg = getattr(context.scene, 'psa_import')
-        sequences = getattr(data, property)
+        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
@@ -446,107 +475,6 @@ class PsaImportSequencesDeselectAll(Operator):
         return {'FINISHED'}
 
 
-class PSA_PT_ImportPanel_Advanced(Panel):
-    bl_space_type = 'PROPERTIES'
-    bl_region_type = 'WINDOW'
-    bl_label = 'Advanced'
-    bl_options = {'DEFAULT_CLOSED'}
-    bl_parent_id = 'PSA_PT_ImportPanel'
-
-    def draw(self, context):
-        layout = self.layout
-        pg = getattr(context.scene, 'psa_import')
-
-        col = layout.column(heading="Options")
-        col.use_property_split = True
-        col.use_property_decorate = False
-        col.prop(pg, 'should_clean_keys')
-        col.separator()
-        col.prop(pg, 'should_use_fake_user')
-        col.prop(pg, 'should_stash')
-        col.prop(pg, 'should_use_action_name_prefix')
-
-        if pg.should_use_action_name_prefix:
-            col.prop(pg, 'action_name_prefix')
-
-
-class PSA_PT_ImportPanel(Panel):
-    bl_space_type = 'PROPERTIES'
-    bl_region_type = 'WINDOW'
-    bl_label = 'PSA Import'
-    bl_context = 'data'
-    bl_category = 'PSA Import'
-    bl_options = {'DEFAULT_CLOSED'}
-
-    @classmethod
-    def poll(cls, context):
-        return context.view_layer.objects.active.type == 'ARMATURE'
-
-    def draw(self, context):
-        layout = self.layout
-        pg = getattr(context.scene, 'psa_import')
-
-        row = layout.row(align=True)
-        row.operator(PsaImportSelectFile.bl_idname, text='', icon='FILEBROWSER')
-        row.prop(pg, 'psa_file_path', text='')
-        row.operator(PsaImportFileReload.bl_idname, text='', icon='FILE_REFRESH')
-
-        if pg.psa_error != '':
-            row = layout.row()
-            row.label(text='File could not be read', icon='ERROR')
-
-        box = layout.box()
-
-        box.label(text=f'Sequences ({len(pg.sequence_list)})', icon='ARMATURE_DATA')
-
-        # select
-        rows = max(3, min(len(pg.sequence_list), 10))
-
-        row = box.row()
-        col = row.column()
-
-        row2 = col.row(align=True)
-        row2.label(text='Select')
-        row2.operator(PsaImportSequencesFromText.bl_idname, text='', icon='TEXT')
-        row2.operator(PsaImportSequencesSelectAll.bl_idname, text='All', icon='CHECKBOX_HLT')
-        row2.operator(PsaImportSequencesDeselectAll.bl_idname, text='None', icon='CHECKBOX_DEHLT')
-
-        col = col.row()
-        col.template_list('PSA_UL_ImportSequenceList', '', pg, 'sequence_list', pg, 'sequence_list_index', rows=rows)
-
-        col = layout.column(heading='')
-        col.use_property_split = True
-        col.use_property_decorate = False
-        col.prop(pg, 'should_overwrite')
-
-        col = layout.column(heading='Write')
-        col.use_property_split = True
-        col.use_property_decorate = False
-        col.prop(pg, 'should_write_keyframes')
-        col.prop(pg, 'should_write_metadata')
-
-        selected_sequence_count = sum(map(lambda x: x.is_selected, pg.sequence_list))
-
-        row = layout.row()
-
-        import_button_text = 'Import'
-        if selected_sequence_count > 0:
-            import_button_text = f'Import ({selected_sequence_count})'
-
-        row.operator(PsaImportOperator.bl_idname, text=import_button_text)
-
-
-class PsaImportFileReload(Operator):
-    bl_idname = 'psa_import.file_reload'
-    bl_label = 'Refresh'
-    bl_options = {'INTERNAL'}
-    bl_description = 'Refresh the PSA file'
-
-    def execute(self, context):
-        load_psa_file(context)
-        return {"FINISHED"}
-
-
 class PsaImportSelectFile(Operator):
     bl_idname = 'psa_import.select_file'
     bl_label = 'Select'
@@ -564,63 +492,123 @@ class PsaImportSelectFile(Operator):
         return {"RUNNING_MODAL"}
 
 
-class PsaImportOperator(Operator):
+class PsaImportOperator(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'}
 
-    @classmethod
-    def poll(cls, context):
-        pg = getattr(context.scene, 'psa_import')
-        active_object = context.view_layer.objects.active
-        if active_object is None or active_object.type != 'ARMATURE':
-            return False
-        return any(map(lambda x: x.is_selected, pg.sequence_list))
-
-    def execute(self, context):
-        pg = getattr(context.scene, 'psa_import')
-        psa_reader = PsaReader(pg.psa_file_path)
-        sequence_names = [x.action_name for x in pg.sequence_list if x.is_selected]
-
-        options = PsaImportOptions()
-        options.sequence_names = sequence_names
-        options.should_clean_keys = pg.should_clean_keys
-        options.should_use_fake_user = pg.should_use_fake_user
-        options.should_stash = pg.should_stash
-        options.action_name_prefix = pg.action_name_prefix if pg.should_use_action_name_prefix else ''
-        options.should_overwrite = pg.should_overwrite
-        options.should_write_metadata = pg.should_write_metadata
-        options.should_write_keyframes = pg.should_write_keyframes
-
-        import_psa(psa_reader, context.view_layer.objects.active, options)
-
-        self.report({'INFO'}, f'Imported {len(sequence_names)} action(s)')
-
-        return {'FINISHED'}
-
-
-class PsaImportFileSelectOperator(Operator, ImportHelper):
-    bl_idname = 'psa_import.file_select'
-    bl_label = 'File Select'
-    bl_options = {'INTERNAL'}
     filename_ext = '.psa'
     filter_glob: StringProperty(default='*.psa', options={'HIDDEN'})
     filepath: StringProperty(
         name='File Path',
         description='File path used for importing the PSA file',
         maxlen=1024,
-        default='')
+        default='',
+        update=on_psa_file_path_updated)
 
-    def invoke(self, context, event):
+    @classmethod
-        context.window_manager.fileselect_add(self)
+    def poll(cls, context):
-        return {'RUNNING_MODAL'}
+        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')
-        pg.psa_file_path = self.filepath
+        psa_reader = PsaReader(self.filepath)
+        sequence_names = [x.action_name for x in pg.sequence_list if x.is_selected]
+
+        options = PsaImportOptions()
+        options.sequence_names = sequence_names
+        options.should_use_fake_user = pg.should_use_fake_user
+        options.should_stash = pg.should_stash
+        options.action_name_prefix = pg.action_name_prefix if pg.should_use_action_name_prefix else ''
+        options.should_overwrite = pg.should_overwrite
+        options.should_write_metadata = pg.should_write_metadata
+        options.should_write_keyframes = pg.should_write_keyframes
+        options.should_convert_to_samples = pg.should_convert_to_samples
+        options.bone_mapping_mode = pg.bone_mapping_mode
+
+        result = import_psa(psa_reader, context.view_layer.objects.active, options)
+
+        if len(result.warnings) > 0:
+            message = f'Imported {len(sequence_names)} action(s) with {len(result.warnings)} warning(s)\n'
+            message += '\n'.join(result.warnings)
+            self.report({'WARNING'}, message)
+        else:
+            self.report({'INFO'}, f'Imported {len(sequence_names)} action(s)')
+
         return {'FINISHED'}
 
+    def invoke(self, context: bpy.types.Context, event: bpy.types.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: bpy.types.Context):
+        layout = self.layout
+        pg = getattr(context.scene, 'psa_import')
+
+        if pg.psa_error:
+            row = layout.row()
+            row.label(text='Select a PSA file', icon='ERROR')
+        else:
+            box = layout.box()
+
+            box.label(text=f'Sequences ({len(pg.sequence_list)})', icon='ARMATURE_DATA')
+
+            # Select buttons.
+            rows = max(3, min(len(pg.sequence_list), 10))
+
+            row = box.row()
+            col = row.column()
+
+            row2 = col.row(align=True)
+            row2.label(text='Select')
+            row2.operator(PsaImportSequencesFromText.bl_idname, text='', icon='TEXT')
+            row2.operator(PsaImportSequencesSelectAll.bl_idname, text='All', icon='CHECKBOX_HLT')
+            row2.operator(PsaImportSequencesDeselectAll.bl_idname, text='None', icon='CHECKBOX_DEHLT')
+
+            col = col.row()
+            col.template_list('PSA_UL_ImportSequenceList', '', pg, 'sequence_list', pg, 'sequence_list_index', rows=rows)
+
+        col = layout.column(heading='')
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(pg, 'should_overwrite')
+
+        col = layout.column(heading='Write')
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(pg, 'should_write_keyframes')
+        col.prop(pg, 'should_write_metadata')
+
+        col = layout.column()
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(pg, 'bone_mapping_mode')
+
+        if pg.should_write_keyframes:
+            col = layout.column(heading='Keyframes')
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(pg, 'should_convert_to_samples')
+            col.separator()
+
+        col = layout.column(heading='Options')
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(pg, 'should_use_fake_user')
+        col.prop(pg, 'should_stash')
+        col.prop(pg, 'should_use_action_name_prefix')
+
+        if pg.should_use_action_name_prefix:
+            col.prop(pg, 'action_name_prefix')
+
 
 classes = (
     PsaImportActionListItem,
@@ -633,10 +621,6 @@ classes = (
     PsaImportSequencesSelectAll,
     PsaImportSequencesDeselectAll,
     PsaImportSequencesFromText,
-    PsaImportFileReload,
-    PSA_PT_ImportPanel,
-    PSA_PT_ImportPanel_Advanced,
     PsaImportOperator,
-    PsaImportFileSelectOperator,
     PsaImportSelectFile,
 )

io_scene_psk_psa/psa/reader.py

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

io_scene_psk_psa/psk/builder.py

@@ -1,10 +1,11 @@
-from collections import OrderedDict
+import typing
-from typing import Dict, List
+
+import bmesh
+import bpy
+from bpy.types import Armature
 
 from .data import *
 from ..helpers import *
-import bmesh
-import bpy
 
 
 class PskInputObjects(object):
@@ -19,6 +20,7 @@ class PskBuildOptions(object):
         self.bone_group_indices: List[int] = []
         self.use_raw_mesh_data = True
         self.material_names: List[str] = []
+        self.should_ignore_bone_name_restrictions = False
 
 
 def get_psk_input_objects(context) -> PskInputObjects:
@@ -60,7 +62,7 @@ def get_psk_input_objects(context) -> PskInputObjects:
 def build_psk(context, options: PskBuildOptions) -> Psk:
     input_objects = get_psk_input_objects(context)
 
-    armature_object = input_objects.armature_object
+    armature_object: bpy.types.Object = input_objects.armature_object
 
     psk = Psk()
     bones = []
@@ -78,10 +80,12 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
         psk.bones.append(psk_bone)
     else:
         bone_names = get_export_bone_names(armature_object, options.bone_filter_mode, options.bone_group_indices)
-        bones = [armature_object.data.bones[bone_name] for bone_name in bone_names]
+        armature_data = typing.cast(Armature, armature_object.data)
+        bones = [armature_data.bones[bone_name] for bone_name in bone_names]
 
         # Check that all bone names are valid.
-        check_bone_names(map(lambda x: x.name, bones))
+        if not options.should_ignore_bone_name_restrictions:
+            check_bone_names(map(lambda x: x.name, bones))
 
         for bone in bones:
             psk_bone = Psk.Bone()
@@ -98,15 +102,17 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
 
             if bone.parent is not None:
                 rotation = bone.matrix.to_quaternion().conjugated()
-                quat_parent = bone.parent.matrix.to_quaternion().inverted()
+                inverse_parent_rotation = bone.parent.matrix.to_quaternion().inverted()
-                parent_head = quat_parent @ bone.parent.head
+                parent_head = inverse_parent_rotation @ bone.parent.head
-                parent_tail = quat_parent @ bone.parent.tail
+                parent_tail = inverse_parent_rotation @ bone.parent.tail
                 location = (parent_tail - parent_head) + bone.head
             else:
-                local_matrix = armature_object.matrix_local
+                armature_local_matrix = armature_object.matrix_local
-                location = local_matrix @ bone.head
+                location = armature_local_matrix @ bone.head
-                rot_matrix = bone.matrix @ local_matrix.to_3x3()
+                bone_rotation = bone.matrix.to_quaternion().conjugated()
-                rotation = rot_matrix.to_quaternion()
+                local_rotation = armature_local_matrix.to_3x3().to_quaternion().conjugated()
+                rotation = bone_rotation @ local_rotation
+                rotation.conjugate()
 
             psk_bone.location.x = location.x
             psk_bone.location.y = location.y
@@ -133,16 +139,17 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
         # MATERIALS
         material_indices = [material_names.index(material.name) for material in input_mesh_object.data.materials]
 
+        # MESH DATA
         if options.use_raw_mesh_data:
             mesh_object = input_mesh_object
             mesh_data = input_mesh_object.data
         else:
             # Create a copy of the mesh object after non-armature modifiers are applied.
 
-            # Temporarily deactivate any armature modifiers on the input mesh object.
+            # Temporarily force the armature into the rest position.
-            active_armature_modifiers = [x for x in filter(lambda x: x.type == 'ARMATURE' and x.is_active, input_mesh_object.modifiers)]
+            # We will undo this later.
-            for modifier in active_armature_modifiers:
+            old_pose_position = armature_object.data.pose_position
-                modifier.show_viewport = False
+            armature_object.data.pose_position = 'REST'
 
             depsgraph = context.evaluated_depsgraph_get()
             bm = bmesh.new()
@@ -157,9 +164,8 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
             for vertex_group in input_mesh_object.vertex_groups:
                 mesh_object.vertex_groups.new(name=vertex_group.name)
 
-            # Reactivate previously active armature modifiers
+            # Restore the previous pose position on the armature.
-            for modifier in active_armature_modifiers:
+            armature_object.data.pose_position = old_pose_position
-                modifier.show_viewport = True
 
         vertex_offset = len(psk.points)
 
@@ -217,6 +223,7 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
 
         # WEIGHTS
         if armature_object is not None:
+            armature_data = typing.cast(Armature, armature_object.data)
             # Because the vertex groups may contain entries for which there is no matching bone in the armature,
             # we must filter them out and not export any weights for these vertex groups.
             bone_names = [x.name for x in bones]
@@ -230,8 +237,8 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
                     # Check to see if there is an associated bone for this vertex group that exists in the armature.
                     # If there is, we can traverse the ancestors of that bone to find an alternate bone to use for
                     # weighting the vertices belonging to this vertex group.
-                    if vertex_group_name in armature_object.data.bones:
+                    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)

io_scene_psk_psa/psk/data.py

@@ -80,6 +80,19 @@ class Psk(object):
             ('bone_index', c_int32),
         ]
 
+    class MorphInfo(Structure):
+        _fields_ = [
+            ('name', c_char * 64),
+            ('vertex_count', c_int32)
+        ]
+
+    class MorphData(Structure):
+        _fields_ = [
+            ('position_delta', Vector3),
+            ('tangent_z_delta', Vector3),
+            ('point_index', c_int32)
+        ]
+
     @property
     def has_extra_uvs(self):
         return len(self.extra_uvs) > 0
@@ -92,6 +105,14 @@ class Psk(object):
     def has_vertex_normals(self):
         return len(self.vertex_normals) > 0
 
+    @property
+    def has_material_references(self):
+        return len(self.material_references) > 0
+
+    @property
+    def has_morph_data(self):
+        return len(self.morph_infos) > 0
+    
     def __init__(self):
         self.points: List[Vector3] = []
         self.wedges: List[Psk.Wedge] = []
@@ -102,3 +123,6 @@ class Psk(object):
         self.extra_uvs: List[Vector2] = []
         self.vertex_colors: List[Color] = []
         self.vertex_normals: List[Vector3] = []
+        self.morph_infos: List[Psk.MorphInfo] = []
+        self.morph_data: List[Psk.MorphData] = []
+        self.material_references: List[str] = []

io_scene_psk_psa/psk/exporter.py

@@ -30,12 +30,14 @@ def _write_section(fp, name: bytes, data_type: Type[Structure] = None, data: lis
 def export_psk(psk: Psk, path: str):
     if len(psk.wedges) > MAX_WEDGE_COUNT:
         raise RuntimeError(f'Number of wedges ({len(psk.wedges)}) exceeds limit of {MAX_WEDGE_COUNT}')
-    if len(psk.bones) > MAX_BONE_COUNT:
-        raise RuntimeError(f'Number of bones ({len(psk.bones)}) exceeds limit of {MAX_BONE_COUNT}')
     if len(psk.points) > MAX_POINT_COUNT:
         raise RuntimeError(f'Numbers of vertices ({len(psk.points)}) exceeds limit of {MAX_POINT_COUNT}')
     if len(psk.materials) > MAX_MATERIAL_COUNT:
         raise RuntimeError(f'Number of materials ({len(psk.materials)}) exceeds limit of {MAX_MATERIAL_COUNT}')
+    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')
@@ -161,7 +163,12 @@ class PskExportOperator(Operator, ExportHelper):
 
         # Populate bone groups list.
         populate_bone_group_list(input_objects.armature_object, pg.bone_group_list)
-        populate_material_list(input_objects.mesh_objects, pg.material_list)
+
+        try:
+            populate_material_list(input_objects.mesh_objects, pg.material_list)
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+            return {'CANCELLED'}
 
         context.window_manager.fileselect_add(self)
 
@@ -208,6 +215,10 @@ class PskExportOperator(Operator, ExportHelper):
         col.operator(PskMaterialListItemMoveUp.bl_idname, text='', icon='TRIA_UP')
         col.operator(PskMaterialListItemMoveDown.bl_idname, text='', icon='TRIA_DOWN')
 
+        layout.separator()
+
+        layout.prop(pg, 'should_ignore_bone_name_restrictions')
+
     def execute(self, context):
         pg = context.scene.psk_export
         options = PskBuildOptions()
@@ -215,6 +226,7 @@ class PskExportOperator(Operator, ExportHelper):
         options.bone_group_indices = [x.index for x in pg.bone_group_list if x.is_selected]
         options.use_raw_mesh_data = pg.use_raw_mesh_data
         options.material_names = [m.material_name for m in pg.material_list]
+        options.should_ignore_bone_name_restrictions = pg.should_ignore_bone_name_restrictions
 
         try:
             psk = build_psk(context, options)
@@ -242,6 +254,12 @@ class PskExportPropertyGroup(PropertyGroup):
     use_raw_mesh_data: BoolProperty(default=False, name='Raw Mesh Data', description='No modifiers will be evaluated as part of the exported mesh')
     material_list: CollectionProperty(type=MaterialListItem)
     material_list_index: IntProperty(default=0)
+    should_ignore_bone_name_restrictions: BoolProperty(
+        default=False,
+        name='Ignore Bone Name Restrictions',
+        description='Bone names restrictions will be ignored. Note that bone names without properly formatted names '
+                    'cannot be referenced in scripts'
+    )
 
 
 classes = (

io_scene_psk_psa/psk/importer.py

@@ -7,28 +7,31 @@ import bmesh
 import bpy
 import numpy as np
 from bpy.props import BoolProperty, EnumProperty, FloatProperty, StringProperty
-from bpy.types import Operator, PropertyGroup, VertexGroup
+from bpy.types import Operator, VertexGroup
 from bpy_extras.io_utils import ImportHelper
 from mathutils import Quaternion, Vector, Matrix
 
 from .data import Psk
 from .reader import read_psk
-from ..helpers import rgb_to_srgb
+from ..helpers import rgb_to_srgb, is_bdk_addon_loaded
 
 
-class PskImportOptions(object):
+class PskImportOptions:
     def __init__(self):
         self.name = ''
         self.should_import_mesh = True
+        self.should_reuse_materials = True
         self.should_import_vertex_colors = True
         self.vertex_color_space = 'sRGB'
         self.should_import_vertex_normals = True
         self.should_import_extra_uvs = True
         self.should_import_skeleton = True
+        self.should_import_shape_keys = True
         self.bone_length = 1.0
+        self.should_import_materials = True
 
 
-class ImportBone(object):
+class ImportBone:
     """
     Intermediate bone type for the purpose of construction.
     """
@@ -46,7 +49,13 @@ class ImportBone(object):
         self.post_quat: Quaternion = Quaternion()
 
 
-def import_psk(psk: Psk, context, options: PskImportOptions):
+class PskImportResult:
+    def __init__(self):
+        self.warnings: List[str] = []
+
+
+def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
+    result = PskImportResult()
     armature_object = None
 
     if options.should_import_skeleton:
@@ -119,10 +128,24 @@ def import_psk(psk: Psk, context, options: PskImportOptions):
         mesh_object = bpy.data.objects.new(options.name, mesh_data)
 
         # MATERIALS
-        for material in psk.materials:
+        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)
+                    material.use_nodes = True
+                mesh_data.materials.append(material)
 
         bm = bmesh.new()
 
@@ -142,7 +165,7 @@ def import_psk(psk: Psk, context, options: PskImportOptions):
                 degenerate_face_indices.add(face_index)
 
         if len(degenerate_face_indices) > 0:
-            print(f'WARNING: Discarded {len(degenerate_face_indices)} degenerate face(s).')
+            result.warnings.append(f'Discarded {len(degenerate_face_indices)} degenerate face(s).')
 
         bm.to_mesh(mesh_data)
 
@@ -200,7 +223,8 @@ def import_psk(psk: Psk, context, options: PskImportOptions):
                     vertex_color_data.data[loop_index].color = 1.0, 1.0, 1.0, 1.0
 
             if len(ambiguous_vertex_color_point_indices) > 0:
-                print(f'WARNING: {len(ambiguous_vertex_color_point_indices)} vertex(es) with ambiguous vertex colors.')
+                result.warnings.append(
+                    f'{len(ambiguous_vertex_color_point_indices)} vertex(es) with ambiguous vertex colors.')
 
         # VERTEX NORMALS
         if psk.has_vertex_normals and options.should_import_vertex_normals:
@@ -214,6 +238,7 @@ def import_psk(psk: Psk, context, options: PskImportOptions):
         bm.normal_update()
         bm.free()
 
+        # WEIGHTS
         # Get a list of all bones that have weights associated with them.
         vertex_group_bone_indices = set(map(lambda weight: weight.bone_index, psk.weights))
         vertex_groups: List[Optional[VertexGroup]] = [None] * len(psk.bones)
@@ -223,6 +248,21 @@ def import_psk(psk: Psk, context, options: PskImportOptions):
         for weight in psk.weights:
             vertex_groups[weight.bone_index].add((weight.point_index,), weight.weight, 'ADD')
 
+        # MORPHS (SHAPE KEYS)
+        if options.should_import_shape_keys:
+            morph_data_iterator = iter(psk.morph_data)
+
+            if psk.has_morph_data:
+                mesh_object.shape_key_add(name='MORPH_BASE', from_mix=False)
+
+            for morph_info in psk.morph_infos:
+                shape_key = mesh_object.shape_key_add(name=morph_info.name.decode('windows-1252'), from_mix=False)
+
+                for _ in range(morph_info.vertex_count):
+                    morph_data = next(morph_data_iterator)
+                    x, y, z = morph_data.position_delta
+                    shape_key.data[morph_data.point_index].co += Vector((x, -y, z))
+
         context.scene.collection.objects.link(mesh_object)
 
         # Add armature modifier to our mesh object.
@@ -236,11 +276,25 @@ def import_psk(psk: Psk, context, options: PskImportOptions):
     except:
         pass
 
+    return result
+
 
 empty_set = set()
 
 
-class PskImportPropertyGroup(PropertyGroup):
+class PskImportOperator(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,
@@ -261,13 +315,13 @@ class PskImportPropertyGroup(PropertyGroup):
         default=True,
         name='Vertex Normals',
         options=empty_set,
-        description='Import vertex normals from PSKX files, if available'
+        description='Import vertex normals, if available'
     )
     should_import_extra_uvs: BoolProperty(
         default=True,
         name='Extra UVs',
         options=empty_set,
-        description='Import extra UV maps from PSKX files, if available'
+        description='Import extra UV maps, if available'
     )
     should_import_mesh: BoolProperty(
         default=True,
@@ -275,6 +329,17 @@ class PskImportPropertyGroup(PropertyGroup):
         options=empty_set,
         description='Import mesh'
     )
+    should_import_materials: BoolProperty(
+        default=True,
+        name='Import Materials',
+        options=empty_set,
+    )
+    should_reuse_materials: BoolProperty(
+        default=True,
+        name='Reuse Materials',
+        options=empty_set,
+        description='Existing materials with matching names will be reused when available'
+    )
     should_import_skeleton: BoolProperty(
         default=True,
         name='Import Skeleton',
@@ -290,62 +355,61 @@ class PskImportPropertyGroup(PropertyGroup):
         options=empty_set,
         description='Length of the bones'
     )
-
+    should_import_shape_keys: BoolProperty(
-
+        default=True,
-class PskImportOperator(Operator, ImportHelper):
+        name='Shape Keys',
-    bl_idname = 'import.psk'
+        options=empty_set,
-    bl_label = 'Import'
+        description='Import shape keys, if available'
-    bl_options = {'INTERNAL', 'UNDO'}
+    )
-    __doc__ = 'Load a PSK file'
-    filename_ext = '.psk'
-    filter_glob: StringProperty(default='*.psk;*.pskx', options={'HIDDEN'})
-    filepath: StringProperty(
-        name='File Path',
-        description='File path used for exporting the PSK file',
-        maxlen=1024,
-        default='')
 
     def execute(self, context):
-        pg = getattr(context.scene, 'psk_import')
-
         psk = read_psk(self.filepath)
 
         options = PskImportOptions()
         options.name = os.path.splitext(os.path.basename(self.filepath))[0]
-        options.should_import_mesh = pg.should_import_mesh
+        options.should_import_mesh = self.should_import_mesh
-        options.should_import_extra_uvs = pg.should_import_extra_uvs
+        options.should_import_extra_uvs = self.should_import_extra_uvs
-        options.should_import_vertex_colors = pg.should_import_vertex_colors
+        options.should_import_vertex_colors = self.should_import_vertex_colors
-        options.should_import_vertex_normals = pg.should_import_vertex_normals
+        options.should_import_vertex_normals = self.should_import_vertex_normals
-        options.vertex_color_space = pg.vertex_color_space
+        options.vertex_color_space = self.vertex_color_space
-        options.should_import_skeleton = pg.should_import_skeleton
+        options.should_import_skeleton = self.should_import_skeleton
-        options.bone_length = pg.bone_length
+        options.bone_length = self.bone_length
+        options.should_import_materials = self.should_import_materials
+        options.should_import_shape_keys = self.should_import_shape_keys
 
-        import_psk(psk, context, options)
+        result = import_psk(psk, context, options)
+
+        if len(result.warnings):
+            message = f'PSK imported with {len(result.warnings)} warning(s)\n'
+            message += '\n'.join(result.warnings)
+            self.report({'WARNING'}, message)
+        else:
+            self.report({'INFO'}, f'PSK imported')
 
         return {'FINISHED'}
 
     def draw(self, context):
-        pg = getattr(context.scene, 'psk_import')
         layout = self.layout
-        layout.prop(pg, 'should_import_mesh')
+        layout.prop(self, 'should_import_materials')
+        layout.prop(self, 'should_import_mesh')
         row = layout.column()
         row.use_property_split = True
         row.use_property_decorate = False
-        if pg.should_import_mesh:
+        if self.should_import_mesh:
-            row.prop(pg, 'should_import_vertex_normals')
+            row.prop(self, 'should_import_vertex_normals')
-            row.prop(pg, 'should_import_extra_uvs')
+            row.prop(self, 'should_import_extra_uvs')
-            row.prop(pg, 'should_import_vertex_colors')
+            row.prop(self, 'should_import_vertex_colors')
-            if pg.should_import_vertex_colors:
+            if self.should_import_vertex_colors:
-                row.prop(pg, 'vertex_color_space')
+                row.prop(self, 'vertex_color_space')
-        layout.prop(pg, 'should_import_skeleton')
+            row.prop(self, 'should_import_shape_keys')
+        layout.prop(self, 'should_import_skeleton')
         row = layout.column()
         row.use_property_split = True
         row.use_property_decorate = False
-        if pg.should_import_skeleton:
+        if self.should_import_skeleton:
-            row.prop(pg, 'bone_length')
+            row.prop(self, 'bone_length')
 
 
 classes = (
     PskImportOperator,
-    PskImportPropertyGroup,
 )

io_scene_psk_psa/psk/reader.py

@@ -1,4 +1,8 @@
 import ctypes
+import os
+import re
+import warnings
+from pathlib import Path
 
 from .data import *
 
@@ -12,8 +16,22 @@ def _read_types(fp, data_class, section: Section, data):
         offset += section.data_size
 
 
-def read_psk(path) -> Psk:
+def _read_material_references(path: str) -> List[str]:
+    property_file_path = Path(path).with_suffix('.props.txt')
+    if not property_file_path.is_file():
+        # Property file does not exist.
+        return []
+    # Do a crude regex match to find the Material list entries.
+    contents = property_file_path.read_text()
+    pattern = r"Material\s*=\s*([^\s^,]+)"
+    return re.findall(pattern, contents)
+
+
+def read_psk(path: str) -> Psk:
+
     psk = Psk()
+
+    # Read the PSK file sections.
     with open(path, 'rb') as fp:
         while fp.read(1):
             fp.seek(-1, 1)
@@ -45,6 +63,19 @@ def read_psk(path) -> Psk:
                 _read_types(fp, Vector2, section, psk.extra_uvs)
             elif section.name == b'VTXNORMS':
                 _read_types(fp, Vector3, section, psk.vertex_normals)
+            elif section.name == b'MRPHINFO':
+                _read_types(fp, Psk.MorphInfo, section, psk.morph_infos)
+            elif section.name == b'MRPHDATA':
+                _read_types(fp, Psk.MorphData, section, psk.morph_data)
             else:
-                raise RuntimeError(f'Unrecognized section "{section.name} at position {15:fp.tell()}"')
+                # Section is not handled, skip it.
+                fp.seek(section.data_size * section.data_count, os.SEEK_CUR)
+                warnings.warn(f'Unrecognized section "{section.name} at position {fp.tell():15}"')
+
+    '''
+    UEViewer exports a sidecar file (*.props.txt) with fully-qualified reference paths for each material
+    (e.g., Texture'Package.Group.Object').
+    '''
+    psk.material_references = _read_material_references(path)
+
     return psk

io_scene_psk_psa/types.py

@@ -1,5 +1,5 @@
-from bpy.props import StringProperty, IntProperty, BoolProperty
+from bpy.props import StringProperty, IntProperty, BoolProperty, FloatProperty
-from bpy.types import PropertyGroup, UIList, UILayout, Context, AnyType
+from bpy.types import PropertyGroup, UIList, UILayout, Context, AnyType, Panel
 
 
 class PSX_UL_BoneGroupList(UIList):
@@ -18,7 +18,33 @@ class BoneGroupListItem(PropertyGroup):
     is_selected: BoolProperty(default=False)
 
 
+class PSX_PG_ActionExportPropertyGroup(PropertyGroup):
+    compression_ratio: FloatProperty(name='Compression Ratio', default=1.0, min=0.0, max=1.0, subtype='FACTOR', description='The key sampling ratio of the exported sequence.\n\nA compression ratio of 1.0 will export all frames, while a compression ratio of 0.5 will export half of the frames')
+    key_quota: IntProperty(name='Key Quota', default=0, min=1, description='The minimum number of frames to be exported')
+
+
+class PSX_PT_ActionPropertyPanel(Panel):
+    bl_idname = 'PSX_PT_ActionPropertyPanel'
+    bl_label = 'PSA Export'
+    bl_space_type = 'DOPESHEET_EDITOR'
+    bl_region_type = 'UI'
+    bl_context = 'action'
+    bl_category = 'Action'
+
+    @classmethod
+    def poll(cls, context: 'Context'):
+        return context.active_object and context.active_object.type == 'ARMATURE' and context.active_action is not None
+
+    def draw(self, context: 'Context'):
+        action = context.active_action
+        layout = self.layout
+        layout.prop(action.psa_export, 'compression_ratio')
+        layout.prop(action.psa_export, 'key_quota')
+
+
 classes = (
+    PSX_PG_ActionExportPropertyGroup,
     BoneGroupListItem,
     PSX_UL_BoneGroupList,
+    PSX_PT_ActionPropertyPanel
 )