Fix for root bone being incorrectly oriented if it wasn't at the identity rotation in the bind pose

README.md

@@ -5,13 +5,12 @@
 
 This Blender addon allows you to import and export meshes and animations to and from the [PSK and PSA file formats](https://wiki.beyondunreal.com/PSK_%26_PSA_file_formats) used in many versions of the Unreal Engine.
 
-# Compatibility
+## Compatibility
 
-| Blender Version                                            | Addon Version                                                                  | Long Term Support |
+| Blender Version                                              | Addon Version                                                                  | Long Term Support |
-|------------------------------------------------------------|--------------------------------------------------------------------------------|-------------------|
+|--------------------------------------------------------------|--------------------------------------------------------------------------------|-------------------|
-| [4.1](https://www.blender.org/download/releases/4-1/)      | [latest](https://github.com/DarklightGames/io_scene_psk_psa/releases/latest)   | TBD               |
+| 4.0+                                                         | [latest](https://github.com/DarklightGames/io_scene_psk_psa/releases/latest)   | TBD               |
-| [4.0](https://www.blender.org/download/releases/4-0/)      | [6.2.1](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/6.2.1) | TBD               |                                      
+| [3.4 - 3.6](https://www.blender.org/download/lts/3-6/)       | [5.0.6](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/5.0.6) | ✅️ June 2025      |
-| [3.4 - 3.6](https://www.blender.org/download/lts/3-6/)     | [5.0.6](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/5.0.6) | ✅️ June 2025      |
 | [2.93 - 3.3](https://www.blender.org/download/releases/3-3/) | [4.3.0](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/4.3.0) | ✅️ September 2024 |
 
 Bug fixes will be issued for legacy addon versions that are under [Blender's LTS maintenance period](https://www.blender.org/download/lts/). Once the LTS period has ended, legacy addon versions will no longer be supported by the maintainers of this repository, although we will accept pull requests for bug fixes. 

io_scene_psk_psa/__init__.py

@@ -3,8 +3,8 @@ from bpy.app.handlers import persistent
 bl_info = {
     'name': 'PSK/PSA Importer/Exporter',
     'author': 'Colin Basnett, Yurii Ti',
-    'version': (7, 0, 0),
+    'version': (6, 2, 0),
-    'blender': (4, 1, 0),
+    'blender': (4, 0, 0),
     'description': 'PSK/PSA Import/Export (.psk/.psa)',
     'warning': '',
     'doc_url': 'https://github.com/DarklightGames/io_scene_psk_psa',

io_scene_psk_psa/psa/config.py

@@ -14,7 +14,7 @@ class PsaConfig:
 
 
 def _load_config_file(file_path: str) -> ConfigParser:
-    """
+    '''
     UEViewer exports a dialect of INI files that is not compatible with Python's ConfigParser.
     Specifically, it allows values in this format:
 
@@ -24,7 +24,7 @@ def _load_config_file(file_path: str) -> ConfigParser:
 
     This is not allowed in Python's ConfigParser, which requires a '=' character after each key name.
     To work around this, we'll modify the file to add the '=' character after each key name if it is missing.
-    """
+    '''
     with open(file_path, 'r') as f:
         lines = f.read().split('\n')
 
@@ -41,7 +41,7 @@ def _load_config_file(file_path: str) -> ConfigParser:
 def _get_bone_flags_from_value(value: str) -> int:
     match value:
         case 'all':
-            return REMOVE_TRACK_LOCATION | REMOVE_TRACK_ROTATION
+            return (REMOVE_TRACK_LOCATION | REMOVE_TRACK_ROTATION)
         case 'trans':
             return REMOVE_TRACK_LOCATION
         case 'rot':

io_scene_psk_psa/psa/export/operators.py

@@ -91,16 +91,15 @@ def update_actions_and_timeline_markers(context: Context, armature: Armature):
 
 
 def get_sequence_fps(context: Context, fps_source: str, fps_custom: float, actions: Iterable[Action]) -> float:
-    match fps_source:
+    if fps_source == 'SCENE':
-        case 'SCENE':
+        return context.scene.render.fps
-            return context.scene.render.fps
+    elif fps_source == 'CUSTOM':
-        case 'CUSTOM':
+        return fps_custom
-            return fps_custom
+    elif fps_source == 'ACTION_METADATA':
-        case 'ACTION_METADATA':
+        # Get the minimum value of action metadata FPS values.
-            # Get the minimum value of action metadata FPS values.
+        return min([action.psa_export.fps for action in actions])
-            return min([action.psa_export.fps for action in actions])
+    else:
-        case _:
+        raise RuntimeError(f'Invalid FPS source "{fps_source}"')
-            raise RuntimeError(f'Invalid FPS source "{fps_source}"')
 
 
 def get_animation_data_object(context: Context) -> Object:

io_scene_psk_psa/psa/export/ui.py

@@ -32,6 +32,7 @@ class PSA_UL_export_sequences(UIList):
         subrow = row.row(align=True)
         subrow.prop(pg, 'sequence_filter_name', text='')
         subrow.prop(pg, 'sequence_use_filter_invert', text='', icon='ARROW_LEFTRIGHT')
+        # subrow.prop(pg, 'sequence_use_filter_sort_reverse', text='', icon='SORT_ASC')
 
         if pg.sequence_source == 'ACTIONS':
             subrow = row.row(align=True)
@@ -43,6 +44,7 @@ class PSA_UL_export_sequences(UIList):
         pg = getattr(context.scene, 'psa_export')
         actions = getattr(data, prop)
         flt_flags = filter_sequences(pg, actions)
+        # flt_neworder = bpy.types.UI_UL_list.sort_items_by_name(actions, 'name')
         flt_neworder = list(range(len(actions)))
         return flt_flags, flt_neworder
 

io_scene_psk_psa/psa/import_/operators.py

@@ -2,7 +2,7 @@ import os
 from pathlib import Path
 
 from bpy.props import StringProperty
-from bpy.types import Operator, Event, Context, FileHandler
+from bpy.types import Operator, Event, Context
 from bpy_extras.io_utils import ImportHelper
 
 from .properties import get_visible_sequences
@@ -89,6 +89,23 @@ class PSA_OT_import_sequences_deselect_all(Operator):
         return {'FINISHED'}
 
 
+class PSA_OT_import_select_file(Operator):
+    bl_idname = 'psa_import.select_file'
+    bl_label = 'Select'
+    bl_options = {'INTERNAL'}
+    bl_description = 'Select a PSA file from which to import animations'
+    filepath: StringProperty(subtype='FILE_PATH')
+    filter_glob: StringProperty(default='*.psa', options={'HIDDEN'})
+
+    def execute(self, context):
+        getattr(context.scene, 'psa_import').psa_file_path = self.filepath
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        context.window_manager.fileselect_add(self)
+        return {'RUNNING_MODAL'}
+
+
 def load_psa_file(context, filepath: str):
     pg = context.scene.psa_import
     pg.sequence_list.clear()
@@ -190,82 +207,67 @@ class PSA_OT_import(Operator, ImportHelper):
         layout = self.layout
         pg = getattr(context.scene, 'psa_import')
 
-        sequences_header, sequences_panel = layout.panel('sequences_panel_id', default_closed=False)
+        if pg.psa_error:
-        sequences_header.label(text='Sequences')
+            row = layout.row()
+            row.label(text='Select a PSA file', icon='ERROR')
+        else:
+            box = layout.box()
 
-        if sequences_panel:
+            box.label(text=f'Sequences ({len(pg.sequence_list)})', icon='ARMATURE_DATA')
-            if pg.psa_error:
-                row = sequences_panel.row()
-                row.label(text='Select a PSA file', icon='ERROR')
-            else:
-                # Select buttons.
-                rows = max(3, min(len(pg.sequence_list), 10))
 
-                row = sequences_panel.row()
+            # Select buttons.
-                col = row.column()
+            rows = max(3, min(len(pg.sequence_list), 10))
 
-                row2 = col.row(align=True)
+            row = box.row()
-                row2.label(text='Select')
+            col = row.column()
-                row2.operator(PSA_OT_import_sequences_from_text.bl_idname, text='', icon='TEXT')
-                row2.operator(PSA_OT_import_sequences_select_all.bl_idname, text='All', icon='CHECKBOX_HLT')
-                row2.operator(PSA_OT_import_sequences_deselect_all.bl_idname, text='None', icon='CHECKBOX_DEHLT')
 
-                col = col.row()
+            row2 = col.row(align=True)
-                col.template_list('PSA_UL_import_sequences', '', pg, 'sequence_list', pg, 'sequence_list_index', rows=rows)
+            row2.label(text='Select')
+            row2.operator(PSA_OT_import_sequences_from_text.bl_idname, text='', icon='TEXT')
+            row2.operator(PSA_OT_import_sequences_select_all.bl_idname, text='All', icon='CHECKBOX_HLT')
+            row2.operator(PSA_OT_import_sequences_deselect_all.bl_idname, text='None', icon='CHECKBOX_DEHLT')
 
-            col = sequences_panel.column(heading='')
+            col = col.row()
+            col.template_list('PSA_UL_import_sequences', '', pg, 'sequence_list', pg, 'sequence_list_index', rows=rows)
+
+        col = layout.column(heading='')
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(pg, 'should_overwrite')
+
+        col = layout.column(heading='Write')
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(pg, 'should_write_keyframes')
+        col.prop(pg, 'should_write_metadata')
+
+        col = layout.column()
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(pg, 'bone_mapping_mode')
+
+        if pg.should_write_keyframes:
+            col = layout.column(heading='Keyframes')
             col.use_property_split = True
             col.use_property_decorate = False
+            col.prop(pg, 'should_convert_to_samples')
+            col.separator()
+            # FPS
             col.prop(pg, 'fps_source')
             if pg.fps_source == 'CUSTOM':
                 col.prop(pg, 'fps_custom')
-            col.prop(pg, 'should_overwrite')
-            col.prop(pg, 'should_use_action_name_prefix')
-            if pg.should_use_action_name_prefix:
-                col.prop(pg, 'action_name_prefix')
 
-        data_header, data_panel = layout.panel('data_panel_id', default_closed=False)
+        col = layout.column(heading='Options')
-        data_header.label(text='Data')
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(pg, 'should_use_fake_user')
+        col.prop(pg, 'should_stash')
+        col.prop(pg, 'should_use_config_file')
 
-        if data_panel:
+        col.prop(pg, 'should_use_action_name_prefix')
-            col = data_panel.column(heading='Write')
-            col.use_property_split = True
-            col.use_property_decorate = False
-            col.prop(pg, 'should_write_keyframes')
-            col.prop(pg, 'should_write_metadata')
 
-            if pg.should_write_keyframes:
+        if pg.should_use_action_name_prefix:
-                col = col.column(heading='Keyframes')
+            col.prop(pg, 'action_name_prefix')
-                col.use_property_split = True
-                col.use_property_decorate = False
-                col.prop(pg, 'should_convert_to_samples')
-
-        advanced_header, advanced_panel = layout.panel('advanced_panel_id', default_closed=True)
-        advanced_header.label(text='Advanced')
-
-        if advanced_panel:
-            col = advanced_panel.column()
-            col.use_property_split = True
-            col.use_property_decorate = False
-            col.prop(pg, 'bone_mapping_mode')
-
-            col = advanced_panel.column(heading='Options')
-            col.use_property_split = True
-            col.use_property_decorate = False
-            col.prop(pg, 'should_use_fake_user')
-            col.prop(pg, 'should_stash')
-            col.prop(pg, 'should_use_config_file')
-
-
-class PSA_FH_import(FileHandler):
-    bl_idname = 'PSA_FH_import'
-    bl_label = 'File handler for Unreal PSA import'
-    bl_import_operator = 'psa_import.import'
-    bl_file_extensions = '.psa'
-
-    @classmethod
-    def poll_drop(cls, context: Context):
-        return context.area and context.area.type == 'VIEW_3D'
 
 
 classes = (
@@ -273,5 +275,5 @@ classes = (
     PSA_OT_import_sequences_deselect_all,
     PSA_OT_import_sequences_from_text,
     PSA_OT_import,
-    PSA_FH_import,
+    PSA_OT_import_select_file,
 )

io_scene_psk_psa/psa/import_/properties.py

@@ -71,18 +71,17 @@ class PSA_PG_import(PropertyGroup):
             ('EXACT', 'Exact', 'Bone names must match exactly.', 'EXACT', 0),
             ('CASE_INSENSITIVE', 'Case Insensitive', 'Bones names must match, ignoring case (e.g., the bone PSA bone '
              '\'root\' can be mapped to the armature bone \'Root\')', 'CASE_INSENSITIVE', 1),
-        ),
+        )
-        default='CASE_INSENSITIVE'
     )
     fps_source: EnumProperty(name='FPS Source', items=(
         ('SEQUENCE', 'Sequence', 'The sequence frame rate matches the original frame rate', 'ACTION', 0),
-        ('SCENE', 'Scene', 'The sequence is resampled to the frame rate of the scene', 'SCENE_DATA', 1),
+        ('SCENE', 'Scene', 'The sequence frame rate dilates to match that of the scene', 'SCENE_DATA', 1),
-        ('CUSTOM', 'Custom', 'The sequence is resampled to a custom frame rate', 2),
+        ('CUSTOM', 'Custom', 'The sequence frame rate dilates to match a custom frame rate', 2),
     ))
     fps_custom: FloatProperty(
         default=30.0,
         name='Custom FPS',
-        description='The frame rate to which the imported sequences will be resampled to',
+        description='The frame rate to which the imported actions will be converted',
         options=empty_set,
         min=1.0,
         soft_min=1.0,

io_scene_psk_psa/psa/importer.py

@@ -2,7 +2,7 @@ import typing
 from typing import List, Optional
 
 import bpy
-import numpy as np
+import numpy
 from bpy.types import FCurve, Object, Context
 from mathutils import Vector, Quaternion
 
@@ -46,16 +46,16 @@ def _calculate_fcurve_data(import_bone: ImportBone, key_data: typing.Iterable[fl
     key_location = Vector(key_data[4:])
     q = import_bone.post_rotation.copy()
     q.rotate(import_bone.original_rotation)
-    rotation = q
+    quat = q
     q = import_bone.post_rotation.copy()
     if import_bone.parent is None:
         q.rotate(key_rotation.conjugated())
     else:
         q.rotate(key_rotation)
-    rotation.rotate(q.conjugated())
+    quat.rotate(q.conjugated())
-    location = key_location - import_bone.original_location
+    loc = key_location - import_bone.original_location
-    location.rotate(import_bone.post_rotation.conjugated())
+    loc.rotate(import_bone.post_rotation.conjugated())
-    return rotation.w, rotation.x, rotation.y, rotation.z, location.x, location.y, location.z
+    return quat.w, quat.x, quat.y, quat.z, loc.x, loc.y, loc.z
 
 
 class PsaImportResult:
@@ -64,12 +64,12 @@ class PsaImportResult:
 
 
 def _get_armature_bone_index_for_psa_bone(psa_bone_name: str, armature_bone_names: List[str], bone_mapping_mode: str = 'EXACT') -> Optional[int]:
-    """
+    '''
     @param psa_bone_name: The name of the PSA bone.
     @param armature_bone_names: The names of the bones in the armature.
     @param bone_mapping_mode: One of 'EXACT' or 'CASE_INSENSITIVE'.
     @return: The index of the armature bone that corresponds to the given PSA bone, or None if no such bone exists.
-    """
+    '''
     for armature_bone_index, armature_bone_name in enumerate(armature_bone_names):
         if bone_mapping_mode == 'CASE_INSENSITIVE':
             if armature_bone_name.lower() == psa_bone_name.lower():
@@ -79,51 +79,6 @@ def _get_armature_bone_index_for_psa_bone(psa_bone_name: str, armature_bone_name
                 return armature_bone_index
     return None
 
-def _get_sample_frame_times(source_frame_count: int, frame_step: float) -> typing.Iterable[float]:
-    # TODO: for correctness, we should also emit the target frame time as well (because the last frame can be a
-    #  fractional frame).
-    time = 0.0
-    while time < source_frame_count - 1:
-        yield time
-        time += frame_step
-    yield source_frame_count - 1
-
-def _resample_sequence_data_matrix(sequence_data_matrix: np.ndarray, frame_step: float = 1.0) -> np.ndarray:
-    """
-    Resamples the sequence data matrix to the target frame count.
-    @param sequence_data_matrix: FxBx7 matrix where F is the number of frames, B is the number of bones, and X is the
-    number of data elements per bone.
-    @param frame_step: The step between frames in the resampled sequence.
-    @return: The resampled sequence data matrix, or sequence_data_matrix if no resampling is necessary.
-    """
-    if frame_step == 1.0:
-        # No resampling is necessary.
-        return sequence_data_matrix
-
-    source_frame_count, bone_count = sequence_data_matrix.shape[:2]
-    sample_frame_times = list(_get_sample_frame_times(source_frame_count, frame_step))
-    target_frame_count = len(sample_frame_times)
-    resampled_sequence_data_matrix = np.zeros((target_frame_count, bone_count, 7), dtype=float)
-
-    for sample_frame_index, sample_frame_time in enumerate(sample_frame_times):
-        frame_index = int(sample_frame_time)
-        if sample_frame_time % 1.0 == 0.0:
-            # Sample time has no fractional part, so just copy the frame.
-            resampled_sequence_data_matrix[sample_frame_index, :, :] = sequence_data_matrix[frame_index, :, :]
-        else:
-            # Sample time has a fractional part, so interpolate between two frames.
-            next_frame_index = frame_index + 1
-            for bone_index in range(bone_count):
-                source_frame_1_data = sequence_data_matrix[frame_index, bone_index, :]
-                source_frame_2_data = sequence_data_matrix[next_frame_index, bone_index, :]
-                factor = sample_frame_time - frame_index
-                q = Quaternion((source_frame_1_data[:4])).slerp(Quaternion((source_frame_2_data[:4])), factor)
-                q.normalize()
-                l = Vector(source_frame_1_data[4:]).lerp(Vector(source_frame_2_data[4:]), factor)
-                resampled_sequence_data_matrix[sample_frame_index, bone_index, :] = q.w, q.x, q.y, q.z, l.x, l.y, l.z
-
-    return resampled_sequence_data_matrix
-
 
 def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object, options: PsaImportOptions) -> PsaImportResult:
     result = PsaImportResult()
@@ -143,7 +98,7 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
         if armature_bone_index is not None:
             # Ensure that no other PSA bone has been mapped to this armature bone yet.
             if armature_bone_index not in armature_to_psa_bone_indices:
-                psa_to_armature_bone_indices[psa_bone_index] = armature_bone_index
+                psa_to_armature_bone_indices[psa_bone_index] = armature_bone_names.index(psa_bone_name)
                 armature_to_psa_bone_indices[armature_bone_index] = psa_bone_index
             else:
                 # This armature bone has already been mapped to a PSA bone.
@@ -172,7 +127,7 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
 
     # Create intermediate bone data for import operations.
     import_bones = []
-    psa_bone_names_to_import_bones = dict()
+    import_bones_dict = dict()
 
     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:
@@ -182,22 +137,15 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
         import_bone = ImportBone(psa_bone)
         import_bone.armature_bone = armature_data.bones[psa_bone_name]
         import_bone.pose_bone = armature_object.pose.bones[psa_bone_name]
-        psa_bone_names_to_import_bones[psa_bone_name] = import_bone
+        import_bones_dict[psa_bone_name] = import_bone
         import_bones.append(import_bone)
 
-    bones_with_missing_parents = []
-
     for import_bone in filter(lambda x: x is not None, import_bones):
         armature_bone = import_bone.armature_bone
-        has_parent = armature_bone.parent is not None
+        if armature_bone.parent is not None and armature_bone.parent.name in psa_bone_names:
-        if has_parent:
+            import_bone.parent = import_bones_dict[armature_bone.parent.name]
-            if armature_bone.parent.name in psa_bone_names:
-                import_bone.parent = psa_bone_names_to_import_bones[armature_bone.parent.name]
-            else:
-                # Add a warning if the parent bone is not in the PSA.
-                bones_with_missing_parents.append(armature_bone)
         # Calculate the original location & rotation of each bone (in world-space maybe?)
-        if has_parent:
+        if import_bone.parent is not None:
             import_bone.original_location = armature_bone.matrix_local.translation - armature_bone.parent.matrix_local.translation
             import_bone.original_location.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
             import_bone.original_rotation = armature_bone.matrix_local.to_quaternion()
@@ -209,12 +157,6 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
 
         import_bone.post_rotation = import_bone.original_rotation.conjugated()
 
-    # Warn about bones with missing parents.
-    if len(bones_with_missing_parents) > 0:
-        count = len(bones_with_missing_parents)
-        message = f'{count} bone(s) have parents that are not present in the PSA:\n' + str([x.name for x in bones_with_missing_parents])
-        result.warnings.append(message)
-
     context.window_manager.progress_begin(0, len(sequences))
 
     # Create and populate the data for new sequences.
@@ -245,9 +187,12 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
             case _:
                 raise ValueError(f'Unknown FPS source: {options.fps_source}')
 
+        keyframe_time_dilation = target_fps / sequence.fps
+
         if options.should_write_keyframes:
-            # Remove existing f-curves.
+            # Remove existing f-curves (replace with action.fcurves.clear() in Blender 3.2)
-            action.fcurves.clear()
+            while len(action.fcurves) > 0:
+                action.fcurves.remove(action.fcurves[-1])
 
             # Create f-curves for the rotation and location of each bone.
             for psa_bone_index, armature_bone_index in psa_to_armature_bone_indices.items():
@@ -281,25 +226,19 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
                     # Calculate the local-space key data for the bone.
                     sequence_data_matrix[frame_index, bone_index] = _calculate_fcurve_data(import_bone, key_data)
 
-            # Resample the sequence data to the target FPS.
-            # If the target frame count is the same as the source frame count, this will be a no-op.
-            resampled_sequence_data_matrix = _resample_sequence_data_matrix(sequence_data_matrix,
-                                                                            frame_step=sequence.fps / target_fps)
-
             # Write the keyframes out.
-            # Note that the f-curve data consists of alternating time and value data.
+            fcurve_data = numpy.zeros(2 * sequence.frame_count, dtype=float)
-            target_frame_count = resampled_sequence_data_matrix.shape[0]
-            fcurve_data = np.zeros(2 * target_frame_count, dtype=float)
-            fcurve_data[0::2] = range(0, target_frame_count)
 
+            # Populate the keyframe time data.
+            fcurve_data[0::2] = [x * keyframe_time_dilation for x in range(sequence.frame_count)]
             for bone_index, import_bone in enumerate(import_bones):
                 if import_bone is None:
                     continue
                 for fcurve_index, fcurve in enumerate(import_bone.fcurves):
                     if fcurve is None:
                         continue
-                    fcurve_data[1::2] = resampled_sequence_data_matrix[:, bone_index, fcurve_index]
+                    fcurve_data[1::2] = sequence_data_matrix[:, bone_index, fcurve_index]
-                    fcurve.keyframe_points.add(target_frame_count)
+                    fcurve.keyframe_points.add(sequence.frame_count)
                     fcurve.keyframe_points.foreach_set('co', fcurve_data)
                     for fcurve_keyframe in fcurve.keyframe_points:
                         fcurve_keyframe.interpolation = 'LINEAR'

io_scene_psk_psa/psa/reader.py

@@ -23,11 +23,11 @@ def _try_fix_cue4parse_issue_103(sequences) -> bool:
 
 
 class PsaReader(object):
-    """
+    '''
     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):
         self.keys_data_offset: int = 0
@@ -43,11 +43,11 @@ class PsaReader(object):
         return self.psa.sequences
 
     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)
@@ -60,12 +60,12 @@ 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.
 
         @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]
         data_size = sizeof(Psa.Key)

io_scene_psk_psa/psk/export/properties.py

@@ -3,7 +3,6 @@ from bpy.types import PropertyGroup, Material
 
 from ...types import PSX_PG_bone_collection_list_item
 
-empty_set = set()
 
 class PSK_PG_material_list_item(PropertyGroup):
     material: PointerProperty(type=Material)
@@ -13,7 +12,7 @@ class PSK_PG_material_list_item(PropertyGroup):
 class PSK_PG_export(PropertyGroup):
     bone_filter_mode: EnumProperty(
         name='Bone Filter',
-        options=empty_set,
+        options=set(),
         description='',
         items=(
             ('ALL', 'All', 'All bones will be exported'),

io_scene_psk_psa/psk/import_/operators.py

@@ -2,7 +2,7 @@ import os
 import sys
 
 from bpy.props import StringProperty, BoolProperty, EnumProperty, FloatProperty
-from bpy.types import Operator, FileHandler, Context
+from bpy.types import Operator
 from bpy_extras.io_utils import ImportHelper
 
 from ..importer import PskImportOptions, import_psk
@@ -11,17 +11,6 @@ from ..reader import read_psk
 empty_set = set()
 
 
-class PSK_FH_import(FileHandler):
-    bl_idname = 'PSK_FH_import'
-    bl_label = 'File handler for Unreal PSK/PSKX import'
-    bl_import_operator = 'import_scene.psk'
-    bl_file_extensions = '.psk;.pskx'
-
-    @classmethod
-    def poll_drop(cls, context: Context):
-        return context.area and context.area.type == 'VIEW_3D'
-
-
 class PSK_OT_import(Operator, ImportHelper):
     bl_idname = 'import_scene.psk'
     bl_label = 'Import'
@@ -143,11 +132,10 @@ class PSK_OT_import(Operator, ImportHelper):
         col.use_property_decorate = False
         col.prop(self, 'scale')
 
-        mesh_header, mesh_panel = layout.panel('mesh_panel_id', default_closed=False)
+        layout.prop(self, 'should_import_mesh')
-        mesh_header.prop(self, 'should_import_mesh')
 
-        if mesh_panel and self.should_import_mesh:
+        if self.should_import_mesh:
-            row = mesh_panel.row()
+            row = layout.row()
             col = row.column()
             col.use_property_split = True
             col.use_property_decorate = False
@@ -159,11 +147,9 @@ class PSK_OT_import(Operator, ImportHelper):
                 col.prop(self, 'vertex_color_space')
             col.prop(self, 'should_import_shape_keys', text='Shape Keys')
 
-        skeleton_header, skeleton_panel = layout.panel('skeleton_panel_id', default_closed=False)
+        layout.prop(self, 'should_import_skeleton')
-        skeleton_header.prop(self, 'should_import_skeleton')
+        if self.should_import_skeleton:
-
+            row = layout.row()
-        if skeleton_panel and self.should_import_skeleton:
-            row = skeleton_panel.row()
             col = row.column()
             col.use_property_split = True
             col.use_property_decorate = False
@@ -172,5 +158,4 @@ class PSK_OT_import(Operator, ImportHelper):
 
 classes = (
     PSK_OT_import,
-    PSK_FH_import,
 )

io_scene_psk_psa/psk/importer.py

@@ -231,6 +231,8 @@ def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
             for vertex_normal in psk.vertex_normals:
                 normals.append(tuple(vertex_normal))
             mesh_data.normals_split_custom_set_from_vertices(normals)
+            # TODO: This has been removed in 4.1!
+            mesh_data.use_auto_smooth = True
         else:
             mesh_data.shade_smooth()