Renamed src folder to io_export_psk_psa

io_export_psk_psa/__init__.py

@@ -0,0 +1,73 @@
+bl_info = {
+    "name": "PSK/PSA Exporter",
+    "author": "Colin Basnett",
+    "version": ( 1, 0, 0 ),
+    "blender": ( 2, 80, 0 ),
+    "location": "File > Export > PSK Export (.psk)",
+    "description": "PSK/PSA Export (.psk)",
+    "warning": "",
+    "wiki_url": "https://github.com/DarklightGames/io_export_psk_psa",
+    "tracker_url": "https://github.com/DarklightGames/io_export_psk_psa/issues",
+    "category": "Import-Export"
+}
+
+if 'bpy' in locals():
+    import importlib
+    importlib.reload(psk_data)
+    importlib.reload(psk_builder)
+    importlib.reload(psk_exporter)
+    importlib.reload(psk_operator)
+    importlib.reload(psa_data)
+    importlib.reload(psa_builder)
+    importlib.reload(psa_exporter)
+    importlib.reload(psa_operator)
+else:
+    # if i remove this line, it can be enabled just fine
+    from .psk import data as psk_data
+    from .psk import builder as psk_builder
+    from .psk import exporter as psk_exporter
+    from .psk import operator as psk_operator
+    from .psa import data as psa_data
+    from .psa import builder as psa_builder
+    from .psa import exporter as psa_exporter
+    from .psa import operator as psa_operator
+
+import bpy
+from bpy.props import IntProperty, CollectionProperty
+
+classes = [
+    psk_operator.PskExportOperator,
+    psa_operator.PsaExportOperator,
+    psa_operator.PSA_UL_ActionList,
+    psa_operator.ActionListItem
+]
+
+
+def psk_menu_func(self, context):
+    self.layout.operator(psk_operator.PskExportOperator.bl_idname, text ='Unreal PSK (.psk)')
+
+
+def psa_menu_func(self, context):
+    self.layout.operator(psa_operator.PsaExportOperator.bl_idname, text='Unreal PSA (.psa)')
+
+
+def register():
+    for cls in classes:
+        bpy.utils.register_class(cls)
+    bpy.types.TOPBAR_MT_file_export.append(psk_menu_func)
+    bpy.types.TOPBAR_MT_file_export.append(psa_menu_func)
+    bpy.types.Scene.psa_action_list = CollectionProperty(type=psa_operator.ActionListItem)
+    bpy.types.Scene.psa_action_list_index = IntProperty(name='index for list??', default=0)
+
+
+def unregister():
+    del bpy.types.Scene.psa_action_list_index
+    del bpy.types.Scene.psa_action_list
+    bpy.types.TOPBAR_MT_file_export.remove(psa_menu_func)
+    bpy.types.TOPBAR_MT_file_export.remove(psk_menu_func)
+    for cls in reversed(classes):
+        bpy.utils.unregister_class(cls)
+
+
+if __name__ == '__main__':
+    register()

io_export_psk_psa/data.py

@@ -0,0 +1,31 @@
+from ctypes import *
+
+
+class Vector3(Structure):
+    _fields_ = [
+        ('x', c_float),
+        ('y', c_float),
+        ('z', c_float),
+    ]
+
+
+class Quaternion(Structure):
+    _fields_ = [
+        ('x', c_float),
+        ('y', c_float),
+        ('z', c_float),
+        ('w', c_float),
+    ]
+
+
+class Section(Structure):
+    _fields_ = [
+        ('name', c_char * 20),
+        ('type_flags', c_int32),
+        ('data_size', c_int32),
+        ('data_count', c_int32)
+    ]
+
+    def __init__(self, *args, **kw):
+        super().__init__(*args, **kw)
+        self.type_flags = 1999801

io_export_psk_psa/psa/builder.py

@@ -0,0 +1,130 @@
+from .data import *
+
+
+class PsaBuilderOptions(object):
+    def __init__(self):
+        self.actions = []
+
+
+# https://git.cth451.me/cth451/blender-addons/blob/master/io_export_unreal_psk_psa.py
+class PsaBuilder(object):
+    def __init__(self):
+        # TODO: add options in here (selected anims, eg.)
+        pass
+
+    def build(self, context, options) -> Psa:
+        object = context.view_layer.objects.active
+
+        if object.type != 'ARMATURE':
+            raise RuntimeError('Selected object must be an Armature')
+
+        armature = object
+
+        if armature.animation_data is None:
+            raise RuntimeError('No animation data for armature')
+
+        psa = Psa()
+
+        bones = list(armature.data.bones)
+
+        # The order of the armature bones and the pose bones is not guaranteed to be the same.
+        # As as a result, we need to reconstruct the list of pose bones in the same order as the
+        # armature bones.
+        bone_names = [x.name for x in bones]
+        pose_bones = [(bone_names.index(bone.name), bone) for bone in armature.pose.bones]
+        pose_bones.sort(key=lambda x: x[0])
+        pose_bones = [x[1] for x in pose_bones]
+
+        for bone in bones:
+            psa_bone = Psa.Bone()
+            psa_bone.name = bytes(bone.name, encoding='utf-8')
+            psa_bone.children_count = len(bone.children)
+
+            try:
+                psa_bone.parent_index = bones.index(bone.parent)
+            except ValueError:
+                psa_bone.parent_index = -1
+
+            if bone.parent is not None:
+                rotation = bone.matrix.to_quaternion()
+                rotation.x = -rotation.x
+                rotation.y = -rotation.y
+                rotation.z = -rotation.z
+                quat_parent = bone.parent.matrix.to_quaternion().inverted()
+                parent_head = quat_parent @ bone.parent.head
+                parent_tail = quat_parent @ bone.parent.tail
+                location = (parent_tail - parent_head) + bone.head
+            else:
+                location = armature.matrix_local @ bone.head
+                rot_matrix = bone.matrix @ armature.matrix_local.to_3x3()
+                rotation = rot_matrix.to_quaternion()
+
+            psa_bone.location.x = location.x
+            psa_bone.location.y = location.y
+            psa_bone.location.z = location.z
+
+            psa_bone.rotation.x = rotation.x
+            psa_bone.rotation.y = rotation.y
+            psa_bone.rotation.z = rotation.z
+            psa_bone.rotation.w = rotation.w
+
+            psa.bones.append(psa_bone)
+
+        frame_start_index = 0
+
+        for action in options.actions:
+            if len(action.fcurves) == 0:
+                continue
+
+            armature.animation_data.action = action
+            context.view_layer.update()
+
+            frame_min, frame_max = [int(x) for x in action.frame_range]
+
+            sequence = Psa.Sequence()
+            sequence.name = bytes(action.name, encoding='utf-8')
+            sequence.frame_count = frame_max - frame_min + 1
+            sequence.frame_start_index = frame_start_index
+            sequence.fps = 30  # TODO: fill in later with r
+
+            frame_count = frame_max - frame_min + 1
+
+            for frame in range(frame_count):
+                context.scene.frame_set(frame)
+
+                for bone in pose_bones:
+                    # TODO: is the cast-to-matrix necessary? (guessing no)
+                    key = Psa.Key()
+                    pose_bone_matrix = bone.matrix
+
+                    if bone.parent is not None:
+                        pose_bone_parent_matrix = bone.parent.matrix
+                        pose_bone_matrix = pose_bone_parent_matrix.inverted() @ pose_bone_matrix
+
+                    location = pose_bone_matrix.to_translation()
+                    rotation = pose_bone_matrix.to_quaternion().normalized()
+
+                    if bone.parent is not None:
+                        rotation.x = -rotation.x
+                        rotation.y = -rotation.y
+                        rotation.z = -rotation.z
+
+                    key.location.x = location.x
+                    key.location.y = location.y
+                    key.location.z = location.z
+                    key.rotation.x = rotation.x
+                    key.rotation.y = rotation.y
+                    key.rotation.z = rotation.z
+                    key.rotation.w = rotation.w
+                    key.time = 1.0 / sequence.fps
+
+                    psa.keys.append(key)
+
+                frame_start_index += 1
+
+                sequence.bone_count = len(pose_bones)
+                sequence.track_time = frame_count
+
+            psa.sequences.append(sequence)
+
+        return psa

io_export_psk_psa/psa/data.py

@@ -0,0 +1,44 @@
+from typing import List
+from ..data import *
+
+
+class Psa(object):
+
+    class Bone(Structure):
+        _fields_ = [
+            ('name', c_char * 64),
+            ('flags', c_int32),
+            ('children_count', c_int32),
+            ('parent_index', c_int32),
+            ('rotation', Quaternion),
+            ('location', Vector3),
+            ('padding', c_char * 16)
+        ]
+
+    class Sequence(Structure):
+        _fields_ = [
+            ('name', c_char * 64),
+            ('group', c_char * 64),
+            ('bone_count', c_int32),
+            ('root_include', c_int32),
+            ('compression_style', c_int32),
+            ('key_quotum', c_int32),  # what the fuck is a quotum
+            ('key_reduction', c_float),
+            ('track_time', c_float),
+            ('fps', c_float),
+            ('start_bone', c_int32),
+            ('frame_start_index', c_int32),
+            ('frame_count', c_int32)
+        ]
+
+    class Key(Structure):
+        _fields_ = [
+            ('location', Vector3),
+            ('rotation', Quaternion),
+            ('time', c_float)
+        ]
+
+    def __init__(self):
+        self.bones: List[Psa.Bone] = []
+        self.sequences: List[Psa.Sequence] = []
+        self.keys: List[Psa.Key] = []

io_export_psk_psa/psa/exporter.py

@@ -0,0 +1,27 @@
+from typing import Type
+from .data import *
+
+
+class PsaExporter(object):
+    def __init__(self, psa: Psa):
+        self.psa: Psa = psa
+
+    # This method is shared by both PSA/K file formats, move this?
+    @staticmethod
+    def write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None):
+        section = Section()
+        section.name = name
+        if data_type is not None and data is not None:
+            section.data_size = sizeof(data_type)
+            section.data_count = len(data)
+        fp.write(section)
+        if data is not None:
+            for datum in data:
+                fp.write(datum)
+
+    def export(self, path: str):
+        with open(path, 'wb') as fp:
+            self.write_section(fp, b'ANIMHEAD')
+            self.write_section(fp, b'BONENAMES', Psa.Bone, self.psa.bones)
+            self.write_section(fp, b'ANIMINFO', Psa.Sequence, self.psa.sequences)
+            self.write_section(fp, b'ANIMKEYS', Psa.Key, self.psa.keys)

io_export_psk_psa/psa/operator.py

@@ -0,0 +1,104 @@
+from bpy.types import Operator, Action, UIList, PropertyGroup
+from bpy_extras.io_utils import ExportHelper
+from bpy.props import StringProperty, BoolProperty, CollectionProperty, PointerProperty
+from .builder import PsaBuilder, PsaBuilderOptions
+from .exporter import PsaExporter
+import bpy
+import re
+
+
+class ActionListItem(PropertyGroup):
+    action: PointerProperty(type=Action)
+    is_selected: BoolProperty(default=False)
+
+    @property
+    def name(self):
+        return self.action.name
+
+
+class PSA_UL_ActionList(UIList):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
+        layout.alignment = 'LEFT'
+        layout.prop(item, 'is_selected', icon_only=True)
+        layout.label(text=item.action.name)
+
+    def filter_items(self, context, data, property):
+        # TODO: returns two lists, apparently
+        actions = getattr(data, property)
+        flt_flags = []
+        flt_neworder = []
+        if self.filter_name:
+            flt_flags = bpy.types.UI_UL_list.filter_items_by_name(self.filter_name, self.bitflag_filter_item, actions, 'name', reverse=self.use_filter_invert)
+        return flt_flags, flt_neworder
+
+
+class PsaExportOperator(Operator, ExportHelper):
+    bl_idname = 'export.psa'
+    bl_label = 'Export'
+    __doc__ = 'PSA Exporter (.psa)'
+    filename_ext = '.psa'
+    filter_glob : StringProperty(default='*.psa', options={'HIDDEN'})
+    filepath : StringProperty(
+        name='File Path',
+        description='File path used for exporting the PSA file',
+        maxlen=1024,
+        default='')
+
+    def __init__(self):
+        self.armature = None
+
+    def draw(self, context):
+        layout = self.layout
+        scene = context.scene
+        box = layout.box()
+        box.label(text='Actions', icon='ACTION')
+        row = box.row()
+        row.template_list('PSA_UL_ActionList', 'asd', scene, 'psa_action_list', scene, 'psa_action_list_index', rows=len(context.scene.psa_action_list))
+
+    def is_action_for_armature(self, action):
+        bone_names = [x.name for x in self.armature.data.bones]
+        print(bone_names)
+        for fcurve in action.fcurves:
+            match = re.match('pose\.bones\["(.+)"\].\w+', fcurve.data_path)
+            if not match:
+                continue
+            bone_name = match.group(1)
+            if bone_name not in bone_names:
+                return False
+        return True
+
+    def invoke(self, context, event):
+        if context.view_layer.objects.active.type != 'ARMATURE':
+            self.report({'ERROR_INVALID_CONTEXT'}, 'The selected object must be an armature.')
+            return {'CANCELLED'}
+
+        self.armature = context.view_layer.objects.active
+
+        context.scene.psa_action_list.clear()
+        for action in bpy.data.actions:
+            item = context.scene.psa_action_list.add()
+            item.action = action
+            if self.is_action_for_armature(action):
+                item.is_selected = True
+
+        if len(context.scene.psa_action_list) == 0:
+            self.report({'ERROR_INVALID_CONTEXT'}, 'There are no actions to export.')
+            return {'CANCELLED'}
+
+        context.window_manager.fileselect_add(self)
+        return {'RUNNING_MODAL'}
+
+    def execute(self, context):
+        actions = [x.action for x in context.scene.psa_action_list if x.is_selected]
+
+        if len(actions) == 0:
+            self.report({'ERROR_INVALID_CONTEXT'}, 'No actions were selected for export.')
+            return {'CANCELLED'}
+
+        options = PsaBuilderOptions()
+        options.actions = actions
+        builder = PsaBuilder()
+        psk = builder.build(context, options)
+        exporter = PsaExporter(psk)
+        exporter.export(self.filepath)
+        return {'FINISHED'}

io_export_psk_psa/psk/builder.py

@@ -0,0 +1,158 @@
+import bpy
+import bmesh
+from .data import *
+
+
+class PskBuilder(object):
+    def __init__(self):
+        # TODO: add options in here
+        pass
+
+    def build(self, context) -> Psk:
+        object = context.view_layer.objects.active
+
+        if object.type != 'MESH':
+            raise RuntimeError('Selected object must be a mesh')
+
+        if len(object.data.materials) == 0:
+            raise RuntimeError('Mesh must have at least one material')
+
+        # ensure that there is exactly one armature modifier
+        modifiers = [x for x in object.modifiers if x.type == 'ARMATURE']
+
+        if len(modifiers) != 1:
+            raise RuntimeError('Mesh must have one armature modifier')
+
+        armature_modifier = modifiers[0]
+        armature_object = armature_modifier.object
+
+        if armature_object is None:
+            raise RuntimeError('Armature modifier has no linked object')
+
+        # TODO: probably requires at least one bone? not sure
+        mesh_data = object.data
+
+        # TODO: if there is an edge-split modifier, we need to apply it (maybe?)
+
+        # TODO: duplicate all the data
+        mesh = bpy.data.meshes.new('export')
+
+        # copy the contents of the mesh
+        bm = bmesh.new()
+        bm.from_mesh(mesh_data)
+        bmesh.ops.triangulate(bm, faces=bm.faces)
+        bm.to_mesh(mesh)
+        bm.free()
+        del bm
+
+        psk = Psk()
+
+        # VERTICES
+        for vertex in object.data.vertices:
+            point = Vector3()
+            point.x = vertex.co.x
+            point.y = vertex.co.y
+            point.z = vertex.co.z
+            psk.points.append(point)
+
+        # WEDGES
+        uv_layer = object.data.uv_layers.active.data
+        if len(object.data.loops) <= 65536:
+            wedge_type = Psk.Wedge16
+        else:
+            wedge_type = Psk.Wedge32
+        psk.wedges = [wedge_type() for _ in range(len(object.data.loops))]
+
+        for loop_index, loop in enumerate(object.data.loops):
+            wedge = psk.wedges[loop_index]
+            wedge.material_index = 0
+            wedge.point_index = loop.vertex_index
+            wedge.u, wedge.v = uv_layer[loop_index].uv
+            wedge.v = 1.0 - wedge.v
+            psk.wedges.append(wedge)
+
+        # MATERIALS
+        for i, m in enumerate(object.data.materials):
+            if m is None:
+                raise RuntimeError('Material cannot be empty (index ' + str(i) + ')')
+            material = Psk.Material()
+            material.name = bytes(m.name, encoding='utf-8')
+            material.texture_index = i
+            psk.materials.append(material)
+
+        # FACES
+        # TODO: this is making the assumption that the mesh is triangulated
+        object.data.calc_loop_triangles()
+        poly_groups, groups = object.data.calc_smooth_groups(use_bitflags=True)
+        for f in object.data.loop_triangles:
+            face = Psk.Face()
+            face.material_index = f.material_index
+            face.wedge_index_1 = f.loops[2]
+            face.wedge_index_2 = f.loops[1]
+            face.wedge_index_3 = f.loops[0]
+            face.smoothing_groups = poly_groups[f.polygon_index]
+            psk.faces.append(face)
+            # update the material index of the wedges
+            for i in range(3):
+                psk.wedges[f.loops[i]].material_index = f.material_index
+
+        # https://github.com/bwrsandman/blender-addons/blob/master/io_export_unreal_psk_psa.py
+        bones = list(armature_object.data.bones)
+        for bone in bones:
+            psk_bone = Psk.Bone()
+            psk_bone.name = bytes(bone.name, encoding='utf-8')
+            psk_bone.flags = 0
+            psk_bone.children_count = len(bone.children)
+
+            try:
+                psk_bone.parent_index = bones.index(bone.parent)
+            except ValueError:
+                psk_bone.parent_index = 0
+
+            if bone.parent is not None:
+                rotation = bone.matrix.to_quaternion()
+                rotation.x = -rotation.x
+                rotation.y = -rotation.y
+                rotation.z = -rotation.z
+                quat_parent = bone.parent.matrix.to_quaternion().inverted()
+                parent_head = quat_parent @ bone.parent.head
+                parent_tail = quat_parent @ bone.parent.tail
+                location = (parent_tail - parent_head) + bone.head
+            else:
+                location = armature_object.matrix_local @ bone.head
+                rot_matrix = bone.matrix @ armature_object.matrix_local.to_3x3()
+                rotation = rot_matrix.to_quaternion()
+
+            psk_bone.location.x = location.x
+            psk_bone.location.y = location.y
+            psk_bone.location.z = location.z
+
+            psk_bone.rotation.x = rotation.x
+            psk_bone.rotation.y = rotation.y
+            psk_bone.rotation.z = rotation.z
+            psk_bone.rotation.w = rotation.w
+
+            psk.bones.append(psk_bone)
+
+        # WEIGHTS
+        # TODO: bone ~> vg might not be 1:1, provide a nice error message if this is the case
+        armature = armature_object.data
+        bone_names = [x.name for x in armature.bones]
+        vertex_group_names = [x.name for x in object.vertex_groups]
+        bone_indices = [bone_names.index(name) for name in vertex_group_names]
+        for vertex_group_index, vertex_group in enumerate(object.vertex_groups):
+            bone_index = bone_indices[vertex_group_index]
+            for vertex_index in range(len(object.data.vertices)):
+                try:
+                    weight = vertex_group.weight(vertex_index)
+                except RuntimeError:
+                    continue
+                if weight == 0.0:
+                    continue
+                w = Psk.Weight()
+                w.bone_index = bone_index
+                w.point_index = vertex_index
+                w.weight = weight
+                psk.weights.append(w)
+
+        return psk

io_export_psk_psa/psk/data.py

@@ -0,0 +1,72 @@
+from typing import List
+from ..data import *
+
+
+class Psk(object):
+
+    class Wedge16(Structure):
+        _fields_ = [
+            ('point_index', c_int16),
+            ('padding1', c_int16),
+            ('u', c_float),
+            ('v', c_float),
+            ('material_index', c_int8),
+            ('reserved', c_int8),
+            ('padding2', c_int16)
+        ]
+
+    class Wedge32(Structure):
+        _fields_ = [
+            ('point_index', c_int32),
+            ('u', c_float),
+            ('v', c_float),
+            ('material_index', c_int32)
+        ]
+
+    class Face(Structure):
+        _fields_ = [
+            ('wedge_index_1', c_int16),
+            ('wedge_index_2', c_int16),
+            ('wedge_index_3', c_int16),
+            ('material_index', c_int8),
+            ('aux_material_index', c_int8),
+            ('smoothing_groups', c_int32)
+        ]
+
+    class Material(Structure):
+        _fields_ = [
+            ('name', c_char * 64),
+            ('texture_index', c_int32),
+            ('poly_flags', c_int32),
+            ('aux_material', c_int32),
+            ('aux_flags', c_int32),
+            ('lod_bias', c_int32),
+            ('lod_style', c_int32)
+        ]
+
+    class Bone(Structure):
+        _fields_ = [
+            ('name', c_char * 64),
+            ('flags', c_int32),
+            ('children_count', c_int32),
+            ('parent_index', c_int32),
+            ('rotation', Quaternion),
+            ('location', Vector3),
+            ('length', c_float),
+            ('size', Vector3)
+        ]
+
+    class Weight(Structure):
+        _fields_ = [
+            ('weight', c_float),
+            ('point_index', c_int32),
+            ('bone_index', c_int32),
+        ]
+
+    def __init__(self):
+        self.points: List[Vector3] = []
+        self.wedges: List[Psk.Wedge16] = []
+        self.faces: List[Psk.Face] = []
+        self.materials: List[Psk.Material] = []
+        self.weights: List[Psk.Weight] = []
+        self.bones: List[Psk.Bone] = []

io_export_psk_psa/psk/exporter.py

@@ -0,0 +1,38 @@
+from typing import Type
+from .data import *
+
+
+class PskExporter(object):
+    def __init__(self, psk: Psk):
+        self.psk: Psk = psk
+
+    @staticmethod
+    def write_section(fp, name: bytes, data_type: Type[Structure] = None, data: list = None):
+        section = Section()
+        section.name = name
+        if data_type is not None and data is not None:
+            section.data_size = sizeof(data_type)
+            section.data_count = len(data)
+        fp.write(section)
+        if data is not None:
+            for datum in data:
+                fp.write(datum)
+
+    def export(self, path: str):
+        # TODO: add logic somewhere to assert lengths of ctype structs
+        with open(path, 'wb') as fp:
+            self.write_section(fp, b'ACTRHEAD')
+            self.write_section(fp, b'PNTS0000', Vector3, self.psk.points)
+
+            # WEDGES
+            # TODO: this really should be on the level of the builder, not the exporter
+            if len(self.psk.wedges) <= 65536:
+                wedge_type = Psk.Wedge16
+            else:
+                wedge_type = Psk.Wedge32
+
+            self.write_section(fp, b'VTXW0000', wedge_type, self.psk.wedges)
+            self.write_section(fp, b'FACE0000', Psk.Face, self.psk.faces)
+            self.write_section(fp, b'MATT0000', Psk.Material, self.psk.materials)
+            self.write_section(fp, b'REFSKELT', Psk.Bone, self.psk.bones)
+            self.write_section(fp, b'RAWWEIGHTS', Psk.Weight, self.psk.weights)

io_export_psk_psa/psk/operator.py

@@ -0,0 +1,26 @@
+from bpy.types import Operator
+from bpy_extras.io_utils import ExportHelper
+from bpy.props import StringProperty, BoolProperty, FloatProperty
+from .builder import PskBuilder
+from .exporter import PskExporter
+
+
+class PskExportOperator(Operator, ExportHelper):
+    bl_idname = 'export.psk'
+    bl_label = 'Export'
+    __doc__ = 'PSK Exporter (.psk)'
+    filename_ext = '.psk'
+    filter_glob: StringProperty(default='*.psk', options={'HIDDEN'})
+
+    filepath: StringProperty(
+        name='File Path',
+        description='File path used for exporting the PSK file',
+        maxlen=1024,
+        default='')
+
+    def execute(self, context):
+        builder = PskBuilder()
+        psk = builder.build(context)
+        exporter = PskExporter(psk)
+        exporter.export(self.filepath)
+        return {'FINISHED'}