Renamed src folder to io_export_psk_psa

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'}