Merge branch 'feature-multiple-meshes'

io_export_psk_psa/psa/operator.py

@@ -58,15 +58,15 @@ class PsaExportOperator(Operator, ExportHelper):
     def is_action_for_armature(self, action):
         if len(action.fcurves) == 0:
             return False
-        bone_names = [x.name for x in self.armature.data.bones]
+        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:
+            if bone_name in bone_names:
-                return False
+                return True
-        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,107 +1,67 @@
 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
 
-    def build(self, context) -> Psk:
+    @staticmethod
-        object = context.view_layer.objects.active
+    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')
 
-        if object.type != 'MESH':
+        input_objects.mesh_objects = context.view_layer.objects.selected
-            raise RuntimeError('Selected object must be a mesh')
 
-        if len(object.data.materials) == 0:
+        if len(input_objects.mesh_objects) == 0:
-            raise RuntimeError('Mesh must have at least one material')
+            raise RuntimeError('At least one mesh must be selected')
 
-        # ensure that there is exactly one armature modifier
+        for obj in input_objects.mesh_objects:
-        modifiers = [x for x in object.modifiers if x.type == 'ARMATURE']
+            if len(obj.data.materials) == 0:
+                raise RuntimeError(f'Mesh "{obj.name}" must have at least one material')
 
-        if len(modifiers) != 1:
+        # ensure that there is exactly one armature modifier object shared between all selected meshes
-            raise RuntimeError('Mesh must have one armature modifier')
+        armature_modifier_objects = set()
 
-        armature_modifier = modifiers[0]
+        for obj in input_objects.mesh_objects:
-        armature_object = armature_modifier.object
+            modifiers = [x for x in obj.modifiers if x.type == 'ARMATURE']
+            if len(modifiers) != 1:
+                raise RuntimeError(f'Mesh "{obj.name}" must have one armature modifier')
+            armature_modifier_objects.add(modifiers[0].object)
 
-        if object.modifiers[-1] != armature_modifier:
+        if len(armature_modifier_objects) > 1:
-            raise RuntimeError('Armature modifier must be the last modifier in the stack')
+            raise RuntimeError('All selected meshes must have the same armature modifier')
 
-        if armature_object is None:
+        input_objects.armature_object = list(armature_modifier_objects)[0]
+
+        if input_objects.armature_object is None:
             raise RuntimeError('Armature modifier has no linked object')
 
-        # TODO: probably requires at least one bone? not sure
+        return input_objects
-        mesh_data = object.data
 
-        # TODO: if there is an edge-split modifier, we need to apply it (maybe?)
+    def build(self, context) -> Psk:
-
+        input_objects = PskBuilder.get_input_objects(context)
-        # TODO: duplicate all the data
+        wedge_count = sum([len(m.data.loops) for m in input_objects.mesh_objects])
-        mesh = bpy.data.meshes.new('export')
+        if wedge_count <= 65536:
-
-        # 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):
+        psk = Psk()
-            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
+        materials = OrderedDict()
-        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
+        bones = list(input_objects.armature_object.data.bones)
-        # 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
-        # TODO: maybe we should use the EDIT bones instead???
-        bones = list(armature_object.data.bones)
         for bone in bones:
             psk_bone = Psk.Bone()
             psk_bone.name = bytes(bone.name, encoding='utf-8')
@@ -123,8 +83,8 @@ class PskBuilder(object):
                 parent_tail = quat_parent @ bone.parent.tail
                 location = (parent_tail - parent_head) + bone.head
             else:
-                location = armature_object.matrix_local @ bone.head
+                location = input_objects.armature_object.matrix_local @ bone.head
-                rot_matrix = bone.matrix @ armature_object.matrix_local.to_3x3()
+                rot_matrix = bone.matrix @ input_objects.armature_object.matrix_local.to_3x3()
                 rotation = rot_matrix.to_quaternion()
 
             psk_bone.location.x = location.x
@@ -138,25 +98,89 @@ class PskBuilder(object):
 
             psk.bones.append(psk_bone)
 
-        # WEIGHTS
+        vertex_offset = 0
-        # TODO: bone ~> vg might not be 1:1, provide a nice error message if this is the case
+        wedge_offset = 0
-        armature = armature_object.data
+        weight_offset = 0
-        bone_names = [x.name for x in armature.bones]
+
-        vertex_group_names = [x.name for x in object.vertex_groups]
+        # TODO: if there is an edge-split modifier, we need to apply it (maybe?)
-        bone_indices = [bone_names.index(name) for name in vertex_group_names]
+        for object in input_objects.mesh_objects:
-        for vertex_group_index, vertex_group in enumerate(object.vertex_groups):
+            # VERTICES
-            bone_index = bone_indices[vertex_group_index]
+            for vertex in object.data.vertices:
-            for vertex_index in range(len(object.data.vertices)):
+                point = Vector3()
-                try:
+                v = object.matrix_world @ vertex.co
-                    weight = vertex_group.weight(vertex_index)
+                point.x = v.x
-                except RuntimeError:
+                point.y = v.y
-                    continue
+                point.z = v.z
-                if weight == 0.0:
+                psk.points.append(point)
-                    continue
+
-                w = Psk.Weight()
+            # WEDGES
-                w.bone_index = bone_index
+            uv_layer = object.data.uv_layers.active.data
-                w.point_index = vertex_index
+            # needs to be additive!!!
-                w.weight = weight
+            psk.wedges.extend([wedge_type() for _ in range(len(object.data.loops))])
-                psk.weights.append(w)
+
+            for loop_index, loop in enumerate(object.data.loops):
+                wedge = psk.wedges[wedge_offset + loop_index]
+                wedge.material_index = 0  # NOTE: this material index is set properly while building the faces
+                wedge.point_index = loop.vertex_index + vertex_offset
+                wedge.u, wedge.v = uv_layer[loop_index].uv
+                wedge.v = 1.0 - wedge.v
+                psk.wedges.append(wedge)
+
+            # 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)
+
+            # 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 = material_indices[f.material_index]
+                face.wedge_index_1 = f.loops[2] + wedge_offset
+                face.wedge_index_2 = f.loops[1] + wedge_offset
+                face.wedge_index_3 = f.loops[0] + wedge_offset
+                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[wedge_offset + f.loops[i]].material_index = face.material_index
+
+            # WEIGHTS
+            # TODO: bone ~> vg might not be 1:1, provide a nice error message if this is the case
+            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)
+            wedge_offset += len(psk.wedges)
+            weight_offset += len(psk.weights)
 
         return psk

io_export_psk_psa/psk/operator.py

@@ -19,32 +19,10 @@ class PskExportOperator(Operator, ExportHelper):
         default='')
 
     def invoke(self, context, event):
-        object = context.view_layer.objects.active
+        try:
-
+            PskBuilder.get_input_objects(context)
-        if object.type != 'MESH':
+        except RuntimeError as e:
-            self.report({'ERROR_INVALID_CONTEXT'}, 'The selected object must be a mesh.')
+            self.report({'ERROR_INVALID_CONTEXT'}, str(e))
-            return {'CANCELLED'}
-
-        if len(object.data.materials) == 0:
-            self.report({'ERROR_INVALID_CONTEXT'}, 'Mesh must have at least one material')
-            return {'CANCELLED'}
-
-        # ensure that there is exactly one armature modifier
-        modifiers = [x for x in object.modifiers if x.type == 'ARMATURE']
-
-        if len(modifiers) != 1:
-            self.report({'ERROR_INVALID_CONTEXT'}, 'Mesh must have one armature modifier')
-            return {'CANCELLED'}
-
-        armature_modifier = modifiers[0]
-        armature_object = armature_modifier.object
-
-        if object.modifiers[-1] != armature_modifier:
-            self.report({'ERROR_INVALID_CONTEXT'}, 'Armature modifier must be the last modifier in the stack')
-            return {'CANCELLED'}
-
-        if armature_object is None:
-            self.report({'ERROR_INVALID_CONTEXT'}, 'Armature modifier has no linked object')
             return {'CANCELLED'}
 
         context.window_manager.fileselect_add(self)