Bone names can now contain hyphens

For some reason this breaks compatibility with Blender 2.92

README.md

@@ -1,4 +1,4 @@
-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).
+This Blender 2.80+ add-on allows you to import and export meshes and animations to and from the [PSK and PSA file formats](https://wiki.beyondunreal.com/PSK_%26_PSA_file_formats) used in many version of the Unreal Engine.
 
 # Features
 * Full PSK/PSA import and export capabilities
@@ -6,8 +6,8 @@ This Blender add-on allows you to import and export meshes and animations to and
 * 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
-* An armature's [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 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 
 
 # Installation
 1. Download the zip file for the latest version from the [releases](https://github.com/DarklightGames/io_export_psk_psa/releases) page.

io_scene_psk_psa/__init__.py

@@ -1,7 +1,7 @@
 bl_info = {
     "name": "PSK/PSA Importer/Exporter",
-    "author": "Colin Basnett",
+    "author": "Colin Basnett, Yurii Ti",
-    "version": (3, 0, 0),
+    "version": (4, 0, 1),
     "blender": (2, 80, 0),
     # "location": "File > Export > PSK Export (.psk)",
     "description": "PSK/PSA Import/Export (.psk/.psa)",

io_scene_psk_psa/helpers.py

@@ -1,9 +1,10 @@
 import datetime
+import re
 from collections import Counter
 from typing import List, Iterable
 
+import bpy.types
 from bpy.types import NlaStrip, Object
-from .types import BoneGroupListItem
 
 
 class Timer:
@@ -31,22 +32,11 @@ def rgb_to_srgb(c):
         return 12.92 * c
 
 
-def get_nla_strips_ending_at_frame(object, frame) -> List[NlaStrip]:
+def get_nla_strips_in_timeframe(animation_data, frame_min, frame_max) -> List[NlaStrip]:
-    if object is None or object.animation_data is None:
+    if animation_data is None:
         return []
     strips = []
-    for nla_track in object.animation_data.nla_tracks:
+    for nla_track in animation_data.nla_tracks:
-        for strip in nla_track.strips:
-            if strip.frame_end == frame:
-                strips.append(strip)
-    return strips
-
-
-def get_nla_strips_in_timeframe(object, frame_min, frame_max) -> List[NlaStrip]:
-    if object is None or object.animation_data is None:
-        return []
-    strips = []
-    for nla_track in object.animation_data.nla_tracks:
         if nla_track.mute:
             continue
         for strip in nla_track.strips:
@@ -57,7 +47,7 @@ def get_nla_strips_in_timeframe(object, frame_min, frame_max) -> List[NlaStrip]:
     return strips
 
 
-def populate_bone_group_list(armature_object: Object, bone_group_list: Iterable[BoneGroupListItem]) -> None:
+def populate_bone_group_list(armature_object: Object, bone_group_list: bpy.types.Collection) -> None:
     """
     Updates the bone group collection.
 
@@ -103,6 +93,14 @@ def get_psa_sequence_name(action, should_use_original_sequence_name):
         return action.name
 
 
+def check_bone_names(bone_names: Iterable[str]):
+    pattern = re.compile(r'^[a-zA-Z0-9_\- ]+$')
+    invalid_bone_names = [x for x in bone_names if pattern.match(x) is None]
+    if len(invalid_bone_names) > 0:
+        raise RuntimeError(f'The following bone names are invalid: {invalid_bone_names}.\n'
+                           f'Bone names must only contain letters, numbers, spaces, and underscores.')
+
+
 def get_export_bone_names(armature_object, bone_filter_mode, bone_group_indices: List[int]) -> List[str]:
     """
     Returns a sorted list of bone indices that should be exported for the given bone filter mode and bone groups.

io_scene_psk_psa/psa/builder.py

@@ -1,14 +1,15 @@
-from typing import Dict, Iterable
+from typing import Dict
 
 from bpy.types import Action
-from mathutils import Matrix
 
 from .data import *
 from ..helpers import *
 
 
-class PsaBuilderOptions(object):
+class PsaBuildOptions(object):
     def __init__(self):
+        self.should_override_animation_data = False
+        self.animation_data_override = None
         self.fps_source = 'SCENE'
         self.fps_custom = 30.0
         self.sequence_source = 'ACTIONS'
@@ -23,11 +24,7 @@ class PsaBuilderOptions(object):
         self.root_motion = False
 
 
-class PsaBuilder(object):
+def get_sequence_fps(context, options: PsaBuildOptions, actions: Iterable[Action]) -> float:
-    def __init__(self):
-        pass
-
-    def get_sequence_fps(self, context, options: PsaBuilderOptions, actions: Iterable[Action]) -> float:
     if options.fps_source == 'SCENE':
         return context.scene.render.fps
     if options.fps_source == 'CUSTOM':
@@ -47,16 +44,64 @@ class PsaBuilder(object):
     else:
         raise RuntimeError(f'Invalid FPS source "{options.fps_source}"')
 
-    def build(self, context, options: PsaBuilderOptions) -> Psa:
+
+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.
+            # Find the final frame of all the NLA strips and use that as the last frame of this sequence.
+            for nla_track in animation_data.nla_tracks:
+                if nla_track.mute:
+                    continue
+                for strip in nla_track.strips:
+                    frame_max = max(frame_max, strip.frame_end)
+
+        if frame_min > frame_max:
+            continue
+
+        sequence_frame_ranges[marker_name] = int(frame_min), int(frame_max)
+
+    return sequence_frame_ranges
+
+
+def build_psa(context, options: PsaBuildOptions) -> Psa:
     active_object = context.view_layer.objects.active
 
     if active_object.type != 'ARMATURE':
         raise RuntimeError('Selected object must be an Armature')
 
-        armature = active_object
+    if options.should_override_animation_data:
+        animation_data_object = options.animation_data_override
+    else:
+        animation_data_object = active_object
 
-        if armature.animation_data is None:
+    animation_data = animation_data_object.animation_data
-            raise RuntimeError('No animation data for armature')
+
+    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:
@@ -66,10 +111,11 @@ class PsaBuilder(object):
 
     psa = Psa()
 
+    armature = active_object
     bones = list(armature.data.bones)
 
     # The order of the armature bones and the pose bones is not guaranteed to be the same.
-        # As as a result, we need to reconstruct the list of pose bones in the same order as the
+    # As a result, we need to reconstruct the list of pose bones in the same order as the
     # armature bones.
     bone_names = [x.name for x in bones]
     pose_bones = [(bone_names.index(bone.name), bone) for bone in armature.pose.bones]
@@ -88,10 +134,13 @@ class PsaBuilder(object):
     if len(bones) == 0:
         raise RuntimeError('No bones available for export')
 
+    # Check that all bone names are valid.
+    check_bone_names(map(lambda bone: bone.name, bones))
+
     # Build list of PSA bones.
     for bone in bones:
         psa_bone = Psa.Bone()
-            psa_bone.name = bytes(bone.name, encoding='utf-8')
+        psa_bone.name = bytes(bone.name, encoding='windows-1252')
 
         try:
             parent_index = bones.index(bone.parent)
@@ -101,13 +150,10 @@ class PsaBuilder(object):
             psa_bone.parent_index = -1
 
         if bone.parent is not None:
-                rotation = bone.matrix.to_quaternion()
+            rotation = bone.matrix.to_quaternion().conjugated()
-                rotation.x = -rotation.x
+            inverse_parent_rotation = bone.parent.matrix.to_quaternion().inverted()
-                rotation.y = -rotation.y
+            parent_head = inverse_parent_rotation @ bone.parent.head
-                rotation.z = -rotation.z
+            parent_tail = inverse_parent_rotation @ bone.parent.tail
-                quat_parent = bone.parent.matrix.to_quaternion().inverted()
-                parent_head = quat_parent @ bone.parent.head
-                parent_tail = quat_parent @ bone.parent.tail
             location = (parent_tail - parent_head) + bone.head
         else:
             location = armature.matrix_local @ bone.head
@@ -150,11 +196,11 @@ class PsaBuilder(object):
             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 = self.get_sequence_fps(context, options, [action])
+            export_sequence.fps = get_sequence_fps(context, options, [action])
             export_sequences.append(export_sequence)
         pass
     elif options.sequence_source == 'TIMELINE_MARKERS':
-            sequence_frame_ranges = self.get_timeline_marker_sequence_frame_ranges(armature, context, options)
+        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()
@@ -163,37 +209,36 @@ class PsaBuilder(object):
             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(active_object, frame_min, frame_max)))
+                map(lambda x: x.action, get_nla_strips_in_timeframe(animation_data, frame_min, frame_max)))
-                export_sequence.fps = self.get_sequence_fps(context, options, nla_strips_actions)
+            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:
-            export_sequence.name = f'{options.sequence_name_prefix}{export_sequence.name}{options.sequence_name_suffix}'.strip()
+        export_sequence.name = f'{options.sequence_name_prefix}{export_sequence.name}{options.sequence_name_suffix}'
+        export_sequence.name = export_sequence.name.strip()
 
     # 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:
-            armature.animation_data.action = export_sequence.nla_state.action
+        # Link the action to the animation data and update view layer.
+        animation_data.action = export_sequence.nla_state.action
         context.view_layer.update()
 
-            psa_sequence = Psa.Sequence()
-
         frame_min = export_sequence.nla_state.frame_min
         frame_max = export_sequence.nla_state.frame_max
         frame_count = frame_max - frame_min + 1
 
+        psa_sequence = Psa.Sequence()
         psa_sequence.name = bytes(export_sequence.name, encoding='windows-1252')
         psa_sequence.frame_count = frame_count
         psa_sequence.frame_start_index = frame_start_index
         psa_sequence.fps = export_sequence.fps
 
-            frame_count = frame_max - frame_min + 1
-
         for frame in range(frame_count):
             context.scene.frame_set(frame_min + frame)
 
@@ -236,44 +281,3 @@ class PsaBuilder(object):
         psa.sequences[export_sequence.name] = psa_sequence
 
     return psa
-
-    def get_timeline_marker_sequence_frame_ranges(self, object, context, options: PsaBuilderOptions) -> 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(object, marker.frame, frame_max)
-                    if len(nla_strips) > 0:
-                        frame_max = min(frame_max, max(map(lambda nla_strip: nla_strip.frame_end, nla_strips)))
-                        frame_min = max(frame_min, min(map(lambda nla_strip: nla_strip.frame_start, nla_strips)))
-                    else:
-                        # No strips in between this marker and the next, just export this as a one-frame animation.
-                        frame_max = frame_min
-            else:
-                # There is no next marker.
-                # Find the final frame of all the NLA strips and use that as the last frame of this sequence.
-                for nla_track in object.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:
-                continue
-
-            sequence_frame_ranges[marker_name] = int(frame_min), int(frame_max)
-
-        return sequence_frame_ranges

io_scene_psk_psa/psa/exporter.py

@@ -1,7 +1,5 @@
 import fnmatch
-import re
 import sys
-from collections import Counter
 from typing import Type
 
 import bpy
@@ -10,18 +8,12 @@ from bpy.props import BoolProperty, CollectionProperty, EnumProperty, FloatPrope
 from bpy.types import Action, Operator, PropertyGroup, UIList
 from bpy_extras.io_utils import ExportHelper
 
-from .builder import PsaBuilder, PsaBuilderOptions
+from .builder import PsaBuildOptions, build_psa
 from .data import *
 from ..helpers import *
 from ..types import BoneGroupListItem
 
 
-class PsaExporter(object):
-    def __init__(self, psa: Psa):
-        self.psa: Psa = psa
-
-    # This method is shared by both PSA/K file formats, move this?
-    @staticmethod
 def write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None):
     section = Section()
     section.name = name
@@ -33,12 +25,13 @@ class PsaExporter(object):
         for datum in data:
             fp.write(datum)
 
-    def export(self, path: str):
+
+def export_psa(psa: Psa, path: str):
     with open(path, 'wb') as fp:
-            self.write_section(fp, b'ANIMHEAD')
+        write_section(fp, b'ANIMHEAD')
-            self.write_section(fp, b'BONENAMES', Psa.Bone, self.psa.bones)
+        write_section(fp, b'BONENAMES', Psa.Bone, psa.bones)
-            self.write_section(fp, b'ANIMINFO', Psa.Sequence, list(self.psa.sequences.values()))
+        write_section(fp, b'ANIMINFO', Psa.Sequence, list(psa.sequences.values()))
-            self.write_section(fp, b'ANIMKEYS', Psa.Key, self.psa.keys)
+        write_section(fp, b'ANIMKEYS', Psa.Key, psa.keys)
 
 
 class PsaExportActionListItem(PropertyGroup):
@@ -64,16 +57,33 @@ def should_use_original_sequence_names_updated(_, context):
     update_action_names(context)
 
 
+def psa_export_property_group_animation_data_override_poll(_context, obj):
+    return obj.animation_data is not None
+
+
+empty_set = set()
+
+
 class PsaExportPropertyGroup(PropertyGroup):
     root_motion: BoolProperty(
         name='Root Motion',
-        options=set(),
+        options=empty_set,
         default=False,
-        description='When set, the root bone will be transformed as it appears in the scene',
+        description='The root bone will be transformed as it appears in the scene',
+    )
+    should_override_animation_data: BoolProperty(
+        name='Override Animation Data',
+        options=empty_set,
+        default=False,
+        description='Use the animation data from a different object instead of the selected object'
+    )
+    animation_data_override: PointerProperty(
+        type=bpy.types.Object,
+        poll=psa_export_property_group_animation_data_override_poll
     )
     sequence_source: EnumProperty(
         name='Source',
-        options=set(),
+        options=empty_set,
         description='',
         items=(
             ('ACTIONS', 'Actions', 'Sequences will be exported using actions', 'ACTION', 0),
@@ -83,7 +93,7 @@ class PsaExportPropertyGroup(PropertyGroup):
     )
     fps_source: EnumProperty(
         name='FPS Source',
-        options=set(),
+        options=empty_set,
         description='',
         items=(
             ('SCENE', 'Scene', '', 'SCENE_DATA', 0),
@@ -93,7 +103,7 @@ class PsaExportPropertyGroup(PropertyGroup):
             ('CUSTOM', 'Custom', '', 2)
         )
     )
-    fps_custom: FloatProperty(default=30.0, min=sys.float_info.epsilon, soft_min=1.0, options=set(), step=100,
+    fps_custom: FloatProperty(default=30.0, min=sys.float_info.epsilon, soft_min=1.0, options=empty_set, step=100,
                               soft_max=60.0)
     action_list: CollectionProperty(type=PsaExportActionListItem)
     action_list_index: IntProperty(default=0)
@@ -101,7 +111,7 @@ class PsaExportPropertyGroup(PropertyGroup):
     marker_list_index: IntProperty(default=0)
     bone_filter_mode: EnumProperty(
         name='Bone Filter',
-        options=set(),
+        options=empty_set,
         description='',
         items=(
             ('ALL', 'All', 'All bones will be exported.'),
@@ -114,7 +124,7 @@ class PsaExportPropertyGroup(PropertyGroup):
     should_use_original_sequence_names: BoolProperty(
         default=False,
         name='Original Names',
-        options=set(),
+        options=empty_set,
         update=should_use_original_sequence_names_updated,
         description='If the action was imported from the PSA Import panel, the original name of the sequence will be '
                     'used instead of the Blender action name',
@@ -122,17 +132,28 @@ class PsaExportPropertyGroup(PropertyGroup):
     should_trim_timeline_marker_sequences: BoolProperty(
         default=True,
         name='Trim Sequences',
-        options=set(),
+        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=set())
+    sequence_name_prefix: StringProperty(name='Prefix', options=empty_set)
-    sequence_name_suffix: StringProperty(name='Suffix', options=set())
+    sequence_name_suffix: StringProperty(name='Suffix', options=empty_set)
-    sequence_filter_name: StringProperty(default='', options={'TEXTEDIT_UPDATE'})
+    sequence_filter_name: StringProperty(
-    sequence_use_filter_invert: BoolProperty(default=False, options=set())
+        default='',
-    sequence_filter_asset: BoolProperty(default=False, name='Show assets',
+        name='Filter by Name',
-                                        description='Show actions that belong to an asset library', options=set())
+        options={'TEXTEDIT_UPDATE'},
-    sequence_use_filter_sort_reverse: BoolProperty(default=True, options=set())
+        description='Only show items matching this name (use \'*\' as wildcard)')
+    sequence_use_filter_invert: BoolProperty(
+        default=False,
+        name='Invert',
+        options=empty_set,
+        description='Invert filtering (show hidden items, and vice versa)')
+    sequence_filter_asset: BoolProperty(
+        default=False,
+        name='Show assets',
+        options=empty_set,
+        description='Show actions that belong to an asset library')
+    sequence_use_filter_sort_reverse: BoolProperty(default=True, options=empty_set)
 
 
 def is_bone_filter_mode_item_available(context, identifier):
@@ -159,9 +180,18 @@ class PsaExportOperator(Operator, ExportHelper):
     def __init__(self):
         self.armature = None
 
+    @classmethod
+    def poll(cls, context):
+        try:
+            cls._check_context(context)
+        except RuntimeError as e:
+            cls.poll_message_set(str(e))
+            return False
+        return True
+
     def draw(self, context):
         layout = self.layout
-        pg = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
 
         # FPS
         layout.prop(pg, 'fps_source', text='FPS')
@@ -171,8 +201,11 @@ class PsaExportOperator(Operator, ExportHelper):
         # SOURCE
         layout.prop(pg, 'sequence_source', text='Source')
 
-        # ROOT MOTION
+        if pg.sequence_source == 'TIMELINE_MARKERS':
-        layout.prop(pg, 'root_motion', text='Root Motion')
+            # ANIMDATA SOURCE
+            layout.prop(pg, 'should_override_animation_data')
+            if pg.should_override_animation_data:
+                layout.prop(pg, 'animation_data_override', text='')
 
         # SELECT ALL/NONE
         row = layout.row(align=True)
@@ -184,7 +217,7 @@ class PsaExportOperator(Operator, ExportHelper):
         if pg.sequence_source == 'ACTIONS':
             rows = max(3, min(len(pg.action_list), 10))
 
-            layout.template_list('PSA_UL_ExportActionList', '', pg, 'action_list', pg, 'action_list_index', rows=rows)
+            layout.template_list('PSA_UL_ExportSequenceList', '', pg, 'action_list', pg, 'action_list_index', rows=rows)
 
             col = layout.column()
             col.use_property_split = True
@@ -195,7 +228,7 @@ class PsaExportOperator(Operator, ExportHelper):
 
         elif pg.sequence_source == 'TIMELINE_MARKERS':
             rows = max(3, min(len(pg.marker_list), 10))
-            layout.template_list('PSA_UL_ExportTimelineMarkerList', '', pg, 'marker_list', pg, 'marker_list_index',
+            layout.template_list('PSA_UL_ExportSequenceList', '', pg, 'marker_list', pg, 'marker_list_index',
                                  rows=rows)
 
             col = layout.column()
@@ -229,15 +262,17 @@ class PsaExportOperator(Operator, ExportHelper):
             layout.template_list('PSX_UL_BoneGroupList', '', pg, 'bone_group_list', pg, 'bone_group_list_index',
                                  rows=rows)
 
-    def should_action_be_selected_by_default(self, action):
+        layout.separator()
-        return action is not None and action.asset_data is None
+
+        # ROOT MOTION
+        layout.prop(pg, 'root_motion', text='Root Motion')
 
     def is_action_for_armature(self, action):
         if len(action.fcurves) == 0:
             return False
         bone_names = set([x.name for x in self.armature.data.bones])
         for fcurve in action.fcurves:
-            match = re.match(r'pose\.bones\["(.+)"\].\w+', fcurve.data_path)
+            match = re.match(r'pose\.bones\["(.+)"].\w+', fcurve.data_path)
             if not match:
                 continue
             bone_name = match.group(1)
@@ -245,17 +280,21 @@ class PsaExportOperator(Operator, ExportHelper):
                 return True
         return False
 
-    def invoke(self, context, event):
+    @classmethod
-        pg = context.scene.psa_export
+    def _check_context(cls, context):
-
         if context.view_layer.objects.active is None:
-            self.report({'ERROR_INVALID_CONTEXT'}, 'An armature must be selected')
+            raise RuntimeError('An armature must be selected')
-            return {'CANCELLED'}
 
         if context.view_layer.objects.active.type != 'ARMATURE':
-            self.report({'ERROR_INVALID_CONTEXT'}, 'The selected object must be an armature.')
+            raise RuntimeError('The selected object must be an armature')
-            return {'CANCELLED'}
 
+    def invoke(self, context, _event):
+        try:
+            self._check_context(context)
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+
+        pg = getattr(context.scene, 'psa_export')
         self.armature = context.view_layer.objects.active
 
         # Populate actions list.
@@ -266,7 +305,7 @@ class PsaExportOperator(Operator, ExportHelper):
             item = pg.action_list.add()
             item.action = action
             item.name = action.name
-            item.is_selected = self.should_action_be_selected_by_default(action)
+            item.is_selected = False
 
         update_action_names(context)
 
@@ -275,6 +314,7 @@ class PsaExportOperator(Operator, ExportHelper):
         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.
@@ -289,12 +329,14 @@ class PsaExportOperator(Operator, ExportHelper):
         return {'RUNNING_MODAL'}
 
     def execute(self, context):
-        pg = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
 
         actions = [x.action for x in pg.action_list if x.is_selected]
         marker_names = [x.name for x in pg.marker_list if x.is_selected]
 
-        options = PsaBuilderOptions()
+        options = PsaBuildOptions()
+        options.should_override_animation_data = pg.should_override_animation_data
+        options.animation_data_override = pg.animation_data_override
         options.fps_source = pg.fps_source
         options.fps_custom = pg.fps_custom
         options.sequence_source = pg.sequence_source
@@ -308,56 +350,42 @@ class PsaExportOperator(Operator, ExportHelper):
         options.sequence_name_suffix = pg.sequence_name_suffix
         options.root_motion = pg.root_motion
 
-        builder = PsaBuilder()
-
         try:
-            psa = builder.build(context, options)
+            psa = build_psa(context, options)
+            self.report({'INFO'}, f'PSA export successful')
         except RuntimeError as e:
             self.report({'ERROR_INVALID_CONTEXT'}, str(e))
             return {'CANCELLED'}
 
-        exporter = PsaExporter(psa)
+        export_psa(psa, self.filepath)
-        exporter.export(self.filepath)
+
         return {'FINISHED'}
 
 
-class PSA_UL_ExportTimelineMarkerList(UIList):
+def filter_sequences(pg: PsaExportPropertyGroup, sequences) -> List[int]:
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
-        layout.prop(item, 'is_selected', icon_only=True, text=item.name)
-
-    def filter_items(self, context, data, property):
-        pg = context.scene.psa_export
-        sequences = getattr(data, property)
-        flt_flags = filter_sequences(pg, sequences)
-        flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(sequences, 'name')
-        return flt_flags, flt_neworder
-
-
-def filter_sequences(pg: PsaExportPropertyGroup, sequences: bpy.types.bpy_prop_collection) -> List[int]:
     bitflag_filter_item = 1 << 30
     flt_flags = [bitflag_filter_item] * len(sequences)
 
-    if pg.sequence_filter_name is not None:
+    if pg.sequence_filter_name:
         # Filter name is non-empty.
         for i, sequence in enumerate(sequences):
             if not fnmatch.fnmatch(sequence.name, f'*{pg.sequence_filter_name}*'):
                 flt_flags[i] &= ~bitflag_filter_item
 
+        # Invert filter flags for all items.
+        if pg.sequence_use_filter_invert:
+            for i, sequence in enumerate(sequences):
+                flt_flags[i] ^= bitflag_filter_item
+
     if not pg.sequence_filter_asset:
         for i, sequence in enumerate(sequences):
             if hasattr(sequence, 'action') and sequence.action.asset_data is not None:
                 flt_flags[i] &= ~bitflag_filter_item
 
-    if pg.sequence_use_filter_invert:
-        # Invert filter flags for all items.
-        for i, sequence in enumerate(sequences):
-            flt_flags[i] ^= bitflag_filter_item
-
     return flt_flags
 
 
-def get_visible_sequences(pg: PsaExportPropertyGroup, sequences: bpy.types.bpy_prop_collection) -> List[
+def get_visible_sequences(pg: PsaExportPropertyGroup, sequences) -> List[PsaExportActionListItem]:
-    PsaExportActionListItem]:
     visible_sequences = []
     for i, flag in enumerate(filter_sequences(pg, sequences)):
         if bool(flag & (1 << 30)):
@@ -365,31 +393,33 @@ def get_visible_sequences(pg: PsaExportPropertyGroup, sequences: bpy.types.bpy_p
     return visible_sequences
 
 
-class PSA_UL_ExportActionList(UIList):
+class PSA_UL_ExportSequenceList(UIList):
 
     def __init__(self):
-        super(PSA_UL_ExportActionList, self).__init__()
+        super(PSA_UL_ExportSequenceList, self).__init__()
         # Show the filtering options by default.
         self.use_filter_show = True
 
     def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
         layout.prop(item, 'is_selected', icon_only=True, text=item.name)
-        if item.action.asset_data is not None:
+        if hasattr(item, 'action') and item.action.asset_data is not None:
             layout.label(text='', icon='ASSET_MANAGER')
 
     def draw_filter(self, context, layout):
-        pg = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
         row = layout.row()
         subrow = row.row(align=True)
         subrow.prop(pg, 'sequence_filter_name', text="")
         subrow.prop(pg, 'sequence_use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
-        subrow = row.row(align=True)
-        subrow.prop(pg, 'sequence_filter_asset', icon_only=True, icon='ASSET_MANAGER')
         # subrow.prop(pg, 'sequence_use_filter_sort_reverse', text='', icon='SORT_ASC')
 
-    def filter_items(self, context, data, property):
+        if pg.sequence_source == 'ACTIONS':
-        pg = context.scene.psa_export
+            subrow = row.row(align=True)
-        actions = getattr(data, property)
+            subrow.prop(pg, 'sequence_filter_asset', icon_only=True, icon='ASSET_MANAGER')
+
+    def filter_items(self, context, data, prop):
+        pg = getattr(context.scene, 'psa_export')
+        actions = getattr(data, prop)
         flt_flags = filter_sequences(pg, actions)
         flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(actions, 'name')
         return flt_flags, flt_neworder
@@ -412,14 +442,14 @@ class PsaExportActionsSelectAll(Operator):
 
     @classmethod
     def poll(cls, context):
-        pg = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
         item_list = cls.get_item_list(context)
         visible_sequences = get_visible_sequences(pg, item_list)
         has_unselected_sequences = any(map(lambda item: not item.is_selected, visible_sequences))
         return has_unselected_sequences
 
     def execute(self, context):
-        pg = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
         sequences = self.get_item_list(context)
         for sequence in get_visible_sequences(pg, sequences):
             sequence.is_selected = True
@@ -448,7 +478,7 @@ class PsaExportActionsDeselectAll(Operator):
         return len(item_list) > 0 and has_selected_items
 
     def execute(self, context):
-        pg = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
         item_list = self.get_item_list(context)
         for sequence in get_visible_sequences(pg, item_list):
             sequence.is_selected = False
@@ -463,13 +493,13 @@ class PsaExportBoneGroupsSelectAll(Operator):
 
     @classmethod
     def poll(cls, context):
-        pg = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
         item_list = pg.bone_group_list
         has_unselected_items = any(map(lambda action: not action.is_selected, item_list))
         return len(item_list) > 0 and has_unselected_items
 
     def execute(self, context):
-        pg = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
         for item in pg.bone_group_list:
             item.is_selected = True
         return {'FINISHED'}
@@ -483,13 +513,13 @@ class PsaExportBoneGroupsDeselectAll(Operator):
 
     @classmethod
     def poll(cls, context):
-        pg = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
         item_list = pg.bone_group_list
         has_selected_actions = any(map(lambda action: action.is_selected, item_list))
         return len(item_list) > 0 and has_selected_actions
 
     def execute(self, context):
-        pg = context.scene.psa_export
+        pg = getattr(context.scene, 'psa_export')
         for action in pg.bone_group_list:
             action.is_selected = False
         return {'FINISHED'}
@@ -500,8 +530,7 @@ classes = (
     PsaExportTimelineMarkerListItem,
     PsaExportPropertyGroup,
     PsaExportOperator,
-    PSA_UL_ExportActionList,
+    PSA_UL_ExportSequenceList,
-    PSA_UL_ExportTimelineMarkerList,
     PsaExportActionsSelectAll,
     PsaExportActionsDeselectAll,
     PsaExportBoneGroupsSelectAll,

io_scene_psk_psa/psa/importer.py

@@ -26,14 +26,6 @@ class PsaImportOptions(object):
         self.action_name_prefix = ''
 
 
-class PsaImporter(object):
-    def __init__(self):
-        pass
-
-    def import_psa(self, psa_reader: PsaReader, armature_object, options: PsaImportOptions):
-        sequences = map(lambda x: psa_reader.sequences[x], options.sequence_names)
-        armature_data = armature_object.data
-
 class ImportBone(object):
     def __init__(self, psa_bone: Psa.Bone):
         self.psa_bone: Psa.Bone = psa_bone
@@ -45,6 +37,7 @@ class PsaImporter(object):
         self.post_quat: Quaternion = Quaternion()
         self.fcurves = []
 
+
 def calculate_fcurve_data(import_bone: ImportBone, key_data: []):
     # Convert world-space transforms to local-space transforms.
     key_rotation = Quaternion(key_data[0:4])
@@ -62,6 +55,11 @@ class PsaImporter(object):
     loc.rotate(import_bone.post_quat.conjugated())
     return quat.w, quat.x, quat.y, quat.z, loc.x, loc.y, loc.z
 
+
+def import_psa(psa_reader: PsaReader, armature_object, options: PsaImportOptions):
+    sequences = map(lambda x: psa_reader.sequences[x], options.sequence_names)
+    armature_data = armature_object.data
+
     # Create an index mapping from bones in the PSA to bones in the target armature.
     psa_to_armature_bone_indices = {}
     armature_bone_names = [x.name for x in armature_data.bones]
@@ -104,7 +102,8 @@ class PsaImporter(object):
             import_bone.parent = import_bones_dict[armature_bone.parent.name]
         # Calculate the original location & rotation of each bone (in world-space maybe?)
         if armature_bone.get('orig_quat') is not None:
-                # TODO: ideally we don't rely on bone auxiliary data like this, the non-aux data path is incorrect (animations are flipped 180 around Z)
+            # TODO: ideally we don't rely on bone auxiliary data like this, the non-aux data path is incorrect
+            # (animations are flipped 180 around Z)
             import_bone.orig_quat = Quaternion(armature_bone['orig_quat'])
             import_bone.orig_loc = Vector(armature_bone['orig_loc'])
             import_bone.post_quat = Quaternion(armature_bone['post_quat'])
@@ -179,7 +178,8 @@ class PsaImporter(object):
                         fcurve_frame_data = sequence_data_matrix[:, bone_index, fcurve_index]
                         last_written_datum = 0
                         for frame_index, datum in enumerate(fcurve_frame_data):
-                                # If the f-curve data is not different enough to the last written frame, un-mark this data for writing.
+                            # If 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:
@@ -220,9 +220,12 @@ class PsaImporter(object):
             nla_track.strips.new(name=action.name, start=0, action=action)
 
 
+empty_set = set()
+
+
 class PsaImportActionListItem(PropertyGroup):
-    action_name: StringProperty(options=set())
+    action_name: StringProperty(options=empty_set)
-    is_selected: BoolProperty(default=False, options=set())
+    is_selected: BoolProperty(default=False, options=empty_set)
 
 
 def load_psa_file(context):
@@ -249,7 +252,7 @@ def on_psa_file_path_updated(property, context):
 
 
 class PsaBonePropertyGroup(PropertyGroup):
-    bone_name: StringProperty(options=set())
+    bone_name: StringProperty(options=empty_set)
 
 
 class PsaDataPropertyGroup(PropertyGroup):
@@ -258,37 +261,37 @@ class PsaDataPropertyGroup(PropertyGroup):
 
 
 class PsaImportPropertyGroup(PropertyGroup):
-    psa_file_path: StringProperty(default='', options=set(), update=on_psa_file_path_updated, name='PSA File Path')
+    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=set())
+                                    options=empty_set)
     should_use_fake_user: BoolProperty(default=True, name='Fake User',
                                        description='Assign each imported action a fake user so that the data block is saved even it has no users',
-                                       options=set())
+                                       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=set())
+                               options=empty_set)
-    should_use_action_name_prefix: BoolProperty(default=False, name='Prefix Action Name', options=set())
+    should_use_action_name_prefix: BoolProperty(default=False, name='Prefix Action Name', options=empty_set)
-    action_name_prefix: StringProperty(default='', name='Prefix', options=set())
+    action_name_prefix: StringProperty(default='', name='Prefix', options=empty_set)
-    should_overwrite: BoolProperty(default=False, name='Reuse Existing Actions', options=set(),
+    should_overwrite: BoolProperty(default=False, name='Reuse Existing Actions', options=empty_set,
                                    description='If an action with a matching name already exists, the existing action will have it\'s data overwritten instead of a new action being created')
-    should_write_keyframes: BoolProperty(default=True, name='Keyframes', options=set())
+    should_write_keyframes: BoolProperty(default=True, name='Keyframes', options=empty_set)
-    should_write_metadata: BoolProperty(default=True, name='Metadata', options=set(),
+    should_write_metadata: BoolProperty(default=True, name='Metadata', options=empty_set,
                                         description='Additional data will be written to the custom properties of the Action (e.g., frame rate)')
     sequence_filter_name: StringProperty(default='', options={'TEXTEDIT_UPDATE'})
-    sequence_filter_is_selected: BoolProperty(default=False, options=set(), name='Only Show Selected',
+    sequence_filter_is_selected: BoolProperty(default=False, options=empty_set, name='Only Show Selected',
                                               description='Only show selected sequences')
-    sequence_use_filter_invert: BoolProperty(default=False, options=set())
+    sequence_use_filter_invert: BoolProperty(default=False, options=empty_set)
     sequence_use_filter_regex: BoolProperty(default=False, name='Regular Expression',
-                                            description='Filter using regular expressions', options=set())
+                                            description='Filter using regular expressions', options=empty_set)
     select_text: PointerProperty(type=bpy.types.Text)
 
 
-def filter_sequences(pg: PsaImportPropertyGroup, sequences: bpy.types.bpy_prop_collection) -> List[int]:
+def filter_sequences(pg: PsaImportPropertyGroup, sequences) -> List[int]:
     bitflag_filter_item = 1 << 30
     flt_flags = [bitflag_filter_item] * len(sequences)
 
@@ -322,8 +325,7 @@ def filter_sequences(pg: PsaImportPropertyGroup, sequences: bpy.types.bpy_prop_c
     return flt_flags
 
 
-def get_visible_sequences(pg: PsaImportPropertyGroup, sequences: bpy.types.bpy_prop_collection) -> List[
+def get_visible_sequences(pg: PsaImportPropertyGroup, sequences) -> List[PsaImportActionListItem]:
-    PsaImportActionListItem]:
     bitflag_filter_item = 1 << 30
     visible_sequences = []
     for i, flag in enumerate(filter_sequences(pg, sequences)):
@@ -333,26 +335,25 @@ def get_visible_sequences(pg: PsaImportPropertyGroup, sequences: bpy.types.bpy_p
 
 
 class PSA_UL_SequenceList(UIList):
-
+    def draw_item(self, context, layout, data, item, icon, active_data, active_property, index, flt_flag):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
         row = layout.row(align=True)
         split = row.split(align=True, factor=0.75)
         column = split.row(align=True)
         column.alignment = 'LEFT'
         column.prop(item, 'is_selected', icon_only=True)
-        column.label(text=item.action_name)
+        column.label(text=getattr(item, 'action_name'))
 
     def draw_filter(self, context, layout):
-        pg = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
         row = layout.row()
-        subrow = row.row(align=True)
+        sub_row = row.row(align=True)
-        subrow.prop(pg, 'sequence_filter_name', text="")
+        sub_row.prop(pg, 'sequence_filter_name', text="")
-        subrow.prop(pg, 'sequence_use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
+        sub_row.prop(pg, 'sequence_use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
-        subrow.prop(pg, 'sequence_use_filter_regex', text="", icon='SORTBYEXT')
+        sub_row.prop(pg, 'sequence_use_filter_regex', text="", icon='SORTBYEXT')
-        subrow.prop(pg, 'sequence_filter_is_selected', text="", icon='CHECKBOX_HLT')
+        sub_row.prop(pg, 'sequence_filter_is_selected', text="", icon='CHECKBOX_HLT')
 
     def filter_items(self, context, data, property):
-        pg = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
         sequences = getattr(data, property)
         flt_flags = filter_sequences(pg, sequences)
         flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(sequences, 'action_name')
@@ -375,7 +376,7 @@ class PsaImportSequencesFromText(Operator):
 
     @classmethod
     def poll(cls, context):
-        pg = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
         return len(pg.sequence_list) > 0
 
     def invoke(self, context, event):
@@ -383,12 +384,15 @@ class PsaImportSequencesFromText(Operator):
 
     def draw(self, context):
         layout = self.layout
-        pg = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
         layout.label(icon='INFO', text='Each sequence name should be on a new line.')
         layout.prop(pg, 'select_text', text='')
 
     def execute(self, context):
-        pg = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
+        if pg.select_text is None:
+            self.report({'ERROR_INVALID_CONTEXT'}, 'No text block selected')
+            return {'CANCELLED'}
         contents = pg.select_text.as_string()
         count = 0
         for line in contents.split('\n'):
@@ -403,18 +407,18 @@ class PsaImportSequencesFromText(Operator):
 class PsaImportSequencesSelectAll(Operator):
     bl_idname = 'psa_import.sequences_select_all'
     bl_label = 'All'
-    bl_description = 'Select all visible sequences'
+    bl_description = 'Select all sequences'
     bl_options = {'INTERNAL'}
 
     @classmethod
     def poll(cls, context):
-        pg = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
         visible_sequences = get_visible_sequences(pg, pg.sequence_list)
         has_unselected_actions = any(map(lambda action: not action.is_selected, visible_sequences))
         return len(visible_sequences) > 0 and has_unselected_actions
 
     def execute(self, context):
-        pg = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
         visible_sequences = get_visible_sequences(pg, pg.sequence_list)
         for sequence in visible_sequences:
             sequence.is_selected = True
@@ -429,13 +433,13 @@ class PsaImportSequencesDeselectAll(Operator):
 
     @classmethod
     def poll(cls, context):
-        pg = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
         visible_sequences = get_visible_sequences(pg, pg.sequence_list)
         has_selected_sequences = any(map(lambda sequence: sequence.is_selected, visible_sequences))
         return len(visible_sequences) > 0 and has_selected_sequences
 
     def execute(self, context):
-        pg = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
         visible_sequences = get_visible_sequences(pg, pg.sequence_list)
         for sequence in visible_sequences:
             sequence.is_selected = False
@@ -451,7 +455,7 @@ class PSA_PT_ImportPanel_Advanced(Panel):
 
     def draw(self, context):
         layout = self.layout
-        pg = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
 
         col = layout.column(heading="Options")
         col.use_property_split = True
@@ -476,11 +480,11 @@ class PSA_PT_ImportPanel(Panel):
 
     @classmethod
     def poll(cls, context):
-        return context.object.type == 'ARMATURE'
+        return context.view_layer.objects.active.type == 'ARMATURE'
 
     def draw(self, context):
         layout = self.layout
-        pg = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
 
         row = layout.row(align=True)
         row.operator(PsaImportSelectFile.bl_idname, text='', icon='FILEBROWSER')
@@ -552,7 +556,7 @@ class PsaImportSelectFile(Operator):
     filter_glob: bpy.props.StringProperty(default="*.psa", options={'HIDDEN'})
 
     def execute(self, context):
-        context.scene.psa_import.psa_file_path = self.filepath
+        getattr(context.scene, 'psa_import').psa_file_path = self.filepath
         return {"FINISHED"}
 
     def invoke(self, context, event):
@@ -568,14 +572,14 @@ class PsaImportOperator(Operator):
 
     @classmethod
     def poll(cls, context):
-        pg = context.scene.psa_import
+        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 = context.scene.psa_import
+        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]
 
@@ -589,7 +593,7 @@ class PsaImportOperator(Operator):
         options.should_write_metadata = pg.should_write_metadata
         options.should_write_keyframes = pg.should_write_keyframes
 
-        PsaImporter().import_psa(psa_reader, context.view_layer.objects.active, options)
+        import_psa(psa_reader, context.view_layer.objects.active, options)
 
         self.report({'INFO'}, f'Imported {len(sequence_names)} action(s)')
 
@@ -613,7 +617,7 @@ class PsaImportFileSelectOperator(Operator, ImportHelper):
         return {'RUNNING_MODAL'}
 
     def execute(self, context):
-        pg = context.scene.psa_import
+        pg = getattr(context.scene, 'psa_import')
         pg.psa_file_path = self.filepath
         return {'FINISHED'}
 

io_scene_psk_psa/psa/reader.py

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

io_scene_psk_psa/psk/builder.py

@@ -1,7 +1,10 @@
 from collections import OrderedDict
+from typing import Dict, List
 
 from .data import *
 from ..helpers import *
+import bmesh
+import bpy
 
 
 class PskInputObjects(object):
@@ -10,43 +13,40 @@ class PskInputObjects(object):
         self.armature_object = None
 
 
-class PskBuilderOptions(object):
+class PskBuildOptions(object):
     def __init__(self):
         self.bone_filter_mode = 'ALL'
-        self.bone_group_indices = []
+        self.bone_group_indices: List[int] = []
+        self.use_raw_mesh_data = True
+        self.material_names: List[str] = []
 
 
-class PskBuilder(object):
+def get_psk_input_objects(context) -> PskInputObjects:
-    def __init__(self):
-        pass
-
-    @staticmethod
-    def get_input_objects(context) -> PskInputObjects:
     input_objects = PskInputObjects()
-        for obj in context.view_layer.objects.selected:
+    for selected_object in context.view_layer.objects.selected:
-            if obj.type != 'MESH':
+        if selected_object.type != 'MESH':
-                raise RuntimeError(f'Selected object "{obj.name}" is not a mesh')
+            raise RuntimeError(f'Selected object "{selected_object.name}" is not a mesh')
 
     input_objects.mesh_objects = context.view_layer.objects.selected
 
     if len(input_objects.mesh_objects) == 0:
         raise RuntimeError('At least one mesh must be selected')
 
-        for obj in input_objects.mesh_objects:
+    for mesh_object in input_objects.mesh_objects:
-            if len(obj.data.materials) == 0:
+        if len(mesh_object.data.materials) == 0:
-                raise RuntimeError(f'Mesh "{obj.name}" must have at least one material')
+            raise RuntimeError(f'Mesh "{mesh_object.name}" must have at least one material')
 
     # Ensure that there are either no armature modifiers (static mesh)
     # or that there is exactly one armature modifier object shared between
     # all selected meshes
     armature_modifier_objects = set()
 
-        for obj in input_objects.mesh_objects:
+    for mesh_object in input_objects.mesh_objects:
-            modifiers = [x for x in obj.modifiers if x.type == 'ARMATURE']
+        modifiers = [x for x in mesh_object.modifiers if x.type == 'ARMATURE']
         if len(modifiers) == 0:
             continue
         elif len(modifiers) > 1:
-                raise RuntimeError(f'Mesh "{obj.name}" must have only one armature modifier')
+            raise RuntimeError(f'Mesh "{mesh_object.name}" must have only one armature modifier')
         armature_modifier_objects.add(modifiers[0].object)
 
     if len(armature_modifier_objects) > 1:
@@ -56,14 +56,14 @@ class PskBuilder(object):
 
     return input_objects
 
-    def build(self, context, options: PskBuilderOptions) -> Psk:
+
-        input_objects = PskBuilder.get_input_objects(context)
+def build_psk(context, options: PskBuildOptions) -> Psk:
+    input_objects = get_psk_input_objects(context)
 
     armature_object = input_objects.armature_object
 
     psk = Psk()
     bones = []
-        materials = OrderedDict()
 
     if armature_object is None:
         # If the mesh has no armature object, simply assign it a dummy bone at the root to satisfy the requirement
@@ -80,6 +80,9 @@ class PskBuilder(object):
         bone_names = get_export_bone_names(armature_object, options.bone_filter_mode, options.bone_group_indices)
         bones = [armature_object.data.bones[bone_name] for bone_name in bone_names]
 
+        # Check that all bone names are valid.
+        check_bone_names(map(lambda x: x.name, bones))
+
         for bone in bones:
             psk_bone = Psk.Bone()
             psk_bone.name = bytes(bone.name, encoding='windows-1252')
@@ -91,71 +94,92 @@ class PskBuilder(object):
                 psk_bone.parent_index = parent_index
                 psk.bones[parent_index].children_count += 1
             except ValueError:
-                    psk_bone.parent_index = 0
+                psk_bone.parent_index = -1
 
             if bone.parent is not None:
-                    rotation = bone.matrix.to_quaternion()
+                rotation = bone.matrix.to_quaternion().conjugated()
-                    rotation.x = -rotation.x
-                    rotation.y = -rotation.y
-                    rotation.z = -rotation.z
                 quat_parent = bone.parent.matrix.to_quaternion().inverted()
                 parent_head = quat_parent @ bone.parent.head
                 parent_tail = quat_parent @ bone.parent.tail
                 location = (parent_tail - parent_head) + bone.head
             else:
-                    location = armature_object.matrix_local @ bone.head
+                local_matrix = armature_object.matrix_local
-                    rot_matrix = bone.matrix @ armature_object.matrix_local.to_3x3()
+                location = local_matrix @ bone.head
+                rot_matrix = bone.matrix @ local_matrix.to_3x3()
                 rotation = rot_matrix.to_quaternion()
 
             psk_bone.location.x = location.x
             psk_bone.location.y = location.y
             psk_bone.location.z = location.z
 
+            psk_bone.rotation.w = rotation.w
             psk_bone.rotation.x = rotation.x
             psk_bone.rotation.y = rotation.y
             psk_bone.rotation.z = rotation.z
-                psk_bone.rotation.w = rotation.w
 
             psk.bones.append(psk_bone)
 
-        for object in input_objects.mesh_objects:
+    # MATERIALS
+    material_names = options.material_names
+
+    for material_name in material_names:
+        psk_material = Psk.Material()
+        psk_material.name = bytes(material_name, encoding='windows-1252')
+        psk_material.texture_index = len(psk.materials)
+        psk.materials.append(psk_material)
+
+    for input_mesh_object in input_objects.mesh_objects:
+
+        # MATERIALS
+        material_indices = [material_names.index(material.name) for material in input_mesh_object.data.materials]
+
+        if options.use_raw_mesh_data:
+            mesh_object = input_mesh_object
+            mesh_data = input_mesh_object.data
+        else:
+            # Create a copy of the mesh object after non-armature modifiers are applied.
+
+            # Temporarily deactivate any armature modifiers on the input mesh object.
+            active_armature_modifiers = [x for x in filter(lambda x: x.type == 'ARMATURE' and x.is_active, input_mesh_object.modifiers)]
+            for modifier in active_armature_modifiers:
+                modifier.show_viewport = False
+
+            depsgraph = context.evaluated_depsgraph_get()
+            bm = bmesh.new()
+            bm.from_object(input_mesh_object, depsgraph)
+            mesh_data = bpy.data.meshes.new('')
+            bm.to_mesh(mesh_data)
+            del bm
+            mesh_object = bpy.data.objects.new('', mesh_data)
+            mesh_object.matrix_world = input_mesh_object.matrix_world
+
+            # Copy the vertex groups
+            for vertex_group in input_mesh_object.vertex_groups:
+                mesh_object.vertex_groups.new(name=vertex_group.name)
+
+            # Reactivate previously active armature modifiers
+            for modifier in active_armature_modifiers:
+                modifier.show_viewport = True
+
         vertex_offset = len(psk.points)
 
         # VERTICES
-            for vertex in object.data.vertices:
+        for vertex in mesh_data.vertices:
             point = Vector3()
-                v = object.matrix_world @ vertex.co
+            v = mesh_object.matrix_world @ vertex.co
             point.x = v.x
             point.y = v.y
             point.z = v.z
             psk.points.append(point)
 
-            uv_layer = object.data.uv_layers.active.data
+        uv_layer = mesh_data.uv_layers.active.data
-
-            # MATERIALS
-            material_indices = []
-            for i, m in enumerate(object.data.materials):
-                if m is None:
-                    raise RuntimeError('Material cannot be empty (index ' + str(i) + ')')
-                if m.name in materials:
-                    # Material already evaluated, just get its index.
-                    material_index = list(materials.keys()).index(m.name)
-                else:
-                    # New material.
-                    material = Psk.Material()
-                    material.name = bytes(m.name, encoding='utf-8')
-                    material.texture_index = len(psk.materials)
-                    psk.materials.append(material)
-                    materials[m.name] = m
-                    material_index = material.texture_index
-                material_indices.append(material_index)
 
         # WEDGES
-            object.data.calc_loop_triangles()
+        mesh_data.calc_loop_triangles()
 
         # Build a list of non-unique wedges.
         wedges = []
-            for loop_index, loop in enumerate(object.data.loops):
+        for loop_index, loop in enumerate(mesh_data.loops):
             wedge = Psk.Wedge()
             wedge.point_index = loop.vertex_index + vertex_offset
             wedge.u, wedge.v = uv_layer[loop_index].uv
@@ -163,13 +187,13 @@ class PskBuilder(object):
             wedges.append(wedge)
 
         # Assign material indices to the wedges.
-            for triangle in object.data.loop_triangles:
+        for triangle in mesh_data.loop_triangles:
             for loop_index in triangle.loops:
                 wedges[loop_index].material_index = material_indices[triangle.material_index]
 
         # Populate the list of wedges with unique wedges & build a look-up table of loop indices to wedge indices
         wedge_indices = {}
-            loop_wedge_indices = [-1] * len(object.data.loops)
+        loop_wedge_indices = [-1] * len(mesh_data.loops)
         for loop_index, wedge in enumerate(wedges):
             wedge_hash = hash(wedge)
             if wedge_hash in wedge_indices:
@@ -181,8 +205,8 @@ class PskBuilder(object):
                 loop_wedge_indices[loop_index] = wedge_index
 
         # FACES
-            poly_groups, groups = object.data.calc_smooth_groups(use_bitflags=True)
+        poly_groups, groups = mesh_data.calc_smooth_groups(use_bitflags=True)
-            for f in object.data.loop_triangles:
+        for f in mesh_data.loop_triangles:
             face = Psk.Face()
             face.material_index = material_indices[f.material_index]
             face.wedge_indices[0] = loop_wedge_indices[f.loops[2]]
@@ -196,7 +220,7 @@ class PskBuilder(object):
             # Because the vertex groups may contain entries for which there is no matching bone in the armature,
             # we must filter them out and not export any weights for these vertex groups.
             bone_names = [x.name for x in bones]
-                vertex_group_names = [x.name for x in object.vertex_groups]
+            vertex_group_names = [x.name for x in mesh_object.vertex_groups]
             vertex_group_bone_indices = dict()
             for vertex_group_index, vertex_group_name in enumerate(vertex_group_names):
                 try:
@@ -215,12 +239,12 @@ class PskBuilder(object):
                                 break
                             except ValueError:
                                 bone = bone.parent
-                for vertex_group_index, vertex_group in enumerate(object.vertex_groups):
+            for vertex_group_index, vertex_group in enumerate(mesh_object.vertex_groups):
                 if vertex_group_index not in vertex_group_bone_indices:
                     # Vertex group has no associated bone, skip it.
                     continue
                 bone_index = vertex_group_bone_indices[vertex_group_index]
-                    for vertex_index in range(len(object.data.vertices)):
+                for vertex_index in range(len(mesh_data.vertices)):
                     try:
                         weight = vertex_group.weight(vertex_index)
                     except RuntimeError:
@@ -233,4 +257,9 @@ class PskBuilder(object):
                     w.weight = weight
                     psk.weights.append(w)
 
+        if not options.use_raw_mesh_data:
+            bpy.data.objects.remove(mesh_object)
+            bpy.data.meshes.remove(mesh_data)
+            del mesh_data
+
     return psk

io_scene_psk_psa/psk/exporter.py

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

io_scene_psk_psa/psk/importer.py

@@ -1,36 +1,55 @@
 import os
 import sys
 from math import inf
-from typing import Optional
+from typing import Optional, List
 
 import bmesh
 import bpy
 import numpy as np
 from bpy.props import BoolProperty, EnumProperty, FloatProperty, StringProperty
-from bpy.types import Operator, PropertyGroup
+from bpy.types import Operator, PropertyGroup, VertexGroup
 from bpy_extras.io_utils import ImportHelper
 from mathutils import Quaternion, Vector, Matrix
 
 from .data import Psk
-from .reader import PskReader
+from .reader import read_psk
 from ..helpers import rgb_to_srgb
 
 
 class PskImportOptions(object):
     def __init__(self):
         self.name = ''
+        self.should_import_mesh = True
         self.should_import_vertex_colors = True
         self.vertex_color_space = 'sRGB'
         self.should_import_vertex_normals = True
         self.should_import_extra_uvs = True
+        self.should_import_skeleton = True
         self.bone_length = 1.0
 
 
-class PskImporter(object):
+class ImportBone(object):
-    def __init__(self):
+    """
-        pass
+    Intermediate bone type for the purpose of construction.
+    """
+    def __init__(self, index: int, psk_bone: Psk.Bone):
+        self.index: int = index
+        self.psk_bone: Psk.Bone = psk_bone
+        self.parent: Optional[ImportBone] = None
+        self.local_rotation: Quaternion = Quaternion()
+        self.local_translation: Vector = Vector()
+        self.world_rotation_matrix: Matrix = Matrix()
+        self.world_matrix: Matrix = Matrix()
+        self.vertex_group = None
+        self.orig_quat: Quaternion = Quaternion()
+        self.orig_loc: Vector = Vector()
+        self.post_quat: Quaternion = Quaternion()
 
-    def import_psk(self, psk: Psk, context, options: PskImportOptions):
+
+def import_psk(psk: Psk, context, options: PskImportOptions):
+    armature_object = None
+
+    if options.should_import_skeleton:
         # ARMATURE
         armature_data = bpy.data.armatures.new(options.name)
         armature_object = bpy.data.objects.new(options.name, armature_data)
@@ -48,21 +67,6 @@ class PskImporter(object):
 
         bpy.ops.object.mode_set(mode='EDIT')
 
-        # Intermediate bone type for the purpose of construction.
-        class ImportBone(object):
-            def __init__(self, index: int, psk_bone: Psk.Bone):
-                self.index: int = index
-                self.psk_bone: Psk.Bone = psk_bone
-                self.parent: Optional[ImportBone] = None
-                self.local_rotation: Quaternion = Quaternion()
-                self.local_translation: Vector = Vector()
-                self.world_rotation_matrix: Matrix = Matrix()
-                self.world_matrix: Matrix = Matrix()
-                self.vertex_group = None
-                self.orig_quat: Quaternion = Quaternion()
-                self.orig_loc: Vector = Vector()
-                self.post_quat: Quaternion = Quaternion()
-
         import_bones = []
 
         for bone_index, psk_bone in enumerate(psk.bones):
@@ -110,6 +114,7 @@ class PskImporter(object):
             edit_bone['post_quat'] = import_bone.local_rotation.conjugated()
 
     # MESH
+    if options.should_import_mesh:
         mesh_data = bpy.data.meshes.new(options.name)
         mesh_object = bpy.data.objects.new(options.name, mesh_data)
 
@@ -211,36 +216,40 @@ class PskImporter(object):
 
         # Get a list of all bones that have weights associated with them.
         vertex_group_bone_indices = set(map(lambda weight: weight.bone_index, psk.weights))
-        for import_bone in map(lambda x: import_bones[x], sorted(list(vertex_group_bone_indices))):
+        vertex_groups: List[Optional[VertexGroup]] = [None] * len(psk.bones)
-            import_bone.vertex_group = mesh_object.vertex_groups.new(
+        for bone_index, psk_bone in map(lambda x: (x, psk.bones[x]), vertex_group_bone_indices):
-                name=import_bone.psk_bone.name.decode('windows-1252'))
+            vertex_groups[bone_index] = mesh_object.vertex_groups.new(name=psk_bone.name.decode('windows-1252'))
 
         for weight in psk.weights:
-            import_bones[weight.bone_index].vertex_group.add((weight.point_index,), weight.weight, 'ADD')
+            vertex_groups[weight.bone_index].add((weight.point_index,), weight.weight, 'ADD')
+
+        context.scene.collection.objects.link(mesh_object)
 
         # Add armature modifier to our mesh object.
+        if options.should_import_skeleton:
             armature_modifier = mesh_object.modifiers.new(name='Armature', type='ARMATURE')
             armature_modifier.object = armature_object
             mesh_object.parent = armature_object
 
-        context.scene.collection.objects.link(mesh_object)
-
     try:
         bpy.ops.object.mode_set(mode='OBJECT')
     except:
         pass
 
 
+empty_set = set()
+
+
 class PskImportPropertyGroup(PropertyGroup):
     should_import_vertex_colors: BoolProperty(
         default=True,
-        options=set(),
+        options=empty_set,
         name='Vertex Colors',
         description='Import vertex colors from PSKX files, if available'
     )
     vertex_color_space: EnumProperty(
         name='Vertex Color Space',
-        options=set(),
+        options=empty_set,
         description='The source vertex color space',
         default='SRGBA',
         items=(
@@ -251,29 +260,41 @@ class PskImportPropertyGroup(PropertyGroup):
     should_import_vertex_normals: BoolProperty(
         default=True,
         name='Vertex Normals',
-        options=set(),
+        options=empty_set,
         description='Import vertex normals from PSKX files, if available'
     )
     should_import_extra_uvs: BoolProperty(
         default=True,
         name='Extra UVs',
-        options=set(),
+        options=empty_set,
         description='Import extra UV maps from PSKX files, if available'
     )
+    should_import_mesh: BoolProperty(
+        default=True,
+        name='Import Mesh',
+        options=empty_set,
+        description='Import mesh'
+    )
+    should_import_skeleton: BoolProperty(
+        default=True,
+        name='Import Skeleton',
+        options=empty_set,
+        description='Import skeleton'
+    )
     bone_length: FloatProperty(
         default=1.0,
         min=sys.float_info.epsilon,
         step=100,
         soft_min=1.0,
         name='Bone Length',
-        options=set(),
+        options=empty_set,
         description='Length of the bones'
     )
 
 
 class PskImportOperator(Operator, ImportHelper):
     bl_idname = 'import.psk'
-    bl_label = 'Export'
+    bl_label = 'Import'
     bl_options = {'INTERNAL', 'UNDO'}
     __doc__ = 'Load a PSK file'
     filename_ext = '.psk'
@@ -285,30 +306,43 @@ class PskImportOperator(Operator, ImportHelper):
         default='')
 
     def execute(self, context):
-        pg = context.scene.psk_import
+        pg = getattr(context.scene, 'psk_import')
-        reader = PskReader()
+
-        psk = reader.read(self.filepath)
+        psk = read_psk(self.filepath)
+
         options = PskImportOptions()
         options.name = os.path.splitext(os.path.basename(self.filepath))[0]
+        options.should_import_mesh = pg.should_import_mesh
         options.should_import_extra_uvs = pg.should_import_extra_uvs
         options.should_import_vertex_colors = pg.should_import_vertex_colors
         options.should_import_vertex_normals = pg.should_import_vertex_normals
         options.vertex_color_space = pg.vertex_color_space
+        options.should_import_skeleton = pg.should_import_skeleton
         options.bone_length = pg.bone_length
-        PskImporter().import_psk(psk, context, options)
+
+        import_psk(psk, context, options)
+
         return {'FINISHED'}
 
     def draw(self, context):
-        pg = context.scene.psk_import
+        pg = getattr(context.scene, 'psk_import')
         layout = self.layout
-        layout.use_property_split = True
+        layout.prop(pg, 'should_import_mesh')
-        layout.use_property_decorate = False
+        row = layout.column()
-        layout.prop(pg, 'should_import_vertex_normals')
+        row.use_property_split = True
-        layout.prop(pg, 'should_import_extra_uvs')
+        row.use_property_decorate = False
-        layout.prop(pg, 'should_import_vertex_colors')
+        if pg.should_import_mesh:
+            row.prop(pg, 'should_import_vertex_normals')
+            row.prop(pg, 'should_import_extra_uvs')
+            row.prop(pg, 'should_import_vertex_colors')
             if pg.should_import_vertex_colors:
-            layout.prop(pg, 'vertex_color_space')
+                row.prop(pg, 'vertex_color_space')
-        layout.prop(pg, 'bone_length')
+        layout.prop(pg, 'should_import_skeleton')
+        row = layout.column()
+        row.use_property_split = True
+        row.use_property_decorate = False
+        if pg.should_import_skeleton:
+            row.prop(pg, 'bone_length')
 
 
 classes = (

io_scene_psk_psa/psk/reader.py

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

io_scene_psk_psa/types.py

@@ -1,12 +1,14 @@
 from bpy.props import StringProperty, IntProperty, BoolProperty
-from bpy.types import PropertyGroup, UIList
+from bpy.types import PropertyGroup, UIList, UILayout, Context, AnyType
 
 
 class PSX_UL_BoneGroupList(UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
+
+    def draw_item(self, context: Context, layout: UILayout, data: AnyType, item: AnyType, icon: int,
+                  active_data: AnyType, active_property: str, index: int = 0, flt_flag: int = 0):
         row = layout.row()
-        row.prop(item, 'is_selected', text=item.name)
+        row.prop(item, 'is_selected', text=getattr(item, 'name'))
-        row.label(text=str(item.count), icon='BONE_DATA')
+        row.label(text=str(getattr(item, 'count')), icon='BONE_DATA')
 
 
 class BoneGroupListItem(PropertyGroup):
@@ -15,10 +17,6 @@ class BoneGroupListItem(PropertyGroup):
     count: IntProperty()
     is_selected: BoolProperty(default=False)
 
-    @property
-    def name(self):
-        return self.name
-
 
 classes = (
     BoneGroupListItem,