# ##### 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 ##### # import bpy from mathutils import * from bl_operators import nla from retarget import hasIKConstraint ### Utility Functions def getConsObj(bone): #utility function - returns related IK target if bone has IK ik = [constraint for constraint in bone.constraints if constraint.type == "IK"] if ik: ik = ik[0] cons_obj = ik.target if ik.subtarget: cons_obj = ik.target.pose.bones[ik.subtarget] else: cons_obj = bone return cons_obj def consObjToBone(cons_obj): #Utility function - returns related bone from ik object if cons_obj.name[-3:] == "Org": return cons_obj.name[:-3] else: return cons_obj.name ### And and Remove Constraints (called from operators) def addNewConstraint(m_constraint, cons_obj): #Decide the correct Blender constraint according to the Mocap constraint type if m_constraint.type == "point" or m_constraint.type == "freeze": c_type = "LIMIT_LOCATION" if m_constraint.type == "distance": c_type = "LIMIT_DISTANCE" if m_constraint.type == "floor": c_type = "FLOOR" #create and store the new constraint within m_constraint real_constraint = cons_obj.constraints.new(c_type) real_constraint.name = "Mocap constraint " + str(len(cons_obj.constraints)) m_constraint.real_constraint_bone = consObjToBone(cons_obj) m_constraint.real_constraint = real_constraint.name #set the rest of the constraint properties setConstraint(m_constraint, bpy.context) def removeConstraint(m_constraint, cons_obj): #remove the influence fcurve and Blender constraint oldConstraint = cons_obj.constraints[m_constraint.real_constraint] removeInfluenceFcurve(cons_obj, bpy.context.active_object, oldConstraint) cons_obj.constraints.remove(oldConstraint) ### Update functions. There are 3: UpdateType/Bone ### update framing (deals with changes in the desired frame range) ### And setConstraint which deals with the rest def updateConstraintBoneType(m_constraint, context): #If the constraint exists, we need to remove it #from the old bone obj = context.active_object bones = obj.pose.bones if m_constraint.real_constraint: bone = bones[m_constraint.real_constraint_bone] cons_obj = getConsObj(bone) removeConstraint(m_constraint, cons_obj) #Regardless, after that we create a new constraint if m_constraint.constrained_bone: bone = bones[m_constraint.constrained_bone] cons_obj = getConsObj(bone) addNewConstraint(m_constraint, cons_obj) def setConstraintFraming(m_constraint, context): obj = context.active_object bones = obj.pose.bones bone = bones[m_constraint.constrained_bone] cons_obj = getConsObj(bone) real_constraint = cons_obj.constraints[m_constraint.real_constraint] #remove the old keyframes removeInfluenceFcurve(cons_obj, obj, real_constraint) #set the new ones according to the m_constraint properties s, e = m_constraint.s_frame, m_constraint.e_frame s_in, s_out = m_constraint.smooth_in, m_constraint.smooth_out real_constraint.influence = 1 real_constraint.keyframe_insert(data_path="influence", frame=s) real_constraint.keyframe_insert(data_path="influence", frame=e) real_constraint.influence = 0 real_constraint.keyframe_insert(data_path="influence", frame=s - s_in) real_constraint.keyframe_insert(data_path="influence", frame=e + s_out) def removeInfluenceFcurve(cons_obj, obj, real_constraint): #Determine if the constrained object is a bone or an empty if isinstance(cons_obj, bpy.types.PoseBone): fcurves = obj.animation_data.action.fcurves else: fcurves = cons_obj.animation_data.action.fcurves #Find the RNA data path of the constraint's influence influence_RNA = real_constraint.path_from_id("influence") #Retrieve the correct fcurve via the RNA data path and remove it fcurve = [fcurve for fcurve in fcurves if fcurve.data_path == influence_RNA] #clear the fcurve and set the frames. if fcurve: fcurves.remove(fcurve[0]) # Function that copies all settings from m_constraint to the real Blender constraints # Is only called when blender constraint already exists def setConstraint(m_constraint, context): if not m_constraint.constrained_bone: return obj = context.active_object bones = obj.pose.bones bone = bones[m_constraint.constrained_bone] cons_obj = getConsObj(bone) real_constraint = cons_obj.constraints[m_constraint.real_constraint] #frame changing section setConstraintFraming(m_constraint, context) #Set the blender constraint parameters if m_constraint.type == "point": real_constraint.owner_space = m_constraint.targetSpace x, y, z = m_constraint.targetPoint real_constraint.max_x = x real_constraint.max_y = y real_constraint.max_z = z real_constraint.min_x = x real_constraint.min_y = y real_constraint.min_z = z real_constraint.use_max_x = True real_constraint.use_max_y = True real_constraint.use_max_z = True real_constraint.use_min_x = True real_constraint.use_min_y = True real_constraint.use_min_z = True if m_constraint.type == "freeze": real_constraint.owner_space = m_constraint.targetSpace bpy.context.scene.frame_set(m_constraint.s_frame) if isinstance(cons_obj, bpy.types.PoseBone): x, y, z = cons_obj.bone.center + (cons_obj.bone.vector / 2) + obj.matrix_world.to_translation() else: x, y, z = cons_obj.matrix_world.to_translation() real_constraint.max_x = x real_constraint.max_y = y real_constraint.max_z = z real_constraint.min_x = x real_constraint.min_y = y real_constraint.min_z = z real_constraint.use_max_x = True real_constraint.use_max_y = True real_constraint.use_max_z = True real_constraint.use_min_x = True real_constraint.use_min_y = True real_constraint.use_min_z = True if m_constraint.type == "distance" and m_constraint.constrained_boneB: real_constraint.owner_space = "WORLD" real_constraint.target = getConsObj(bones[m_constraint.constrained_boneB]) real_constraint.limit_mode = "LIMITDIST_ONSURFACE" real_constraint.distance = m_constraint.targetDist # active/baked check real_constraint.mute = (not m_constraint.active) def locBake(s_frame, e_frame, bones): scene = bpy.context.scene bakeDict = {} for bone in bones: bakeDict[bone.name] = {} for t in range(s_frame, e_frame): scene.frame_set(t) for bone in bones: bakeDict[bone.name][t] = bone.matrix.copy() for t in range(s_frame, e_frame): for bone in bones: print(bone.bone.matrix_local.to_translation()) bone.matrix = bakeDict[bone.name][t] bone.keyframe_insert("location", frame=t) # Baking function which bakes all bones effected by the constraint def bakeAllConstraints(obj, s_frame, e_frame, bones): for bone in bones: bone.bone.select = False selectedBones = [] # Marks bones that need a full bake simpleBake = [] # Marks bones that need only a location bake for end_bone in bones: if end_bone.name in [m_constraint.real_constraint_bone for m_constraint in obj.data.mocap_constraints]: #For all bones that have a constraint: ik = hasIKConstraint(end_bone) cons_obj = getConsObj(end_bone) if ik: #If it's an auto generated IK: if ik.chain_count == 0: selectedBones += bones # Chain len 0, bake everything else: selectedBones += [end_bone] + end_bone.parent_recursive[:ik.chain_count - 1] # Bake the chain else: #It's either an FK bone which we should just bake #OR a user created IK target bone simpleBake += [end_bone] for bone in selectedBones: bone.bone.select = True constraintTrack = obj.animation_data.nla_tracks["Mocap constraints"] constraintStrip = constraintTrack.strips[0] constraintStrip.action_frame_start = s_frame constraintStrip.action_frame_end = e_frame constraintStrip.frame_start = s_frame constraintStrip.frame_end = e_frame if selectedBones: #Use bake function from NLA Bake Action operator nla.bake(s_frame, e_frame, action=constraintStrip.action, only_selected=True, do_pose=True, do_object=False) if simpleBake: #Do a "simple" bake, location only, world space only. locBake(s_frame, e_frame, simpleBake) #Calls the baking function and decativates releveant constraints def bakeConstraints(context): obj = context.active_object bones = obj.pose.bones s_frame, e_frame = context.scene.frame_start, context.scene.frame_end #Bake relevant bones bakeAllConstraints(obj, s_frame, e_frame, bones) for m_constraint in obj.data.mocap_constraints: end_bone = bones[m_constraint.real_constraint_bone] cons_obj = getConsObj(end_bone) # It's a control empty: turn the ik off if not isinstance(cons_obj, bpy.types.PoseBone): ik_con = hasIKConstraint(end_bone) if ik_con: ik_con.mute = True # Deactivate related Blender Constraint m_constraint.active = False #Deletes the baked fcurves and reactivates relevant constraints def unbakeConstraints(context): # to unbake constraints we delete the whole strip obj = context.active_object bones = obj.pose.bones scene = bpy.context.scene constraintTrack = obj.animation_data.nla_tracks["Mocap constraints"] constraintStrip = constraintTrack.strips[0] action = constraintStrip.action # delete the fcurves on the strip for fcurve in action.fcurves: action.fcurves.remove(fcurve) # reactivate relevant constraints for m_constraint in obj.data.mocap_constraints: end_bone = bones[m_constraint.real_constraint_bone] cons_obj = getConsObj(end_bone) # It's a control empty: turn the ik back on if not isinstance(cons_obj, bpy.types.PoseBone): ik_con = hasIKConstraint(end_bone) if ik_con: ik_con.mute = False m_constraint.active = True