io_export_unreal_psk_psa.py

                    else:
                        flatcount += 1
                        face.select = False
                    #print("selected:",face.select)
                    #print(("smooth:",face.use_smooth))
                bpy.context.scene.update()
                bpy.ops.object.mode_set(mode='EDIT')
                print("Select Smooth Count:",smoothcount," Flat Count:",flatcount)
				
                break
        #objects = bpy.data.objects
        print("Selected faces exectue!")        
        return{'FINISHED'}
		
class OBJECT_OT_UTRebuildArmature(bpy.types.Operator):
    bl_idname = "object.utrebuildarmature"  # XXX, name???
    bl_label = "Rebuild Armature"
    __doc__ = "If mesh is deform when importing to unreal engine try this. It rebuild the bones one at the time by select one armature object scrape to raw setup build."
    
    def invoke(self, context, event):
        
        for obj in bpy.data.objects:
            if obj.type == 'ARMATURE' and obj.select == True:
                currentbone = [] #select armature for roll copy
                print("Armature Name:",obj.name)
                objectname = "ArmatureDataPSK"
                meshname ="ArmatureObjectPSK"
                armdata = bpy.data.armatures.new(objectname)
                ob_new = bpy.data.objects.new(meshname, armdata)
                bpy.context.scene.objects.link(ob_new)
                bpy.ops.object.mode_set(mode='OBJECT')
                for i in bpy.context.scene.objects: i.select = False #deselect all objects
                ob_new.select = True
                bpy.context.scene.objects.active = obj
                
                bpy.ops.object.mode_set(mode='EDIT')
                for bone in obj.data.edit_bones:
                    if bone.parent != None:
                        currentbone.append([bone.name,bone.roll])
                    else:
                        currentbone.append([bone.name,bone.roll])
                bpy.ops.object.mode_set(mode='OBJECT')
                for i in bpy.context.scene.objects: i.select = False #deselect all objects
                bpy.context.scene.objects.active = ob_new
                bpy.ops.object.mode_set(mode='EDIT')
                
                for bone in obj.data.bones:
                    bpy.ops.object.mode_set(mode='EDIT')
                    newbone = ob_new.data.edit_bones.new(bone.name)
                    newbone.head = bone.head_local
                    newbone.tail = bone.tail_local
                    for bonelist in currentbone:
                        if bone.name == bonelist[0]:
                            newbone.roll = bonelist[1]
                            break
                    if bone.parent != None:
                        parentbone = ob_new.data.edit_bones[bone.parent.name]
                        newbone.parent = parentbone
                print("Bone Count:",len(obj.data.bones))
                print("Hold Bone Count",len(currentbone))
                print("New Bone Count",len(ob_new.data.edit_bones))
                print("Rebuild Armture Finish:",ob_new.name)
                bpy.context.scene.update()
                break
        self.report({'INFO'}, "Rebuild Armature Finish!")
        return{'FINISHED'}
		
# rounded the vert locations to save a bit of blurb.. change the round value or remove for accuracy i suppose
def rounded_tuple(tup):
    return tuple(round(value,4) for value in tup)
	
def unpack_list(list_of_tuples):
    l = []
    for t in list_of_tuples:
        l.extend(t)
    return l
	
class OBJECT_OT_UTRebuildMesh(bpy.types.Operator):
    bl_idname = "object.utrebuildmesh"  # XXX, name???
    bl_label = "Rebuild Mesh"
    __doc__ = "Work In Progress. Support only Quad faces. It rebuild the mesh from scrape from the selected mesh."
    
    def invoke(self, context, event):
        #print("Init Export Script:")
        for obj in bpy.data.objects:
            if obj.type == 'MESH' and obj.select == True:
                for i in bpy.context.scene.objects: i.select = False #deselect all objects
                obj.select = True
                bpy.context.scene.objects.active = obj
                bpy.ops.object.mode_set(mode='OBJECT')
				
                #bpy.ops.object.mode_set(mode='EDIT')
                mesh = obj.data
                faces = []
                verts = []
                smoothings = []
                facecount  = 0
                for face in mesh.faces:
                    facecount += 1
                    x = [f for f in face.vertices]
                    faces.extend(x)
                    #print(dir(face))
                    smoothings.append(face.use_smooth)
                    
                #print("faces",len(faces),"face count:",facecount,"Covert:",len(faces)//4)
                    #print(x)
                
                for vertex in mesh.vertices:
                    #verts.extend([(vertex.co[0],vertex.co[1],vertex.co[2])])
                    verts.append(vertex.co.to_tuple())
                #print("Face/Vertex Array")
                me_ob = bpy.data.meshes.new("ReBuildMesh")
                me_ob.vertices.add(len(verts))
                #print("Vertex Count:",len(verts))
                #for face in faces:
                    #print("------")
                    #print(face)
                me_ob.faces.add(len(faces)//4)
                #print(facecount)
                #me_ob.faces.add(facecount - 3)
                #print("Face Count:",len(faces)//4)
                me_ob.vertices.foreach_set("co", unpack_list(verts))
                #me_ob.vertices.foreach_set("co", verts)
                me_ob.faces.foreach_set("vertices_raw", faces)
                me_ob.faces.foreach_set("use_smooth", smoothings)
                me_ob.update_tag()
                me_ob.update()
                obmesh = bpy.data.objects.new("ReBuildMesh",me_ob)
                bpy.context.scene.objects.link(obmesh)
                print("Object Name:",obmesh.name)
                bpy.context.scene.update()
                break
        print("Finish Mesh Build...")
        self.report({'INFO'}, "Rebuild Mesh Finish!")
        return{'FINISHED'}
		
def menu_func(self, context):
    #bpy.context.scene.unrealexportpsk = True
    #bpy.context.scene.unrealexportpsa = True
    default_path = os.path.splitext(bpy.data.filepath)[0] + ".psk"
    self.layout.operator(ExportUDKAnimData.bl_idname, text="Skeleton Mesh / Animation Data (.psk/.psa)").filepath = default_path

def register():
    bpy.utils.register_module(__name__)
    bpy.types.INFO_MT_file_export.append(menu_func)

def unregister():
    bpy.utils.unregister_module(__name__)
    bpy.types.INFO_MT_file_export.remove(menu_func)

if __name__ == "__main__":
    register()