Merge branch 'blender-4.1' into scale_keys

# Conflicts:
#	io_scene_psk_psa/psa/import_/operators.py
#	io_scene_psk_psa/psa/importer.py

io_scene_psk_psa/__init__.py

@@ -3,7 +3,7 @@ from bpy.app.handlers import persistent
 bl_info = {
     'name': 'PSK/PSA Importer/Exporter',
     'author': 'Colin Basnett, Yurii Ti',
-    'version': (6, 1, 2),
+    'version': (6, 2, 0),
     'blender': (4, 0, 0),
     'description': 'PSK/PSA Import/Export (.psk/.psa)',
     'warning': '',
@@ -24,6 +24,8 @@ 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)
@@ -34,6 +36,7 @@ if 'bpy' in locals():
     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)
@@ -50,6 +53,8 @@ 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
@@ -72,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 +\
@@ -107,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)
@@ -114,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

io_scene_psk_psa/psa/config.py

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

io_scene_psk_psa/psa/data.py

@@ -58,7 +58,27 @@ class Psa:
         def __repr__(self) -> str:
             return repr((self.location, self.rotation, self.time))
 
+    class ScaleKey(Structure):
+        _fields_ = [
+            ('scale', Vector3),
+            ('time', c_float)
+        ]
+
+        @property
+        def data(self):
+            yield self.scale.x
+            yield self.scale.y
+            yield self.scale.z
+
+        def __repr__(self) -> str:
+            return repr((self.scale, self.time))
+
     def __init__(self):
         self.bones: List[Psa.Bone] = []
         self.sequences: typing.OrderedDict[str, Psa.Sequence] = OrderedDict()
         self.keys: List[Psa.Key] = []
+        self.scale_keys: List[Psa.ScaleKey] = []
+
+    @property
+    def has_scale_keys(self):
+        return len(self.scale_keys) > 0

io_scene_psk_psa/psa/export/operators.py

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

io_scene_psk_psa/psa/export/ui.py

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

io_scene_psk_psa/psa/import_/operators.py

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

io_scene_psk_psa/psa/import_/properties.py

@@ -47,6 +47,8 @@ class PSA_PG_import(PropertyGroup):
                                    description='If an action with a matching name already exists, the existing action '
                                                'will have it\'s data overwritten instead of a new action being created')
     should_write_keyframes: BoolProperty(default=True, name='Keyframes', options=empty_set)
+    should_write_scale_keys: BoolProperty(default=True, name='Scale Keys', options=empty_set, description=
+                                        'Import scale keys, if available')
     should_write_metadata: BoolProperty(default=True, name='Metadata', options=empty_set,
                                         description='Additional data will be written to the custom properties of the '
                                                     'Action (e.g., frame rate)')
@@ -75,13 +77,13 @@ class PSA_PG_import(PropertyGroup):
     )
     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),
+        ('SCENE', 'Scene', 'The sequence is resampled to the frame rate of the scene', 'SCENE_DATA', 1),
-        ('CUSTOM', 'Custom', 'The sequence frame rate dilates to match a custom frame rate', 2),
+        ('CUSTOM', 'Custom', 'The sequence is resampled to 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',
+        description='The frame rate to which the imported sequences will be resampled to',
         options=empty_set,
         min=1.0,
         soft_min=1.0,

io_scene_psk_psa/psa/importer.py

@@ -1,8 +1,8 @@
 import typing
-from typing import List, Optional
+from typing import List, Optional, Iterable
 
 import bpy
-import numpy
+import numpy as np
 from bpy.types import FCurve, Object, Context
 from mathutils import Vector, Quaternion
 
@@ -19,6 +19,7 @@ class PsaImportOptions(object):
         self.should_overwrite = False
         self.should_write_keyframes = True
         self.should_write_metadata = True
+        self.should_write_scale_keys = True
         self.action_name_prefix = ''
         self.should_convert_to_samples = False
         self.bone_mapping_mode = 'CASE_INSENSITIVE'
@@ -38,24 +39,25 @@ class ImportBone(object):
         self.original_rotation: Quaternion = Quaternion()
         self.post_rotation: Quaternion = Quaternion()
         self.fcurves: List[FCurve] = []
+        self.scale_fcurves: List[FCurve] = []
 
 
-def _calculate_fcurve_data(import_bone: ImportBone, key_data: typing.Iterable[float]):
+def _calculate_fcurve_data(import_bone: ImportBone, key_data: Iterable[float]):
     # 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_rotation.copy()
     q.rotate(import_bone.original_rotation)
-    quat = q
+    rotation = q
     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())
+    rotation.rotate(q.conjugated())
-    loc = key_location - import_bone.original_location
+    location = key_location - import_bone.original_location
-    loc.rotate(import_bone.post_rotation.conjugated())
+    location.rotate(import_bone.post_rotation.conjugated())
-    return quat.w, quat.x, quat.y, quat.z, loc.x, loc.y, loc.z
+    return rotation.w, rotation.x, rotation.y, rotation.z, location.x, location.y, location.z
 
 
 class PsaImportResult:
@@ -64,12 +66,12 @@ class PsaImportResult:
 
 
 def _get_armature_bone_index_for_psa_bone(psa_bone_name: str, armature_bone_names: List[str], bone_mapping_mode: str = 'EXACT') -> Optional[int]:
-    '''
+    """
     @param psa_bone_name: The name of the PSA bone.
     @param armature_bone_names: The names of the bones in the armature.
     @param bone_mapping_mode: One of 'EXACT' or 'CASE_INSENSITIVE'.
     @return: The index of the armature bone that corresponds to the given PSA bone, or None if no such bone exists.
-    '''
+    """
     for armature_bone_index, armature_bone_name in enumerate(armature_bone_names):
         if bone_mapping_mode == 'CASE_INSENSITIVE':
             if armature_bone_name.lower() == psa_bone_name.lower():
@@ -79,6 +81,51 @@ def _get_armature_bone_index_for_psa_bone(psa_bone_name: str, armature_bone_name
                 return armature_bone_index
     return None
 
+def _get_sample_frame_times(source_frame_count: int, frame_step: float) -> typing.Iterable[float]:
+    # TODO: for correctness, we should also emit the target frame time as well (because the last frame can be a
+    #  fractional frame).
+    time = 0.0
+    while time < source_frame_count - 1:
+        yield time
+        time += frame_step
+    yield source_frame_count - 1
+
+def _resample_sequence_data_matrix(sequence_data_matrix: np.ndarray, frame_step: float = 1.0) -> np.ndarray:
+    """
+    Resamples the sequence data matrix to the target frame count.
+    @param sequence_data_matrix: FxBx7 matrix where F is the number of frames, B is the number of bones, and X is the
+    number of data elements per bone.
+    @param frame_step: The step between frames in the resampled sequence.
+    @return: The resampled sequence data matrix, or sequence_data_matrix if no resampling is necessary.
+    """
+    if frame_step == 1.0:
+        # No resampling is necessary.
+        return sequence_data_matrix
+
+    source_frame_count, bone_count = sequence_data_matrix.shape[:2]
+    sample_frame_times = list(_get_sample_frame_times(source_frame_count, frame_step))
+    target_frame_count = len(sample_frame_times)
+    resampled_sequence_data_matrix = np.zeros((target_frame_count, bone_count, 7), dtype=float)
+
+    for sample_frame_index, sample_frame_time in enumerate(sample_frame_times):
+        frame_index = int(sample_frame_time)
+        if sample_frame_time % 1.0 == 0.0:
+            # Sample time has no fractional part, so just copy the frame.
+            resampled_sequence_data_matrix[sample_frame_index, :, :] = sequence_data_matrix[frame_index, :, :]
+        else:
+            # Sample time has a fractional part, so interpolate between two frames.
+            next_frame_index = frame_index + 1
+            for bone_index in range(bone_count):
+                source_frame_1_data = sequence_data_matrix[frame_index, bone_index, :]
+                source_frame_2_data = sequence_data_matrix[next_frame_index, bone_index, :]
+                factor = sample_frame_time - frame_index
+                q = Quaternion((source_frame_1_data[:4])).slerp(Quaternion((source_frame_2_data[:4])), factor)
+                q.normalize()
+                l = Vector(source_frame_1_data[4:]).lerp(Vector(source_frame_2_data[4:]), factor)
+                resampled_sequence_data_matrix[sample_frame_index, bone_index, :] = q.w, q.x, q.y, q.z, l.x, l.y, l.z
+
+    return resampled_sequence_data_matrix
+
 
 def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object, options: PsaImportOptions) -> PsaImportResult:
     result = PsaImportResult()
@@ -142,8 +189,10 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
 
     for import_bone in filter(lambda x: x is not None, import_bones):
         armature_bone = import_bone.armature_bone
+
         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 import_bone.parent is not None:
             import_bone.original_location = armature_bone.matrix_local.translation - armature_bone.parent.matrix_local.translation
@@ -153,7 +202,8 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
             import_bone.original_rotation.conjugate()
         else:
             import_bone.original_location = armature_bone.matrix_local.translation.copy()
-            import_bone.original_rotation = armature_bone.matrix_local.to_quaternion()
+            import_bone.original_rotation = armature_bone.matrix_local.to_quaternion().conjugated()
+
         import_bone.post_rotation = import_bone.original_rotation.conjugated()
 
     context.window_manager.progress_begin(0, len(sequences))
@@ -186,12 +236,9 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
             case _:
                 raise ValueError(f'Unknown FPS source: {options.fps_source}')
 
-        keyframe_time_dilation = target_fps / sequence.fps
-
         if options.should_write_keyframes:
-            # Remove existing f-curves (replace with action.fcurves.clear() in Blender 3.2)
+            # Remove existing f-curves.
-            while len(action.fcurves) > 0:
+            action.fcurves.clear()
-                action.fcurves.remove(action.fcurves[-1])
 
             # Create f-curves for the rotation and location of each bone.
             for psa_bone_index, armature_bone_index in psa_to_armature_bone_indices.items():
@@ -212,6 +259,14 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
                     action.fcurves.new(location_data_path, index=2, action_group=pose_bone.name) if add_location_fcurves else None,  # Lz
                 ]
                 
+                if options.should_write_scale_keys:
+                    scale_data_path = pose_bone.path_from_id('scale')
+                    import_bone.fcurves += [
+                        action.fcurves.new(scale_data_path, index=0, action_group=pose_bone.name),  # Sx
+                        action.fcurves.new(scale_data_path, index=1, action_group=pose_bone.name),  # Sy
+                        action.fcurves.new(scale_data_path, index=2, action_group=pose_bone.name),  # Sz
+                    ]
+
             # Read the sequence data matrix from the PSA.
             sequence_data_matrix = psa_reader.read_sequence_data_matrix(sequence_name)
 
@@ -225,23 +280,45 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object,
                     # Calculate the local-space key data for the bone.
                     sequence_data_matrix[frame_index, bone_index] = _calculate_fcurve_data(import_bone, key_data)
 
-            # Write the keyframes out.
+            # Resample the sequence data to the target FPS.
-            fcurve_data = numpy.zeros(2 * sequence.frame_count, dtype=float)
+            # If the target frame count is the same as the source frame count, this will be a no-op.
+            resampled_sequence_data_matrix = _resample_sequence_data_matrix(sequence_data_matrix,
+                                                                            frame_step=sequence.fps / target_fps)
+
+            # Write the keyframes out.
+            # Note that the f-curve data consists of alternating time and value data.
+            target_frame_count = resampled_sequence_data_matrix.shape[0]
+            fcurve_data = np.zeros(2 * target_frame_count, dtype=float)
+            fcurve_data[0::2] = range(0, target_frame_count)
 
-            # Populate the keyframe time data.
-            fcurve_data[0::2] = [x * keyframe_time_dilation for x in range(sequence.frame_count)]
             for bone_index, import_bone in enumerate(import_bones):
                 if import_bone is None:
                     continue
                 for fcurve_index, fcurve in enumerate(import_bone.fcurves):
                     if fcurve is None:
                         continue
-                    fcurve_data[1::2] = sequence_data_matrix[:, bone_index, fcurve_index]
+                    fcurve_data[1::2] = resampled_sequence_data_matrix[:, bone_index, fcurve_index]
-                    fcurve.keyframe_points.add(sequence.frame_count)
+                    fcurve.keyframe_points.add(target_frame_count)
                     fcurve.keyframe_points.foreach_set('co', fcurve_data)
                     for fcurve_keyframe in fcurve.keyframe_points:
                         fcurve_keyframe.interpolation = 'LINEAR'
 
+            if options.should_write_scale_keys:
+                sequence_scale_data_matrix = psa_reader.read_sequence_scale_key_data_matrix(sequence_name)
+                # Write the scale keys out.
+                fcurve_data = numpy.zeros(2 * sequence.frame_count, dtype=float)
+                # 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.scale_fcurves):
+                        fcurve_data[1::2] = sequence_scale_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.
                 for fcurve in action.fcurves:

io_scene_psk_psa/psa/reader.py

@@ -1,4 +1,5 @@
 import ctypes
+from typing import Optional
 
 import numpy as np
 
@@ -23,14 +24,15 @@ def _try_fix_cue4parse_issue_103(sequences) -> bool:
 
 
 class PsaReader(object):
-    '''
+    """
     This class reads the sequences and bone information immediately upon instantiation and holds onto a file handle.
     The keyframe data is not read into memory upon instantiation due to its potentially very large size.
     To read the key data for a particular sequence, call :read_sequence_keys.
-    '''
+    """
 
     def __init__(self, path):
         self.keys_data_offset: int = 0
+        self.scale_keys_data_offset: Optional[int] = None
         self.fp = open(path, 'rb')
         self.psa: Psa = self._read(self.fp)
 
@@ -43,11 +45,11 @@ class PsaReader(object):
         return self.psa.sequences
 
     def read_sequence_data_matrix(self, sequence_name: str) -> np.ndarray:
-        '''
+        """
         Reads and returns the data matrix for the given sequence.
         @param sequence_name: The name of the sequence.
         @return: An FxBx7 matrix where F is the number of frames, B is the number of bones.
-        '''
+        """
         sequence = self.psa.sequences[sequence_name]
         keys = self.read_sequence_keys(sequence_name)
         bone_count = len(self.bones)
@@ -60,13 +62,13 @@ 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.
+        @return: A list of keys for the sequence.
-        '''
+        """
-        # Set the file reader to the beginning of the keys data
+        # Set the file reader to the beginning of the key data.
         sequence = self.psa.sequences[sequence_name]
         data_size = sizeof(Psa.Key)
         bone_count = len(self.psa.bones)
@@ -82,6 +84,49 @@ class PsaReader(object):
             offset += data_size
         return keys
 
+    def read_sequence_scale_key_data_matrix(self, sequence_name: str) -> np.ndarray:
+        """
+        Reads and returns the scale key data matrix for the given sequence.
+        @param sequence_name: The name of the sequence.
+        @return: An FxBx3 matrix where F is the number of frames, B is the number of bones.
+        """
+        sequence = self.psa.sequences[sequence_name]
+        scale_keys = self.read_sequence_scale_keys(sequence_name)
+        bone_count = len(self.bones)
+        matrix_size = sequence.frame_count, bone_count, 3
+        matrix = np.ones(matrix_size)
+        keys_iter = iter(scale_keys)
+        for frame_index in range(sequence.frame_count):
+            for bone_index in range(bone_count):
+                matrix[frame_index, bone_index, :] = iter(next(keys_iter).scale)
+        return matrix
+
+    def read_sequence_scale_keys(self, sequence_name: str) -> List[Psa.ScaleKey]:
+        """
+        Reads and returns the scale key data for a sequence.
+
+        Throws a RuntimeError exception if the sequence does not contain scale keys (use Psa.has_scale_keys to check).
+        @param sequence_name: The name of the sequence.
+        @return: A list of scale keys for the sequence.
+        """
+        if not self.psa.has_scale_keys:
+            raise RuntimeError('The PSA file does not contain scale keys.')
+        # Set the file reader to the beginning of the key data.
+        sequence = self.psa.sequences[sequence_name]
+        data_size = sizeof(Psa.ScaleKey)
+        bone_count = len(self.psa.bones)
+        buffer_length = data_size * bone_count * sequence.frame_count
+        sequence_scale_keys_offset = self.keys_data_offset + (sequence.frame_start_index * bone_count * data_size)
+        self.fp.seek(sequence_scale_keys_offset, 0)
+        buffer = self.fp.read(buffer_length)
+        offset = 0
+        scale_keys = []
+        for _ in range(sequence.frame_count * bone_count):
+            scale_key = Psa.ScaleKey.from_buffer_copy(buffer, offset)
+            scale_keys.append(scale_key)
+            offset += data_size
+        return scale_keys
+
     @staticmethod
     def _read_types(fp, data_class, section: Section, data):
         buffer_length = section.data_size * section.data_count
@@ -111,6 +156,10 @@ class PsaReader(object):
                 # Skip keys on this pass. We will keep this file open and read from it as needed.
                 self.keys_data_offset = fp.tell()
                 fp.seek(section.data_size * section.data_count, 1)
+            elif section.name == b'SCALEKEYS':
+                # Skip scale keys on this pass. We will keep this file open and read from it as needed.
+                self.scale_keys_data_offset = fp.tell()
+                fp.seek(section.data_size * section.data_count, 1)
             else:
                 fp.seek(section.data_size * section.data_count, 1)
                 print(f'Unrecognized section in PSA: "{section.name}"')

io_scene_psk_psa/psk/builder.py

@@ -1,15 +1,19 @@
+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):
@@ -17,7 +21,7 @@ class PskBuildOptions(object):
         self.bone_filter_mode = 'ALL'
         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
 
 
@@ -61,7 +65,7 @@ def get_psk_input_objects(context) -> PskInputObjects:
 class PskBuildResult(object):
     def __init__(self):
         self.psk = None
-        self.warnings = []
+        self.warnings: List[str] = []
 
 
 def build_psk(context, options: PskBuildOptions) -> PskBuildResult:
@@ -72,9 +76,9 @@ def build_psk(context, options: PskBuildOptions) -> 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
@@ -135,21 +139,25 @@ def build_psk(context, options: PskBuildOptions) -> PskBuildResult:
             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()
         try:
-            psk_material.name = bytes(material_name, encoding='windows-1252')
+            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')
+            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)
 
     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_slot.material.name) for material_slot in input_mesh_object.material_slots]
 
@@ -177,8 +185,16 @@ def build_psk(context, options: PskBuildOptions) -> PskBuildResult:
             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)
-            if any(map(lambda x: x < 0, scale)):
+
-                result.warnings.append(f'Mesh "{input_mesh_object.name}" has negative scaling which may result in inverted normals.')
+            # 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:
@@ -207,11 +223,11 @@ def build_psk(context, options: PskBuildOptions) -> PskBuildResult:
         # 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:
@@ -219,8 +235,8 @@ def build_psk(context, options: PskBuildOptions) -> PskBuildResult:
                 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:
@@ -233,6 +249,7 @@ def build_psk(context, options: PskBuildOptions) -> PskBuildResult:
 
         # 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]
@@ -242,6 +259,11 @@ def build_psk(context, options: PskBuildOptions) -> PskBuildResult:
             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)

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

@@ -20,19 +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_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 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
 
 
@@ -159,7 +159,7 @@ class PSK_OT_export(Operator, ExportHelper):
         options.bone_filter_mode = pg.bone_filter_mode
         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:

io_scene_psk_psa/psk/export/properties.py

@@ -1,18 +1,19 @@
-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_collection_list_item
 
+empty_set = set()
 
 class PSK_PG_material_list_item(PropertyGroup):
-    material_name: StringProperty()
+    material: PointerProperty(type=Material)
     index: IntProperty()
 
 
 class PSK_PG_export(PropertyGroup):
     bone_filter_mode: EnumProperty(
         name='Bone Filter',
-        options=set(),
+        options=empty_set,
         description='',
         items=(
             ('ALL', 'All', 'All bones will be exported'),

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

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

io_scene_psk_psa/psk/importer.py

@@ -7,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
 
 
@@ -134,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)
 
@@ -166,38 +170,38 @@ def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
         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 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 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:
             # Convert vertex colors to sRGB if necessary.
             psk_vertex_colors = np.zeros((len(psk.vertex_colors), 4))
-            for i in range(len(psk.vertex_colors)):
+            for vertex_color_index in range(len(psk.vertex_colors)):
-                psk_vertex_colors[i,:] = psk.vertex_colors[i].normalized()
+                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]):
@@ -227,7 +231,6 @@ def import_psk(psk: Psk, context, options: PskImportOptions) -> PskImportResult:
             for vertex_normal in psk.vertex_normals:
                 normals.append(tuple(vertex_normal))
             mesh_data.normals_split_custom_set_from_vertices(normals)
-            # TODO: This has been removed in 4.1!
             mesh_data.use_auto_smooth = True
         else:
             mesh_data.shade_smooth()

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/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

@@ -51,5 +51,5 @@ classes = (
     PSX_PG_action_export,
     PSX_PG_bone_collection_list_item,
     PSX_UL_bone_collection_list,
-    PSX_PT_action
+    PSX_PT_action,
 )