a485bf6556
When baking custom properties that were named exactly the same as a property already in Blender (in this case `scale`), it would fail. The issue was introduced with eee32726c7 where the goal was to not key addon defined properties. The problem with that approach was that `obj.bpy_rna.properties` not only contains addon defined properties but also all that are native to Blender. So the rna path would be created to be identical as for e.g. transform properties. The fix is to test the property for `is_runtime` which is true for addon defined properties but false for blender internal properties I tested with the test file of #121349 to confirm that doing so doesn't bring that original bug back. Pull Request: https://projects.blender.org/blender/blender/pulls/135297
750 lines
27 KiB
Python
750 lines
27 KiB
Python
# SPDX-FileCopyrightText: 2011-2023 Blender Authors
|
|
#
|
|
# SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
__all__ = (
|
|
"bake_action",
|
|
"bake_action_objects",
|
|
|
|
"bake_action_iter",
|
|
"bake_action_objects_iter",
|
|
|
|
"BakeOptions",
|
|
)
|
|
|
|
import bpy
|
|
from bpy.types import Action, ActionSlot, ActionChannelbag
|
|
from dataclasses import dataclass
|
|
|
|
from collections.abc import (
|
|
Mapping,
|
|
Sequence,
|
|
)
|
|
|
|
from rna_prop_ui import (
|
|
rna_idprop_value_to_python,
|
|
)
|
|
|
|
FCurveKey = tuple[
|
|
# `fcurve.data_path`.
|
|
str,
|
|
# `fcurve.array_index`.
|
|
int,
|
|
]
|
|
|
|
# List of `[frame0, value0, frame1, value1, ...]` pairs.
|
|
ListKeyframes = list[float]
|
|
|
|
|
|
@dataclass
|
|
class BakeOptions:
|
|
only_selected: bool
|
|
"""Only bake selected bones."""
|
|
|
|
do_pose: bool
|
|
"""Bake pose channels"""
|
|
|
|
do_object: bool
|
|
"""Bake objects."""
|
|
|
|
do_visual_keying: bool
|
|
"""Use the final transformations for baking ('visual keying')."""
|
|
|
|
do_constraint_clear: bool
|
|
"""Remove constraints after baking."""
|
|
|
|
do_parents_clear: bool
|
|
"""Unparent after baking objects."""
|
|
|
|
do_clean: bool
|
|
"""Remove redundant keyframes after baking."""
|
|
|
|
do_location: bool
|
|
"""Bake location channels"""
|
|
|
|
do_rotation: bool
|
|
"""Bake rotation channels"""
|
|
|
|
do_scale: bool
|
|
"""Bake scale channels"""
|
|
|
|
do_bbone: bool
|
|
"""Bake b-bone channels"""
|
|
|
|
do_custom_props: bool
|
|
"""Bake custom properties."""
|
|
|
|
|
|
def action_get_channelbag_for_slot(action: Action, slot: ActionSlot) -> ActionChannelbag | None:
|
|
"""
|
|
Returns the first channelbag found for the slot.
|
|
In case there are multiple layers or strips they are iterated until a
|
|
channelbag for that slot is found. In case no matching channelbag is found, returns None.
|
|
"""
|
|
for layer in action.layers:
|
|
for strip in layer.strips:
|
|
channelbag = strip.channelbag(slot)
|
|
if channelbag:
|
|
return channelbag
|
|
return None
|
|
|
|
|
|
def _ensure_channelbag_exists(action: Action, slot: ActionSlot):
|
|
for layer in action.layers:
|
|
for strip in layer.strips:
|
|
channelbag = strip.channelbag(slot, ensure=True)
|
|
return channelbag
|
|
|
|
|
|
def bake_action(
|
|
obj,
|
|
*,
|
|
action,
|
|
frames,
|
|
bake_options,
|
|
):
|
|
"""
|
|
:arg obj: Object to bake.
|
|
:type obj: :class:`bpy.types.Object`
|
|
:arg action: An action to bake the data into, or None for a new action
|
|
to be created.
|
|
:type action: :class:`bpy.types.Action` | None
|
|
:arg frames: Frames to bake.
|
|
:type frames: int
|
|
:arg bake_options: Options for baking.
|
|
:type bake_options: :class:`anim_utils.BakeOptions`
|
|
:return: Action or None.
|
|
:rtype: :class:`bpy.types.Action` | None
|
|
"""
|
|
if not (bake_options.do_pose or bake_options.do_object):
|
|
return None
|
|
|
|
action, = bake_action_objects(
|
|
[(obj, action)],
|
|
frames=frames,
|
|
bake_options=bake_options
|
|
)
|
|
return action
|
|
|
|
|
|
def bake_action_objects(
|
|
object_action_pairs,
|
|
*,
|
|
frames,
|
|
bake_options,
|
|
):
|
|
"""
|
|
A version of :func:`bake_action_objects_iter` that takes frames and returns the output.
|
|
|
|
:arg frames: Frames to bake.
|
|
:type frames: iterable of int
|
|
:arg bake_options: Options for baking.
|
|
:type bake_options: :class:`anim_utils.BakeOptions`
|
|
|
|
:return: A sequence of Action or None types (aligned with ``object_action_pairs``)
|
|
:rtype: Sequence[:class:`bpy.types.Action`]
|
|
"""
|
|
if not (bake_options.do_pose or bake_options.do_object):
|
|
return []
|
|
|
|
iter = bake_action_objects_iter(object_action_pairs, bake_options=bake_options)
|
|
iter.send(None)
|
|
for frame in frames:
|
|
iter.send(frame)
|
|
return iter.send(None)
|
|
|
|
|
|
def bake_action_objects_iter(
|
|
object_action_pairs,
|
|
bake_options,
|
|
):
|
|
"""
|
|
An coroutine that bakes actions for multiple objects.
|
|
|
|
:arg object_action_pairs: Sequence of object action tuples,
|
|
action is the destination for the baked data. When None a new action will be created.
|
|
:type object_action_pairs: Sequence of (:class:`bpy.types.Object`, :class:`bpy.types.Action`)
|
|
:arg bake_options: Options for baking.
|
|
:type bake_options: :class:`anim_utils.BakeOptions`
|
|
"""
|
|
scene = bpy.context.scene
|
|
frame_back = scene.frame_current
|
|
iter_all = tuple(
|
|
bake_action_iter(obj, action=action, bake_options=bake_options)
|
|
for (obj, action) in object_action_pairs
|
|
)
|
|
for iter in iter_all:
|
|
iter.send(None)
|
|
while True:
|
|
frame = yield None
|
|
if frame is None:
|
|
break
|
|
scene.frame_set(frame)
|
|
bpy.context.view_layer.update()
|
|
for iter in iter_all:
|
|
iter.send(frame)
|
|
scene.frame_set(frame_back)
|
|
yield tuple(iter.send(None) for iter in iter_all)
|
|
|
|
|
|
# XXX visual keying is actually always considered as True in this code...
|
|
def bake_action_iter(
|
|
obj,
|
|
*,
|
|
action,
|
|
bake_options,
|
|
):
|
|
"""
|
|
An coroutine that bakes action for a single object.
|
|
|
|
:arg obj: Object to bake.
|
|
:type obj: :class:`bpy.types.Object`
|
|
:arg action: An action to bake the data into, or None for a new action
|
|
to be created.
|
|
:type action: :class:`bpy.types.Action` | None
|
|
:arg bake_options: Boolean options of what to include into the action bake.
|
|
:type bake_options: :class:`anim_utils.BakeOptions`
|
|
|
|
:return: an action or None
|
|
:rtype: :class:`bpy.types.Action`
|
|
"""
|
|
# -------------------------------------------------------------------------
|
|
# Helper Functions and vars
|
|
|
|
# Note: BBONE_PROPS is a list so we can preserve the ordering
|
|
BBONE_PROPS = [
|
|
"bbone_curveinx", "bbone_curveoutx",
|
|
"bbone_curveinz", "bbone_curveoutz",
|
|
"bbone_rollin", "bbone_rollout",
|
|
"bbone_scalein", "bbone_scaleout",
|
|
"bbone_easein", "bbone_easeout",
|
|
]
|
|
BBONE_PROPS_LENGTHS = {
|
|
"bbone_curveinx": 1,
|
|
"bbone_curveoutx": 1,
|
|
"bbone_curveinz": 1,
|
|
"bbone_curveoutz": 1,
|
|
"bbone_rollin": 1,
|
|
"bbone_rollout": 1,
|
|
"bbone_scalein": 3,
|
|
"bbone_scaleout": 3,
|
|
"bbone_easein": 1,
|
|
"bbone_easeout": 1,
|
|
}
|
|
|
|
def can_be_keyed(value):
|
|
"""Returns a tri-state boolean.
|
|
|
|
- True: known to be keyable.
|
|
- False: known to not be keyable.
|
|
- None: unknown, might be an enum property for which RNA uses a string to
|
|
indicate a specific item (keyable) or an actual string property (not
|
|
keyable).
|
|
"""
|
|
if isinstance(value, (int, float, bool)):
|
|
# These types are certainly keyable.
|
|
return True
|
|
if isinstance(value, (list, tuple, set, dict)):
|
|
# These types are certainly not keyable.
|
|
return False
|
|
# Maybe this could be made stricter, as also ID pointer properties and
|
|
# some other types cannot be keyed. However, the above checks are enough
|
|
# to fix the crash that this code was written for (#117988).
|
|
return None
|
|
|
|
# Convert rna_prop types (IDPropertyArray, etc) to python types.
|
|
def clean_custom_properties(obj):
|
|
if not bake_options.do_custom_props:
|
|
# Don't bother remembering any custom properties when they're not
|
|
# going to be baked anyway.
|
|
return {}
|
|
|
|
# Be careful about which properties to actually consider for baking, as
|
|
# keeping references to complex Blender data-structures around for too long
|
|
# can cause crashes. See #117988.
|
|
clean_props = {
|
|
key: rna_idprop_value_to_python(value)
|
|
for key, value in obj.items()
|
|
if can_be_keyed(value) is not False
|
|
}
|
|
return clean_props
|
|
|
|
def bake_custom_properties(obj, *, custom_props, frame, group_name=""):
|
|
import idprop
|
|
if frame is None or not custom_props:
|
|
return
|
|
for key, value in custom_props.items():
|
|
if key in obj.bl_rna.properties and not obj.bl_rna.properties[key].is_animatable:
|
|
continue
|
|
if isinstance(obj[key], idprop.types.IDPropertyGroup):
|
|
continue
|
|
obj[key] = value
|
|
# The check for `is_runtime` is needed in case the custom property has the same
|
|
# name as a built in property, e.g. `scale`. In that case the simple check
|
|
# `key in ...` would be true and the square brackets would never get added.
|
|
if key in obj.bl_rna.properties and obj.bl_rna.properties[key].is_runtime:
|
|
rna_path = key
|
|
else:
|
|
rna_path = "[\"{:s}\"]".format(bpy.utils.escape_identifier(key))
|
|
try:
|
|
obj.keyframe_insert(rna_path, frame=frame, group=group_name)
|
|
except TypeError:
|
|
# The is_animatable check above is per property. A property in isolation
|
|
# may be considered animatable, but it could be owned by a data-block that
|
|
# itself cannot be animated.
|
|
continue
|
|
|
|
def pose_frame_info(obj):
|
|
matrix = {}
|
|
bbones = {}
|
|
custom_props = {}
|
|
for name, pbone in obj.pose.bones.items():
|
|
if bake_options.do_visual_keying:
|
|
# Get the final transform of the bone in its own local space...
|
|
matrix[name] = obj.convert_space(pose_bone=pbone, matrix=pbone.matrix,
|
|
from_space='POSE', to_space='LOCAL')
|
|
else:
|
|
matrix[name] = pbone.matrix_basis.copy()
|
|
|
|
# Bendy Bones
|
|
if pbone.bone.bbone_segments > 1:
|
|
bbones[name] = {bb_prop: getattr(pbone, bb_prop) for bb_prop in BBONE_PROPS}
|
|
|
|
# Custom Properties
|
|
custom_props[name] = clean_custom_properties(pbone)
|
|
|
|
return matrix, bbones, custom_props
|
|
|
|
def armature_frame_info(obj):
|
|
if obj.type != 'ARMATURE':
|
|
return {}
|
|
return clean_custom_properties(obj)
|
|
|
|
if bake_options.do_parents_clear:
|
|
if bake_options.do_visual_keying:
|
|
def obj_frame_info(obj):
|
|
return obj.matrix_world.copy(), clean_custom_properties(obj)
|
|
else:
|
|
def obj_frame_info(obj):
|
|
parent = obj.parent
|
|
matrix = obj.matrix_basis
|
|
if parent:
|
|
return parent.matrix_world @ matrix, clean_custom_properties(obj)
|
|
else:
|
|
return matrix.copy(), clean_custom_properties(obj)
|
|
else:
|
|
if bake_options.do_visual_keying:
|
|
def obj_frame_info(obj):
|
|
parent = obj.parent
|
|
matrix = obj.matrix_world
|
|
if parent:
|
|
return parent.matrix_world.inverted_safe() @ matrix, clean_custom_properties(obj)
|
|
else:
|
|
return matrix.copy(), clean_custom_properties(obj)
|
|
else:
|
|
def obj_frame_info(obj):
|
|
return obj.matrix_basis.copy(), clean_custom_properties(obj)
|
|
|
|
# -------------------------------------------------------------------------
|
|
# Setup the Context
|
|
|
|
if obj.pose is None:
|
|
bake_options.do_pose = False
|
|
|
|
if not (bake_options.do_pose or bake_options.do_object):
|
|
raise Exception("Pose and object baking is disabled, no action needed")
|
|
|
|
pose_info = []
|
|
armature_info = []
|
|
obj_info = []
|
|
|
|
# -------------------------------------------------------------------------
|
|
# Collect transformations
|
|
|
|
while True:
|
|
# Caller is responsible for setting the frame and updating the scene.
|
|
frame = yield None
|
|
|
|
# Signal we're done!
|
|
if frame is None:
|
|
break
|
|
if bake_options.do_pose:
|
|
pose_info.append((frame, *pose_frame_info(obj)))
|
|
armature_info.append((frame, armature_frame_info(obj)))
|
|
if bake_options.do_object:
|
|
obj_info.append((frame, *obj_frame_info(obj)))
|
|
|
|
# -------------------------------------------------------------------------
|
|
# Clean (store initial data)
|
|
if bake_options.do_clean and action is not None:
|
|
clean_orig_data = {fcu: {p.co[1] for p in fcu.keyframe_points} for fcu in action.fcurves}
|
|
else:
|
|
clean_orig_data = {}
|
|
|
|
# -------------------------------------------------------------------------
|
|
# Create action
|
|
|
|
# in case animation data hasn't been created
|
|
atd = obj.animation_data_create()
|
|
is_new_action = action is None
|
|
if is_new_action:
|
|
action = bpy.data.actions.new("Action")
|
|
else:
|
|
# When baking into the current action, a slot needs to be assigned.
|
|
if not atd.action_slot:
|
|
slot = action.slots.new(obj.id_type, obj.name)
|
|
atd.action_slot = slot
|
|
|
|
# Only leave tweak mode if we actually need to modify the action (#57159)
|
|
if action != atd.action:
|
|
# Leave tweak mode before trying to modify the action (#48397)
|
|
if atd.use_tweak_mode:
|
|
atd.use_tweak_mode = False
|
|
|
|
atd.action = action
|
|
if action.is_action_layered:
|
|
slot = action.slots.new(obj.id_type, obj.name)
|
|
atd.action_slot = slot
|
|
|
|
# Baking the action only makes sense in Replace mode, so force it (#69105)
|
|
if not atd.use_tweak_mode:
|
|
atd.action_blend_type = 'REPLACE'
|
|
|
|
# -------------------------------------------------------------------------
|
|
# Apply transformations to action
|
|
|
|
# pose
|
|
lookup_fcurves = {}
|
|
assert action.is_action_layered
|
|
channelbag = action_get_channelbag_for_slot(action, atd.action_slot)
|
|
if channelbag:
|
|
# channelbag can be None if no layers or strips exist in the action.
|
|
lookup_fcurves = {(fcurve.data_path, fcurve.array_index): fcurve for fcurve in channelbag.fcurves}
|
|
|
|
if bake_options.do_pose:
|
|
for f, armature_custom_properties in armature_info:
|
|
bake_custom_properties(obj, custom_props=armature_custom_properties,
|
|
frame=f, group_name="Armature Custom Properties")
|
|
|
|
for name, pbone in obj.pose.bones.items():
|
|
if bake_options.only_selected and not pbone.bone.select:
|
|
continue
|
|
|
|
if bake_options.do_constraint_clear:
|
|
while pbone.constraints:
|
|
pbone.constraints.remove(pbone.constraints[0])
|
|
|
|
# Create compatible euler & quaternion rotation values.
|
|
euler_prev = None
|
|
quat_prev = None
|
|
|
|
base_fcurve_path = pbone.path_from_id() + "."
|
|
path_location = base_fcurve_path + "location"
|
|
path_quaternion = base_fcurve_path + "rotation_quaternion"
|
|
path_axis_angle = base_fcurve_path + "rotation_axis_angle"
|
|
path_euler = base_fcurve_path + "rotation_euler"
|
|
path_scale = base_fcurve_path + "scale"
|
|
paths_bbprops = [(base_fcurve_path + bbprop) for bbprop in BBONE_PROPS]
|
|
|
|
keyframes = KeyframesCo()
|
|
|
|
if bake_options.do_location:
|
|
keyframes.add_paths(path_location, 3)
|
|
if bake_options.do_rotation:
|
|
keyframes.add_paths(path_quaternion, 4)
|
|
keyframes.add_paths(path_axis_angle, 4)
|
|
keyframes.add_paths(path_euler, 3)
|
|
if bake_options.do_scale:
|
|
keyframes.add_paths(path_scale, 3)
|
|
|
|
if bake_options.do_bbone and pbone.bone.bbone_segments > 1:
|
|
for prop_name, path in zip(BBONE_PROPS, paths_bbprops):
|
|
keyframes.add_paths(path, BBONE_PROPS_LENGTHS[prop_name])
|
|
|
|
rotation_mode = pbone.rotation_mode
|
|
total_new_keys = len(pose_info)
|
|
for (f, matrix, bbones, custom_props) in pose_info:
|
|
pbone.matrix_basis = matrix[name].copy()
|
|
|
|
if bake_options.do_location:
|
|
keyframes.extend_co_values(path_location, 3, f, pbone.location)
|
|
|
|
if bake_options.do_rotation:
|
|
if rotation_mode == 'QUATERNION':
|
|
if quat_prev is not None:
|
|
quat = pbone.rotation_quaternion.copy()
|
|
quat.make_compatible(quat_prev)
|
|
pbone.rotation_quaternion = quat
|
|
quat_prev = quat
|
|
del quat
|
|
else:
|
|
quat_prev = pbone.rotation_quaternion.copy()
|
|
keyframes.extend_co_values(path_quaternion, 4, f, pbone.rotation_quaternion)
|
|
elif rotation_mode == 'AXIS_ANGLE':
|
|
keyframes.extend_co_values(path_axis_angle, 4, f, pbone.rotation_axis_angle)
|
|
else: # euler, XYZ, ZXY etc
|
|
if euler_prev is not None:
|
|
euler = pbone.matrix_basis.to_euler(pbone.rotation_mode, euler_prev)
|
|
pbone.rotation_euler = euler
|
|
del euler
|
|
euler_prev = pbone.rotation_euler.copy()
|
|
keyframes.extend_co_values(path_euler, 3, f, pbone.rotation_euler)
|
|
|
|
if bake_options.do_scale:
|
|
keyframes.extend_co_values(path_scale, 3, f, pbone.scale)
|
|
|
|
# Bendy Bones
|
|
if bake_options.do_bbone and pbone.bone.bbone_segments > 1:
|
|
bbone_shape = bbones[name]
|
|
for prop_index, prop_name in enumerate(BBONE_PROPS):
|
|
prop_len = BBONE_PROPS_LENGTHS[prop_name]
|
|
if prop_len > 1:
|
|
keyframes.extend_co_values(
|
|
paths_bbprops[prop_index], prop_len, f, bbone_shape[prop_name]
|
|
)
|
|
else:
|
|
keyframes.extend_co_value(
|
|
paths_bbprops[prop_index], f, bbone_shape[prop_name]
|
|
)
|
|
# Custom Properties
|
|
if bake_options.do_custom_props:
|
|
bake_custom_properties(pbone, custom_props=custom_props[name], frame=f, group_name=name)
|
|
|
|
if is_new_action:
|
|
keyframes.insert_keyframes_into_new_action(total_new_keys, action, name)
|
|
else:
|
|
keyframes.insert_keyframes_into_existing_action(
|
|
lookup_fcurves, total_new_keys, action, atd.action_slot)
|
|
|
|
# object. TODO. multiple objects
|
|
if bake_options.do_object:
|
|
if bake_options.do_constraint_clear:
|
|
while obj.constraints:
|
|
obj.constraints.remove(obj.constraints[0])
|
|
|
|
# Create compatible euler & quaternion rotations.
|
|
euler_prev = None
|
|
quat_prev = None
|
|
|
|
path_location = "location"
|
|
path_quaternion = "rotation_quaternion"
|
|
path_axis_angle = "rotation_axis_angle"
|
|
path_euler = "rotation_euler"
|
|
path_scale = "scale"
|
|
|
|
keyframes = KeyframesCo()
|
|
if bake_options.do_location:
|
|
keyframes.add_paths(path_location, 3)
|
|
if bake_options.do_rotation:
|
|
keyframes.add_paths(path_quaternion, 4)
|
|
keyframes.add_paths(path_axis_angle, 4)
|
|
keyframes.add_paths(path_euler, 3)
|
|
if bake_options.do_scale:
|
|
keyframes.add_paths(path_scale, 3)
|
|
|
|
rotation_mode = obj.rotation_mode
|
|
total_new_keys = len(obj_info)
|
|
for (f, matrix, custom_props) in obj_info:
|
|
name = "Action Bake" # XXX: placeholder
|
|
obj.matrix_basis = matrix
|
|
|
|
if bake_options.do_location:
|
|
keyframes.extend_co_values(path_location, 3, f, obj.location)
|
|
|
|
if bake_options.do_rotation:
|
|
if rotation_mode == 'QUATERNION':
|
|
if quat_prev is not None:
|
|
quat = obj.rotation_quaternion.copy()
|
|
quat.make_compatible(quat_prev)
|
|
obj.rotation_quaternion = quat
|
|
quat_prev = quat
|
|
del quat
|
|
else:
|
|
quat_prev = obj.rotation_quaternion.copy()
|
|
keyframes.extend_co_values(path_quaternion, 4, f, obj.rotation_quaternion)
|
|
|
|
elif rotation_mode == 'AXIS_ANGLE':
|
|
keyframes.extend_co_values(path_axis_angle, 4, f, obj.rotation_axis_angle)
|
|
else: # euler, XYZ, ZXY etc
|
|
if euler_prev is not None:
|
|
obj.rotation_euler = matrix.to_euler(obj.rotation_mode, euler_prev)
|
|
euler_prev = obj.rotation_euler.copy()
|
|
keyframes.extend_co_values(path_euler, 3, f, obj.rotation_euler)
|
|
|
|
if bake_options.do_scale:
|
|
keyframes.extend_co_values(path_scale, 3, f, obj.scale)
|
|
|
|
if bake_options.do_custom_props:
|
|
bake_custom_properties(obj, custom_props=custom_props, frame=f, group_name=name)
|
|
|
|
if is_new_action:
|
|
keyframes.insert_keyframes_into_new_action(total_new_keys, action, name)
|
|
else:
|
|
keyframes.insert_keyframes_into_existing_action(
|
|
lookup_fcurves, total_new_keys, action, atd.action_slot)
|
|
|
|
if bake_options.do_parents_clear:
|
|
obj.parent = None
|
|
|
|
# -------------------------------------------------------------------------
|
|
# Clean
|
|
|
|
if bake_options.do_clean:
|
|
for fcu in action.fcurves:
|
|
fcu_orig_data = clean_orig_data.get(fcu, set())
|
|
|
|
keyframe_points = fcu.keyframe_points
|
|
i = 1
|
|
while i < len(keyframe_points) - 1:
|
|
val = keyframe_points[i].co[1]
|
|
|
|
if val in fcu_orig_data:
|
|
i += 1
|
|
continue
|
|
|
|
val_prev = keyframe_points[i - 1].co[1]
|
|
val_next = keyframe_points[i + 1].co[1]
|
|
|
|
if abs(val - val_prev) + abs(val - val_next) < 0.0001:
|
|
keyframe_points.remove(keyframe_points[i])
|
|
else:
|
|
i += 1
|
|
|
|
yield action
|
|
|
|
|
|
class KeyframesCo:
|
|
"""
|
|
A buffer for keyframe Co unpacked values per ``FCurveKey``. ``FCurveKeys`` are added using
|
|
``add_paths()``, Co values stored using extend_co_values(), then finally use
|
|
``insert_keyframes_into_*_action()`` for efficiently inserting keys into the F-curves.
|
|
|
|
Users are limited to one Action Group per instance.
|
|
"""
|
|
__slots__ = (
|
|
"keyframes_from_fcurve",
|
|
)
|
|
|
|
# `keyframes[(rna_path, array_index)] = list(time0,value0, time1,value1,...)`.
|
|
keyframes_from_fcurve: Mapping[FCurveKey, ListKeyframes]
|
|
|
|
def __init__(self):
|
|
self.keyframes_from_fcurve = {}
|
|
|
|
def add_paths(
|
|
self,
|
|
rna_path: str,
|
|
total_indices: int,
|
|
) -> None:
|
|
keyframes_from_fcurve = self.keyframes_from_fcurve
|
|
for array_index in range(0, total_indices):
|
|
keyframes_from_fcurve[(rna_path, array_index)] = []
|
|
|
|
def extend_co_values(
|
|
self,
|
|
rna_path: str,
|
|
total_indices: int,
|
|
frame: float,
|
|
values: Sequence[float],
|
|
) -> None:
|
|
keyframes_from_fcurve = self.keyframes_from_fcurve
|
|
for array_index in range(0, total_indices):
|
|
keyframes_from_fcurve[(rna_path, array_index)].extend((frame, values[array_index]))
|
|
|
|
def extend_co_value(
|
|
self,
|
|
rna_path: str,
|
|
frame: float,
|
|
value: float,
|
|
) -> None:
|
|
self.keyframes_from_fcurve[(rna_path, 0)].extend((frame, value))
|
|
|
|
def insert_keyframes_into_new_action(
|
|
self,
|
|
total_new_keys: int,
|
|
action: Action,
|
|
action_group_name: str,
|
|
) -> None:
|
|
"""
|
|
Assumes the action is new, that it has no F-curves. Otherwise, the only difference between versions is
|
|
performance and implementation simplicity.
|
|
|
|
:arg action_group_name: Name of Action Group that F-curves are added to.
|
|
:type action_group_name: str
|
|
"""
|
|
linear_enum_values = [
|
|
bpy.types.Keyframe.bl_rna.properties["interpolation"].enum_items["LINEAR"].value
|
|
] * total_new_keys
|
|
|
|
for fc_key, key_values in self.keyframes_from_fcurve.items():
|
|
if len(key_values) == 0:
|
|
continue
|
|
|
|
data_path, array_index = fc_key
|
|
keyframe_points = action.fcurves.new(
|
|
data_path, index=array_index, action_group=action_group_name
|
|
).keyframe_points
|
|
|
|
keyframe_points.add(total_new_keys)
|
|
keyframe_points.foreach_set("co", key_values)
|
|
keyframe_points.foreach_set("interpolation", linear_enum_values)
|
|
|
|
# There's no need to do fcurve.update() because the keys are already ordered, have
|
|
# no duplicates and all handles are Linear.
|
|
|
|
def insert_keyframes_into_existing_action(
|
|
self,
|
|
lookup_fcurves: Mapping[FCurveKey, bpy.types.FCurve],
|
|
total_new_keys: int,
|
|
action: Action,
|
|
action_slot: ActionSlot,
|
|
) -> None:
|
|
"""
|
|
Assumes the action already exists, that it might already have F-curves. Otherwise, the
|
|
only difference between versions is performance and implementation simplicity.
|
|
|
|
:arg lookup_fcurves: : This is only used for efficiency.
|
|
It's a substitute for ``action.fcurves.find()`` which is a potentially expensive linear search.
|
|
:type lookup_fcurves: ``Mapping[FCurveKey, bpy.types.FCurve]``
|
|
:arg action_group_name: Name of Action Group that F-curves are added to.
|
|
:type action_group_name: str
|
|
"""
|
|
linear_enum_values = [
|
|
bpy.types.Keyframe.bl_rna.properties["interpolation"].enum_items["LINEAR"].value
|
|
] * total_new_keys
|
|
|
|
for fc_key, key_values in self.keyframes_from_fcurve.items():
|
|
if len(key_values) == 0:
|
|
continue
|
|
|
|
fcurve = lookup_fcurves.get(fc_key, None)
|
|
if fcurve is None:
|
|
data_path, array_index = fc_key
|
|
assert action.is_action_layered
|
|
channelbag = _ensure_channelbag_exists(action, action_slot)
|
|
if not channelbag:
|
|
# Can happen if no layers or strips exist on the action.
|
|
continue
|
|
fcurve = channelbag.fcurves.new(data_path, index=array_index)
|
|
|
|
keyframe_points = fcurve.keyframe_points
|
|
|
|
co_buffer = [0] * (2 * len(keyframe_points))
|
|
keyframe_points.foreach_get("co", co_buffer)
|
|
co_buffer.extend(key_values)
|
|
|
|
ipo_buffer = [None] * len(keyframe_points)
|
|
keyframe_points.foreach_get("interpolation", ipo_buffer)
|
|
ipo_buffer.extend(linear_enum_values)
|
|
|
|
# XXX: Currently baking inserts the same number of keys for all baked properties.
|
|
# This block of code breaks if that's no longer true since we then will not be properly
|
|
# initializing all the data.
|
|
keyframe_points.add(total_new_keys)
|
|
keyframe_points.foreach_set("co", co_buffer)
|
|
keyframe_points.foreach_set("interpolation", ipo_buffer)
|
|
|
|
# This also deduplicates keys where baked keys were inserted on the
|
|
# same frame as existing ones.
|
|
fcurve.update()
|