path: root/bck_export.py

# "simple" exporter for BCK anim files from SMG
# file format information --> https://humming-owl.neocities.org/smg-stuff/pages/tutorials/bck

import bpy, math
from . import blender_funcs
from . import bck_funcs
from . import file_ops
from . import math_funcs
import mathutils

# export BCK animation from the selected armature object
def export_bck_func(options, context):
  
  # this thing is always needed for stuff
  scene = context.scene
  
  # checking stage
  
  # if no armature is selected
  if (scene.objects.active == None):
    blender_funcs.disp_msg("No Armature selected. Select one and try again.")
    return {"FINISHED"}
  elif (scene.objects.active.type != "ARMATURE"):
    blender_funcs.disp_msg("No Armature selected. Currently selecting: \"%s\"" % (scene.objects.active.name))
    return {"FINISHED"}
  
  # select the armature object
  armature = scene.objects.active
  blender_funcs.select_obj(armature, False, "OBJECT")
  
  # if the armature has no bones (lmao)
  if (len(armature.data.bones) == 0):
    blender_funcs.disp_msg("Armature selected \"%s\" does not have any bones." % (armature.name))
    return {"FINISHED"}
  
  # if the armature has no animation data
  if (armature.animation_data == None
      or armature.animation_data.action == None):
    blender_funcs.disp_msg("Armature selected \"%s\" does not have an animation active." % (armature.name))
    return {"FINISHED"}
  
  # start gathering the animation information
  bck_anim = bck_funcs.smg_bck_anim()
  
  # loop mode (dark python string magic - ascii math)
  bck_anim.loop_mode = options.loop_mode.encode()[-1] - "A".encode()[0]
  bck_anim.anim_length = options.anim_length
  bck_anim.bone_count = len(armature.data.bones)
  for i in range(bck_anim.bone_count):
    # append the bone component animation data
    bck_anim.anim_data.append(bck_funcs.smg_bck_anim.anim_data())
    
  # start getting the actual animation data
  for i in range(len(armature.data.bones)):
    data_bone = armature.data.bones[i] # correct bone index order
    pose_bone = armature.pose.bones[data_bone.name] # pose matrix is got from here
    
    # check if the bone has animation data (1 or more keyframes)
    # if not just add its rest pose value to the structure
    
    # gather the existing fcurves for a bone
    bone_fcurves = [None, None, None, None, None, None, None, None, None]
    # ^ sx, rx, tx, sy (24!), ry, ty, sz, rz and tz in that order (bck order)
    bone_data_path_str = "pose.bones[\"%s\"]." % (data_bone.name)
    for fcurve in armature.animation_data.action.fcurves:
      if (fcurve.data_path == bone_data_path_str + "scale"):
        bone_fcurves[int((3 * fcurve.array_index) + 0)] = fcurve
      elif (fcurve.data_path == bone_data_path_str + "rotation_euler"):
        bone_fcurves[int((3 * fcurve.array_index) + 1)] = fcurve
      elif (fcurve.data_path == bone_data_path_str + "location"):
        bone_fcurves[int((3 * fcurve.array_index) + 2)] = fcurve
    
    # generate all the animation points, interpolation stuff will be done later
    
    # get the rest pose matrix
    rest_mat = data_bone.matrix_local.copy()
    if (pose_bone.parent != None):
      rest_mat = data_bone.parent.matrix_local.copy().inverted() * rest_mat.copy()
    else:
      rest_mat = mathutils.Matrix.Identity(4)
    
    # get the points on all frames, only the points
    for j in range(bck_anim.anim_length):
      # find the values respect to rest pose
      scale = [1, 1, 1]
      rot = [0, 0, 0]
      transl = [0, 0, 0]
      
      # all components
      for k in range(9):
        # components with fcurve 
        if (bone_fcurves[k] != None and len(bone_fcurves[k].keyframe_points) >= 1):
          value = bone_fcurves[k].evaluate(options.first_frame + j)
          # check which is the component to get
          if (k == 0 or k == 3 or k == 6):
            scale[int((k - 0) / 3)] = value
          elif (k == 1 or k == 4 or k == 7):
            rot[int((k - 1) / 3)] = value
          elif (k == 2 or k == 5 or k == 8):
            transl[int((k - 2) / 3)] = value
        
      # convert the values to be respect to parent
      new_mat = rest_mat.copy() * math_funcs.calc_transf_mat(scale, rot, transl).copy()
      for k in range(9):
        value = None
        # check which is the component to get
        if (k == 0 or k == 3 or k == 6):
          value = round(new_mat.to_scale()[int((k - 0) / 3)], options.rounding_vec[0])
        elif (k == 1 or k == 4 or k == 7):
          value = round(new_mat.to_euler("XYZ")[int((k - 1) / 3)], options.rounding_vec[1])
        elif (k == 2 or k == 5 or k == 8):
          value = round(100 * new_mat.to_translation()[int((k - 2) / 3)], options.rounding_vec[2])
          # 100 times because of blenxy's coordinates
        bck_anim.anim_data[i].comp[k].value.append(value)
        
  # got all the animation points
    
  # delete constant value animation tracks
  for i in range(bck_anim.bone_count):
    for j in range(9):
      anim_track_constant = True
      for k in range(bck_anim.anim_length):
        if (k == 0):
          continue
        # check if the whole animation track is the same
        if (bck_anim.anim_data[i].comp[j].value[k - 1] != bck_anim.anim_data[i].comp[j].value[k]):
          anim_track_constant = False
          break
      if (anim_track_constant == True):
        bck_anim.anim_data[i].comp[j].kf_count = 1
        bck_anim.anim_data[i].comp[j].interp_mode = 0
        bck_anim.anim_data[i].comp[j].time = [None]
        bck_anim.anim_data[i].comp[j].value = [bck_anim.anim_data[i].comp[j].value[0]]
        bck_anim.anim_data[i].comp[j].in_slope = [None]
        bck_anim.anim_data[i].comp[j].out_slope = [None]
  
  print(bck_anim)
  
  # keep all the samples intact and calculate the slopes
  # using linear interpolation between consecutive frames
  if (options.export_type == "OPT_A"):
    
    # assign the rest of the variables
    for i in range(bck_anim.bone_count):
      for j in range(9):
        # skip 1 keyframe animations
        if (bck_anim.anim_data[i].comp[j].kf_count == 1):
          continue
        bck_anim.anim_data[i].comp[j].kf_count = bck_anim.anim_length
        bck_anim.anim_data[i].comp[j].interp_mode = 1 # has to be like this
        for k in range(bck_anim.anim_length):
          bck_anim.anim_data[i].comp[j].time.append(k)
          in_slope = 0
          out_slope = 0
          if (k > 0):
            in_slope = bck_anim.anim_data[i].comp[j].value[k] - bck_anim.anim_data[i].comp[j].value[k - 1]
          if (k < bck_anim.anim_length - 1):
            out_slope = bck_anim.anim_data[i].comp[j].value[k + 1] - bck_anim.anim_data[i].comp[j].value[k]
          # set the rounding digit
          rounding = options.rounding_vec[0] # scale
          if (j == 1 or j == 4 or j == 7): # rotation
            rounding = options.rounding_vec[1]
          elif (j == 2 or j == 5 or j == 8): # translation
            rounding = options.rounding_vec[2]
          bck_anim.anim_data[i].comp[j].in_slope.append(round(in_slope, rounding))
          bck_anim.anim_data[i].comp[j].out_slope.append(round(out_slope, rounding))
  
  # find "best" interpolator fits for the samples
  elif (options.export_type == "OPT_B"):
    
    # assign the rest of the variables
    for i in range(bck_anim.bone_count):
      # assign the best fit for each animation component
      for j in range(9):
        # skip 1 keyframe animations
        if (bck_anim.anim_data[i].comp[j].kf_count == 1):
          continue
        # get the best fit interpolation result
        interp_result = math_funcs.find_best_cubic_hermite_spline_fit(options.first_frame,
                                                                      bck_anim.anim_data[i].comp[j].value,
                                                                      options.angle_limit)      
        # set the rounding digit
        rounding = options.rounding_vec[0] # scale
        if (j == 1 or j == 4 or j == 7): # rotation
          rounding = options.rounding_vec[1]
        elif (j == 2 or j == 5 or j == 8): # translation
          rounding = options.rounding_vec[2]        
        # round all the values returned by the interpolation fit
        for k in range(interp_result.kf_count):
          interp_result.value[k] = round(interp_result.value[k], rounding)
          if (k > 0):
            interp_result.in_slope[k] = round(interp_result.in_slope[k], rounding)
          if (k < interp_result.kf_count - 1):
            interp_result.out_slope[k] = round(interp_result.out_slope[k], rounding)
        
        # check if the fit can be made in interpolation mode == 0 (in_slope = out_slope)
        # assign the best fit for each animation component
        can_use_smooth_interp = True
        for k in range(interp_result.kf_count):
          if (k == 0 or k == interp_result.kf_count - 1):
            continue
          if (interp_result.in_slope[k] != interp_result.out_slope[k]):
            can_use_smooth_interp = False
            break
        
        # nice, adjust in_slope[0] and out_slope[-1]
        if (can_use_smooth_interp == True):
          interp_result.in_slope[0] = interp_result.out_slope[0]
          interp_result.out_slope[-1] = interp_result.in_slope[-1]
        else:
          interp_result.in_slope[0] = 0
          interp_result.out_slope[-1] = 0
          
        # overwrite the old animation track
        bck_anim.anim_data[i].comp[j].kf_count = interp_result.kf_count
        bck_anim.anim_data[i].comp[j].interp_mode = 1
        if (can_use_smooth_interp == True):
          bck_anim.anim_data[i].comp[j].interp_mode = 0
        bck_anim.anim_data[i].comp[j].time = interp_result.time
        bck_anim.anim_data[i].comp[j].value = interp_result.value
        bck_anim.anim_data[i].comp[j].in_slope = interp_result.in_slope
        bck_anim.anim_data[i].comp[j].out_slope = interp_result.out_slope
  
  # hopefully everything went okay
  print(bck_anim)
  
  # create a raw bck struct and write the BCK file
  raw = bck_funcs.create_smg_bck_raw(bck_anim)
  print(raw)  
  endian_ch = ">" # big endian character for struct.unpack()   
  if (options.endian == "OPT_B"): # little character
    endian_ch = "<"
  bck_funcs.write_smg_bck_raw(raw, options.filepath, endian_ch)
  
  # done!
  blender_funcs.disp_msg("BCK animation \"%s\" written" % (file_ops.get_file_name(options.filepath)))
  return {"FINISHED"}

# Stuff down is for the menu appending
# of the importer 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, FloatProperty, IntProperty, IntVectorProperty
from bpy.types import Operator

# export_bck class 
class export_bck(Operator, ExportHelper):
  """Export the animation data from an Armature into a SMG BCK file"""
  # stuff for blender
  bl_idname = "export_scene.bck"
  bl_label = "Export BCK (SMG)"
  filename_ext = ".bck"
  filter_glob = StringProperty(default = "*.bck", options = {"HIDDEN"}, maxlen = 255)    
  
  # exporter options
  export_type = EnumProperty(
    name = "Export Mode",
    description = "Way in which the animation will be exported",
    default = "OPT_B",
    items = (
      ("OPT_A", "Sample Everything", "Animation will be written completely sampled doing linear interpolation between all the frames of the animation. Some cleanup will be done while reading. Fast and accurate but takes a lot of space"),
      ("OPT_B", "Find Best Interpolator", "Will find the best interpolator fits for all the animation curves involved in the animation. Slow and not that accurate but can take less space")
    )
  )
  angle_limit = FloatProperty(
    name = "Derivative angle limit",
    description = "Value used to specify a keyframe generation at curve points at which sudden slope changes occur. Useful to adjust several straight lines. The angle comes from scaling the vertical axis of the animation track so that the \"visual derivative changes\" become visible. For export option \"Find Best Interpolator\"",
    default = 45,
    min = 0,
    max = 180,
  )
  first_frame = IntProperty(
    name = "First frame",
    description = "Value used to specify the first frame of the animation",
    default = 0,
  )
  anim_length = IntProperty(
    name = "Animation length",
    description = "Value used to specify the number of frames of the BCK animation after the first frame specified",
    default = 30,
  )
  loop_mode = EnumProperty(
    name = "Loop mode",
    description = "Way in which the animation be played in-game",
    default = "OPT_C",
    items = (
      ("OPT_A", "Play once - Stop at last frame", "Animation will start playing forwards and, when the animation data finishes, the last frame will be kept loaded into the model"),
      ("OPT_B", "Play once - Stop at first frame", "Animation will start playing forwards and, when the animation data finishes, the first frame will be kept loaded into the model"),
      ("OPT_C", "Repeat - Play forwards always", "Animation will start playing forwards and, when the animation data finishes, will play again from the beginning forwards"),
      ("OPT_D", "Play once - First forwards then backwards", "Animation will start playing forwards and, when the animation data finishes, the animation will be played backwards. This occurs only once"),
      ("OPT_E", "Repeat - Play forwards then backwards always", "Animation will start playing forwards and, when the animation data finishes, the animation will be played backwards. This repeats infinitely")
    )
  )
  endian = EnumProperty(
    name = "Endian order",
    description = "Way in which the animation data will be written",
    default = "OPT_A",
    items = (
      ("OPT_A", "Big", "Write data in the big endian byte ordering"),
      ("OPT_B", "Little", "Write data in the little endian byte ordering")
    )
  )
  rounding_vec = IntVectorProperty(
    name = "Round SRT to digit",
    description = "Round the scale, rotation and translation values (in that order) to the specified decimal position",
    default = (3, 5, 1),
    min = 0,
    max = 9
  )
  # what the importer actually does
  def execute(self, context):
    return export_bck_func(self, context)

# stuff to append the item to the File -> Import/Export menu
def menu_export_bck(self, context):
  self.layout.operator(export_bck.bl_idname, text = "BCK for SMG (.bck)")

# register func
@bpy.app.handlers.persistent
def register(dummy):
  try:
    bpy.utils.register_class(export_bck)
    bpy.types.INFO_MT_file_export.append(menu_export_bck)
  except:
    return
    
# unregister func
def unregister():
  try:
    bpy.utils.unregister_class(export_bck)
    bpy.types.INFO_MT_file_export.remove(menu_export_bck)
  except:
    return