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(s):",smoothcount," Flat Count(s):",flatcount)
                bselected = True
                break
        if bselected:
            print("Selected Face(s) Exectue!")
            self.report({'INFO'}, "Selected Face(s) Exectue!")
        else:
            print("Didn't select Mesh Object!")
            self.report({'INFO'}, "Didn't Select Mesh Object!")
        print("----------------------------------------")        
        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):
        print("----------------------------------------")
        print("Init Rebuild Armature...")
        bselected = False
        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()
                bselected = True
                break
        if bselected:
            self.report({'INFO'}, "Rebuild Armature Finish!")
        else:
            self.report({'INFO'}, "Didn't Select Armature Object!")
        print("End of Rebuild Armature.")
        print("----------------------------------------")
        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__ = """It rebuild the mesh from scrape from the selected mesh object."""
    
    def invoke(self, context, event):
        print("----------------------------------------")
        print("Init Mesh Bebuild...")
        bselected = False
        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')
                me_ob = bpy.data.meshes.new(("Re_"+obj.name))
                mesh = obj.data
                faces = []
                verts = []
                smoothings = []
                uvfaces = []
                #print(dir(mesh))
                print("creating array build mesh...")
                uv_layer = mesh.uv_textures.active
                for face in mesh.faces:
                    v = []
                    smoothings.append(face.use_smooth)#smooth or flat in boolean
                    if uv_layer != None:#check if there texture data exist
                        faceUV = uv_layer.data[face.index]
                        #print(len(faceUV.uv))
                        uvs = []
                        for uv in faceUV.uv:
                            #vert = mesh.vertices[videx]
                            #print("UV:",uv[0],":",uv[1])
                            uvs.append((uv[0],uv[1]))
                        #print(uvs)
                        uvfaces.append(uvs)
                    for videx in face.vertices:
                        vert = mesh.vertices[videx]
                        v.append(videx)
                    faces.append(v)                    
                #vertex positions
                for vertex in mesh.vertices:
                    verts.append(vertex.co.to_tuple())				
                #vertices weight groups into array
                vertGroups = {} #array in strings
                for vgroup in obj.vertex_groups:
                    #print(dir(vgroup))
                    #print("name:",(vgroup.name),"index:",vgroup.index)
                    #vertex in index and weight
                    vlist = []
                    for v in mesh.vertices:
                        for vg in v.groups:
                            if vg.group == vgroup.index:
                                vlist.append((v.index,vg.weight))
                                #print((v.index,vg.weight))
                    vertGroups[vgroup.name] = vlist					
                '''
				#Fail for this method
				#can't covert the tri face plogyon
                for face in mesh.faces:
                    x = [f for f in face.vertices]
                    faces.extend(x)
                    smoothings.append(face.use_smooth)
                for vertex in mesh.vertices:
                    verts.append(vertex.co.to_tuple())
                me_ob.vertices.add(len(verts))
                me_ob.faces.add(len(faces)//4)
                me_ob.vertices.foreach_set("co", unpack_list(verts))
                me_ob.faces.foreach_set("vertices_raw", faces)
                me_ob.faces.foreach_set("use_smooth", smoothings)
                '''
                #test dummy mesh
                #verts = [(-1,1,0),(1,1,0),(1,-1,0),(-1,-1,0),(0,1,1),(0,-1,1)]
                #faces = [(0,1,2,3),(1,2,5,4),(0,3,5,4),(0,1,4),(2,3,5)]
                #for f in faces:
                    #print("face",f)
                #for v in verts:
                    #print("vertex",v)
                #me_ob = bpy.data.objects.new("ReBuildMesh",me_ob)
                print("creating mesh object...")
                me_ob.from_pydata(verts, [], faces)
                me_ob.faces.foreach_set("use_smooth", smoothings)#smooth array from face
                me_ob.update()
                #check if there is uv faces
                if len(uvfaces) > 0:
                    uvtex = me_ob.uv_textures.new(name="retex")
                    for i, face in enumerate(me_ob.faces):
                        blender_tface = uvtex.data[i] #face
                        mfaceuv = uvfaces[i]
                        if len(mfaceuv) == 3:
                            blender_tface.uv1 = mfaceuv[0];
                            blender_tface.uv2 = mfaceuv[1];
                            blender_tface.uv3 = mfaceuv[2];
                        if len(mfaceuv) == 4:
                            blender_tface.uv1 = mfaceuv[0];
                            blender_tface.uv2 = mfaceuv[1];
                            blender_tface.uv3 = mfaceuv[2];
                            blender_tface.uv4 = mfaceuv[3];
                
                obmesh = bpy.data.objects.new(("Re_"+obj.name),me_ob)
                bpy.context.scene.update()
                #Build tmp materials
                materialname = "ReMaterial"
                for matcount in mesh.materials:
                    matdata = bpy.data.materials.new(materialname)
                    me_ob.materials.append(matdata)
                #assign face to material id
                for face in mesh.faces:
                    #print(dir(face))
                    me_ob.faces[face.index].material_index = face.material_index
                #vertices weight groups
                for vgroup in vertGroups:
                    #print("vgroup",vgroup)#name of group
                    #print(dir(vgroup))
                    #print(vertGroups[vgroup])
                    group = obmesh.vertex_groups.new(vgroup)
                    #print("group index",group.index)
                    for v in vertGroups[vgroup]:
                        group.add([v[0]], v[1], 'ADD')# group.add(array[vertex id],weight,add)
                        #print("[vertex id, weight]",v) #array (0,0)
                        #print("[vertex id, weight]",v[0],":",v[1]) #array (0,0)
                bpy.context.scene.objects.link(obmesh)
                print("Mesh Material Count:",len(me_ob.materials))
                for mat in me_ob.materials:
                    print("-Material:",mat.name)
                print("Object Name:",obmesh.name)
                bpy.context.scene.update()
                #bpy.ops.wm.console_toggle()
                bselected = True
                break
        if bselected:
            self.report({'INFO'}, "Rebuild Mesh Finish!")
            print("Finish Mesh Build...")
        else:
            self.report({'INFO'}, "Didn't Select Mesh Object!")
            print("Didn't Select Mesh Object!")
        print("----------------------------------------")
        
        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()