first commit on NotABug

1 files changed, 1067 insertions, 0 deletions

diff --git a/collada_bmd_bdl_import.py b/collada_bmd_bdl_import.py
new file mode 100644
index 0000000..9187193
--- /dev/null
+++ b/collada_bmd_bdl_import.py
@@ -0,0 +1,1067 @@
+'''
+just a DAE importer for SuperBMD DAEs
+it loads the said DAE files with the default importer and the extension re-builds 
+the armature and mesh skinning. Done because Blender's 2.79 Collada importer
+can miss armature stuff when importing (not all the time). It also lets
+you select the type of pose you want in the armature when imported in Blender
+
+For my mental sanity this importer is only for SuperBMD files
+Blender 2.79 deals with armature data on Collada files in an 
+extremely poorly way. Hopefully in the future I can make my own
+Collada importer (epik project >:]).
+'''
+
+import bpy, math, re
+from mathutils import Matrix, Vector
+from numpy import array 
+# ^ needed for converting an array to the correct type
+
+# Notes (AFAIK):
+
+# - bind shape matrix or BSM: matrix that tells the position of 
+#   a mesh with respect to the armature origin so it is in the
+#   correct position for the bone it is assigned to.
+# - inverse bind matrix or IBM: matrix located at the skin section of
+#   the collada file. The inverse of this matrix, the bind matrix,
+#   describes a bone position with respect to the armature origin when the 
+#   meshes were assigned to the bones (shows on Blender in the 
+#   bind_mat custom property for the bones of an armature). Bind matrices
+#   are the ones that show on Blender when loading a model. This matrix
+#   is the reference matrix used to when vertex weighted agaisnt a bone
+#   are moved by it in an animation
+# - rest matrix: matrix found on the armature section of the collada
+#   file. It describes a bone position with respect to its parent bone
+#   at the moment the armature was edited (after the skinning) to get
+#   the model rest pose (t-pose stuff, for animation purposes). Shows
+#   on Blender on the rest_mat custom property for the bones of an armature.
+# - All matrices read by Blender assume that the rotation system located in
+#   each 4x4 matrix is in the extrinsic Euler XYZ system
+
+################################################
+# get_bone_rest_matrix function
+# function to:
+# - calculate final rest matrix of a single bone
+################################################
+def calculate_rest_matrix(rest_matrices, row_pos, bone_parenting_diagram):
+  
+  # acumulate transformation matrices while reading bone_parenting_diagram
+  # reading is done from the child bone to the ultimate parent bone
+  # final matrix will be initialized with current bone matrix from rest_matrices
+  final_matrix = rest_matrices[row_pos]
+  
+  # bone position on bone_parenting_diagram will be found in the next for loop
+  bone_parenting_pos = 0  
+  
+  for number in range(len(bone_parenting_diagram[row_pos])):
+    if (bone_parenting_diagram[row_pos][number] == 1):
+      bone_parenting_pos = number
+      break
+  
+  # with bone position on bone_parenting_diagram now it is time to read said
+  # array from bottom to top searching for each consecutive parent of said bone
+  # for a single bone, its parent is on the row the first "1" is found 
+  # that is 1 position left from said bone in its row
+  
+  # example:
+  #         |
+  #         v
+  # bone 1 [1, 0, 0]  row 1
+  # bone 2 [0, 1, 0]  row 2
+  # bone 3 [0, 1 ,0]  row 3
+  #            ^  
+  #            |            
+  # bone 3's parent is bone 1
+  
+  # set 2 for loops to read the array from down to top and right to left >:]
+  # first loop on each for loop is skipped
+  
+  # variable to be used on inner loop
+  current_row = row_pos
+  
+  for parenting_pos in range(bone_parenting_pos, -1, -1):
+    
+    # first loop is skipped
+    if (parenting_pos == bone_parenting_pos):
+      continue
+    
+    for row_number in range(current_row, -1, -1):
+      
+      # first loop is skipped
+      if (row_number == row_pos):
+        continue
+      
+      # if element found is 0 go up one row
+      # if element found is 1 grab transformation matrix from rest_matrices
+      # perform multiplication, store row_number for the next inner loop
+      # then break out of the inner loop      
+      if (bone_parenting_diagram[row_number][parenting_pos] == 0):        
+        continue
+      
+      # bone_parenting_diagram[row_number][parenting_pos] == 1 returns True
+      else:        
+        # acumulate transformation matrices
+        final_matrix = rest_matrices[row_number] * final_matrix
+        
+        # set new row for the next time the inner loop is executed        
+        current_row = row_number
+        break
+  #
+  
+  return final_matrix
+
+
+###############################################
+###############################################
+# read_bmd_bdl_collada function (MAIN FUNCTION)
+# read superbmd/blenxy collada file
+# used to import the collada file into Blender
+###############################################
+###############################################
+def read_bmd_bdl_collada(context, filepath, debug_messages, show_armature_pose):   
+  
+  ###################
+  # importing section
+  ###################
+  
+  # scene variable is always needed for something
+  scene = bpy.context.scene
+  
+  print("\nImporting Collada file used in BMD/BDL conversion...\n")
+
+  # import collada in the standard way (blender importer, with no flags)
+  bpy.ops.wm.collada_import(filepath=filepath)
+  
+  print("\nCollada file (DAE) imported.")
+  
+  # initialize armature variable
+  armature = scene.objects.active
+  
+  # search the armature of the imported model
+  # Collada importer selects a child of the armature
+  # if only an armature is immported then the Collada
+  # importer selection is already the armature object
+  if (scene.objects.active.type != "ARMATURE"):
+    armature = scene.objects.active.parent
+  
+  # deselect everything
+  bpy.ops.object.select_all(action='DESELECT')
+  scene.objects.active = None  
+  
+  # select and make active the armature
+  armature.select = True
+  scene.objects.active = armature
+    
+  
+  ###########################
+  # get armature data section
+  # from Collada file
+  ###########################
+  
+  print("Getting Armature data...")
+  
+  # open DAE file
+  f = open(filepath, 'r', encoding='utf-8')
+  
+  # I need the bind matrices and rest matrices from the armature bones
+  # also the bind shape matrix for each mesh
+  
+  # bind matrices are in the library_controllers section of the Collada file
+  # the inverse of them to be specific
+  # each mesh that is assigned to a vertex group (and consequently to a bone)
+  # has an inverse bind matrix for said bone. By inversing that matrix I get the
+  # bind matrix for the bone. This matrix is the one that should be applied to
+  # the bones on Blender.
+  
+  # rest matrices are in the library_visual_scenes section (matrices relative 
+  # to each bone) and they are used in the animation process. 
+  # If a bone does not have an inverse bind matrix on any mesh then 
+  # the matrix used to position the bone on blender is pulled from here 
+  # (the multiplication of the parent's rest matrices + the bone rest matrix).
+  
+  
+  #########################################################
+  # infinite loop to get to the skin section of the collada
+  #########################################################
+  while True:  
+    line = f.readline()
+    
+    # find() returns -1 if it does not find anything on a string
+    # 0 is equivalent to False
+    if (line.find("<library_controllers>") + 1):
+      break
+  
+  
+  #############################
+  # library_visual_scenes start
+  #############################
+  
+  # controller_data will be used to store the mesh id, its bind shape matrix
+  # and bone names with their inverse bind pose matrix one mesh per row
+  # as follows:
+  
+  # row 1: mesh 1 id, BSM, bone 1 name, IBM of bone 1, bone 2 name, IBM of bone 2, ...
+  # row 2: mesh 2 id, BSM, bone a name, IBM of bone a, bone b name, IBM of bone b, ...
+  #   .
+  #   .
+  #   .
+  
+  controller_data = [[]]
+  
+  # variables to keep track of the crontroller data length
+  i = -1 # for number of rows
+  
+  #######################################################
+  # infinite loop to read the library_controllers section
+  #######################################################
+  while True:
+  
+    line = f.readline()    
+    
+    #########################
+    # controller start
+    # the skin stuff for each 
+    # mesh is defined there
+    #########################
+    if (line.find("<controller") + 1):
+    
+      i = i + 1
+      
+      # for the first mesh there is already a row in controller_data
+      if (i != 0):
+        controller_data.append([])      
+      
+      # get mesh id
+      mesh_id = re.search('id="(.+?)"', line).group(1)
+      controller_data[i].append(mesh_id)
+      
+    
+    ##############################################
+    # bind shape matrix from current mesh on row i
+    ##############################################
+    elif (line.find("<bind_shape_matrix>") + 1):
+      k = 0
+      temp_rest_matrices = []
+      
+      while (k < 4):
+        temp_array = [0, 0, 0, 0]
+        line = f.readline()
+        temp_array = line.split()
+        temp_array = [float(string) for string in temp_array]
+        l = 0
+        
+        # fill temp_rest_matrices with a row
+        while (l < 4):
+          temp_rest_matrices.append(temp_array[l])
+          l = l + 1
+        
+        k = k + 1
+      
+      # created "a" so the next matrix assignation is more readable
+      a = temp_rest_matrices       
+      matrix = Matrix(( [a[0],  a[1],  a[2],  a[3]],
+                        [a[4],  a[5],  a[6],  a[7]],
+                        [a[8],  a[9],  a[10], a[11]],
+                        [a[12], a[13], a[14], a[15]]
+                          ))
+      
+      controller_data[i].append(matrix)
+    
+    
+    ########################################################
+    # Name_array start
+    # the names of the bones to which the mesh was assigned 
+    # to are here. Next to this section a few lines down the 
+    # collada file there is the float_array section that has
+    # the inverse bind matrices for each bone of Name_array 
+    ########################################################
+    elif (line.find("<Name_array") + 1):
+      
+      # line were the bone names are
+      line = f.readline()
+      
+      # store bone names in temp_bones
+      temp_bones = []
+      temp_bones = line.split()
+      
+      # skip the lines until float_array appears
+      while True:
+        line = f.readline()
+        if(line.find("<float_array") + 1):
+          break
+      
+      
+      ###################
+      # float_array start
+      ###################
+      
+      # read a 4x4 matrix, store it on temp_array_matrices
+      # then create a matrix and append the matrix with the
+      # respetive bone on controller_data[i]
+      
+      # to store matrices
+      temp_matrices = []
+      
+      while True:
+        
+        # to store a matrix in the form of an array
+        temp_array_matrix = []
+        
+        # will store the numbers as strings first on temp_array_matrix
+        k = 0
+        while (k < 4):
+          line = f.readline()
+          
+          for number in line.split():
+            temp_array_matrix.append(float(number))
+          
+          k = k + 1
+        
+        # created "a" so the next matrix assignation is more readable
+        a = temp_array_matrix        
+        # build matrix
+        temp_matrix = Matrix((  [a[0],  a[1], a[2], a[3]],
+                                [a[4],  a[5], a[6], a[7]],
+                                [a[8],  a[9], a[10],a[11]],
+                                [a[12], a[13],a[14],a[15]]
+                                  ))
+        
+        # append matrix to temp_matrices
+        temp_matrices.append(temp_matrix)  
+        
+        # after reading a matrix there is either
+        # - a blank line (another matrix starts next)
+        # - the end of float_array
+        
+        line = f.readline()
+                
+        if (line.find("</float_array>") + 1):
+          
+          # assign all bone names and its matrices to controller_data[i]
+          for k in range(len(temp_bones)):
+            controller_data[i].append(temp_bones[k])
+            controller_data[i].append(temp_matrices[k])
+          
+          # end of the Name_array and float_array section
+          break
+    
+    
+    ####################################
+    # end of library_controllers section
+    ####################################
+    elif (line.find("</library_controllers>") + 1):
+      break
+  
+  
+  ######################
+  # controller data view
+  ######################
+  
+  if (debug_messages):  
+    for mesh in controller_data:
+      print("\nrow start")
+      for element in mesh:
+        print(element)
+    print()
+  
+  
+  #############################
+  # library_visual_scenes start
+  #############################
+  
+  line = f.readline()
+  
+  if not (line.find("<library_visual_scenes>") + 1):
+    print("DAE file contains an incompatible skin section structure for this importer. Check the file and try again.")
+    # end importer    
+    return {'FINISHED'}
+  
+  line = f.readline() # contains visual_scene start
+  
+  # the next 2 lines have the armature name and tranformation matrix
+  # respectively, so I will store those separately from the bone's data
+  
+  line = f.readline()  
+  armature_name = name = re.search('name="(.+?)"', line).group(1)
+  
+  line = f.readline()
+  armature_matrix_string = re.search('<matrix.*>(.*)</matrix>', line).group(1).split()
+  
+  # created "a" so the next matrix assignation is more readable
+  a = [float(string) for string in armature_matrix_string]
+  armature_matrix = Matrix((  [a[0], a[4], a[8],  a[12]],
+                              [a[1], a[5], a[9],  a[13]],
+                              [a[2], a[6], a[10], a[14]],
+                              [a[3], a[7], a[11], a[15]]
+                                ))
+  
+  ###########
+  # bone data
+  ###########
+  
+  # infinite loop to read this section
+    # all bone names will be stored in bones_array (as they show on the DAE file)
+    # all the matrices will be stored in rest_matrices (as they show on the DAE file)
+      # in this way the bones_array[i] bone rest matrix will be rest_matrices[i]
+    # to check tag start/end bone_tag_check will be used
+      # when <node> tag is reached the bone name related to that tag will be stored
+      # in bone_tag_check, then, if </node> tag is reached whatever bone is at the
+      # end of the bone_tag_check gets banished (like a stack)
+        # in this way I can get parent bones more easily for complex bone structures
+  
+  bones_array = []    
+  rest_matrices = []   
+  bone_tag_check = []
+  
+  # the following array will be used to "draw" bone parenting
+  # each row will represent a bone and it will be filled with zeros from left to right
+  # until a position (position defined by the bone name position in bones_array) in
+  # which there will be a 1. In this way I can get a visual diagram to get the bone
+  # parenting for if I need to rebuild it later in the program
+  
+  bone_parenting_diagram = [[]]
+  
+  i = -1  # position of the last element on bones_array and rest_matrices   
+  j = -1  # position of the last non_empty element on bone_tag_check
+  
+  # ^ initialized to -1 so the while loop from below is more convinient
+  
+  #########################################################
+  # infinite loop section
+  # exit condition is when j = -1 (bone_tag_check is empty)
+  #########################################################
+  
+  while True:
+    
+    line = f.readline()
+        
+    
+    ############
+    # node start
+    ############
+    if (line.find("<node ") + 1):
+      
+      # new bone, new matrix, new element in bone_tag_check
+      i = i + 1
+      j = j + 1
+      
+      # bone name
+      bone_name = re.search('name="(.+?)"', line).group(1)      
+      bones_array.append(bone_name)
+      
+      # bone tag check
+      if (j >= len(bone_tag_check)):
+        bone_tag_check.append(bone_name)
+      else:
+        bone_tag_check[j] = bone_name
+        
+      # bone parenting diagram
+      if (i == 0):      
+        bone_parenting_diagram[0] = [1]
+      else:
+        bone_parenting_diagram.append([])
+        for k in range(j):
+          bone_parenting_diagram[i].append(0)
+        bone_parenting_diagram[i].append(1)      
+            
+    
+    ##################
+    # matrix from node
+    ##################
+    elif (line.find("<matrix ") + 1):
+    
+      # store contents of matrix tag in an array
+      # transform array to float type then to a 4x4 matrix
+      bone_matrix_string_array = re.search('<matrix.*>(.*)</matrix>', line).group(1).split()
+      # created "a" so the next matrix assignation is more readable
+      a = [float(string) for string in bone_matrix_string_array]
+      bone_matrix = Matrix(([a[0],  a[1],   a[2],  a[3]],
+                            [a[4],  a[5],   a[6],  a[7]],
+                            [a[8],  a[9],   a[10], a[11]],
+                            [a[12], a[13],  a[14], a[15]]
+                              ))
+                              
+      rest_matrices.append(bone_matrix)
+      
+      
+    ##########
+    # node end
+    ##########
+    elif (line.find("</node>") + 1):
+      
+      # empty element bone_tag_check[j]
+      # decrease j by 1
+      bone_tag_check[j] = ""
+      j = j - 1
+    
+    
+    #####################################
+    # what kind of DAE file I am reading?
+    #####################################
+    else:
+      
+      # if the collada file contains a different structure than the usual
+      # for the armature section just end the importer and print text error text
+      print("DAE file contains an incompatible armature section structure for this importer. Check the file and try again.")
+      return {'FINISHED'}
+    
+    
+    ###########
+    # exit loop
+    ###########
+    if (j == -1):
+      break
+   
+  
+  ##############
+  # post process
+  
+  # finalize filling with zeros the rows of the bone_parenting_diagram  
+  final_row_length = len(bone_tag_check)
+  
+  for row in bone_parenting_diagram:
+    for l in range(final_row_length - len(row)):
+      row.append(0)  
+  
+  
+  ####################
+  # armature data view
+  ####################
+  
+  if (debug_messages):
+    print("Bone Names")
+    print()
+    print(bones_array)
+    print()
+    print("Rest Matrices")
+    print()
+    for rest_mat in rest_matrices:
+      print(rest_mat)
+    print()
+    print("Bone tag check (empty = good)")
+    print("number of columns must match the bone\nparenting diagram number of columns")
+    print()
+    print(bone_tag_check)
+    print()
+    print("Bone Parenting Diagram")
+    print()
+    for bone in bone_parenting_diagram:
+      print(bone)
+    print()
+  
+  
+  ##########################
+  # re-ordering data section
+  ##########################
+  
+  # this section is to fill 2 big and important arrays
+  # with all the data read from above
+  # - bind_matrices will hold all bone bind matrices for each bone (from the skin read)
+  #   the inverse of the ones read to be specific. Will use the rest matrix from the 
+  #   armature section of the Collada if the bone does not have an IBM defined
+  # - final_rest_matrices will hold all bone rest matrices (armature section of 
+  #   the collada) matrices will be calculated with calculate_rest_matrix() 
+  #   function for each bone
+  
+  # the matrices will be in the ordered as the bone names on bone_names
+  
+  bind_matrices = []
+  final_rest_matrices = []
+  
+  # will be used to tell if a bone had defined a bind matrix and a rest matrix
+  # checking if a bone has a bind matrix is enought
+  has_bind_rest = []
+  
+  # rest_matrices will be filled first and bind_matrices after  
+  
+  #####################
+  # final_rest_matrices
+  for i in range(len(bones_array)):
+    final_rest_matrices.append(calculate_rest_matrix(rest_matrices, i, bone_parenting_diagram))
+    
+  ###############
+  # bind_matrices
+  for i in range(len(bones_array)):
+    
+    # loop through each element of the controller_data array 
+    # to find all the bone's inverse bind matrices available
+    
+    bone_found = False
+    
+    for row in range(len(controller_data)):
+      for col in range(len(controller_data[row])):
+        if (bones_array[i] == controller_data[row][col]):
+          bind_matrices.append(controller_data[row][col + 1].inverted())
+          has_bind_rest.append(True)
+          bone_found = True
+          break
+      
+      if (bone_found):
+        break
+    
+    # if a bone has not been found
+    # assign final rest matrix of said bone from final_rest_matrices
+    if not (bone_found):
+      bind_matrices.append(final_rest_matrices[i])
+      has_bind_rest.append(False)
+   
+      
+  ##############################################
+  # bind, rest and final rest matrices data view
+  ##############################################
+  
+  if (debug_messages):
+    print("Bone Names")
+    print()
+    print(bones_array)
+    
+    print("\nBind Matrices\n")
+    for bind_mat in bind_matrices:
+      print(bind_mat)
+    
+    print("\nRest Matrices\n")
+    for rest_mat in rest_matrices:
+      print(rest_mat)
+    
+    print("\nFinal Rest Matrices\n")
+    for final_rest_mat in final_rest_matrices:
+      print(final_rest_mat)
+    
+    print("\nBone has both Matrices defined in Collada")  
+    print()
+    print(bones_array)
+    print(has_bind_rest)
+    print()
+    
+  ##########################
+  # Rebuild armature section
+  ##########################
+  
+  # for this I will create a different armature object with all the bones
+  # and then link all the meshes from the imported model into this armature
+  # at the end the original imported armature will be deleted.
+  
+  print("Attempting re-build...")
+  
+  # change to object mode  
+  bpy.ops.object.mode_set(mode='OBJECT')
+  
+  # deselect everything
+  bpy.ops.object.select_all(action='DESELECT')
+  scene.objects.active = None
+  
+  # store old armature object
+  armature_old = armature
+  
+  # create new armature
+  bpy.ops.object.armature_add(location=(0.0, 0.0, 0.0))
+  armature = scene.objects.active
+  # change its name
+  armature.name = armature_old.name + "_new" 
+  
+  # apply transformation matrix of armature old into new armature
+  armature.matrix_world = armature_matrix
+  
+  # enter edit mode
+  bpy.ops.object.mode_set(mode='EDIT')
+  
+  # create, apply transformation matrix and parent all bones in a 
+  # column of the bone_parenting_diagram array (those at the "same parenting level")
+  # elements in bone_parenting_diagram are bone_parenting_diagram[i][j]
+  
+  for j in range(len(bone_parenting_diagram[0])):
+    for i in range(len(bone_parenting_diagram)):
+      
+      # first bone (position [0][0]) is already created
+      # I assume there is one bone that is the main bone
+      if (i == 0):
+        armature.data.edit_bones[0].name = bones_array[0]
+        armature.data.edit_bones[0].matrix = bind_matrices[0]
+        continue
+      
+      ##################################
+      # for the columns next to column 0
+      ##################################
+       
+      # current position does not have a bone
+      if (bone_parenting_diagram[i][j] == 0):
+        continue
+        
+      # bone_parenting_diagram[i][j] == 1 returns True
+      # bone found, create it and assign name
+      bpy.ops.armature.bone_primitive_add(name = bones_array[i])  
+      
+      # find parent bone
+      # read the rows above the bone row to find its parent
+      # it is located at the column next to it (one column left)
+      # second argument in range() is -1 as I need a loop on k = 0
+      
+      for k in range(i, -1, -1):
+        
+        # make k 1 less than i (row adjustment)
+        if (k >= i):
+          continue
+        
+        # start reading the column next to bone column (left column)
+        # Find the nearest 1 on said column (parent bone) 
+        if (bone_parenting_diagram[k][j - 1] == 0):
+          continue
+        
+        # bone_parenting_diagram[k][j - 1] == 1 returns True --> parent bone found
+        
+        # assign bone parent         
+        armature.data.edit_bones[bones_array[i]].parent = armature.data.edit_bones[bones_array[k]]
+        
+        # and more length to the bone (visual stuff, non-important)
+        armature.data.edit_bones[bones_array[i]].length = 10
+        
+        # apply transformation matrix (bind matrix)
+        armature.data.edit_bones[bones_array[i]].matrix = bind_matrices[i]
+        
+        break  
+  
+  # leave edit mode
+  bpy.ops.object.mode_set(mode='OBJECT')
+  
+  # assign bone custom properties only to bones that have
+  # both bind and rest matrices defined in the collada file
+  for i in range(len(bones_array)):
+    
+    # only check bones that have a bind matrix
+    if (has_bind_rest[i]):
+      
+      # Note: custom property matrices bind_mat and rest_mat are column written
+      
+      # create bind_mat custom property 
+      # Note: by using Blender's FloatVectorProperty I get 
+      #       a custom property that can't be edited through GUI 
+      #       (API Defined, but it works well on the bind/rest_mat export)
+      #       can be edited if exporting the model as DAE and then
+      #       re-importing after closing and re-openning Blender
+      
+      # create rest_mat custom property (Blender's FloatVectorProperty)
+      # bpy.types.Bone.rest_mat = bpy.props.FloatVectorProperty(
+                                          # name="rest_mat",
+                                          # size=16,
+                                          # subtype="MATRIX"
+                                          # )
+      
+      # bind matrix for bone
+      a = bind_matrices[i].transposed()
+      temp_array = [a[0][0], a[0][1], a[0][2], a[0][3],
+                    a[1][0], a[1][1], a[1][2], a[1][3],
+                    a[2][0], a[2][1], a[2][2], a[2][3],
+                    a[3][0], a[3][1], a[3][2], a[3][3]] 
+      
+      # convert temp_array to the right type with numpy
+      temp_array = array(temp_array, dtype = 'f')
+      
+      armature.data.bones[bones_array[i]]["bind_mat"] = temp_array
+      
+      # rest matrix for bone
+      a = rest_matrices[i].transposed()
+      temp_array = (a[0][0], a[0][1], a[0][2], a[0][3],
+                    a[1][0], a[1][1], a[1][2], a[1][3],
+                    a[2][0], a[2][1], a[2][2], a[2][3],
+                    a[3][0], a[3][1], a[3][2], a[3][3])
+      
+      # convert temp_array to the right type with numpy
+      temp_array = array(temp_array, dtype = 'f')
+      
+      armature.data.bones[bones_array[i]]["rest_mat"] = temp_array
+      
+      # Note: ^ if I don't convert temp_array to the right type and
+      #       just assign it to the custom property, the exported matrices
+      #       will contain weird data (no clue why that happens)
+              
+  
+  # armature has finished being built
+  print("Re-build done!")
+  
+  # assign meshes from old armature into new armature
+  # also reconect mesh's armature modifiers to the new armature
+  for child_mesh in armature_old.children:
+    child_mesh.parent = armature
+    child_mesh.modifiers["Armature"].object = armature
+  
+  # rename new armature with old armature's name
+  armature.name = armature_old.name
+  
+  
+  ###############
+  # final section
+  ###############
+  
+  # change back to object mode  
+  bpy.ops.object.mode_set(mode='OBJECT')
+  
+  # deselect everything
+  bpy.ops.object.select_all(action='DESELECT')
+  scene.objects.active = None
+      
+  # select old armature
+  armature_old.select = True
+  scene.objects.active = armature_old    
+      
+  # delete old armature
+  # it has been an honor :saluting_face:
+  bpy.ops.object.delete(use_global = False)
+    
+  # select new armature again
+  armature.select = True
+  scene.objects.active = armature
+  
+  ########################
+  # apply pose to armature
+  ########################
+  
+  print("Generating Armature poses...")
+    
+  # already have done the bind pose from the steps above
+  # so end the importer if the bind pose is the pose 
+  # is the one wanted to be applied to the bones of the armature
+  if (show_armature_pose == "OPT_A"):
+    print("Bind Pose done!")
+  
+  # ^ if that is not the case then I have to build again the
+  # armature for the rest pose and the ignore rest pose
+  # but this time I have to deform manually the meshes so they are
+  # correct for the animation imports
+  
+  # Note: for some reason Mario's mesh has a deformation
+  #       in the Hip zone after these vertex transformation
+  
+  # rest pose/ignore rest pose build
+  else:
+  
+    # change to edit mode
+    bpy.ops.object.mode_set(mode='EDIT')
+    
+    # build the rest pose/ignore rest pose on the bones 
+    # of the armature (edit_bones, does not matter applying order)
+    # use final_rest_matrices for rest pose
+    # use rot_90_deg_mat for ignore rest pose
+    for i in range(len(armature.data.edit_bones)):
+    #    
+        # get edit_bone
+        edit_bone = armature.data.edit_bones[i]
+        
+        if (show_armature_pose == "OPT_B"):        
+          # rotate matrix (use )
+          matrix = final_rest_matrices[i]
+          
+        elif (show_armature_pose == "OPT_C"):        
+          # rotate matrix (all of the bones on ignore 
+          # rest pose are in the same place)
+          matrix = Matrix(( [1, 0, 0, 0],
+                            [0, 1, 0, 0],
+                            [0, 0, 1, 0],
+                            [0, 0, 0, 1]
+                              ))
+          
+        # assign matrix
+        edit_bone.matrix = matrix
+    #
+    
+    # deform mesh according to the rest pose
+    # of the armature a vertex at a time
+    for mesh in armature.children:
+    #      
+      # get all vertex groups on the mesh
+      # its index and name
+      mesh_vertex_groups = [[], []]
+      for vertex_group in mesh.vertex_groups:
+        mesh_vertex_groups[0].append(vertex_group.index)
+        mesh_vertex_groups[1].append(vertex_group.name)
+      
+      for vertex in mesh.data.vertices:
+      #  
+        # get vertex in armature's reference system
+        # and as a vector to be able to be multiplied by matrices
+        vertex_vector = Vector(([ vertex.co[0],
+                                  vertex.co[1],
+                                  vertex.co[2]]
+                                    ))
+        
+        # final vertex position variable
+        final_vertex_vector = Vector(([0, 0, 0]))
+        
+        # get the sum of the weights of this vertex on all
+        # vertex groups, the individual weights on each group
+        # and the vertex group index
+        # leave extra row on vertex_vertex_groups to store 
+        # the vertex group names for later
+        weight_sum = 0
+        vertex_vertex_groups = [[], [], []]    
+        for vertex_group in vertex.groups:
+          vertex_vertex_groups[0].append(vertex_group.group)
+          vertex_vertex_groups[1].append(vertex_group.weight)
+          weight_sum = weight_sum + vertex_group.weight
+        
+        # iterate through each bone this vertex is linked to
+        # and apply the "skinning formula" AFAIK
+        
+        # this formula is as follows:
+        
+        # for a bone with a bind matrix (the matrix that describes the bone position
+        # without deforming the mesh, respect to armature) and a pose matrix (the
+        # position the bone has when the mesh deforms, with respect to armature)
+        # that influences a vertex with armature coordinates v and relative 
+        # weight w for said bone the final position of the vertex for said
+        # bone movement is
+        
+        # v_final_for_bone = inverse_bind_mat * bone_pose_matrix * v * w
+        
+        # were w is the fraction of the weight of the vertex on the vertex group
+        # that is linked to the bone divided by the sum of all the weights the vertex
+        # has on all vertex groups it is assigned to
+        
+        # v_final_for_all_bones (the final trasnformation of the vertex that is
+        # got by all the bones that have influence on said vertex) is found by adding
+        # all individual v_final_for_bone vectors (one per bone, all the bones that
+        # influence the vertex)
+        
+        # find the bone names that affect this vertex
+        # and add those to the 3rd row of vertex_vertex_groups
+        # i will be used to go throught a mesh_vertex_groups row
+        # j will ve used to go through a vertex_vertex_groups row
+        i = 0
+        j = 0
+        while (j != len(vertex_vertex_groups[0])):
+        #       
+          # when vertex group is located in mesh_vertex_groups
+          # append vertex group name in vertex_vertex_groups[2] (bone name)
+          # start reading mesh_vertex_groups again to search for the next bone
+          if (mesh_vertex_groups[0][i] == vertex_vertex_groups[0][j]):
+            vertex_vertex_groups[2].append(mesh_vertex_groups[1][i])
+            i = 0
+            j = j + 1
+          
+          i = i + 1
+        #
+          
+        # iterate through each bone that affects this vertex
+        for i in range(len(vertex_vertex_groups[0])):
+        #                    
+          # get bone and its index
+          bone = armature.data.bones[vertex_vertex_groups[2][i]]
+          bone_index = 0
+          for j in range(len(armature.data.bones)):
+            if (vertex_vertex_groups[2][i] == armature.data.bones[j].name):
+              bone_index = j
+              break            
+          
+          # do the proper multiplication of the influence of 
+          # each bone on the vertex and sum the resulting vectors          
+          # inverse_bind_mat is got from bind_matrices
+          # bone_pose_matrix will be the final_rest_matrices (for rest pose)
+          # or the identity matrix (for ignore rest pose)
+          bind_matrix = bind_matrices[bone_index]
+          inv_bind_matrix = bind_matrix.inverted()
+          
+          if (show_armature_pose == "OPT_B"):
+          
+            bone_pose_matrix = final_rest_matrices[bone_index]
+          
+          elif (show_armature_pose == "OPT_C"):
+            
+            bone_pose_matrix = Matrix(( [1, 0, 0, 0],
+                                        [0, 1, 0, 0],
+                                        [0, 0, 1, 0],
+                                        [0, 0, 0, 1]
+                                          ))
+          
+          final_vertex_vector = final_vertex_vector + (inv_bind_matrix * bone_pose_matrix * vertex_vector * (vertex_vertex_groups[1][i] / weight_sum))
+        #
+          
+        # apply final_vertex_vector to vertex   
+        # in armature reference system     
+        vertex.co = final_vertex_vector        
+      #
+    #
+  
+  # scale down and rotate the armature
+  armature.scale = (0.01, 0.01, 0.01)
+  armature.rotation_euler[0] = math.radians(90)   
+  
+  # apply scale to armature
+  bpy.ops.object.mode_set(mode='OBJECT')
+  bpy.ops.object.transform_apply(location=False, rotation=True, scale=True)  
+  
+  # apply scale to all meshes on armature
+  for mesh in armature.children:
+    mesh.select = True
+    scene.objects.active = mesh
+    bpy.ops.object.transform_apply(location=False, rotation=True, scale=True)
+    mesh.select = False
+    scene.objects.active = None
+    
+  # select armature again
+  armature.select = True
+  scene.objects.active = armature
+  
+  if (show_armature_pose == "OPT_B"):
+    print("Rest Pose done!")
+  elif (show_armature_pose == "OPT_C"):
+    print("Ignore Rest Pose done!")
+  
+  # end importer
+  return {'FINISHED'} 
+
+
+#################################################
+# Stuff down is for the menu appending
+# of the importer to work plus some setting stuff
+# comes from a Blender importer template
+#################################################
+
+# ExportHelper is a helper class, defines filename and
+# invoke() function which calls the file selector.
+from bpy_extras.io_utils import ExportHelper
+from bpy.props import StringProperty, BoolProperty, EnumProperty
+from bpy.types import Operator
+
+
+class Import_BMD_BDL_Collada(Operator, ExportHelper):
+    """Import a Collada file from SuperBMD (SuperBMD only)"""
+    bl_idname = "import_scene.collada_bmd_bdl"
+    bl_label = "Import Collada (from SuperBMD)"
+
+    # ExportHelper mixin class uses this
+    filename_ext = ".dae"
+
+    filter_glob = StringProperty(
+            default="*.dae",
+            options={'HIDDEN'},
+            maxlen=255,
+            )
+
+    # option to show messages on terminal of the bone importing process
+    debug_messages = BoolProperty( name = "Display debug messages",
+                                description = "Display armature data as it is read",
+                                default = False,
+                              )
+    
+    # option to allow users define the pose of the armature that is shown on Blender
+    show_armature_pose = EnumProperty(
+      name="Armature Pose",
+      description="Pose to load on Blender for the imported armature",
+      items=( ('OPT_A', "Bind Pose", "Show Armature on Bind Pose"),
+              ('OPT_B', "Rest Pose", "Show Armature on Rest Pose"),
+              ('OPT_C', "Ignore Rest Pose", "Show Armature as on SMG when an empty BCK animation is applied to it. WARNNING: for complex armature models bone deformations on mesh wont be accurate (it is unknown why)")),
+              default='OPT_B',
+                )
+
+    def execute(self, context):
+        return read_bmd_bdl_collada(context, self.filepath, self.debug_messages, self.show_armature_pose)
+
+
+# Only needed if you want to add into a dynamic menu
+def menu_import_bmd_bdl_collada(self, context):
+    self.layout.operator(Import_BMD_BDL_Collada.bl_idname, text="Collada (from SuperBMD) (.dae)")
+
+bpy.utils.register_class(Import_BMD_BDL_Collada)
+bpy.types.INFO_MT_file_import.append(menu_import_bmd_bdl_collada)
+
+
+# test call
+bpy.ops.import_scene.collada_bmd_bdl('INVOKE_DEFAULT')