def scan_actions(context, sub, selected): scn = context.scene fc = (int(scn.frame_current_final), scn.frame_current_final)[sub] frames = list() for obj in selected: if Is.gpencil(obj): for layer in obj.data.layers: for frame in layer.frames: frames.append(frame.frame_number) for obj in Get.objects_nla(context): # Poll object if pose(context): if not pose(obj): continue elif selected: bones = [ f'pose.bones[\"{b.name}\"]' for b in Get.selected_pose_bones(context, src=obj) ] if not bones: continue else: bones = list() else: if (selected and obj not in selected): continue else: bones = list() for anim in Get.animation_datas(obj): if (not anim.action): continue if anim.use_tweak_mode: for s in Get.strips(anim.id_data): if s.action == anim.action: strip = s if s.active: break # Get loop ends cycle = list() afe = strip.action_frame_end fel = fer = Get.frame_from_strip(context, strip, afe) while fel < strip.frame_end: offset = (fer - strip.frame_start) cycle.append(offset) fel += abs(offset) # If offset becomes negative, it "should" create an infinite loop # abs() forces positive, which "should" prevent loop else: strip = None for fcurve in anim.action.fcurves: path = fcurve.data_path if bones: # Bones are selected, so verify this fcurve if for one of them for bpath in bones: if path.startswith(bpath): break else: continue elif path.startswith('pose.bones[\"'): try: eval(repr(obj) + '.' + path) # Validate path bpath = path.split('\"]', 1)[0] + '\"]' bone = eval(repr(obj) + '.' + bpath) if not Is.visible(context, bone): continue except: # curve points to a removed bone or something continue scan_fcurve(context, sub, fcurve, frames, strip=strip) return sorted(set(frames))
def get_keys(self, context): scn_frame = context.scene.frame_current_final fcurves = dict() quats = dict() updates = dict() break_sync = False if hasattr(context.scene, 'sync'): break_sync = context.scene.sync.sync_3d and context.scene.sync.sync_between_3d if context.mode == 'POSE': # objects = [o for o in Get.objects(context) if o.mode == 'POSE'] objects = list() for ob in Get.objects(context): if ob.mode != 'POSE': continue bones = tuple([f"pose.bones[\"{b.name}\"]" for b in Get.selected_pose_bones(context, ob)]) if bones: objects.append((ob, bones)) if not objects: for ob in Get.objects(context): if ob.mode != 'POSE': continue bones = tuple([f"pose.bones[\"{b.name}\"]" for b in ob.pose.bones if Is.visible(context, b)]) if bones: objects.append((ob, bones)) else: objects = [(o, list()) for o in Get.selected_objects(context)] for (ob, bones) in objects: for anim in Get.animation_datas(ob): action = anim.action if not action: continue if anim.use_tweak_mode: frame = Get.frame_to_strip(context, anim, scn_frame) for s in Get.strips(anim.id_data): if s.action == action: strip = s if s.active: break blend = strip.blend_type else: frame = scn_frame blend = anim.action_blend_type offset = abs(frame - scn_frame) if (scn_frame < frame): offset *= -1 for fc in anim.action.fcurves: path = fc.data_path index = fc.array_index if len(fc.keyframe_points) < 2: continue if bones: src = None for bone in bones: if path.startswith(bone): try: eval(repr(ob) + '.' + path) # Validate path src = eval(repr(ob) + '.' + bone) attr = path.replace(bone, '', 1) if attr.startswith('.'): attr = attr.replace('.', '', 1) is_custom = False else: is_custom = True except: # curve points to a removed bone or something src = None break else: # Pose mode but bone not selected continue if src is None: # Missing bone continue else: attr = path src = ob if attr in transforms: is_custom = False elif attr.startswith('["'): is_custom = True else: # if attr.startswith(('pose.bones', 'bones')): continue # Find the property to be able to manipulate, and its current value if is_custom: prop = src split = attr.rsplit('"]["', 1) if len(split) == 2: prop = eval(repr(src) + split[0] + '"]') attr = '["' + split[1] prop_value = getattr(prop, attr) elif hasattr(src, attr): prop = getattr(src, attr) if Is.iterable(prop): # elif attr in transforms: # prop = src.path_resolve(attr) prop_value = prop[index] else: prop = src prop_value = getattr(prop, attr) else: # maybe a constraint: # pose.bones[bone.name].constraints[con.name].influence continue # Function to apply values to the bone/object, later if Is.iterable(prop): def apply(self, val): "Function to apply values to (array) in bone/object, later" self.prop[self.index] = val prop = src.path_resolve(attr) prop_value = prop[index] is_array = True else: def apply(self, val): setattr(self.prop, self.attr, val) is_array = False cache = dict( attr=attr, apply=apply, index=index, is_array=is_array, key=None, quat=None, prop=prop, src=src, value=fc.evaluate(frame), ) left = type('', (), cache) current = type('', (), cache) current.found = False right = type('', (), cache) pre_key = None # Find the current keyframe, and keys left and right if break_sync: # types = context.scene.keyframe_navigation_types types = ('KEYFRAME', 'MOVING_HOLD') for key in fc.keyframe_points: if key.co.x < frame: if (left.key is None) or (key.type in types): left.key = key left.value = key.co.y right.key = key right.value = key.co.y elif key.co.x == frame: if left.key is None: left.key = key left.value = key.co.y current.key = key current.found = True right.key = key right.value = key.co.y elif key.co.x > frame: if left.key is None: left.key = key left.value = key.co.y if (key.type in types) or key == fc.keyframe_points[-1]: right.key = key right.value = key.co.y break if not (left.key and right.key): for key in fc.keyframe_points: if key.co.x < frame: left.key = key left.value = key.co.y right.key = key right.value = key.co.y elif key.co.x == frame: if left.key is None: left.key = key left.value = key.co.y current.key = key current.found = True right.key = key right.value = key.co.y elif key.co.x > frame: if left.key is None: left.key = key left.value = key.co.y right.key = key right.value = key.co.y break if not (left.key and right.key): # Nothing to tween continue # Get info for current keyframe's defaults sVal = left.key.co.x + offset eVal = right.key.co.x + offset current.w1 = frame - sVal current.w2 = eVal - frame left.frame = left.key.co.x current.frame = frame right.frame = right.key.co.x current.in_range = False if frame < left.frame: left.value = prop_value elif right.frame < frame: right.value = prop_value else: current.in_range = True if blend == 'REPLACE': current.value = prop_value else: if not self.has_additive: self.has_additive = True if current.key: value = current.key.co.y else: value = fc.evaluate(frame) left.value = prop_value + (left.value - value) current.value = prop_value # + (value - value) right.value = prop_value + (right.value - value) if tween.update: if sVal not in updates: updates[sVal] = list() if eVal not in updates: updates[eVal] = list() updates[sVal].append(left) updates[eVal].append(right) # Add classes to memory fcurves[fc] = [left, current, right] if attr == 'rotation_quaternion': # Do math for quaternions if (action, path) not in quats: quats[(action, path)] = dict() if (src.lock_rotations_4d or not src.lock_rotation_w) \ and True not in src.lock_rotation[:]: quats[(action, path)][index] = (left, current, right) if updates: for frame in updates: context.scene.frame_set(frame) for (cls) in updates[frame]: if Is.iterable(prop): cls.value = cls.prop[cls.index] else: cls.value = getattr(cls.prop, cls.attr) context.scene.frame_set(scn_frame) for (action, path) in quats: if len(quats[action, path]) < 4: continue (w_left, w_current, w_right) = quats[action, path][0] (x_left, x_current, x_right) = quats[action, path][1] (y_left, y_current, y_right) = quats[action, path][2] (z_left, z_current, z_right) = quats[action, path][3] left_quat = [x.value for x in (w_left, x_left, y_left, z_left)] current_quat = [x.value for x in (w_current, x_current, y_current, z_current)] right_quat = [x.value for x in (w_right, x_right, y_right, z_right)] cpp.normalize_qt(left_quat) cpp.normalize_qt(current_quat) cpp.normalize_qt(right_quat) for x in (w_left, x_left, y_left, z_left): x.quat = left_quat for x in (w_current, x_current, y_current, z_current): x.quat = current_quat for x in (w_right, x_right, y_right, z_right): x.quat = right_quat return fcurves