Incremented version to 4.2.0

This allows imported PSA actions to map to armature bones with names
that differ only by case.

In addition, import warnings are now written to the info log so they
have better visibility to the user.

README.md

@@ -1,4 +1,13 @@
-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). In addition, the non-standard PSKX format is also supported for import only.
+This Blender 2.80+ add-on allows you to import and export meshes and animations to and from the [PSK and PSA file formats](https://wiki.beyondunreal.com/PSK_%26_PSA_file_formats) used in many version of the Unreal Engine.
+
+# Features
+* Full PSK/PSA import and export capabilities
+* Non-standard PSKX file format with vertex normals, extra UV channels and vertex colors is supported for import only
+* Fine-grained PSA sequence importing for efficient workflow when working with large PSA files
+* Automatic keyframe reduction on PSA import
+* PSA sequence metadata (e.g., frame rate, sequence name) is preserved on import, allowing this data to be reused on export
+* Specific [bone groups](https://docs.blender.org/manual/en/latest/animation/armatures/properties/bone_groups.html) can be excluded from PSK/PSA export (useful for excluding non-contributing bones such as IK controllers)
+* PSA sequences can be exported directly from actions or delineated using a scene's [timeline markers](https://docs.blender.org/manual/en/latest/animation/markers.html), allowing direct use of the [NLA](https://docs.blender.org/manual/en/latest/editors/nla/index.html) when creating sequences 
 
 # Installation
 1. Download the zip file for the latest version from the [releases](https://github.com/DarklightGames/io_export_psk_psa/releases) page.

io_scene_psk_psa/__init__.py

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

io_scene_psk_psa/helpers.py

@@ -1,8 +1,10 @@
 import datetime
+import re
 from collections import Counter
-from typing import List
+from typing import List, Iterable
 
-from bpy.types import NlaStrip
+import bpy.types
+from bpy.types import NlaStrip, Object
 
 
 class Timer:
@@ -30,22 +32,11 @@ def rgb_to_srgb(c):
         return 12.92 * c
 
 
-def get_nla_strips_ending_at_frame(object, frame) -> List[NlaStrip]:
-    if object is None or object.animation_data is None:
+def get_nla_strips_in_timeframe(animation_data, frame_min, frame_max) -> List[NlaStrip]:
+    if animation_data is None:
         return []
     strips = []
-    for nla_track in object.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:
+    for nla_track in animation_data.nla_tracks:
         if nla_track.mute:
             continue
         for strip in nla_track.strips:
@@ -56,7 +47,26 @@ def get_nla_strips_in_timeframe(object, frame_min, frame_max) -> List[NlaStrip]:
     return strips
 
 
-def populate_bone_group_list(armature_object, bone_group_list):
+def populate_bone_group_list(armature_object: Object, bone_group_list: bpy.props.CollectionProperty) -> None:
+    """
+    Updates the bone group collection.
+
+    Bone group selections are preserved between updates unless none of the groups were previously selected;
+    otherwise, all groups are selected by default.
+    """
+    has_selected_groups = any([g.is_selected for g in bone_group_list])
+    unassigned_group_is_selected, selected_assigned_group_names = True, []
+
+    if has_selected_groups:
+        # Preserve group selections before clearing the list.
+        # We handle selections for the unassigned group separately to cover the edge case
+        # where there might be an actual group with 'Unassigned' as its name.
+        unassigned_group_idx, unassigned_group_is_selected = next(iter([
+            (i, g.is_selected) for i, g in enumerate(bone_group_list) if g.index == -1]), (-1, False))
+
+        selected_assigned_group_names = [
+            g.name for i, g in enumerate(bone_group_list) if i != unassigned_group_idx and g.is_selected]
+
     bone_group_list.clear()
 
     if armature_object and armature_object.pose:
@@ -66,14 +76,14 @@ def populate_bone_group_list(armature_object, bone_group_list):
         item.name = 'Unassigned'
         item.index = -1
         item.count = 0 if None not in bone_group_counts else bone_group_counts[None]
-        item.is_selected = True
+        item.is_selected = unassigned_group_is_selected
 
         for bone_group_index, bone_group in enumerate(armature_object.pose.bone_groups):
             item = bone_group_list.add()
             item.name = bone_group.name
             item.index = bone_group_index
             item.count = 0 if bone_group not in bone_group_counts else bone_group_counts[bone_group]
-            item.is_selected = True
+            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):
@@ -83,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-Z\d_\- ]+$')
+    invalid_bone_names = [x for x in bone_names if pattern.match(x) is None]
+    if len(invalid_bone_names) > 0:
+        raise RuntimeError(f'The following bone names are invalid: {invalid_bone_names}.\n'
+                           f'Bone names must only contain letters, numbers, spaces, hyphens and underscores.')
+
+
 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,13 +1,15 @@
-from typing import Dict, Iterable
+from typing import Dict
 
-from bpy.types import Action
+from bpy.types import Action, Armature, Bone
 
 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'
@@ -17,22 +19,13 @@ class PsaBuilderOptions(object):
         self.bone_group_indices = []
         self.should_use_original_sequence_names = False
         self.should_trim_timeline_marker_sequences = True
+        self.should_ignore_bone_name_restrictions = False
         self.sequence_name_prefix = ''
         self.sequence_name_suffix = ''
+        self.root_motion = False
 
 
-class PsaBuilderPerformance:
-    def __init__(self):
-        self.frame_set_duration = datetime.timedelta()
-        self.key_build_duration = datetime.timedelta()
-        self.key_add_duration = datetime.timedelta()
-
-
-class PsaBuilder(object):
-    def __init__(self):
-        pass
-
-    def get_sequence_fps(self, context, options: PsaBuilderOptions, actions: Iterable[Action]) -> float:
+def get_sequence_fps(context, options: PsaBuildOptions, actions: Iterable[Action]) -> float:
     if options.fps_source == 'SCENE':
         return context.scene.render.fps
     if options.fps_source == 'CUSTOM':
@@ -52,17 +45,64 @@ class PsaBuilder(object):
     else:
         raise RuntimeError(f'Invalid FPS source "{options.fps_source}"')
 
-    def build(self, context, options: PsaBuilderOptions) -> Psa:
-        performance = PsaBuilderPerformance()
+
+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: 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')
 
-        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:
-            raise RuntimeError('No animation data for armature')
+    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:
@@ -72,18 +112,20 @@ class PsaBuilder(object):
 
     psa = Psa()
 
-        bones = list(armature.data.bones)
+    armature_object = active_object
+    armature_data = typing.cast(Armature, armature_object.data)
+    bones: List[Bone] = list(iter(armature_data.bones))
 
     # The order of the armature bones and the pose bones is not guaranteed to be the same.
-        # As as a result, we need to reconstruct the list of pose bones in the same order as the
+    # As a result, we need to reconstruct the list of pose bones in the same order as the
     # armature bones.
     bone_names = [x.name for x in bones]
-        pose_bones = [(bone_names.index(bone.name), bone) for bone in armature.pose.bones]
+    pose_bones = [(bone_names.index(bone.name), bone) for bone in armature_object.pose.bones]
     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.
@@ -94,10 +136,14 @@ class PsaBuilder(object):
     if len(bones) == 0:
         raise RuntimeError('No bones available for export')
 
+    # Check that all bone names are valid.
+    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:
         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)
@@ -107,18 +153,18 @@ class PsaBuilder(object):
             psa_bone.parent_index = -1
 
         if bone.parent is not None:
-                rotation = bone.matrix.to_quaternion()
-                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
+            rotation = bone.matrix.to_quaternion().conjugated()
+            inverse_parent_rotation = bone.parent.matrix.to_quaternion().inverted()
+            parent_head = inverse_parent_rotation @ bone.parent.head
+            parent_tail = inverse_parent_rotation @ bone.parent.tail
             location = (parent_tail - parent_head) + bone.head
         else:
-                location = armature.matrix_local @ bone.head
-                rot_matrix = bone.matrix @ armature.matrix_local.to_3x3()
-                rotation = rot_matrix.to_quaternion()
+            armature_local_matrix = armature_object.matrix_local
+            location = armature_local_matrix @ bone.head
+            bone_rotation = bone.matrix.to_quaternion().conjugated()
+            local_rotation = armature_local_matrix.to_3x3().to_quaternion().conjugated()
+            rotation = bone_rotation @ local_rotation
+            rotation.conjugate()
 
         psa_bone.location.x = location.x
         psa_bone.location.y = location.y
@@ -156,11 +202,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()
@@ -168,59 +214,64 @@ class PsaBuilder(object):
             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(active_object, frame_min, frame_max)))
-                export_sequence.fps = self.get_sequence_fps(context, options, nla_strips_actions)
+                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:
-            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()
+
+    # 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 = 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:
-            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):
-                with Timer() as t:
             context.scene.frame_set(frame_min + frame)
-                performance.frame_set_duration += t.duration
 
             for pose_bone in pose_bones:
-                    with Timer() as t:
                 key = Psa.Key()
-                        pose_bone_matrix = pose_bone.matrix
 
                 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_object.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.x = -rotation.x
-                            rotation.y = -rotation.y
-                            rotation.z = -rotation.z
+                    rotation.conjugate()
 
                 key.location.x = location.x
                 key.location.y = location.y
@@ -230,11 +281,8 @@ class PsaBuilder(object):
                 key.rotation.z = rotation.z
                 key.rotation.w = rotation.w
                 key.time = 1.0 / psa_sequence.fps
-                    performance.key_build_duration += t.duration
 
-                    with Timer() as t:
                 psa.keys.append(key)
-                    performance.key_add_duration += t.duration
 
             psa_sequence.bone_count = len(pose_bones)
             psa_sequence.track_time = frame_count
@@ -243,41 +291,8 @@ class PsaBuilder(object):
 
         psa.sequences[export_sequence.name] = psa_sequence
 
+    # Restore the previous action & frame.
+    animation_data.action = saved_action
+    context.scene.frame_set(saved_frame_current)
+
     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)
-                    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:
-                # 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/data.py

@@ -6,7 +6,7 @@ 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.
 """
 
 
@@ -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,7 +1,5 @@
 import fnmatch
-import re
 import sys
-from collections import Counter
 from typing import Type
 
 import bpy
@@ -10,19 +8,13 @@ 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):
+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:
@@ -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')
-            self.write_section(fp, b'BONENAMES', Psa.Bone, self.psa.bones)
-            self.write_section(fp, b'ANIMINFO', Psa.Sequence, list(self.psa.sequences.values()))
-            self.write_section(fp, b'ANIMKEYS', Psa.Key, self.psa.keys)
+        write_section(fp, b'ANIMHEAD')
+        write_section(fp, b'BONENAMES', Psa.Bone, psa.bones)
+        write_section(fp, b'ANIMINFO', Psa.Sequence, list(psa.sequences.values()))
+        write_section(fp, b'ANIMKEYS', Psa.Key, psa.keys)
 
 
 class PsaExportActionListItem(PropertyGroup):
@@ -64,10 +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=empty_set,
+        default=False,
+        description='The root bone will be transformed as it appears in the scene',
+    )
+    should_override_animation_data: BoolProperty(
+        name='Override Animation Data',
+        options=empty_set,
+        default=False,
+        description='Use the animation data from a different object instead of the selected object'
+    )
+    animation_data_override: PointerProperty(
+        type=bpy.types.Object,
+        poll=psa_export_property_group_animation_data_override_poll
+    )
     sequence_source: EnumProperty(
         name='Source',
-        options=set(),
+        options=empty_set,
         description='',
         items=(
             ('ACTIONS', 'Actions', 'Sequences will be exported using actions', 'ACTION', 0),
@@ -77,7 +93,7 @@ class PsaExportPropertyGroup(PropertyGroup):
     )
     fps_source: EnumProperty(
         name='FPS Source',
-        options=set(),
+        options=empty_set,
         description='',
         items=(
             ('SCENE', 'Scene', '', 'SCENE_DATA', 0),
@@ -87,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)
@@ -95,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.'),
@@ -108,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',
@@ -116,17 +132,34 @@ 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_suffix: StringProperty(name='Suffix', options=set())
-    sequence_filter_name: StringProperty(default='', options={'TEXTEDIT_UPDATE'})
-    sequence_use_filter_invert: BoolProperty(default=False, options=set())
-    sequence_filter_asset: BoolProperty(default=False, name='Show assets',
-                                        description='Show actions that belong to an asset library', options=set())
-    sequence_use_filter_sort_reverse: BoolProperty(default=True, options=set())
+    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.'
+    )
+    sequence_name_prefix: StringProperty(name='Prefix', options=empty_set)
+    sequence_name_suffix: StringProperty(name='Suffix', options=empty_set)
+    sequence_filter_name: StringProperty(
+        default='',
+        name='Filter by Name',
+        options={'TEXTEDIT_UPDATE'},
+        description='Only show items matching this name (use \'*\' as wildcard)')
+    sequence_use_filter_invert: BoolProperty(
+        default=False,
+        name='Invert',
+        options=empty_set,
+        description='Invert filtering (show hidden items, and vice versa)')
+    sequence_filter_asset: BoolProperty(
+        default=False,
+        name='Show assets',
+        options=empty_set,
+        description='Show actions that belong to an asset library')
+    sequence_use_filter_sort_reverse: BoolProperty(default=True, options=empty_set)
 
 
 def is_bone_filter_mode_item_available(context, identifier):
@@ -153,9 +186,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')
@@ -165,6 +207,12 @@ class PsaExportOperator(Operator, ExportHelper):
         # SOURCE
         layout.prop(pg, 'sequence_source', text='Source')
 
+        if pg.sequence_source == 'TIMELINE_MARKERS':
+            # ANIMDATA SOURCE
+            layout.prop(pg, 'should_override_animation_data')
+            if pg.should_override_animation_data:
+                layout.prop(pg, 'animation_data_override', text='')
+
         # SELECT ALL/NONE
         row = layout.row(align=True)
         row.label(text='Select')
@@ -175,7 +223,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
@@ -186,7 +234,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()
@@ -220,15 +268,19 @@ 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):
-        return action is not None and action.asset_data is None
+        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)
+            match = re.match(r'pose\.bones\[\"([^\"]+)\"](\[\"([^\"]+)\"])?', fcurve.data_path)
             if not match:
                 continue
             bone_name = match.group(1)
@@ -236,17 +288,21 @@ class PsaExportOperator(Operator, ExportHelper):
                 return True
         return False
 
-    def invoke(self, context, event):
-        pg = context.scene.psa_export
-
+    @classmethod
+    def _check_context(cls, context):
         if context.view_layer.objects.active is None:
-            self.report({'ERROR_INVALID_CONTEXT'}, 'An armature must be selected')
-            return {'CANCELLED'}
+            raise RuntimeError('An armature must be selected')
 
         if context.view_layer.objects.active.type != 'ARMATURE':
-            self.report({'ERROR_INVALID_CONTEXT'}, 'The selected object must be an armature.')
-            return {'CANCELLED'}
+            raise RuntimeError('The selected object must be an armature')
 
+    def invoke(self, context, _event):
+        try:
+            self._check_context(context)
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+
+        pg = getattr(context.scene, 'psa_export')
         self.armature = context.view_layer.objects.active
 
         # Populate actions list.
@@ -257,7 +313,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)
 
@@ -266,6 +322,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.
@@ -280,12 +337,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
@@ -295,59 +354,47 @@ class PsaExportOperator(Operator, ExportHelper):
         options.bone_group_indices = [x.index for x in pg.bone_group_list if x.is_selected]
         options.should_use_original_sequence_names = pg.should_use_original_sequence_names
         options.should_trim_timeline_marker_sequences = pg.should_trim_timeline_marker_sequences
+        options.should_ignore_bone_name_restrictions = pg.should_ignore_bone_name_restrictions
         options.sequence_name_prefix = pg.sequence_name_prefix
         options.sequence_name_suffix = pg.sequence_name_suffix
-
-        builder = PsaBuilder()
+        options.root_motion = pg.root_motion
 
         try:
-            psa = builder.build(context, options)
+            psa = build_psa(context, options)
+            self.report({'INFO'}, f'PSA export successful')
         except RuntimeError as e:
             self.report({'ERROR_INVALID_CONTEXT'}, str(e))
             return {'CANCELLED'}
 
-        exporter = PsaExporter(psa)
-        exporter.export(self.filepath)
+        export_psa(psa, self.filepath)
+
         return {'FINISHED'}
 
 
-class PSA_UL_ExportTimelineMarkerList(UIList):
-    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]:
+def filter_sequences(pg: PsaExportPropertyGroup, sequences) -> List[int]:
     bitflag_filter_item = 1 << 30
     flt_flags = [bitflag_filter_item] * len(sequences)
 
-    if pg.sequence_filter_name 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[
-    PsaExportActionListItem]:
+def get_visible_sequences(pg: PsaExportPropertyGroup, sequences) -> List[PsaExportActionListItem]:
     visible_sequences = []
     for i, flag in enumerate(filter_sequences(pg, sequences)):
         if bool(flag & (1 << 30)):
@@ -355,31 +402,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):
-        pg = context.scene.psa_export
-        actions = getattr(data, property)
+        if pg.sequence_source == 'ACTIONS':
+            subrow = row.row(align=True)
+            subrow.prop(pg, 'sequence_filter_asset', icon_only=True, icon='ASSET_MANAGER')
+
+    def filter_items(self, context, data, prop):
+        pg = getattr(context.scene, 'psa_export')
+        actions = getattr(data, prop)
         flt_flags = filter_sequences(pg, actions)
         flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(actions, 'name')
         return flt_flags, flt_neworder
@@ -402,14 +451,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
@@ -438,7 +487,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
@@ -453,13 +502,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'}
@@ -473,13 +522,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'}
@@ -490,8 +539,7 @@ classes = (
     PsaExportTimelineMarkerListItem,
     PsaExportPropertyGroup,
     PsaExportOperator,
-    PSA_UL_ExportActionList,
-    PSA_UL_ExportTimelineMarkerList,
+    PSA_UL_ExportSequenceList,
     PsaExportActionsSelectAll,
     PsaExportActionsDeselectAll,
     PsaExportBoneGroupsSelectAll,

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
-from bpy.props import StringProperty, BoolProperty, CollectionProperty, PointerProperty, IntProperty
-from bpy.types import Operator, UIList, PropertyGroup, Panel
+import numpy
+from bpy.props import StringProperty, BoolProperty, CollectionProperty, PointerProperty, IntProperty, EnumProperty
+from bpy.types import Operator, UIList, PropertyGroup, Panel, 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,17 +25,11 @@ 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 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):
+class ImportBone(object):
     def __init__(self, psa_bone: Psa.Bone):
         self.psa_bone: Psa.Bone = psa_bone
         self.parent: Optional[ImportBone] = None
@@ -43,9 +38,10 @@ class PsaImporter(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:])
@@ -62,40 +58,74 @@ 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
 
+
+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 = 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_names.append(psa_bone_name)
+        psa_bone_name: str = psa_bone.name.decode('windows-1252')
         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(
-                f'The armature object \'{armature_object.name}\' is missing the following bones that exist in the PSA:')
-            print(list(sorted(missing_bone_names)))
+        result.warnings.append(
+            f'The armature \'{armature_object.name}\' is missing {len(missing_bone_names)} bones that exist in '
+            'the PSA:\n' +
+            str(list(sorted(missing_bone_names)))
+        )
     del armature_bone_names
 
     # Create intermediate bone data for import operations.
     import_bones = []
     import_bones_dict = dict()
 
-        for psa_bone_index, psa_bone in enumerate(psa_reader.bones):
-            bone_name = psa_bone.name.decode('windows-1252')
-            if psa_bone_index not in psa_to_armature_bone_indices:  # TODO: replace with bone_name in armature_data.bones
+    for (psa_bone_index, psa_bone), psa_bone_name in zip(enumerate(psa_reader.bones), psa_bone_names):
+        if psa_bone_index not in psa_to_armature_bone_indices:
             # PSA bone does not map to armature bone, skip it and leave an empty bone in its place.
             import_bones.append(None)
             continue
         import_bone = ImportBone(psa_bone)
-            import_bone.armature_bone = armature_data.bones[bone_name]
-            import_bone.pose_bone = armature_object.pose.bones[bone_name]
-            import_bones_dict[bone_name] = import_bone
+        import_bone.armature_bone = armature_data.bones[psa_bone_name]
+        import_bone.pose_bone = armature_object.pose.bones[psa_bone_name]
+        import_bones_dict[psa_bone_name] = import_bone
         import_bones.append(import_bone)
 
     for import_bone in filter(lambda x: x is not None, import_bones):
@@ -104,7 +134,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'])
@@ -155,7 +186,6 @@ class PsaImporter(object):
 
             # 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):
@@ -167,40 +197,23 @@ class PsaImporter(object):
                     # 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
-                # insufficiently large change in the data from the last written frame.
-                if options.should_clean_keys:
-                    threshold = 0.001
+            # Write the keyframes out.
+            fcurve_data = numpy.zeros(2 * sequence.frame_count, dtype=float)
+            fcurve_data[0::2] = range(sequence.frame_count)
             for bone_index, import_bone in enumerate(import_bones):
                 if import_bone is None:
                     continue
-                        for fcurve_index in range(len(import_bone.fcurves)):
-                            # Get all the keyframe data for the bone's f-curve data from the sequence data matrix.
-                            fcurve_frame_data = sequence_data_matrix[:, bone_index, fcurve_index]
-                            last_written_datum = 0
-                            for frame_index, datum in enumerate(fcurve_frame_data):
-                                # If the f-curve data is not different enough to the last written frame, un-mark this data for writing.
-                                if frame_index > 0 and abs(datum - last_written_datum) < threshold:
-                                    keyframe_write_matrix[frame_index, bone_index, fcurve_index] = 0
-                                else:
-                                    last_written_datum = datum
+                for fcurve_index, fcurve in enumerate(import_bone.fcurves):
+                    fcurve_data[1::2] = sequence_data_matrix[:, bone_index, fcurve_index]
+                    fcurve.keyframe_points.add(sequence.frame_count)
+                    fcurve.keyframe_points.foreach_set('co', fcurve_data)
 
-                # Write the keyframes out!
-                for frame_index in range(sequence.frame_count):
-                    for bone_index, import_bone in enumerate(import_bones):
-                        if import_bone is None:
-                            continue
-                        bone_has_writeable_keyframes = any(keyframe_write_matrix[frame_index, bone_index])
-                        if bone_has_writeable_keyframes:
-                            # This bone has writeable keyframes for this frame.
-                            key_data = sequence_data_matrix[frame_index, bone_index]
-                            for fcurve, should_write, datum in zip(import_bone.fcurves,
-                                                                   keyframe_write_matrix[frame_index, bone_index],
-                                                                   key_data):
-                                if should_write:
-                                    fcurve.keyframe_points.insert(frame_index, datum, options={'FAST'})
+            if options.should_convert_to_samples:
+                # Bake the curve to samples.
+                for fcurve in action.fcurves:
+                    fcurve.convert_to_samples(start=0, end=sequence.frame_count)
 
-            # Write
+        # Write meta-data.
         if options.should_write_metadata:
             action['psa_sequence_name'] = sequence_name
             action['psa_sequence_fps'] = sequence.fps
@@ -219,10 +232,15 @@ class PsaImporter(object):
             nla_track.mute = True
             nla_track.strips.new(name=action.name, start=0, action=action)
 
+    return result
+
+
+empty_set = set()
+
 
 class PsaImportActionListItem(PropertyGroup):
-    action_name: StringProperty(options=set())
-    is_selected: BoolProperty(default=False, options=set())
+    action_name: StringProperty(options=empty_set)
+    is_selected: BoolProperty(default=False, options=empty_set)
 
 
 def load_psa_file(context):
@@ -244,12 +262,12 @@ def load_psa_file(context):
         pg.psa_error = str(e)
 
 
-def on_psa_file_path_updated(property, context):
+def on_psa_file_path_updated(property_, context):
     load_psa_file(context)
 
 
 class PsaBonePropertyGroup(PropertyGroup):
-    bone_name: StringProperty(options=set())
+    bone_name: StringProperty(options=empty_set)
 
 
 class PsaDataPropertyGroup(PropertyGroup):
@@ -258,37 +276,53 @@ 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())
     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())
+                                       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=set())
-    should_use_action_name_prefix: BoolProperty(default=False, name='Prefix Action Name', options=set())
-    action_name_prefix: StringProperty(default='', name='Prefix', options=set())
-    should_overwrite: BoolProperty(default=False, name='Reuse Existing Actions', options=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_metadata: BoolProperty(default=True, name='Metadata', options=set(),
-                                        description='Additional data will be written to the custom properties of the Action (e.g., frame rate)')
+                               options=empty_set)
+    should_use_action_name_prefix: BoolProperty(default=False, name='Prefix Action Name', options=empty_set)
+    action_name_prefix: StringProperty(default='', name='Prefix', options=empty_set)
+    should_overwrite: BoolProperty(default=False, name='Reuse Existing Actions', options=empty_set,
+                                   description='If an action with a matching name already exists, the existing action '
+                                               'will have it\'s data overwritten instead of a new action being created')
+    should_write_keyframes: BoolProperty(default=True, name='Keyframes', options=empty_set)
+    should_write_metadata: BoolProperty(default=True, name='Metadata', options=empty_set,
+                                        description='Additional data will be written to the custom properties of the '
+                                                    'Action (e.g., frame rate)')
     sequence_filter_name: StringProperty(default='', options={'TEXTEDIT_UPDATE'})
-    sequence_filter_is_selected: BoolProperty(default=False, options=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)
+    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: 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 +356,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[
-    PsaImportActionListItem]:
+def get_visible_sequences(pg: PsaImportPropertyGroup, sequences) -> List[PsaImportActionListItem]:
     bitflag_filter_item = 1 << 30
     visible_sequences = []
     for i, flag in enumerate(filter_sequences(pg, sequences)):
@@ -333,27 +366,26 @@ 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_propname, index):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_property, index, flt_flag):
         row = layout.row(align=True)
         split = row.split(align=True, factor=0.75)
         column = split.row(align=True)
         column.alignment = 'LEFT'
         column.prop(item, 'is_selected', icon_only=True)
-        column.label(text=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)
-        subrow.prop(pg, 'sequence_filter_name', text="")
-        subrow.prop(pg, 'sequence_use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
-        subrow.prop(pg, 'sequence_use_filter_regex', text="", icon='SORTBYEXT')
-        subrow.prop(pg, 'sequence_filter_is_selected', text="", icon='CHECKBOX_HLT')
+        sub_row = row.row(align=True)
+        sub_row.prop(pg, 'sequence_filter_name', text="")
+        sub_row.prop(pg, 'sequence_use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
+        sub_row.prop(pg, 'sequence_use_filter_regex', text="", icon='SORTBYEXT')
+        sub_row.prop(pg, 'sequence_filter_is_selected', text="", icon='CHECKBOX_HLT')
 
-    def filter_items(self, context, data, property):
-        pg = context.scene.psa_import
-        sequences = getattr(data, property)
+    def filter_items(self, context, data, property_):
+        pg = getattr(context.scene, 'psa_import')
+        sequences = getattr(data, property_)
         flt_flags = filter_sequences(pg, sequences)
         flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(sequences, 'action_name')
         return flt_flags, flt_neworder
@@ -375,7 +407,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 +415,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 +438,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 +464,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,13 +486,23 @@ 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 = layout.column()
         col.use_property_split = True
         col.use_property_decorate = False
-        col.prop(pg, 'should_clean_keys')
+        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')
@@ -476,11 +521,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 +597,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,29 +613,35 @@ 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]
 
         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
+        options.should_convert_to_samples = pg.should_convert_to_samples
+        options.bone_mapping_mode = pg.bone_mapping_mode
 
-        PsaImporter().import_psa(psa_reader, context.view_layer.objects.active, options)
+        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'}
@@ -613,7 +664,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.
-    The key data is not read into memory upon instantiation due to it's potentially very large size.
-    To read the key data for a particular sequence, call `read_sequence_keys`.
+    This class reads the sequences and bone information immediately upon instantiation and holds onto a file handle.
+    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.
     """
 
     def __init__(self, path):
@@ -22,10 +22,15 @@ 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):
+    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)
@@ -38,10 +43,11 @@ class PsaReader(object):
         return matrix
 
     def read_sequence_keys(self, sequence_name: str) -> List[Psa.Key]:
-        """ Reads and returns the key data for a sequence.
+        """
+        Reads and returns the key data for a sequence.
 
-        :param sequence_name: The name of the sequence.
-        :return: A list of Psa.Keys.
+        @param sequence_name: The name of the sequence.
+        @return: A list of Psa.Keys.
         """
         # Set the file reader to the beginning of the keys data
         sequence = self.psa.sequences[sequence_name]
@@ -60,7 +66,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 +92,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,4 +1,8 @@
-from collections import OrderedDict
+import typing
+
+import bmesh
+import bpy
+from bpy.types import Armature
 
 from .data import *
 from ..helpers import *
@@ -10,43 +14,41 @@ 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] = []
+        self.should_ignore_bone_name_restrictions = False
 
 
-class PskBuilder(object):
-    def __init__(self):
-        pass
-
-    @staticmethod
-    def get_input_objects(context) -> PskInputObjects:
+def get_psk_input_objects(context) -> PskInputObjects:
     input_objects = PskInputObjects()
-        for obj in context.view_layer.objects.selected:
-            if obj.type != 'MESH':
-                raise RuntimeError(f'Selected object "{obj.name}" is not a mesh')
+    for selected_object in context.view_layer.objects.selected:
+        if selected_object.type != 'MESH':
+            raise RuntimeError(f'Selected object "{selected_object.name}" is not a mesh')
 
     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:
-            if len(obj.data.materials) == 0:
-                raise RuntimeError(f'Mesh "{obj.name}" must have at least one material')
+    for mesh_object in input_objects.mesh_objects:
+        if len(mesh_object.data.materials) == 0:
+            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:
-            modifiers = [x for x in obj.modifiers if x.type == 'ARMATURE']
+    for mesh_object in input_objects.mesh_objects:
+        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 +58,14 @@ class PskBuilder(object):
 
     return input_objects
 
-    def build(self, context, options: PskBuilderOptions) -> Psk:
-        input_objects = PskBuilder.get_input_objects(context)
 
-        armature_object = input_objects.armature_object
+def build_psk(context, options: PskBuildOptions) -> Psk:
+    input_objects = get_psk_input_objects(context)
+
+    armature_object: bpy.types.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
@@ -78,7 +80,12 @@ class PskBuilder(object):
         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.
+        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()
@@ -91,71 +98,94 @@ 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.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
+                rotation = bone.matrix.to_quaternion().conjugated()
+                inverse_parent_rotation = bone.parent.matrix.to_quaternion().inverted()
+                parent_head = inverse_parent_rotation @ bone.parent.head
+                parent_tail = inverse_parent_rotation @ bone.parent.tail
                 location = (parent_tail - parent_head) + bone.head
             else:
-                    location = armature_object.matrix_local @ bone.head
-                    rot_matrix = bone.matrix @ armature_object.matrix_local.to_3x3()
-                    rotation = rot_matrix.to_quaternion()
+                armature_local_matrix = armature_object.matrix_local
+                location = armature_local_matrix @ bone.head
+                bone_rotation = bone.matrix.to_quaternion().conjugated()
+                local_rotation = armature_local_matrix.to_3x3().to_quaternion().conjugated()
+                rotation = bone_rotation @ local_rotation
+                rotation.conjugate()
 
             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]
+
+        # MESH DATA
+        if options.use_raw_mesh_data:
+            mesh_object = input_mesh_object
+            mesh_data = input_mesh_object.data
+        else:
+            # Create a copy of the mesh object after non-armature modifiers are applied.
+
+            # Temporarily force the armature into the rest position.
+            # We will undo this later.
+            old_pose_position = armature_object.data.pose_position
+            armature_object.data.pose_position = 'REST'
+
+            depsgraph = context.evaluated_depsgraph_get()
+            bm = bmesh.new()
+            bm.from_object(input_mesh_object, depsgraph)
+            mesh_data = bpy.data.meshes.new('')
+            bm.to_mesh(mesh_data)
+            del bm
+            mesh_object = bpy.data.objects.new('', mesh_data)
+            mesh_object.matrix_world = input_mesh_object.matrix_world
+
+            # Copy the vertex groups
+            for vertex_group in input_mesh_object.vertex_groups:
+                mesh_object.vertex_groups.new(name=vertex_group.name)
+
+            # Restore the previous pose position on the armature.
+            armature_object.data.pose_position = old_pose_position
+
         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
-
-            # 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)
+        uv_layer = mesh_data.uv_layers.active.data
 
         # 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 +193,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 +211,8 @@ class PskBuilder(object):
                 loop_wedge_indices[loop_index] = wedge_index
 
         # FACES
-            poly_groups, groups = object.data.calc_smooth_groups(use_bitflags=True)
-            for f in object.data.loop_triangles:
+        poly_groups, groups = mesh_data.calc_smooth_groups(use_bitflags=True)
+        for f in mesh_data.loop_triangles:
             face = Psk.Face()
             face.material_index = material_indices[f.material_index]
             face.wedge_indices[0] = loop_wedge_indices[f.loops[2]]
@@ -193,10 +223,11 @@ class PskBuilder(object):
 
         # WEIGHTS
         if armature_object is not None:
+            armature_data = typing.cast(Armature, armature_object.data)
             # Because the vertex groups may contain entries for which there is no matching bone in the armature,
             # we must filter them out and not export any weights for these vertex groups.
             bone_names = [x.name for x in bones]
-                vertex_group_names = [x.name for x in object.vertex_groups]
+            vertex_group_names = [x.name for x in mesh_object.vertex_groups]
             vertex_group_bone_indices = dict()
             for vertex_group_index, vertex_group_name in enumerate(vertex_group_names):
                 try:
@@ -206,8 +237,8 @@ class PskBuilder(object):
                     # Check to see if there is an associated bone for this vertex group that exists in the armature.
                     # If there is, we can traverse the ancestors of that bone to find an alternate bone to use for
                     # weighting the vertices belonging to this vertex group.
-                        if vertex_group_name in armature_object.data.bones:
-                            bone = armature_object.data.bones[vertex_group_name]
+                    if vertex_group_name in armature_data.bones:
+                        bone = armature_data.bones[vertex_group_name]
                         while bone is not None:
                             try:
                                 bone_index = bone_names.index(bone.name)
@@ -215,12 +246,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 +264,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.types import Operator, PropertyGroup
+from bpy.props import BoolProperty, StringProperty, CollectionProperty, IntProperty, EnumProperty
+from bpy.types import Operator, PropertyGroup, UIList
 from bpy_extras.io_utils import ExportHelper
 
-from .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 __init__(self, psk: Psk):
-        self.psk: Psk = psk
-
-    @staticmethod
-    def write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None):
+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:
-            raise RuntimeError(f'Number of wedges ({len(self.psk.wedges)}) exceeds limit of {MAX_WEDGE_COUNT}')
-        if len(self.psk.bones) > MAX_BONE_COUNT:
-            raise RuntimeError(f'Number of bones ({len(self.psk.bones)}) exceeds limit of {MAX_BONE_COUNT}')
-        if len(self.psk.points) > MAX_POINT_COUNT:
-            raise RuntimeError(f'Numbers of vertices ({len(self.psk.points)}) exceeds limit of {MAX_POINT_COUNT}')
-        if len(self.psk.materials) > MAX_MATERIAL_COUNT:
-            raise RuntimeError(f'Number of materials ({len(self.psk.materials)}) exceeds limit of {MAX_MATERIAL_COUNT}')
+
+def export_psk(psk: Psk, path: str):
+    if len(psk.wedges) > MAX_WEDGE_COUNT:
+        raise RuntimeError(f'Number of wedges ({len(psk.wedges)}) exceeds limit of {MAX_WEDGE_COUNT}')
+    if len(psk.bones) > MAX_BONE_COUNT:
+        raise RuntimeError(f'Number of bones ({len(psk.bones)}) exceeds limit of {MAX_BONE_COUNT}')
+    if len(psk.points) > MAX_POINT_COUNT:
+        raise RuntimeError(f'Numbers of vertices ({len(psk.points)}) exceeds limit of {MAX_POINT_COUNT}')
+    if len(psk.materials) > MAX_MATERIAL_COUNT:
+        raise RuntimeError(f'Number of materials ({len(psk.materials)}) exceeds limit of {MAX_MATERIAL_COUNT}')
 
     with open(path, 'wb') as fp:
-            self.write_section(fp, b'ACTRHEAD')
-            self.write_section(fp, b'PNTS0000', Vector3, self.psk.points)
+        _write_section(fp, b'ACTRHEAD')
+        _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)
-            self.write_section(fp, b'FACE0000', Psk.Face, self.psk.faces)
-            self.write_section(fp, b'MATT0000', Psk.Material, self.psk.materials)
-            self.write_section(fp, b'REFSKELT', Psk.Bone, self.psk.bones)
-            self.write_section(fp, b'RAWWEIGHTS', Psk.Weight, self.psk.weights)
+        _write_section(fp, b'VTXW0000', Psk.Wedge16, wedges)
+        _write_section(fp, b'FACE0000', Psk.Face, psk.faces)
+        _write_section(fp, b'MATT0000', Psk.Material, psk.materials)
+        _write_section(fp, b'REFSKELT', Psk.Bone, psk.bones)
+        _write_section(fp, b'RAWWEIGHTS', Psk.Weight, psk.weights)
 
 
 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,45 @@ 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)
 
+        try:
+            populate_material_list(input_objects.mesh_objects, pg.material_list)
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+            return {'CANCELLED'}
+
         context.window_manager.fileselect_add(self)
 
         return {'RUNNING_MODAL'}
 
+    @classmethod
+    def poll(cls, context):
+        try:
+            get_psk_input_objects(context)
+        except RuntimeError as e:
+            cls.poll_message_set(str(e))
+            return False
+        return True
+
     def draw(self, context):
         layout = self.layout
-        scene = context.scene
-        pg = scene.psk_export
+        pg = getattr(context.scene, 'psk_export')
+
+        layout.prop(pg, 'use_raw_mesh_data')
 
         # BONES
-        box = layout.box()
-        box.label(text='Bones', icon='BONE_DATA')
+        layout.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 +198,38 @@ 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')
+
+        layout.separator()
+
+        layout.prop(pg, 'should_ignore_bone_name_restrictions')
+
     def execute(self, context):
         pg = context.scene.psk_export
-        builder = PskBuilder()
-        options = PskBuilderOptions()
+        options = PskBuildOptions()
         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]
+        options.should_ignore_bone_name_restrictions = pg.should_ignore_bone_name_restrictions
+
         try:
-            psk = builder.build(context, options)
-            exporter = PskExporter(psk)
-            exporter.export(self.filepath)
+            psk = build_psk(context, options)
+            export_psk(psk, self.filepath)
+            self.report({'INFO'}, f'PSK export successful')
         except RuntimeError as e:
             self.report({'ERROR_INVALID_CONTEXT'}, str(e))
             return {'CANCELLED'}
@@ -152,9 +249,22 @@ 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)
+    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 = (
+    MaterialListItem,
+    PSK_UL_MaterialList,
+    PskMaterialListItemMoveUp,
+    PskMaterialListItemMoveDown,
     PskExportOperator,
-    PskExportPropertyGroup
+    PskExportPropertyGroup,
 )

io_scene_psk_psa/psk/importer.py

@@ -1,36 +1,61 @@
 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):
-    def __init__(self):
-        pass
+class ImportBone(object):
+    """
+    Intermediate bone type for the purpose of construction.
+    """
+    def __init__(self, index: int, psk_bone: Psk.Bone):
+        self.index: int = index
+        self.psk_bone: Psk.Bone = psk_bone
+        self.parent: Optional[ImportBone] = None
+        self.local_rotation: Quaternion = Quaternion()
+        self.local_translation: Vector = Vector()
+        self.world_rotation_matrix: Matrix = Matrix()
+        self.world_matrix: Matrix = Matrix()
+        self.vertex_group = None
+        self.orig_quat: Quaternion = Quaternion()
+        self.orig_loc: Vector = Vector()
+        self.post_quat: Quaternion = Quaternion()
 
-    def import_psk(self, 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:
         # ARMATURE
         armature_data = bpy.data.armatures.new(options.name)
         armature_object = bpy.data.objects.new(options.name, armature_data)
@@ -48,21 +73,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 +120,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)
 
@@ -137,7 +148,7 @@ class PskImporter(object):
                 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)
 
@@ -195,7 +206,8 @@ class PskImporter(object):
                     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:
@@ -211,36 +223,42 @@ 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))):
-            import_bone.vertex_group = mesh_object.vertex_groups.new(
-                name=import_bone.psk_bone.name.decode('windows-1252'))
+        vertex_groups: List[Optional[VertexGroup]] = [None] * len(psk.bones)
+        for bone_index, psk_bone in map(lambda x: (x, psk.bones[x]), vertex_group_bone_indices):
+            vertex_groups[bone_index] = mesh_object.vertex_groups.new(name=psk_bone.name.decode('windows-1252'))
 
         for weight in psk.weights:
-            import_bones[weight.bone_index].vertex_group.add((weight.point_index,), weight.weight, 'ADD')
+            vertex_groups[weight.bone_index].add((weight.point_index,), weight.weight, 'ADD')
+
+        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
 
+    return result
+
+
+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 +269,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 +315,50 @@ class PskImportOperator(Operator, ImportHelper):
         default='')
 
     def execute(self, context):
-        pg = context.scene.psk_import
-        reader = PskReader()
-        psk = reader.read(self.filepath)
+        pg = getattr(context.scene, 'psk_import')
+
+        psk = read_psk(self.filepath)
+
         options = PskImportOptions()
         options.name = os.path.splitext(os.path.basename(self.filepath))[0]
+        options.should_import_mesh = pg.should_import_mesh
         options.should_import_extra_uvs = pg.should_import_extra_uvs
         options.should_import_vertex_colors = pg.should_import_vertex_colors
         options.should_import_vertex_normals = pg.should_import_vertex_normals
         options.vertex_color_space = pg.vertex_color_space
+        options.should_import_skeleton = pg.should_import_skeleton
         options.bone_length = pg.bone_length
-        PskImporter().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 = context.scene.psk_import
+        pg = getattr(context.scene, 'psk_import')
         layout = self.layout
-        layout.use_property_split = True
-        layout.use_property_decorate = False
-        layout.prop(pg, 'should_import_vertex_normals')
-        layout.prop(pg, 'should_import_extra_uvs')
-        layout.prop(pg, 'should_import_vertex_colors')
+        layout.prop(pg, 'should_import_mesh')
+        row = layout.column()
+        row.use_property_split = True
+        row.use_property_decorate = False
+        if pg.should_import_mesh:
+            row.prop(pg, 'should_import_vertex_normals')
+            row.prop(pg, 'should_import_extra_uvs')
+            row.prop(pg, 'should_import_vertex_colors')
             if pg.should_import_vertex_colors:
-            layout.prop(pg, 'vertex_color_space')
-        layout.prop(pg, 'bone_length')
+                row.prop(pg, 'vertex_color_space')
+        layout.prop(pg, 'should_import_skeleton')
+        row = layout.column()
+        row.use_property_split = True
+        row.use_property_decorate = False
+        if pg.should_import_skeleton:
+            row.prop(pg, 'bone_length')
 
 
 classes = (

io_scene_psk_psa/psk/reader.py

@@ -3,13 +3,7 @@ import ctypes
 from .data import *
 
 
-class PskReader(object):
-
-    def __init__(self):
-        pass
-
-    @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
@@ -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: str) -> 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.label(text=str(item.count), icon='BONE_DATA')
+        row.prop(item, 'is_selected', text=getattr(item, 'name'))
+        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,