io_export_unreal_psk_psa.py

                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_MeshClearWeights(bpy.types.Operator):
    """Remove all mesh vertex groups weights for the bones."""
    bl_idname = "object.meshclearweights"  # XXX, name???
    bl_label = "Remove Vertex Weights"#"Remove Mesh vertex weights"
    
    def invoke(self, context, event):
        for obj in bpy.data.objects:
            if obj.type == 'MESH' and obj.select == True:
                for vg in obj.vertex_groups:
                    obj.vertex_groups.remove(vg)
                self.report({'INFO'}, "Mesh Vertex Groups Remove!")
                break           
        return{'FINISHED'}

def unpack_list(list_of_tuples):
    l = []
    for t in list_of_tuples:
        l.extend(t)
    return l

def rebuildmesh(obj):
    #make sure it in object mode
    print("Mesh Object Name:",obj.name)
    bpy.ops.object.mode_set(mode='OBJECT')
    for i in bpy.context.scene.objects: i.select = False #deselect all objects
    obj.select = True
    bpy.context.scene.objects.active = obj
    
    me_ob = bpy.data.meshes.new(("Re_"+obj.name))
    mesh = obj.data
    faces = []
    verts = []
    smoothings = []
    uvfaces = []
    #print("creating array build mesh...")
    mmesh = obj.to_mesh(bpy.context.scene,True,'PREVIEW')
    uv_layer = mmesh.tessface_uv_textures.active
    for face in mmesh.tessfaces:
        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]
            uvs = []
            for uv in faceUV.uv:
                uvs.append((uv[0],uv[1]))
            uvfaces.append(uvs)
        #print((face.vertices[:]))
        if len(face.vertices) == 3:
            faces.extend([(face.vertices[0],face.vertices[1],face.vertices[2],0)])
        else:
            faces.extend([(face.vertices[0],face.vertices[1],face.vertices[2],face.vertices[3])])
    #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:
        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
    
    #print("creating mesh object...")
    #me_ob.from_pydata(verts, [], faces)
    me_ob.vertices.add(len(verts))
    me_ob.tessfaces.add(len(faces))
    me_ob.vertices.foreach_set("co", unpack_list(verts)) 
    me_ob.tessfaces.foreach_set("vertices_raw",unpack_list( faces))
    me_ob.tessfaces.foreach_set("use_smooth", smoothings)#smooth array from face
    
    #check if there is uv faces
    if len(uvfaces) > 0:
        uvtex = me_ob.tessface_uv_textures.new(name="retex")
        for i, face in enumerate(me_ob.tessfaces):
            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];
    
    me_ob.update()#need to update the information to able to see into the secne
    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.tessfaces:
        me_ob.faces[face.index].material_index = face.material_index
    #vertices weight groups
    for vgroup in vertGroups:
        group = obmesh.vertex_groups.new(vgroup)
        for v in vertGroups[vgroup]:
            group.add([v[0]], v[1], 'ADD')# group.add(array[vertex id],weight,add)
    bpy.context.scene.objects.link(obmesh)
    #print("Mesh Material Count:",len(me_ob.materials))
    matcount = 0
    #print("MATERIAL ID OREDER:")
    for mat in me_ob.materials:
        #print("-Material:",mat.name,"INDEX:",matcount)
        matcount += 1
    print("Mesh Object Name:",obmesh.name)
    bpy.context.scene.update()
    return obmesh

class OBJECT_OT_UTRebuildMesh(bpy.types.Operator):
    """It rebuild the mesh from scrape from the selected mesh object. """ \
    """Note the scale will be 1:1 for object mode. To keep from deforming"""
    bl_idname = "object.utrebuildmesh"  # XXX, name???
    bl_label = "Rebuild Mesh"#"Rebuild Mesh"
    
    def invoke(self, context, event):
        print("----------------------------------------")
        print("Init Mesh Bebuild...")
        bselected = False
        bpy.ops.object.mode_set(mode='OBJECT')
        for obj in bpy.data.objects:
            if obj.type == 'MESH' and obj.select == True:
                rebuildmesh(obj)
        self.report({'INFO'}, "Rebuild Mesh Finish!")
        print("Finish Mesh Build...")
        print("----------------------------------------")
        return{'FINISHED'}

def rebuildarmature(obj):
    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

    ob_new.animation_data_create()#create animation data
    if obj.animation_data != None:#check for animation
        ob_new.animation_data.action  = obj.animation_data.action  #just make sure it here to do the animations if exist
    print("Armature Object Name:",ob_new.name)
    return ob_new
        
class OBJECT_OT_UTRebuildArmature(bpy.types.Operator):
    """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. """ \
    """Note the scale will be 1:1 for object mode. To keep from deforming"""
    bl_idname = "object.utrebuildarmature"  # XXX, name???
    bl_label = "Rebuild Armature" #Rebuild Armature
    
    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:
                rebuildarmature(obj)
        self.report({'INFO'}, "Rebuild Armature Finish!")
        print("End of Rebuild Armature.")
        print("----------------------------------------")
        return{'FINISHED'}

class UDKActionSetListPG(bpy.types.PropertyGroup):
    bool    = BoolProperty(default=False)
    string  = StringProperty()
    actionname  = StringProperty()
    bmatch    = BoolProperty(default=False,name="Match", options={"HIDDEN"},description = "This check against bone names and action group names matches and override boolean if true.")
    bexport    = BoolProperty(default=False,name="Export",description = "Check this to export the animation")

bpy.utils.register_class(UDKActionSetListPG)
bpy.types.Scene.udkas_list = CollectionProperty(type=UDKActionSetListPG)
bpy.types.Scene.udkas_list_idx = IntProperty()

class UL_UDKActionSetList(bpy.types.UIList):
    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
        layout.label(item.name)
        layout.prop(item, "bmatch", text="Match")
        layout.prop(item, "bexport", text="Export")

class UDKObjListPG(bpy.types.PropertyGroup):
    bool    = BoolProperty(default=False)
    string  = StringProperty()
    bexport    = BoolProperty(default=False,name="Export", options={"HIDDEN"},description = "This will be ignore when exported")
    bselect    = BoolProperty(default=False,name="Select", options={"HIDDEN"},description = "This will be ignore when exported")
    otype  = StringProperty(name="Type",description = "This will be ignore when exported")

bpy.utils.register_class(UDKObjListPG)
bpy.types.Scene.udkobj_list = CollectionProperty(type=UDKObjListPG)
bpy.types.Scene.udkobj_list_idx = IntProperty()

class UL_UDKObjList(bpy.types.UIList):
    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
        layout.label(item.name)
        layout.prop(item, "otype", text="")
        layout.prop(item, "bselect", text="")

class UDKMeshListPG(bpy.types.PropertyGroup):
    bool    = BoolProperty(default=False)
    string  = StringProperty()
    bexport    = BoolProperty(default=False,name="Export", options={"HIDDEN"},description = "This object will be export when true.")
    bselect    = BoolProperty(default=False,name="Select", options={"HIDDEN"},description = "Make sure you have Mesh is parent to Armature.")
    otype  = StringProperty(name="Type",description = "This will be ignore when exported")

bpy.utils.register_class(UDKMeshListPG)
bpy.types.Scene.udkmesh_list = CollectionProperty(type=UDKMeshListPG)
bpy.types.Scene.udkmesh_list_idx = IntProperty()

class UL_UDKMeshList(bpy.types.UIList):
    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
        layout.label(item.name)
        #layout.prop(item, "bselect", text="Select")
        layout.prop(item, "bexport", text="Export")

class UDKArmListPG(bpy.types.PropertyGroup):
    bool    = BoolProperty(default=False)
    string  = StringProperty()
    bexport    = BoolProperty(default=False,name="Export", options={"HIDDEN"},description = "This will be ignore when exported")
    bselect    = BoolProperty(default=False,name="Select", options={"HIDDEN"},description = "This will be ignore when exported")
    otype  = StringProperty(name="Type",description = "This will be ignore when exported")

bpy.utils.register_class(UDKArmListPG)
bpy.types.Scene.udkArm_list = CollectionProperty(type=UDKArmListPG)
bpy.types.Scene.udkArm_list_idx = IntProperty()

class UL_UDKArmList(bpy.types.UIList):
    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
        layout.label(item.name)

class Panel_UDKExport( bpy.types.Panel ):

    bl_label        = "UDK Export"
    bl_idname       = "OBJECT_PT_udk_tools"
    #bl_space_type  = "PROPERTIES"
    #bl_region_type = "WINDOW"
    #bl_context     = "object"
    bl_space_type   = "VIEW_3D"
    bl_region_type  = "TOOLS"
    
    #def draw_header(self, context):
    #   layout = self.layout
        #obj = context.object
        #layout.prop(obj, "select", text="")
    
    #@classmethod
    #def poll(cls, context):
    #   return context.active_object

    def draw(self, context):
        layout = self.layout
        path = get_dst_path()

        object_name = ""
        #if context.object:
        #   object_name = context.object.name
        if context.active_object:
            object_name = context.active_object.name
        row10 = layout.row()
        row10.prop(context.scene, "udk_option_smoothing_groups")
        row10.prop(context.scene, "udk_option_clamp_uv")
        row10.prop(context.scene, "udk_option_verbose")
        row = layout.row()
        row.label(text="Active object: " + object_name)
        #layout.separator()
        layout.prop(context.scene, "udk_option_filename_src")
        row = layout.row()
        row.label(text=path)
        #layout.separator()
        layout.prop(context.scene, "udk_option_export")
        layout.prop(context.scene, "udk_option_selectobjects")
        
        if context.scene.udk_option_selectobjects:
            layout.operator("object.selobjectpdate")
            layout.label(text="ARMATURE - Index")
            layout.template_list("UL_UDKArmList", "udk_armatures", context.scene, "udkArm_list",
                                 context.scene, "udkArm_list_idx", rows=3)
            layout.label(text="MESH - Export")
            layout.template_list("UL_UDKMeshList", "", context.scene, "udkmesh_list",
                                 context.scene, "udkmesh_list_idx", rows=5)
        layout.prop(context.scene, "udk_option_selectanimations")
        if context.scene.udk_option_selectanimations:
            layout.operator("action.setanimupdate")
            layout.label(text="Action Set(s) - Match / Export")
            layout.template_list("UL_UDKActionSetList", "", context.scene, "udkas_list",
                                 context.scene, "udkas_list_idx", rows=5)
        test = layout.separator()
        layout.prop(context.scene, "udk_option_scale")
        layout.prop(context.scene, "udk_option_rebuildobjects")
        #layout.prop(context.scene, "udk_option_ignoreactiongroupnames")
        row11 = layout.row()
        row11.operator("object.udk_export")
        row11.operator("object.toggle_console")
        layout.operator(OBJECT_OT_UTRebuildArmature.bl_idname)
        layout.label(text="Mesh")        
        layout.operator(OBJECT_OT_MeshClearWeights.bl_idname)
        layout.operator(OBJECT_OT_UTSelectedFaceSmooth.bl_idname)
        layout.operator(OBJECT_OT_UTRebuildMesh.bl_idname)
        layout.operator(OBJECT_OT_UDKCheckMeshLines.bl_idname)

def udkupdateobjects():
        my_objlist = bpy.context.scene.udkArm_list
        objectl = []
        for objarm in bpy.context.scene.objects:#list and filter only mesh and armature
            if objarm.type == 'ARMATURE':
                objectl.append(objarm)
        for _objd in objectl:#check if list has in udk list
            bfound_obj = False
            for _obj in my_objlist:
                if _obj.name == _objd.name and _obj.otype == _objd.type:
                    _obj.bselect = _objd.select
                    bfound_obj = True
                    break
            if bfound_obj == False:
                #print("ADD ARMATURE...")
                my_item = my_objlist.add()
                my_item.name = _objd.name
                my_item.bselect = _objd.select
                my_item.otype = _objd.type
        removeobject = []
        for _udkobj in my_objlist:
            bfound_objv = False
            for _objd in bpy.context.scene.objects: #check if there no existing object from sense to remove it
                if _udkobj.name == _objd.name and _udkobj.otype == _objd.type:
                    bfound_objv = True
                    break
            if bfound_objv == False:
                removeobject.append(_udkobj)
        #print("remove check...")
        for _item in removeobject: #loop remove object from udk list object
            count = 0
            for _obj in my_objlist:
                if _obj.name == _item.name and _obj.otype == _item.otype:
                    my_objlist.remove(count)
                    break
                count += 1
                
        my_objlist = bpy.context.scene.udkmesh_list
        objectl = []
        for objarm in bpy.context.scene.objects:#list and filter only mesh and armature
            if objarm.type == 'MESH':
                objectl.append(objarm)
        for _objd in objectl:#check if list has in udk list
            bfound_obj = False
            for _obj in my_objlist:
                if _obj.name == _objd.name and _obj.otype == _objd.type:
                    _obj.bselect = _objd.select
                    bfound_obj = True
                    break
            if bfound_obj == False:
                my_item = my_objlist.add()
                my_item.name = _objd.name
                my_item.bselect = _objd.select
                my_item.otype = _objd.type
        removeobject = []
        for _udkobj in my_objlist:
            bfound_objv = False
            for _objd in bpy.context.scene.objects: #check if there no existing object from sense to remove it
                if _udkobj.name == _objd.name and _udkobj.otype == _objd.type:
                    bfound_objv = True
                    break
            if bfound_objv == False:
                removeobject.append(_udkobj)
        #print("remove check...")
        for _item in removeobject: #loop remove object from udk list object
            count = 0
            for _obj in my_objlist:
                if _obj.name == _item.name and _obj.otype == _item.otype:
                    my_objlist.remove(count)
                    break
                count += 1
                
class OBJECT_OT_UDKObjUpdate(bpy.types.Operator):
    """This will update the filter of the mesh and armature."""
    bl_idname = "object.selobjectpdate"
    bl_label = "Update Object(s)"
    
    actionname = bpy.props.StringProperty()
 
    def execute(self, context):
        udkupdateobjects()
        return{'FINISHED'}

def udkcheckmeshline():
    objmesh = None
    for obj in bpy.context.scene.objects:
        if obj.type == 'MESH' and obj.select == True:
            objmesh = obj
    objmesh = triangulate_mesh(objmesh) #create a copy of the mesh
    bpy.ops.object.mode_set(mode='OBJECT')
    for i in bpy.context.scene.objects: i.select = False # deselect all objects
    objmesh.select = True
    bpy.context.scene.objects.active = objmesh #set active mesh
    wedges          = ObjMap()
    points          = ObjMap()
    bpy.ops.object.mode_set(mode='EDIT') #set in edit mode
    bpy.ops.mesh.select_all(action='DESELECT')
    bpy.context.tool_settings.mesh_select_mode = (True, False, False) #select vertices
        
    if objmesh != None:
        print("found mesh")
        print(objmesh)
        print(objmesh.data.tessfaces)
        vertex_list = []
        for face in objmesh.data.tessfaces:
            wedge_list  = []
            vect_list   = []
            for i in range(3):
                vert_index  = face.vertices[i]
                vert        = objmesh.data.vertices[vert_index]
                vect_list.append( FVector(vert.co.x, vert.co.y, vert.co.z) )
                vpos = objmesh.matrix_local * vert.co
                p               = VPoint()
                p.Point.X       = vpos.x
                p.Point.Y       = vpos.y
                p.Point.Z       = vpos.z
                w               = VVertex()
                w.PointIndex    = points.get(p) # store keys
                index_wedge = wedges.get(w)
                wedge_list.append(index_wedge)
            no = face.normal
            norm = FVector(no[0], no[1], no[2])
            tnorm = vect_list[1].sub(vect_list[0]).cross(vect_list[2].sub(vect_list[1]))
            dot = norm.dot(tnorm)
            
            tri = VTriangle()
            if dot > 0:
                (tri.WedgeIndex2, tri.WedgeIndex1, tri.WedgeIndex0) = wedge_list
            elif dot < 0:
                (tri.WedgeIndex0, tri.WedgeIndex1, tri.WedgeIndex2) = wedge_list
            else:
                dindex0 = face.vertices[0];
                dindex1 = face.vertices[1];
                dindex2 = face.vertices[2];
                vertex_list.append(dindex0)
                vertex_list.append(dindex1)
                vertex_list.append(dindex2)
        
        bpy.ops.object.mode_set(mode='OBJECT')
        for vertex in objmesh.data.vertices: #loop all vertex in the mesh list
            for vl in vertex_list: #loop for error vertex
                if vertex.index == vl: #if match set to select
                    vertex.select = True
                    break
        bpy.ops.object.mode_set(mode='EDIT') #set in edit mode to see the select vertex
        objmesh.data.update() # update object
        bpy.context.scene.update() #update scene
        message = "MESH PASS"
        if len(vertex_list) > 0:
            message = "MESH FAIL"
    return message

class OBJECT_OT_UDKCheckMeshLines(bpy.types.Operator):
    """Select the mesh for export test. This will create dummy mesh to see which area are broken. """ \
    """If the vertices share the same position it will causes an bug."""
    bl_idname = "object.udkcheckmeshline"
    bl_label = "Check Mesh Vertices"
 
    def execute(self, context):
        message = udkcheckmeshline()
        self.report({'ERROR'}, message)
        return{'FINISHED'}

class OBJECT_OT_ActionSetAnimUpdate(bpy.types.Operator):
    """Select Armture to match the action set groups. """ \
    """All bones keys must be set to match with number of bones."""
    bl_idname = "action.setanimupdate"
    bl_label = "Update Action Set(s)"

    actionname = bpy.props.StringProperty()
 
    def execute(self, context):
        my_sett = bpy.context.scene.udkas_list
        
        bones = []
        armature = None
        armatures = []
        armatureselected = []
        for objarm in bpy.context.scene.objects:
            if objarm.type == 'ARMATURE':
                #print("ADDED ARMATURE...")
                armatures.append(objarm)
                if objarm.select == True:
                    armatureselected.append(objarm)
                
        if len(armatureselected) == len(armatures) == 1:
            armature = armatures[0]
        if len(armatures) == 1:
            armature = armatures[0]
        if len(armatureselected) == 1:      
            armature = armatureselected[0]
            
        if armature != None:
            for bone in armature.pose.bones:
                bones.append(bone.name)

        for action in bpy.data.actions:#action list
            bfound = False
            count = 0
            for actionbone in action.groups:
                #print("Pose bone name: ",actionbone.name)
                for b in bones:
                    if b == actionbone.name:
                        count += 1
                        #print(b," : ",actionbone.name)
                        break
            for actionlist in my_sett:
                if action.name == actionlist.name:
                    bactionfound = True
                    if len(bones) == len(action.groups) == count:
                        actionlist.bmatch = True
                    else:
                        actionlist.bmatch = False
                    bfound = True
                    break
            if bfound != True:
                my_item = my_sett.add()
                #print(dir(my_item.bmatch))
                my_item.name = action.name
                #my_item.template_list_controls = "bmatch:bexport"
                if len(bones) == len(action.groups) == count:
                    my_item.bmatch = True
                else:
                    my_item.bmatch = False
        removeactions = []  
        #check action list and data actions
        for actionlist in bpy.context.scene.udkas_list:
            bfind = False
            notfound = 0
            for act in bpy.data.actions:
                if actionlist.name == act.name:
                    bfind = True
                else:
                    notfound += 1
            #print("ACT NAME:",actionlist.name," COUNT",notfound)
            if notfound == len(bpy.data.actions):
                #print("remove :",actionlist.name)
                removeactions.append(actionlist.name)   
        #print("Not in the action data list:",len(removeactions))
        #remove list or chnages in the name the template list
        for actname in removeactions:
            actioncount = 0
            for actionlist in my_sett:
                #print("action name:",actionlist.name)
                if actionlist.name == actname:
                    my_sett.remove(actioncount);
                    break
                actioncount += 1
        return{'FINISHED'}      
        
class ExportUDKAnimData(bpy.types.Operator):
    """Export Skeleton Mesh / Animation Data file(s). """ \
    """One mesh and one armature else select one mesh or armature to be exported"""
    bl_idname = "export_anim.udk" # this is important since its how bpy.ops.export.udk_anim_data is constructed
    bl_label = "Export PSK/PSA"

    # List of operator properties, the attributes will be assigned
    # to the class instance from the operator settings before calling.

    filepath = StringProperty(
            subtype='FILE_PATH',
            )
    filter_glob = StringProperty(
            default="*.psk;*.psa",
            options={'HIDDEN'},
            )
    udk_option_smoothing_groups = bpy.types.Scene.udk_option_smoothing_groups
    udk_option_clamp_uv = bpy.types.Scene.udk_option_clamp_uv
    udk_option_verbose = bpy.types.Scene.udk_option_verbose
    udk_option_filename_src = bpy.types.Scene.udk_option_filename_src
    udk_option_export = bpy.types.Scene.udk_option_export
    udk_option_scale = bpy.types.Scene.udk_option_scale
    udk_option_rebuildobjects = bpy.types.Scene.udk_option_rebuildobjects
    
    @classmethod
    def poll(cls, context):
        return context.active_object != None

    def execute(self, context):
        scene = bpy.context.scene
        scene.udk_option_export_psk = (scene.udk_option_export == '0' or scene.udk_option_export == '2')
        scene.udk_option_export_psa = (scene.udk_option_export == '1' or scene.udk_option_export == '2')
        bpy.context.scene.udk_option_scale = self.udk_option_scale
        bpy.context.scene.udk_option_rebuildobjects = self.udk_option_rebuildobjects
            
        filepath = get_dst_path()
        
        # cache settings
        restore_frame = scene.frame_current
        
        message = "Finish Export!"
        try:
            export(filepath)

        except Error as err:
            print(err.message)
            message = err.message
        
        # restore settings
        scene.frame_set(restore_frame)
        
        self.report({'WARNING', 'INFO'}, message)
        return {'FINISHED'}
        
    def invoke(self, context, event):
        wm = context.window_manager
        wm.fileselect_add(self)
        return {'RUNNING_MODAL'}
        
def menu_func(self, context):
    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

#===========================================================================
# Entry
#===========================================================================
def register():
    #print("REGISTER")
    bpy.utils.register_module(__name__)
    bpy.types.INFO_MT_file_export.append(menu_func)
    
def unregister():
    #print("UNREGISTER")
    bpy.utils.unregister_module(__name__)
    bpy.types.INFO_MT_file_export.remove(menu_func)
        
if __name__ == "__main__":
    #print("\n"*4)
    print(header("UDK Export PSK/PSA 2.6", 'CENTER'))
    register()
    
#loader
#filename = "D:/Projects/BlenderScripts/io_export_udk_psa_psk_alpha.py"
#exec(compile(open(filename).read(), filename, 'exec'))