changed file name and update credits as the bones are working a bit.

2 files changed, 1089 insertions, 804 deletions

diff --git a/io_import_scene_unreal_psa_psk.py b/io_import_scene_unreal_psa_psk.py
new file mode 100644
index 00000000..f7805768
--- /dev/null
+++ b/io_import_scene_unreal_psa_psk.py
@@ -0,0 +1,1089 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+bl_info = {
+    "name": "Import Unreal Skeleton Mesh (.psk)/Animation Set (psa)",
+    "author": "Darknet, flufy3d, camg188",
+    "version": (2, 1),
+    "blender": (2, 6, 4),
+    "location": "File > Import > Skeleton Mesh (.psk)/Animation Set (psa)",
+    "description": "Import Skeleleton Mesh/Animation Data",
+    "warning": "",
+    "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.5/Py/"
+        "Scripts/Import-Export/Unreal_psk_psa",
+    "tracker_url": "https://projects.blender.org/tracker/index.php?"\
+        "func=detail&aid=21366",
+    "category": "Import-Export"}
+
+"""
+Version': '2.0' ported by Darknet
+
+Unreal Tournament PSK file to Blender mesh converter V1.0
+Author: D.M. Sturgeon (camg188 at the elYsium forum), ported by Darknet
+Imports a *psk file to a new mesh
+
+-No UV Texutre
+-No Weight
+-No Armature Bones
+-No Material ID
+-Export Text Log From Current Location File (Bool )
+"""
+
+import bpy
+import mathutils
+import math
+from mathutils import *
+from math import *
+from bpy.props import *
+from string import *
+from struct import *
+from math import *
+from bpy.props import *
+
+bpy.types.Scene.unrealbonesize = FloatProperty(
+    name="Bone Length",
+    description="Bone Length from head to tail distance",
+    default=1,min=0.001,max=1000)
+
+#output log in to txt file
+DEBUGLOG = False
+
+scale = 1.0
+bonesize = 1.0
+from bpy_extras.io_utils import unpack_list, unpack_face_list
+
+class md5_bone:
+    bone_index=0
+    name=""
+    bindpos=[]
+    bindmat=[]
+    origmat=[]
+    head=[]
+    tail=[]
+    scale = []
+    parent=""
+    parent_index=0
+    blenderbone=None
+    roll=0
+
+    def __init__(self):
+        self.bone_index=0
+        self.name=""
+        self.bindpos=[0.0]*3
+        self.scale=[0.0]*3
+        self.head=[0.0]*3
+        self.tail=[0.0]*3
+        self.bindmat=[None]*3  #is this how you initilize a 2d-array
+        for i in range(3): self.bindmat[i] = [0.0]*3
+        self.origmat=[None]*3  #is this how you initilize a 2d-array
+        for i in range(3): self.origmat[i] = [0.0]*3
+        self.parent=""
+        self.parent_index=0
+        self.blenderbone=None
+
+    def dump(self):
+        print ("bone index: ", self.bone_index)
+        print ("name: ", self.name)
+        print ("bind position: ", self.bindpos)
+        print ("bind translation matrix: ", self.bindmat)
+        print ("parent: ", self.parent)
+        print ("parent index: ", self.parent_index)
+        print ("blenderbone: ", self.blenderbone)
+        
+def getheadpos(pbone,bones):
+    pos_head = [0.0]*3
+
+    #pos = mathutils.Vector((x,y,z)) * pbone.origmat
+    pos = pbone.bindmat.to_translation()
+    
+    """
+    tmp_bone = pbone
+    while tmp_bone.name != tmp_bone.parent.name:
+        pos = pos * tmp_bone.parent.bindmat
+        tmp_bone = tmp_bone.parent
+    """
+    
+    pos_head[0] = pos.x
+    pos_head[1] = pos.y
+    pos_head[2] = pos.z
+    
+    return pos_head
+def gettailpos(pbone,bones):
+    pos_tail = [0.0]*3
+    ischildfound = False
+    childbone = None
+    childbonelist = []
+    for bone in bones:
+        if bone.parent.name == pbone.name:
+            ischildfound = True
+            childbone = bone
+            childbonelist.append(bone)
+            
+    if ischildfound:
+        tmp_head = [0.0]*3
+        for bone in childbonelist:
+            tmp_head[0] += bone.head[0]
+            tmp_head[1] += bone.head[1]
+            tmp_head[2] += bone.head[2]
+        tmp_head[0] /= len(childbonelist)
+        tmp_head[1] /= len(childbonelist)
+        tmp_head[2] /= len(childbonelist)
+        return tmp_head
+    else:
+        tmp_len = 0.0
+        tmp_len += (pbone.head[0] - pbone.parent.head[0])**2
+        tmp_len += (pbone.head[1] - pbone.parent.head[1])**2
+        tmp_len += (pbone.head[2] - pbone.parent.head[2])**2
+        tmp_len = tmp_len**0.5 * 0.5
+        pos_tail[0] = pbone.head[0] + tmp_len * pbone.bindmat[0][0]
+        pos_tail[1] = pbone.head[1] + tmp_len * pbone.bindmat[1][0]
+        pos_tail[2] = pbone.head[2] + tmp_len * pbone.bindmat[2][0]
+
+        
+    return pos_tail
+
+        
+        
+def pskimport(infile,importmesh,importbone,bDebugLogPSK,importmultiuvtextures):
+    global DEBUGLOG
+    DEBUGLOG = bDebugLogPSK
+    print ("--------------------------------------------------")
+    print ("---------SCRIPT EXECUTING PYTHON IMPORTER---------")
+    print ("--------------------------------------------------")
+    print (" DEBUG Log:",bDebugLogPSK)
+    print ("Importing file: ", infile)
+    
+    pskfile = open(infile,'rb')
+    if (DEBUGLOG):
+        logpath = infile.replace(".psk", ".txt")
+        print("logpath:",logpath)
+        logf = open(logpath,'w')
+        
+    def printlog(strdata):
+        if (DEBUGLOG):
+            logf.write(strdata)
+    
+    objName = infile.split('\\')[-1].split('.')[0]
+    
+    me_ob = bpy.data.meshes.new(objName)
+    print("objName:",objName)
+    printlog(("New Mesh = " + me_ob.name + "\n"))
+    #read general header
+    indata = unpack('20s3i',pskfile.read(32))
+    #not using the general header at this time
+    #================================================================================================== 
+    # vertex point
+    #================================================================================================== 
+    #read the PNTS0000 header
+    indata = unpack('20s3i',pskfile.read(32))
+    recCount = indata[3]
+    printlog(( "Nbr of PNTS0000 records: " + str(recCount) + "\n"))
+    counter = 0
+    verts = []
+    verts2 = []
+    while counter < recCount:
+        counter = counter + 1
+        indata = unpack('3f',pskfile.read(12))
+        #print(indata[0],indata[1],indata[2])
+        verts.extend([(indata[0],indata[1],indata[2])])
+        verts2.extend([(indata[0],indata[1],indata[2])])
+        #print([(indata[0],indata[1],indata[2])])
+        printlog(str(indata[0]) + "|" +str(indata[1]) + "|" +str(indata[2]) + "\n")
+        #Tmsh.vertices.append(NMesh.Vert(indata[0],indata[1],indata[2]))
+        
+    #================================================================================================== 
+    # UV
+    #================================================================================================== 
+    #read the VTXW0000 header
+    indata = unpack('20s3i',pskfile.read(32))
+    recCount = indata[3]
+    printlog( "Nbr of VTXW0000 records: " + str(recCount)+ "\n")
+    counter = 0
+    UVCoords = []
+    #UVCoords record format = [index to PNTS, U coord, v coord]
+    printlog("[index to PNTS, U coord, v coord]\n");
+    while counter < recCount:
+        counter = counter + 1
+        indata = unpack('hhffhh',pskfile.read(16))
+        UVCoords.append([indata[0],indata[2],indata[3]])
+        printlog(str(indata[0]) + "|" +str(indata[2]) + "|" +str(indata[3])+"\n")
+        #print('mat index %i',indata(4))
+        #print([indata[0],indata[2],indata[3]])
+        #print([indata[1],indata[2],indata[3]])
+        
+    #================================================================================================== 
+    # Face
+    #================================================================================================== 
+    #read the FACE0000 header
+    indata = unpack('20s3i',pskfile.read(32))
+    recCount = indata[3]
+    printlog( "Nbr of FACE0000 records: "+ str(recCount) + "\n")
+    #PSK FACE0000 fields: WdgIdx1|WdgIdx2|WdgIdx3|MatIdx|AuxMatIdx|SmthGrp
+    #associate MatIdx to an image, associate SmthGrp to a material
+    SGlist = []
+    counter = 0
+    faces = []
+    faceuv = []
+    facesmooth = []
+    #the psk values are: nWdgIdx1|WdgIdx2|WdgIdx3|MatIdx|AuxMatIdx|SmthGrp
+    printlog("nWdgIdx1|WdgIdx2|WdgIdx3|MatIdx|AuxMatIdx|SmthGrp \n")
+    while counter < recCount:
+        counter = counter + 1
+        indata = unpack('hhhbbi',pskfile.read(12))        
+        printlog(str(indata[0]) + "|" +str(indata[1]) + "|" +str(indata[2])+ "|" +str(indata[3])+ "|" +str(indata[4])+ "|" +str(indata[5]) + "\n")
+        #indata[0] = index of UVCoords
+        #UVCoords[indata[0]]=[index to PNTS, U coord, v coord]
+        #UVCoords[indata[0]][0] = index to PNTS
+        PNTSA = UVCoords[indata[2]][0]
+        PNTSB = UVCoords[indata[1]][0]
+        PNTSC = UVCoords[indata[0]][0]
+        #print(PNTSA,PNTSB,PNTSC) #face id vertex
+        #faces.extend([0,1,2,0])
+        faces.extend([(PNTSA,PNTSB,PNTSC,0)])
+        uv = []
+        u0 = UVCoords[indata[2]][1]
+        v0 = UVCoords[indata[2]][2]
+        uv.append([u0,1.0 - v0])
+        u1 = UVCoords[indata[1]][1]
+        v1 = UVCoords[indata[1]][2]
+        uv.append([u1,1.0 - v1])
+        u2 = UVCoords[indata[0]][1]
+        v2 = UVCoords[indata[0]][2]
+        uv.append([u2,1.0 - v2])
+        faceuv.append([uv,indata[3],indata[4],indata[5]])
+        
+        #print("material:",indata[3])
+        #print("UV: ",u0,v0)
+        #update the uv var of the last item in the Tmsh.faces list
+        # which is the face just added above
+        ##Tmsh.faces[-1].uv = [(u0,v0),(u1,v1),(u2,v2)]
+        #print("smooth:",indata[5])
+        #collect a list of the smoothing groups
+        facesmooth.append(indata[5])
+        #print(indata[5])
+        if SGlist.count(indata[5]) == 0:
+            SGlist.append(indata[5])
+            print("smooth:",indata[5])
+        #assign a material index to the face
+        #Tmsh.faces[-1].materialIndex = SGlist.index(indata[5])
+    printlog( "Using Materials to represent PSK Smoothing Groups...\n")
+    #==========
+    # skip something...
+    #==========
+    
+    #================================================================================================== 
+    # Material
+    #================================================================================================== 
+    ##
+    #read the MATT0000 header
+    indata = unpack('20s3i',pskfile.read(32))
+    recCount = indata[3]
+    printlog("Nbr of MATT0000 records: " +  str(recCount) + "\n" )
+    printlog(" - Not importing any material data now. PSKs are texture wrapped! \n")
+    counter = 0
+    materialcount = 0
+    while counter < recCount:
+        counter = counter + 1
+        indata = unpack('64s6i',pskfile.read(88))
+        materialcount += 1
+        print("Material",counter)
+        print("Mat name %s",indata[0])
+
+    ##
+    
+    #================================================================================================== 
+    # Bones (Armature)
+    #================================================================================================== 
+    #read the REFSKEL0 header
+    indata = unpack('20s3i',pskfile.read(32))
+    recCount = indata[3]
+    printlog( "Nbr of REFSKEL0 records: " + str(recCount) + "\n")
+    #REFSKEL0 fields - Name|Flgs|NumChld|PrntIdx|Qw|Qx|Qy|Qz|LocX|LocY|LocZ|Lngth|XSize|YSize|ZSize
+    
+    Bns = []
+    bone = []
+    
+    md5_bones = []
+    bni_dict = {}
+    #================================================================================================== 
+    # Bone Data 
+    #==================================================================================================
+    counter = 0
+    print ("---PRASE--BONES---")
+    printlog("Name|Flgs|NumChld|PrntIdx|Qx|Qy|Qz|Qw|LocX|LocY|LocZ|Lngth|XSize|YSize|ZSize\n")
+    while counter < recCount:
+        indata = unpack('64s3i11f',pskfile.read(120))
+        #print( "DATA",str(indata))
+        
+        bone.append(indata)
+        
+        createbone = md5_bone()
+        #temp_name = indata[0][:30]
+        temp_name = indata[0]
+        temp_name = bytes.decode(temp_name)
+        temp_name = temp_name.lstrip(" ")
+        temp_name = temp_name.rstrip(" ")
+        temp_name = temp_name.strip()
+        temp_name = temp_name.strip( bytes.decode(b'\x00'))
+        printlog(temp_name + "|" +str(indata[1]) + "|" +str(indata[2])+ "|" +str(indata[3])+ "|" +str(indata[4])+ "|" +str(indata[5]) + "|" +str(indata[6]) + "|" +str(indata[7]) + "|" +str(indata[8])+ "|" +str(indata[9])+ "|" +str(indata[10])+ "|" +str(indata[11]) + "|" +str(indata[12]) + "|" +str(indata[13]) + "|" +str(indata[14])+ "\n")   
+        createbone.name = temp_name
+        createbone.bone_index = counter
+        createbone.parent_index = indata[3]
+        createbone.bindpos[0] = indata[8]
+        createbone.bindpos[1] = indata[9]
+        createbone.bindpos[2] = indata[10]
+        createbone.scale[0] = indata[12]
+        createbone.scale[1] = indata[13]
+        createbone.scale[2] = indata[14]
+        
+        bni_dict[createbone.name] = createbone.bone_index
+        
+        #w,x,y,z
+        if (counter == 0):#main parent
+             createbone.bindmat = mathutils.Quaternion((indata[7],-indata[4],-indata[5],-indata[6])).to_matrix() 
+             createbone.origmat = mathutils.Quaternion((indata[7],-indata[4],-indata[5],-indata[6])).to_matrix() 
+        else:
+             createbone.bindmat = mathutils.Quaternion((indata[7],-indata[4],-indata[5],-indata[6])).to_matrix()
+             createbone.origmat = mathutils.Quaternion((indata[7],-indata[4],-indata[5],-indata[6])).to_matrix()
+        
+        createbone.bindmat = mathutils.Matrix.Translation(mathutils.Vector((indata[8],indata[9],indata[10]))) * createbone.bindmat.to_4x4()
+
+            
+        md5_bones.append(createbone)
+        counter = counter + 1
+        bnstr = (str(indata[0]))
+        Bns.append(bnstr)
+        
+    for pbone in md5_bones:
+        pbone.parent =  md5_bones[pbone.parent_index]
+        
+        
+    for pbone in md5_bones:
+        if pbone.name != pbone.parent.name:
+            pbone.bindmat =   pbone.parent.bindmat * pbone.bindmat 
+            #print(pbone.name)
+            #print(pbone.bindmat)
+            #print("end")
+        else:
+            pbone.bindmat = pbone.bindmat
+        
+    for pbone in md5_bones:
+        pbone.head = getheadpos(pbone,md5_bones)
+        
+    for pbone in md5_bones:
+        pbone.tail = gettailpos(pbone,md5_bones)
+        
+    
+
+    for pbone in md5_bones:
+        pbone.parent =  md5_bones[pbone.parent_index].name
+      
+        
+            
+    bonecount = 0
+    for armbone in bone:
+        temp_name = armbone[0][:30]
+        #print ("BONE NAME: ",len(temp_name))
+        temp_name=str((temp_name))
+        #temp_name = temp_name[1]
+        #print ("BONE NAME: ",temp_name)
+        bonecount +=1
+    print ("-------------------------")
+    print ("----Creating--Armature---")
+    print ("-------------------------")
+    
+    #================================================================================================
+    #Check armature if exist if so create or update or remove all and addnew bone
+    #================================================================================================
+    #bpy.ops.object.mode_set(mode='OBJECT')
+    meshname ="ArmObject"
+    objectname = "armaturedata"
+    # arm = None  # UNUSED
+    if importbone:
+        obj = bpy.data.objects.get(meshname)
+        # arm = obj  # UNUSED
+
+        if not obj:
+            armdata = bpy.data.armatures.new(objectname)
+            ob_new = bpy.data.objects.new(meshname, armdata)
+            #ob_new = bpy.data.objects.new(meshname, 'ARMATURE')
+            #ob_new.data = 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
+            #set current armature to edit the bone
+            bpy.context.scene.objects.active = ob_new
+            #set mode to able to edit the bone
+            if bpy.ops.object.mode_set.poll():
+                bpy.ops.object.mode_set(mode='EDIT')
+
+            #newbone = ob_new.data.edit_bones.new('test')
+            #newbone.tail.y = 1
+            print("creating bone(s)")
+            bpy.ops.object.mode_set(mode='OBJECT')
+            for bone in md5_bones:
+                #print(dir(bone))
+                bpy.ops.object.mode_set(mode='EDIT')#Go to edit mode for the bones
+                newbone = ob_new.data.edit_bones.new(bone.name)
+                #parent the bone
+                #print("DRI:",dir(newbone))
+                parentbone = None
+                #note bone location is set in the real space or global not local
+                bonesize = bpy.types.Scene.unrealbonesize
+                if bone.name != bone.parent:
+                    pos_x = bone.bindpos[0]
+                    pos_y = bone.bindpos[1]
+                    pos_z = bone.bindpos[2]
+                    #print( "LINKING:" , bone.parent ,"j")
+                    parentbone = ob_new.data.edit_bones[bone.parent]
+                    newbone.parent = parentbone
+                    rotmatrix = bone.bindmat
+                    newbone.head.x = bone.head[0]
+                    newbone.head.y = bone.head[1]
+                    newbone.head.z = bone.head[2]
+                    newbone.tail.x = bone.tail[0]
+                    newbone.tail.y = bone.tail[1]
+                    newbone.tail.z = bone.tail[2]
+
+                    vecp = parentbone.tail - parentbone.head
+                    vecc = newbone.tail - newbone.head
+                    vecc.normalize()
+                    vecp.normalize()
+                    if vecp.dot(vecc) > -0.8:
+                        newbone.roll = parentbone.roll
+                    else:
+                        newbone.roll = - parentbone.roll
+                else:
+                    rotmatrix = bone.bindmat
+                    newbone.head.x = bone.head[0]
+                    newbone.head.y = bone.head[1]
+                    newbone.head.z = bone.head[2]
+                    newbone.tail.x = bone.tail[0]
+                    newbone.tail.y = bone.tail[1]
+                    newbone.tail.z = bone.tail[2]
+                    newbone.roll = math.radians(90.0)
+                """
+                vec = newbone.tail - newbone.head 
+                if vec.z > 0.0:
+                    newbone.roll = math.radians(90.0)
+                else:
+                    newbone.roll = math.radians(-90.0)
+                """
+    bpy.context.scene.update()
+    
+    #==================================================================================================
+    #END BONE DATA BUILD
+    #==================================================================================================
+    VtxCol = []
+    for x in range(len(Bns)):
+        #change the overall darkness of each material in a range between 0.1 and 0.9
+        tmpVal = ((float(x)+1.0)/(len(Bns))*0.7)+0.1
+        tmpVal = int(tmpVal * 256)
+        tmpCol = [tmpVal,tmpVal,tmpVal,0]
+        #Change the color of each material slightly
+        if x % 3 == 0:
+            if tmpCol[0] < 128: tmpCol[0] += 60
+            else: tmpCol[0] -= 60
+        if x % 3 == 1:
+            if tmpCol[1] < 128: tmpCol[1] += 60
+            else: tmpCol[1] -= 60
+        if x % 3 == 2:
+            if tmpCol[2] < 128: tmpCol[2] += 60
+            else: tmpCol[2] -= 60
+        #Add the material to the mesh
+        VtxCol.append(tmpCol)
+    
+    #================================================================================================== 
+    # Bone Weight
+    #================================================================================================== 
+    #read the RAWW0000 header
+    indata = unpack('20s3i',pskfile.read(32))
+    recCount = indata[3]
+    printlog( "Nbr of RAWW0000 records: " + str(recCount) +"\n")
+    #RAWW0000 fields: Weight|PntIdx|BoneIdx
+    RWghts = []
+    counter = 0
+    while counter < recCount:
+        counter = counter + 1
+        indata = unpack('fii',pskfile.read(12))
+        RWghts.append([indata[1],indata[2],indata[0]])
+        #print("weight:",[indata[1],indata[2],indata[0]])
+    #RWghts fields = PntIdx|BoneIdx|Weight
+    RWghts.sort()
+    printlog( "Vertex point and groups count =" + str(len(RWghts)) + "\n")
+    printlog("PntIdx|BoneIdx|Weight")
+    for vg in RWghts:
+        printlog( str(vg[0]) + "|" + str(vg[1]) + "|" + str(vg[2]) + "\n")
+        
+    #Tmsh.update_tag()
+    
+    #set the Vertex Colors of the faces
+    #face.v[n] = RWghts[0]
+    #RWghts[1] = index of VtxCol
+    """
+    for x in range(len(Tmsh.faces)):
+        for y in range(len(Tmsh.faces[x].v)):
+            #find v in RWghts[n][0]
+            findVal = Tmsh.faces[x].v[y].index
+            n = 0
+            while findVal != RWghts[n][0]:
+                n = n + 1
+            TmpCol = VtxCol[RWghts[n][1]]
+            #check if a vertex has more than one influence
+            if n != len(RWghts)-1:
+                if RWghts[n][0] == RWghts[n+1][0]:
+                    #if there is more than one influence, use the one with the greater influence
+                    #for simplicity only 2 influences are checked, 2nd and 3rd influences are usually very small
+                    if RWghts[n][2] < RWghts[n+1][2]:
+                        TmpCol = VtxCol[RWghts[n+1][1]]
+        Tmsh.faces[x].col.append(NMesh.Col(TmpCol[0],TmpCol[1],TmpCol[2],0))
+    """
+    if (DEBUGLOG):
+        logf.close()
+    #================================================================================================== 
+    #Building Mesh
+    #================================================================================================== 
+    print("vertex:",len(verts),"faces:",len(faces))
+    print("vertex2:",len(verts2))
+    me_ob.vertices.add(len(verts2))
+    me_ob.tessfaces.add(len(faces))
+    me_ob.vertices.foreach_set("co", unpack_list(verts2))
+    me_ob.tessfaces.foreach_set("vertices_raw",unpack_list( faces))
+    
+    for face in me_ob.tessfaces:
+	    face.use_smooth = facesmooth[face.index]
+    
+        
+    """
+    Material setup coding.
+    First the mesh has to be create first to get the uv texture setup working.
+    -Create material(s) list in the psk pack data from the list.(to do list)
+    -Append the material to the from create the mesh object.
+    -Create Texture(s)
+    -fae loop for uv assign and assign material index
+    
+    """
+    bpy.ops.object.mode_set(mode='OBJECT')
+    #===================================================================================================
+    #Material Setup
+    #===================================================================================================
+    print ("-------------------------")
+    print ("----Creating--Materials--")
+    print ("-------------------------")
+    materialname = "pskmat"
+    materials = []
+
+    for matcount in range(materialcount):
+        #if texturedata != None:
+        matdata = bpy.data.materials.new(materialname + str(matcount))
+        #mtex = matdata.texture_slots.new()
+        #mtex.texture = texture[matcount].data
+        #print(type(texture[matcount].data))
+        #print(dir(mtex))
+        #print(dir(matdata))
+        #for texno in range(len( bpy.data.textures)):
+            #print((bpy.data.textures[texno].name))		
+            #print(dir(bpy.data.textures[texno]))
+        #matdata.active_texture = bpy.data.textures[matcount-1]
+        #matdata.texture_coords = 'UV'
+        #matdata.active_texture = texturedata
+        materials.append(matdata)
+
+    for material in materials:
+        #add material to the mesh list of materials
+        me_ob.materials.append(material)
+    #===================================================================================================
+    #UV Setup
+    #===================================================================================================
+    print ("-------------------------")
+    print ("-- Creating UV Texture --")
+    print ("-------------------------") 
+    texture = []
+    # texturename = "text1"  # UNUSED
+    countm = 0
+    for countm in range(materialcount):
+        psktexname="psk" + str(countm)
+        me_ob.uv_textures.new(name=psktexname)
+        countm += 1
+    print("INIT UV TEXTURE...")
+    _matcount = 0
+    #for mattexcount in materials:
+        #print("MATERAIL ID:",_matcount)
+    _textcount = 0
+    for uv in me_ob.tessface_uv_textures: # uv texture
+        print("UV TEXTURE ID:",_textcount)
+        print(dir(uv))
+        for face in me_ob.tessfaces:# face, uv
+            #print(dir(face))
+            if faceuv[face.index][1] == _textcount: #if face index and texture index matches assign it
+                mfaceuv = faceuv[face.index] #face index
+                _uv1 = mfaceuv[0][0] #(0,0)
+                uv.data[face.index].uv1 = mathutils.Vector((_uv1[0],_uv1[1])) #set them
+                _uv2 = mfaceuv[0][1] #(0,0)
+                uv.data[face.index].uv2 = mathutils.Vector((_uv2[0],_uv2[1])) #set them
+                _uv3 = mfaceuv[0][2] #(0,0)
+                uv.data[face.index].uv3 = mathutils.Vector((_uv3[0],_uv3[1])) #set them
+            else: #if not match zero them
+                uv.data[face.index].uv1 = mathutils.Vector((0,0)) #zero them 
+                uv.data[face.index].uv2 = mathutils.Vector((0,0)) #zero them 
+                uv.data[face.index].uv3 = mathutils.Vector((0,0)) #zero them 
+        _textcount += 1
+        #_matcount += 1
+        #print(matcount)
+    print("END UV TEXTURE...")
+
+    print("UV TEXTURE LEN:",len(texture))
+        #for tex in me_ob.uv_textures:
+            #print("mesh tex:",dir(tex))
+            #print((tex.name))
+    
+    #for face in me_ob.faces:
+        #print(dir(face))
+
+    #===================================================================================================
+    #
+    #===================================================================================================
+    obmesh = bpy.data.objects.new(objName,me_ob)
+    #===================================================================================================
+    #Mesh Vertex Group bone weight
+    #===================================================================================================
+    print("---- building bone weight mesh ----")
+    #print(dir(ob_new.data.bones))
+    #create bone vertex group #deal with bone id for index number
+    for bone in ob_new.data.bones:
+        #print("names:",bone.name,":",dir(bone))
+        #print("names:",bone.name)
+        group = obmesh.vertex_groups.new(bone.name)
+    
+        
+    for vgroup in obmesh.vertex_groups:
+        #print(vgroup.name,":",vgroup.index)
+        for vgp in RWghts:
+            #bone index
+                
+            if vgp[1] == bni_dict[vgroup.name]:
+                #print(vgp)
+                #[vertex id],weight
+                vgroup.add([vgp[0]], vgp[2], 'ADD')
+    
+    
+    #check if there is a material to set to
+    if len(materials) > 0:
+        obmesh.active_material = materials[0] #material setup tmp
+    print("---- adding mesh to the scene ----")
+    
+    bpy.ops.object.mode_set(mode='OBJECT')
+    #bpy.ops.object.select_pattern(extend=True, pattern=obmesh.name, case_sensitive=True)
+    #bpy.ops.object.select_pattern(extend=True, pattern=ob_new.name, case_sensitive=True)
+
+    #bpy.ops.object.select_name(name=str(obmesh.name))
+    #bpy.ops.object.select_name(name=str(ob_new.name))
+    #bpy.context.scene.objects.active = ob_new
+    me_ob.update()
+    bpy.context.scene.objects.link(obmesh)   
+    bpy.context.scene.update()
+    obmesh.select = False
+    ob_new.select = False
+    obmesh.select = True
+    ob_new.select = True
+    bpy.ops.object.parent_set(type="ARMATURE")
+    
+    print ("PSK2Blender completed")
+#End of def pskimport#########################
+
+def getInputFilenamepsk(self,filename,importmesh,importbone,bDebugLogPSK,importmultiuvtextures):
+    checktype = filename.split('\\')[-1].split('.')[1]
+    print ("------------",filename)
+    if checktype.lower() != 'psk':
+        print ("  Selected file = ",filename)
+        raise (IOError, "The selected input file is not a *.psk file")
+        #self.report({'INFO'}, ("Selected file:"+ filename))
+    else:
+        pskimport(filename,importmesh,importbone,bDebugLogPSK,importmultiuvtextures)
+		
+def getInputFilenamepsa(self,filename,context):
+    checktype = filename.split('\\')[-1].split('.')[1]
+    if checktype.lower() != 'psa':
+        print ("  Selected file = ",filename)
+        raise (IOError, "The selected input file is not a *.psa file")
+        #self.report({'INFO'}, ("Selected file:"+ filename))
+    else:
+        psaimport(filename,context)
+
+class IMPORT_OT_psk(bpy.types.Operator):
+    '''Load a skeleton mesh psk File'''
+    bl_idname = "import_scene.psk"
+    bl_label = "Import PSK"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_options = {'UNDO'}
+
+    # 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",
+            options={'HIDDEN'},
+            )
+    importmesh = BoolProperty(
+            name="Mesh",
+            description="Import mesh only. (not yet build.)",
+            default=True,
+            )
+    importbone = BoolProperty(
+            name="Bones",
+            description="Import bones only. Current not working yet",
+            default=True,
+            )
+    importmultiuvtextures = BoolProperty(
+            name="Single UV Texture(s)",
+            description="Single or Multi uv textures",
+            default=True,
+            )
+    bDebugLogPSK = BoolProperty(
+            name="Debug Log.txt",
+            description="Log the output of raw format. It will save in " \
+                        "current file dir. Note this just for testing",
+            default=False,
+            )
+    unrealbonesize = FloatProperty(
+            name="Bone Length",
+            description="Bone Length from head to tail distance",
+            default=1,
+            min=0.001,
+            max=1000,
+            )
+
+    def execute(self, context):
+        bpy.types.Scene.unrealbonesize = self.unrealbonesize
+        getInputFilenamepsk(self,self.filepath,self.importmesh,self.importbone,self.bDebugLogPSK,self.importmultiuvtextures)
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        wm = context.window_manager
+        wm.fileselect_add(self)
+        return {'RUNNING_MODAL'}  
+
+
+class psa_bone:
+    name=""
+    Transform=None
+    parent=None
+    def __init__(self):
+        self.name=""
+        self.Transform=None
+        self.parent=None
+		
+def psaimport(filename,context):
+    print ("--------------------------------------------------")
+    print ("---------SCRIPT EXECUTING PYTHON IMPORTER---------")
+    print ("--------------------------------------------------")
+    print ("Importing file: ", filename)
+    psafile = open(filename,'rb')
+    debug = True
+    if (debug):
+        logpath = filename.replace(".psa", ".txt")
+        print("logpath:",logpath)
+        logf = open(logpath,'w')
+    def printlog(strdata):
+        if (debug):
+            logf.write(strdata)
+    def printlogplus(name,data):
+        if (debug):
+            logf.write(str(name)+'\n')
+            if isinstance(data,bytes):
+                logf.write(str(bytes.decode(data).strip(bytes.decode(b'\x00'))))
+            else:
+                logf.write(str(data))
+            logf.write('\n')
+            
+    printlog('-----------Log File------------\n')
+    #General Header
+    indata = unpack('20s3i',psafile.read(32))
+    printlogplus('ChunkID',indata[0])
+    printlogplus('TypeFlag',indata[1])
+    printlogplus('DataSize',indata[2])
+    printlogplus('DataCount',indata[3])
+    #Bones Header
+    indata = unpack('20s3i',psafile.read(32))
+    printlogplus('ChunkID',indata[0])
+    printlogplus('TypeFlag',indata[1])
+    printlogplus('DataSize',indata[2])
+    printlogplus('DataCount',indata[3])
+    #Bones Data
+    BoneIndex2NamePairMap = {}
+    BoneNotFoundList = []
+    printlog("Name|Flgs|NumChld|PrntIdx|Qx|Qy|Qz|Qw|LocX|LocY|LocZ|Length|XSize|YSize|ZSize\n")
+    recCount = indata[3]
+    counter = 0
+    nobonematch = True
+    while counter < recCount:
+        indata = unpack('64s3i11f',psafile.read(120))
+        #printlogplus('bone',indata[0])
+        bonename = str(bytes.decode(indata[0]).strip(bytes.decode(b'\x00')))
+        if bonename in bpy.data.armatures['armaturedata'].bones.keys():
+            BoneIndex2NamePairMap[counter] = bonename
+            print('find bone',bonename)
+            nobonematch = False
+        else:
+            print('can not find the bone:',bonename)
+            BoneNotFoundList.append(counter)
+        counter += 1
+    
+    if nobonematch:
+        print('no bone was match so skip import!')
+        return
+        
+    #Animations Header
+    indata = unpack('20s3i',psafile.read(32))
+    printlogplus('ChunkID',indata[0])
+    printlogplus('TypeFlag',indata[1])
+    printlogplus('DataSize',indata[2])
+    printlogplus('DataCount',indata[3])
+    #Animations Data
+    recCount = indata[3]
+    counter = 0
+    Raw_Key_Nums = 0
+    Action_List = []
+    while counter < recCount:
+        indata = unpack('64s64s4i3f3i',psafile.read(64+64+4*4+3*4+3*4))
+        printlogplus('Name',indata[0])
+        printlogplus('Group',indata[1])
+        printlogplus('totalbones',indata[2])
+        printlogplus('NumRawFrames',indata[-1])
+        Name = str(bytes.decode(indata[0]).strip(bytes.decode(b'\x00')))
+        Group = str(bytes.decode(indata[1]).strip(bytes.decode(b'\x00')))
+        totalbones = indata[2]
+        NumRawFrames = indata[-1]
+        
+        Raw_Key_Nums += indata[2] * indata[-1]
+        Action_List.append((Name,Group,totalbones,NumRawFrames))
+        
+        counter += 1
+        
+    #Raw keys Header
+    Raw_Key_List = []
+    indata = unpack('20s3i',psafile.read(32))
+    printlogplus('ChunkID',indata[0])
+    printlogplus('TypeFlag',indata[1])
+    printlogplus('DataSize',indata[2])
+    printlogplus('DataCount',indata[3])
+    if(Raw_Key_Nums != indata[3]):
+        print('error! Raw_Key_Nums Inconsistent')
+        return
+    #Raw keys Data
+    recCount = Raw_Key_Nums
+    counter = 0
+    while counter < recCount:
+        indata = unpack('3f4f1f',psafile.read(3*4+4*4+4))
+        pos = mathutils.Vector((indata[0], indata[1], indata[2]))
+        quat = mathutils.Quaternion((indata[6], indata[3], indata[4], indata[5]))
+        time = indata[7]
+        Raw_Key_List.append((pos,quat,time))
+        counter += 1
+    #Scale keys Header,Scale keys Data,Curve keys Header,Curve keys Data
+    curFilePos = psafile.tell()
+    psafile.seek(0,2)
+    endFilePos = psafile.tell()
+    if curFilePos == endFilePos:
+        print('no Scale keys,Curve keys')
+     
+    #build the animation line
+    if bpy.ops.object.mode_set.poll():
+        bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
+        
+    NeededBoneMatrix = {}
+    for bone in bpy.data.armatures['armaturedata'].bones:
+        name = bone.name
+        ori_matrix = bone.matrix
+        matrix = bone.matrix_local.to_3x3()
+        bone_rest_matrix = Matrix(matrix)
+        #bone_rest_matrix = bone.matrix_local.to_3x3()
+        #bone_rest_matrix = bone.matrix_local.to_quaternion().conjugated().to_matrix()
+        bone_rest_matrix_inv = Matrix(bone_rest_matrix)
+        bone_rest_matrix_inv.invert()
+        bone_rest_matrix_inv.resize_4x4()
+        bone_rest_matrix.resize_4x4()
+        NeededBoneMatrix[name] = (bone_rest_matrix,bone_rest_matrix_inv,ori_matrix)
+        
+    #build tmp pose bone tree
+    psa_bones = {}
+    for bone in bpy.data.objects['ArmObject'].pose.bones:
+        _psa_bone = psa_bone()
+        _psa_bone.name = bone.name
+        _psa_bone.Transform = bone.matrix
+        if bone.parent != None:
+            _psa_bone.parent = psa_bones[bone.parent.name]
+        else:
+            _psa_bone.parent = None
+        psa_bones[bone.name] = _psa_bone
+    
+    raw_key_index = 0
+
+    for raw_action in Action_List:
+        Name            = raw_action[0]
+        Group           = raw_action[1]
+        Totalbones      = raw_action[2]
+        NumRawFrames    = raw_action[3]
+        context.scene.update()
+        object = bpy.data.objects['ArmObject']
+        object.animation_data_create()
+        action = bpy.data.actions.new(name=Name)    
+        object.animation_data.action = action
+        for i in range(NumRawFrames):
+            context.scene.frame_set(i+1)
+            pose_bones = object.pose.bones
+            for j in range(Totalbones):
+                if j not in BoneNotFoundList:
+                    bName = BoneIndex2NamePairMap[j]
+                    pbone           = psa_bones[bName]
+                    pos = Raw_Key_List[raw_key_index][0]
+                    quat = Raw_Key_List[raw_key_index][1]
+           
+                    mat = Matrix()
+                    if pbone.parent != None:
+                        quat = quat.conjugated()
+                        mat = Matrix.Translation(pos) * quat.to_matrix().to_4x4()
+                        mat = pose_bones[bName].parent.matrix * mat 
+                        #mat = pbone.parent.Transform * mat
+                    else:
+                        mat = pbone.Transform * Matrix.Translation(pos) * quat.to_matrix().to_4x4()
+
+                    pose_bones[bName].matrix = mat
+                    pbone.Transform = mat
+
+                raw_key_index += 1
+
+            #bpy.data.meshes[1]
+            for bone in pose_bones:              
+                bone.matrix = psa_bones[bone.name].Transform
+                bone.keyframe_insert("rotation_quaternion")
+                bone.keyframe_insert("location")
+
+            def whirlSingleBone(pose_bone,quat):
+                bpy.context.scene.update()
+                #record child's matrix and origin rotate
+                hymat = Quaternion((0.707,-0.707,0,0)).inverted().to_matrix().to_4x4()
+                children_infos = {}
+                childrens = pose_bone.children
+                for child in childrens:
+                    armmat = bpy.data.armatures['armaturedata'].bones[child.name].matrix.copy().to_4x4()                    
+                    cmat = child.matrix.copy() * armmat.inverted() * hymat.inverted()
+                    pos = cmat.to_translation()
+                    rotmat = cmat.to_3x3()
+                    children_infos[child] = (armmat,pos,rotmat)
+                
+                #whirl this bone by quat
+                pose_bone.matrix *= quat.to_matrix().to_4x4()
+                pose_bone.keyframe_insert("location")
+                pose_bone.keyframe_insert("rotation_quaternion")
+                bpy.context.scene.update()
+                #set back children bon to original position 
+                #reverse whirl child bone by quat.inverse()
+                
+                for child in childrens:
+                    armmat = children_infos[child][0]
+                    pos = children_infos[child][1]
+                    rotmat = children_infos[child][2] 
+
+                    child.matrix = Matrix.Translation(pos) * rotmat.to_4x4() * hymat * armmat 
+                    child.keyframe_insert("location") 
+                    child.keyframe_insert("rotation_quaternion")
+
+            for bone in pose_bones:
+                if bone.parent != None:
+                    whirlSingleBone(bone,Quaternion((0.707,0,0,-0.707)))
+                else:
+                    bone.rotation_quaternion *= Quaternion((0.707,-0.707,0,0))*Quaternion((0.707,0,0,-0.707))
+                    bone.keyframe_insert("rotation_quaternion")
+            
+        break
+        
+    context.scene.frame_set(0)
+    if(debug):
+        logf.close()
+		
+class IMPORT_OT_psa(bpy.types.Operator):
+    '''Load a skeleton anim psa File'''
+    bl_idname = "import_scene.psa"
+    bl_label = "Import PSA"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+
+    filepath = StringProperty(
+            subtype='FILE_PATH',
+            )
+    filter_glob = StringProperty(
+            default="*.psa",
+            options={'HIDDEN'},
+            )
+
+    def execute(self, context):
+        getInputFilenamepsa(self,self.filepath,context)
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        wm = context.window_manager
+        wm.fileselect_add(self)
+        return {'RUNNING_MODAL'}  		
+
+class IMPORT_OT_psa(bpy.types.Operator):
+    '''Load a skeleton anim psa File'''
+    bl_idname = "import_scene.psa"
+    bl_label = "Import PSA"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+
+    filepath = StringProperty(
+            subtype='FILE_PATH',
+            )
+    filter_glob = StringProperty(
+            default="*.psa",
+            options={'HIDDEN'},
+            )
+
+    def execute(self, context):
+        getInputFilenamepsa(self,self.filepath,context)
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        wm = context.window_manager
+        wm.fileselect_add(self)
+        return {'RUNNING_MODAL'}  
+
+def menu_func(self, context):
+    self.layout.operator(IMPORT_OT_psk.bl_idname, text="Skeleton Mesh (.psk)")
+    self.layout.operator(IMPORT_OT_psa.bl_idname, text="Skeleton Anim (.psa)")
+
+def register():
+    bpy.utils.register_module(__name__)
+    bpy.types.INFO_MT_file_import.append(menu_func)
+    
+def unregister():
+    bpy.utils.unregister_module(__name__)
+    bpy.types.INFO_MT_file_import.remove(menu_func)
+
+if __name__ == "__main__":
+    register()
+
+#note this only read the data and will not be place in the scene    
+#getInputFilename('C:\\blenderfiles\\BotA.psk') 
+#getInputFilename('C:\\blenderfiles\\AA.PSK')
\ No newline at end of file
diff --git a/io_import_scene_unreal_psk.py b/io_import_scene_unreal_psk.py
deleted file mode 100644
index 96784b1d..00000000
--- a/io_import_scene_unreal_psk.py
+++ /dev/null
@@ -1,804 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-bl_info = {
-    "name": "Import Unreal Skeleton Mesh (.psk)",
-    "author": "Darknet",
-    "version": (2, 1),
-    "blender": (2, 6, 3),
-    "location": "File > Import > Skeleton Mesh (.psk)",
-    "description": "Import Skeleleton Mesh",
-    "warning": "",
-    "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
-        "Scripts/Import-Export/Unreal_psk_psa",
-    "tracker_url": "https://projects.blender.org/tracker/index.php?"\
-        "func=detail&aid=21366",
-    "category": "Import-Export"}
-
-"""
-Version': '2.0' ported by Darknet
-
-Unreal Tournament PSK file to Blender mesh converter V1.0
-Author: 
--Darknet (Redesign and reworked)
--D.M. Sturgeon (camg188 at the elYsium forum)
--#2011-01-20 MARIUSZ SZKARADEK GLOGOW POLAND 
-
-Imports a *psk file to a new mesh
-
--No UV Texutre
--No Weight
--No Armature Bones
--No Material ID
-"""
-
-import bpy
-import bmesh
-import mathutils
-import math
-from string import *
-from struct import *
-import struct
-from math import *
-from bpy.props import *
-from bpy_extras.io_utils import unpack_list, unpack_face_list
-
-Quaternion = mathutils.Quaternion
-
-bpy.types.Scene.unrealbonesize = FloatProperty(
-    name="Bone Length",
-    description="Bone Length from head to tail distance",
-    default=1,min=0.001,max=1000)
-
-#output log in to txt file
-DEBUGLOG = False
-
-scale = 1.0
-bonesize = 1.0
-skala = 1
-flipyz = False   
-flipuv = True
-
-#pack read words	
-def word(long): 
-   s=''
-   for j in range(0,long): 
-       lit =  struct.unpack('c',plik.read(1))[0]
-       #print(">",lit)
-       #print(">",bytes.decode(lit))
-       if ord(lit)!=0:
-           #print(lit)
-           s+=bytes.decode(lit)
-           if len(s)>100:
-               break
-   return s
-#pack read data   
-def b(n):
-    return struct.unpack(n*'b', plik.read(n))
-def B(n):
-    return struct.unpack(n*'B', plik.read(n))
-def h(n):
-    return struct.unpack(n*'h', plik.read(n*2))
-def H(n):
-    return struct.unpack(n*'H', plik.read(n*2))
-def i(n):
-    return struct.unpack(n*'i', plik.read(n*4))
-def f(n):
-    return struct.unpack(n*'f', plik.read(n*4))
-
-#work in progress
-#bmesh
-#tess function prefix
-def drawmesh():
-    global DEBUGLOG, plik,vertexes,uvcoord,faceslist,num_faces,facemat,facesmooth,m
-    global vertexes_ids,bonesdata,meshesdata,groups,num_materials,skala,flipyz,flipuv,mat_faceslist
-    global vertices,faces
-    print(faces[0])
-    print("[CREATING MESH:]")
-    me_ob = bpy.data.meshes.new('testmesh')
-    #create mesh
-    print("-Vertices count:",len(vertices))
-    me_ob.vertices.add(len(vertices))
-    print("-Faces count:",len(faces))
-    me_ob.tessfaces.add(len(faces))
-    print("-Creating vertices points...")
-    me_ob.vertices.foreach_set("co", unpack_list(vertices))
-    print("-Creating faces idx...")
-    me_ob.tessfaces.foreach_set("vertices_raw",unpack_list( faces))
-    for face in me_ob.tessfaces:
-        print(dir(face))
-        face.use_smooth = facesmooth[face.index]
-        #face.material_index = facemat[face.index]#not yet working
-    print("-Creating UV Texture...")
-    me_ob.tessface_uv_textures.new('uvtexture')
-    #uvtex = me_ob.tessface_uv_textures[0]
-    for uv in me_ob.tessface_uv_textures:
-        for face in me_ob.tessfaces:
-            #uv.data[face.index].uv1.x = 
-            
-            #print(uv.data[face.index].uv1)
-            #uv.data[face.index].uv1 = Vector(uvcoord[faces[face.index]][0],uvcoord[face.index][1])
-            print(face.vertices_raw[0],face.vertices_raw[1],face.vertices_raw[2])
-            uv.data[face.index].uv1 = mathutils.Vector((uvcoord[face.vertices_raw[0]][0],uvcoord[face.vertices_raw[0]][1]))
-            uv.data[face.index].uv2 = mathutils.Vector((uvcoord[face.vertices_raw[1]][0],uvcoord[face.vertices_raw[1]][1]))
-            uv.data[face.index].uv3 = mathutils.Vector((uvcoord[face.vertices_raw[2]][0],uvcoord[face.vertices_raw[2]][1]))
-
-    ob = bpy.data.objects.new("TestObject",me_ob)
-    #create vertex group
-    for bone_id in range(len(bonesdata)):
-        bonedata = bonesdata[str(bone_id)]
-        namebone = bonedata[0]#.strip()[-25:]
-        #print("NAME:",namebone)
-        ob.vertex_groups.new(namebone)
-    me_ob.update()
-    bpy.context.scene.objects.link(ob) 
-
-#Create Armature
-def check_armature():
-    global DEBUGLOG, plik,vertexes,uvcoord,faceslist,num_faces,facemat,facesmooth,m
-    global vertexes_ids,bonesdata,meshesdata,groups,num_materials,skala,flipyz,flipuv,amt
-    
-    #create Armature
-    bpy.ops.object.mode_set(mode='OBJECT')
-    for i in bpy.context.scene.objects: i.select = False #deselect all objects
-
-    bpy.ops.object.add(
-     type='ARMATURE', 
-     enter_editmode=True,
-     location=(0,0,0))
-    ob = bpy.context.object
-    ob.show_x_ray = True
-    ob.name = "ARM"
-    amt = ob.data
-    amt.name = 'Amt'
-    amt.show_axes = True
-    bpy.ops.object.mode_set(mode='EDIT')
-    bpy.context.scene.update()
-#Create bones
-def make_bone():    
-    global DEBUGLOG, plik,vertexes,uvcoord,faceslist,num_faces,facemat,facesmooth,m
-    global vertexes_ids,bonesdata,meshesdata,groups,num_materials,skala,flipyz,flipuv,amt
-    global bonenames
-    bonenames = []
-    
-    print ('make bone')
-    
-    for bone_id in range(len(bonesdata)):
-       bonedata = bonesdata[str(bone_id)]
-       namebone = bonedata[0]#.strip()[-25:]
-       newbone = amt.edit_bones.new(namebone)
-       #those are need to show in the scene
-       newbone.head = (0,0,0)
-       newbone.tail = (0,0,1)
-       bonenames.append(namebone)
-    bpy.context.scene.update()
-#Make bone parent
-def make_bone_parent():    
-    global DEBUGLOG, plik,vertexes,uvcoord,faceslist,num_faces,facemat,facesmooth,m
-    global vertexes_ids,bonesdata,meshesdata,groups,num_materials,skala,flipyz,flipuv,amt    
-    global children
-    children = {}
-    
-    print ('make bone parent')
-    for bone_id in range(len(bonesdata)):
-        bonedata = bonesdata[str(bone_id)]
-        namebone  = bonenames[bone_id]
-        nameparent = bonenames[bonedata[1][2]]
-        #print(nameparent)
-        if nameparent != None:#make sure it has name
-           parentbone = amt.edit_bones[nameparent]
-           bonecurrnet = amt.edit_bones[namebone]
-           bonecurrnet.parent = parentbone
-    bpy.context.scene.update()
-
-#make bone martix set    
-def bones_matrix():    
-    global DEBUGLOG, plik,vertexes,uvcoord,faceslist,num_faces,facemat,facesmooth,m
-    global vertexes_ids,bonesdata,meshesdata,groups,num_materials,skala,flipyz,flipuv,amt
-    
-    for bone_id in range(len(bonesdata)):
-        bonedata = bonesdata[str(bone_id)]
-        namebone = bonedata[0]#.strip()[-25:]
-        nameparent = bonenames[bonedata[1][2]]
-        pos = bonedata[2][4:7] 
-        rot = bonedata[2][0:4] 
-        qx,qy,qz,qw = rot[0],rot[1],rot[2],rot[3]
-        #print("Quaternion:",qx,qy,qz,qw)
-        if bone_id==0:
-            rot =  mathutils.Quaternion((qw,-qx,-qy,-qz))
-        if bone_id!=0:
-            rot =  mathutils.Quaternion((qw,qx,qy,qz))
-        matrix = mathutils.Matrix()
-        rot = rot.to_matrix().inverted()
-        #print(rot)
-        matrix[0][:3] = rot[0]
-        matrix[1][:3] = rot[1]
-        matrix[2][:3] = rot[2]
-        matrix[3][:3] = pos
-        if bone_id>0:
-            bonedata.append(matrix*bonesdata[str(bonedata[1][2])][3])
-        else:
-            bonedata.append(matrix)
-    bpy.context.scene.update()
-
-#not working    
-def make_bone_position():
-    print ('make bone position')
-    bpy.ops.object.mode_set(mode='EDIT')
-    for bone_id in range(len(bonesdata)):
-        bonedata = bonesdata[str(bone_id)]
-        namebone = bonedata[0]#.strip()[-25:]
-        bone = amt.edit_bones[namebone]
-        bone.transform(bonedata[3], scale=True, roll=True)
-        bvec = bone.tail- bone.head
-        bvec.normalize()
-        bone.tail = bone.head + 0.1 * bvec
-        #bone.tail = bone.head + 1 * bvec
-    bpy.context.scene.update()    
-        
-#not working  
-def make_bone_position1():    
-    print ('make bone position')
-    bpy.ops.object.mode_set(mode='EDIT')
-    for bone_id in range(len(bonesdata)):
-        bonedata = bonesdata[str(bone_id)]
-        namebone = bonedata[0]#.strip()[-25:]
-        pos = bonedata[2][4:7] 
-        pos1 = pos[0]*skala  
-        pos2 = pos[1]*skala  
-        pos3 = pos[2]*skala 
-        if flipyz == False:
-            pos = [pos1,pos2,pos3]
-        if flipyz == True:
-            pos = [pos1,-pos3,pos2]
-        rot = bonedata[2][0:4] 
-        qx,qy,qz,qw = rot[0],rot[1],rot[2],rot[3]
-        if bone_id==0:
-            rot = mathutils.Quaternion((qw,-qx,-qy,-qz))
-        if bone_id!=0:
-            rot = mathutils.Quaternion((qw,qx,qy,qz))
-        #rot = rot.toMatrix().invert() 	
-        rot = rot.to_matrix().inverted() 	
-        bone = amt.edit_bones[namebone]
-        #print("BONES:",amt.bones[0])
-        
-        if bone_id!=0:
-            bone.head = bone.parent.head+mathutils.Vector(pos) * bone.parent.matrix
-            #print(dir(rot))
-            #print("rot:",rot)
-            #print("matrix:",bone.parent.matrix)
-            
-            tempM = rot.to_4x4()*bone.parent.matrix
-            #bone.matrix = tempM
-            bone.transform(tempM, scale=False, roll=True)
-            #bone.matrix_local = tempM
-        else:
-            bone.head = mathutils.Vector(pos)
-            #bone.matrix = rot
-            bone.transform(rot, scale=False, roll=True)
-            #bone.matrix_local = rot
-        bvec = bone.tail- bone.head
-        bvec.normalize()
-        bone.tail = bone.head + 0.1 * bvec
-        #bone.tail = bone.head + 1 * bvec
-    
-
-#http://www.blender.org/forum/viewtopic.php?t=13340&sid=8b17d5de07b17960021bbd72cac0495f            
-def fixRollZ(b):
-    v = (b.tail-b.head)/b.length
-    b.roll -= math.degrees(math.atan2(v[0]*v[2]*(1 - v[1]),v[0]*v[0] + v[1]*v[2]*v[2])) 
-def fixRoll(b):
-    v = (b.tail-b.head)/b.length
-    if v[2]*v[2] > .5:
-        #align X-axis
-        b.roll += math.degrees(math.atan2(v[0]*v[2]*(1 - v[1]),v[2]*v[2] + v[1]*v[0]*v[0]))
-    else:
-        #align Z-axis
-        b.roll -= math.degrees(math.atan2(v[0]*v[2]*(1 - v[1]),v[0]*v[0] + v[1]*v[2]*v[2])) 
-""" #did not port this yet unstable but work in some ways
-def make_bone_position3():    
-            for bone in md5_bones:
-                #print(dir(bone))
-                bpy.ops.object.mode_set(mode='EDIT')
-                newbone = ob_new.data.edit_bones.new(bone.name)
-                #parent the bone
-                print("DRI:",dir(newbone))
-                parentbone = None
-                print("bone name:",bone.name)
-                #note bone location is set in the real space or global not local
-                bonesize = bpy.types.Scene.unrealbonesize
-                if bone.name != bone.parent:
-
-                    pos_x = bone.bindpos[0]
-                    pos_y = bone.bindpos[1]
-                    pos_z = bone.bindpos[2]
-                    
-                    #print( "LINKING:" , bone.parent ,"j")
-                    parentbone = ob_new.data.edit_bones[bone.parent]
-                    newbone.parent = parentbone
-                    
-                    rotmatrix = bone.bindmat.to_matrix().to_4x4().to_3x3()  # XXX, redundant matrix conversion?
-                    newbone.transform(bone.bindmat.to_matrix().to_4x4(),True,True)
-                    #parent_head = parentbone.matrix.to_quaternion().inverse() * parentbone.head
-                    #parent_tail = parentbone.matrix.to_quaternion().inverse() * parentbone.tail
-                    #location=Vector(pos_x,pos_y,pos_z)
-                    #set_position = (parent_tail - parent_head) + location
-                    #print("tmp head:",set_position)
-
-                    #pos_x = set_position.x
-                    #pos_y = set_position.y
-                    #pos_z = set_position.z
-                    
-                 
-                    newbone.head.x = parentbone.head.x + pos_x
-                    newbone.head.y = parentbone.head.y + pos_y
-                    newbone.head.z = parentbone.head.z + pos_z
-                    #print("head:",newbone.head)
-                    newbone.tail.x = parentbone.head.x + (pos_x + bonesize * rotmatrix[0][1])
-                    newbone.tail.y = parentbone.head.y + (pos_y + bonesize * rotmatrix[1][1])
-                    newbone.tail.z = parentbone.head.z + (pos_z + bonesize * rotmatrix[2][1])
-                    #newbone.roll = fixRoll(newbone)
-                else:
-                    #print("rotmatrix:",dir(bone.bindmat.to_matrix().resize_4x4()))
-                    #rotmatrix = bone.bindmat.to_matrix().resize_4x4().to_3x3()  # XXX, redundant matrix conversion?
-                    rotmatrix = bone.bindmat.to_matrix().to_3x3()  # XXX, redundant matrix conversion?
-                    #newbone.transform(bone.bindmat.to_matrix(),True,True)
-                    newbone.head.x = bone.bindpos[0]
-                    newbone.head.y = bone.bindpos[1]
-                    newbone.head.z = bone.bindpos[2]
-                    newbone.tail.x = bone.bindpos[0] + bonesize * rotmatrix[0][1]
-                    newbone.tail.y = bone.bindpos[1] + bonesize * rotmatrix[1][1]
-                    newbone.tail.z = bone.bindpos[2] + bonesize * rotmatrix[2][1]
-                    #newbone.roll = fixRoll(newbone)
-                    #print("no parent")    
-""" 
-    
-
-#import psk file
-def pskimport(filename,importmesh,importbone,bDebugLogPSK,importmultiuvtextures):
-    global DEBUGLOG, plik,vertexes,uvcoord,faceslist,num_faces,facemat,facesmooth,m
-    global vertexes_ids,bonesdata,meshesdata,groups,num_materials,skala,flipyz,flipuv,amt,vertices,faces
-    points = []
-    vertexes = []
-    vertices = []
-    uvcoord = []
-    faceslist = []
-    datafaces = []
-    faces = []
-    facemat = []
-    facesmooth = []
-    groups = []
-    vertexes_ids = []
-    bonesdata = {}
-    meshesdata ={}
-	
-    DEBUGLOG = bDebugLogPSK
-    print ("--------------------------------------------------")
-    print ("---------SCRIPT EXECUTING PYTHON IMPORTER---------")
-    print ("--------------------------------------------------")
-    print (" DEBUG Log:",bDebugLogPSK)
-    print ("Importing file: ", filename)
-    
-    plik = open(filename,'rb')
-    word(20),i(3)
-    
-    #------POINTS------
-    print ('reading points')
-    word(20)
-    data = i(3)
-    num_points = data[2]    
-    for m in range(num_points):
-        v=f(3)
-        v1 =v[0]*skala
-        v2 =v[1]*skala
-        v3 =v[2]*skala
-        if flipyz == False:
-            points.append([v1,v2,v3])
-        if flipyz == True:
-            points.append([v1,-v3,v2])
-        vertexes_ids.append([])
-    
-    #------VERTEXES----
-    print ('reading vertexes')
-    word(20)
-    data = i(3)
-    num_vertexes = data[2]
-    for m in range(num_vertexes):
-        data1 = H(2)
-        vertexes.append(points[data1[0]])
-        vertices.append(points[data1[0]])
-        #vertices.extend(points[data1[0]])
-        #vertices.extend([(points[data1[0]][0],points[data1[0]][1],points[data1[0]][2] )])
-        #vertices.extend([(points[data1[0]][0],points[data1[0]][1],points[data1[0]][2] )])
-        #print(points[data1[0]])
-        if flipuv == False:
-            uvcoord.append([f(1)[0],1-f(1)[0]])
-        if flipuv == True:
-            uvcoord.append([f(1)[0],f(1)[0]])
-        vertexes_ids[data1[0]].append(m)
-        b(2),h(1)
-    
-    
-    #------FACES-------
-    print ('reading faces')
-    word(20)
-    data = i(3)
-    num_faces = data[2]
-    for m in range(num_faces):
-        v0=H(1)[0]
-        v1=H(1)[0]
-        v2=H(1)[0]
-        faceslist.append([v1,v0,v2])
-        faces.extend([(v1,v0,v2,0)])
-        #faces.append([v1,v0,v2])
-        #print((v1,v0,v2,0))
-        mat_ids = B(2) 
-        facemat.append(mat_ids)
-        if str(mat_ids[0]) not in meshesdata:
-            meshesdata[str(mat_ids[0])] = []          
-        meshesdata[str(mat_ids[0])].append(m)
-        facesmooth.append(i(1)[0])
-        #datafaces.append([v1,v0,v2],mat_ids
-    
-    #------MATERIALS---
-    print ('making materials')
-    word(20)
-    data = i(3)
-    num_materials = data[2]
-    for m in range(num_materials):
-        name = word(64)
-        print ('read materials from',name)
-        matdata = bpy.data.materials.new(name)
-        #try:
-            #mat = Material.Get(namemodel+'-'+str(m))
-            #mat = Material.Get(name)
-        #except:
-            #mat = Material.New(namemodel+'-'+str(m))
-            #mat = Material.New(name)
-        i(6)
-        #make_materials(name,mat)
-    
-    #-------BONES------
-    print ('reading bones')
-    #check_armature()
-    check_armature()
-    word(20)
-    data = i(3)
-    num_bones = data[2]
-    for m in range(num_bones):
-        #print(str(m)) #index
-        bonesdata[str(m)] = []
-        bonename = word(64)
-        bonename = bonename#.strip() 
-        bonename = bonename.strip() 
-        #print(bonename)#bone name
-        bonesdata[str(m)].append(bonename)
-        bonesdata[str(m)].append(i(3))
-        bonesdata[str(m)].append(f(11))
-    make_bone()
-    make_bone_parent()
-    bones_matrix()
-    make_bone_position1()
-
-    
-     #-------SKINNING---
-    print ('making skinning')
-    word(20)
-    data = i(3)
-    num_groups = data[2]
-    
-    for m in range(num_groups):
-        w = f(1)[0]
-        v_id  = i(1)[0]         
-        gr = i(1)[0]
-        groups.append([w,v_id,gr]) 
-    #create Mesh
-    drawmesh()
-
-    print ("IMPORTER PSK Blender 2.6 completed")
-#End of def pskimport#########################
-
-def psaimport(filename):
-    global plik,bonesdata,animdata,anim_offset,animation_names
-    bonesdata = {}
-    animation_names = []
-    animation_num_bones = []
-    animation_num_keys = []
-    animation_loc_keys = []
-    animation_rot_keys = []
-    animdata = {}
-    plik = open(filename,'rb')
-    print (word(20),i(3))
-
-    #-------BONES------
-    #check_armature_for_psa()
-    print (word(20))
-    data = i(3)
-    #print data
-    num_bones = data[2]
-    for m in range(num_bones):
-        bonesdata[str(m)] = []
-        name = word(64)
-        bonesdata[str(m)].append(name)
-        bonesdata[str(m)].append(i(3))
-        bonesdata[str(m)].append(f(11))
-
-
-    #--------ANIMATIONS-INFO
-    print (word(20))
-    data = i(3)
-    #print data
-    for m in range(data[2]):
-        name_animation = word(64)#name animation
-        print("NAME:",name_animation)
-        animation_names.append(name_animation)
-        word(64)#name of owner of animation ?
-        data = i(4)#num bones - 0 - 0 - num keys for all bones for this animation
-        num_bones = data[0] 
-        animation_num_bones.append(num_bones)
-        f(3)
-        data = i(3) 
-        num_keys = data[2]
-        animation_num_keys.append(num_keys)
-    print (plik.tell())
-
-    #--------ANIMATIONS-KEYS
-    print (word(20))
-    data = i(3)
-    #print data
-    anim_offset = {}
-    seek = plik.tell()
-    for m in range(len(animation_names)):
-        anim_name = animation_names[m]
-        anim_bones = animation_num_bones[m]
-        anim_keys = animation_num_keys[m]
-        anim_offset[anim_name] = []
-        anim_offset[anim_name].append(seek)
-        anim_offset[anim_name].append(anim_keys)
-        anim_offset[anim_name].append(anim_bones)
-        seek+=anim_keys*anim_bones*32
-    
-    
-def getInputFilename(self,filename,importmesh,importbone,bDebugLogPSK,importmultiuvtextures):
-    checktype = filename.split('\\')[-1].split('.')[1]
-    print ("------------",filename)
-    if checktype.lower() != 'psk':
-        print ("  Selected file = ",filename)
-        raise (IOError, "The selected input file is not a *.psk file")
-        #self.report({'INFO'}, ("Selected file:"+ filename))
-    else:
-        pskimport(filename,importmesh,importbone,bDebugLogPSK,importmultiuvtextures)
-#import panel
-class IMPORT_OT_psk(bpy.types.Operator):
-    """Load a skeleton mesh psk File"""
-    bl_idname = "import_scene.psk"
-    bl_label = "Import PSK"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_options = {'UNDO'}
-
-    # 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",
-            options={'HIDDEN'},
-            )
-    importmesh = BoolProperty(
-            name="Mesh",
-            description="Import mesh only. (not yet build.)",
-            default=True,
-            )
-    importbone = BoolProperty(
-            name="Bones",
-            description="Import bones only. Current not working yet",
-            default=True,
-            )
-    importmultiuvtextures = BoolProperty(
-            name="Single UV Texture(s)",
-            description="Single or Multi uv textures",
-            default=True,
-            )
-    bDebugLogPSK = BoolProperty(
-            name="Debug Log.txt",
-            description="Log the output of raw format. It will save in " \
-                        "current file dir. Note this just for testing",
-            default=False,
-            )
-    unrealbonesize = FloatProperty(
-            name="Bone Length",
-            description="Bone Length from head to tail distance",
-            default=1,
-            min=0.001,
-            max=1000,
-            )
-
-    def execute(self, context):
-        bpy.types.Scene.unrealbonesize = self.unrealbonesize
-        getInputFilename(self,self.filepath,self.importmesh,self.importbone,self.bDebugLogPSK,self.importmultiuvtextures)
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        wm.fileselect_add(self)
-        return {'RUNNING_MODAL'}  
-#import panel psk	
-class OBJECT_OT_PSKPath(bpy.types.Operator):
-    bl_idname = "object.pskpath"
-    bl_label = "PSK Path"
-    __doc__ = ""
-
-    filepath = StringProperty(
-            subtype='FILE_PATH',
-            )
-    filter_glob = StringProperty(
-            default="*.psk",
-            options={'HIDDEN'},
-            )
-    importmesh = BoolProperty(
-            name="Mesh",
-            description="Import mesh only. (not yet build.)",
-            default=True,
-            )
-    importbone = BoolProperty(
-            name="Bones",
-            description="Import bones only. Current not working yet",
-            default=True,
-            )
-    importmultiuvtextures = BoolProperty(
-            name="Single UV Texture(s)",
-            description="Single or Multi uv textures",
-            default=True,
-            )
-    bDebugLogPSK = BoolProperty(
-            name="Debug Log.txt",
-            description="Log the output of raw format. It will save in " \
-                        "current file dir. Note this just for testing",
-            default=False,
-            )
-    unrealbonesize = FloatProperty(
-            name="Bone Length",
-            description="Bone Length from head to tail distance",
-            default=1,
-            min=0.001,
-            max=1000,
-            )
-    
-    def execute(self, context):
-        #context.scene.importpskpath = self.properties.filepath
-        bpy.types.Scene.unrealbonesize = self.unrealbonesize
-        getInputFilename(self,self.filepath,self.importmesh,self.importbone,self.bDebugLogPSK,self.importmultiuvtextures)
-        return {'FINISHED'}
-        
-    def invoke(self, context, event):
-        #bpy.context.window_manager.fileselect_add(self)
-        wm = context.window_manager
-        wm.fileselect_add(self)
-        return {'RUNNING_MODAL'}
-#import panel psa		
-class OBJECT_OT_PSAPath(bpy.types.Operator):
-    bl_idname = "object.psapath"
-    bl_label = "PSA Path"
-    __doc__ = ""
-
-    filepath = StringProperty(name="PSA File Path", description="Filepath used for importing the PSA file", maxlen= 1024, default= "")
-    filter_glob = StringProperty(
-            default="*.psa",
-            options={'HIDDEN'},
-            )
-    def execute(self, context):
-        #context.scene.importpsapath = self.properties.filepath
-        psaimport(self.filepath)
-        return {'FINISHED'}
-        
-    def invoke(self, context, event):
-        bpy.context.window_manager.fileselect_add(self)
-        return {'RUNNING_MODAL'}
-		
-class OBJECT_OT_Path(bpy.types.Operator):
-    bl_idname = "object.path"
-    bl_label = "MESH BUILD TEST"
-    __doc__ = ""
-    # generic transform props
-    view_align = BoolProperty(
-            name="Align to View",
-            default=False,
-            )
-    location = FloatVectorProperty(
-            name="Location",
-            subtype='TRANSLATION',
-            )
-    rotation = FloatVectorProperty(
-            name="Rotation",
-            subtype='EULER',
-            )
-    def execute(self, context):
-        return {'FINISHED'}
-        
-    def invoke(self, context, event):
-        me = bpy.data.meshes.new("test")
-        obmade = bpy.data.objects.new("TestObject",me)
-        print("Create Simple Mesh")
-        bpy.data.scenes[0].objects.link(obmade)
-        for i in bpy.context.scene.objects: i.select = False #deselect all objects
-        obmade.select = True
-        bpy.context.scene.objects.active = obmade
-        
-        verts = [(0,0,0),(2,0,0),(2,0,2)]
-        edges = [(0,1),(1,2),(2,0)]
-        faces = []
-        faces.extend([(0,1,2,0)])
-        #me.vertices.add(len(verts))
-        #print(dir(me))
-        me.vertices.add(len(verts))
-        me.tessfaces.add(len(faces))
-        for face in me.tessfaces:
-            print(dir(face))
-        
-        me.vertices.foreach_set("co", unpack_list(verts))
-        me.tessfaces.foreach_set("vertices_raw", unpack_list(faces))
-        me.edges.add(len(edges))
-        me.edges.foreach_set("vertices", unpack_list(edges))
-        
-        #print(len(me.tessfaces))
-        me.tessface_uv_textures.new("uvtexture")
-        #for uv in me.tessface_uv_textures:
-            #print(len(uv.data))
-            #print(dir(uv.data[0]))
-            #print(dir(uv.data[0].uv1))
-        return {'RUNNING_MODAL'}
-
-#import menu panel tool bar
-class VIEW3D_PT_unrealimport_objectmode(bpy.types.Panel):
-    bl_space_type = "VIEW_3D"
-    bl_region_type = "TOOLS"
-    bl_label = "Import PSK/PSA"
-    
-    @classmethod
-    def poll(cls, context):
-        return context.active_object
-
-    def draw(self, context):
-        layout = self.layout
-        rd = context.scene
-
-        row2 = layout.row(align=True)
-        row2.operator(OBJECT_OT_PSKPath.bl_idname)                
-        row2.operator(OBJECT_OT_PSAPath.bl_idname)        
-        row2.operator(OBJECT_OT_Path.bl_idname)        
-#import panel
-def menu_func(self, context):
-    self.layout.operator(IMPORT_OT_psk.bl_idname, text="Skeleton Mesh (.psk)")
-
-def register():
-    bpy.utils.register_module(__name__)
-    bpy.types.INFO_MT_file_import.append(menu_func)
-    
-def unregister():
-    bpy.utils.unregister_module(__name__)
-    bpy.types.INFO_MT_file_import.remove(menu_func)
-
-if __name__ == "__main__":
-    register()
-
-#note this only read the data and will not be place in the scene    
-#getInputFilename('C:\\blenderfiles\\BotA.psk') 
-#getInputFilename('C:\\blenderfiles\\AA.PSK')
-#getInputFilename('C:\\blender26x\\blender-2.psk')