Fix for accidental check-in of bugged animation code in previous commit

This reverts commit e29f9e16dd.

README.md

@@ -1,3 +1,29 @@
-# io_export_psk_psa
+This Blender add-on allows you to export meshes and animations to the [PSK and PSA file formats](https://wiki.beyondunreal.com/PSK_%26_PSA_file_formats).
 
-If you are looking for a PSK/PSA importer, use [this one](https://github.com/Befzz/blender3d_import_psk_psa)!
+# Installation
+1. Download the zip file for the latest version from the [releases](https://github.com/DarklightGames/io_export_psk_psa/releases) page.
+2. Open Blender 2.80 or later.
+3. Navigate to the Blender Preferences (Edit > Preferences).
+4. Select the "Add-ons" tab.
+5. Click the "Install..." button.
+6. Select the .zip file that you downloaded earlier and click "Install Add-on".
+7. Enable the newly added "Import-Export: PSK/PSA Exporter" addon.
+
+# Usage
+## Exporting a PSK
+1. Select the mesh objects you wish to export.
+3. Navigate to File > Export > Unreal PSK (.psk)
+4. Enter the file name and click "Export".
+
+## Exporting a PSA
+1. Select the armature objects you wish to export.
+2. Navigate to File > Export > Unreal PSA (.psa)
+3. Enter the file name and click "Export".
+
+# FAQ
+## Can I use this addon to import PSK and PSA files?
+Currently, no.
+
+Presumably you are using this in concert with the [UE Viewer](https://www.gildor.org/en/projects/umodel) program to import extracted meshes. It is *not recommended* to export PSK/PSA from UE Viewer since it [does not preserve smoothing groups](https://github.com/gildor2/UEViewer/issues/235). As a result, the shading of imported models will be incorrect and will need to be manually fixed. Instead, it is recommended to export meshes to the glTF format for import into Blender since it preserves the correct mesh shading.
+
+Regardless, if you are dead set on using a PSK/PSA importer, use [this one](https://github.com/Befzz/blender3d_import_psk_psa).

io_export_psk_psa/__init__.py

@@ -1,8 +1,8 @@
 bl_info = {
     "name": "PSK/PSA Exporter",
     "author": "Colin Basnett",
-    "version": ( 1, 0, 0 ),
-    "blender": ( 2, 80, 0 ),
+    "version": (1, 1, 1),
+    "blender": (2, 80, 0),
     "location": "File > Export > PSK Export (.psk)",
     "description": "PSK/PSA Export (.psk)",
     "warning": "",

io_export_psk_psa/psa/builder.py

@@ -85,15 +85,14 @@ class PsaBuilder(object):
             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
+            sequence.fps = context.scene.render.fps
 
             frame_count = frame_max - frame_min + 1
 
             for frame in range(frame_count):
-                context.scene.frame_set(frame)
+                context.scene.frame_set(frame_min + frame)
 
                 for bone in pose_bones:
-                    # TODO: is the cast-to-matrix necessary? (guessing no)
                     key = Psa.Key()
                     pose_bone_matrix = bone.matrix
 

io_export_psk_psa/psa/operator.py

@@ -56,16 +56,17 @@ class PsaExportOperator(Operator, ExportHelper):
         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)
+        if len(action.fcurves) == 0:
+            return False
+        bone_names = set([x.name for x in self.armature.data.bones])
         for fcurve in action.fcurves:
-            match = re.match('pose\.bones\["(.+)"\].\w+', fcurve.data_path)
+            match = re.match(r'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
+            if bone_name in bone_names:
+                return True
+        return False
 
     def invoke(self, context, event):
         if context.view_layer.objects.active.type != 'ARMATURE':

io_export_psk_psa/psk/builder.py

@@ -1,158 +1,203 @@
 import bpy
 import bmesh
+from collections import OrderedDict
 from .data import *
 
+# https://github.com/bwrsandman/blender-addons/blob/master/io_export_unreal_psk_psa.py
+
+class PskInputObjects(object):
+    def __init__(self):
+        self.mesh_objects = []
+        self.armature_object = None
+
 
 class PskBuilder(object):
     def __init__(self):
-        # TODO: add options in here
         pass
 
+    @staticmethod
+    def get_input_objects(context) -> PskInputObjects:
+        input_objects = PskInputObjects()
+        for obj in context.view_layer.objects.selected:
+            if obj.type != 'MESH':
+                raise RuntimeError(f'Selected object "{obj.name}" is not a mesh')
+
+        input_objects.mesh_objects = context.view_layer.objects.selected
+
+        if len(input_objects.mesh_objects) == 0:
+            raise RuntimeError('At least one mesh must be selected')
+
+        for obj in input_objects.mesh_objects:
+            if len(obj.data.materials) == 0:
+                raise RuntimeError(f'Mesh "{obj.name}" must have at least one material')
+
+        # Ensure that there are either no armature modifiers (static mesh)
+        # or that there is exactly one armature modifier object shared between
+        # all selected meshes
+        armature_modifier_objects = set()
+
+        for obj in input_objects.mesh_objects:
+            modifiers = [x for x in obj.modifiers if x.type == 'ARMATURE']
+            if len(modifiers) == 0:
+                continue
+            elif len(modifiers) == 2:
+                raise RuntimeError(f'Mesh "{obj.name}" must have only one armature modifier')
+            armature_modifier_objects.add(modifiers[0].object)
+
+        if len(armature_modifier_objects) > 1:
+            raise RuntimeError('All selected meshes must have the same armature modifier')
+        elif len(armature_modifier_objects) == 1:
+            input_objects.armature_object = list(armature_modifier_objects)[0]
+
+        return input_objects
+
     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
+        input_objects = PskBuilder.get_input_objects(context)
 
         psk = Psk()
+        materials = OrderedDict()
 
-        # 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:
+        if input_objects.armature_object is None:
+            # Static mesh (no armature)
             psk_bone = Psk.Bone()
-            psk_bone.name = bytes(bone.name, encoding='utf-8')
+            psk_bone.name = bytes('static', 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_bone.children_count = 0
+            psk_bone.parent_index = 0
+            psk_bone.location = Vector3(0, 0, 0)
+            psk_bone.rotation = Quaternion(0, 0, 0, 1)
             psk.bones.append(psk_bone)
+        else:
+            bones = list(input_objects.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)
 
-        # 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)
+                    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 = input_objects.armature_object.matrix_local @ bone.head
+                    rot_matrix = bone.matrix @ input_objects.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)
+
+        vertex_offset = 0
+
+        for object in input_objects.mesh_objects:
+            # VERTICES
+            for vertex in object.data.vertices:
+                point = Vector3()
+                v = object.matrix_world @ vertex.co
+                point.x = v.x
+                point.y = v.y
+                point.z = v.z
+                psk.points.append(point)
+
+            uv_layer = object.data.uv_layers.active.data
+
+            # MATERIALS
+            material_indices = []
+            for i, m in enumerate(object.data.materials):
+                if m is None:
+                    raise RuntimeError('Material cannot be empty (index ' + str(i) + ')')
+                if m.name in materials:
+                    material_index = list(materials.keys()).index(m.name)
+                else:
+                    material = Psk.Material()
+                    material.name = bytes(m.name, encoding='utf-8')
+                    material.texture_index = len(psk.materials)
+                    psk.materials.append(material)
+                    materials[m.name] = m
+                    material_index = material.texture_index
+                material_indices.append(material_index)
+
+            # WEDGES
+            object.data.calc_loop_triangles()
+
+            # Build a list of non-unique wedges.
+            wedges = []
+            for loop_index, loop in enumerate(object.data.loops):
+                wedge = Psk.Wedge()
+                wedge.point_index = loop.vertex_index + vertex_offset
+                wedge.u, wedge.v = uv_layer[loop_index].uv
+                wedge.v = 1.0 - wedge.v
+                wedges.append(wedge)
+
+            # Assign material indices to the wedges.
+            for triangle in object.data.loop_triangles:
+                for loop_index in triangle.loops:
+                    wedges[loop_index].material_index = material_indices[triangle.material_index]
+
+            # Populate the list of wedges with unique wedges & build a look-up table of loop indices to wedge indices
+            wedge_indices = {}
+            loop_wedge_indices = [-1] * len(object.data.loops)
+            for loop_index, wedge in enumerate(wedges):
+                wedge_hash = hash(wedge)
+                if wedge_hash in wedge_indices:
+                    loop_wedge_indices[loop_index] = wedge_indices[wedge_hash]
+                else:
+                    wedge_index = len(psk.wedges)
+                    wedge_indices[wedge_hash] = wedge_index
+                    psk.wedges.append(wedge)
+                    loop_wedge_indices[loop_index] = wedge_index
+
+            # FACES
+            poly_groups, groups = object.data.calc_smooth_groups(use_bitflags=True)
+            for f in object.data.loop_triangles:
+                face = Psk.Face()
+                face.material_index = material_indices[f.material_index]
+                face.wedge_indices[0] = loop_wedge_indices[f.loops[2]]
+                face.wedge_indices[1] = loop_wedge_indices[f.loops[1]]
+                face.wedge_indices[2] = loop_wedge_indices[f.loops[0]]
+                face.smoothing_groups = poly_groups[f.polygon_index]
+                psk.faces.append(face)
+
+            # WEIGHTS
+            # TODO: bone ~> vg might not be 1:1, provide a nice error message if this is the case
+            if input_objects.armature_object is not None:
+                armature = input_objects.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_offset + vertex_index
+                        w.weight = weight
+                        psk.weights.append(w)
+
+            vertex_offset = len(psk.points)
 
         return psk

io_export_psk_psa/psk/data.py

@@ -4,30 +4,38 @@ from ..data import *
 
 class Psk(object):
 
+    class Wedge(object):
+        def __init__(self):
+            self.point_index: int = 0
+            self.u: float = 0.0
+            self.v: float = 0.0
+            self.material_index: int = 0
+
+        def __hash__(self):
+            return hash(f'{self.point_index}-{self.u}-{self.v}-{self.material_index}')
+
     class Wedge16(Structure):
         _fields_ = [
-            ('point_index', c_int16),
+            ('point_index', c_uint16),
             ('padding1', c_int16),
             ('u', c_float),
             ('v', c_float),
-            ('material_index', c_int8),
+            ('material_index', c_uint8),
             ('reserved', c_int8),
             ('padding2', c_int16)
         ]
 
     class Wedge32(Structure):
         _fields_ = [
-            ('point_index', c_int32),
+            ('point_index', c_uint32),
             ('u', c_float),
             ('v', c_float),
-            ('material_index', c_int32)
+            ('material_index', c_uint32)
         ]
 
     class Face(Structure):
         _fields_ = [
-            ('wedge_index_1', c_int16),
-            ('wedge_index_2', c_int16),
-            ('wedge_index_3', c_int16),
+            ('wedge_indices', c_uint16 * 3),
             ('material_index', c_int8),
             ('aux_material_index', c_int8),
             ('smoothing_groups', c_int32)
@@ -65,7 +73,7 @@ class Psk(object):
 
     def __init__(self):
         self.points: List[Vector3] = []
-        self.wedges: List[Psk.Wedge16] = []
+        self.wedges: List[Psk.Wedge] = []
         self.faces: List[Psk.Face] = []
         self.materials: List[Psk.Material] = []
         self.weights: List[Psk.Weight] = []

io_export_psk_psa/psk/exporter.py

@@ -19,19 +19,26 @@ class PskExporter(object):
                 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)
+            wedges = []
+            for index, w in enumerate(self.psk.wedges):
+                wedge = wedge_type()
+                wedge.material_index = w.material_index
+                wedge.u = w.u
+                wedge.v = w.v
+                wedge.point_index = w.point_index
+                wedges.append(wedge)
+
+            self.write_section(fp, b'VTXW0000', wedge_type, 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)

io_export_psk_psa/psk/operator.py

@@ -18,6 +18,16 @@ class PskExportOperator(Operator, ExportHelper):
         maxlen=1024,
         default='')
 
+    def invoke(self, context, event):
+        try:
+            PskBuilder.get_input_objects(context)
+        except RuntimeError as e:
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
+            return {'CANCELLED'}
+
+        context.window_manager.fileselect_add(self)
+        return {'RUNNING_MODAL'}
+
     def execute(self, context):
         builder = PskBuilder()
         psk = builder.build(context)