DarklightGames/io_scene_psk_psa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed an issue where ACTIVE_ACTION sequence source was not working

Browse Source 
Also added a scene-level transform source.
This commit is contained in:
Colin Basnett
2025-05-18 00:46:50 -07:00
parent ff2fe35846
commit 00d9e3996c
16 changed files with 324 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
io_scene_psk_psa/__init__.py
View File

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

26
io_scene_psk_psa/psa/builder.py
View File

@@ -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.

2
io_scene_psk_psa/psa/config.py
View File

@@ -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.

25
io_scene_psk_psa/psa/export/operators.py
View File

@@ -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)

77
io_scene_psk_psa/psa/export/properties.py
View File

@@ -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'
)

18
io_scene_psk_psa/psa/importer.py
View File

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

4
io_scene_psk_psa/psa/writer.py
View File

@@ -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:

46
io_scene_psk_psa/psk/builder.py
View File

@@ -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,6 +168,7 @@ 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)
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)
@@ -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}'
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

62
io_scene_psk_psa/psk/export/operators.py
View File

@@ -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()
@@ -477,11 +498,20 @@ class PSK_OT_export(Operator, ExportHelper):
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)

32
io_scene_psk_psa/psk/export/properties.py
View File

@@ -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):

36
io_scene_psk_psa/psk/properties.py
View File

@@ -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(

13
io_scene_psk_psa/shared/dfs.py
View File

@@ -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()

76
io_scene_psk_psa/shared/helpers.py
View File

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

15
io_scene_psk_psa/shared/types.py
View File

@@ -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,

39
io_scene_psk_psa/shared/ui.py
View File

@@ -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,
)

3
pyproject.toml
View File

@@ -10,3 +10,6 @@ branch = true
[tool.coverage.report]
ignore_errors = true
[tool.pyright]
reportInvalidTypeForm = false