From 00d9e3996c9da31507289ac981ca2150bfc9aa73 Mon Sep 17 00:00:00 2001 From: Colin Basnett Date: Sun, 18 May 2025 00:46:50 -0700 Subject: [PATCH] Fixed an issue where ACTIVE_ACTION sequence source was not working Also added a scene-level transform source. --- io_scene_psk_psa/__init__.py | 13 ++-- io_scene_psk_psa/psa/builder.py | 26 +++++--- io_scene_psk_psa/psa/config.py | 2 + io_scene_psk_psa/psa/export/operators.py | 25 +++----- io_scene_psk_psa/psa/export/properties.py | 77 ++++++++++++++--------- io_scene_psk_psa/psa/importer.py | 18 +++--- io_scene_psk_psa/psa/writer.py | 4 +- io_scene_psk_psa/psk/builder.py | 52 +++++++-------- io_scene_psk_psa/psk/export/operators.py | 62 +++++++++++++----- io_scene_psk_psa/psk/export/properties.py | 32 +++++----- io_scene_psk_psa/psk/properties.py | 36 +++++++---- io_scene_psk_psa/shared/dfs.py | 13 ---- io_scene_psk_psa/shared/helpers.py | 76 ++++++++++++++++++---- io_scene_psk_psa/shared/types.py | 15 ++++- io_scene_psk_psa/shared/ui.py | 39 +++++++++++- pyproject.toml | 3 + 16 files changed, 324 insertions(+), 169 deletions(-) diff --git a/io_scene_psk_psa/__init__.py b/io_scene_psk_psa/__init__.py index 4b1eede..62a5045 100644 --- a/io_scene_psk_psa/__init__.py +++ b/io_scene_psk_psa/__init__.py @@ -71,6 +71,7 @@ import bpy from bpy.props import PointerProperty classes = shared_types.classes + \ + shared_ui.classes + \ psk_properties.classes + \ psk_ui.classes + \ psk_import_operators.classes + \ @@ -108,15 +109,17 @@ 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) - bpy.types.Action.psa_export = PointerProperty(type=shared_types.PSX_PG_action_export) + bpy.types.Material.psk = PointerProperty(type=psk_properties.PSX_PG_material, options={'HIDDEN'}) + bpy.types.Scene.psx_export = PointerProperty(type=shared_types.PSX_PG_scene_export, options={'HIDDEN'}) + bpy.types.Scene.psa_import = PointerProperty(type=psa_import_properties.PSA_PG_import, options={'HIDDEN'}) + bpy.types.Scene.psa_export = PointerProperty(type=psa_export_properties.PSA_PG_export, options={'HIDDEN'}) + bpy.types.Scene.psk_export = PointerProperty(type=psk_export_properties.PSK_PG_export, options={'HIDDEN'}) + bpy.types.Action.psa_export = PointerProperty(type=shared_types.PSX_PG_action_export, options={'HIDDEN'}) def unregister(): del bpy.types.Material.psk + del bpy.types.Scene.psx_export del bpy.types.Scene.psa_import del bpy.types.Scene.psa_export del bpy.types.Scene.psk_export diff --git a/io_scene_psk_psa/psa/builder.py b/io_scene_psk_psa/psa/builder.py index ed98fbd..493fee6 100644 --- a/io_scene_psk_psa/psa/builder.py +++ b/io_scene_psk_psa/psa/builder.py @@ -30,7 +30,7 @@ class PsaBuildOptions: self.animation_data: Optional[AnimData] = None self.sequences: List[PsaBuildSequence] = [] self.bone_filter_mode: str = 'ALL' - self.bone_collection_indices: List[Tuple[str, int]] = [] + self.bone_collection_indices: List[PsaBoneCollectionIndex] = [] self.sequence_name_prefix: str = '' self.sequence_name_suffix: str = '' self.scale = 1.0 @@ -39,6 +39,11 @@ class PsaBuildOptions: self.forward_axis = 'X' self.up_axis = 'Z' self.root_bone_name = 'ROOT' + self.sequence_source = 'ACTIONS' # One of ('ACTIONS', 'TIMELINE_MARKERS', 'NLA_STRIPS') + + @property + def bone_collection_primary_key(self) -> str: + return 'DATA' if self.sequence_source == 'ACTIVE_ACTION' else 'OBJECT' def _get_pose_bone_location_and_rotation( @@ -100,8 +105,15 @@ def _get_pose_bone_location_and_rotation( def build_psa(context: Context, options: PsaBuildOptions) -> Psa: psa = Psa() + armature_objects_for_bones = options.armature_objects + if options.sequence_source == 'ACTIVE_ACTION' and len(options.armature_objects) >= 2: + # Make sure that the data-block for all the selected armature objects is the same. + if any(map(lambda o: o.data != options.armature_objects[0].data, options.armature_objects[1:])): + raise RuntimeError('All armature objects must share the same data-block when exporting from the active action') + armature_objects_for_bones = [options.armature_objects[0]] + psx_bone_create_result = create_psx_bones( - armature_objects=options.armature_objects, + armature_objects=armature_objects_for_bones, export_space=options.export_space, root_bone_name=options.root_bone_name, forward_axis=options.forward_axis, @@ -109,6 +121,7 @@ def build_psa(context: Context, options: PsaBuildOptions) -> Psa: scale=options.scale, bone_filter_mode=options.bone_filter_mode, bone_collection_indices=options.bone_collection_indices, + bone_collection_primary_key=options.bone_collection_primary_key, ) # Build list of PSA bones. @@ -145,11 +158,7 @@ def build_psa(context: Context, options: PsaBuildOptions) -> Psa: frame_extents = abs(frame_end - frame_start) frame_count_raw = frame_extents + 1 frame_count = max(1, max(export_sequence.key_quota, int(frame_count_raw * export_sequence.compression_ratio))) - - try: - frame_step = frame_extents / (frame_count - 1) - except ZeroDivisionError: - frame_step = 0.0 + frame_step = frame_extents / (frame_count - 1) if frame_count > 1 else 0.0 # If this is a reverse sequence, we need to reverse the frame step. if frame_start > frame_end: @@ -219,9 +228,6 @@ def build_psa(context: Context, options: PsaBuildOptions) -> Psa: export_bones.append(PsaExportBone(pose_bone, armature_object, armature_scales[armature_object])) - for export_bone in export_bones: - print(export_bone.pose_bone, export_bone.armature_object, export_bone.scale) - match options.sampling_mode: case 'INTERPOLATED': # Used as a store for the last frame's pose bone locations and rotations. diff --git a/io_scene_psk_psa/psa/config.py b/io_scene_psk_psa/psa/config.py index c5e616e..f0c8a2a 100644 --- a/io_scene_psk_psa/psa/config.py +++ b/io_scene_psk_psa/psa/config.py @@ -56,6 +56,8 @@ def read_psa_config(psa_sequence_names: List[str], file_path: str) -> PsaConfig: if config.has_section('RemoveTracks'): for key, value in config.items('RemoveTracks'): match = re.match(f'^(.+)\.(\d+)$', key) + if not match: + continue sequence_name = match.group(1) # Map the sequence name onto the actual sequence name in the PSA file. diff --git a/io_scene_psk_psa/psa/export/operators.py b/io_scene_psk_psa/psa/export/operators.py index 6d88f7e..522e609 100644 --- a/io_scene_psk_psa/psa/export/operators.py +++ b/io_scene_psk_psa/psa/export/operators.py @@ -14,7 +14,7 @@ from .properties import ( ) from ..builder import build_psa, PsaBuildSequence, PsaBuildOptions from ..writer import write_psa -from ...shared.helpers import populate_bone_collection_list, get_nla_strips_in_frame_range +from ...shared.helpers import populate_bone_collection_list, get_nla_strips_in_frame_range, PsxBoneCollection from ...shared.semver import SemanticVersion from ...shared.ui import draw_bone_filter_mode @@ -400,7 +400,7 @@ class PSA_OT_export(Operator, ExportHelper): rows=rows ) - bones_advanced_header, bones_advanced_panel = layout.panel('Advanced', default_closed=False) + bones_advanced_header, bones_advanced_panel = layout.panel('Bones Advanced', default_closed=False) bones_advanced_header.label(text='Advanced') if bones_advanced_panel: flow = bones_advanced_panel.grid_flow() @@ -450,7 +450,11 @@ class PSA_OT_export(Operator, ExportHelper): armature_object.animation_data_create() update_actions_and_timeline_markers(context, self.armature_objects) - populate_bone_collection_list(self.armature_objects, pg.bone_collection_list) + populate_bone_collection_list( + pg.bone_collection_list, + self.armature_objects, + primary_key='DATA' if pg.sequence_source == 'ACTIVE_ACTION' else 'OBJECT', + ) context.window_manager.fileselect_add(self) @@ -459,16 +463,6 @@ class PSA_OT_export(Operator, ExportHelper): def execute(self, context): pg = getattr(context.scene, 'psa_export') - # 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') - - if pg.sequence_source == 'TIMELINE_MARKERS' and len(pg.marker_list) == 0: - raise RuntimeError('No timeline markers were selected for export') - - if 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) animation_data = animation_data_object.animation_data @@ -537,15 +531,16 @@ 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_collection_indices = [(x.armature_object_name, x.index) for x in pg.bone_collection_list if x.is_selected] + options.bone_collection_indices = [PsxBoneCollection(x.armature_object_name, x.armature_data_name, x.index) for x in pg.bone_collection_list if x.is_selected] options.sequence_name_prefix = pg.sequence_name_prefix options.sequence_name_suffix = pg.sequence_name_suffix - options.scale = pg.scale options.sampling_mode = pg.sampling_mode options.export_space = pg.export_space + options.scale = pg.scale options.forward_axis = pg.forward_axis options.up_axis = pg.up_axis options.root_bone_name = pg.root_bone_name + options.sequence_source = pg.sequence_source try: psa = build_psa(context, options) diff --git a/io_scene_psk_psa/psa/export/properties.py b/io_scene_psk_psa/psa/export/properties.py index 5d907dd..26c512e 100644 --- a/io_scene_psk_psa/psa/export/properties.py +++ b/io_scene_psk_psa/psa/export/properties.py @@ -12,7 +12,10 @@ from bpy.props import ( StringProperty, ) from bpy.types import PropertyGroup, Object, Action, AnimData, Context -from ...shared.types import ForwardUpAxisMixin, ExportSpaceMixin, PsxBoneExportMixin + +from ...shared.dfs import dfs_view_layer_objects +from ...shared.helpers import populate_bone_collection_list +from ...shared.types import TransformMixin, ExportSpaceMixin, PsxBoneExportMixin def psa_export_property_group_animation_data_override_poll(_context, obj): @@ -103,7 +106,43 @@ def animation_data_override_update_cb(self: 'PSA_PG_export', context: Context): self.nla_track = '' -class PSA_PG_export(PropertyGroup, ForwardUpAxisMixin, ExportSpaceMixin, PsxBoneExportMixin): +sequence_source_items = ( + ('ACTIONS', 'Actions', 'Sequences will be exported using actions', 'ACTION', 0), + ('TIMELINE_MARKERS', 'Timeline Markers', 'Sequences are delineated by scene timeline markers', 'MARKER_HLT', 1), + ('NLA_TRACK_STRIPS', 'NLA Track Strips', 'Sequences are delineated by the start & end times of strips on the selected NLA track', 'NLA', 2), + ('ACTIVE_ACTION', 'Active Action', 'The active action will be exported for each selected armature', 'ACTION', 3), +) + +fps_source_items = ( + ('SCENE', 'Scene', '', 'SCENE_DATA', 0), + ('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', 'ACTION', 1), + ('CUSTOM', 'Custom', '', 2) +) + +compression_ratio_source_items = ( + ('ACTION_METADATA', 'Action Metadata', 'The compression ratio will be determined by action\'s Compression Ratio 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', 'ACTION', 1), + ('CUSTOM', 'Custom', '', 2) +) + +sampling_mode_items = ( + ('INTERPOLATED', 'Interpolated', 'Sampling is performed by interpolating the evaluated bone poses from the adjacent whole frames.', 'INTERPOLATED', 0), + ('SUBFRAME', 'Subframe', 'Sampling is performed by evaluating the bone poses at the subframe time.\n\nNot recommended unless you are also animating with subframes enabled.', 'SUBFRAME', 1), +) + + +def sequence_source_update_cb(self: 'PSA_PG_export', context: Context) -> None: + armature_objects = [] + for dfs_object in dfs_view_layer_objects(context.view_layer): + if dfs_object.obj.type == 'ARMATURE' and dfs_object.is_selected: + armature_objects.append(dfs_object.obj) + + populate_bone_collection_list( + self.bone_collection_list, + armature_objects, + primary_key='DATA' if self.sequence_source == 'ACTIVE_ACTION' else 'OBJECT') + + +class PSA_PG_export(PropertyGroup, TransformMixin, ExportSpaceMixin, PsxBoneExportMixin): should_override_animation_data: BoolProperty( name='Override Animation Data', options=set(), @@ -120,12 +159,8 @@ class PSA_PG_export(PropertyGroup, ForwardUpAxisMixin, ExportSpaceMixin, PsxBone name='Source', options=set(), description='', - items=( - ('ACTIONS', 'Actions', 'Sequences will be exported using actions', 'ACTION', 0), - ('TIMELINE_MARKERS', 'Timeline Markers', 'Sequences are delineated by scene timeline markers', 'MARKER_HLT', 1), - ('NLA_TRACK_STRIPS', 'NLA Track Strips', 'Sequences are delineated by the start & end times of strips on the selected NLA track', 'NLA', 2), - ('ACTIVE_ACTION', 'Active Action', 'The active action will be exported for each selected armature', 'ACTION', 3), - ) + items=sequence_source_items, + update=sequence_source_update_cb, ) nla_track: StringProperty( name='NLA Track', @@ -139,22 +174,14 @@ class PSA_PG_export(PropertyGroup, ForwardUpAxisMixin, ExportSpaceMixin, PsxBone name='FPS Source', options=set(), description='', - items=( - ('SCENE', 'Scene', '', 'SCENE_DATA', 0), - ('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', 'ACTION', 1), - ('CUSTOM', 'Custom', '', 2) - ) + items=fps_source_items, ) - fps_custom: FloatProperty(default=30.0, min=sys.float_info.epsilon, soft_min=1.0, options=set(), step=100, - soft_max=60.0) + fps_custom: FloatProperty(default=30.0, min=sys.float_info.epsilon, soft_min=1.0, options=set(), step=100, soft_max=60.0) compression_ratio_source: EnumProperty( name='Compression Ratio Source', options=set(), description='', - items=( - ('ACTION_METADATA', 'Action Metadata', 'The compression ratio will be determined by action\'s Compression Ratio 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', 'ACTION', 1), - ('CUSTOM', 'Custom', '', 2) - ) + items=compression_ratio_source_items, ) compression_ratio_custom: FloatProperty(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') action_list: CollectionProperty(type=PSA_PG_export_action_list_item) @@ -193,21 +220,11 @@ class PSA_PG_export(PropertyGroup, ForwardUpAxisMixin, ExportSpaceMixin, PsxBone name='Show Reversed', description='Show reversed sequences' ) - scale: FloatProperty( - name='Scale', - default=1.0, - description='Scale factor to apply to the bone translations. Use this if you are exporting animations for a scaled PSK mesh', - min=0.0, - soft_max=100.0 - ) sampling_mode: EnumProperty( name='Sampling Mode', options=set(), description='The method by which frames are sampled', - items=( - ('INTERPOLATED', 'Interpolated', 'Sampling is performed by interpolating the evaluated bone poses from the adjacent whole frames.', 'INTERPOLATED', 0), - ('SUBFRAME', 'Subframe', 'Sampling is performed by evaluating the bone poses at the subframe time.\n\nNot recommended unless you are also animating with subframes enabled.', 'SUBFRAME', 1), - ), + items=sampling_mode_items, default='INTERPOLATED' ) diff --git a/io_scene_psk_psa/psa/importer.py b/io_scene_psk_psa/psa/importer.py index 3221855..06fb419 100644 --- a/io_scene_psk_psa/psa/importer.py +++ b/io_scene_psk_psa/psa/importer.py @@ -1,9 +1,8 @@ -import typing -from typing import Iterable, List, Optional, cast as typing_cast +from typing import Sequence, Iterable, List, Optional, cast as typing_cast import bpy import numpy as np -from bpy.types import Armature, Context, FCurve, Object +from bpy.types import Armature, Context, FCurve, Object, Bone, PoseBone from mathutils import Vector, Quaternion from .config import PsaConfig, REMOVE_TRACK_LOCATION, REMOVE_TRACK_ROTATION @@ -18,7 +17,7 @@ class PsaImportOptions(object): fps_custom: float = 30.0, fps_source: str = 'SEQUENCE', psa_config: PsaConfig = PsaConfig(), - sequence_names: List[str] = None, + sequence_names: Optional[List[str]] = None, should_convert_to_samples: bool = False, should_overwrite: bool = False, should_stash: bool = False, @@ -48,15 +47,15 @@ class ImportBone(object): def __init__(self, psa_bone: PsxBone): self.psa_bone: PsxBone = psa_bone self.parent: Optional[ImportBone] = None - self.armature_bone = None - self.pose_bone = None + self.armature_bone: Optional[Bone] = None + self.pose_bone: Optional[PoseBone] = None self.original_location: Vector = Vector() self.original_rotation: Quaternion = Quaternion() self.post_rotation: Quaternion = Quaternion() self.fcurves: List[FCurve] = [] -def _calculate_fcurve_data(import_bone: ImportBone, key_data: Iterable[float]): +def _calculate_fcurve_data(import_bone: ImportBone, key_data: Sequence[float]): # Convert world-space transforms to local-space transforms. key_rotation = Quaternion(key_data[0:4]) key_location = Vector(key_data[4:]) @@ -345,8 +344,9 @@ def import_psa(context: Context, psa_reader: PsaReader, armature_object: Object, # If the user specifies, store the new animations as strips on a non-contributing NLA track. if options.should_stash: - if armature_object.animation_data is None: - armature_object.animation_data_create() + animation_data = armature_object.animation_data + if animation_data is None: + animation_data = armature_object.animation_data_create() for action in actions: nla_track = armature_object.animation_data.nla_tracks.new() nla_track.name = action.name diff --git a/io_scene_psk_psa/psa/writer.py b/io_scene_psk_psa/psa/writer.py index 015c1e5..b31be25 100644 --- a/io_scene_psk_psa/psa/writer.py +++ b/io_scene_psk_psa/psa/writer.py @@ -1,11 +1,11 @@ from ctypes import Structure, sizeof -from typing import Type +from typing import Optional, Type, Collection from .data import Psa from ..shared.data import PsxBone, Section -def write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None): +def write_section(fp, name: bytes, data_type: Optional[Type[Structure]] = None, data: Optional[Collection] = None): section = Section() section.name = name if data_type is not None and data is not None: diff --git a/io_scene_psk_psa/psk/builder.py b/io_scene_psk_psa/psk/builder.py index 3f415fd..a948986 100644 --- a/io_scene_psk_psa/psk/builder.py +++ b/io_scene_psk_psa/psk/builder.py @@ -3,14 +3,16 @@ import bpy import numpy as np from bpy.types import Armature, Collection, Context, Depsgraph, Object from mathutils import Matrix -from typing import Dict, Generator, Iterable, List, Optional, Set, Tuple, cast as typing_cast +from typing import Dict, Iterable, List, Optional, Set, Tuple, cast as typing_cast from .data import Psk from .properties import triangle_type_and_bit_flags_to_poly_flags from ..shared.data import Vector3 from ..shared.dfs import DfsObject, dfs_collection_objects, dfs_view_layer_objects from ..shared.helpers import ( + PsxBoneCollection, convert_string_to_cp1252_bytes, create_psx_bones, + get_armatures_for_mesh_objects, get_coordinate_system_transform, ) @@ -24,7 +26,7 @@ class PskInputObjects(object): class PskBuildOptions(object): def __init__(self): self.bone_filter_mode = 'ALL' - self.bone_collection_indices: List[Tuple[str, int]] = [] + self.bone_collection_indices: List[PsxBoneCollection] = [] self.object_eval_state = 'EVALUATED' self.material_order_mode = 'AUTOMATIC' self.material_name_list: List[str] = [] @@ -59,34 +61,21 @@ def get_mesh_objects_for_context(context: Context) -> Iterable[DfsObject]: def get_armature_for_mesh_object(mesh_object: Object) -> Optional[Object]: + if mesh_object.type != 'MESH': + return None for modifier in mesh_object.modifiers: if modifier.type == 'ARMATURE': return modifier.object return None -def get_armatures_for_mesh_objects(mesh_objects: Iterable[Object]) -> Generator[Object, None, None]: - # Ensure that there are either no armature modifiers (static mesh) or that there is exactly one armature modifier - # object shared between all meshes. - armature_objects = set() - for mesh_object in mesh_objects: - modifiers = [x for x in mesh_object.modifiers if x.type == 'ARMATURE'] - if len(modifiers) == 0: - continue - if modifiers[0].object in armature_objects: - continue - yield modifiers[0].object - - def _get_psk_input_objects(mesh_dfs_objects: Iterable[DfsObject]) -> PskInputObjects: mesh_dfs_objects = list(mesh_dfs_objects) if len(mesh_dfs_objects) == 0: raise RuntimeError('At least one mesh must be selected') - input_objects = PskInputObjects() input_objects.mesh_dfs_objects = mesh_dfs_objects input_objects.armature_objects |= set(get_armatures_for_mesh_objects(map(lambda x: x.obj, mesh_dfs_objects))) - return input_objects @@ -95,10 +84,8 @@ def get_psk_input_objects_for_context(context: Context) -> PskInputObjects: return _get_psk_input_objects(mesh_objects) -def get_psk_input_objects_for_collection(collection: Collection, should_exclude_hidden_meshes: bool = True) -> PskInputObjects: +def get_psk_input_objects_for_collection(collection: Collection) -> PskInputObjects: mesh_objects = get_mesh_objects_for_collection(collection) - if should_exclude_hidden_meshes: - mesh_objects = filter(lambda x: x.is_visible, mesh_objects) return _get_psk_input_objects(mesh_objects) @@ -181,8 +168,9 @@ def build_psk(context: Context, input_objects: PskInputObjects, options: PskBuil psk_material = Psk.Material() psk_material.name = convert_string_to_cp1252_bytes(material.name if material else 'None') 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) + if material is not None: + 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) # TODO: This wasn't left in a good state. We should detect if we need to add a "default" material. @@ -203,6 +191,9 @@ def build_psk(context: Context, input_objects: PskInputObjects, options: PskBuil # Calculate the export spaces for the armature objects. # This is used later to transform the mesh object geometry into the export space. armature_mesh_export_space_matrices: Dict[Optional[Object], Matrix] = {None: Matrix.Identity(4)} + if options.export_space == 'ARMATURE': + # For meshes without an armature modifier, we need to set the export space to the armature object. + armature_mesh_export_space_matrices[None] = _get_mesh_export_space_matrix(list(input_objects.armature_objects)[0], options.export_space) for armature_object in armature_objects: armature_mesh_export_space_matrices[armature_object] = _get_mesh_export_space_matrix(armature_object, options.export_space) @@ -215,13 +206,11 @@ def build_psk(context: Context, input_objects: PskInputObjects, options: PskBuil for armature_object in armature_objects: armature_object.data.pose_position = 'REST' - material_names = [m.name for m in materials] + material_names = [m.name if m is not None else 'None' for m in materials] for object_index, input_mesh_object in enumerate(input_objects.mesh_dfs_objects): obj, matrix_world = input_mesh_object.obj, input_mesh_object.matrix_world - armature_object = get_armature_for_mesh_object(obj) - should_flip_normals = False # Material indices @@ -281,7 +270,14 @@ def build_psk(context: Context, input_objects: PskInputObjects, options: PskBuil case _: assert False, f'Invalid object evaluation state: {options.object_eval_state}' - mesh_export_space_matrix = armature_mesh_export_space_matrices[armature_object] + match options.export_space: + case 'ARMATURE' | 'ROOT': + mesh_export_space_matrix = armature_mesh_export_space_matrices[armature_object] + case 'WORLD': + mesh_export_space_matrix = armature_mesh_export_space_matrices[armature_object] + case _: + assert False, f'Invalid export space: {options.export_space}' + vertex_transform_matrix = scale_matrix @ coordinate_system_matrix @ mesh_export_space_matrix point_transform_matrix = vertex_transform_matrix @ mesh_object.matrix_world @@ -419,11 +415,11 @@ def build_psk(context: Context, input_objects: PskInputObjects, options: PskBuil for armature_object, pose_position in original_armature_object_pose_positions.items(): armature_object.data.pose_position = pose_position - context.window_manager.progress_end() - # https://github.com/DarklightGames/io_scene_psk_psa/issues/129. psk.sort_and_normalize_weights() + context.window_manager.progress_end() + result.psk = psk return result diff --git a/io_scene_psk_psa/psk/export/operators.py b/io_scene_psk_psa/psk/export/operators.py index e160c49..faf7703 100644 --- a/io_scene_psk_psa/psk/export/operators.py +++ b/io_scene_psk_psa/psk/export/operators.py @@ -3,7 +3,7 @@ from typing import Iterable, List, Optional, cast as typing_cast import bpy from bpy.props import BoolProperty, StringProperty -from bpy.types import Collection, Context, Depsgraph, Material, Object, Operator, SpaceProperties +from bpy.types import Collection, Context, Depsgraph, Material, Object, Operator, SpaceProperties, Scene from bpy_extras.io_utils import ExportHelper from .properties import PskExportMixin @@ -15,7 +15,7 @@ from ..builder import ( get_psk_input_objects_for_context, ) from ..writer import write_psk -from ...shared.helpers import populate_bone_collection_list +from ...shared.helpers import PsxBoneCollection, populate_bone_collection_list from ...shared.ui import draw_bone_filter_mode @@ -77,7 +77,7 @@ class PSK_OT_bone_collection_list_populate(Operator): if not input_objects.armature_objects: self.report({'ERROR_INVALID_CONTEXT'}, 'No armature modifiers found on mesh objects') return {'CANCELLED'} - populate_bone_collection_list(input_objects.armature_objects, export_operator.bone_collection_list) + populate_bone_collection_list(export_operator.bone_collection_list, input_objects.armature_objects) return {'FINISHED'} @@ -246,18 +246,28 @@ def get_sorted_materials_by_names(materials: Iterable[Material], material_names: return materials_in_collection + materials_not_in_collection -def get_psk_build_options_from_property_group(pg: PskExportMixin) -> PskBuildOptions: +def get_psk_build_options_from_property_group(scene: Scene, pg: PskExportMixin) -> PskBuildOptions: options = PskBuildOptions() options.object_eval_state = pg.object_eval_state options.export_space = pg.export_space options.bone_filter_mode = pg.bone_filter_mode - options.bone_collection_indices = [(x.armature_object_name, x.index) for x in pg.bone_collection_list if x.is_selected] - options.scale = pg.scale - options.forward_axis = pg.forward_axis - options.up_axis = pg.up_axis + options.bone_collection_indices = [PsxBoneCollection(x.armature_object_name, x.armature_data_name, x.index) for x in pg.bone_collection_list if x.is_selected] options.root_bone_name = pg.root_bone_name options.material_order_mode = pg.material_order_mode options.material_name_list = pg.material_name_list + + match pg.transform_source: + case 'SCENE': + transform_source = getattr(scene, 'psx_export') + case 'SELF': + transform_source = pg + case _: + assert False, f'Invalid transform source: {pg.transform_source}' + + options.scale = transform_source.scale + options.forward_axis = transform_source.forward_axis + options.up_axis = transform_source.up_axis + return options @@ -279,12 +289,12 @@ class PSK_OT_export_collection(Operator, ExportHelper, PskExportMixin): collection = bpy.data.collections.get(self.collection) try: - input_objects = get_psk_input_objects_for_collection(collection, self.should_exclude_hidden_meshes) + input_objects = get_psk_input_objects_for_collection(collection) except RuntimeError as e: self.report({'ERROR_INVALID_CONTEXT'}, str(e)) return {'CANCELLED'} - options = get_psk_build_options_from_property_group(self) + options = get_psk_build_options_from_property_group(context.scene, self) filepath = str(Path(self.filepath).resolve()) try: @@ -317,7 +327,6 @@ class PSK_OT_export_collection(Operator, ExportHelper, PskExportMixin): flow.use_property_split = True flow.use_property_decorate = False flow.prop(self, 'object_eval_state', text='Data') - flow.prop(self, 'should_exclude_hidden_meshes') # Bones bones_header, bones_panel = layout.panel('Bones', default_closed=False) @@ -375,10 +384,22 @@ class PSK_OT_export_collection(Operator, ExportHelper, PskExportMixin): flow.use_property_split = True flow.use_property_decorate = False flow.prop(self, 'export_space') - flow.prop(self, 'scale') - flow.prop(self, 'forward_axis') - flow.prop(self, 'up_axis') + flow.prop(self, 'transform_source') + flow = transform_panel.grid_flow(row_major=True) + flow.use_property_split = True + flow.use_property_decorate = False + + match self.transform_source: + case 'SCENE': + transform_source = getattr(context.scene, 'psx_export') + flow.enabled = False + case 'CUSTOM': + transform_source = self + + flow.prop(transform_source, 'scale') + flow.prop(transform_source, 'forward_axis') + flow.prop(transform_source, 'up_axis') class PSK_OT_export(Operator, ExportHelper): @@ -403,7 +424,7 @@ class PSK_OT_export(Operator, ExportHelper): pg = getattr(context.scene, 'psk_export') - populate_bone_collection_list(input_objects.armature_objects, pg.bone_collection_list) + populate_bone_collection_list(pg.bone_collection_list, input_objects.armature_objects) depsgraph = context.evaluated_depsgraph_get() @@ -476,12 +497,21 @@ class PSK_OT_export(Operator, ExportHelper): flow.prop(pg, 'scale') flow.prop(pg, 'forward_axis') flow.prop(pg, 'up_axis') + + # Extended Format + extended_format_header, extended_format_panel = layout.panel('Extended Format', default_closed=False) + extended_format_header.label(text='Extended Format') + if extended_format_panel: + flow = extended_format_panel.grid_flow(row_major=True) + flow.use_property_split = True + flow.use_property_decorate = False + flow.prop(pg, 'should_export_vertex_normals', text='Vertex Normals') def execute(self, context): pg = getattr(context.scene, 'psk_export') input_objects = get_psk_input_objects_for_context(context) - options = get_psk_build_options_from_property_group(pg) + options = get_psk_build_options_from_property_group(context.scene, pg) try: result = build_psk(context, input_objects, options) diff --git a/io_scene_psk_psa/psk/export/properties.py b/io_scene_psk_psa/psk/export/properties.py index 3128e17..9f3741f 100644 --- a/io_scene_psk_psa/psk/export/properties.py +++ b/io_scene_psk_psa/psk/export/properties.py @@ -8,7 +8,7 @@ from bpy.props import ( StringProperty, ) from bpy.types import Material, PropertyGroup -from ...shared.types import ExportSpaceMixin, ForwardUpAxisMixin, PsxBoneExportMixin +from ...shared.types import ExportSpaceMixin, TransformMixin, PsxBoneExportMixin object_eval_state_items = ( ('EVALUATED', 'Evaluated', 'Use data from fully evaluated object'), @@ -20,33 +20,27 @@ material_order_mode_items = ( ('MANUAL', 'Manual', 'Manually arrange the materials'), ) +transform_source_items = ( + ('SCENE', 'Scene', 'Use the scene transform settings'), + ('CUSTOM', 'Custom', 'Use custom transform settings'), +) + class PSK_PG_material_list_item(PropertyGroup): material: PointerProperty(type=Material) index: IntProperty() + class PSK_PG_material_name_list_item(PropertyGroup): material_name: StringProperty() index: IntProperty() -class PskExportMixin(ExportSpaceMixin, ForwardUpAxisMixin, PsxBoneExportMixin): +class PskExportMixin(ExportSpaceMixin, TransformMixin, PsxBoneExportMixin): object_eval_state: EnumProperty( items=object_eval_state_items, name='Object Evaluation State', default='EVALUATED' ) - should_exclude_hidden_meshes: BoolProperty( - default=False, - name='Visible Only', - description='Export only visible meshes' - ) - scale: FloatProperty( - name='Scale', - default=1.0, - description='Scale factor to apply to the exported mesh and armature', - min=0.0001, - soft_max=100.0 - ) material_order_mode: EnumProperty( name='Material Order', description='The order in which to export the materials', @@ -55,6 +49,16 @@ class PskExportMixin(ExportSpaceMixin, ForwardUpAxisMixin, PsxBoneExportMixin): ) material_name_list: CollectionProperty(type=PSK_PG_material_name_list_item) material_name_list_index: IntProperty(default=0) + should_export_vertex_normals: BoolProperty( + 'Export Vertex Normals', + default=False, + description='Export VTXNORMS section.' + ) + transform_source: EnumProperty( + items=transform_source_items, + name='Transform Source', + default='SCENE' + ) class PSK_PG_export(PropertyGroup, PskExportMixin): diff --git a/io_scene_psk_psa/psk/properties.py b/io_scene_psk_psa/psk/properties.py index 13bdc66..e1a8619 100644 --- a/io_scene_psk_psa/psk/properties.py +++ b/io_scene_psk_psa/psk/properties.py @@ -20,9 +20,15 @@ mesh_triangle_bit_flags_items = ( ) 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_type: EnumProperty( + name='Triangle Type', + items=mesh_triangle_types_items + ) + mesh_triangle_bit_flags: EnumProperty( + name='Triangle Bit Flags', + items=mesh_triangle_bit_flags_items, + 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} @@ -36,7 +42,7 @@ def triangle_type_and_bit_flags_to_poly_flags(mesh_triangle_type: str, mesh_tria return poly_flags -def poly_flags_to_triangle_type_and_bit_flags(poly_flags: int) -> (str, set[str]): +def poly_flags_to_triangle_type_and_bit_flags(poly_flags: int) -> tuple[str, set[str]]: try: triangle_type = next(item[0] for item in mesh_triangle_types_items if item[3] == (poly_flags & 15)) except StopIteration: @@ -53,6 +59,17 @@ def should_import_skleton_get(self): return self.components in {'ALL', 'ARMATURE'} +vertex_color_space_items = ( + ('LINEAR', 'Linear', ''), + ('SRGBA', 'sRGBA', ''), +) + +psk_import_components_items = ( + ('ALL', 'Mesh & Armature', 'Import mesh and armature'), + ('MESH', 'Mesh Only', 'Import mesh only'), + ('ARMATURE', 'Armature Only', 'Import armature only'), +) + class PskImportMixin: should_import_vertex_colors: BoolProperty( default=True, @@ -65,10 +82,7 @@ class PskImportMixin: options=set(), description='The source vertex color space', default='SRGBA', - items=( - ('LINEAR', 'Linear', ''), - ('SRGBA', 'sRGBA', ''), - ) + items=vertex_color_space_items ) should_import_vertex_normals: BoolProperty( default=True, @@ -86,11 +100,7 @@ class PskImportMixin: name='Components', options=set(), description='Which components to import', - items=( - ('ALL', 'Mesh & Armature', 'Import mesh and armature'), - ('MESH', 'Mesh Only', 'Import mesh only'), - ('ARMATURE', 'Armature Only', 'Import armature only'), - ), + items=psk_import_components_items, default='ALL' ) should_import_mesh: BoolProperty( diff --git a/io_scene_psk_psa/shared/dfs.py b/io_scene_psk_psa/shared/dfs.py index baba7a5..cadc583 100644 --- a/io_scene_psk_psa/shared/dfs.py +++ b/io_scene_psk_psa/shared/dfs.py @@ -146,16 +146,3 @@ def dfs_view_layer_objects(view_layer: ViewLayer) -> Iterable[DfsObject]: yield from _dfs_collection_objects_recursive(layer_collection.collection, visited=visited) yield from layer_collection_objects_recursive(view_layer.layer_collection) - - -def _is_dfs_object_visible(obj: Object, instance_objects: List[Object]) -> bool: - """ - Check if a DFS object is visible. - - @param obj: The object. - @param instance_objects: The instance objects. - @return: True if the object is visible, False otherwise. - """ - if instance_objects: - return instance_objects[-1].visible_get() - return obj.visible_get() diff --git a/io_scene_psk_psa/shared/helpers.py b/io_scene_psk_psa/shared/helpers.py index e517a4e..fc0b57a 100644 --- a/io_scene_psk_psa/shared/helpers.py +++ b/io_scene_psk_psa/shared/helpers.py @@ -1,8 +1,7 @@ import bpy from collections import Counter from typing import List, Iterable, Optional, Dict, Tuple, cast as typing_cast -from bpy.props import CollectionProperty -from bpy.types import Armature, AnimData, Object +from bpy.types import Armature, AnimData, Object, ArmatureModifier from mathutils import Matrix, Vector, Quaternion as BpyQuaternion from .data import Vector3, Quaternion from ..shared.data import PsxBone @@ -28,16 +27,27 @@ def get_nla_strips_in_frame_range(animation_data: AnimData, frame_min: float, fr yield strip -def populate_bone_collection_list(armature_objects: Iterable[Object], bone_collection_list: CollectionProperty) -> None: +def populate_bone_collection_list(bone_collection_list, armature_objects: Iterable[Object], primary_key: str = 'OBJECT'): """ - Updates the bone collections collection. + Updates the bone collection list. - Bone collection selections are preserved between updates unless none of the groups were previously selected; - otherwise, all collections are selected by default. + Selection is preserved between updates unless none of the groups were previously selected. + Otherwise, all collections are selected by default. + + The primary key is used to determine how to group the armature objects. For example, if the primary key is + 'DATA', then all bone collections with the same armature data-block will be under one entry. + + :param bone_collection_list: The list to update. + :param armature_objects: The armature objects to populate the collection with. + :param primary_key: The primary key to use for the collection (one of 'OBJECT' or 'DATA'). + :return: None """ has_selected_collections = any([g.is_selected for g in bone_collection_list]) unassigned_collection_is_selected, selected_assigned_collection_names = True, [] + if primary_key not in ('OBJECT', 'DATA'): + assert False, f'Invalid primary key: {primary_key}' + if not armature_objects: return @@ -51,16 +61,26 @@ def populate_bone_collection_list(armature_objects: Iterable[Object], bone_colle selected_assigned_collection_names = [ g.name for i, g in enumerate(bone_collection_list) if i != unassigned_collection_idx and g.is_selected] + bone_collection_list.clear() + unique_armature_data = set() + for armature_object in armature_objects: armature = typing_cast(Armature, armature_object.data) if armature is None: - return + continue + + if primary_key == 'DATA' and armature_object.data in unique_armature_data: + # Skip this armature since we have already added an entry for it and we are using the data as the key. + continue + + unique_armature_data.add(armature_object.data) item = bone_collection_list.add() item.armature_object_name = armature_object.name + item.armature_data_name = armature_object.data.name if armature_object.data else '' item.name = 'Unassigned' # TODO: localize item.index = -1 # Count the number of bones without an assigned bone collection @@ -70,6 +90,7 @@ def populate_bone_collection_list(armature_objects: Iterable[Object], bone_colle for bone_collection_index, bone_collection in enumerate(armature.collections_all): item = bone_collection_list.add() item.armature_object_name = armature_object.name + item.armature_data_name = armature_object.data.name if armature_object.data else '' item.name = bone_collection.name item.index = bone_collection_index item.count = len(bone_collection.bones) @@ -286,6 +307,16 @@ def convert_bpy_quaternion_to_psx_quaternion(other: BpyQuaternion) -> Quaternion return quaternion +class PsxBoneCollection: + """ + Stores the armature's object name, data-block name and bone collection index. + """ + def __init__(self, armature_object_name: str, armature_data_name: str, index: int): + self.armature_object_name = armature_object_name + self.armature_data_name = armature_data_name + self.index = index + + def create_psx_bones( armature_objects: List[Object], export_space: str = 'WORLD', @@ -294,7 +325,8 @@ def create_psx_bones( up_axis: str = 'Z', scale: float = 1.0, bone_filter_mode: str = 'ALL', - bone_collection_indices: Optional[List[Tuple[str, int]]] = None, + bone_collection_indices: Optional[List[PsxBoneCollection]] = None, + bone_collection_primary_key: str = 'OBJECT', ) -> PsxBoneCreateResult: """ Creates a list of PSX bones from the given armature objects and options. @@ -306,20 +338,27 @@ def create_psx_bones( bones: List[Tuple[PsxBone, Optional[Object]]] = [] - if export_space != 'WORLD' and len(armature_objects) > 1: + if export_space != 'WORLD' and len(armature_objects) >= 2: armature_object_names = [armature_object.name for armature_object in armature_objects] - raise RuntimeError(f'When exporting multiple armatures, the Export Space must be World. The following armatures are attempting to be exported: {armature_object_names}') + raise RuntimeError(f'When exporting multiple armatures, the Export Space must be World.\n' \ + f'The following armatures are attempting to be exported: {armature_object_names}') coordinate_system_matrix = get_coordinate_system_transform(forward_axis, up_axis) coordinate_system_default_rotation = coordinate_system_matrix.to_quaternion() total_bone_count = sum(len(armature_object.data.bones) for armature_object in armature_objects) - # Store the bone names to be exported for each armature object. armature_object_bone_names: Dict[Object, List[str]] = dict() for armature_object in armature_objects: - armature_bone_collection_indices = [x[1] for x in bone_collection_indices if x[0] == armature_object.name] + armature_bone_collection_indices: List[int] = [] + match bone_collection_primary_key: + case 'OBJECT': + armature_bone_collection_indices.extend([x.index for x in bone_collection_indices if x.armature_object_name == armature_object.name]) + case 'DATA': + armature_bone_collection_indices.extend([x.index for x in bone_collection_indices if armature_object.data and x.armature_data_name == armature_object.data.name]) + case _: + assert False, f'Invalid primary key: {bone_collection_primary_key}' bone_names = get_export_bone_names(armature_object, bone_filter_mode, armature_bone_collection_indices) armature_object_bone_names[armature_object] = bone_names @@ -429,3 +468,16 @@ def get_coordinate_system_transform(forward_axis: str = 'X', up_axis: str = 'Z') (up.x, up.y, up.z, 0.0), (0.0, 0.0, 0.0, 1.0) )) + + +def get_armatures_for_mesh_objects(mesh_objects: Iterable[Object]): + """ + Returns a generator of unique armature objects that are used by the given mesh objects. + """ + armature_objects: set[Object] = set() + for mesh_object in mesh_objects: + armature_modifiers = [typing_cast(ArmatureModifier, x) for x in mesh_object.modifiers if x.type == 'ARMATURE'] + for armature_object in map(lambda x: x.object, armature_modifiers): + if armature_object is not None: + armature_objects.add(armature_object) + yield from armature_objects diff --git a/io_scene_psk_psa/shared/types.py b/io_scene_psk_psa/shared/types.py index 75a0861..9f4b91e 100644 --- a/io_scene_psk_psa/shared/types.py +++ b/io_scene_psk_psa/shared/types.py @@ -21,6 +21,7 @@ class PSX_UL_bone_collection_list(UIList): class PSX_PG_bone_collection_list_item(PropertyGroup): armature_object_name: StringProperty() + armature_data_name: StringProperty() name: StringProperty() index: IntProperty() count: IntProperty() @@ -93,7 +94,14 @@ def up_axis_update(self, __context): self.forward_axis = next((axis for axis in axis_identifiers if axis != self.up_axis), 'X') -class ForwardUpAxisMixin: +class TransformMixin: + scale: FloatProperty( + name='Scale', + default=1.0, + description='Scale factor to apply to all location data', + soft_min=0.0, + soft_max=100.0 + ) forward_axis: EnumProperty( name='Forward', items=forward_items, @@ -139,7 +147,12 @@ class PsxBoneExportMixin: ) +class PSX_PG_scene_export(PropertyGroup, TransformMixin): + pass + + classes = ( + PSX_PG_scene_export, PSX_PG_action_export, PSX_PG_bone_collection_list_item, PSX_UL_bone_collection_list, diff --git a/io_scene_psk_psa/shared/ui.py b/io_scene_psk_psa/shared/ui.py index 88f10be..f8be4b1 100644 --- a/io_scene_psk_psa/shared/ui.py +++ b/io_scene_psk_psa/shared/ui.py @@ -1,4 +1,5 @@ -from bpy.types import UILayout +import bpy +from bpy.types import Context, UILayout, Panel from .types import bone_filter_mode_items @@ -16,3 +17,39 @@ def draw_bone_filter_mode(layout: UILayout, pg, should_always_show_bone_collecti item_layout = row.row(align=True) item_layout.prop_enum(pg, 'bone_filter_mode', item_identifier) item_layout.enabled = should_always_show_bone_collections or is_bone_filter_mode_item_available(pg, identifier) + + +class PSX_PT_scene(Panel): + bl_idname = 'PSX_PT_scene' + bl_label = 'PSK Export' + bl_space_type = 'PROPERTIES' + bl_region_type = 'WINDOW' + bl_context = 'scene' + bl_category = 'PSK/PSA' + + @classmethod + def poll(cls, context): + return context.scene is not None + + def draw(self, context: Context): + layout = self.layout + scene = bpy.context.scene + psx_export = getattr(scene, 'psx_export', None) + if psx_export is None: + return + + # Transform + transform_header, transform_panel = layout.panel('Transform', default_closed=False) + transform_header.label(text='Transform') + if transform_panel: + flow = layout.grid_flow(columns=1) + flow.use_property_split = True + flow.use_property_decorate = False + flow.prop(psx_export, 'scale') + flow.prop(psx_export, 'forward_axis') + flow.prop(psx_export, 'up_axis') + + +classes = ( + PSX_PT_scene, +) diff --git a/pyproject.toml b/pyproject.toml index 120fe8a..b785ff6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,3 +10,6 @@ branch = true [tool.coverage.report] ignore_errors = true + +[tool.pyright] +reportInvalidTypeForm = false \ No newline at end of file