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

umodel, for some reason, exports some models with no bones. For
compatibility and convenience, an armature with no bones may as well not
exist, so we treat it as though it doesn't on export, and a single fake
root bone is added for maximum compatibility.

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/ISSUE_TEMPLATE/feature_request.md

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

README.md

@@ -1,24 +1,32 @@
-[![Blender](https://img.shields.io/badge/Blender->=3.4-blue?logo=blender&logoColor=white)](https://www.blender.org/download/ "Download Blender")
+[![Blender](https://img.shields.io/badge/Blender->=2.9-blue?logo=blender&logoColor=white)](https://www.blender.org/download/ "Download Blender")
 [![GitHub release](https://img.shields.io/github/release/DarklightGames/io_scene_psk_psa?include_prereleases=&sort=semver&color=blue)](https://github.com/DarklightGames/io_scene_psk_psa/releases/)
 
 [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/L4L3853VR)
 
-This Blender 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 versions of the Unreal Engine.
+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.
 
-> **NOTE**: This addon requires Blender 3.4+. If this is not available to you, install version [4.3.0](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/4.3.0), as it has a minimum Blender version of 2.9, but is no longer receiving new features.
+## Compatibility
+
+| Blender Version                                              | Addon Version                                                                  | Long Term Support |
+|--------------------------------------------------------------|--------------------------------------------------------------------------------|-------------------|
+| 4.0+                                                         | [latest](https://github.com/DarklightGames/io_scene_psk_psa/releases/latest)   | TBD               |
+| [3.4 - 3.6](https://www.blender.org/download/lts/3-6/)       | [5.0.6](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/5.0.6) | ✅️ June 2025      |
+| [2.93 - 3.3](https://www.blender.org/download/releases/3-3/) | [4.3.0](https://github.com/DarklightGames/io_scene_psk_psa/releases/tag/4.3.0) | ✅️ September 2024 |
+
+Bug fixes will be issued for legacy addon versions that are under [Blender's LTS maintenance period](https://www.blender.org/download/lts/). Once the LTS period has ended, legacy addon versions will no longer be supported by the maintainers of this repository, although we will accept pull requests for bug fixes. 
 
 # Features
 * Full PSK/PSA import and export capabilities.
 * Non-standard file section data is supported for import only (vertex normals, extra UV channels, vertex colors, shape keys).
 * Fine-grained PSA sequence importing for efficient workflow when working with large PSA files.
 * PSA sequence metadata (e.g., frame rate, sequence name) is preserved on import, allowing this data to be reused on export.
-* Specific [bone groups](https://docs.blender.org/manual/en/latest/animation/armatures/properties/bone_groups.html) can be excluded from PSK/PSA export (useful for excluding non-contributing bones such as IK controllers).
+* Specific bone collections can be excluded from PSK/PSA export (useful for excluding non-contributing bones such as IK controllers).
-* PSA sequences can be exported directly from actions or delineated using a scene's [timeline markers](https://docs.blender.org/manual/en/latest/animation/markers.html), allowing direct use of the [NLA](https://docs.blender.org/manual/en/latest/editors/nla/index.html) when creating sequences.
+* PSA sequences can be exported directly from actions or delineated using a scene's [timeline markers](https://docs.blender.org/manual/en/latest/animation/markers.html) or NLA track strips, allowing direct use of the [NLA](https://docs.blender.org/manual/en/latest/editors/nla/index.html) when creating sequences.
 * Manual re-ordering of material slots when exporting multiple mesh objects.
 
 # Installation
 1. Download the zip file for the latest version from the [releases](https://github.com/DarklightGames/io_export_psk_psa/releases) page.
-2. Open Blender 3.4.0 or later.
+2. Open Blender 4.0.0 or later.
 3. Navigate to the Blender Preferences (`Edit` > `Preferences`).
 4. Select the `Add-ons` tab.
 5. Click the `Install...` button.
@@ -46,7 +54,15 @@ This Blender add-on allows you to import and export meshes and animations to and
 3. Select the PSA file you want to import.
 4. Select the sequences that you want to import and click `Import`.
 
+> Note that in order to see the imported actions applied to your armature, you must use the [Dope Sheet](https://docs.blender.org/manual/en/latest/editors/dope_sheet/introduction.html) or [Nonlinear Animation](https://docs.blender.org/manual/en/latest/editors/nla/introduction.html) editors.
+
 # FAQ
+
+## Why can't I see the animations imported from my PSA?
+Simply importing an animation into the scene will not automatically apply the action to the armature. This is in part because a PSA can have multiple sequences imported from it, and also that it's generally bad form for importers to modify the scene when they don't need to.
+
+The PSA importer creates [Actions](https://docs.blender.org/manual/en/latest/animation/actions.html) for each of the selected sequences in the PSA. These actions can be applied to your armature via the [Action Editor](https://docs.blender.org/manual/en/latest/editors/dope_sheet/action.html) or [NLA Editor](https://docs.blender.org/manual/en/latest/editors/nla/index.html).
+
 ## Why are the mesh normals not accurate when importing a PSK extracted from [UE Viewer](https://www.gildor.org/en/projects/umodel)?
 If preserving the mesh normals of models is important for your workflow, it is *not recommended* to export PSK files from UE Viewer. This is because UE Viewer makes no attempt to reconstruct the original [smoothing groups](https://en.wikipedia.org/wiki/Smoothing_group). As a result, the normals of imported PSK files will be incorrect when imported into Blender and will need to be manually fixed.
 

io_scene_psk_psa/__init__.py

@@ -1,13 +1,15 @@
+from bpy.app.handlers import persistent
+
 bl_info = {
-    "name": "PSK/PSA Importer/Exporter",
+    'name': 'PSK/PSA Importer/Exporter',
-    "author": "Colin Basnett, Yurii Ti",
+    'author': 'Colin Basnett, Yurii Ti',
-    "version": (5, 0, 2),
+    'version': (6, 2, 0),
-    "blender": (3, 4, 0),
+    'blender': (4, 0, 0),
-    "description": "PSK/PSA Import/Export (.psk/.psa)",
+    'description': 'PSK/PSA Import/Export (.psk/.psa)',
-    "warning": "",
+    'warning': '',
-    "doc_url": "https://github.com/DarklightGames/io_scene_psk_psa",
+    'doc_url': 'https://github.com/DarklightGames/io_scene_psk_psa',
-    "tracker_url": "https://github.com/DarklightGames/io_scene_psk_psa/issues",
+    'tracker_url': 'https://github.com/DarklightGames/io_scene_psk_psa/issues',
-    "category": "Import-Export"
+    'category': 'Import-Export'
 }
 
 if 'bpy' in locals():
@@ -22,15 +24,19 @@ if 'bpy' in locals():
     importlib.reload(psk_writer)
     importlib.reload(psk_builder)
     importlib.reload(psk_importer)
+    importlib.reload(psk_properties)
+    importlib.reload(psk_ui)
     importlib.reload(psk_export_properties)
     importlib.reload(psk_export_operators)
     importlib.reload(psk_export_ui)
     importlib.reload(psk_import_operators)
 
     importlib.reload(psa_data)
+    importlib.reload(psa_config)
     importlib.reload(psa_reader)
     importlib.reload(psa_writer)
     importlib.reload(psa_builder)
+    importlib.reload(psa_importer)
     importlib.reload(psa_export_properties)
     importlib.reload(psa_export_operators)
     importlib.reload(psa_export_ui)
@@ -47,12 +53,15 @@ else:
     from .psk import writer as psk_writer
     from .psk import builder as psk_builder
     from .psk import importer as psk_importer
+    from .psk import properties as psk_properties
+    from .psk import ui as psk_ui
     from .psk.export import properties as psk_export_properties
     from .psk.export import operators as psk_export_operators
     from .psk.export import ui as psk_export_ui
     from .psk.import_ import operators as psk_import_operators
 
     from .psa import data as psa_data
+    from .psa import config as psa_config
     from .psa import reader as psa_reader
     from .psa import writer as psa_writer
     from .psa import builder as psa_builder
@@ -68,6 +77,8 @@ import bpy
 from bpy.props import PointerProperty
 
 classes = psx_types.classes +\
+          psk_properties.classes +\
+          psk_ui.classes +\
           psk_import_operators.classes +\
           psk_export_properties.classes +\
           psk_export_operators.classes +\
@@ -103,6 +114,7 @@ def register():
     bpy.types.TOPBAR_MT_file_import.append(psk_import_menu_func)
     bpy.types.TOPBAR_MT_file_export.append(psa_export_menu_func)
     bpy.types.TOPBAR_MT_file_import.append(psa_import_menu_func)
+    bpy.types.Material.psk = PointerProperty(type=psk_properties.PSX_PG_material)
     bpy.types.Scene.psa_import = PointerProperty(type=psa_import_properties.PSA_PG_import)
     bpy.types.Scene.psa_export = PointerProperty(type=psa_export_properties.PSA_PG_export)
     bpy.types.Scene.psk_export = PointerProperty(type=psk_export_properties.PSK_PG_export)
@@ -110,6 +122,7 @@ def register():
 
 
 def unregister():
+    del bpy.types.Material.psk
     del bpy.types.Scene.psa_import
     del bpy.types.Scene.psa_export
     del bpy.types.Scene.psk_export
@@ -124,3 +137,16 @@ def unregister():
 
 if __name__ == '__main__':
     register()
+
+
+@persistent
+def load_handler(dummy):
+    # Convert old `psa_sequence_fps` property to new `psa_export.fps` property.
+    # This is only needed for backwards compatibility with files that may have used older versions of the addon.
+    for action in bpy.data.actions:
+        if 'psa_sequence_fps' in action:
+            action.psa_export.fps = action['psa_sequence_fps']
+            del action['psa_sequence_fps']
+
+
+bpy.app.handlers.load_post.append(load_handler)

io_scene_psk_psa/helpers.py

@@ -1,7 +1,5 @@
-import datetime
 import re
 import typing
-from collections import Counter
 from typing import List, Iterable
 
 import addon_utils
@@ -9,24 +7,6 @@ import bpy.types
 from bpy.types import NlaStrip, Object, AnimData
 
 
-class Timer:
-    def __enter__(self):
-        self.start = datetime.datetime.now()
-        self.interval = None
-        return self
-
-    def __exit__(self, *args):
-        self.end = datetime.datetime.now()
-        self.interval = self.end - self.start
-
-    @property
-    def duration(self):
-        if self.interval is not None:
-            return self.interval
-        else:
-            return datetime.datetime.now() - self.start
-
-
 def rgb_to_srgb(c: float):
     if c > 0.0031308:
         return 1.055 * (pow(c, (1.0 / 2.4))) - 0.055
@@ -34,7 +14,7 @@ def rgb_to_srgb(c: float):
         return 12.92 * c
 
 
-def get_nla_strips_in_timeframe(animation_data: AnimData, frame_min: float, frame_max: float) -> List[NlaStrip]:
+def get_nla_strips_in_frame_range(animation_data: AnimData, frame_min: float, frame_max: float) -> List[NlaStrip]:
     if animation_data is None:
         return []
     strips = []
@@ -49,43 +29,49 @@ def get_nla_strips_in_timeframe(animation_data: AnimData, frame_min: float, fram
     return strips
 
 
-def populate_bone_group_list(armature_object: Object, bone_group_list: bpy.props.CollectionProperty) -> None:
+def populate_bone_collection_list(armature_object: Object, bone_collection_list: bpy.props.CollectionProperty) -> None:
-    """
+    '''
-    Updates the bone group collection.
+    Updates the bone collections collection.
 
-    Bone group selections are preserved between updates unless none of the groups were previously selected;
+    Bone collection selections are preserved between updates unless none of the groups were previously selected;
-    otherwise, all groups are selected by default.
+    otherwise, all collections are selected by default.
-    """
+    '''
-    has_selected_groups = any([g.is_selected for g in bone_group_list])
+    has_selected_collections = any([g.is_selected for g in bone_collection_list])
-    unassigned_group_is_selected, selected_assigned_group_names = True, []
+    unassigned_collection_is_selected, selected_assigned_collection_names = True, []
 
-    if has_selected_groups:
+    if armature_object is None:
+        return
+
+    if has_selected_collections:
         # Preserve group selections before clearing the list.
         # We handle selections for the unassigned group separately to cover the edge case
         # where there might be an actual group with 'Unassigned' as its name.
-        unassigned_group_idx, unassigned_group_is_selected = next(iter([
+        unassigned_collection_idx, unassigned_collection_is_selected = next(iter([
-            (i, g.is_selected) for i, g in enumerate(bone_group_list) if g.index == -1]), (-1, False))
+            (i, g.is_selected) for i, g in enumerate(bone_collection_list) if g.index == -1]), (-1, False))
 
-        selected_assigned_group_names = [
+        selected_assigned_collection_names = [
-            g.name for i, g in enumerate(bone_group_list) if i != unassigned_group_idx and g.is_selected]
+            g.name for i, g in enumerate(bone_collection_list) if i != unassigned_collection_idx and g.is_selected]
 
-    bone_group_list.clear()
+    bone_collection_list.clear()
 
-    if armature_object and armature_object.pose:
+    armature = armature_object.data
-        bone_group_counts = Counter(map(lambda x: x.bone_group, armature_object.pose.bones))
 
-        item = bone_group_list.add()
+    if armature is None:
-        item.name = 'Unassigned'
+        return
-        item.index = -1
-        item.count = 0 if None not in bone_group_counts else bone_group_counts[None]
-        item.is_selected = unassigned_group_is_selected
 
-        for bone_group_index, bone_group in enumerate(armature_object.pose.bone_groups):
+    item = bone_collection_list.add()
-            item = bone_group_list.add()
+    item.name = 'Unassigned'
-            item.name = bone_group.name
+    item.index = -1
-            item.index = bone_group_index
+    # Count the number of bones without an assigned bone collection
-            item.count = 0 if bone_group not in bone_group_counts else bone_group_counts[bone_group]
+    item.count = sum(map(lambda bone: 1 if len(bone.collections) == 0 else 0, armature.bones))
-            item.is_selected = bone_group.name in selected_assigned_group_names if has_selected_groups else True
+    item.is_selected = unassigned_collection_is_selected
+
+    for bone_collection_index, bone_collection in enumerate(armature.collections):
+        item = bone_collection_list.add()
+        item.name = bone_collection.name
+        item.index = bone_collection_index
+        item.count = len(bone_collection.bones)
+        item.is_selected = bone_collection.name in selected_assigned_collection_names if has_selected_collections else True
 
 
 def check_bone_names(bone_names: Iterable[str]):
@@ -97,32 +83,37 @@ def check_bone_names(bone_names: Iterable[str]):
                            f'You can bypass this by disabling "Enforce Bone Name Restrictions" in the export settings.')
 
 
-def get_export_bone_names(armature_object: Object, bone_filter_mode: str, bone_group_indices: List[int]) -> List[str]:
+def get_export_bone_names(armature_object: Object, bone_filter_mode: str, bone_collection_indices: List[int]) -> List[str]:
-    """
+    '''
-    Returns a sorted list of bone indices that should be exported for the given bone filter mode and bone groups.
+    Returns a sorted list of bone indices that should be exported for the given bone filter mode and bone collections.
 
-    Note that the ancestors of bones within the bone groups will also be present in the returned list.
+    Note that the ancestors of bones within the bone collections will also be present in the returned list.
 
     :param armature_object: Blender object with type 'ARMATURE'
-    :param bone_filter_mode: One of ['ALL', 'BONE_GROUPS']
+    :param bone_filter_mode: One of ['ALL', 'BONE_COLLECTIONS']
-    :param bone_group_indices: List of bone group indices to be exported.
+    :param bone_collection_indices: List of bone collection indices to be exported.
     :return: A sorted list of bone indices that should be exported.
-    """
+    '''
     if armature_object is None or armature_object.type != 'ARMATURE':
         raise ValueError('An armature object must be supplied')
 
     armature_data = typing.cast(bpy.types.Armature, armature_object.data)
     bones = armature_data.bones
-    pose_bones = armature_object.pose.bones
     bone_names = [x.name for x in bones]
 
     # Get a list of the bone indices that we are explicitly including.
     bone_index_stack = []
-    is_exporting_none_bone_groups = -1 in bone_group_indices
+    is_exporting_unassigned_bone_collections = -1 in bone_collection_indices
-    for bone_index, pose_bone in enumerate(pose_bones):
+    bone_collections = list(armature_data.collections)
+
+    for bone_index, bone in enumerate(bones):
+        # Check if this bone is in any of the collections in the bone collection indices list.
+        this_bone_collection_indices = set(bone_collections.index(x) for x in bone.collections)
+        is_in_exported_bone_collections = len(set(bone_collection_indices).intersection(this_bone_collection_indices)) > 0
+
         if bone_filter_mode == 'ALL' or \
-                (pose_bone.bone_group is None and is_exporting_none_bone_groups) or \
+                (len(bone.collections) == 0 and is_exporting_unassigned_bone_collections) or \
-                (pose_bone.bone_group is not None and pose_bone.bone_group_index in bone_group_indices):
+                is_in_exported_bone_collections:
             bone_index_stack.append((bone_index, None))
 
     # For each bone that is explicitly being added, recursively walk up the hierarchy and ensure that all of
@@ -143,7 +134,7 @@ def get_export_bone_names(armature_object: Object, bone_filter_mode: str, bone_g
 
     # Split out the bone indices and the instigator bone names into separate lists.
     # We use the bone names for the return values because the bone name is a more universal way of referencing them.
-    # For example, users of this function may modify bone lists, which would invalidate the indices and require a
+    # For example, users of this function may modify bone lists, which would invalidate the indices and require an
     # index mapping scheme to resolve it. Using strings is more comfy and results in less code downstream.
     instigator_bone_names = [bones[x[1]].name if x[1] is not None else None for x in bone_indices]
     bone_names = [bones[x[0]].name for x in bone_indices]

io_scene_psk_psa/psa/builder.py

@@ -26,7 +26,7 @@ class PsaBuildOptions:
         self.animation_data: Optional[AnimData] = None
         self.sequences: List[PsaBuildSequence] = []
         self.bone_filter_mode: str = 'ALL'
-        self.bone_group_indices: List[int] = []
+        self.bone_collection_indices: List[int] = []
         self.should_enforce_bone_name_restrictions: bool = False
         self.sequence_name_prefix: str = ''
         self.sequence_name_suffix: str = ''
@@ -73,7 +73,7 @@ def build_psa(context: bpy.types.Context, options: PsaBuildOptions) -> Psa:
     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_object, options.bone_filter_mode, options.bone_group_indices)
+    export_bone_names = get_export_bone_names(armature_object, options.bone_filter_mode, options.bone_collection_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.
@@ -91,7 +91,11 @@ def build_psa(context: bpy.types.Context, options: PsaBuildOptions) -> Psa:
     # Build list of PSA bones.
     for bone in bones:
         psa_bone = Psa.Bone()
-        psa_bone.name = bytes(bone.name, encoding='windows-1252')
+
+        try:
+            psa_bone.name = bytes(bone.name, encoding='windows-1252')
+        except UnicodeEncodeError:
+            raise RuntimeError(f'Bone name "{bone.name}" contains characters that cannot be encoded in the Windows-1252 codepage')
 
         try:
             parent_index = bones.index(bone.parent)
@@ -165,7 +169,10 @@ def build_psa(context: bpy.types.Context, options: PsaBuildOptions) -> Psa:
             frame_step = -frame_step
 
         psa_sequence = Psa.Sequence()
-        psa_sequence.name = bytes(export_sequence.name, encoding='windows-1252')
+        try:
+            psa_sequence.name = bytes(export_sequence.name, encoding='windows-1252')
+        except UnicodeEncodeError:
+            raise RuntimeError(f'Sequence name "{export_sequence.name}" contains characters that cannot be encoded in the Windows-1252 codepage')
         psa_sequence.frame_count = frame_count
         psa_sequence.frame_start_index = frame_start_index
         psa_sequence.fps = frame_count / sequence_duration

io_scene_psk_psa/psa/config.py

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

io_scene_psk_psa/psa/data.py

@@ -4,10 +4,10 @@ from typing import List
 
 from ..data import *
 
-"""
+'''
 Note that keys are not stored within the Psa object.
 Use the PsaReader::get_sequence_keys to get the keys for a sequence.
-"""
+'''
 
 
 class Psa:

io_scene_psk_psa/psa/export/operators.py

@@ -8,10 +8,10 @@ from bpy.types import Context, Armature, Action, Object, AnimData, TimelineMarke
 from bpy_extras.io_utils import ExportHelper
 from bpy_types import Operator
 
-from io_scene_psk_psa.helpers import populate_bone_group_list, get_nla_strips_in_timeframe
+from .properties import PSA_PG_export, PSA_PG_export_action_list_item, filter_sequences
-from io_scene_psk_psa.psa.builder import build_psa, PsaBuildSequence, PsaBuildOptions
+from ..builder import build_psa, PsaBuildSequence, PsaBuildOptions
-from io_scene_psk_psa.psa.export.properties import PSA_PG_export, PSA_PG_export_action_list_item, filter_sequences
+from ..writer import write_psa
-from io_scene_psk_psa.psa.writer import write_psa
+from ...helpers import populate_bone_collection_list, get_nla_strips_in_frame_range
 
 
 def is_action_for_armature(armature: Armature, action: Action):
@@ -47,7 +47,7 @@ def update_actions_and_timeline_markers(context: Context, armature: Armature):
         if not is_action_for_armature(armature, action):
             continue
 
-        if not action.name.startswith('#'):
+        if action.name != '' and not action.name.startswith('#'):
             for (name, frame_start, frame_end) in get_sequences_from_action(action):
                 item = pg.action_list.add()
                 item.action = action
@@ -60,7 +60,7 @@ def update_actions_and_timeline_markers(context: Context, armature: Armature):
         # Pose markers are not guaranteed to be in frame-order, so make sure that they are.
         pose_markers = sorted(action.pose_markers, key=lambda x: x.frame)
         for pose_marker_index, pose_marker in enumerate(pose_markers):
-            if pose_marker.name.startswith('#'):
+            if pose_marker.name.strip() == '' or pose_marker.name.startswith('#'):
                 continue
             for (name, frame_start, frame_end) in get_sequences_from_action_pose_marker(action, pose_markers, pose_marker, pose_marker_index):
                 item = pg.action_list.add()
@@ -78,14 +78,16 @@ def update_actions_and_timeline_markers(context: Context, armature: Armature):
     for marker_name in marker_names:
         if marker_name not in sequence_frame_ranges:
             continue
-        if marker_name.startswith('#'):
+        if marker_name.strip() == '' or marker_name.startswith('#'):
             continue
-        item = pg.marker_list.add()
-        item.name = marker_name
-        item.is_selected = False
         frame_start, frame_end = sequence_frame_ranges[marker_name]
-        item.frame_start = frame_start
+        sequences = get_sequences_from_name_and_frame_range(marker_name, frame_start, frame_end)
-        item.frame_end = frame_end
+        for (sequence_name, frame_start, frame_end) in sequences:
+            item = pg.marker_list.add()
+            item.name = sequence_name
+            item.is_selected = False
+            item.frame_start = frame_start
+            item.frame_end = frame_end
 
 
 def get_sequence_fps(context: Context, fps_source: str, fps_custom: float, actions: Iterable[Action]) -> float:
@@ -95,16 +97,7 @@ def get_sequence_fps(context: Context, fps_source: str, fps_custom: float, actio
         return fps_custom
     elif fps_source == 'ACTION_METADATA':
         # Get the minimum value of action metadata FPS values.
-        fps_list = []
+        return min([action.psa_export.fps for action in actions])
-        for action in filter(lambda x: 'psa_sequence_fps' in x, actions):
-            fps = action['psa_sequence_fps']
-            if type(fps) == int or type(fps) == float:
-                fps_list.append(fps)
-        if len(fps_list) > 0:
-            return min(fps_list)
-        else:
-            # No valid action metadata to use, fallback to scene FPS
-            return context.scene.render.fps
     else:
         raise RuntimeError(f'Invalid FPS source "{fps_source}"')
 
@@ -117,7 +110,7 @@ def get_animation_data_object(context: Context) -> Object:
     if active_object.type != 'ARMATURE':
         raise RuntimeError('Selected object must be an Armature')
 
-    if pg.should_override_animation_data:
+    if pg.sequence_source != 'ACTIONS' and pg.should_override_animation_data:
         animation_data_object = pg.animation_data_override
     else:
         animation_data_object = active_object
@@ -126,9 +119,9 @@ def get_animation_data_object(context: Context) -> Object:
 
 
 def is_bone_filter_mode_item_available(context, identifier):
-    if identifier == 'BONE_GROUPS':
+    if identifier == 'BONE_COLLECTIONS':
-        obj = context.active_object
+        armature = context.active_object.data
-        if not obj.pose or not obj.pose.bone_groups:
+        if len(armature.collections) == 0:
             return False
     return True
 
@@ -150,7 +143,7 @@ def get_timeline_marker_sequence_frame_ranges(animation_data: AnimData, context:
         if next_marker_index < len(sorted_timeline_markers):
             # There is a next marker. Use that next marker's frame position as the last frame of this sequence.
             frame_end = sorted_timeline_markers[next_marker_index].frame
-            nla_strips = get_nla_strips_in_timeframe(animation_data, marker.frame, frame_end)
+            nla_strips = get_nla_strips_in_frame_range(animation_data, marker.frame, frame_end)
             if len(nla_strips) > 0:
                 frame_end = min(frame_end, max(map(lambda nla_strip: nla_strip.frame_end, nla_strips)))
                 frame_start = max(frame_start, min(map(lambda nla_strip: nla_strip.frame_start, nla_strips)))
@@ -174,11 +167,9 @@ def get_timeline_marker_sequence_frame_ranges(animation_data: AnimData, context:
     return sequence_frame_ranges
 
 
-def get_sequences_from_action(action: Action) -> List[Tuple[str, int, int]]:
+def get_sequences_from_name_and_frame_range(name: str, frame_start: int, frame_end: int) -> List[Tuple[str, int, int]]:
-    frame_start = int(action.frame_range[0])
-    frame_end = int(action.frame_range[1])
     reversed_pattern = r'(.+)/(.+)'
-    reversed_match = re.match(reversed_pattern, action.name)
+    reversed_match = re.match(reversed_pattern, name)
     if reversed_match:
         forward_name = reversed_match.group(1)
         backwards_name = reversed_match.group(2)
@@ -187,7 +178,13 @@ def get_sequences_from_action(action: Action) -> List[Tuple[str, int, int]]:
             (backwards_name, frame_end, frame_start)
         ]
     else:
-        return [(action.name, frame_start, frame_end)]
+        return [(name, frame_start, frame_end)]
+
+
+def get_sequences_from_action(action: Action) -> List[Tuple[str, int, int]]:
+    frame_start = int(action.frame_range[0])
+    frame_end = int(action.frame_range[1])
+    return get_sequences_from_name_and_frame_range(action.name, frame_start, frame_end)
 
 
 def get_sequences_from_action_pose_marker(action: Action, pose_markers: List[TimelineMarker], pose_marker: TimelineMarker, pose_marker_index: int) -> List[Tuple[str, int, int]]:
@@ -196,17 +193,7 @@ def get_sequences_from_action_pose_marker(action: Action, pose_markers: List[Tim
         frame_end = pose_markers[pose_marker_index + 1].frame
     else:
         frame_end = int(action.frame_range[1])
-    reversed_pattern = r'(.+)/(.+)'
+    return get_sequences_from_name_and_frame_range(pose_marker.name, frame_start, frame_end)
-    reversed_match = re.match(reversed_pattern, pose_marker.name)
-    if reversed_match:
-        forward_name = reversed_match.group(1)
-        backwards_name = reversed_match.group(2)
-        return [
-            (forward_name, frame_start, frame_end),
-            (backwards_name, frame_end, frame_start)
-        ]
-    else:
-        return [(pose_marker.name, frame_start, frame_end)]
 
 
 def get_visible_sequences(pg: PSA_PG_export, sequences) -> List[PSA_PG_export_action_list_item]:
@@ -254,12 +241,18 @@ class PSA_OT_export(Operator, ExportHelper):
         # SOURCE
         layout.prop(pg, 'sequence_source', text='Source')
 
-        if pg.sequence_source == 'TIMELINE_MARKERS':
+        if pg.sequence_source in {'TIMELINE_MARKERS', 'NLA_TRACK_STRIPS'}:
             # ANIMDATA SOURCE
             layout.prop(pg, 'should_override_animation_data')
             if pg.should_override_animation_data:
                 layout.prop(pg, 'animation_data_override', text='')
 
+        if pg.sequence_source == 'NLA_TRACK_STRIPS':
+            flow = layout.grid_flow()
+            flow.use_property_split = True
+            flow.use_property_decorate = False
+            flow.prop(pg, 'nla_track')
+
         # SELECT ALL/NONE
         row = layout.row(align=True)
         row.label(text='Select')
@@ -269,25 +262,19 @@ class PSA_OT_export(Operator, ExportHelper):
         # ACTIONS
         if pg.sequence_source == 'ACTIONS':
             rows = max(3, min(len(pg.action_list), 10))
-
             layout.template_list('PSA_UL_export_sequences', '', pg, 'action_list', pg, 'action_list_index', rows=rows)
-
-            col = layout.column()
-            col.use_property_split = True
-            col.use_property_decorate = False
-            col.prop(pg, 'sequence_name_prefix')
-            col.prop(pg, 'sequence_name_suffix')
-
         elif pg.sequence_source == 'TIMELINE_MARKERS':
             rows = max(3, min(len(pg.marker_list), 10))
-            layout.template_list('PSA_UL_export_sequences', '', pg, 'marker_list', pg, 'marker_list_index',
+            layout.template_list('PSA_UL_export_sequences', '', pg, 'marker_list', pg, 'marker_list_index', rows=rows)
-                                 rows=rows)
+        elif pg.sequence_source == 'NLA_TRACK_STRIPS':
+            rows = max(3, min(len(pg.nla_strip_list), 10))
+            layout.template_list('PSA_UL_export_sequences', '', pg, 'nla_strip_list', pg, 'nla_strip_list_index', rows=rows)
 
-            col = layout.column()
+        col = layout.column()
-            col.use_property_split = True
+        col.use_property_split = True
-            col.use_property_decorate = False
+        col.use_property_decorate = False
-            col.prop(pg, 'sequence_name_prefix')
+        col.prop(pg, 'sequence_name_prefix')
-            col.prop(pg, 'sequence_name_suffix')
+        col.prop(pg, 'sequence_name_suffix')
 
         # Determine if there is going to be a naming conflict and display an error, if so.
         selected_items = [x for x in pg.action_list if x.is_selected]
@@ -304,13 +291,13 @@ class PSA_OT_export(Operator, ExportHelper):
         row = layout.row(align=True)
         row.prop(pg, 'bone_filter_mode', text='Bones')
 
-        if pg.bone_filter_mode == 'BONE_GROUPS':
+        if pg.bone_filter_mode == 'BONE_COLLECTIONS':
             row = layout.row(align=True)
             row.label(text='Select')
-            row.operator(PSA_OT_export_bone_groups_select_all.bl_idname, text='All', icon='CHECKBOX_HLT')
+            row.operator(PSA_OT_export_bone_collections_select_all.bl_idname, text='All', icon='CHECKBOX_HLT')
-            row.operator(PSA_OT_export_bone_groups_deselect_all.bl_idname, text='None', icon='CHECKBOX_DEHLT')
+            row.operator(PSA_OT_export_bone_collections_deselect_all.bl_idname, text='None', icon='CHECKBOX_DEHLT')
-            rows = max(3, min(len(pg.bone_group_list), 10))
+            rows = max(3, min(len(pg.bone_collection_list), 10))
-            layout.template_list('PSX_UL_bone_group_list', '', pg, 'bone_group_list', pg, 'bone_group_list_index',
+            layout.template_list('PSX_UL_bone_collection_list', '', pg, 'bone_collection_list', pg, 'bone_collection_list_index',
                                  rows=rows)
 
         layout.prop(pg, 'should_enforce_bone_name_restrictions')
@@ -345,8 +332,7 @@ class PSA_OT_export(Operator, ExportHelper):
 
         update_actions_and_timeline_markers(context, self.armature_object.data)
 
-        # Populate bone groups list.
+        populate_bone_collection_list(self.armature_object, pg.bone_collection_list)
-        populate_bone_group_list(self.armature_object, pg.bone_group_list)
 
         context.window_manager.fileselect_add(self)
 
@@ -358,8 +344,10 @@ class PSA_OT_export(Operator, ExportHelper):
         # Ensure that we actually have items that we are going to be exporting.
         if pg.sequence_source == 'ACTIONS' and len(pg.action_list) == 0:
             raise RuntimeError('No actions were selected for export')
-        elif pg.sequence_source == 'TIMELINE_MARKERS' and len(pg.marker_names) == 0:
+        elif pg.sequence_source == 'TIMELINE_MARKERS' and len(pg.marker_list) == 0:
             raise RuntimeError('No timeline markers were selected for export')
+        elif pg.sequence_source == 'NLA_TRACK_STRIPS' and len(pg.nla_strip_list) == 0:
+            raise RuntimeError('No NLA track strips were selected for export')
 
         # Populate the export sequence list.
         animation_data_object = get_animation_data_object(context)
@@ -371,29 +359,38 @@ class PSA_OT_export(Operator, ExportHelper):
         export_sequences: List[PsaBuildSequence] = []
 
         if pg.sequence_source == 'ACTIONS':
-            for action in filter(lambda x: x.is_selected, pg.action_list):
+            for action_item in filter(lambda x: x.is_selected, pg.action_list):
-                if len(action.action.fcurves) == 0:
+                if len(action_item.action.fcurves) == 0:
                     continue
                 export_sequence = PsaBuildSequence()
-                export_sequence.nla_state.action = action.action
+                export_sequence.nla_state.action = action_item.action
-                export_sequence.name = action.name
+                export_sequence.name = action_item.name
-                export_sequence.nla_state.frame_start = action.frame_start
+                export_sequence.nla_state.frame_start = action_item.frame_start
-                export_sequence.nla_state.frame_end = action.frame_end
+                export_sequence.nla_state.frame_end = action_item.frame_end
-                export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, [action.action])
+                export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, [action_item.action])
-                export_sequence.compression_ratio = action.action.psa_export.compression_ratio
+                export_sequence.compression_ratio = action_item.action.psa_export.compression_ratio
-                export_sequence.key_quota = action.action.psa_export.key_quota
+                export_sequence.key_quota = action_item.action.psa_export.key_quota
                 export_sequences.append(export_sequence)
         elif pg.sequence_source == 'TIMELINE_MARKERS':
-            for marker in pg.marker_list:
+            for marker_item in filter(lambda x: x.is_selected, pg.marker_list):
                 export_sequence = PsaBuildSequence()
-                export_sequence.name = marker.name
+                export_sequence.name = marker_item.name
                 export_sequence.nla_state.action = None
-                export_sequence.nla_state.frame_start = marker.frame_start
+                export_sequence.nla_state.frame_start = marker_item.frame_start
-                export_sequence.nla_state.frame_end = marker.frame_end
+                export_sequence.nla_state.frame_end = marker_item.frame_end
                 nla_strips_actions = set(
-                    map(lambda x: x.action, get_nla_strips_in_timeframe(animation_data, marker.frame_start, marker.frame_end)))
+                    map(lambda x: x.action, get_nla_strips_in_frame_range(animation_data, marker_item.frame_start, marker_item.frame_end)))
                 export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, nla_strips_actions)
                 export_sequences.append(export_sequence)
+        elif pg.sequence_source == 'NLA_TRACK_STRIPS':
+            for nla_strip_item in filter(lambda x: x.is_selected, pg.nla_strip_list):
+                export_sequence = PsaBuildSequence()
+                export_sequence.name = nla_strip_item.name
+                export_sequence.nla_state.action = None
+                export_sequence.nla_state.frame_start = nla_strip_item.frame_start
+                export_sequence.nla_state.frame_end = nla_strip_item.frame_end
+                export_sequence.fps = get_sequence_fps(context, pg.fps_source, pg.fps_custom, [nla_strip_item.action])
+                export_sequences.append(export_sequence)
         else:
             raise ValueError(f'Unhandled sequence source: {pg.sequence_source}')
 
@@ -401,7 +398,7 @@ class PSA_OT_export(Operator, ExportHelper):
         options.animation_data = animation_data
         options.sequences = export_sequences
         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.bone_collection_indices = [x.index for x in pg.bone_collection_list if x.is_selected]
         options.should_ignore_bone_name_restrictions = pg.should_enforce_bone_name_restrictions
         options.sequence_name_prefix = pg.sequence_name_prefix
         options.sequence_name_suffix = pg.sequence_name_suffix
@@ -432,6 +429,8 @@ class PSA_OT_export_actions_select_all(Operator):
             return pg.action_list
         elif pg.sequence_source == 'TIMELINE_MARKERS':
             return pg.marker_list
+        elif pg.sequence_source == 'NLA_TRACK_STRIPS':
+            return pg.nla_strip_list
         return None
 
     @classmethod
@@ -463,6 +462,8 @@ class PSA_OT_export_actions_deselect_all(Operator):
             return pg.action_list
         elif pg.sequence_source == 'TIMELINE_MARKERS':
             return pg.marker_list
+        elif pg.sequence_source == 'NLA_TRACK_STRIPS':
+            return pg.nla_strip_list
         return None
 
     @classmethod
@@ -479,42 +480,42 @@ class PSA_OT_export_actions_deselect_all(Operator):
         return {'FINISHED'}
 
 
-class PSA_OT_export_bone_groups_select_all(Operator):
+class PSA_OT_export_bone_collections_select_all(Operator):
-    bl_idname = 'psa_export.bone_groups_select_all'
+    bl_idname = 'psa_export.bone_collections_select_all'
     bl_label = 'Select All'
-    bl_description = 'Select all bone groups'
+    bl_description = 'Select all bone collections'
     bl_options = {'INTERNAL'}
 
     @classmethod
     def poll(cls, context):
         pg = getattr(context.scene, 'psa_export')
-        item_list = pg.bone_group_list
+        item_list = pg.bone_collection_list
         has_unselected_items = any(map(lambda action: not action.is_selected, item_list))
         return len(item_list) > 0 and has_unselected_items
 
     def execute(self, context):
         pg = getattr(context.scene, 'psa_export')
-        for item in pg.bone_group_list:
+        for item in pg.bone_collection_list:
             item.is_selected = True
         return {'FINISHED'}
 
 
-class PSA_OT_export_bone_groups_deselect_all(Operator):
+class PSA_OT_export_bone_collections_deselect_all(Operator):
-    bl_idname = 'psa_export.bone_groups_deselect_all'
+    bl_idname = 'psa_export.bone_collections_deselect_all'
     bl_label = 'Deselect All'
-    bl_description = 'Deselect all bone groups'
+    bl_description = 'Deselect all bone collections'
     bl_options = {'INTERNAL'}
 
     @classmethod
     def poll(cls, context):
         pg = getattr(context.scene, 'psa_export')
-        item_list = pg.bone_group_list
+        item_list = pg.bone_collection_list
         has_selected_actions = any(map(lambda action: action.is_selected, item_list))
         return len(item_list) > 0 and has_selected_actions
 
     def execute(self, context):
         pg = getattr(context.scene, 'psa_export')
-        for action in pg.bone_group_list:
+        for action in pg.bone_collection_list:
             action.is_selected = False
         return {'FINISHED'}
 
@@ -523,6 +524,6 @@ classes = (
     PSA_OT_export,
     PSA_OT_export_actions_select_all,
     PSA_OT_export_actions_deselect_all,
-    PSA_OT_export_bone_groups_select_all,
+    PSA_OT_export_bone_collections_select_all,
-    PSA_OT_export_bone_groups_deselect_all,
+    PSA_OT_export_bone_collections_deselect_all,
 )

io_scene_psk_psa/psa/export/properties.py

@@ -1,12 +1,13 @@
+import re
 import sys
 from fnmatch import fnmatch
-from typing import List
+from typing import List, Optional
 
 from bpy.props import BoolProperty, PointerProperty, EnumProperty, FloatProperty, CollectionProperty, IntProperty, \
     StringProperty
-from bpy.types import PropertyGroup, Object, Action
+from bpy.types import PropertyGroup, Object, Action, AnimData, Context
 
-from ...types import PSX_PG_bone_group_list_item
+from ...types import PSX_PG_bone_collection_list_item
 
 
 def psa_export_property_group_animation_data_override_poll(_context, obj):
@@ -19,13 +20,13 @@ empty_set = set()
 class PSA_PG_export_action_list_item(PropertyGroup):
     action: PointerProperty(type=Action)
     name: StringProperty()
-    is_selected: BoolProperty(default=False)
+    is_selected: BoolProperty(default=True)
     frame_start: IntProperty(options={'HIDDEN'})
     frame_end: IntProperty(options={'HIDDEN'})
     is_pose_marker: BoolProperty(options={'HIDDEN'})
 
 
-class PSA_PG_export_timeline_markers(PropertyGroup):
+class PSA_PG_export_timeline_markers(PropertyGroup):  # TODO: rename this to singular
     marker_index: IntProperty()
     name: StringProperty()
     is_selected: BoolProperty(default=True)
@@ -33,6 +34,51 @@ class PSA_PG_export_timeline_markers(PropertyGroup):
     frame_end: IntProperty(options={'HIDDEN'})
 
 
+class PSA_PG_export_nla_strip_list_item(PropertyGroup):
+    name: StringProperty()
+    action: PointerProperty(type=Action)
+    frame_start: FloatProperty()
+    frame_end: FloatProperty()
+    is_selected: BoolProperty(default=True)
+
+
+def nla_track_update_cb(self: 'PSA_PG_export', context: Context) -> None:
+    self.nla_strip_list.clear()
+    if context.object is None or context.object.animation_data is None:
+        return
+    match = re.match(r'^(\d+).+$', self.nla_track)
+    self.nla_track_index = int(match.group(1)) if match else -1
+    if self.nla_track_index >= 0:
+        nla_track = context.object.animation_data.nla_tracks[self.nla_track_index]
+        for nla_strip in nla_track.strips:
+            strip: PSA_PG_export_nla_strip_list_item = self.nla_strip_list.add()
+            strip.action = nla_strip.action
+            strip.name = nla_strip.name
+            strip.frame_start = nla_strip.frame_start
+            strip.frame_end = nla_strip.frame_end
+
+
+def get_animation_data(pg: 'PSA_PG_export', context: Context) -> Optional[AnimData]:
+    animation_data_object = context.object
+    if pg.should_override_animation_data:
+        animation_data_object = pg.animation_data_override
+    return animation_data_object.animation_data if animation_data_object else None
+
+
+def nla_track_search_cb(self, context: Context, edit_text: str):
+    pg = getattr(context.scene, 'psa_export')
+    animation_data = get_animation_data(pg, context)
+    if animation_data is None:
+        return
+    for index, nla_track in enumerate(animation_data.nla_tracks):
+        yield f'{index} - {nla_track.name}'
+
+
+def animation_data_override_update_cb(self: 'PSA_PG_export', context: Context):
+    # Reset NLA track selection
+    self.nla_track = ''
+
+
 class PSA_PG_export(PropertyGroup):
     root_motion: BoolProperty(
         name='Root Motion',
@@ -46,10 +92,12 @@ class PSA_PG_export(PropertyGroup):
         name='Override Animation Data',
         options=empty_set,
         default=False,
-        description='Use the animation data from a different object instead of the selected object'
+        description='Use the animation data from a different object instead of the selected object',
+        update=animation_data_override_update_cb,
     )
     animation_data_override: PointerProperty(
         type=Object,
+        update=animation_data_override_update_cb,
         poll=psa_export_property_group_animation_data_override_poll
     )
     sequence_source: EnumProperty(
@@ -58,19 +106,25 @@ class PSA_PG_export(PropertyGroup):
         description='',
         items=(
             ('ACTIONS', 'Actions', 'Sequences will be exported using actions', 'ACTION', 0),
-            ('TIMELINE_MARKERS', 'Timeline Markers', 'Sequences will be exported using timeline markers', 'MARKER_HLT',
+            ('TIMELINE_MARKERS', 'Timeline Markers', 'Sequences are delineated by scene timeline markers', 'MARKER_HLT', 1),
-             1),
+            ('NLA_TRACK_STRIPS', 'NLA Track Strips', 'Sequences are delineated by the start & end times of strips on the selected NLA track', 'NLA', 2)
         )
     )
+    nla_track: StringProperty(
+        name='NLA Track',
+        options=empty_set,
+        description='',
+        search=nla_track_search_cb,
+        update=nla_track_update_cb
+    )
+    nla_track_index: IntProperty(name='NLA Track Index', default=-1)
     fps_source: EnumProperty(
         name='FPS Source',
         options=empty_set,
         description='',
         items=(
             ('SCENE', 'Scene', '', 'SCENE_DATA', 0),
-            ('ACTION_METADATA', 'Action Metadata',
+            ('ACTION_METADATA', 'Action Metadata', 'The frame rate will be determined by action\'s FPS property found in the PSA Export panel.\n\nIf the Sequence Source is Timeline Markers, the lowest value of all contributing actions will be used', 'PROPERTIES', 1),
-             'The frame rate will be determined by action\'s "psa_sequence_fps" custom property, if it exists. If the Sequence Source is Timeline Markers, the lowest value of all contributing actions will be used. If no metadata is available, the scene\'s frame rate will be used.',
-             'PROPERTIES', 1),
             ('CUSTOM', 'Custom', '', 2)
         )
     )
@@ -80,23 +134,25 @@ class PSA_PG_export(PropertyGroup):
     action_list_index: IntProperty(default=0)
     marker_list: CollectionProperty(type=PSA_PG_export_timeline_markers)
     marker_list_index: IntProperty(default=0)
+    nla_strip_list: CollectionProperty(type=PSA_PG_export_nla_strip_list_item)
+    nla_strip_list_index: IntProperty(default=0)
     bone_filter_mode: EnumProperty(
         name='Bone Filter',
         options=empty_set,
         description='',
         items=(
             ('ALL', 'All', 'All bones will be exported.'),
-            ('BONE_GROUPS', 'Bone Groups', 'Only bones belonging to the selected bone groups and their ancestors will '
+            ('BONE_COLLECTIONS', 'Bone Collections', 'Only bones belonging to the selected bone collections and their '
-                                           'be exported.'),
+             'ancestors will be exported.'),
         )
     )
-    bone_group_list: CollectionProperty(type=PSX_PG_bone_group_list_item)
+    bone_collection_list: CollectionProperty(type=PSX_PG_bone_collection_list_item)
-    bone_group_list_index: IntProperty(default=0, name='', description='')
+    bone_collection_list_index: IntProperty(default=0, name='', description='')
     should_enforce_bone_name_restrictions: BoolProperty(
         default=False,
         name='Enforce Bone Name Restrictions',
         description='Bone names restrictions will be enforced. Note that bone names without properly formatted names '
-                    'cannot be referenced in scripts'
+                    'may not be able to be referenced in-engine'
     )
     sequence_name_prefix: StringProperty(name='Prefix', options=empty_set)
     sequence_name_suffix: StringProperty(name='Suffix', options=empty_set)
@@ -145,7 +201,7 @@ def filter_sequences(pg: PSA_PG_export, sequences) -> List[int]:
 
     if not pg.sequence_filter_asset:
         for i, sequence in enumerate(sequences):
-            if hasattr(sequence, 'action') and sequence.action.asset_data is not None:
+            if hasattr(sequence, 'action') and sequence.action is not None and sequence.action.asset_data is not None:
                 flt_flags[i] &= ~bitflag_filter_item
 
     if not pg.sequence_filter_pose_marker:
@@ -164,5 +220,6 @@ def filter_sequences(pg: PSA_PG_export, sequences) -> List[int]:
 classes = (
     PSA_PG_export_action_list_item,
     PSA_PG_export_timeline_markers,
+    PSA_PG_export_nla_strip_list_item,
     PSA_PG_export,
 )

io_scene_psk_psa/psa/export/ui.py

@@ -16,7 +16,7 @@ class PSA_UL_export_sequences(UIList):
         item = cast(PSA_PG_export_action_list_item, item)
         is_pose_marker = hasattr(item, 'is_pose_marker') and item.is_pose_marker
         layout.prop(item, 'is_selected', icon_only=True, text=item.name)
-        if hasattr(item, 'action') and item.action.asset_data is not None:
+        if hasattr(item, 'action') and item.action is not None and item.action.asset_data is not None:
             layout.label(text='', icon='ASSET_MANAGER')
 
         row = layout.row(align=True)
@@ -30,15 +30,15 @@ class PSA_UL_export_sequences(UIList):
         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_filter_name', text='')
-        subrow.prop(pg, 'sequence_use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
+        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)
             subrow.prop(pg, 'sequence_filter_asset', icon_only=True, icon='ASSET_MANAGER')
             subrow.prop(pg, 'sequence_filter_pose_marker', icon_only=True, icon='PMARKER')
-            subrow.prop(pg, 'sequence_filter_reversed', text="", icon='FRAME_PREV')
+            subrow.prop(pg, 'sequence_filter_reversed', text='', icon='FRAME_PREV')
 
     def filter_items(self, context, data, prop):
         pg = getattr(context.scene, 'psa_export')

io_scene_psk_psa/psa/import_/operators.py

@@ -1,10 +1,12 @@
 import os
+from pathlib import Path
 
 from bpy.props import StringProperty
 from bpy.types import Operator, Event, Context
 from bpy_extras.io_utils import ImportHelper
 
 from .properties import get_visible_sequences
+from ..config import read_psa_config
 from ..importer import import_psa, PsaImportOptions
 from ..reader import PsaReader
 
@@ -93,15 +95,15 @@ class PSA_OT_import_select_file(Operator):
     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'})
+    filter_glob: StringProperty(default='*.psa', options={'HIDDEN'})
 
     def execute(self, context):
         getattr(context.scene, 'psa_import').psa_file_path = self.filepath
-        return {"FINISHED"}
+        return {'FINISHED'}
 
     def invoke(self, context, event):
         context.window_manager.fileselect_add(self)
-        return {"RUNNING_MODAL"}
+        return {'RUNNING_MODAL'}
 
 
 def load_psa_file(context, filepath: str):
@@ -156,6 +158,10 @@ class PSA_OT_import(Operator, ImportHelper):
         psa_reader = PsaReader(self.filepath)
         sequence_names = [x.action_name for x in pg.sequence_list if x.is_selected]
 
+        if len(sequence_names) == 0:
+            self.report({'ERROR_INVALID_CONTEXT'}, 'No sequences selected')
+            return {'CANCELLED'}
+
         options = PsaImportOptions()
         options.sequence_names = sequence_names
         options.should_use_fake_user = pg.should_use_fake_user
@@ -166,13 +172,25 @@ class PSA_OT_import(Operator, ImportHelper):
         options.should_write_keyframes = pg.should_write_keyframes
         options.should_convert_to_samples = pg.should_convert_to_samples
         options.bone_mapping_mode = pg.bone_mapping_mode
+        options.fps_source = pg.fps_source
+        options.fps_custom = pg.fps_custom
+
+        if options.should_use_config_file:
+            # Read the PSA config file if it exists.
+            config_path = Path(self.filepath).with_suffix('.config')
+            if config_path.exists():
+                try:
+                    options.psa_config = read_psa_config(psa_reader, str(config_path))
+                except Exception as e:
+                    self.report({'WARNING'}, f'Failed to read PSA config file: {e}')
 
         result = import_psa(context, psa_reader, context.view_layer.objects.active, options)
 
         if len(result.warnings) > 0:
             message = f'Imported {len(sequence_names)} action(s) with {len(result.warnings)} warning(s)\n'
-            message += '\n'.join(result.warnings)
             self.report({'WARNING'}, message)
+            for warning in result.warnings:
+                self.report({'WARNING'}, warning)
         else:
             self.report({'INFO'}, f'Imported {len(sequence_names)} action(s)')
 
@@ -234,12 +252,18 @@ class PSA_OT_import(Operator, ImportHelper):
             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 = 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_config_file')
+
         col.prop(pg, 'should_use_action_name_prefix')
 
         if pg.should_use_action_name_prefix:

io_scene_psk_psa/psa/import_/properties.py

@@ -2,7 +2,8 @@ import re
 from fnmatch import fnmatch
 from typing import List
 
-from bpy.props import StringProperty, BoolProperty, CollectionProperty, IntProperty, PointerProperty, EnumProperty
+from bpy.props import StringProperty, BoolProperty, CollectionProperty, IntProperty, PointerProperty, EnumProperty, \
+    FloatProperty
 from bpy.types import PropertyGroup, Text
 
 empty_set = set()
@@ -10,7 +11,7 @@ empty_set = set()
 
 class PSA_PG_import_action_list_item(PropertyGroup):
     action_name: StringProperty(options=empty_set)
-    is_selected: BoolProperty(default=False, options=empty_set)
+    is_selected: BoolProperty(default=True, options=empty_set)
 
 
 class PSA_PG_bone(PropertyGroup):
@@ -31,6 +32,12 @@ class PSA_PG_import(PropertyGroup):
                                        description='Assign each imported action a fake user so that the data block is '
                                                    'saved even it has no users',
                                        options=empty_set)
+    should_use_config_file: BoolProperty(default=True, name='Use Config File',
+                                            description='Use the .config file that is sometimes generated when the PSA '
+                                                        'file is exported from UEViewer. This file contains '
+                                                        'options that can be used to filter out certain bones tracks '
+                                                        'from the imported actions',
+                                            options=empty_set)
     should_stash: BoolProperty(default=False, name='Stash',
                                description='Stash each imported action as a strip on a new non-contributing NLA track',
                                options=empty_set)
@@ -66,6 +73,21 @@ class PSA_PG_import(PropertyGroup):
              '\'root\' can be mapped to the armature bone \'Root\')', 'CASE_INSENSITIVE', 1),
         )
     )
+    fps_source: EnumProperty(name='FPS Source', items=(
+        ('SEQUENCE', 'Sequence', 'The sequence frame rate matches the original frame rate', 'ACTION', 0),
+        ('SCENE', 'Scene', 'The sequence frame rate dilates to match that of the scene', 'SCENE_DATA', 1),
+        ('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 actions will be converted',
+        options=empty_set,
+        min=1.0,
+        soft_min=1.0,
+        soft_max=60.0,
+        step=100,
+    )
 
 
 def filter_sequences(pg: PSA_PG_import, sequences) -> List[int]:

io_scene_psk_psa/psa/import_/ui.py

@@ -17,10 +17,10 @@ class PSA_UL_sequences(UIList):
         pg = getattr(context.scene, 'psa_import')
         row = layout.row()
         sub_row = row.row(align=True)
-        sub_row.prop(pg, 'sequence_filter_name', text="")
+        sub_row.prop(pg, 'sequence_filter_name', text='')
-        sub_row.prop(pg, 'sequence_use_filter_invert', text="", icon='ARROW_LEFTRIGHT')
+        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_use_filter_regex', text='', icon='SORTBYEXT')
-        sub_row.prop(pg, 'sequence_filter_is_selected', text="", icon='CHECKBOX_HLT')
+        sub_row.prop(pg, 'sequence_filter_is_selected', text='', icon='CHECKBOX_HLT')
 
     def filter_items(self, context, data, property_):
         pg = getattr(context.scene, 'psa_import')

io_scene_psk_psa/psa/importer.py

@@ -6,6 +6,7 @@ import numpy
 from bpy.types import FCurve, Object, Context
 from mathutils import Vector, Quaternion
 
+from .config import PsaConfig, REMOVE_TRACK_LOCATION, REMOVE_TRACK_ROTATION
 from .data import Psa
 from .reader import PsaReader
 
@@ -21,6 +22,10 @@ class PsaImportOptions(object):
         self.action_name_prefix = ''
         self.should_convert_to_samples = False
         self.bone_mapping_mode = 'CASE_INSENSITIVE'
+        self.fps_source = 'SEQUENCE'
+        self.fps_custom: float = 30.0
+        self.should_use_config_file = True
+        self.psa_config: PsaConfig = PsaConfig()
 
 
 class ImportBone(object):
@@ -29,9 +34,9 @@ class ImportBone(object):
         self.parent: Optional[ImportBone] = None
         self.armature_bone = None
         self.pose_bone = None
-        self.orig_loc: Vector = Vector()
+        self.original_location: Vector = Vector()
-        self.orig_quat: Quaternion = Quaternion()
+        self.original_rotation: Quaternion = Quaternion()
-        self.post_quat: Quaternion = Quaternion()
+        self.post_rotation: Quaternion = Quaternion()
         self.fcurves: List[FCurve] = []
 
 
@@ -39,17 +44,17 @@ def _calculate_fcurve_data(import_bone: ImportBone, key_data: typing.Iterable[fl
     # Convert world-space transforms to local-space transforms.
     key_rotation = Quaternion(key_data[0:4])
     key_location = Vector(key_data[4:])
-    q = import_bone.post_quat.copy()
+    q = import_bone.post_rotation.copy()
-    q.rotate(import_bone.orig_quat)
+    q.rotate(import_bone.original_rotation)
     quat = q
-    q = import_bone.post_quat.copy()
+    q = import_bone.post_rotation.copy()
     if import_bone.parent is None:
         q.rotate(key_rotation.conjugated())
     else:
         q.rotate(key_rotation)
     quat.rotate(q.conjugated())
-    loc = key_location - import_bone.orig_loc
+    loc = key_location - import_bone.original_location
-    loc.rotate(import_bone.post_quat.conjugated())
+    loc.rotate(import_bone.post_rotation.conjugated())
     return quat.w, quat.x, quat.y, quat.z, loc.x, loc.y, loc.z
 
 
@@ -59,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():
@@ -140,23 +145,17 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
         if armature_bone.parent is not None and armature_bone.parent.name in psa_bone_names:
             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:
+        if import_bone.parent is not None:
-            # TODO: ideally we don't rely on bone auxiliary data like this, the non-aux data path is incorrect
+            import_bone.original_location = armature_bone.matrix_local.translation - armature_bone.parent.matrix_local.translation
-            # (animations are flipped 180 around Z)
+            import_bone.original_location.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
-            import_bone.orig_quat = Quaternion(armature_bone['orig_quat'])
+            import_bone.original_rotation = armature_bone.matrix_local.to_quaternion()
-            import_bone.orig_loc = Vector(armature_bone['orig_loc'])
+            import_bone.original_rotation.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
-            import_bone.post_quat = Quaternion(armature_bone['post_quat'])
+            import_bone.original_rotation.conjugate()
         else:
-            if import_bone.parent is not None:
+            import_bone.original_location = armature_bone.matrix_local.translation.copy()
-                import_bone.orig_loc = armature_bone.matrix_local.translation - armature_bone.parent.matrix_local.translation
+            import_bone.original_rotation = armature_bone.matrix_local.to_quaternion().conjugated()
-                import_bone.orig_loc.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
+
-                import_bone.orig_quat = armature_bone.matrix_local.to_quaternion()
+        import_bone.post_rotation = import_bone.original_rotation.conjugated()
-                import_bone.orig_quat.rotate(armature_bone.parent.matrix_local.to_quaternion().conjugated())
-                import_bone.orig_quat.conjugate()
-            else:
-                import_bone.orig_loc = armature_bone.matrix_local.translation.copy()
-                import_bone.orig_quat = armature_bone.matrix_local.to_quaternion()
-            import_bone.post_quat = import_bone.orig_quat.conjugated()
 
     context.window_manager.progress_begin(0, len(sequences))
 
@@ -167,11 +166,29 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
         sequence_name = sequence.name.decode('windows-1252')
         action_name = options.action_name_prefix + sequence_name
 
+        # Get the bone track flags for this sequence, or an empty dictionary if none exist.
+        sequence_bone_track_flags = dict()
+        if sequence_name in options.psa_config.sequence_bone_flags.keys():
+            sequence_bone_track_flags = options.psa_config.sequence_bone_flags[sequence_name]
+
         if options.should_overwrite and action_name in bpy.data.actions:
             action = bpy.data.actions[action_name]
         else:
             action = bpy.data.actions.new(name=action_name)
 
+        # Calculate the target FPS.
+        match options.fps_source:
+            case 'CUSTOM':
+                target_fps = options.fps_custom
+            case 'SCENE':
+                target_fps = context.scene.render.fps
+            case 'SEQUENCE':
+                target_fps = sequence.fps
+            case _:
+                raise ValueError(f'Unknown FPS source: {options.fps_source}')
+
+        keyframe_time_dilation = target_fps / sequence.fps
+
         if options.should_write_keyframes:
             # Remove existing f-curves (replace with action.fcurves.clear() in Blender 3.2)
             while len(action.fcurves) > 0:
@@ -179,18 +196,21 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
 
             # Create f-curves for the rotation and location of each bone.
             for psa_bone_index, armature_bone_index in psa_to_armature_bone_indices.items():
+                bone_track_flags = sequence_bone_track_flags.get(psa_bone_index, 0)
                 import_bone = import_bones[psa_bone_index]
                 pose_bone = import_bone.pose_bone
                 rotation_data_path = pose_bone.path_from_id('rotation_quaternion')
                 location_data_path = pose_bone.path_from_id('location')
+                add_rotation_fcurves = (bone_track_flags & REMOVE_TRACK_ROTATION) == 0
+                add_location_fcurves = (bone_track_flags & REMOVE_TRACK_LOCATION) == 0
                 import_bone.fcurves = [
-                    action.fcurves.new(rotation_data_path, index=0, action_group=pose_bone.name),  # Qw
+                    action.fcurves.new(rotation_data_path, index=0, action_group=pose_bone.name) if add_rotation_fcurves else None,  # Qw
-                    action.fcurves.new(rotation_data_path, index=1, action_group=pose_bone.name),  # Qx
+                    action.fcurves.new(rotation_data_path, index=1, action_group=pose_bone.name) if add_rotation_fcurves else None,  # Qx
-                    action.fcurves.new(rotation_data_path, index=2, action_group=pose_bone.name),  # Qy
+                    action.fcurves.new(rotation_data_path, index=2, action_group=pose_bone.name) if add_rotation_fcurves else None,  # Qy
-                    action.fcurves.new(rotation_data_path, index=3, action_group=pose_bone.name),  # Qz
+                    action.fcurves.new(rotation_data_path, index=3, action_group=pose_bone.name) if add_rotation_fcurves else None,  # Qz
-                    action.fcurves.new(location_data_path, index=0, action_group=pose_bone.name),  # Lx
+                    action.fcurves.new(location_data_path, index=0, action_group=pose_bone.name) if add_location_fcurves else None,  # Lx
-                    action.fcurves.new(location_data_path, index=1, action_group=pose_bone.name),  # Ly
+                    action.fcurves.new(location_data_path, index=1, action_group=pose_bone.name) if add_location_fcurves else None,  # Ly
-                    action.fcurves.new(location_data_path, index=2, action_group=pose_bone.name),  # Lz
+                    action.fcurves.new(location_data_path, index=2, action_group=pose_bone.name) if add_location_fcurves else None,  # Lz
                 ]
 
             # Read the sequence data matrix from the PSA.
@@ -208,14 +228,20 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
 
             # Write the keyframes out.
             fcurve_data = numpy.zeros(2 * sequence.frame_count, dtype=float)
-            fcurve_data[0::2] = range(sequence.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] = sequence_data_matrix[:, bone_index, fcurve_index]
                     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'
 
             if options.should_convert_to_samples:
                 # Bake the curve to samples.
@@ -224,7 +250,7 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
 
         # Write meta-data.
         if options.should_write_metadata:
-            action['psa_sequence_fps'] = sequence.fps
+            action.psa_export.fps = target_fps
 
         action.use_fake_user = options.should_use_fake_user
 

io_scene_psk_psa/psa/reader.py

@@ -5,12 +5,29 @@ import numpy as np
 from .data import *
 
 
+def _try_fix_cue4parse_issue_103(sequences) -> bool:
+    # Detect if the file was exported from CUE4Parse prior to the fix for issue #103.
+    # https://github.com/FabianFG/CUE4Parse/issues/103
+    # The issue was that the frame_start_index was not being set correctly, and was always being set to the same value
+    # as the frame_count.
+    # This fix will eventually be deprecated as it is only necessary for files exported prior to the fix.
+    if len(sequences) > 0 and sequences[0].frame_start_index == sequences[0].frame_count:
+        # Manually set the frame_start_index for each sequence. This assumes that the sequences are in order with
+        # no shared frames between sequences (all exporters that I know of do this, so it's a safe assumption).
+        frame_start_index = 0
+        for i, sequence in enumerate(sequences):
+            sequence.frame_start_index = frame_start_index
+            frame_start_index += sequence.frame_count
+        return True
+    return False
+
+
 class PsaReader(object):
-    """
+    '''
     This class 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
@@ -26,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)
@@ -43,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)
@@ -86,14 +103,15 @@ class PsaReader(object):
             elif section.name == b'ANIMINFO':
                 sequences = []
                 PsaReader._read_types(fp, Psa.Sequence, section, sequences)
+                # Try to fix CUE4Parse bug, if necessary.
+                _try_fix_cue4parse_issue_103(sequences)
                 for sequence in sequences:
                     psa.sequences[sequence.name.decode()] = sequence
             elif section.name == b'ANIMKEYS':
                 # Skip keys on this pass. We will keep this file open and read from it as needed.
                 self.keys_data_offset = fp.tell()
                 fp.seek(section.data_size * section.data_count, 1)
-            elif section.name == b'SCALEKEYS':
-                fp.seek(section.data_size * section.data_count, 1)
             else:
-                raise RuntimeError(f'Unrecognized section "{section.name}"')
+                fp.seek(section.data_size * section.data_count, 1)
+                print(f'Unrecognized section in PSA: "{section.name}"')
         return psa

io_scene_psk_psa/psk/builder.py

@@ -1,23 +1,27 @@
+from typing import Optional
+
 import bmesh
 import bpy
-from bpy.types import Armature
+import numpy as np
+from bpy.types import Armature, Material
 
 from .data import *
+from .properties import triangle_type_and_bit_flags_to_poly_flags
 from ..helpers import *
 
 
 class PskInputObjects(object):
     def __init__(self):
         self.mesh_objects = []
-        self.armature_object = None
+        self.armature_object: Optional[Object] = None
 
 
 class PskBuildOptions(object):
     def __init__(self):
         self.bone_filter_mode = 'ALL'
-        self.bone_group_indices: List[int] = []
+        self.bone_collection_indices: List[int] = []
         self.use_raw_mesh_data = True
-        self.material_names: List[str] = []
+        self.materials: List[Material] = []
         self.should_enforce_bone_name_restrictions = False
 
 
@@ -58,17 +62,23 @@ def get_psk_input_objects(context) -> PskInputObjects:
     return input_objects
 
 
-def build_psk(context, options: PskBuildOptions) -> Psk:
+class PskBuildResult(object):
-    input_objects = get_psk_input_objects(context)
+    def __init__(self):
+        self.psk = None
+        self.warnings: List[str] = []
 
+
+def build_psk(context, options: PskBuildOptions) -> PskBuildResult:
+    input_objects = get_psk_input_objects(context)
     armature_object: bpy.types.Object = input_objects.armature_object
 
+    result = PskBuildResult()
     psk = Psk()
     bones = []
 
-    if armature_object is None:
+    if armature_object is None or len(armature_object.data.bones) == 0:
-        # If the mesh has no armature object, simply assign it a dummy bone at the root to satisfy the requirement
+        # If the mesh has no armature object or no bones, simply assign it a dummy bone at the root to satisfy the
-        # that a PSK file must have at least one bone.
+        # requirement that a PSK file must have at least one bone.
         psk_bone = Psk.Bone()
         psk_bone.name = bytes('root', encoding='windows-1252')
         psk_bone.flags = 0
@@ -78,7 +88,7 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
         psk_bone.rotation = Quaternion.identity()
         psk.bones.append(psk_bone)
     else:
-        bone_names = get_export_bone_names(armature_object, options.bone_filter_mode, options.bone_group_indices)
+        bone_names = get_export_bone_names(armature_object, options.bone_filter_mode, options.bone_collection_indices)
         armature_data = typing.cast(Armature, armature_object.data)
         bones = [armature_data.bones[bone_name] for bone_name in bone_names]
 
@@ -88,7 +98,11 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
 
         for bone in bones:
             psk_bone = Psk.Bone()
-            psk_bone.name = bytes(bone.name, encoding='windows-1252')
+            try:
+                psk_bone.name = bytes(bone.name, encoding='windows-1252')
+            except UnicodeEncodeError:
+                raise RuntimeError(
+                    f'Bone name "{bone.name}" contains characters that cannot be encoded in the Windows-1252 codepage')
             psk_bone.flags = 0
             psk_bone.children_count = 0
 
@@ -125,18 +139,27 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
             psk.bones.append(psk_bone)
 
     # MATERIALS
-    material_names = options.material_names
+    for material in options.materials:
-
-    for material_name in material_names:
         psk_material = Psk.Material()
-        psk_material.name = bytes(material_name, encoding='windows-1252')
+        try:
+            psk_material.name = bytes(material.name, encoding='windows-1252')
+        except UnicodeEncodeError:
+            raise RuntimeError(f'Material name "{material.name}" contains characters that cannot be encoded in the Windows-1252 codepage')
         psk_material.texture_index = len(psk.materials)
+        psk_material.poly_flags = triangle_type_and_bit_flags_to_poly_flags(material.psk.mesh_triangle_type,
+                                                                            material.psk.mesh_triangle_bit_flags)
         psk.materials.append(psk_material)
 
-    for input_mesh_object in input_objects.mesh_objects:
+    context.window_manager.progress_begin(0, len(input_objects.mesh_objects))
+
+    material_names = [m.name for m in options.materials]
+
+    for object_index, input_mesh_object in enumerate(input_objects.mesh_objects):
+
+        should_flip_normals = False
 
         # MATERIALS
-        material_indices = [material_names.index(material.name) for material in input_mesh_object.data.materials]
+        material_indices = [material_names.index(material_slot.material.name) for material_slot in input_mesh_object.material_slots]
 
         # MESH DATA
         if options.use_raw_mesh_data:
@@ -147,8 +170,10 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
 
             # Temporarily force the armature into the rest position.
             # We will undo this later.
-            old_pose_position = armature_object.data.pose_position
+            old_pose_position = None
-            armature_object.data.pose_position = 'REST'
+            if armature_object is not None:
+                old_pose_position = armature_object.data.pose_position
+                armature_object.data.pose_position = 'REST'
 
             depsgraph = context.evaluated_depsgraph_get()
             bm = bmesh.new()
@@ -159,12 +184,25 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
             mesh_object = bpy.data.objects.new('', mesh_data)
             mesh_object.matrix_world = input_mesh_object.matrix_world
 
+            scale = (input_mesh_object.scale.x, input_mesh_object.scale.y, input_mesh_object.scale.z)
+
+            # Negative scaling in Blender results in inverted normals after the scale is applied. However, if the scale
+            # is not applied, the normals will appear unaffected in the viewport. The evaluated mesh data used in the
+            # export will have the scale applied, but this behavior is not obvious to the user.
+            #
+            # In order to have the exporter be as WYSIWYG as possible, we need to check for negative scaling and invert
+            # the normals if necessary. If two axes have negative scaling and the third has positive scaling, the
+            # normals will be correct. We can detect this by checking if the number of negative scaling axes is odd. If
+            # it is, we need to invert the normals of the mesh by swapping the order of the vertices in each face.
+            should_flip_normals = sum(1 for x in scale if x < 0) % 2 == 1
+
             # Copy the vertex groups
             for vertex_group in input_mesh_object.vertex_groups:
                 mesh_object.vertex_groups.new(name=vertex_group.name)
 
             # Restore the previous pose position on the armature.
-            armature_object.data.pose_position = old_pose_position
+            if old_pose_position is not None:
+                armature_object.data.pose_position = old_pose_position
 
         vertex_offset = len(psk.points)
 
@@ -185,11 +223,11 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
         # Build a list of non-unique wedges.
         wedges = []
         for loop_index, loop in enumerate(mesh_data.loops):
-            wedge = Psk.Wedge()
+            wedges.append(Psk.Wedge(
-            wedge.point_index = loop.vertex_index + vertex_offset
+                point_index=loop.vertex_index + vertex_offset,
-            wedge.u, wedge.v = uv_layer[loop_index].uv
+                u=uv_layer[loop_index].uv[0],
-            wedge.v = 1.0 - wedge.v
+                v=1.0 - uv_layer[loop_index].uv[1]
-            wedges.append(wedge)
+            ))
 
         # Assign material indices to the wedges.
         for triangle in mesh_data.loop_triangles:
@@ -197,8 +235,8 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
                 wedges[loop_index].material_index = material_indices[triangle.material_index]
 
         # Populate the list of wedges with unique wedges & build a look-up table of loop indices to wedge indices
-        wedge_indices = {}
+        wedge_indices = dict()
-        loop_wedge_indices = [-1] * len(mesh_data.loops)
+        loop_wedge_indices = np.full(len(mesh_data.loops), -1)
         for loop_index, wedge in enumerate(wedges):
             wedge_hash = hash(wedge)
             if wedge_hash in wedge_indices:
@@ -211,6 +249,7 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
 
         # FACES
         poly_groups, groups = mesh_data.calc_smooth_groups(use_bitflags=True)
+        psk_face_start_index = len(psk.faces)
         for f in mesh_data.loop_triangles:
             face = Psk.Face()
             face.material_index = material_indices[f.material_index]
@@ -220,6 +259,11 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
             face.smoothing_groups = poly_groups[f.polygon_index]
             psk.faces.append(face)
 
+        if should_flip_normals:
+            # Invert the normals of the faces.
+            for face in psk.faces[psk_face_start_index:]:
+                face.wedge_indices[0], face.wedge_indices[2] = face.wedge_indices[2], face.wedge_indices[0]
+
         # WEIGHTS
         if armature_object is not None:
             armature_data = typing.cast(Armature, armature_object.data)
@@ -268,4 +312,10 @@ def build_psk(context, options: PskBuildOptions) -> Psk:
             bpy.data.meshes.remove(mesh_data)
             del mesh_data
 
-    return psk
+        context.window_manager.progress_update(object_index)
+
+    context.window_manager.progress_end()
+
+    result.psk = psk
+
+    return result

io_scene_psk_psa/psk/data.py

@@ -5,11 +5,11 @@ from ..data import *
 
 class Psk(object):
     class Wedge(object):
-        def __init__(self):
+        def __init__(self, point_index: int, u: float, v: float, material_index: int = 0):
-            self.point_index: int = 0
+            self.point_index: int = point_index
-            self.u: float = 0.0
+            self.u: float = u
-            self.v: float = 0.0
+            self.v: float = v
-            self.material_index: int = 0
+            self.material_index = material_index
 
         def __hash__(self):
             return hash(f'{self.point_index}-{self.u}-{self.v}-{self.material_index}')

io_scene_psk_psa/psk/export/operators.py

@@ -4,14 +4,14 @@ from bpy_extras.io_utils import ExportHelper
 
 from ..builder import build_psk, PskBuildOptions, get_psk_input_objects
 from ..writer import write_psk
-from ...helpers import populate_bone_group_list
+from ...helpers import populate_bone_collection_list
 
 
 def is_bone_filter_mode_item_available(context, identifier):
     input_objects = get_psk_input_objects(context)
     armature_object = input_objects.armature_object
-    if identifier == 'BONE_GROUPS':
+    if identifier == 'BONE_COLLECTIONS':
-        if not armature_object or not armature_object.pose or not armature_object.pose.bone_groups:
+        if armature_object is None or armature_object.data is None or len(armature_object.data.collections) == 0:
             return False
     # else if... you can set up other conditions if you add more options
     return True
@@ -20,18 +20,19 @@ def is_bone_filter_mode_item_available(context, identifier):
 def populate_material_list(mesh_objects, material_list):
     material_list.clear()
 
-    material_names = []
+    materials = []
     for mesh_object in mesh_objects:
-        for i, material in enumerate(mesh_object.data.materials):
+        for i, material_slot in enumerate(mesh_object.material_slots):
+            material = material_slot.material
             # TODO: put this in the poll arg?
             if material is None:
-                raise RuntimeError('Material cannot be empty (index ' + str(i) + ')')
+                raise RuntimeError('Material slot cannot be empty (index ' + str(i) + ')')
-            if material.name not in material_names:
+            if material not in materials:
-                material_names.append(material.name)
+                materials.append(material)
 
-    for index, material_name in enumerate(material_names):
+    for index, material in enumerate(materials):
         m = material_list.add()
-        m.material_name = material_name
+        m.material = material
         m.index = index
 
 
@@ -50,7 +51,7 @@ class PSK_OT_material_list_move_up(Operator):
         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"}
+        return {'FINISHED'}
 
 
 class PSK_OT_material_list_move_down(Operator):
@@ -68,7 +69,7 @@ class PSK_OT_material_list_move_down(Operator):
         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"}
+        return {'FINISHED'}
 
 
 class PSK_OT_export(Operator, ExportHelper):
@@ -94,8 +95,7 @@ class PSK_OT_export(Operator, ExportHelper):
 
         pg = getattr(context.scene, 'psk_export')
 
-        # Populate bone groups list.
+        populate_bone_collection_list(input_objects.armature_object, pg.bone_collection_list)
-        populate_bone_group_list(input_objects.armature_object, pg.bone_group_list)
 
         try:
             populate_material_list(input_objects.mesh_objects, pg.material_list)
@@ -136,10 +136,10 @@ class PSK_OT_export(Operator, ExportHelper):
             item_layout.prop_enum(pg, 'bone_filter_mode', item.identifier)
             item_layout.enabled = is_bone_filter_mode_item_available(context, identifier)
 
-        if pg.bone_filter_mode == 'BONE_GROUPS':
+        if pg.bone_filter_mode == 'BONE_COLLECTIONS':
             row = box.row()
-            rows = max(3, min(len(pg.bone_group_list), 10))
+            rows = max(3, min(len(pg.bone_collection_list), 10))
-            row.template_list('PSX_UL_bone_group_list', '', pg, 'bone_group_list', pg, 'bone_group_list_index', rows=rows)
+            row.template_list('PSX_UL_bone_collection_list', '', pg, 'bone_collection_list', pg, 'bone_collection_list_index', rows=rows)
 
         box.prop(pg, 'should_enforce_bone_name_restrictions')
 
@@ -147,7 +147,7 @@ class PSK_OT_export(Operator, ExportHelper):
         box = layout.box()
         box.label(text='Materials', icon='MATERIAL')
         row = box.row()
-        rows = max(3, min(len(pg.bone_group_list), 10))
+        rows = max(3, min(len(pg.bone_collection_list), 10))
         row.template_list('PSK_UL_materials', '', pg, 'material_list', pg, 'material_list_index', rows=rows)
         col = row.column(align=True)
         col.operator(PSK_OT_material_list_move_up.bl_idname, text='', icon='TRIA_UP')
@@ -157,18 +157,24 @@ class PSK_OT_export(Operator, ExportHelper):
         pg = context.scene.psk_export
         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.bone_collection_indices = [x.index for x in pg.bone_collection_list if x.is_selected]
         options.use_raw_mesh_data = pg.use_raw_mesh_data
-        options.material_names = [m.material_name for m in pg.material_list]
+        options.materials = [m.material for m in pg.material_list]
         options.should_enforce_bone_name_restrictions = pg.should_enforce_bone_name_restrictions
-
+        
         try:
-            psk = build_psk(context, options)
+            result = build_psk(context, options)
-            write_psk(psk, self.filepath)
+            for warning in result.warnings:
-            self.report({'INFO'}, f'PSK export successful')
+                self.report({'WARNING'}, warning)
+            write_psk(result.psk, self.filepath)
+            if len(result.warnings) > 0:
+                self.report({'WARNING'}, f'PSK export successful with {len(result.warnings)} warnings')
+            else:
+                self.report({'INFO'}, f'PSK export successful')
         except RuntimeError as e:
             self.report({'ERROR_INVALID_CONTEXT'}, str(e))
             return {'CANCELLED'}
+    
         return {'FINISHED'}
 
 

io_scene_psk_psa/psk/export/properties.py

@@ -1,11 +1,11 @@
-from bpy.props import EnumProperty, CollectionProperty, IntProperty, BoolProperty, StringProperty
+from bpy.props import EnumProperty, CollectionProperty, IntProperty, BoolProperty, PointerProperty
-from bpy.types import PropertyGroup
+from bpy.types import PropertyGroup, Material
 
-from ...types import PSX_PG_bone_group_list_item
+from ...types import PSX_PG_bone_collection_list_item
 
 
 class PSK_PG_material_list_item(PropertyGroup):
-    material_name: StringProperty()
+    material: PointerProperty(type=Material)
     index: IntProperty()
 
 
@@ -16,12 +16,12 @@ class PSK_PG_export(PropertyGroup):
         description='',
         items=(
             ('ALL', 'All', 'All bones will be exported'),
-            ('BONE_GROUPS', 'Bone Groups',
+            ('BONE_COLLECTIONS', 'Bone Collections',
-             'Only bones belonging to the selected bone groups and their ancestors will be exported')
+             'Only bones belonging to the selected bone collections and their ancestors will be exported')
         )
     )
-    bone_group_list: CollectionProperty(type=PSX_PG_bone_group_list_item)
+    bone_collection_list: CollectionProperty(type=PSX_PG_bone_collection_list_item)
-    bone_group_list_index: IntProperty(default=0)
+    bone_collection_list_index: IntProperty(default=0)
     use_raw_mesh_data: BoolProperty(default=False, name='Raw Mesh Data', description='No modifiers will be evaluated as part of the exported mesh')
     material_list: CollectionProperty(type=PSK_PG_material_list_item)
     material_list_index: IntProperty(default=0)

io_scene_psk_psa/psk/export/ui.py

@@ -4,7 +4,7 @@ from bpy.types import UIList
 class PSK_UL_materials(UIList):
     def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
         row = layout.row()
-        row.label(text=str(getattr(item, 'material_name')), icon='MATERIAL')
+        row.prop(item.material, 'name', text='', emboss=False, icon_value=layout.icon(item.material))
 
 
 classes = (

io_scene_psk_psa/psk/import_/operators.py

@@ -27,8 +27,8 @@ class PSK_OT_import(Operator, ImportHelper):
     should_import_vertex_colors: BoolProperty(
         default=True,
         options=empty_set,
-        name='Vertex Colors',
+        name='Import Vertex Colors',
-        description='Import vertex colors from PSKX files, if available'
+        description='Import vertex colors, if available'
     )
     vertex_color_space: EnumProperty(
         name='Vertex Color Space',
@@ -42,13 +42,13 @@ class PSK_OT_import(Operator, ImportHelper):
     )
     should_import_vertex_normals: BoolProperty(
         default=True,
-        name='Vertex Normals',
+        name='Import Vertex Normals',
         options=empty_set,
         description='Import vertex normals, if available'
     )
     should_import_extra_uvs: BoolProperty(
         default=True,
-        name='Extra UVs',
+        name='Import Extra UVs',
         options=empty_set,
         description='Import extra UV maps, if available'
     )
@@ -63,12 +63,6 @@ class PSK_OT_import(Operator, ImportHelper):
         name='Import Materials',
         options=empty_set,
     )
-    should_reuse_materials: BoolProperty(
-        default=True,
-        name='Reuse Materials',
-        options=empty_set,
-        description='Existing materials with matching names will be reused when available'
-    )
     should_import_skeleton: BoolProperty(
         default=True,
         name='Import Skeleton',
@@ -82,14 +76,20 @@ class PSK_OT_import(Operator, ImportHelper):
         soft_min=1.0,
         name='Bone Length',
         options=empty_set,
+        subtype='DISTANCE',
         description='Length of the bones'
     )
     should_import_shape_keys: BoolProperty(
         default=True,
-        name='Shape Keys',
+        name='Import Shape Keys',
         options=empty_set,
         description='Import shape keys, if available'
     )
+    scale: FloatProperty(
+        name='Scale',
+        default=1.0,
+        soft_min=0.0,
+    )
 
     def execute(self, context):
         psk = read_psk(self.filepath)
@@ -105,6 +105,11 @@ class PSK_OT_import(Operator, ImportHelper):
         options.bone_length = self.bone_length
         options.should_import_materials = self.should_import_materials
         options.should_import_shape_keys = self.should_import_shape_keys
+        options.scale = self.scale
+
+        if not options.should_import_mesh and not options.should_import_skeleton:
+            self.report({'ERROR'}, 'Nothing to import')
+            return {'CANCELLED'}
 
         result = import_psk(psk, context, options)
 
@@ -113,30 +118,42 @@ class PSK_OT_import(Operator, ImportHelper):
             message += '\n'.join(result.warnings)
             self.report({'WARNING'}, message)
         else:
-            self.report({'INFO'}, f'PSK imported')
+            self.report({'INFO'}, f'PSK imported ({options.name})')
 
         return {'FINISHED'}
 
     def draw(self, context):
         layout = self.layout
-        layout.prop(self, 'should_import_materials')
+
+        row = layout.row()
+
+        col = row.column()
+        col.use_property_split = True
+        col.use_property_decorate = False
+        col.prop(self, 'scale')
+
         layout.prop(self, 'should_import_mesh')
-        row = layout.column()
+
-        row.use_property_split = True
-        row.use_property_decorate = False
         if self.should_import_mesh:
-            row.prop(self, 'should_import_vertex_normals')
+            row = layout.row()
-            row.prop(self, 'should_import_extra_uvs')
+            col = row.column()
-            row.prop(self, 'should_import_vertex_colors')
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(self, 'should_import_materials', text='Materials')
+            col.prop(self, 'should_import_vertex_normals', text='Vertex Normals')
+            col.prop(self, 'should_import_extra_uvs', text='Extra UVs')
+            col.prop(self, 'should_import_vertex_colors', text='Vertex Colors')
             if self.should_import_vertex_colors:
-                row.prop(self, 'vertex_color_space')
+                col.prop(self, 'vertex_color_space')
-            row.prop(self, 'should_import_shape_keys')
+            col.prop(self, 'should_import_shape_keys', text='Shape Keys')
+
         layout.prop(self, 'should_import_skeleton')
-        row = layout.column()
-        row.use_property_split = True
-        row.use_property_decorate = False
         if self.should_import_skeleton:
-            row.prop(self, 'bone_length')
+            row = layout.row()
+            col = row.column()
+            col.use_property_split = True
+            col.use_property_decorate = False
+            col.prop(self, 'bone_length')
 
 
 classes = (

io_scene_psk_psa/psk/importer.py

@@ -1,4 +1,3 @@
-from math import inf
 from typing import Optional, List
 
 import bmesh
@@ -8,6 +7,7 @@ from bpy.types import VertexGroup
 from mathutils import Quaternion, Vector, Matrix
 
 from .data import Psk
+from .properties import poly_flags_to_triangle_type_and_bit_flags
 from ..helpers import rgb_to_srgb, is_bdk_addon_loaded
 
 
@@ -17,19 +17,20 @@ class PskImportOptions:
         self.should_import_mesh = True
         self.should_reuse_materials = True
         self.should_import_vertex_colors = True
-        self.vertex_color_space = 'sRGB'
+        self.vertex_color_space = 'SRGB'
         self.should_import_vertex_normals = True
         self.should_import_extra_uvs = True
         self.should_import_skeleton = True
         self.should_import_shape_keys = True
         self.bone_length = 1.0
         self.should_import_materials = True
+        self.scale = 1.0
 
 
 class ImportBone:
-    """
+    '''
     Intermediate bone type for the purpose of construction.
-    """
+    '''
     def __init__(self, index: int, psk_bone: Psk.Bone):
         self.index: int = index
         self.psk_bone: Psk.Bone = psk_bone
@@ -39,9 +40,9 @@ class ImportBone:
         self.world_rotation_matrix: Matrix = Matrix()
         self.world_matrix: Matrix = Matrix()
         self.vertex_group = None
-        self.orig_quat: Quaternion = Quaternion()
+        self.original_rotation: Quaternion = Quaternion()
-        self.orig_loc: Vector = Vector()
+        self.original_location: Vector = Vector()
-        self.post_quat: Quaternion = Quaternion()
+        self.post_rotation: Quaternion = Quaternion()
 
 
 class PskImportResult:
@@ -52,6 +53,7 @@ class PskImportResult:
 def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
     result = PskImportResult()
     armature_object = None
+    mesh_object = None
 
     if options.should_import_skeleton:
         # ARMATURE
@@ -111,12 +113,6 @@ def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
             edit_bone_matrix.translation = import_bone.world_matrix.translation
             edit_bone.matrix = edit_bone_matrix
 
-            # Store bind pose information in the bone's custom properties.
-            # This information is used when importing animations from PSA files.
-            edit_bone['orig_quat'] = import_bone.local_rotation
-            edit_bone['orig_loc'] = import_bone.local_translation
-            edit_bone['post_quat'] = import_bone.local_rotation.conjugated()
-
     # MESH
     if options.should_import_mesh:
         mesh_data = bpy.data.meshes.new(options.name)
@@ -131,7 +127,7 @@ def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
                     # Material already exists, just re-use it.
                     material = bpy.data.materials[material_name]
                 elif is_bdk_addon_loaded() and psk.has_material_references:
-                    # Material does not yet exist and we have the BDK addon installed.
+                    # Material does not yet exist, and we have the BDK addon installed.
                     # Attempt to load it using BDK addon's operator.
                     material_reference = psk.material_references[material_index]
                     if material_reference and bpy.ops.bdk.link_material(reference=material_reference) == {'FINISHED'}:
@@ -139,6 +135,9 @@ def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
                 else:
                     # Just create a blank material.
                     material = bpy.data.materials.new(material_name)
+                    mesh_triangle_type, mesh_triangle_bit_flags = poly_flags_to_triangle_type_and_bit_flags(psk_material.poly_flags)
+                    material.psk.mesh_triangle_type = mesh_triangle_type
+                    material.psk.mesh_triangle_bit_flags = mesh_triangle_bit_flags
                     material.use_nodes = True
                 mesh_data.materials.append(material)
 
@@ -150,85 +149,92 @@ def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
 
         bm.verts.ensure_lookup_table()
 
-        degenerate_face_indices = set()
+        # FACES
+        invalid_face_indices = set()
         for face_index, face in enumerate(psk.faces):
-            point_indices = [bm.verts[psk.wedges[i].point_index] for i in reversed(face.wedge_indices)]
+            point_indices = map(lambda i: psk.wedges[i].point_index, reversed(face.wedge_indices))
+            points = [bm.verts[i] for i in point_indices]
             try:
-                bm_face = bm.faces.new(point_indices)
+                bm_face = bm.faces.new(points)
                 bm_face.material_index = face.material_index
             except ValueError:
-                degenerate_face_indices.add(face_index)
+                # This happens for two reasons:
+                # 1. Two or more of the face's points are the same. (i.e, point indices of [0, 0, 1])
+                # 2. The face is a duplicate of another face. (i.e., point indices of [0, 1, 2] and [0, 1, 2])
+                invalid_face_indices.add(face_index)
 
-        if len(degenerate_face_indices) > 0:
+        # TODO: Handle invalid faces better.
-            result.warnings.append(f'Discarded {len(degenerate_face_indices)} degenerate face(s).')
+        if len(invalid_face_indices) > 0:
+            result.warnings.append(f'Discarded {len(invalid_face_indices)} invalid face(s).')
 
         bm.to_mesh(mesh_data)
 
         # TEXTURE COORDINATES
-        data_index = 0
+        uv_layer_data_index = 0
         uv_layer = mesh_data.uv_layers.new(name='VTXW0000')
         for face_index, face in enumerate(psk.faces):
-            if face_index in degenerate_face_indices:
+            if face_index in invalid_face_indices:
                 continue
             face_wedges = [psk.wedges[i] for i in reversed(face.wedge_indices)]
             for wedge in face_wedges:
-                uv_layer.data[data_index].uv = wedge.u, 1.0 - wedge.v
+                uv_layer.data[uv_layer_data_index].uv = wedge.u, 1.0 - wedge.v
-                data_index += 1
+                uv_layer_data_index += 1
 
         # EXTRA UVS
         if psk.has_extra_uvs and options.should_import_extra_uvs:
             extra_uv_channel_count = int(len(psk.extra_uvs) / len(psk.wedges))
             wedge_index_offset = 0
             for extra_uv_index in range(extra_uv_channel_count):
-                data_index = 0
+                uv_layer_data_index = 0
                 uv_layer = mesh_data.uv_layers.new(name=f'EXTRAUV{extra_uv_index}')
                 for face_index, face in enumerate(psk.faces):
-                    if face_index in degenerate_face_indices:
+                    if face_index in invalid_face_indices:
                         continue
                     for wedge_index in reversed(face.wedge_indices):
                         u, v = psk.extra_uvs[wedge_index_offset + wedge_index]
-                        uv_layer.data[data_index].uv = u, 1.0 - v
+                        uv_layer.data[uv_layer_data_index].uv = u, 1.0 - v
-                        data_index += 1
+                        uv_layer_data_index += 1
                 wedge_index_offset += len(psk.wedges)
 
         # VERTEX COLORS
         if psk.has_vertex_colors and options.should_import_vertex_colors:
-            size = (len(psk.points), 4)
+            # Convert vertex colors to sRGB if necessary.
-            vertex_colors = np.full(size, inf)
+            psk_vertex_colors = np.zeros((len(psk.vertex_colors), 4))
-            vertex_color_data = mesh_data.vertex_colors.new(name='VERTEXCOLOR')
+            for vertex_color_index in range(len(psk.vertex_colors)):
-            ambiguous_vertex_color_point_indices = []
+                psk_vertex_colors[vertex_color_index,:] = psk.vertex_colors[vertex_color_index].normalized()
+            match options.vertex_color_space:
+                case 'SRGBA':
+                    for i in range(psk_vertex_colors.shape[0]):
+                        psk_vertex_colors[i, :3] = tuple(map(lambda x: rgb_to_srgb(x), psk_vertex_colors[i, :3]))
+                case _:
+                    pass
 
-            for wedge_index, wedge in enumerate(psk.wedges):
+            # Map the PSK vertex colors to the face corners.
-                point_index = wedge.point_index
+            face_count = len(psk.faces) - len(invalid_face_indices)
-                psk_vertex_color = psk.vertex_colors[wedge_index].normalized()
+            face_corner_colors = np.full((face_count * 3, 4), 1.0)
-                if vertex_colors[point_index, 0] != inf and tuple(vertex_colors[point_index]) != psk_vertex_color:
+            face_corner_color_index = 0
-                    ambiguous_vertex_color_point_indices.append(point_index)
+            for face_index, face in enumerate(psk.faces):
-                else:
+                if face_index in invalid_face_indices:
-                    vertex_colors[point_index] = psk_vertex_color
+                    continue
+                for wedge_index in reversed(face.wedge_indices):
+                    face_corner_colors[face_corner_color_index] = psk_vertex_colors[wedge_index]
+                    face_corner_color_index += 1
 
-            if options.vertex_color_space == 'SRGBA':
+            # Create the vertex color attribute.
-                for i in range(vertex_colors.shape[0]):
+            face_corner_color_attribute = mesh_data.attributes.new(name='VERTEXCOLOR', type='FLOAT_COLOR', domain='CORNER')
-                    vertex_colors[i, :3] = tuple(map(lambda x: rgb_to_srgb(x), vertex_colors[i, :3]))
+            face_corner_color_attribute.data.foreach_set('color', face_corner_colors.flatten())
-
-            for loop_index, loop in enumerate(mesh_data.loops):
-                vertex_color = vertex_colors[loop.vertex_index]
-                if vertex_color is not None:
-                    vertex_color_data.data[loop_index].color = vertex_color
-                else:
-                    vertex_color_data.data[loop_index].color = 1.0, 1.0, 1.0, 1.0
-
-            if len(ambiguous_vertex_color_point_indices) > 0:
-                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:
-            mesh_data.polygons.foreach_set("use_smooth", [True] * len(mesh_data.polygons))
+            mesh_data.polygons.foreach_set('use_smooth', [True] * len(mesh_data.polygons))
             normals = []
             for vertex_normal in psk.vertex_normals:
                 normals.append(tuple(vertex_normal))
             mesh_data.normals_split_custom_set_from_vertices(normals)
+            # TODO: This has been removed in 4.1!
             mesh_data.use_auto_smooth = True
+        else:
+            mesh_data.shade_smooth()
 
         bm.normal_update()
         bm.free()
@@ -266,6 +272,9 @@ def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
             armature_modifier.object = armature_object
             mesh_object.parent = armature_object
 
+    root_object = armature_object if options.should_import_skeleton else mesh_object
+    root_object.scale = (options.scale, options.scale, options.scale)
+
     try:
         bpy.ops.object.mode_set(mode='OBJECT')
     except:

io_scene_psk_psa/psk/properties.py

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

io_scene_psk_psa/psk/reader.py

@@ -23,7 +23,7 @@ def _read_material_references(path: str) -> List[str]:
         return []
     # Do a crude regex match to find the Material list entries.
     contents = property_file_path.read_text()
-    pattern = r"Material\s*=\s*([^\s^,]+)"
+    pattern = r'Material\s*=\s*([^\s^,]+)'
     return re.findall(pattern, contents)
 
 
@@ -78,4 +78,16 @@ def read_psk(path: str) -> Psk:
     '''
     psk.material_references = _read_material_references(path)
 
+    '''
+    Tools like UEViewer and CUE4Parse write the point index as a 32-bit integer, exploiting the fact that due to struct
+    alignment, there were 16-bits of padding following the original 16-bit point index in the wedge struct.
+    However, this breaks compatibility with PSK files that were created with older tools that treated the
+    point index as a 16-bit integer and might have junk data written to the padding bits.
+    To work around this, we check if each point is still addressable using a 16-bit index, and if it is, assume the
+    point index is a 16-bit integer and truncate the high bits.
+    '''
+    if len(psk.points) <= 65536:
+        for wedge in psk.wedges:
+            wedge.point_index &= 0xFFFF
+
     return psk

io_scene_psk_psa/psk/ui.py

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

io_scene_psk_psa/psk/writer.py

@@ -6,7 +6,7 @@ from ..data import Section, Vector3
 
 MAX_WEDGE_COUNT = 65536
 MAX_POINT_COUNT = 4294967296
-MAX_BONE_COUNT = 256
+MAX_BONE_COUNT = 2147483647
 MAX_MATERIAL_COUNT = 256
 
 

io_scene_psk_psa/types.py

@@ -2,7 +2,7 @@ from bpy.props import StringProperty, IntProperty, BoolProperty, FloatProperty
 from bpy.types import PropertyGroup, UIList, UILayout, Context, AnyType, Panel
 
 
-class PSX_UL_bone_group_list(UIList):
+class PSX_UL_bone_collection_list(UIList):
 
     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):
@@ -11,7 +11,7 @@ class PSX_UL_bone_group_list(UIList):
         row.label(text=str(getattr(item, 'count')), icon='BONE_DATA')
 
 
-class PSX_PG_bone_group_list_item(PropertyGroup):
+class PSX_PG_bone_collection_list_item(PropertyGroup):
     name: StringProperty()
     index: IntProperty()
     count: IntProperty()
@@ -21,6 +21,7 @@ class PSX_PG_bone_group_list_item(PropertyGroup):
 class PSX_PG_action_export(PropertyGroup):
     compression_ratio: FloatProperty(name='Compression Ratio', default=1.0, min=0.0, max=1.0, subtype='FACTOR', description='The key sampling ratio of the exported sequence.\n\nA compression ratio of 1.0 will export all frames, while a compression ratio of 0.5 will export half of the frames')
     key_quota: IntProperty(name='Key Quota', default=0, min=1, description='The minimum number of frames to be exported')
+    fps: FloatProperty(name='FPS', default=30.0, min=0.0, description='The frame rate of the exported sequence')
 
 
 class PSX_PT_action(Panel):
@@ -38,13 +39,17 @@ class PSX_PT_action(Panel):
     def draw(self, context: 'Context'):
         action = context.active_action
         layout = self.layout
-        layout.prop(action.psa_export, 'compression_ratio')
+        flow = layout.grid_flow(columns=1)
-        layout.prop(action.psa_export, 'key_quota')
+        flow.use_property_split = True
+        flow.use_property_decorate = False
+        flow.prop(action.psa_export, 'compression_ratio')
+        flow.prop(action.psa_export, 'key_quota')
+        flow.prop(action.psa_export, 'fps')
 
 
 classes = (
     PSX_PG_action_export,
-    PSX_PG_bone_group_list_item,
+    PSX_PG_bone_collection_list_item,
-    PSX_UL_bone_group_list,
+    PSX_UL_bone_collection_list,
-    PSX_PT_action
+    PSX_PT_action,
 )