CSV exporter update

1 files changed, 341 insertions, 182 deletions

diff --git a/csv_anim_bck_export.py b/csv_anim_bck_export.py
index a1eeaa3..9451507 100644
--- a/csv_anim_bck_export.py
+++ b/csv_anim_bck_export.py
@@ -3,8 +3,9 @@ CSV exporter for the BCK animation type
 CSV to be used with the j3d animation editor program
 '''
 
-import bpy, math
+import bpy, math, re
 from mathutils import Matrix
+from .my_functions import *
 
 # Notes (AFAIK):
 
@@ -12,19 +13,6 @@ from mathutils import Matrix
 #   must be the ones that are relative to its parent bone
 # - Extrinsic Euler XYZ system is the one being used for rotation values.
 # - all animations must start in Frame 0 (starting frame).
-
-################################################
-# ShowMessageBox function
-# show message on screen for errors or warnnings
-# copied this code from a page I saw it in :)
-################################################
-def ShowMessageBox(message = "", title = "Message Box", icon = 'INFO'):
-    
-    def draw(self, context):
-      self.layout.label(text=message)
-    
-    bpy.context.window_manager.popup_menu(draw, title = title, icon = icon)
-
     
 ######################################
 # write_csv_bck (MAIN FUNCTION)
@@ -32,7 +20,10 @@ def ShowMessageBox(message = "", title = "Message Box", icon = 'INFO'):
 # data for the BCK animation type
 # to be used with J3D Animation Editor 
 ######################################
-def write_csv_bck(context, filepath, loop_mode):
+def write_csv_bck(context, filepath, loop_mode, export_mode):
+  
+  # always needed
+  scene = bpy.context.scene
   
   # loop mode variable declaration
   loop_number = 0
@@ -48,267 +39,435 @@ def write_csv_bck(context, filepath, loop_mode):
   elif (loop_mode == "OPT_E"):
     loop_number = 4
   
-  print("Selecting Armature object...")
-  
-  # Get Armature object
-  armature_count = 0
-  for object in bpy.data.objects:
-    if (object.type == "ARMATURE"):
-      armature = object
-      armature_count = armature_count + 1
-  
-  # more than 2 armature objects, print error and end exporter
-  if (armature_count > 1):
-    print("\n### ERROR ###")
-    print("2 or more Armature Objects detected. Animations will only be extracted from one.")
-    print("### ERROR ###\n")
-    ShowMessageBox("2 or more Armature Objects detected. Animations will only be extracted from one.", "Error Exporting CSV File (for BCK)", 'ERROR')
+  # if nothing is selected end the exporter
+  if (scene.objects.active == None
+      or
+      scene.objects.active.type != 'ARMATURE'):
+    error_string = "No Armature object selected. Select one and try again."
+    print("\n### ERROR ###\n" + error_string + "\n### ERROR ###\n")
+    show_message(error_string, "Error exporting collada file", 'ERROR')
     return {'FINISHED'}
   
+  # get armature object
+  armature = scene.objects.active  
+  print()
+  print("###############")
+  print("Armature found: %s" % armature.name)
+  print()
+  
   print("Creating CSV file (for BCK)...")
   
   # open file to write
   f = open(filepath, 'w', encoding='utf-8')
-
-  scene = bpy.context.scene
   
   print("Writing CSV header...")
   
-  # write the "header" of the CSV animation table (for BCK)  
-  f.write("%d,%d,%d,%s" % (loop_number, scene.frame_end, 0, ".bck"))
+  ###############################################
+  # write the "header" of the CSV animation table
+  ###############################################
+  
+  animation_length = scene.frame_end + 1
+  f.write("%d,%d,%d,%s" % (loop_number, animation_length - 1, 0, ".bck"))
   f.write("\n")
   
   f.write("Bone Name,Tangent Interpolation,Component")
 
-  for frame in range(scene.frame_end + 1):
+  for frame in range(animation_length):
     f.write(",Frame %d" % (frame))
   f.write("\n")
   
-  ########################################
-  # read animation data for one bone
-  # then dump the animation data for 
-  # said bone on the CSV file (one by one)
+  ####################################################
+  # get a detailed list of the keyframes used in the 
+  # animation and the bones related to those keyframes 
+  #
+  # bone_kf_data will hold the bone and keyframe position as follows:
+  #
+  # bone name --> name of the animated bone
+  # anim property --> Scale/Rotation/Translation
+  # axis --> 0/1/2 --> X/Y/Z
+  #
+  # a bone name, anim property, axis, kf 1 pos, kf 2 pos, ...
+  # another bone name, anim property, axis, kf 3 pos, kf 4 pos, ...
+  # ...
+  # 
+  # Note that each animation property can have different keyframe positions in time  
+  
+  bone_kf_data = []
+      
+  for i in range(len(armature.animation_data.action.fcurves)):
+  #  
+    # get curve
+    curve = armature.animation_data.action.fcurves[i]    
+    # add new row for given curve in bone_kf_data
+    bone_kf_data.append([])
+    
+    ################################################################
+    # append bone name, animation property and axis related to curve
+        
+    # bone name
+    bone_kf_data[i].append(re.search('\["(.+?)"\]', curve.data_path).group(1))
+    
+    # anim property
+    if (curve.data_path.find("scale") + 1):
+      bone_kf_data[i].append("scale")
+    elif (curve.data_path.find("rotation_euler") + 1):
+      bone_kf_data[i].append("rotation")
+    elif (curve.data_path.find("location") + 1):
+      bone_kf_data[i].append("translation")    
+    # axis
+    if (curve.array_index == 0):
+      bone_kf_data[i].append("x")
+    elif (curve.array_index == 1):
+      bone_kf_data[i].append("y")
+    elif (curve.array_index == 2):
+      bone_kf_data[i].append("z")      
+    
+    # store keyframe data 
+    for j in range(len(curve.keyframe_points)):
+      keyframe = curve.keyframe_points[j]
+      bone_kf_data[i].append(int(keyframe.co[0])) # keyframe pos is an integer (frame)
+  #  
+  
+  # print bone_kf_data to terminal
+  print()
+  for row in bone_kf_data:
+    print(row)
+  
+  ############################################################
+  # get the armature bones that contain 2 or more keyframes
+  # defined (read bone_kf_data) and store at the side of
+  # each bone name the last keyframe position of its animation
+  # 
+  # bone_last_kf_pos will contain data as follows:
+  #
+  # bone1 name, last bone1 keyframe position, bone2 name, last bone2 keyframe position, ...
+  #
+  bone_last_kf_pos = []  
+  for i in range(len(bone_kf_data)):
+  #  
+    if (len(bone_last_kf_pos) != 0):
+      # if the last bone name on bone_last_kf_pos is the same as the
+      # one on bone_kf_data[i][0] go to the column element
+      if (bone_last_kf_pos[len(bone_last_kf_pos) - 2] == bone_kf_data[i][0]):
+        # check if the keyframe position of the bone is larger and store the larger value
+        if (bone_last_kf_pos[len(bone_last_kf_pos) - 1] < bone_kf_data[i][len(bone_kf_data[i]) - 1]):
+          bone_last_kf_pos[len(bone_last_kf_pos) - 1] = bone_kf_data[i][len(bone_kf_data[i]) - 1]
+        continue
+    
+    # bone animation row has more than 1 keyframe on an anim property
+    # append bone name and last keyframe position in time
+    if (len(bone_kf_data[i]) > 4):    
+      bone_last_kf_pos.append(bone_kf_data[i][0])
+      bone_last_kf_pos.append(bone_kf_data[i][len(bone_kf_data[i]) - 1])      
+  #
+  
+  # print bones_with_kf to terminal
+  print()
+  print(bone_last_kf_pos)
+  print()
   
-  # i will be used to track the bones
-  # j to track the frames of the animation   
-  ########################################
+  ###################################################################
+  # read animation data for one bone then dump the animation data for 
+  # said bone on the CSV file
+  ###################################################################
   
-  # for loop to iterate throught each bone
+  ########################
+  # loop through each bone
   for i in range(len(armature.pose.bones)):
-    
-    # get current bone
+  
+    # get bone
     bone = armature.pose.bones[i]
+    # print bone going to be processed on terminal
+    print("Processing animation for bone: %s" % (bone.name))       
     
-    print("Extracting/Writing animation data for bone: %s" % (bone.name))
-    
-    # bone_anim_data will hold the animation data for bone as follows
-    # the row length of bone_anim_data will match the number 
-    # of frames in the animation
+    # store the animation data scale/rotation/translation X/Y/Z on
+    # bone_anim_data which will have 9 rows and each row will be the
+    # length of the animation + 1 (including Frame 0 values)
     
-    #   row 1 --> X scaling
-    #   row 2 --> Y scaling
-    #   row 3 --> Z scaling
-    #   row 4 --> X rotation
-    #   row 5 --> Y rotation
-    #   row 6 --> Z rotation
-    #   row 7 --> X translation
-    #   row 8 --> Y translation
-    #   row 9 --> Z translation
+    # row 1 --> Scale X
+    # row 2 --> Scale Y
+    # row 3 --> Scale Z
+    # row 4 --> Rotation X
+    # row 5 --> Rotation Y
+    # row 6 --> Rotation Z
+    # row 7 --> Translation X
+    # row 8 --> Translation Y
+    # row 9 --> Translation Z
     
-    # already initialized with 9 rows as I don't need more than that
     bone_anim_data = [[], [], [], [], [], [], [], [], []]
     
-    # get the animation length
-    animation_length = scene.frame_end + 1
-        
-    ##########################
-    # read bone animation data
-    ##########################
+    ###############################################################
+    # fill bone_anim_data so the rows have the animation length + 1
+    for j in range(len(bone_anim_data)):
+      for k in range(animation_length):
+        bone_anim_data[j].append("")
     
-    # for loop to iterate throught each frame   
-    for j in range(animation_length):
-    #  
-      # set scene frame
-      scene.frame_set(j)
-      
-      # data will be rounded as follows
-      # - scaling to 2 decimals
-      # - rotation to 1 decimal
-      # - translation to 1 decimal
-      
-      # Note: bone.matrix returns the final transformation matrix of a
-      #       pose.bone with respect to the armature origin and as I 
-      #       need the bone's transformation matrix relative to its 
-      #       parent (bone.parent.matrix.inverted() * bone.matrix) 
-      #       gives the desired result (the bone transformation 
-      #       matrix relative to parent)
+    ###########################################################################
+    # check if the bone has 2 or more keyframes (bone has an animation)
+    # and store the animation length of that bone (read bone_last_kf_pos,
+    # first frame counts on the animation length!, to use later)
+    bone_has_anim = False
+    anim_length_for_bone = 0 + 1
+    for j in range(int(len(bone_last_kf_pos) / 2)):
+    #
+      if (bone_last_kf_pos[2 * j] == bone.name):
+        bone_has_anim = True
+        anim_length_for_bone = bone_last_kf_pos[(2 * j) + 1] + 1                    
+        break
+    #
+    
+    print("Bone has animation? ", end = "")
+    print(bone_has_anim)
+    print("Bone animation length: %d" % (anim_length_for_bone))
+    
+    ###################################################################
+    # if export mode is "only keyframes" define current_bone_kf_data
+    # and get from it all the bone keyframes in each animation property
+    # keyframes on bone_kfs won't necessarily be on order 
+    # (do it on bones that have animation)
+    current_bone_kf_data = []
+    bone_kfs = []
+    if (export_mode == "OPT_B" and bone_has_anim == True):
+    #
+      ##########################################################
+      # store the rows of bone_kf_data in which the current bone
+      # appears in current_bone_kf_data (to use later)
+      current_bone_kf_data = []
+      for j in range(len(bone_kf_data)):
+        if (bone_kf_data[j][0] == bone.name):
+          current_bone_kf_data.append(bone_kf_data[j])
       
-      # first bone must be the outermost bone
-      # and therefore it has no parent   
-      if (i == 0):
+      #################################################
+      # read current_bone_kf_data to get all the unique
+      # keyframe positions of the bone animation
+      for j in range(len(current_bone_kf_data)):
+      #  
+        # store the keyframes found on the first row
+        # of current_bone_kf_data in bone_kfs
+        if (j == 0):
+          for k in range(len(current_bone_kf_data[0])):
+            # make k equal to 3
+            if (k < 3):
+              continue
+            bone_kfs.append(current_bone_kf_data[j][k])
+          
+        # other rows
+        for k in range(len(current_bone_kf_data[j])):
+        # 
+          if (k < 3): # make k equal to 3
+            continue
+          
+          # loop through bone_kfs to check for new keyframe positions
+          keyframe_exists = False
+          for l in range(len(bone_kfs)):
+            if (current_bone_kf_data[j][k] == bone_kfs[l]):
+              keyframe_exists = True
+              break     
+          
+          if (keyframe_exists == False):
+            bone_kfs.append(current_bone_kf_data[j][k])
+        #
+      #
+      # ~ print(current_bone_kf_data)
+      print("Bone's keyframes position:")
+      print(bone_kfs)    
+    #
+    
+    print()
+    
+    # if bone_has_anim equals False only store its first frame animation values
+    # if bone_has_anim equals True store (depending on the export mode) its 
+    # keyframes/all frame animation values (until the last keyframe)
+        
+    ########################################
+    # loop through the animation of the bone
+    # k is used to go through bone_kfs if
+    # export mode is "only keyframes"
+    k = 0
+    for j in range(anim_length_for_bone):
+    #      
+      ##########################################
+      # set scene frame depending on export mode
+      if (export_mode == "OPT_B" and bone_has_anim == True and j != 0):
+      #
+        # check k in case bone_kfs end is reached
+        if (k == len(bone_kfs)):
+          break
+          
+        frame = bone_kfs[k]
+        scene.frame_set(frame)
+        k = k + 1
+      #
+      else:
+      #
+        frame = j
+        scene.frame_set(frame)
+      #
       
+      # first bone must be the outermost bone and therefore it 
+      # has no parent (batman moment, sorry batman u epik >:])
+      if (i == 0):      
         # -90 degree rotation matrix      
-        rot_mat = Matrix((  [1, 0, 0, 0],
-                            [0 , math.cos(-(math.pi/2)), -math.sin(-(math.pi/2)), 0],
-                            [0 , math.sin(-(math.pi/2)), math.cos(-(math.pi/2)), 0],
-                            [0, 0, 0, 1]
-                              ))
-         
-        # bone_relative_to_parent_matrix of the first bone is rotated 
-        # -90 degrees in the X axis as the main bone will use the 
-        # Z axis as the UP axis in the animation instead of Y 
-        # (applying said rotation is done to avoid the issue)
-        # pose.bone.matrix_basis is equal to rot_mat * bone.matrix (AFAIK)
-               
-        bone_relative_to_parent_matrix = rot_mat * bone.matrix
+        rot_mat = calc_rotation_matrix(math.radians(-90), 0, 0)
+        # the first bone has to be rotated -90 degrees 
+        # on X to get correct animation values for it
+        bone_rel_to_parent_mat = rot_mat * bone.matrix      
+      else: # for any other bone
+        bone_rel_to_parent_mat = bone.parent.matrix.inverted() * bone.matrix
       
-      # for any other bone
-      else:
-        bone_relative_to_parent_matrix = bone.parent.matrix.inverted() * bone.matrix
+      ##########################################
+      # extract bone_rel_to_parent_mat anim data
       
       # bone scaling
-      bone_scale = bone_relative_to_parent_matrix.to_scale()
+      bone_scale = bone_rel_to_parent_mat.to_scale()
       # bone rotation (stored in radians, extrinsic XYZ Euler)
-      bone_rotation = bone_relative_to_parent_matrix.to_euler("XYZ")
+      bone_rotation = bone_rel_to_parent_mat.to_euler("XYZ")
       # bone translation (multiplied by 100 because 1 GU is 100 meters)
-      bone_translation = 100 * bone_relative_to_parent_matrix.to_translation()
+      bone_translation = 100 * bone_rel_to_parent_mat.to_translation()
       
+      ##########################################################
+      # store frame animation values of bone into bone_anim_data
+              
       # scaling data
-      bone_anim_data[0].append(round(bone_scale[0], 2))
-      bone_anim_data[1].append(round(bone_scale[1], 2))
-      bone_anim_data[2].append(round(bone_scale[2], 2))
+      bone_anim_data[0][frame] = round(bone_scale[0], 2)
+      bone_anim_data[1][frame] = round(bone_scale[1], 2)
+      bone_anim_data[2][frame] = round(bone_scale[2], 2)
       
       # rotation data (must be in degrees!)
-      bone_anim_data[3].append(round(math.degrees(bone_rotation[0]), 1))
-      bone_anim_data[4].append(round(math.degrees(bone_rotation[1]), 1))
-      bone_anim_data[5].append(round(math.degrees(bone_rotation[2]), 1))  
+      bone_anim_data[3][frame] = round(math.degrees(bone_rotation[0]), 2)
+      bone_anim_data[4][frame] = round(math.degrees(bone_rotation[1]), 2)
+      bone_anim_data[5][frame] = round(math.degrees(bone_rotation[2]), 2)  
       
       # position data
-      bone_anim_data[6].append(round(bone_translation[0], 1))
-      bone_anim_data[7].append(round(bone_translation[1], 1))
-      bone_anim_data[8].append(round(bone_translation[2], 1))
+      bone_anim_data[6][frame] = round(bone_translation[0], 2)
+      bone_anim_data[7][frame] = round(bone_translation[1], 2)
+      bone_anim_data[8][frame] = round(bone_translation[2], 2)
+      
+      # ^ a lot of values can be repeated in each row.
+      # When writing the animation data to the CSV is when
+      # an optimization method will be done
     #
     
+    # ~ for row in bone_anim_data:
+      # ~ print(row)
+    # ~ print()
+    
     ####################################
     # write bone animation data into CSV
     # read bone_anim_data
     ####################################
-    for k in range(9):
+    for j in range(9):
     #    
       # first 3 rows are scaling data
       # the next 3 rows are rotation data
-      # the final 3 rows are translation data
-        
+      # the final 3 rows are translation data        
       # the start of the first row for a bone
       # animation data (Scale X) contains the bone name
-      if (k == 0):
+      if (j == 0):
         f.write("%s,Linear,Scale X:" % (bone.name))
-        
-      # other rows just contain the animation properties
-      elif(k == 1):
+      elif(j == 1):
         f.write(",Linear,Scale Y:")
-      elif(k == 2):
+      elif(j == 2):
         f.write(",Linear,Scale Z:")
-      elif(k == 3):
+      elif(j == 3):
         f.write(",Linear,Rotation X:")
-      elif(k == 4):
+      elif(j == 4):
         f.write(",Linear,Rotation Y:")
-      elif(k == 5):
+      elif(j == 5):
         f.write(",Linear,Rotation Z:")
-      elif(k == 6):
+      elif(j == 6):
         f.write(",Linear,Translation X:")
-      elif(k == 7):
+      elif(j == 7):
         f.write(",Linear,Translation Y:")
-      elif(k == 8):
+      elif(j == 8):
         f.write(",Linear,Translation Z:")
-        
-      # Note: ^ "Linear" is chosen as the animation timing
-      #        has been already set in blender.
-      #       The animation values must be interpreted linearly
-      #       by the game so the animation plays as in Blender
       
       ###################################
       # write animation row data
       # will print values with 2 decimals
       ###################################
-      for l in range(animation_length):
-      #        
+      for k in range(animation_length):
+      #                  
         # get current animation value
-        current_value = bone_anim_data[k][l]
+        current_value = bone_anim_data[j][k]
         
-        # print the first value from row
-        if (l == 0):
-          f.write(",%.2f" % (current_value))          
-        
-        # compare old_value with current_value
-        # if equal leave blank the animation frame value otherwise write said value
-        # this is done to avoid repeating the same number each time
-        elif (old_value == current_value):          
+        # write the first value from row
+        if (k == 0):
+          f.write(",%.2f" % (current_value))
+        # compare old_value with current_value. if equal leave blank the
+        # animation frame value otherwise write said value. This is done
+        # to avoid repeating the same number each time (to save file size)
+        elif (old_value == current_value or current_value == ""):          
           f.write(",")        
         else:
           f.write(",%.2f" % (current_value))
         
         # if the end of a row is reached write a newline char to the line
-        if (l == (animation_length - 1)):
+        if (k == (animation_length - 1)):
           f.write("\n")
         
         # store old animation value for the next loop
-        old_value = current_value
-      #    
+        if (current_value != ""):
+          old_value = current_value
+      #
     #
-    
-  f.close()
-  
-  print("Armature animation data extracted!")
+  #
   
   # exporter end
   return {'FINISHED'}
 
 
-# ExportHelper is a helper class, defines filename and
-# invoke() function which calls the file selector.
+#################################################
+# Stuff down is for the menu appending
+# of the exporter to work plus some setting stuff
+# comes from a Blender importer template
+#################################################
+
 from bpy_extras.io_utils import ExportHelper
 from bpy.props import StringProperty, BoolProperty, EnumProperty
 from bpy.types import Operator
 
-
 class Export_CSV_BCK(Operator, ExportHelper):
-    """Save a CSV file for BCK conversion (to use with J3D Animation Editor)"""
-    bl_idname = "export_scene.csv_bck"
-    bl_label = "Export CSV (for BCK)"
-    
-    filename_ext = ".csv"
-
-    filter_glob = StringProperty(
-            default="*.csv",
-            options={'HIDDEN'},
-            maxlen=255,
-            )
+#
+  """Save a CSV file for BCK conversion (to use with J3D Animation Editor)"""
+  bl_idname = "export_scene.csv_bck"
+  bl_label = "Export CSV (for BCK)"  
+  filename_ext = ".csv"
 
-    loop_mode = EnumProperty(
-      name="Loop Mode",
-      description="Choose the loop mode for the animation",
-      items=(
-          ('OPT_A', "Once", "Play the animation once and stop at the last frame"),
-          ('OPT_B', "Once and Reset", "Play the animation once and stop at the first frame"),
-          ('OPT_C', "Loop", "Loop the animation infinitely"),
-          ('OPT_D', "Mirrored Once", "Play the animation forwards and then backwards once. Stops at the first frame"),
-          ('OPT_E', "Mirrored Loop", "Play the animation forwards and then backwards infinitely")
-          ),
-          default='OPT_A',
-          )
-
-    def execute(self, context):
-        return write_csv_bck(context, self.filepath, self.loop_mode)
+  filter_glob = StringProperty(
+    default="*.csv",
+    options={'HIDDEN'},
+    maxlen=255,
+      )
 
+  loop_mode = EnumProperty(
+    name="Loop Mode",
+    description="Choose the loop mode for the animation",
+    items=( ('OPT_A', "Once", "Play the animation once and stop at the last frame"),
+            ('OPT_B', "Once and Reset", "Play the animation once and stop at the first frame"),
+            ('OPT_C', "Loop", "Loop the animation infinitely"),
+            ('OPT_D', "Mirrored Once", "Play the animation forwards and then backwards once. Stops at the first frame"),
+            ('OPT_E', "Mirrored Loop", "Play the animation forwards and then backwards infinitely")
+              ), default='OPT_A'
+                )
+  export_mode = EnumProperty(
+    name="Export Mode",
+    description="Choose the method used to export the model animation data",
+    items=( ('OPT_A', "All Frames", "Export animation values for each frame of the animation. Slow, higher CSV file size, more accurate animation"),
+            ('OPT_B', "Only Keyframes", "Only export the animation keyframe values of each bone. Fast, lower CSV file size, least accurate animation"),
+              ), default='OPT_A'
+                )
+  
+  def execute(self, context):
+    return write_csv_bck(context, self.filepath, self.loop_mode, self.export_mode)
+#
 
 # Only needed if you want to add into a dynamic menu
 def menu_export_csv_bck(self, context):
-    self.layout.operator(Export_CSV_BCK.bl_idname, text="CSV (for BCK) (.csv)")
+  self.layout.operator(Export_CSV_BCK.bl_idname, text="CSV Animation Table (for BCK) (.csv)")
 
 bpy.utils.register_class(Export_CSV_BCK)
 bpy.types.INFO_MT_file_export.append(menu_export_csv_bck)
 
-
 # test call
 bpy.ops.export_scene.csv_bck('INVOKE_DEFAULT')