# "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 (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 = new_mat.to_scale()[int((k - 0) / 3)] elif (k == 1 or k == 4 or k == 7): value = new_mat.to_euler("XYZ")[int((k - 1) / 3)] elif (k == 2 or k == 5 or k == 8): value = 100 * new_mat.to_translation()[int((k - 2) / 3)] # conversion from 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 comp_min_dif = options.min_dif # min difference (radians) if (j == 0 or j == 3 or j == 6): # scale comp_min_dif = options.min_dif / 3 elif (j == 2 or j == 5 or j == 8): # translation comp_min_dif = options.min_dif * 1000 if (abs(bck_anim.anim_data[i].comp[j].value[k - 1] - bck_anim.anim_data[i].comp[j].value[k]) > comp_min_dif): 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] bck_anim.anim_data[i].comp[j].in_slope.append(in_slope) bck_anim.anim_data[i].comp[j].out_slope.append(out_slope) # 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) # 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 comp_min_dif = options.min_dif # min difference (radians) if (j == 0 or j == 3 or j == 6): # scale comp_min_dif = options.min_dif / 3 elif (j == 2 or j == 5 or j == 8): # translation comp_min_dif = options.min_dif * 1000 for k in range(interp_result.kf_count): if (k == 0 or k == interp_result.kf_count - 1): continue if (abs(interp_result.in_slope[k] - interp_result.out_slope[k]) > comp_min_dif): 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 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") ) ) min_dif = FloatProperty( name = "Minimum difference", description = "Minimum difference at which 2 numbers can be considered the same. For reference, this value is linked to randians magnitude", default = 0.001, min = 1e-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)") bpy.utils.register_class(export_bck) bpy.types.INFO_MT_file_export.append(menu_export_bck) # test call bpy.ops.export_scene.bck("INVOKE_DEFAULT")