Raincloud/blender-portable-repo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
blender-portable-repo/scripts/addons/cc_blender_tools-2_4_0/rigutils.py
T
Raincloud eef5547a2c 2026-03-11_4
2026-03-17 15:34:28 -06:00

4686 lines
181 KiB
Python
Raw Permalink Blame History

# Copyright (C) 2021 Victor Soupday
# This file is part of CC/iC Blender Tools <https://github.com/soupday/cc_blender_tools>
#
# CC/iC Blender Tools 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 3 of the License, or
# (at your option) any later version.
#
# CC/iC Blender Tools 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 CC/iC Blender Tools. If not, see <https://www.gnu.org/licenses/>.
import bpy
from mathutils import Vector, Matrix, Quaternion, Euler
from random import random
import re, time, os
from . import springbones, bones, facerig, modifiers, rigify_mapping_data, lib, utils, vars
from typing import List
def edit_rig(rig):
if rig and utils.edit_mode_to(rig):
return True
utils.log_error(f"Unable to edit rig: {rig}!")
return False
def select_rig(rig):
if rig and utils.object_mode_to(rig):
return True
utils.log_error(f"Unable to select rig: {rig}!")
return False
def pose_rig(rig):
if rig and utils.pose_mode_to(rig):
return True
utils.log_error(f"Unable to pose rig: {rig}!")
return False
def name_in_data_paths(action, name, slot_type=None):
channel = utils.get_action_channelbag(action, slot_type=slot_type)
if channel:
for fcurve in channel.fcurves:
if name in fcurve.data_path:
return True
return False
def name_in_pose_bone_data_paths_regex(action, name, slot_type=None):
channel = utils.get_action_channelbag(action, slot_type=slot_type)
if channel:
name = ".*" + name
for fcurve in channel.fcurves:
if re.match(name, fcurve.data_path):
return True
return False
def bone_name_in_armature_regex(arm, name):
for bone in arm.data.bones:
if re.match(name, bone.name):
return True
return False
def rig_has_bones(armature: bpy.types.Object, bones: list):
if armature:
if len(armature.data.bones) > 0:
for bone_name in bones:
if type(bone_name) is list:
found = False
for bn in bone_name:
if bn in armature.data.bones:
found = True
if not found:
return False
elif bone_name not in armature.data.bones:
return False
return True
return False
def action_has_bones(action: bpy.types.Action, bones: list):
channel = utils.get_action_channelbag(action, slot_type="OBJECT")
if channel:
if len(channel.fcurves) > 0:
for bone_name in bones:
if type(bone_name) is list:
found = False
for bn in bone_name:
if name_in_data_paths(action, bn, slot_type="OBJECT"):
found = True
if not found:
return False
elif not name_in_data_paths(action, bone_name, slot_type="OBJECT"):
return False
return True
return False
def is_G3_action(action):
return action_has_bones(action, rigify_mapping_data.CC3_BONE_NAMES)
def is_G3_armature(armature):
return rig_has_bones(armature, rigify_mapping_data.CC3_BONE_NAMES)
def is_iClone_action(action):
return action_has_bones(action, rigify_mapping_data.ICLONE_BONE_NAMES)
def is_iClone_armature(armature):
return rig_has_bones(armature, rigify_mapping_data.ICLONE_BONE_NAMES)
def is_ActorCore_action(action):
return action_has_bones(action, rigify_mapping_data.ACTOR_CORE_BONE_NAMES)
def is_ActorCore_armature(armature):
return rig_has_bones(armature, rigify_mapping_data.ACTOR_CORE_BONE_NAMES)
def is_GameBase_action(action):
return action_has_bones(action, rigify_mapping_data.GAME_BASE_BONE_NAMES)
def is_GameBase_armature(armature):
return rig_has_bones(armature, rigify_mapping_data.GAME_BASE_BONE_NAMES)
def is_Mixamo_action(action):
return action_has_bones(action, rigify_mapping_data.MIXAMO_BONE_NAMES)
def is_Mixamo_armature(armature):
return rig_has_bones(armature, rigify_mapping_data.MIXAMO_BONE_NAMES)
def is_rigify_action(action):
return action_has_bones(action, rigify_mapping_data.RIGIFY_BONE_NAMES)
def is_rigify_armature(armature):
return rig_has_bones(armature, rigify_mapping_data.RIGIFY_BONE_NAMES)
def is_rl_rigify_action(action):
return action_has_bones(action, rigify_mapping_data.RIGIFY_PLUS_BONE_NAMES)
def is_rigify_plus_armature(armature):
return rig_has_bones(armature, rigify_mapping_data.RIGIFY_PLUS_BONE_NAMES)
def is_rl_armature(armature):
if (is_ActorCore_armature(armature) or
is_G3_armature(armature) or
is_GameBase_armature(armature) or
is_iClone_armature(armature)):
return True
return False
def get_rig_generation(armature):
if is_ActorCore_armature(armature):
return "ActorCore"
elif is_G3_armature(armature):
return "G3"
elif is_GameBase_armature(armature):
return "GameBase"
elif is_iClone_armature(armature):
return "G3"
else:
return "Unknown"
def is_unity_action(action):
return "_Unity" in action.name and "|A|" in action.name
def get_armature_action_source_type(armature, action=None):
if armature and not action and armature.type == "ARMATURE":
if is_G3_armature(armature):
return "G3", "G3 (CC3/CC3+)"
if is_iClone_armature(armature):
return "G3", "G3 (iClone)"
if is_ActorCore_armature(armature):
return "G3", "G3 (ActorCore)"
if is_GameBase_armature(armature):
return "GameBase", "GameBase (CC3/CC3+)"
if is_Mixamo_armature(armature):
return "Mixamo", "Mixamo"
if is_rigify_plus_armature(armature):
return "Rigify+", "Rigify+"
if is_rigify_armature(armature):
return "Rigify", "Rigify"
if armature and action and armature.type == "ARMATURE":
if is_G3_armature(armature) and is_G3_action(action):
return "G3", "G3 (CC3/CC3+)"
if is_iClone_armature(armature) and is_iClone_action(action):
return "G3", "G3 (iClone)"
if is_ActorCore_armature(armature) and is_ActorCore_action(action):
return "G3", "G3 (ActorCore)"
if is_GameBase_armature(armature) and is_GameBase_action(action):
return "GameBase", "GameBase (CC3/CC3+)"
if is_Mixamo_armature(armature) and is_Mixamo_action(action):
return "Mixamo", "Mixamo"
if is_rigify_plus_armature(armature) and is_rl_rigify_action(action):
return "Rigify+", "Rigify+"
if is_rigify_armature(armature) and is_rigify_action(action):
return "Rigify", "Rigify"
# detect other types as they become available...
return "Unknown", "Unknown"
def find_source_actions(source_action, source_rig=None):
src_set_id, src_set_gen, src_type_id, src_object_id = get_motion_set_ids(source_action)
src_prefix = get_motion_prefix(source_action)
src_prefix, src_rig_id, src_type_id, src_object_id, src_motion_id = decode_action_name(source_action)
if not src_motion_id:
src_motion_id = get_motion_id(source_action)
actions = {
"motion_info": {
"prefix": src_prefix,
"motion_id": src_motion_id,
"set_id": src_set_id,
"set_generation": src_set_gen,
"slotted": False,
},
"count": 0,
"armature": None,
"armatures": [],
"keys": {},
"objects": {},
}
if src_set_id:
utils.log_info(f"Looking for motion set id: {src_set_id}")
for action in bpy.data.actions:
if "rl_set_id" in action:
set_id, set_gen, type_id, object_id = get_motion_set_ids(action)
unused = utils.get_prop(action, "rl_unused_action", False)
if set_id == src_set_id:
if type_id == "KEY":
utils.log_info(f" - Found shape-key action: {action.name} for {object_id}")
actions["keys"][object_id] = action
elif type_id == "ARM" or type_id == "SLOTTED":
utils.log_info(f" - Found armature action: {action.name}")
actions["armatures"].append(action)
if not unused and not actions["armature"]:
actions["armature"] = action
actions["slotted"] = (type_id == "SLOTTED")
return actions
# try matching actions by action name pattern
if src_type_id and src_motion_id:
# match actions by name pattern
utils.log_info(f"Looking for shape-key actions matching: [<{src_prefix}>|]{src_rig_id}|[K|A]|[<obj>|]{src_motion_id}")
for action in bpy.data.actions:
motion_prefix, rig_id, type_id, object_id, motion_id = decode_action_name(action)
if (motion_id and object_id not in actions and
motion_prefix == src_prefix and
rig_id == src_rig_id and
utils.partial_match(motion_id, src_motion_id)):
if type_id == "K":
utils.log_info(f" - Found shape-key action: {action.name} for {object_id}")
actions["keys"][object_id] = action
elif type_id == "A":
utils.log_info(f" - Found armature action: {action.name}")
actions["armature"] = action
return actions
# try to fetch shape-key actions from source armature child objects, if supplied
elif source_rig:
utils.log_info(f"Looking for shape-key actions in armature child objects: {source_rig.name}")
action = utils.safe_get_action(source_rig)
if action:
utils.log_info(f" - Found armature action: {action.name}")
actions["armature"] = action
for obj in source_rig.children:
obj_id = get_obj_id(obj)
if obj.type == "MESH":
action = utils.safe_get_action(obj.data.shape_keys)
if action:
utils.log_info(f" - Found shape-key action: {action.name} for {obj_id}")
actions["keys"][obj_id] = action
actions["objects"][obj_id] = obj
return actions
return actions
def get_main_body_action(source_actions):
# find the "Body" action
for obj_id in source_actions["keys"]:
action: bpy.types.Action = source_actions["keys"][obj_id]
l_name = obj_id.lower()
if l_name == "body":
utils.log_info(f" - Using main body action: {action.name}")
return action
# find the action with the most shape keys
action_with_most_keys = None
num_keys = 0
for obj_id in source_actions["keys"]:
action = source_actions["keys"][obj_id]
channel = utils.get_action_channelbag(action, slot_type="KEY")
if channel:
if len(channel.fcurves) > num_keys:
num_keys = len(channel.fcurves)
action_with_most_keys = action
if action_with_most_keys:
utils.log_info(f" - Using action with most shape keys: {action_with_most_keys.name}")
else:
utils.log_info(f" - No shape key actions in this Motion set!")
return action_with_most_keys
"""
# TODO: No longer used.
def apply_source_actions(dst_rig, source_actions, copy=False,
motion_id=None, motion_prefix=None,
set_id=None, set_generation=None,
all_matching=False, filter=None):
apply_source_armature_action(dst_rig, source_actions, copy=copy,
motion_id=motion_id, motion_prefix=motion_prefix,
set_id=set_id, set_generation=set_generation)
apply_source_key_actions(dst_rig, source_actions, copy=copy,
all_matching=all_matching,
motion_id=motion_id, motion_prefix=motion_prefix,
set_id=set_id, set_generation=set_generation,
filter=filter)
# TODO: No longer used.
def apply_source_armature_action(dst_rig, source_actions, copy=False,
motion_id=None, motion_prefix=None,
set_id=None, set_generation=None):
obj_used = []
actions_used = []
rig_id = get_rig_id(dst_rig)
rl_arm_id = utils.get_rl_object_id(dst_rig)
if not motion_id:
motion_id = source_actions["motion_info"]["motion_id"]
if motion_prefix is None:
motion_prefix = source_actions["motion_info"]["prefix"]
utils.log_info(f"Applying source armature action:")
action = source_actions["armature"]
is_slotted = source_actions["slotted"]
if action:
if copy and motion_id:
action_name = make_armature_action_name(rig_id, motion_id, motion_prefix)
utils.log_info(f" - Copying action: {action.name} to {action_name}")
action = utils.copy_action(action, action_name)
if set_id and set_generation:
add_motion_set_data(action, set_id, set_generation, rl_arm_id=rl_arm_id, slotted=is_slotted)
utils.log_info(f" - Applying action: {action.name} to {rig_id}")
load_slotted_action(dst_rig, action)
obj_used.append(dst_rig)
actions_used.append(action)
return obj_used, actions_used
# TODO: No longer used.
def apply_source_key_actions(dst_rig, source_actions, all_matching=False, copy=False,
motion_id=None, motion_prefix=None,
set_id=None, set_generation=None,
filter=None):
obj_used = []
key_actions = {}
if source_actions["slotted"]:
return key_actions
rig_id = get_rig_id(dst_rig)
if motion_id == "" or motion_id == "TEMP":
motion_id = "TEMP_" + utils.generate_random_id(12)
if motion_id is None:
motion_id = source_actions["motion_info"]["motion_id"]
if motion_prefix is None:
motion_prefix = source_actions["motion_info"]["prefix"]
# TODO this should really collect all named shape key animation tracks across all source objects
# and create actions specific to each target object.
# e.g. facial hair meshes have tongue shape keys which the body action alone doesn't have.
# apply to exact matches first
utils.log_info(f"Applying source key actions: (copy={copy}, motion_id={motion_id})")
objects = utils.get_child_objects(dst_rig)
for obj in objects:
if filter and obj not in filter: continue
if obj.type == "MESH":
if utils.object_has_shape_keys(obj):
obj_id = get_action_obj_id(obj)
old_action = utils.safe_get_action(obj.data.shape_keys)
if (obj_id in source_actions["keys"] and
obj_has_action_shape_keys(obj, source_actions["keys"][obj_id])):
action = source_actions["keys"][obj_id]
if copy and motion_id:
action_name = make_key_action_name(rig_id, motion_id, obj_id, motion_prefix)
utils.log_info(f" - Copying action: {action.name} to {action_name}")
action = utils.copy_action(action, action_name)
if set_id and set_generation:
add_motion_set_data(action, set_id, set_generation, obj_id=obj_id)
utils.log_info(f" - Applying action: {action.name} to {obj_id}")
utils.safe_set_action(obj.data.shape_keys, action)
obj_used.append(obj)
key_actions[obj_id] = (action, old_action)
else:
utils.safe_set_action(obj.data.shape_keys, None)
# apply to other compatible shape key objects
if all_matching:
utils.log_info(f"Applying other matching source key actions:")
body_action = get_main_body_action(source_actions)
for obj in objects:
if filter and obj not in filter: continue
if obj not in obj_used and utils.object_has_shape_keys(obj):
obj_id = get_action_obj_id(obj)
old_action = utils.safe_get_action(obj.data.shape_keys)
if body_action:
if obj_has_action_shape_keys(obj, body_action):
action = body_action
if copy and motion_id:
action_name = make_key_action_name(rig_id, motion_id, obj_id, motion_prefix)
utils.log_info(f" - Copying action: {action.name} to {action_name}")
action = utils.copy_action(action, action_name)
if set_id and set_generation:
add_motion_set_data(action, set_id, set_generation, obj_id=obj_id)
utils.log_info(f" - Applying action: {action.name} to {obj_id}")
utils.safe_set_action(obj.data.shape_keys, action)
obj_used.append(obj)
key_actions[obj_id] = (action, old_action)
return key_actions
"""
def obj_has_action_shape_keys(obj, action: bpy.types.Action):
channel = utils.get_action_channelbag(action, slot_type="KEY")
if channel:
if obj.data.shape_keys and obj.data.shape_keys.key_blocks:
for key in obj.data.shape_keys.key_blocks:
for fcurve in channel.fcurves:
if key.name in fcurve.data_path:
return True
return False
def get_rig_id(rig):
rig_id = utils.strip_name(rig.name.strip()).replace("|", "_")
return rig_id
def get_armature_id(rig):
return utils.get_prop(rig, "rl_armature_id", None)
def get_motion_id(action):
if type(action) is str:
action_name = action
else:
action_name = action.name
ids = action_name.split("|")
if ids:
return ids[-1]
return action_name
def decode_action_name(action):
"""Decode action name into prefix, rig_id, type("A"|"K"), object_id, motion_id.
if the action name does not follow this naming pattern all values return None."""
if type(action) is str:
action_name = action
else:
action_name = action.name
#utils.log_detail(f"Decoding Action name: {action_name}")
motion_id = action_name
prefix = ""
rig_id = ""
type_id = "A"
obj_id = ""
try:
ids = action_name.split("|")
for i, id in enumerate(ids):
ids[i] = id.strip()
L = len(ids)
K = L
if "A" in ids or "UA" in ids or "S" in ids:
K -= 1
elif "K" in ids or "UK" in ids:
K -= 2
if L > 0:
motion_id = ids[-1]
if K >= 3:
prefix = ids[0]
rig_id = ids[1]
elif K >= 2:
rig_id = ids[0]
if "rl_action_type" in action:
if action["rl_action_type"] == "ARM":
type_id = "A"
elif action["rl_action_type"] == "KEY":
type_id = "K"
if "rl_key_object" in action:
obj_id = action["rl_key_object"]
elif action["rl_action_type"] == "SLOTTED":
type_id = "S"
else:
if "A" in ids:
type_id = "A"
elif "K" in ids:
type_id = "K"
i = ids.index("K")
if L > i+1:
obj_id = ids[i+1]
elif "S" in ids:
type_id = "S"
except Exception as e:
prefix = None
rig_id = None
type_id = None
obj_id = None
motion_id = action_name
return prefix, rig_id, type_id, obj_id, motion_id
def get_motion_id(action, default_name="Motion"):
if action:
motion_id = action.name.split("|")[-1].strip()
else:
motion_id = ""
if not motion_id and default_name:
motion_id = f"{default_name}_{utils.generate_random_id(8)}"
return motion_id
def get_motion_prefix(action, default_prefix=""):
prefix = decode_action_name(action)[0]
if prefix is None:
return default_prefix
elif prefix:
return prefix.strip()
else:
return prefix
def get_obj_id(obj):
obj_id = utils.strip_cc_base_name(obj.name).replace("|", "_")
return obj_id
def get_formatted_prefix(motion_prefix):
if motion_prefix is None:
motion_prefix = ""
motion_prefix = motion_prefix.strip().replace("|", "_")
while motion_prefix.endswith("_"):
motion_prefix = motion_prefix[:-1]
return motion_prefix
def get_unique_set_motion_id(rig_id, motion_id, motion_prefix, exclude_set_id=None, slotted=False):
test_name = make_armature_action_name(rig_id, motion_id, motion_prefix, slotted=slotted)
base_name = test_name
num_suffix = 0
while test_name in bpy.data.actions:
if exclude_set_id and "rl_set_id" in bpy.data.actions[test_name]:
if exclude_set_id == bpy.data.actions[test_name]["rl_set_id"]:
break
num_suffix += 1
test_name = f"{base_name}_{num_suffix:03d}"
if num_suffix > 0:
motion_id += f"_{num_suffix:03d}"
return motion_id
def generate_action_name(rig_id, code_id, obj_id, motion_id, motion_prefix):
f_prefix = get_formatted_prefix(motion_prefix)
name = ""
if f_prefix:
name += f"{f_prefix}"
if rig_id:
if name: name += "|"
name += f"{rig_id}"
if code_id:
if name: name += "|"
name += f"{code_id}"
if obj_id:
if name: name += "|"
name += f"{obj_id}"
if motion_id:
if name: name += "|"
name += f"{motion_id}"
return name
#return f"{f_prefix}{rig_id}|{code_id}|{motion_id}"
def make_armature_action_name(rig_id, motion_id, motion_prefix, slotted=False):
if slotted:
return generate_action_name(rig_id, "", "", motion_id, motion_prefix)
else:
return generate_action_name(rig_id, "A", "", motion_id, motion_prefix)
def make_key_action_name(rig_id, motion_id, obj_id, motion_prefix):
return generate_action_name(rig_id, "K", obj_id, motion_id, motion_prefix)
def set_armature_action_name(action, rig_id, motion_id, motion_prefix, slotted=False):
action.name = make_armature_action_name(rig_id, motion_id, motion_prefix, slotted=slotted)
def set_key_action_name(action, rig_id, motion_id, obj_id, motion_prefix):
action.name = make_key_action_name(rig_id, motion_id, obj_id, motion_prefix)
def get_set_generation(rig):
return utils.get_prop(rig, "rl_set_generation", None)
def update_rig_set_generation(rig):
rl_set_generation, source_label = get_armature_action_source_type(rig)
if ("rl_set_generation" not in rig or
rig["rl_set_generation"] != rl_set_generation):
rig["rl_set_generation"] = rl_set_generation
return rl_set_generation
def generate_set_id():
return utils.generate_random_id(32)
def generate_motion_set(rig, motion_id, motion_prefix):
rl_set_id = generate_set_id()
rl_set_generation = update_rig_set_generation(rig)
return rl_set_id, rl_set_generation
def get_motion_set_ids(action):
set_id = utils.get_prop(action, "rl_set_id", None)
set_generation = utils.get_prop(action, "rl_set_generation", None)
action_type_id = utils.get_prop(action, "rl_action_type", None)
key_object = utils.get_prop(action, "rl_key_object", None)
return set_id, set_generation, action_type_id, key_object
def get_motion_set_actions(action_or_set_id):
actions = []
if type(action_or_set_id) is bpy.types.Action:
set_id = utils.get_prop(action_or_set_id, "rl_set_id", None)
else:
set_id = action_or_set_id
if set_id:
for action in bpy.data.actions:
if utils.get_prop(action, "rl_set_id") == set_id:
actions.append(action)
return actions
def get_actions_frame_range(actions):
action: bpy.types.Action = None
frame_start = None
frame_end = None
for action in actions:
start = action.frame_range[0]
end = action.frame_range[1]
if frame_start is None:
frame_start = start
frame_end = end
if start < frame_start:
frame_start = start
if end > frame_end:
frame_end = end
return frame_start, frame_end
def get_motion_set_frame_range(action_or_set_id):
actions = get_motion_set_actions(action_or_set_id)
return get_actions_frame_range(actions)
def replace_motion_set(set_id, old_set_id):
actions = get_motion_set_actions(set_id)
old_actions = get_motion_set_actions(old_set_id)
temp_id = generate_set_id()
name = old_actions[0].name if len(old_actions) == 1 else None
for action in actions:
if name:
utils.force_action_name(action, name)
utils.set_prop(action, "rl_set_id", old_set_id)
for action in old_actions:
utils.set_prop(action, "rl_set_id", temp_id)
delete_motion_set(temp_id)
def add_motion_set_data(action, set_id, set_generation, obj_id=None, arm_id=None, slotted=False):
action["rl_set_id"] = set_id
action["rl_set_generation"] = set_generation
if slotted:
action["rl_action_type"] = "SLOTTED"
elif obj_id is not None:
action["rl_action_type"] = "KEY"
action["rl_key_object"] = obj_id
else:
action["rl_action_type"] = "ARM"
if arm_id is not None:
action["rl_armature_id"] = arm_id
def update_motion_set_index(action):
props = vars.props()
props.action_set_list_index = utils.index_in_collection(action, bpy.data.actions)
def load_motion_set(rig, action, move=False, temp=None):
prefs = vars.prefs()
if action:
utils.log_info(f"Load Motion Set: {action.name} {'Move ' if move else ''}{'Temp ' if temp else ''}")
else:
utils.log_info(f"Clearing Motion Set ...")
# clear the pose and shape-keys first before loading the motion set
clear_motion_set(rig)
arm_action = action
if action:
utils.log_indent()
if prefs.use_action_slots():
arm_action = load_slotted_action(rig, action,
move=move, temp=temp)
else:
arm_action = load_separate_actions(rig, action,
move=move, temp=temp)
if arm_action:
update_motion_set_index(arm_action)
utils.log_recess()
return arm_action
def new_motion_set(rig):
prefs = vars.prefs()
slotted = prefs.use_action_slots()
rig_id = get_rig_id(rig)
rl_arm_id = utils.get_rl_object_id(rig)
set_id = generate_set_id()
set_generation = utils.get_prop(rig, "rl_set_generation")
motion_id = "New"
motion_id = get_unique_set_motion_id(rig_id, motion_id, "", slotted=slotted)
action_name = make_armature_action_name(rig_id, motion_id, "", slotted=slotted)
action = bpy.data.actions.new(action_name)
slot, channel = add_action_ob_slot_channelbag(action, rig)
add_motion_set_data(action, set_id, set_generation, arm_id=rl_arm_id, slotted=slotted)
utils.safe_set_action(rig, action, slot=slot)
utils.safe_set_action(rig.data, None, create=False)
for child in rig.children:
if utils.object_exists_is_mesh(child) and utils.object_has_shape_keys(child):
utils.safe_set_action(child, None, create=False)
utils.safe_set_action(child.data, None, create=False)
utils.safe_set_action(child.data.shape_keys, None, create=False)
update_motion_set_index(action)
return action
def clear_motion_set(rig):
mode_selection = utils.store_mode_selection_state()
has_actions = utils.safe_get_action(rig)
if not has_actions:
reset_pose(rig)
utils.safe_set_action(rig, None)
objects = utils.get_child_objects(rig)
for obj in objects:
if obj.type == "MESH":
if utils.object_has_shape_keys(obj):
utils.safe_set_action(obj.data.shape_keys, None)
if not has_actions:
reset_shape_keys(obj)
utils.restore_mode_selection_state(mode_selection)
def clear_all_actions(objects):
for obj in objects:
if utils.object_exists_is_armature(obj):
utils.safe_set_action(obj, None)
elif utils.object_exists_is_mesh(obj):
if utils.object_has_shape_keys(obj):
utils.safe_set_action(obj.data.shape_keys, None)
def push_motion_set(rig: bpy.types.Object, set_armature_action, push_index = 0):
prefs = vars.prefs()
source_actions = find_source_actions(set_armature_action, None)
frame = bpy.context.scene.frame_current
set_arm_action: bpy.types.Action = source_actions["armature"]
start = int(set_arm_action.frame_range[0])
end = int(set_arm_action.frame_range[1])
length = end - start
is_slotted = prefs.use_action_slots() and utils.get_prop(set_arm_action, "rl_action_type") == "SLOTTED"
objects = utils.get_child_objects(rig)
# find all available NLA tracks
nla_data = []
if rig.animation_data.nla_tracks:
nla_data.append(rig.animation_data.nla_tracks)
for obj in objects:
if obj.data.shape_keys and obj.data.shape_keys.animation_data:
if obj.data.shape_keys.animation_data.nla_tracks:
nla_data.append(obj.data.shape_keys.animation_data.nla_tracks)
# count the mininum number of shared tracks across all action objects
min_tracks = 0
for nla_tracks in nla_data:
l = len(nla_tracks)
if l > 0:
if min_tracks == 0:
min_tracks = l
min_tracks = min(min_tracks, l)
# find the first available track that can fit the motion set
available_tracks = [True] * min_tracks
for nla_tracks in nla_data:
for i in range(0, min_tracks):
track: bpy.types.NlaTrack = nla_tracks[i]
strip: bpy.types.NlaStrip
for strip in track.strips:
if frame >= strip.frame_start and frame < strip.frame_end:
available_tracks[i] = False
elif (frame + length) >= strip.frame_start and (frame + length) < strip.frame_end:
available_tracks[i] = False
elif strip.frame_start < frame and strip.frame_end >= frame + length:
available_tracks[i] = False
track_index = -1
for i, available in enumerate(available_tracks):
if available:
track_index = i
break
# push the actions
action: bpy.types.Action = source_actions["armature"]
rig: bpy.types.Object
if rig.animation_data is None:
rig.animation_data_create()
if not rig.animation_data.nla_tracks or track_index == -1:
track = rig.animation_data.nla_tracks.new()
else:
track = rig.animation_data.nla_tracks[track_index]
try:
strip = track.strips.new(action.name, frame, action)
except:
track = rig.animation_data.nla_tracks.new()
strip = track.strips.new(action.name, frame, action)
strip.action_frame_start = start
strip.action_frame_end = end
strip.name = f"{action.name}|{push_index:03d}"
for obj in objects:
if is_slotted:
if "KEAll Keys" in action.slots:
obj_id = "KEAll Keys"
else:
obj_id = "KE" + obj.name
if obj.type == "MESH" and obj_id in action.slots:
slot = action.slots[obj_id]
if obj.data.shape_keys:
if not obj.data.shape_keys.animation_data:
obj.data.shape_keys.animation_data_create()
if not obj.data.shape_keys.animation_data.nla_tracks or track_index == -1:
track = obj.data.shape_keys.animation_data.nla_tracks.new()
else:
track = obj.data.shape_keys.animation_data.nla_tracks[track_index]
try:
strip = track.strips.new(action.name, frame, action)
except:
track = obj.data.shape_keys.animation_data.nla_tracks.new()
strip = track.strips.new(action.name, frame, action)
strip.action_slot = slot
strip.action_frame_start = start
strip.action_frame_end = end
strip.name = f"{action.name}|{push_index:03d}"
else:
obj_id = get_obj_id(obj)
if obj.type == "MESH" and obj_id in source_actions["keys"]:
action = source_actions["keys"][obj_id]
if obj.data.shape_keys:
if not obj.data.shape_keys.animation_data:
obj.data.shape_keys.animation_data_create()
if not obj.data.shape_keys.animation_data.nla_tracks or track_index == -1:
track = obj.data.shape_keys.animation_data.nla_tracks.new()
else:
track = obj.data.shape_keys.animation_data.nla_tracks[track_index]
try:
strip = track.strips.new(action.name, frame, action)
except:
track = obj.data.shape_keys.animation_data.nla_tracks.new()
strip = track.strips.new(action.name, frame, action)
strip.action_frame_start = start
strip.action_frame_end = end
strip.name = f"{action.name}|{push_index:03d}"
def clear_animation_data(obj: bpy.types.Object):
if obj.type == "ARMATURE" or obj.type == "MESH":
# remove action
utils.safe_set_action(obj, None)
# remove strips
# this removes drivers too...
#obj.animation_data_clear()
ad = obj.animation_data
if ad:
while ad.nla_tracks:
ad.nla_tracks.remove(ad.nla_tracks[0])
if obj.type == "MESH":
# remove shape key action
utils.safe_set_action(obj.data.shape_keys, None)
# remove shape key strips
if obj.data.shape_keys and obj.data.shape_keys.animation_data:
obj.data.shape_keys.animation_data_clear()
ad = obj.data.shape_keys.animation_data
if ad:
while ad.nla_tracks:
ad.nla_tracks.remove(ad.nla_tracks[0])
def reset_nla_tracks(obj):
track = None
if obj.type == "ARMATURE" or obj.type == "MESH":
# remove action
utils.safe_set_action(obj, None)
# remove strips
ad = obj.animation_data
if ad:
while ad.nla_tracks:
ad.nla_tracks.remove(ad.nla_tracks[0])
if obj.type == "MESH":
# remove shape key action
utils.safe_set_action(obj.data.shape_keys, None)
# remove shape key strips
if obj.data.shape_keys and obj.data.shape_keys.animation_data:
ad = obj.data.shape_keys.animation_data
if ad:
while ad.nla_tracks:
ad.nla_tracks.remove(ad.nla_tracks[0])
return track
def create_key_proxy_object(obj_id, action: bpy.types.Action=None,
shape_keys=None, parent=None, channel=None):
# create object
bpy.ops.mesh.primitive_cube_add(size=0.1, enter_editmode=False,
align='WORLD',
location=(0, 0, 0),
scale=(1, 1, 1))
obj: bpy.types.Object = utils.get_active_object()
obj.shape_key_add(name="Basis")
name = f"Key_Proxy_{obj_id}"
obj.name = name
obj.data.name = name
obj["key_proxy"] = "WqebNXksi9wLQwco1hyFQMlIYcbqWGZF"
obj.data["key_proxy"] = "WqebNXksi9wLQwco1hyFQMlIYcbqWGZF"
if parent:
obj.parent = parent
obj.hide_set(True)
if channel:
for fcurve in channel.fcurves:
data_path = fcurve.data_path
if data_path.startswith("key_blocks["):
key_name = data_path[12:-8]
key = obj.shape_key_add(name=key_name)
key.slider_max = 1.5
key.slider_min = -1.5
elif action:
channel = utils.get_action_channelbag(action, slot_type="KEY")
for fcurve in channel.fcurves:
data_path = fcurve.data_path
if data_path.startswith("key_blocks["):
key_name = data_path[12:-8]
key = obj.shape_key_add(name=key_name)
key.slider_max = 1.5
key.slider_min = -1.5
elif shape_keys:
if "Basis" in shape_keys:
shape_keys.remove("Basis")
for key_name in shape_keys:
key = obj.shape_key_add(name=key_name)
key.slider_max = 1.5
key.slider_min = -1.5
return obj
def get_shape_key_action_objects(rigify_rig, source_rig, source_action=None, shape_keys=None):
objects = []
if source_rig and source_action:
source_actions = find_source_actions(source_action, source_rig)
if source_actions["slotted"]:
channelbags = utils.get_action_channelbags(source_action)
for channel in channelbags:
slot = channel.slot
if slot.target_id_type == "KEY":
obj_id = slot.name_display
obj = create_key_proxy_object(obj_id, parent=source_rig, channel=channel)
utils.safe_set_action(obj.data.shape_keys, source_action, slot=slot)
objects.append(obj)
else:
for obj_id, obj_action in source_actions["keys"].items():
# we don't need all the objects, just these three
if obj_id in ["Body", "Tongue", "Eye"]:
obj = create_key_proxy_object(obj_id, action=obj_action, parent=source_rig)
utils.safe_set_action(obj.data.shape_keys, obj_action)
objects.append(obj)
elif shape_keys:
obj = create_key_proxy_object(f"Key_Proxy_{rigify_rig.name}", shape_keys=shape_keys, parent=source_rig)
objects.append(obj)
return objects
def apply_fast_key_proxies(objects=None):
store = {}
if not objects:
objects = list(bpy.data.objects)
RBWC = bpy.data.collections["RigidBodyWorld"] if "RigidBodyWorld" in bpy.data.collections else None
for obj in objects:
if utils.object_exists_is_mesh(obj):
# don't replace widgets
if obj.name.startswith("WGT-"): continue
# don't replace rigid body world meshes
if RBWC and obj.name in RBWC.objects: continue
# don't replace existing key_proxies
if "key_proxy" in obj: continue
key_action, key_slot = utils.safe_get_action_slot(obj.data.shape_keys)
if utils.object_has_shape_keys(obj):
keys = [ key.name for key in obj.data.shape_keys.key_blocks ]
else:
keys = None
values = None
proxy = create_key_proxy_object(obj.name, shape_keys=keys)
proxy_mesh = proxy.data
bpy.data.objects.remove(proxy)
store[obj.name] = obj.data
obj.data = proxy_mesh
utils.safe_set_action(proxy_mesh.shape_keys, key_action, slot=key_slot)
return store
def restore_fast_key_proxies(store):
if store:
for obj_name in store:
if obj_name in bpy.data.objects:
obj = bpy.data.objects[obj_name]
if utils.get_prop(obj.data, "key_proxy") == "WqebNXksi9wLQwco1hyFQMlIYcbqWGZF":
proxy_mesh = obj.data
obj.data = store[obj_name]
if obj.data.shape_keys:
action, slot = utils.safe_get_action_slot(proxy_mesh.shape_keys)
utils.safe_set_action(obj.data.shape_keys, action, slot=slot)
bpy.data.meshes.remove(proxy_mesh)
def clean_up_shape_key_proxy_objects():
for obj in bpy.data.objects:
if utils.get_prop(obj, "key_proxy") == "WqebNXksi9wLQwco1hyFQMlIYcbqWGZF":
utils.delete_object(obj)
def get_nla_tracks(data):
try:
if data and data.animation_data and data.animation_data.nla_tracks:
return data.animation_data.nla_tracks
except:
return None
def get_all_nla_strips(data, obj, strips=None):
if strips is None:
strips = {}
tracks = get_nla_tracks(data)
if tracks:
for track in tracks:
for strip in track.strips:
strips[strip] = (obj, track)
return strips
def get_strips_by_sets(set_ids: set):
all_strips = {}
for obj in bpy.data.objects:
if utils.object_exists(obj):
if obj.type == "ARMATURE":
get_all_nla_strips(obj, obj, all_strips)
elif obj.type == "MESH":
get_all_nla_strips(obj.data.shape_keys, obj, all_strips)
strip: bpy.types.NlaStrip
strips = {}
for strip in all_strips:
strip_set_id = utils.get_prop(strip.action, "rl_set_id")
for sel_set_id, sel_auto_index in set_ids:
if strip_set_id == sel_set_id:
strip_auto_index = utils.get_auto_index_suffix(strip.name)
if strip_auto_index == sel_auto_index:
obj, track = all_strips[strip]
strips[strip] = (obj, track)
return strips
def unselect_all_but_strip(active_strip):
all_strips = {}
for obj in bpy.data.objects:
if utils.object_exists(obj):
if obj.type == "ARMATURE":
get_all_nla_strips(obj, obj, all_strips)
elif obj.type == "MESH":
get_all_nla_strips(obj.data.shape_keys, obj, all_strips)
for strip in all_strips:
if strip != active_strip and strip.select:
strip.select = False
def select_strips_by_set(active_strip: bpy.types.NlaStrip):
strips = bpy.context.selected_nla_strips.copy()
set_ids = set()
for strip in strips:
set_id = utils.get_prop(strip.action, "rl_set_id")
strip_auto_index = utils.get_auto_index_suffix(strip.name)
if set_id and strip_auto_index:
set_ids.add((set_id, strip_auto_index))
if not active_strip and bpy.context.selected_nla_strips:
active_strip = bpy.context.selected_nla_strips[0]
if active_strip:
unselect_all_but_strip(active_strip)
strips = get_strips_by_sets(set_ids)
for strip in strips:
strip.select = True
def align_strips(strips, to_strip: bpy.types.NlaStrip=None, left=True):
strip: bpy.types.NlaStrip
left_frame = None if not to_strip else to_strip.frame_start
right_frame = None if not to_strip else to_strip.frame_end
# if no active strip, get the left most and right most frame in all strips
if not to_strip:
for strip in strips:
if left_frame is None:
left_frame = strip.frame_start
if right_frame is None:
right_frame = strip.frame_end
left_frame = min(strip.frame_start, left_frame)
right_frame = max(strip.frame_end, right_frame)
# align strips
# TODO sort strips in reverse order of direction
for strip in strips:
length = strip.frame_end - strip.frame_start
if left:
strip.frame_start = left_frame
strip.frame_end = strip.frame_start + length
strip.frame_start = strip.frame_end - length
else:
strip.frame_end = right_frame
strip.frame_start = strip.frame_end - length
strip.frame_end = strip.frame_start + length
def size_strips(strips, to_strip: bpy.types.NlaStrip=None, longest=True, reset=False):
to_length = 0
if to_strip:
to_length = to_strip.frame_end - to_strip.frame_start
min_length = None
max_length = None
strip: bpy.types.NlaStrip
# find the shortest and longest strip lengths
for strip in strips:
length = strip.frame_end - strip.frame_start
if min_length is None:
min_length = length
if max_length is None:
max_length = length
min_length = min(length, min_length)
max_length = max(length, max_length)
if not to_strip:
to_length = max_length if longest else min_length
for strip in strips:
if reset:
action_length = int(strip.action.frame_range[1] - strip.action.frame_range[0])
strip.frame_end = strip.frame_start + action_length
strip.frame_start = strip.frame_end - action_length
elif to_length > 0:
strip.frame_end = strip.frame_start + to_length
strip.frame_start = strip.frame_end - to_length
def set_action_set_fake_user(action, use_fake_user):
set_id = utils.get_prop(action, "rl_set_id")
if set_id:
for action in bpy.data.actions:
action_set_id = utils.get_prop(action, "rl_set_id")
if action_set_id == set_id:
action.use_fake_user = use_fake_user
utils.update_ui(all=True)
def delete_motion_set(action_or_set_id):
if type(action_or_set_id) is bpy.types.Action:
set_id = utils.get_prop(action_or_set_id, "rl_set_id")
else:
set_id = action_or_set_id
to_remove = []
if set_id:
for action in bpy.data.actions:
action_set_id = utils.get_prop(action, "rl_set_id")
if action_set_id == set_id:
to_remove.append(action)
for action in to_remove:
bpy.data.actions.remove(action)
utils.update_ui(all=True)
def duplicate_motion_set(source_action):
set_id = utils.get_prop(source_action, "rl_set_id")
set_generation = utils.get_prop(source_action, "rl_set_generation", None)
action_type_id = utils.get_prop(source_action, "rl_action_type", None)
arm_id = utils.get_prop(source_action, "rl_armature_id", None)
new_set_id = generate_set_id()
duplicates = []
if set_id:
for action in bpy.data.actions:
action_set_id = utils.get_prop(action, "rl_set_id")
if action_set_id == set_id:
set_generation = utils.get_prop(action, "rl_set_generation", set_generation)
action_type_id = utils.get_prop(action, "rl_action_type", action_type_id)
obj_id = utils.get_prop(action, "rl_key_object", None)
arm_id = utils.get_prop(action, "rl_armature_id", arm_id)
is_slotted = action_type_id == "SLOTTED"
duplicate_action = action.copy()
add_motion_set_data(duplicate_action, new_set_id, set_generation, obj_id, arm_id, slotted=is_slotted)
duplicates.append(duplicate_action)
update_motion_set_index(source_action)
utils.update_ui(all=True)
def rename_armature(arm, name):
armature_object = None
armature_data = None
try:
armature_object = bpy.data.objects[name]
except:
pass
try:
armature_data = bpy.data.armatures[name]
except:
pass
utils.force_object_name(arm, name)
utils.force_armature_name(arm.data, name)
return armature_object, armature_data
def restore_armature_names(armature_object, armature_data, name):
if armature_object:
utils.force_object_name(armature_object, name)
if armature_data:
utils.force_armature_name(armature_data, name)
def get_rigify_ik_fk_influence_avg(rig):
ik_fk = 0
num_bones = 0
ik_fk_control_bones = ["upper_arm_parent.L", "upper_arm_parent.R", "thigh_parent.L", "thigh_parent.R"]
for bone_name in ik_fk_control_bones:
if bone_name in rig.pose.bones:
num_bones += 1
pose_bone = rig.pose.bones[bone_name]
ik_fk += pose_bone["IK_FK"]
if num_bones > 0:
ik_fk /= num_bones
return ik_fk
def get_rigify_ik_fk_influence(rig):
ik_fk_control_bones = ["upper_arm_parent.L", "upper_arm_parent.R", "thigh_parent.L", "thigh_parent.R"]
ik_fk = [0,0,0,0]
for i, bone_name in enumerate(ik_fk_control_bones):
if bone_name in rig.pose.bones:
pose_bone = rig.pose.bones[bone_name]
ik_fk[i] = pose_bone["IK_FK"]
return ik_fk
def set_rigify_ik_fk_influence(rig, ik_fk):
ik_fk_control_bones = ["upper_arm_parent.L", "upper_arm_parent.R", "thigh_parent.L", "thigh_parent.R"]
if type(ik_fk) is list:
for i, bone_name in enumerate(ik_fk_control_bones):
if bone_name in rig.pose.bones:
pose_bone = rig.pose.bones[bone_name]
pose_bone["IK_FK"] = ik_fk[i]
else:
for bone_name in ik_fk_control_bones:
if bone_name in rig.pose.bones:
pose_bone = rig.pose.bones[bone_name]
pose_bone["IK_FK"] = ik_fk
def poke_rig(rig):
"""Switches modes on the armature and sets the root pose bone location to force updates
after changing custom paramters i.e. IK_FK on the limbs."""
state = utils.store_mode_selection_state()
select_rig(rig)
pose_bone: bpy.types.PoseBone = rig.pose.bones[0]
loc = pose_bone.location
pose_bone.location = loc
pose_rig(rig)
utils.restore_mode_selection_state(state)
def set_bone_tail_length(bone: bpy.types.EditBone, tail):
"""Set the length based on a new tail position, but don't set the tail directly
as it may cause changes in the bone roll and angles."""
if bone and tail:
if type(tail) is bpy.types.EditBone:
new_tail = tail.head.copy()
elif type(tail) is Vector:
new_tail = tail.copy()
length = (new_tail - bone.head).length
bone.length = length
def set_bone_deform(bone: bpy.types.EditBone, use_deform, objects):
try:
if bone:
# don't set non deform on rig bones if there are objects weighted to it
for obj in objects:
if bone.name in obj.vertex_groups:
return
bone.use_deform = use_deform
except: ...
def fix_cc3_standard_rig(cc3_rig):
if edit_rig(cc3_rig):
objects = utils.get_child_objects(cc3_rig, of_type="MESH")
left_eye = bones.get_edit_bone(cc3_rig, "CC_Base_L_Eye")
right_eye = bones.get_edit_bone(cc3_rig, "CC_Base_R_Eye")
left_hand = bones.get_edit_bone(cc3_rig, ["CC_Base_L_Hand", "hand_l"])
right_hand = bones.get_edit_bone(cc3_rig, ["CC_Base_R_Hand", "hand_r"])
left_foot = bones.get_edit_bone(cc3_rig, ["CC_Base_L_Foot", "foot_l"])
right_foot = bones.get_edit_bone(cc3_rig, ["CC_Base_R_Foot", "foot_r"])
head = bones.get_edit_bone(cc3_rig, ["CC_Base_Head", "head"])
left_upper_arm = bones.get_edit_bone(cc3_rig, ["CC_Base_L_Upperarm", "upperarm_l"])
right_upper_arm = bones.get_edit_bone(cc3_rig, ["CC_Base_R_Upperarm", "upperarm_r"])
left_lower_arm = bones.get_edit_bone(cc3_rig, ["CC_Base_L_Forearm", "lowerarm_l"])
right_lower_arm = bones.get_edit_bone(cc3_rig, ["CC_Base_R_Forearm", "lowerarm_r"])
left_thigh = bones.get_edit_bone(cc3_rig, ["CC_Base_L_Thigh", "thigh_l"])
right_thigh = bones.get_edit_bone(cc3_rig, ["CC_Base_R_Thigh", "thigh_r"])
left_calf = bones.get_edit_bone(cc3_rig, ["CC_Base_L_Calf", "calf_l"])
right_calf = bones.get_edit_bone(cc3_rig, ["CC_Base_R_Calf", "calf_r"])
# fix deform state
for bone_name in bones.NONE_DEFORM_BONES:
edit_bone = bones.get_edit_bone(cc3_rig, bone_name)
if edit_bone:
set_bone_deform(edit_bone, False, objects)
# eyes
eye_z = None
if left_eye and right_eye:
eye_z = ((left_eye.head + right_eye.head) * 0.5).z
# head
if head:
head_tail = head.tail.copy()
head_tail.z = eye_z + (eye_z - head.head.z) * 0.5
set_bone_tail_length(head, head_tail)
# arms
set_bone_tail_length(left_upper_arm, left_lower_arm)
set_bone_tail_length(right_upper_arm, right_lower_arm)
set_bone_tail_length(left_lower_arm, left_hand)
set_bone_tail_length(right_lower_arm, right_hand)
# legs
set_bone_tail_length(left_thigh, left_calf)
set_bone_tail_length(right_thigh, right_calf)
set_bone_tail_length(left_calf, left_foot)
set_bone_tail_length(right_calf, right_foot)
select_rig(cc3_rig)
def reset_rotation_modes(rig, rotation_mode = "QUATERNION"):
pose_bone: bpy.types.PoseBone
for pose_bone in rig.pose.bones:
pose_bone.rotation_mode = rotation_mode
def is_skinned_rig(rig):
meshes = utils.get_child_objects(rig)
for mesh in meshes:
mod = None
for m in mesh.modifiers:
if m and m.type == "ARMATURE":
mod = m
if mod:
return True
return False
def is_face_rig(rig):
return ("facerig" in rig.pose.bones)
BASE_RIG_COLLECTION_CCIC240 = ["Face (Primary)", "Face (Secondary)",
"Torso", "Torso (Tweak)", "Fingers", "Fingers (Detail)",
"Arm.L (IK)", "Arm.L (FK)", "Arm.L (Tweak)", "Leg.L (IK)", "Leg.L (FK)", "Leg.L (Tweak)",
"Arm.R (IK)", "Arm.R (FK)", "Arm.R (Tweak)", "Leg.R (IK)", "Leg.R (FK)", "Leg.R (Tweak)",
"Root" ]
BASE_RIG_COLLECTION = ["Face", "Face (Primary)", "Face (Secondary)",
"Torso", "Torso (Tweak)", "Fingers", "Fingers (Detail)",
"Arm.L (IK)", "Arm.L (FK)", "Arm.L (Tweak)", "Leg.L (IK)", "Leg.L (FK)", "Leg.L (Tweak)",
"Arm.R (IK)", "Arm.R (FK)", "Arm.R (Tweak)", "Leg.R (IK)", "Leg.R (FK)", "Leg.R (Tweak)",
"Root" ]
BASE_RIG_LAYERS = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,28]
BASE_DEF_COLLECTION = ["DEF"]
BASE_DEF_LAYERS = [29]
FULL_RIG_COLLECTION_CCIC240 = ["Face", "Face (Primary)", "Face (Secondary)",
"Torso", "Torso (Tweak)", "Fingers", "Fingers (Detail)",
"Arm.L (IK)", "Arm.L (FK)", "Arm.L (Tweak)", "Leg.L (IK)", "Leg.L (FK)", "Leg.L (Tweak)",
"Arm.R (IK)", "Arm.R (FK)", "Arm.R (Tweak)", "Leg.R (IK)", "Leg.R (FK)", "Leg.R (Tweak)",
"Root",
"Spring (IK)", "Spring (FK)", "Spring (Tweak)"]
FULL_RIG_COLLECTION = ["Face", "Face (Primary)", "Face (Secondary)",
"Torso", "Torso (Tweak)", "Fingers", "Fingers (Detail)",
"Arm.L (IK)", "Arm.L (FK)", "Arm.L (Tweak)", "Leg.L (IK)", "Leg.L (FK)", "Leg.L (Tweak)",
"Arm.R (IK)", "Arm.R (FK)", "Arm.R (Tweak)", "Leg.R (IK)", "Leg.R (FK)", "Leg.R (Tweak)",
"Root",
"Spring (IK)", "Spring (FK)", "Spring (Tweak)",
"Face (Expressions)", "Face (UI)"]
FULL_RIG_LAYERS = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,28]
FULL_DEF_COLLECTION = ["DEF", "Spring (Edit)", "Spring (Root)"]
FULL_DEF_LAYERS = [24, 25, 29]
SPRING_RIG_COLLECTION = ["Spring (IK)", "Spring (FK)", "Spring (Tweak)"]
SPRING_RIG_LAYERS = [19,20,21]
SPRING_DEF_COLLECTION = ["Spring (Edit)", "Spring (Root)"]
SPRING_DEF_LAYERS = [24,25]
FACE_RIG_COLLECTION_CCIC240 = ["Face"]
FACE_RIG_COLLECTION = ["Face (Expressions)", "Face (UI)"]
FACE_RIG_LAYERS = [22,23]
FACE_RIG_HIDE_CCIC240 = ["Face (Primary)", "Face (Secondary)"]
FACE_RIG_HIDE = ["Face", "Face (Primary)", "Face (Secondary)"]
FACE_RIG_HIDE_LAYERS = [0,1,2]
def show_hide_collections_layers(rig, collections, layers, show=True):
if rig:
if utils.B400():
for collection in rig.data.collections:
if collection.name in collections:
collection.is_visible = show
else:
for i in range(0, 32):
if i in layers:
rig.data.layers[i] = show
def is_full_rigify_rig_shown(rig):
if rig:
FRC = FULL_RIG_COLLECTION_CCIC240 if facerig.is_ccic_240_rig(rig) else FULL_RIG_COLLECTION
FRH = FACE_RIG_HIDE_CCIC240 if facerig.is_ccic_240_rig(rig) else FACE_RIG_HIDE
face_rig = is_face_rig(rig)
if utils.B400():
for collection in rig.data.collections:
if face_rig and collection.name in FRH:
continue
if collection.name in FRC and not collection.is_visible:
return False
else:
for i in range(0, 32):
if face_rig and i in FACE_RIG_HIDE_LAYERS:
continue
if i in FULL_RIG_LAYERS and rig.data.layers[i] == False:
return False
return True
else:
return False
def toggle_show_full_rig(rig):
if rig:
FRC = FULL_RIG_COLLECTION_CCIC240 if facerig.is_ccic_240_rig(rig) else FULL_RIG_COLLECTION
BRC = BASE_RIG_COLLECTION_CCIC240 if facerig.is_ccic_240_rig(rig) else BASE_RIG_COLLECTION
FRH = FACE_RIG_HIDE_CCIC240 if facerig.is_ccic_240_rig(rig) else FACE_RIG_HIDE
face_rig = is_face_rig(rig)
show = not is_full_rigify_rig_shown(rig)
if utils.B400():
if show:
for collection in rig.data.collections:
if face_rig and collection.name in FRH:
collection.is_visible = False
else:
collection.is_visible = collection.name in FRC
else:
for collection in rig.data.collections:
if face_rig and collection.name in FRH:
collection.is_visible = False
else:
collection.is_visible = collection.name in BRC
else:
if show:
rig.data.layers[vars.ROOT_BONE_LAYER] = True
else:
rig.data.layers[vars.DEF_BONE_LAYER] = True
for i in range(0, 32):
if show:
rig.data.layers[i] = i in FULL_RIG_LAYERS
else:
rig.data.layers[i] = i in BASE_RIG_LAYERS
if face_rig:
for layer in FACE_RIG_HIDE_LAYERS:
rig.data.layers[layer] = False
def is_base_rig_shown(rig):
if rig:
FRH = FACE_RIG_HIDE_CCIC240 if facerig.is_ccic_240_rig(rig) else FACE_RIG_HIDE
BRC = BASE_RIG_COLLECTION_CCIC240 if facerig.is_ccic_240_rig(rig) else BASE_RIG_COLLECTION
face_rig = is_face_rig(rig)
if utils.B400():
for collection in rig.data.collections:
if face_rig and collection.name in FRH:
continue
if collection.name in BRC and not collection.is_visible:
return False
else:
for i in range(0, 32):
if face_rig and i in FACE_RIG_HIDE_LAYERS:
continue
if i in BASE_RIG_LAYERS and rig.data.layers[i] == False:
return False
return True
else:
return False
def toggle_show_base_rig(rig):
if rig:
FRH = FACE_RIG_HIDE_CCIC240 if facerig.is_ccic_240_rig(rig) else FACE_RIG_HIDE
BRC = BASE_RIG_COLLECTION_CCIC240 if facerig.is_ccic_240_rig(rig) else BASE_RIG_COLLECTION
show = True
face_rig = is_face_rig(rig)
if is_full_rigify_rig_shown(rig):
show = True
elif is_base_rig_shown(rig):
show = False
if utils.B400():
if show:
for collection in rig.data.collections:
if face_rig and collection.name in FRH:
collection.is_visible = False
else:
collection.is_visible = collection.name in BRC
else:
for collection in rig.data.collections:
collection.is_visible = collection.name in BASE_DEF_COLLECTION
else:
if show:
rig.data.layers[vars.ROOT_BONE_LAYER] = True
else:
rig.data.layers[vars.DEF_BONE_LAYER] = True
for i in range(0, 32):
if show:
rig.data.layers[i] = i in BASE_RIG_LAYERS
else:
rig.data.layers[i] = i in BASE_DEF_LAYERS
if face_rig:
for layer in FACE_RIG_HIDE_LAYERS:
rig.data.layers[layer] = False
def is_spring_rig_shown(rig):
if rig:
if utils.B400():
for collection in rig.data.collections:
if collection.name in SPRING_RIG_COLLECTION and not collection.is_visible:
return False
else:
for i in range(0, 32):
if i in SPRING_RIG_LAYERS and rig.data.layers[i] == False:
return False
return True
else:
return False
def toggle_show_spring_rig(rig):
if rig:
show = True
if is_full_rigify_rig_shown(rig):
show = True
elif is_spring_rig_shown(rig):
show = False
if utils.B400():
if show:
for collection in rig.data.collections:
collection.is_visible = collection.name in SPRING_RIG_COLLECTION
else:
for collection in rig.data.collections:
collection.is_visible = collection.name in SPRING_DEF_COLLECTION
else:
if show:
rig.data.layers[vars.SPRING_IK_LAYER] = True
else:
rig.data.layers[vars.DEF_BONE_LAYER] = True
for i in range(0, 32):
if show:
rig.data.layers[i] = i in SPRING_RIG_LAYERS
else:
rig.data.layers[i] = i in SPRING_DEF_LAYERS
def is_only_face_rig_shown(rig):
only_shown = False
shown = True
if rig:
FRC = FACE_RIG_COLLECTION_CCIC240 if facerig.is_ccic_240_rig(rig) else FACE_RIG_COLLECTION
if utils.B400():
for collection in rig.data.collections:
if collection.name in FRC:
if collection.is_visible:
only_shown = True
else:
shown = False
for collection in rig.data.collections:
if collection.name not in FRC:
if collection.is_visible:
return shown, False
else:
for layer in range(0, 32):
if layer in FRC:
if rig.data.layers[layer]:
only_shown = True
else:
shown = False
for layer in range(0, 32):
if layer not in FRC:
if rig.data.layers[layer]:
return shown, False
return shown, only_shown
def toggle_show_only_face_rig(rig):
if rig:
FRC = FACE_RIG_COLLECTION_CCIC240 if facerig.is_ccic_240_rig(rig) else FACE_RIG_COLLECTION
BRC = BASE_RIG_COLLECTION_CCIC240 if facerig.is_ccic_240_rig(rig) else BASE_RIG_COLLECTION
FRH = FACE_RIG_HIDE_CCIC240 if facerig.is_ccic_240_rig(rig) else FACE_RIG_HIDE
face_rig = is_face_rig(rig)
show_only = False
if utils.B400():
for collection in rig.data.collections:
if collection.name not in FRC and collection.is_visible:
show_only = True
else:
for layer in range(0, 32):
if rig.data.layers[layer] and layer not in FACE_RIG_LAYERS:
show_only = True
if utils.B400():
if show_only:
for collection in rig.data.collections:
collection.is_visible = collection.name in FRC
else:
for collection in rig.data.collections:
if face_rig and collection.name in FRH:
collection.is_visible = False
else:
collection.is_visible = collection.name in BRC
else:
if show_only:
rig.data.layers[22] = True
rig.data.layers[23] = True
for layer in range(0, 32):
rig.data.layers[layer] = layer in FACE_RIG_LAYERS
else:
rig.data.layers[22] = False
rig.data.layers[23] = False
for layer in range(0, 32):
rig.data.layers[layer] = layer in BASE_RIG_LAYERS and layer not in FACE_RIG_HIDE_LAYERS
def reset_pose(rig, exceptions=None, use_selected=False):
if rig:
utils.pose_mode_to(rig)
rig.data.pose_position = "POSE"
bones_data = {}
for pose_bone in rig.pose.bones:
bone = pose_bone.bone
if exceptions and pose_bone.name in exceptions:
bones.select_bone(rig, pose_bone, False)
continue
selected = bones.get_bone_selected(rig, bone)
bones_data[bone] = (selected, bone.hide, bone.hide_select)
if not use_selected:
bones.select_bone(rig, bone, True)
bone.hide = False
if bones.can_unlock(pose_bone):
bone.hide_select = False
bpy.ops.pose.transforms_clear()
for bone in rig.data.bones:
if bone in bones_data:
selected, bone.hide, bone.hide_select = bones_data[bone]
bones.select_bone(rig, bone, selected)
def reset_shape_keys(mesh):
if mesh and utils.object_has_shape_keys(mesh):
key: bpy.types.ShapeKey
for key in mesh.data.shape_keys.key_blocks:
key.value = 0.0
def is_rig_rest_position(rig):
if rig:
if rig.data.pose_position == "REST":
return True
return False
def toggle_rig_rest_position(rig):
if rig:
if rig.data.pose_position == "POSE":
rig.data.pose_position = "REST"
else:
rig.data.pose_position = "POSE"
def get_local_pose_bone_transform(M: Matrix, pose_bone: bpy.types.PoseBone):
"""M: Matrix - object space matrix of the transform to convert
pose_bone: bpy.types.PoseBone - pose bone to calculate local space transform for."""
L: Matrix # local space matrix we want
NL: Matrix # non-local space matrix we want (if not using local location or inherit rotation)
R: Matrix = pose_bone.bone.matrix_local # bone rest pose matrix
RI: Matrix = R.inverted() # bone rest pose matrix inverted
if pose_bone.parent:
PI: Matrix = pose_bone.parent.matrix.inverted() # parent object space matrix inverted (after contraints and drivers)
PR: Matrix = pose_bone.parent.bone.matrix_local # parent rest pose matrix
L = RI @ (PR @ (PI @ M))
NL = PI @ M
else:
L = RI @ M
NL = M
if not pose_bone.bone.use_local_location:
loc = NL.to_translation()
else:
loc = L.to_translation()
sca = L.to_scale()
if not pose_bone.bone.use_inherit_rotation:
rot = NL.to_quaternion()
else:
rot = L.to_quaternion()
return loc, rot, sca, L, NL
def apply_as_rest_pose(rig):
if rig and select_rig(rig):
objects = utils.get_child_objects(rig)
for obj in objects:
if utils.object_exists(obj):
vis = obj.visible_get()
if not vis:
utils.unhide(obj)
mod: bpy.types.ArmatureModifier = modifiers.get_object_modifier(obj, "ARMATURE")
if mod:
# apply armature modifier with preserve settings and mod order
modifiers.apply_modifier(obj, modifier=mod, preserving=True)
modifiers.get_armature_modifier(obj, create=True, armature=rig)
utils.hide(obj, not vis)
if pose_rig(rig):
bpy.ops.pose.armature_apply(selected=False)
utils.object_mode_to(rig)
def constrain_pose_rigs(src_rig, dst_rig):
# constrain the destination rig rest pose to the source rig pose
constraints = {}
if select_rig(src_rig):
src_bone: bpy.types.PoseBone
dst_bone: bpy.types.PoseBone
for src_bone in src_rig.pose.bones:
if src_bone.name in dst_rig.pose.bones:
dst_bone = dst_rig.pose.bones[src_bone.name]
con = bones.add_copy_transforms_constraint(src_rig, dst_rig, src_bone.name, dst_bone.name)
constraints[dst_bone] = con
return constraints
def unconstrain_pose_rigs(constraints):
# remove the constraints
for dst_bone in constraints:
con = constraints[dst_bone]
dst_bone.constraints.remove(con)
def cmp_matrix(A: Matrix, B: Matrix):
rows = len(A.row)
cols = len(A.col)
delta = 0
for i in range(0, rows):
for j in range(0, cols):
delta += abs(A[i][j] - B[i][j])
if delta < 0.001:
return True
return False
def is_rest_pose_same(src_rig, dst_rig):
if len(src_rig.data.bones) != len(dst_rig.data.bones):
return False
src_bone: bpy.types.Bone
dst_bone: bpy.types.Bone
for src_bone in src_rig.data.bones:
if src_bone.name not in dst_rig.data.bones:
return False
dst_bone = dst_rig.data.bones[src_bone.name]
if not cmp_matrix(src_bone.matrix, dst_bone.matrix):
return False
return True
def copy_rest_pose(src_rig, dst_rig):
# TODO make everything visible...
temp_collection = utils.force_visible_in_scene("TMP_COPY_POSE", src_rig, dst_rig)
TS = utils.store_object_transform(src_rig)
TD = utils.store_object_transform(dst_rig)
utils.reset_object_transform(src_rig)
utils.reset_object_transform(dst_rig)
src_action, src_slot = utils.safe_get_action_slot(src_rig)
dst_action, dst_slot = utils.safe_get_action_slot(dst_rig)
utils.safe_set_action(src_rig, None)
utils.safe_set_action(dst_rig, None)
utils.try_select_objects([src_rig, dst_rig], clear_selection=True)
bones.clear_pose(src_rig)
bones.clear_pose(dst_rig)
# constrain the destination rig rest pose to the source rig pose
constraints = constrain_pose_rigs(src_rig, dst_rig)
# apply the destination pose as rest pose
apply_as_rest_pose(dst_rig)
# remove the constraints
unconstrain_pose_rigs(constraints)
utils.restore_object_transform(src_rig, TS)
utils.restore_object_transform(dst_rig, TD)
utils.safe_set_action(src_rig, src_action, slot=src_slot)
utils.safe_set_action(dst_rig, dst_action, slot=dst_slot)
utils.restore_visible_in_scene(temp_collection)
def bake_rig_action(src_rig, dst_rig, reuse_action=False):
src_action: bpy.types.Action = utils.safe_get_action(src_rig)
baked_action = None
if utils.try_select_object(dst_rig, True) and utils.set_active_object(dst_rig):
utils.log_info(f"Baking action: {src_action.name} to {dst_rig.name}")
# frame range
if src_action:
start_frame = int(src_action.frame_range[0])
end_frame = int(src_action.frame_range[1])
else:
start_frame = int(bpy.context.scene.frame_start)
end_frame = int(bpy.context.scene.frame_end)
# limit view layer to dst rig (bakes faster)
tmp_collection, layer_collections, to_hide = utils.limit_view_layer_to_collection("TMP_BAKE", dst_rig)
utils.set_active_object(dst_rig)
utils.set_mode("POSE")
# bake
bpy.ops.nla.bake(frame_start=start_frame,
frame_end=end_frame,
only_selected=True,
visual_keying=True,
use_current_action=reuse_action,
clear_constraints=False,
clean_curves=False,
bake_types={'POSE'})
# armature action
baked_action = utils.safe_get_action(dst_rig)
utils.object_mode()
# restore view layers
utils.restore_limited_view_layers(tmp_collection, layer_collections, to_hide)
# return the baked action
return baked_action
def bake_rig_action_from_source(src_rig, dst_rig):
"""Bakes the action from one rig to another, for when rigs have different bind poses but have the same bones.
Also copies any slotted key actions from the source.
Used by DataLink for retargeting prop animations."""
#temp_collection = utils.force_visible_in_scene("TMP_Bake_Retarget", src_rig, dst_rig)
rig_settings = bones.store_armature_settings(dst_rig)
# constrain the destination rig rest pose to the source rig pose
constraints = constrain_pose_rigs(src_rig, dst_rig)
baked_action = None
if select_rig(dst_rig):
bones.make_bones_visible(dst_rig)
bone : bpy.types.Bone
bones.select_all_bones(dst_rig, True)
baked_action = bake_rig_action(src_rig, dst_rig)
# remove contraints
unconstrain_pose_rigs(constraints)
bones.restore_armature_settings(dst_rig, rig_settings)
#load_slotted_action(dst_rig, baked_action)
#utils.restore_visible_in_scene(temp_collection)
return baked_action
DISABLE_TWEAK_STRETCH_IN = [
"DEF-thigh.R",
"DEF-thigh.R.001",
"DEF-shin.R",
"DEF-shin.R.001",
"DEF-foot.R",
"DEF-thigh.L",
"DEF-thigh.L.001",
"DEF-shin.L",
"DEF-shin.L.001",
"DEF-foot.L",
]
DISABLE_TWEAK_STRETCH_FOR = [
"thigh_tweak.R",
"thigh_tweak.R.001",
"shin_tweak.R",
"shin_tweak.R.001",
"foot_tweak.R",
"thigh_tweak.L",
"thigh_tweak.L.001",
"shin_tweak.L",
"shin_tweak.L.001",
"foot_tweak.L",
]
def set_ik_stretch_control(rigify_rig, fac):
"""Set the default state of the IK Stretch controls"""
control_bone_names = [ "upper_arm_parent.L", "upper_arm_parent.R", "thigh_parent.L", "thigh_parent.R" ]
for bone_name in control_bone_names:
control_bone = bones.get_pose_bone(rigify_rig, bone_name)
if control_bone:
if "IK_Stretch" in control_bone:
control_bone["IK_Stretch"] = fac
def disable_ik_stretch(rigify_rig, bone_names=None):
con_store = {}
ik_store = { "constraints": con_store }
for pose_bone in rigify_rig.pose.bones:
if bone_names and pose_bone.name not in bone_names:
continue
for con in pose_bone.constraints:
if con and con.type == "IK":
con_store[con] = con.use_stretch
# disabling this for now, as it can cause really bad IK solving...
#con.use_stretch = False
return ik_store
DEFAULT_IK_STRETCH_BONES = {
"MCH-shin_ik.L": True,
"MCH-shin_ik.R": True,
"MCH-forearm_ik.L": True,
"MCH-forearm_ik.R": True
}
def is_stretch_enabled(rigify_rig):
for bone_name, ik_stretch in DEFAULT_IK_STRETCH_BONES.items():
if bone_name in rigify_rig.pose.bones:
pose_bone = rigify_rig.pose.bones[bone_name]
for con in pose_bone.constraints:
if con and con.type == "IK":
if con.use_stretch:
return True
return False
def restore_ik_stretch(ik_store=None, rigify_rig=None):
if ik_store:
con_store = ik_store["constraints"]
for con in con_store:
con.use_stretch = con_store[con]
elif rigify_rig:
for bone_name, ik_stretch in DEFAULT_IK_STRETCH_BONES.items():
if bone_name in rigify_rig.pose.bones:
pose_bone = rigify_rig.pose.bones[bone_name]
for con in pose_bone.constraints:
if con and con.type == "IK":
con.use_stretch = ik_stretch
def update_avatar_rig(rig):
prefs = vars.prefs()
utils.log_info("Updating avatar rig...")
if is_rigify_armature(rig):
# disable all stretch-to tweak constraints and hide tweak bones...
# tweak bones are not fully compatible with CC/iC animation (probably Blender only)
# and cause positioning errors as they stretch/compress the bones.
# NOTE: Seems to have been because of a bug in Blender 4.1, fixed in 4.2 so disabling this...
if False:
if prefs.datalink_disable_tweak_bones:
disable = True
influence = 0.0
else:
disable = False
influence = 1.0
pose_bone: bpy.types.PoseBone
for pose_bone in rig.pose.bones:
if pose_bone.name in DISABLE_TWEAK_STRETCH_FOR:
if disable:
bones.set_bone_color(rig, pose_bone, "TWEAK_DISABLED")
else:
bones.set_bone_color(rig, pose_bone, "TWEAK")
elif prefs.datalink_disable_tweak_bones and pose_bone.name in DISABLE_TWEAK_STRETCH_IN:
for con in pose_bone.constraints:
if con.type == "STRETCH_TO":
if "tweak" in con.subtarget:
con.influence = influence
# disable IK stretch
if "IK_Stretch" in pose_bone:
pose_bone["IK_Stretch"] = 0.0
else: # just disable IK Stretch...
pose_bone: bpy.types.PoseBone
for pose_bone in rig.pose.bones:
# disable IK stretch
if "IK_Stretch" in pose_bone:
pose_bone["IK_Stretch"] = 0.0
def update_prop_rig(rig):
prefs = vars.prefs()
if not rig: return
utils.log_info("Updating prop rig...")
skin_bones = set()
rigid_bones = set()
mesh_bones = set()
root_bones = set()
skinned_root_bones = set()
root_bones.add(rig.data.bones[0])
USE_JSON_BONE_DATA = True
meshes = utils.get_child_objects(rig)
for obj in meshes:
if (obj.parent_type == "BONE" and obj.parent_bone in rig.data.bones):
bone = rig.data.bones[obj.parent_bone]
if (bone.parent and bone.parent.parent and
"CC_Base_Pivot" in bone.parent.name):
mesh_bones.add(bone.name)
rigid_bones.add(bone.parent.parent.name)
elif (bone.parent and
"CC_Base_Pivot" in bone.name):
rigid_bones.add(bone.parent.name)
elif bone.parent:
rigid_bones.add(bone.parent.name)
else:
rigid_bones.add(bone.name)
elif (obj.parent_type == "OBJECT" and obj.vertex_groups and len(obj.vertex_groups) == 1 and
utils.strip_name(obj.vertex_groups[0].name) == bones.rl_export_bone_name(utils.strip_name(obj.name))):
bone = rig.data.bones[obj.vertex_groups[0].name]
if (bone.parent and bone.parent.parent and
"CC_Base_Pivot" in bone.parent.name):
mesh_bones.add(bone.name)
rigid_bones.add(bone.parent.parent.name)
elif (bone.parent and
"CC_Base_Pivot" in bone.name):
rigid_bones.add(bone.parent.name)
elif bone.parent:
rigid_bones.add(bone.parent.name)
else:
rigid_bones.add(bone.name)
elif (obj.parent_type == "OBJECT" and obj.vertex_groups and len(obj.vertex_groups) > 0):
for vg in obj.vertex_groups:
skin_bones.add(vg.name)
if USE_JSON_BONE_DATA:
first_name = obj.vertex_groups[0].name
if first_name in rig.pose.bones:
pose_bone = rig.pose.bones[first_name]
while pose_bone.parent:
if "root_id" and "root_type" in pose_bone:
skinned_root_bones.add(pose_bone.name)
break
pose_bone = pose_bone.parent
if USE_JSON_BONE_DATA:
for pose_bone in rig.pose.bones:
if "root_id" in pose_bone and "root_type" in pose_bone:
root_bones.add(pose_bone.name)
pose_bone: bpy.types.PoseBone
for pose_bone in rig.pose.bones:
bone = pose_bone.bone
pivot_bone = "CC_Base_Pivot" in pose_bone.name
skin_bone = bone.name in skin_bones
rigid_bone = bone.name in rigid_bones
mesh_bone = bone.name in mesh_bones
root_bone = bone.name in root_bones
dummy_bone = not (skin_bone or rigid_bone or mesh_bone) and len(bone.children) == 0
node_bone = not (skin_bone or rigid_bone or mesh_bone) and len(bone.children) > 0
if root_bone:
bone.hide = False
elif pivot_bone:
bone.hide = True
elif skin_bone:
bone.hide = prefs.datalink_hide_prop_bones
elif mesh_bone:
bone.hide = True
elif rigid_bone:
bone.hide = False
elif dummy_bone:
bone.hide = True
elif node_bone:
bone.hide = prefs.datalink_hide_prop_bones
"""
import bpy
b = bpy.context.active_bone
c = b.children[0]
print(f"{b.head_local} {c.head_local} {b.length}")
hi = b.matrix_local.inverted() @ b.head_local
ti = b.matrix_local.inverted() @ b.tail_local
db = (ti - hi)/b.length
print(db)
ci = b.matrix_local.inverted() @ c.head_local
dc = (ci - hi)/b.length
print(dc)
print(db.dot(dc))
print(abs(db.length - dc.length))
q = db.rotation_difference(dc)
print(q)
print(q.to_euler())
"""
def get_bone_orientation(rig, bone_set: set):
B: bpy.types.Bone
C: bpy.types.Bone
for bone_name in bone_set:
B = rig.data.bones[bone_name]
if B.children and B.parent:
for C in B.children:
if B.length > 0.01:
# convert heads and tail to B local space
bhl = B.matrix_local.inverted() @ B.head_local
btl = B.matrix_local.inverted() @ B.tail_local
chl = B.matrix_local.inverted() @ C.head_local
# get bone axis in B local space
db: Vector = (btl - bhl) / B.length
# get direction to child in B local space
dc: Vector = (chl - bhl) / B.length
# if the distance to the child is ~= the same as the bone length
# (this should mean a chain of bones)
if abs(db.length - dc.length) < 0.01:
# get the rotation difference between the bone axis and the direction to the child
q = db.rotation_difference(dc)
euler = q.to_euler()
return euler
return Euler((0,0,0), "XYZ")
def get_widget_rig_collection(chr_cache):
try_names = [ chr_cache.character_name ]
rig = chr_cache.get_armature()
rig_name = utils.strip_name(rig.name)
if rig_name.endswith("_Rigify"):
rig_name = rig_name[:-7]
try_names.append(rig_name)
if utils.object_exists_is_armature(chr_cache.rig_original_rig):
rig_name = chr_cache.rig_original_rig.name
try_names.append(rig_name)
for name in try_names:
try_collection_name = f"WGTS_{name}_rig"
if try_collection_name in bpy.data.collections:
return try_collection_name
for name in try_names:
for collection in bpy.data.collections:
if name in collection.name:
return collection.name
return None
def get_expression_widgets(chr_cache, collection_name):
chr_name = chr_cache.character_name
facial_profile, viseme_profile = chr_cache.get_facial_profile()
tag = ""
if facial_profile == "EXT":
tag = "Ext"
elif facial_profile == "STD":
tag = "Std"
elif facial_profile == "TRA":
tag = "Tra"
elif facial_profile == "MH":
tag = "MH"
else:
raise Exception("Unknown facial profile!")
WGT_LINES = lib.get_object(f"WGT-RL_FaceRig_{tag}_Control_Lines", "RL_Custom_Widget",
names=f"WGT-{chr_name}_rig_{tag}_Control_Lines")
WGT_GROUPS = lib.get_object(f"WGT-RL_FaceRig_{tag}_Groups", "RL_Custom_Widget",
names=f"WGT-{chr_name}_rig_{tag}_Groups")
WGT_LABELS = lib.get_object(f"WGT-RL_FaceRig_{tag}_Labels", "RL_Custom_Widget",
names=f"WGT-{chr_name}_rig_{tag}_Labels")
WGT_OUTLINE = lib.get_object(f"WGT-RL_FaceRig_{tag}_Outline", "RL_Custom_Widget",
names=f"WGT-{chr_name}_rig_{tag}_Outline")
WGT_SLIDER = bones.make_line_widget(f"WGT-{chr_name}_rig_{tag}_Slider", 2.0)
WGT_RECT = bones.make_box_widget(f"WGT-{chr_name}_rig_{tag}_Rect", 2.0)
WGT_NUB = bones.make_sphere_widget(f"WGT-{chr_name}_rig_{tag}_Slider_Nub", 0.01666)
WGT_NAME = bones.make_text_widget(f"WGT-{chr_name}_rig_{tag}_Name", chr_name, 2.0, (0, 0.87, 0), 0.05)
bones.add_widget_to_collection(WGT_LINES, collection_name)
bones.add_widget_to_collection(WGT_GROUPS, collection_name)
bones.add_widget_to_collection(WGT_LABELS, collection_name)
bones.add_widget_to_collection(WGT_OUTLINE, collection_name)
bones.add_widget_to_collection(WGT_SLIDER, collection_name)
bones.add_widget_to_collection(WGT_RECT, collection_name)
bones.add_widget_to_collection(WGT_NUB, collection_name)
bones.add_widget_to_collection(WGT_NAME, collection_name)
return WGT_OUTLINE, WGT_GROUPS, WGT_LABELS, WGT_LINES, WGT_SLIDER, WGT_RECT, WGT_NUB, WGT_NAME
def get_expression_widgets_2(chr_cache, collection_name):
facial_profile, viseme_profile = chr_cache.get_facial_profile()
if facial_profile == "MH":
tag = "MH2"
WGT_LINES_2 = lib.get_object(f"WGT-RL_FaceRig_{tag}_Control_Lines", "RL_Custom_Widget")
WGT_GROUPS_2 = lib.get_object(f"WGT-RL_FaceRig_{tag}_Groups", "RL_Custom_Widget")
WGT_LABELS_2 = lib.get_object(f"WGT-RL_FaceRig_{tag}_Labels", "RL_Custom_Widget")
WGT_OUTLINE_2 = lib.get_object(f"WGT-RL_FaceRig_{tag}_Outline", "RL_Custom_Widget")
bones.add_widget_to_collection(WGT_LINES_2, collection_name)
bones.add_widget_to_collection(WGT_GROUPS_2, collection_name)
bones.add_widget_to_collection(WGT_LABELS_2, collection_name)
bones.add_widget_to_collection(WGT_OUTLINE_2, collection_name)
return WGT_OUTLINE_2, WGT_GROUPS_2, WGT_LABELS_2, WGT_LINES_2
else:
return None, None, None, None
def get_custom_widgets():
wgt_pivot = bones.make_axes_widget("WGT-datalink_pivot", 1)
wgt_mesh = bones.make_cone_widget("WGT-datalink_mesh", 1)
wgt_default = bones.make_sphere_widget("WGT-datalink_default", 1)
wgt_root = bones.make_root_widget("WGT-datalink_root", 2.5)
wgt_skin = bones.make_spike_widget("WGT-datalink_skin", 1)
bones.add_widget_to_collection(wgt_pivot, "WGTS_Datalink")
bones.add_widget_to_collection(wgt_mesh, "WGTS_Datalink")
bones.add_widget_to_collection(wgt_default, "WGTS_Datalink")
bones.add_widget_to_collection(wgt_root, "WGTS_Datalink")
bones.add_widget_to_collection(wgt_skin, "WGTS_Datalink")
widgets = {
"pivot": wgt_pivot,
"mesh": wgt_mesh,
"default": wgt_default,
"root": wgt_root,
"skin": wgt_skin,
}
return widgets
def set_bone_shape_scale(pose_bone: bpy.types.PoseBone, scale):
try:
if type(scale) is float or type(scale) is int:
S = Vector((scale, scale, scale))
elif type(scale) is list or type(scale) is tuple:
S = Vector(scale)
elif type(scale) is Vector:
S = scale
else:
return False
pose_bone.custom_shape_scale_xyz = S
return True
except:
pass
try:
pose_bone.custom_shape_scale = scale
return True
except:
pass
utils.log_error(f"Unable to set bone shape scale: {pose_bone.name} / {scale}")
return False
def custom_prop_rig(rig):
prefs = vars.prefs()
if not rig: return
utils.log_info("Applying custom prop rig...")
widgets = get_custom_widgets()
rig.show_in_front = True #not is_skinned_rig(rig)
rig.data.display_type = 'WIRE'
skin_bones = set()
rigid_bones = set()
mesh_bones = set()
root_bones = set()
skinned_root_bones = set()
root_bones.add(rig.data.bones[0].name)
USE_JSON_BONE_DATA = True
meshes = utils.get_child_objects(rig)
for obj in meshes:
if (obj.parent_type == "BONE" and obj.parent_bone in rig.data.bones):
bone = rig.data.bones[obj.parent_bone]
if (bone.parent and bone.parent.parent and
"CC_Base_Pivot" in bone.parent.name):
mesh_bones.add(bone.name)
rigid_bones.add(bone.parent.parent.name)
elif (bone.parent and
"CC_Base_Pivot" in bone.name):
rigid_bones.add(bone.parent.name)
elif bone.parent:
rigid_bones.add(bone.parent.name)
else:
rigid_bones.add(bone.name)
elif (obj.parent_type == "OBJECT" and obj.vertex_groups and len(obj.vertex_groups) == 1 and
utils.strip_name(obj.vertex_groups[0].name) == bones.rl_export_bone_name(utils.strip_name(obj.name))):
bone = rig.data.bones[obj.vertex_groups[0].name]
if (bone.parent and bone.parent.parent and
"CC_Base_Pivot" in bone.parent.name):
mesh_bones.add(bone.name)
rigid_bones.add(bone.parent.parent.name)
elif (bone.parent and
"CC_Base_Pivot" in bone.name):
rigid_bones.add(bone.parent.name)
elif bone.parent:
rigid_bones.add(bone.parent.name)
else:
rigid_bones.add(bone.name)
elif (obj.parent_type == "OBJECT" and obj.vertex_groups and len(obj.vertex_groups) > 0):
for vg in obj.vertex_groups:
skin_bones.add(vg.name)
if USE_JSON_BONE_DATA:
first_name = obj.vertex_groups[0].name
if first_name in rig.pose.bones:
pose_bone = rig.pose.bones[first_name]
while pose_bone.parent:
if "root_id" and "root_type" in pose_bone:
skinned_root_bones.add(pose_bone.name)
break
pose_bone = pose_bone.parent
skin_bone_orientation = get_bone_orientation(rig, skin_bones)
if USE_JSON_BONE_DATA:
for pose_bone in rig.pose.bones:
if "root_id" in pose_bone and "root_type" in pose_bone:
root_bones.add(pose_bone.name)
if select_rig(rig):
pose_bone: bpy.types.PoseBone
for pose_bone in rig.pose.bones:
bone = pose_bone.bone
pivot_bone = "CC_Base_Pivot" in pose_bone.name
skin_bone = bone.name in skin_bones
rigid_bone = bone.name in rigid_bones
mesh_bone = bone.name in mesh_bones
root_bone = bone.name in root_bones
dummy_bone = not (skin_bone or rigid_bone or mesh_bone) and len(bone.children) == 0
node_bone = not (skin_bone or rigid_bone or mesh_bone) and len(bone.children) > 0
if root_bone:
if not pose_bone.parent:
pose_bone.custom_shape = widgets["root"]
set_bone_shape_scale(pose_bone, 20)
else:
pose_bone.custom_shape = widgets["default"]
set_bone_shape_scale(pose_bone, 15)
bone.hide = False
pose_bone.use_custom_shape_bone_size = False
bones.set_bone_color(rig, pose_bone, "ROOT")
elif pivot_bone:
pose_bone.custom_shape = widgets["pivot"]
bone.hide = True
pose_bone.use_custom_shape_bone_size = False
set_bone_shape_scale(pose_bone, 10)
bones.set_bone_color(rig, pose_bone, "SPECIAL")
elif skin_bone:
pose_bone.custom_shape = widgets["skin"]
bone.hide = prefs.datalink_hide_prop_bones
pose_bone.use_custom_shape_bone_size = True
pose_bone.use
#pose_bone.bone.show_wire = True
pose_bone.custom_shape_rotation_euler = skin_bone_orientation
bones.set_bone_color(rig, pose_bone, "SKIN")
elif mesh_bone:
pose_bone.custom_shape = widgets["mesh"]
bone.hide = True
pose_bone.use_custom_shape_bone_size = False
set_bone_shape_scale(pose_bone, 10)
bones.set_bone_color(rig, pose_bone, "SPECIAL")
elif rigid_bone:
pose_bone.custom_shape = widgets["default"]
bone.hide = False
pose_bone.use_custom_shape_bone_size = False
set_bone_shape_scale(pose_bone, 10)
bones.set_bone_color(rig, pose_bone, "TWEAK")
elif dummy_bone:
pose_bone.custom_shape = widgets["pivot"]
bone.hide = True
pose_bone.use_custom_shape_bone_size = False
set_bone_shape_scale(pose_bone, 10)
bones.set_bone_color(rig, pose_bone, "IK")
elif node_bone:
pose_bone.custom_shape = widgets["default"]
bone.hide = prefs.datalink_hide_prop_bones
pose_bone.use_custom_shape_bone_size = False
set_bone_shape_scale(pose_bone, 10)
bones.set_bone_color(rig, pose_bone, "SPECIAL")
def custom_avatar_rig(rig):
prefs = vars.prefs()
if not rig: return
utils.log_info("Applying custom avatar rig...")
widgets = get_custom_widgets()
rig.show_in_front = False
rig.data.display_type = 'OCTAHEDRAL'
skin_bones = set()
root_bones = set()
root_bones.add(rig.data.bones[0].name)
for bone in rig.data.bones:
if bone not in root_bones:
skin_bones.add(bone.name)
skin_bone_orientation = get_bone_orientation(rig, skin_bones)
if select_rig(rig):
pose_bone: bpy.types.PoseBone
for pose_bone in rig.pose.bones:
bone = pose_bone.bone
if bone.parent is None:
if not pose_bone.parent:
pose_bone.custom_shape = widgets["root"]
set_bone_shape_scale(pose_bone, 20)
else:
pose_bone.custom_shape = widgets["default"]
set_bone_shape_scale(pose_bone, 15)
bone.hide = False
pose_bone.use_custom_shape_bone_size = False
bones.set_bone_color(rig, pose_bone, "ROOT")
else:
pose_bone.custom_shape = widgets["skin"]
bone.hide = False
pose_bone.use_custom_shape_bone_size = True
#pose_bone.bone.show_wire = True
pose_bone.custom_shape_rotation_euler = skin_bone_orientation
bones.set_bone_color(rig, pose_bone, "SKIN")
def de_pivot(chr_cache):
"""Removes the pivot bones and corrects the parenting of the mesh objects
from a CC/iC character or prop"""
if chr_cache:
rig = chr_cache.get_armature()
objects = chr_cache.get_all_objects(include_armature=False,
of_type="MESH")
if rig and objects:
true_parents = {}
if select_rig(rig):
obj: bpy.types.Object
for obj in objects:
if obj.parent == rig:
if obj.parent_type == "BONE":
parent_bone_name = obj.parent_bone
parent_bone: bpy.types.PoseBone = rig.pose.bones[parent_bone_name]
if "CC_Base_Pivot" in parent_bone.name:
true_parent = parent_bone.parent
M = obj.matrix_world.copy()
true_parents[obj] = (true_parent, M)
to_remove = []
if edit_rig(rig):
for edit_bone in rig.data.edit_bones:
if "CC_Base_Pivot" in edit_bone.name:
to_remove.append(edit_bone)
for edit_bone in to_remove:
rig.data.edit_bones.remove(edit_bone)
for obj in true_parents:
true_parent, M = true_parents[obj]
obj.parent_bone = true_parent.name
obj.matrix_world = M
select_rig(rig)
class CCICMotionSetFunctions(bpy.types.Operator):
bl_idname = "ccic.motion_set_funcs"
bl_label = "Motion Set Functions"
bl_options = {"REGISTER", "UNDO", "INTERNAL"}
param: bpy.props.StringProperty(
name = "param",
default = ""
)
def execute(self, context):
props = vars.props()
props.store_ui_list_indices()
action = props.action_set_list_action
#chr_cache = props.get_context_character_cache(context)
if self.param == "DELETE":
delete_motion_set(action)
elif self.param == "DUPLICATE":
duplicate_motion_set(action)
return {"FINISHED"}
@classmethod
def description(cls, context, properties):
return "Show motion set info"
class CCICMotionSetRename(bpy.types.Operator):
bl_idname = "ccic.motion_set_rename"
bl_label = "Rename Motion Set"
action: bpy.props.StringProperty(name="Action", default="")
prefix: bpy.props.StringProperty(name="Motion Prefix", default="")
rig_id: bpy.props.StringProperty(name="Character / Rig ID", default="")
motion_id: bpy.props.StringProperty(name="Motion Name / ID", default="")
set_id = bpy.props.StringProperty(name="Set ID", default="")
action_type = bpy.props.StringProperty(name="Action Type", default="")
def execute(self, context):
props = vars.props()
prefix = self.prefix
rig_id = self.rig_id
motion_id = get_unique_set_motion_id(rig_id, self.motion_id, prefix,
exclude_set_id=self.set_id,
slotted=(self.action_type == "SLOTTED"))
for action in bpy.data.actions:
if "rl_set_id" in action:
if action["rl_set_id"] == self.set_id:
set_id, set_generation, action_type_id, obj_id = get_motion_set_ids(action)
if action_type_id == "ARM":
name = make_armature_action_name(rig_id, motion_id, prefix, slotted=False)
action.name = name
elif action_type_id == "KEY":
name = make_key_action_name(rig_id, motion_id, obj_id, prefix)
action.name = name
elif action_type_id == "SLOTTED":
name = make_armature_action_name(rig_id, motion_id, prefix, slotted=True)
action.name = name
return {"FINISHED"}
def invoke(self, context, event):
props = vars.props()
prefs = vars.prefs()
props.store_ui_list_indices()
action = props.action_set_list_action
self.action = action.name
chr_cache = props.get_context_character_cache(context)
if not action:
return {"FINISHED"}
set_id, set_generation, action_type_id, key_object = get_motion_set_ids(action)
self.action_type = action_type_id
if not set_id:
return {"FINISHED"}
self.set_id = set_id
prefix, rig_id, type_id, obj_id, motion_id = decode_action_name(action)
if prefix:
self.prefix = prefix
else:
self.prefix = ""
if rig_id:
self.rig_id = rig_id
else:
self.rig_id = ""
if motion_id:
self.motion_id = motion_id
elif action.name:
self.motion_id = action.name.split("|")[-1]
else:
self.motion_id = "Motion"
return context.window_manager.invoke_props_dialog(self, width=400)
def draw(self, context):
layout = self.layout
split = layout.split(factor=0.35)
col_1 = split.column()
col_2 = split.column()
col_1.label(text="Motion Set ID:")
col_2.label(text=self.set_id)
col_1.separator()
col_2.separator()
col_1.label(text="Prefix:")
col_2.prop(self, "prefix", text="")
col_1.separator()
col_2.separator()
col_1.label(text="Character / Rig ID:")
col_2.prop(self, "rig_id", text="")
col_1.separator()
col_2.separator()
col_1.label(text="Motion Name / ID:")
col_2.prop(self, "motion_id", text="")
layout.separator()
@classmethod
def description(cls, context, properties):
return "Change the name, prefix, and character/rig id of the motion set"
class CCICMotionSetInfo(bpy.types.Operator):
bl_idname = "ccic.motion_set_info"
bl_label = "Motion Set Info"
prefix: bpy.props.StringProperty(name="Motion Prefix", default="")
rig_id: bpy.props.StringProperty(name="Character / Rig ID", default="")
motion_id: bpy.props.StringProperty(name="Motion Name / ID", default="")
set_id: bpy.props.StringProperty(name="Set ID", default="")
def execute(self, context):
return {"FINISHED"}
def invoke(self, context, event):
props = vars.props()
prefs = vars.prefs()
props.store_ui_list_indices()
action = props.action_set_list_action
chr_cache = props.get_context_character_cache(context)
self.delete_me = False
# TODO make delete an op button?
# TODO use_fake_user button
if not action:
return {"FINISHED"}
set_id, set_generation, action_type_id, key_object = get_motion_set_ids(action)
if not set_id:
return {"FINISHED"}
self.set_id = set_id
prefix, rig_id, type_id, obj_id, motion_id = decode_action_name(action)
if prefix:
self.prefix = prefix
if rig_id:
self.rig_id = rig_id
elif chr_cache:
self.rig_id = chr_cache.character_name
else:
self.rig_id = "Rig"
if motion_id:
self.motion_id = motion_id
elif action.name:
self.motion_id = action.name.split("|")[-1]
else:
self.motion_id = "Motion"
return context.window_manager.invoke_popup(self, width=600)
def draw(self, context):
layout = self.layout
split = layout.split(factor=0.25)
col_1 = split.column()
col_2 = split.column()
col_1.label(text="Motion Set ID:")
col_2.label(text=self.set_id)
col_1.separator()
col_2.separator()
col_1.label(text="Prefix:")
col_2.label(text=self.prefix if self.prefix else "(None)")
col_1.label(text="Character / Rig ID:")
col_2.label(text=self.rig_id if self.rig_id else "(None)")
col_1.label(text="Motion Name / ID:")
col_2.label(text=self.motion_id if self.motion_id else "(None)")
layout.separator()
layout.label(text="Actions:")
split = layout.split(factor=0.25)
col_1 = split.column()
col_2 = split.column()
for action in bpy.data.actions:
action_set_id = utils.get_prop(action, "rl_set_id")
action_type = utils.get_prop(action, "rl_action_type")
if action_set_id == self.set_id:
if action_type == "ARM":
col_1.label(text="Armature")
elif action_type == "KEY":
obj_id = utils.get_prop(action, "rl_key_object", "(None)")
col_1.label(text=obj_id)
else:
col_1.label(text="?")
col_2.label(text=action.name)
col_1.separator()
col_2.separator()
col_1.separator()
row = col_2.split(factor=0.5).column().row()
row.alert = True
row.scale_y = 1.5
row.operator("ccic.rigutils", text="Delete Motion Set", icon="ERROR").param = "DELETE_MOTION_SET"
layout.separator()
layout.separator()
layout.separator()
@classmethod
def description(cls, context, properties):
return "Show motion set info"
#region Operators
class CCICRigUtils(bpy.types.Operator):
"""Rig Utilities"""
bl_idname = "ccic.rigutils"
bl_label = "Rig Utils"
bl_options = {"REGISTER"}
param: bpy.props.StringProperty(
name = "param",
default = "",
options={"HIDDEN"}
)
def execute(self, context):
props = vars.props()
prefs = vars.prefs()
chr_cache = props.get_context_character_cache(context)
rig = chr_cache.get_armature() if chr_cache else None
if chr_cache:
props.store_ui_list_indices()
if rig:
if self.param == "TOGGLE_SHOW_FULL_RIG":
toggle_show_full_rig(rig)
elif self.param == "TOGGLE_SHOW_BASE_RIG":
toggle_show_base_rig(rig)
elif self.param == "TOGGLE_SHOW_SPRING_RIG":
toggle_show_spring_rig(rig)
elif self.param == "TOGGLE_SHOW_RIG_POSE":
toggle_rig_rest_position(rig)
elif self.param == "TOGGLE_SHOW_SPRING_BONES":
springbones.toggle_show_spring_bones(chr_cache)
elif self.param == "TOGGLE_EXPRESSION_RIG_LOCK":
facerig.toggle_lock_position(chr_cache, rig)
elif self.param == "BUTTON_RESET_POSE_SELECTED":
mode_selection = utils.store_mode_selection_state()
reset_pose(rig, use_selected=True)
utils.restore_mode_selection_state(mode_selection)
elif self.param == "BUTTON_RESET_POSE":
mode_selection = utils.store_mode_selection_state()
reset_pose(rig, use_selected=False)
utils.restore_mode_selection_state(mode_selection)
elif self.param == "RESET_EXPRESSION_POSE":
if chr_cache.rigified:
mode_selection = utils.store_mode_selection_state()
facerig.clear_expression_pose(chr_cache, rig)
utils.restore_mode_selection_state(mode_selection)
elif self.param == "RESET_EXPRESSION_POSE_SELECTED":
if chr_cache.rigified:
mode_selection = utils.store_mode_selection_state()
facerig.clear_expression_pose(chr_cache, rig, selected=True)
utils.restore_mode_selection_state(mode_selection)
elif self.param == "TOGGLE_SHOW_FACE_RIG":
toggle_show_only_face_rig(rig)
elif self.param == "SET_LIMB_FK":
if chr_cache.rigified:
set_rigify_ik_fk_influence(rig, 1.0)
poke_rig(rig)
elif self.param == "SET_LIMB_IK":
if chr_cache.rigified:
set_rigify_ik_fk_influence(rig, 0.0)
poke_rig(rig)
elif self.param == "LOAD_MOTION_SET":
action = props.action_set_list_action
load_motion_set(rig, action)
elif self.param == "PUSH_ACTION_SET":
action = props.action_set_list_action
auto_index = chr_cache.get_auto_index()
push_motion_set(rig, action, auto_index)
elif self.param == "CLEAR_ACTION_SET":
clear_motion_set(rig)
elif self.param == "NEW_ACTION_SET":
new_motion_set(rig)
elif self.param == "DISABLE_CONSTRAINT_STRETCH":
mode_selection = utils.store_mode_selection_state()
rigify_rig = chr_cache.get_armature()
disable_ik_stretch(rigify_rig)
utils.restore_mode_selection_state(mode_selection)
elif self.param == "ENABLE_CONSTRAINT_STRETCH":
mode_selection = utils.store_mode_selection_state()
rigify_rig = chr_cache.get_armature()
restore_ik_stretch(rigify_rig=rigify_rig)
utils.restore_mode_selection_state(mode_selection)
if self.param == "SELECT_SET_STRIPS":
strip = context.active_nla_strip
select_strips_by_set(strip)
elif self.param == "NLA_ALIGN_LEFT":
strips = context.selected_nla_strips
align_strips(strips, left=True)
elif self.param == "NLA_ALIGN_TO_LEFT":
strips = context.selected_nla_strips
active_strip = context.active_nla_strip
align_strips(strips, to_strip=active_strip, left=True)
elif self.param == "NLA_ALIGN_RIGHT":
strips = context.selected_nla_strips
align_strips(strips, left=False)
elif self.param == "NLA_ALIGN_TO_RIGHT":
strips = context.selected_nla_strips
active_strip = context.active_nla_strip
align_strips(strips, to_strip=active_strip, left=False)
elif self.param == "NLA_SIZE_SHORTEST":
strips = context.selected_nla_strips
size_strips(strips, longest=False)
elif self.param == "NLA_SIZE_LONGEST":
strips = context.selected_nla_strips
size_strips(strips, longest=True)
elif self.param == "NLA_SIZE_TO":
strips = context.selected_nla_strips
active_strip = context.active_nla_strip
size_strips(strips, to_strip=active_strip)
elif self.param == "NLA_RESET_SIZE":
strips = context.selected_nla_strips
size_strips(strips, reset=True)
elif self.param == "SET_FAKE_USER_ON":
action = props.action_set_list_action
set_action_set_fake_user(action, True)
elif self.param == "SET_FAKE_USER_OFF":
action = props.action_set_list_action
set_action_set_fake_user(action, False)
elif self.param == "DELETE_MOTION_SET":
action = props.action_set_list_action
delete_motion_set(action)
props.restore_ui_list_indices()
if self.param == "CLEAN_ACTIONS":
if utils.object_exists_is_camera(context.object) or utils.object_exists_is_light(context.object):
clean_actions(context.object)
elif rig:
clean_actions(rig)
return {"FINISHED"}
@classmethod
def description(cls, context, properties):
if properties.param == "TOGGLE_SHOW_SPRING_BONES":
return "Quick toggle for the armature layers to show just the spring bones or just the body bones"
elif properties.param == "TOGGLE_SHOW_FULL_RIG":
return "Toggles showing all the rig controls"
elif properties.param == "TOGGLE_SHOW_BASE_RIG":
return "Toggles showing the base rig controls"
elif properties.param == "TOGGLE_SHOW_SPRING_RIG":
return "Toggles showing just the spring rig controls"
elif properties.param == "TOGGLE_SHOW_RIG_POSE":
return "Toggles the rig between pose mode and rest pose"
elif properties.param == "TOGGLE_SHOW_FACE_RIG":
return "Toggles showing just the face expression rig controls"
elif properties.param == "TOGGLE_EXPRESSION_RIG_LOCK":
return "Toggle locking the position of the expression rig and making unselectable"
elif properties.param == "BUTTON_RESET_POSE":
return "Clears all pose transforms"
elif properties.param == "BUTTON_RESET_POSE_SELECTED":
return "Clears the pose on all selected bones"
elif properties.param == "RESET_EXPRESSION_POSE":
return "Clears the expression on all expression controls"
elif properties.param == "RESET_EXPRESSION_POSE_SELECTED":
return "Clears the pose on all selected expression rig bones"
elif properties.param == "LOAD_MOTION_SET":
return "Loads the chosen motion set (armature and shape key actions) into the all the character objects"
elif properties.param == "PUSH_ACTION_SET":
return "Pushes the chosen motion set (armature and shape key actions) into the NLA tracks of all the character objects at the current frame. " \
"A suitable track will be chosen to fit the actions. If there is no room available a new track will be added to contain the actions"
elif properties.param == "CLEAR_ACTION_SET":
return "Removes all actions from the character"
elif properties.param == "SELECT_SET_STRIPS":
return "Selects all the strips belonging to the same motion set and strip index"
elif properties.param == "NLA_ALIGN_LEFT":
return "Aligns all selected strips to the left most of frame of all selected strips"
elif properties.param == "NLA_ALIGN_RIGHT":
return "Aligns all selected strips to right most of frame of all selected strips"
elif properties.param == "NLA_ALIGN_TO_LEFT":
return "Aligns all selected strips to the left hand frame of the active strip"
elif properties.param == "NLA_ALIGN_TO_RIGHT":
return "Aligns all selected strips to the right hand frame of the active strip"
elif properties.param == "NLA_SIZE_SHORTEST":
return "Sets the frame lengths of all selected strips to the length of the shortest strip in the selection"
elif properties.param == "NLA_SIZE_TO":
return "Sets the frame lengths of all selected strips to the length of the active strip"
elif properties.param == "NLA_SIZE_LONGEST":
return "Sets the frame lengths of all selected strips to the length of the longest strip in the selection"
elif properties.param == "NLA_RESET_SIZE":
return "Resets the frame lengths of all selected strips to the length of the underlying action"
elif properties.param == "SET_FAKE_USER_ON":
return "Set fake user on all actions in the motion set"
elif properties.param == "SET_FAKE_USER_OFF":
return "Clear fake user on all actions in the motion set"
elif properties.param == "DELETE_MOTION_SET":
return "Delete all actions in the motion set"
elif properties.param == "DISABLE_CONSTRAINT_STRETCH":
return "Disable stretch in all IK mechanisms on the rig. By default the Blender Rigify rig allows a certain amount of stretch in the bones ease IK alignment.\n" \
"But in other applications, this bone stretch is not possible, disabling the IK stretch system can aid with animation alignment problems"
elif properties.param == "ENABLE_CONSTRAINT_STRETCH":
return "Re-enable the IK stretch mechanisms in the rig"
return ""
class CCIC_ImportMixBones_UL_List(bpy.types.UIList):
def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
if self.layout_type in {'DEFAULT', 'COMPACT'}:
layout.label(text=item.name if item else "", translate=False, icon_value=icon)
elif self.layout_type in {'GRID'}:
layout.alignment = 'CENTER'
layout.label(text="", icon_value=icon)
def filter_items(self, context, data, propname):
filtered = []
ordered = []
items = getattr(data, propname)
filtered = [self.bitflag_filter_item] * len(items)
for i, item in enumerate(items):
allowed = True
# filter by name
if self.filter_name and self.filter_name != "*":
if self.filter_name not in item.name:
allowed = False
# block not allowed
if not allowed:
filtered[i] &= ~self.bitflag_filter_item
return filtered, ordered
class CCICActionImportFunctions(bpy.types.Operator):
"""Action Import Functions"""
bl_idname = "ccic.action_import_functions"
bl_label = "Action Import Functions"
bl_options = {"REGISTER", "UNDO"}
param: bpy.props.StringProperty(
name = "param",
default = "",
options={"HIDDEN"}
)
def execute(self, context):
props = vars.props()
prefs = vars.prefs()
chr_cache = props.get_context_character_cache(context)
if chr_cache:
if self.param == "ADD_BONE":
self.add_bone(chr_cache)
elif self.param == "REMOVE_BONE":
self.remove_bone(chr_cache)
return {"FINISHED"}
def add_bone(self, chr_cache):
arm = chr_cache.get_armature()
props = chr_cache.action_options
bone_index = props.rig_mix_bones_list_index
bone = arm.data.bones[bone_index]
for bone_item in props.import_mix_bones:
if bone_item.name == bone.name:
return
bone_item = props.import_mix_bones.add()
bone_item.name = bone.name
bone_item.weight = 1.0
def remove_bone(self, chr_cache):
props = chr_cache.action_options
index = props.import_mix_bones_list_index
try:
props.import_mix_bones.remove(index)
except:
print(f"Unable to remove import mix bones index: {index}")
@classmethod
def description(cls, context, properties):
return ""
class CCIC_RigMixBones_UL_List(bpy.types.UIList):
def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
if self.layout_type in {'DEFAULT', 'COMPACT'}:
layout.label(text=item.name if item else "", translate=False, icon_value=icon)
elif self.layout_type in {'GRID'}:
layout.alignment = 'CENTER'
layout.label(text="", icon_value=icon)
def filter_items(self, context, data, propname):
props = vars.props()
filtered = []
ordered = []
items = getattr(data, propname)
filtered = [self.bitflag_filter_item] * len(items)
item : bpy.types.Action
chr_cache = props.get_context_character_cache(context)
if chr_cache:
arm = chr_cache.get_armature()
for i, item in enumerate(items):
allowed = True
# filter by name
if self.filter_name and self.filter_name != "*":
if self.filter_name not in item.name:
allowed = False
# block not allowed
if not allowed:
filtered[i] &= ~self.bitflag_filter_item
return filtered, ordered
class CCICActionImportOptions(bpy.types.Operator):
"""Action Import Options"""
bl_idname = "ccic.action_import_options"
bl_label = "Action Import Options"
bl_options = {"REGISTER", "UNDO"}
chr_cache = None
objects = {}
@classmethod
def poll(cls, context):
return True
#props = vars.props()
#return props.get_context_character_cache(context) is not None
@classmethod
def label(cls, context, chr_cache=None):
props = vars.props()
if not chr_cache:
chr_cache = props.get_context_character_cache(context, strict=True)
if not chr_cache:
opts = props.action_options
if chr_cache and chr_cache.action_options:
opts = chr_cache.action_options
action_text = {
"NEW": "New",
"REPLACE": "Replace",
"BLEND": "Overwrite",
}
frame_text = {
"START": "Start",
"CURRENT": "Current",
"MATCH": "Match",
}
mask_text = " (Mask)" if opts.use_masking else ""
return f"{action_text[opts.get_action_mode()]} | {frame_text[opts.get_frame_mode()]}{mask_text}"
def draw(self, context):
prefs = vars.prefs()
props = vars.props()
layout = self.layout
column = layout.column()
# prefs
column.label(text="Preferences:")
row = column.row()
grid = row.grid_flow(row_major=True, columns=2)
if utils.B440():
grid.prop(prefs, "action_use_action_slots")
grid.prop(prefs, "action_add_key_slots_per_obj")
#grid.prop(prefs, "action_clean_actions")
grid.prop(prefs, "action_add_empty_key_channels")
if True:
opts = props.action_options
column.separator()
column.row().label(text="Global Motion Options:")
column.row().prop(opts, "action_mode")
column.row().prop(opts, "frame_mode")
if self.chr_cache and self.chr_cache.action_options:
arm = self.chr_cache.get_armature()
opts = self.chr_cache.action_options
column.separator()
row = column.row()
row.prop(opts, "override_global")
row.label(text=f"{self.chr_cache.character_name}")
column = column.column()
column.enabled = opts.override_global
column.row().prop(opts, "action_mode")
column.row().prop(opts, "frame_mode")
return
column.separator()
column.row().prop(opts, "use_masking")
if opts.use_masking:
row = column.row()
row.template_list("CCIC_RigMixBones_UL_List", "rig_mix_bones_list",
arm.data, "bones",
opts, "rig_mix_bones_list_index",
rows=8, maxrows=8)
col = row.column()
col.separator(factor=4.0)
col.operator("ccic.action_import_functions", text="", icon="PLAY").param = "ADD_BONE"
col.separator(factor=4.0)
col.operator("ccic.action_import_functions", text="", icon="PLAY_REVERSE").param = "REMOVE_BONE"
col.separator(factor=4.0)
row.template_list("CCIC_ImportMixBones_UL_List", "import_mix_bones_list",
opts, "import_mix_bones",
opts, "import_mix_bones_list_index",
rows=8, maxrows=8)
def execute(self, context):
props = vars.props()
prefs = vars.prefs()
#self.chr_cache = props.get_context_character_cache(context)
return {'FINISHED'}
def invoke(self, context, event):
props = vars.props()
prefs = vars.prefs()
utils.set_mode("OBJECT")
self.chr_cache = props.get_context_character_cache(context, strict=True)
return context.window_manager.invoke_props_dialog(self, width=500)
@classmethod
def description(cls, context, properties):
return "Description"
# endregion
def add_action_slot_channelbag(action, name, slot_type, reuse=False, clear=False):
if utils.B440():
channelbags = utils.get_action_channelbags(action)
if reuse:
for channelbag in channelbags:
if channelbag.slot and channelbag.slot.target_id_type == slot_type and channelbag.slot.name_display == name:
slot = channelbag.slot
channel = channelbag
if clear:
channel.fcurves.clear()
return slot, channel
slot = action.slots.new(slot_type, name)
channel = channelbags.new(slot)
else:
slot = None
channel = action
return slot, channel
def add_action_key_slot_channelbag(action, obj: bpy.types.Object, reuse=False, clear=False):
return add_action_slot_channelbag(action, obj.name, "KEY", reuse=reuse, clear=clear)
def add_action_ob_slot_channelbag(action, obj: bpy.types.Object, reuse=False, clear=False):
return add_action_slot_channelbag(action, obj.name, "OBJECT", reuse=reuse, clear=clear)
def is_slotted_action(action):
return utils.B440() and len(action.slots) > 1
def copy_slot_actions(src_action, dst_action, slot_type):
src_channelbags = utils.get_action_channelbags(src_action)
for src_channel in src_channelbags:
slot = src_channel.slot
if slot.target_id_type == slot_type:
dst_slot, dst_channel = add_action_slot_channelbag(dst_action, slot.name_display, slot_type)
for fcurve in src_channel.fcurves:
copy_fcurve_to_channel(fcurve, dst_channel)
def copy_action_shape_key_channels(rig, src_action, dst_action, fake_user=True):
prefs = vars.prefs()
copy_actions = [dst_action]
if prefs.use_action_slots():
copy_slot_actions(src_action, dst_action, "KEY")
else:
rig_id = get_rig_id(rig)
motion_set = get_motion_set_ids(dst_action)
set_id = motion_set[0]
set_generation = motion_set[1]
motion_prefix = get_motion_prefix(dst_action)
motion_id = get_motion_id(dst_action)
key_actions = fetch_key_actions(src_action)
for key_action in key_actions:
key_object = utils.get_prop(key_action, "rl_key_object")
action_name = make_key_action_name(rig_id, motion_id, key_object, motion_prefix)
utils.log_info(f" - Copying Key Action: {key_action.name} to {action_name}")
copy_action: bpy.types.Action = key_action.copy()
copy_action.name = action_name
copy_action.use_fake_user = fake_user
add_motion_set_data(copy_action, set_id, set_generation, obj_id=key_object, slotted=False)
copy_actions.append(copy_action)
return copy_actions
def fetch_key_actions(source_action):
source_actions = find_source_actions(source_action)
return source_actions["keys"].values()
def fetch_action_curve_database(source_action):
database = {}
SOURCE_CHANNELS = ["CC_Base_Body", "CC_Game_Body", "CC_Base_Tongue"]
source_actions = find_source_actions(source_action)
if source_actions["armature"]:
source_action = source_actions["armature"]
source_arm_actions = [a for a in source_actions["armatures"]]
source_key_actions = [a for a in source_actions["keys"].values()]
arm_actions = [a.copy() for a in source_arm_actions]
key_actions = [a.copy() for a in source_key_actions]
for arm_action in arm_actions:
arm_action.name = "DB_AC_TMP"
for key_action in key_actions:
key_action.name = "DB_KC_TMP"
data_curves = { "OBJECT": {}, "KEY": {} }
database["source_action"] = source_action
database["source_arm_actions"] = source_arm_actions
database["source_key_actions"] = source_key_actions
database["arm_actions"] = arm_actions
database["key_actions"] = key_actions
all_actions = []
database["all_actions"] = all_actions
for a in source_arm_actions + source_key_actions + arm_actions + key_actions:
if a not in all_actions:
all_actions.append(a)
database["curves"] = data_curves
first_frame = None
if utils.B440():
all_actions = arm_actions + key_actions
a: bpy.types.Action
for a in all_actions:
channelbags = utils.get_action_channelbags(a)
# build database of fcurves by slot
for channel in channelbags:
slot = channel.slot
is_source_channel = False
for MC in SOURCE_CHANNELS:
if slot.name_display.startswith(MC):
is_source_channel = True
slot_type = slot.target_id_type
if slot_type not in data_curves:
data_curves[slot_type] = {}
slot_curves = data_curves[slot_type]
fcurve: bpy.types.FCurve = None
for fcurve in channel.fcurves:
data_path = fcurve.data_path
index = fcurve.array_index
id = (data_path, index)
if id not in slot_curves or is_source_channel:
slot_curves[id] = fcurve
if fcurve.keyframe_points and len(fcurve.keyframe_points) > 0:
frame = fcurve.keyframe_points[0].co.x
if first_frame is None or frame < first_frame:
first_frame = frame
else:
all_actions = []
for arm_action in arm_actions:
all_actions.append(("OBJECT", arm_action))
for key_action in key_actions:
all_actions.append(("KEY", key_action))
for slot_type, a in all_actions:
# build database of fcurves by slot
if slot_type not in data_curves:
data_curves[slot_type] = {}
slot_curves = data_curves[slot_type]
fcurve: bpy.types.FCurve = None
for fcurve in a.fcurves:
data_path = fcurve.data_path
index = fcurve.array_index
id = (data_path, index)
if id not in slot_curves:
slot_curves[id] = fcurve
if fcurve.keyframe_points and len(fcurve.keyframe_points) > 0:
frame = fcurve.keyframe_points[0].co.x
if first_frame is None or frame < first_frame:
first_frame = frame
database["first_frame"] = first_frame
return database
def load_slotted_action(rig, action: bpy.types.Action, move=False, temp=None):
prefs = vars.prefs()
# determine motion set info
rig_id = get_rig_id(rig)
rl_arm_id = utils.get_rl_object_id(rig)
old_action = utils.safe_get_action(rig)
set_id = utils.get_prop(action, "rl_set_id")
set_generation = utils.get_prop(action, "rl_set_generation")
motion_prefix = get_motion_prefix(action)
motion_id = get_motion_id(action)
src_rl_arm_id = utils.get_prop(action, "rl_armature_id")
use_fake_user = action.use_fake_user
# if loading onto a different rig_id, we want to create a new motion set ...
use_new_motion_set = (rl_arm_id != src_rl_arm_id) or temp or move
if temp:
motion_prefix = "TEMP"
motion_id = temp
if use_new_motion_set:
set_id = generate_set_id()
# generate a database of fcurves in the motion set
database = fetch_action_curve_database(action)
# re-use the existing source armature action
if use_new_motion_set:
motion_id = get_unique_set_motion_id(rig_id, motion_id, motion_prefix, slotted=True)
action_name = generate_action_name(rig_id, "", "", motion_id, motion_prefix)
# if temp, re-use any existing temp action
if temp and action_name in bpy.data.actions:
action = bpy.data.actions[action_name]
else:
action = action.copy()
utils.force_action_name(action, action_name)
# add motion set data
add_motion_set_data(action, set_id, set_generation, arm_id=rl_arm_id, slotted=True)
action.use_fake_user = use_fake_user
# if this is a temporary action, store the action it replaced
if temp:
action["rl_temp_action"] = old_action.name if old_action else ""
else:
action: bpy.types.Action = database["source_action"]
# build channels for each object in rig
utils.log_info(f"Retargetting Slotted Action: {action.name}")
keep_slots = []
keep_channels = []
data_curves = database["curves"]
first_frame = database["first_frame"]
# ARMATURE ACTION
#
if "OBJECT" in data_curves:
slot_curves = data_curves["OBJECT"]
used_ids = set()
# add armature (object) slot
rig_slot, rig_channel = add_action_ob_slot_channelbag(action, rig, reuse=True, clear=True)
# for each bone fcurve in the database in the order of the pose bones on the rig ...
for bone in rig.pose.bones:
for id, fcurve in slot_curves.items():
curve_path, index = id
# that exist on this rig:
if id not in used_ids and bone.name in curve_path and utils.has_data_path(rig, curve_path):
clone = copy_fcurve_to_channel(fcurve, rig_channel)
# add fcurve to bone group
group_name = utils.get_data_path_object_name(curve_path)
if group_name:
if group_name in rig_channel.groups:
group = rig_channel.groups[group_name]
else:
group = rig_channel.groups.new(group_name)
clone.group = group
# store used id's
used_ids.add(id)
# keep this slot/channel and load onto rig slot
keep_slots.append(rig_slot)
keep_channels.append(rig_channel)
utils.safe_set_action(rig, action, create=True, slot=rig_slot)
# determine unused bone fcurves
unused_ids = set()
for id in slot_curves:
if id not in used_ids:
unused_ids.add(id)
if unused_ids:
# add slot for unused bone fcurves
rig_slot, rig_channel = add_action_slot_channelbag(action, "Unused Object", "OBJECT", reuse=True, clear=True)
# add unused fcurves
for id in unused_ids:
fcurve = slot_curves[id]
copy_fcurve_to_channel(fcurve, rig_channel)
# always keep this slot/channel
keep_slots.append(rig_slot)
keep_channels.append(rig_channel)
# SHAPE KEY ACTIONS
#
EXCLUDE_KEYS = ["Basis"]
SOURCE_MESH_NAMES = ["CC_Base_Body", "CC_Game_Body", "CC_Base_Tongue", "CC_Base_Eye"]
if "KEY" in data_curves:
slot_curves = data_curves["KEY"]
used_ids = set()
# determine source key names from source mesh shape keys
# (i.e. shape keys from the body/tongue/eyes)
source_keys = set()
for smn in SOURCE_MESH_NAMES:
for obj in rig.children:
if obj.name.startswith(smn):
if utils.object_exists_is_mesh(obj) and utils.object_has_shape_keys(obj):
for key in obj.data.shape_keys.key_blocks:
source_keys.add(key.name)
# if generating a single key slot for all meshes
if not prefs.action_add_key_slots_per_obj:
# add shape key slot/channel for all mesh objects
key_slot, key_channel = add_action_slot_channelbag(action, "All Keys", "KEY", reuse=True, clear=True)
# done id's across all meshes
done_ids = set()
done_keys = set()
for obj in rig.children:
if utils.object_exists_is_mesh(obj) and utils.object_has_shape_keys(obj):
# if generating key actions per mesh
if prefs.action_add_key_slots_per_obj:
# generate a specific shape key slot for each mesh object
key_slot, key_channel = add_action_key_slot_channelbag(action, obj, reuse=True, clear=True)
# done id's per mesh
done_ids = set()
done_keys = set()
has_keys = False
# determine data paths of all driven shape keys in this mesh
driver_paths = set()
if obj.data.shape_keys.animation_data:
for driver in obj.data.shape_keys.animation_data.drivers:
driver_paths.add(driver.data_path)
# for each key curve in the database ...
for id, fcurve in slot_curves.items():
curve_path, index = id
# whose data path exists on this object and is not driven
if utils.has_data_path(obj.data.shape_keys, curve_path) and curve_path not in driver_paths:
# this slot/channel has keys for this mesh
has_keys = True
# if not already added for this mesh
if id not in done_ids:
fcurve = slot_curves[id]
key_name = utils.get_data_path_object_name(curve_path)
clone = copy_fcurve_to_channel(fcurve, key_channel)
# add fcurve to expression group
group_name = get_shape_key_group_name(key_name)
if group_name:
if group_name in key_channel.groups:
group = key_channel.groups[group_name]
else:
group = key_channel.groups.new(group_name)
clone.group = group
# store used id's
done_keys.add(key_name)
used_ids.add(id)
done_ids.add(id)
if prefs.action_add_empty_key_channels and first_frame is not None:
# for any shape keys without fcurves that are source shape keys
# (i.e. shape keys from the body/tongue/eyes)
for key in obj.data.shape_keys.key_blocks:
if (key.name not in done_keys and
key.name in source_keys and
key.name not in EXCLUDE_KEYS):
data_path = f"key_blocks[\"{key.name}\"].value"
# that are not driven
if data_path not in driver_paths:
# this action has keys for this mesh
has_keys = True
# add a zero single keyframe track
fcurve = key_channel.fcurves.new(data_path)
fcurve.keyframe_points.add(1)
fcurve.keyframe_points.foreach_set('co', [first_frame, 0.0])
reset_fcurve_interpolation(fcurve)
# add fcurve to expression group
group_name = get_shape_key_group_name(key.name)
if group_name:
if group_name in key_channel.groups:
group = key_channel.groups[group_name]
else:
group = key_channel.groups.new(group_name)
fcurve.group = group
# keep slots/channels that have assigned keys and load onto mesh slot,
# remove slots/channels that have no assigned keys
if has_keys:
keep_slots.append(key_slot)
keep_channels.append(key_channel)
utils.safe_set_action(obj.data.shape_keys, action, create=True, slot=key_slot)
else:
utils.safe_set_action(obj.data.shape_keys, None)
# determine unused shape key fcurves
unused_ids = set()
for id in slot_curves:
if id not in used_ids:
unused_ids.add(id)
if unused_ids:
# add slot/channel for unused shape key fcuves
key_slot, key_channel = add_action_slot_channelbag(action, "Unused Keys", "KEY", reuse=True, clear=True)
# add unused shape key fcurves to action
for id in unused_ids:
fcurve = slot_curves[id]
copy_fcurve_to_channel(fcurve, key_channel)
# always keep this slot/channel
keep_slots.append(key_slot)
keep_channels.append(key_channel)
# remove old and unused slots and channels
delete_slots = []
delete_channels = []
channelbags = utils.get_action_channelbags(action)
for slot in action.slots:
if slot not in keep_slots:
delete_slots.append(slot)
for channel in channelbags:
if channel not in keep_channels:
delete_channels.append(channel)
for channel in delete_channels:
channelbags.remove(channel)
for slot in delete_slots:
action.slots.remove(slot)
# remove all database copies
delete_actions = database["arm_actions"] + database["key_actions"]
if move or not use_new_motion_set:
# remove old actions if moving to a new motion set
delete_actions += database["source_arm_actions"] + database["source_key_actions"]
# remove actions, except this action
for delete_action in delete_actions:
if utils.action_exists(delete_action):
if delete_action != action:
bpy.data.actions.remove(delete_action)
# ensure the action knows it is slotted
utils.set_prop(action, "rl_action_type", "SLOTTED")
# optional: clean up action key frames
if prefs.action_clean_actions:
if utils.action_exists(action):
clean_action_keyframes(action, channels=True)
return action
def load_separate_actions(rig: bpy.types.Object, action: bpy.types.Action, move=False, temp=None):
prefs = vars.prefs()
# determine motion set info
rig_id = get_rig_id(rig)
rl_arm_id = utils.get_rl_object_id(rig)
old_action = utils.safe_get_action(rig)
set_id = utils.get_prop(action, "rl_set_id")
set_generation = utils.get_prop(action, "rl_set_generation")
motion_prefix = get_motion_prefix(action)
motion_id = get_motion_id(action)
src_rl_arm_id = utils.get_prop(action, "rl_armature_id")
use_fake_user = action.use_fake_user
# if loading onto a different rig_id, we want to create a new motion set ...
use_new_motion_set = (rl_arm_id != src_rl_arm_id) or temp or move
if temp:
motion_prefix = "TEMP"
motion_id = temp
if use_new_motion_set:
set_id = generate_set_id()
# generate database of fcurves in the motion set
database = fetch_action_curve_database(action)
# build channels for each object in rig
utils.log_info(f"Retargetting Separate Actions: {action.name}")
keep_actions = []
remove_actions = []
data_curves = database["curves"]
first_frame = database["first_frame"]
# ARMATURE ACTION
#
if "OBJECT" in data_curves:
slot_curves = data_curves["OBJECT"]
used_ids = set()
# re-use the existing source armature action
if use_new_motion_set:
motion_id = get_unique_set_motion_id(rig_id, motion_id, motion_prefix, slotted=False)
action_name = generate_action_name(rig_id, "A", "", motion_id, motion_prefix)
# if temp, re-use any existing temp action
if temp and action_name in bpy.data.actions:
rig_action = bpy.data.actions[action_name]
else:
rig_action = bpy.data.actions.new(action_name)
utils.force_action_name(rig_action, action_name)
else:
rig_action: bpy.types.Action = database["source_action"]
utils.clear_action(rig_action)
# add slot and motion set data
rig_slot, rig_channel = add_action_ob_slot_channelbag(rig_action, rig, reuse=True, clear=True)
add_motion_set_data(rig_action, set_id, set_generation, arm_id=rl_arm_id, slotted=False)
rig_action.use_fake_user = use_fake_user
# if this is a temporary action, store the action it replaced
if temp:
rig_action["rl_temp_action"] = old_action.name if old_action else ""
# for each bone fcurve in the database in the order of the pose bones on the rig ...
for bone in rig.pose.bones:
for id, fcurve in slot_curves.items():
curve_path, index = id
# that exist on this rig:
if id not in used_ids and bone.name in curve_path and utils.has_data_path(rig, curve_path):
clone = copy_fcurve_to_channel(fcurve, rig_channel)
# add fcurve to bone group
group_name = utils.get_data_path_object_name(curve_path)
if group_name:
if group_name in rig_channel.groups:
group = rig_channel.groups[group_name]
else:
group = rig_channel.groups.new(group_name)
clone.group = group
# store used id's
used_ids.add(id)
# keep this and load onto rig
keep_actions.append(rig_action)
utils.safe_set_action(rig, rig_action, create=True, slot=rig_slot)
# determine unused bone fcurves
unused_ids = set()
for id in slot_curves:
if id not in used_ids:
unused_ids.add(id)
if unused_ids:
# generate an action for unused bones
action_name = generate_action_name(rig_id, "UA", "", motion_id, motion_prefix)
if temp and action_name in bpy.data.actions:
rig_action = bpy.data.actions[action_name]
else:
rig_action = bpy.data.actions.new(action_name)
utils.force_action_name(rig_action, action_name)
rig_action["rl_unused_action"] = True
# add slot and motion set data
rig_slot, rig_channel = add_action_slot_channelbag(rig_action, "Unused Object", "OBJECT", reuse=True, clear=True)
add_motion_set_data(rig_action, set_id, set_generation, arm_id=rl_arm_id, slotted=False)
rig_action.use_fake_user = use_fake_user
# if this is a temporary action, store the action it replaced
if temp:
rig_action["rl_temp_action"] = old_action.name if old_action else ""
# add unused fcurves
for id in unused_ids:
fcurve = slot_curves[id]
copy_fcurve_to_channel(fcurve, rig_channel)
# always keep this
keep_actions.append(rig_action)
# SHAPE KEY ACTIONS
#
EXCLUDE_KEYS = ["Basis"]
SOURCE_MESH_NAMES = ["CC_Base_Body", "CC_Game_Body", "CC_Base_Tongue", "CC_Base_Eye"]
if "KEY" in data_curves:
slot_curves = data_curves["KEY"]
used_ids = set()
# determine source key names from source mesh shape keys
# (i.e. shape keys from the body/tongue/eyes)
source_keys = set()
for smn in SOURCE_MESH_NAMES:
for obj in rig.children:
if obj.name.startswith(smn):
if utils.object_exists_is_mesh(obj) and utils.object_has_shape_keys(obj):
for key in obj.data.shape_keys.key_blocks:
source_keys.add(key.name)
# if generating a single key action for all meshes
if not prefs.action_add_key_slots_per_obj:
# use a single action for all mesh objects
action_name = generate_action_name(rig_id, "K", "ALL", motion_id, motion_prefix)
if temp and action_name in bpy.data.actions:
key_action = bpy.data.actions[action_name]
else:
key_action = bpy.data.actions.new(action_name)
utils.force_action_name(key_action, action_name)
# add slot and motion set data
add_motion_set_data(key_action, set_id, set_generation, obj_id="ALL", slotted=False)
key_slot, key_channel = add_action_slot_channelbag(key_action, "Key", "KEY", reuse=True, clear=True)
key_action.use_fake_user = use_fake_user
# if this is a temporary action, store the action it replaced
if temp:
key_action["rl_temp_action"] = old_action.name if old_action else ""
# done id's across all meshes
done_ids = set()
done_keys = set()
for obj in rig.children:
if utils.object_exists_is_mesh(obj) and utils.object_has_shape_keys(obj):
obj_id = get_obj_id(obj)
# if generating key actions per mesh
if prefs.action_add_key_slots_per_obj:
# generate a specific shape key slot for each mesh object
action_name = make_key_action_name(rig_id, motion_id, obj_id, motion_prefix)
if temp and action_name in bpy.data.actions:
key_action = bpy.data.actions[action_name]
else:
key_action = bpy.data.actions.new(action_name)
utils.force_action_name(key_action, action_name)
# add slot and motion set data
key_slot, key_channel = add_action_key_slot_channelbag(key_action, obj, reuse=True, clear=True)
add_motion_set_data(key_action, set_id, set_generation, obj_id=obj_id, slotted=False)
key_action.use_fake_user = use_fake_user
# if this is a temporary action, store the action it replaced
if temp:
key_action["rl_temp_action"] = old_action.name if old_action else ""
# done id's per mesh
done_ids = set()
done_keys = set()
has_keys = False
# determine data paths of all driven shape keys in this mesh
driver_paths = set()
if obj.data.shape_keys.animation_data:
for driver in obj.data.shape_keys.animation_data.drivers:
driver_paths.add(driver.data_path)
# for each key curve in the database
for id, fcurve in slot_curves.items():
curve_path, index = id
# whose data path exists on this object and is not driven
if utils.has_data_path(obj.data.shape_keys, curve_path) and curve_path not in driver_paths:
# this action has keys for this mesh
has_keys = True
# if not already added for this mesh
if id not in done_ids:
fcurve = slot_curves[id]
key_name = utils.get_data_path_object_name(curve_path)
clone = copy_fcurve_to_channel(fcurve, key_channel)
# add fcurve to expression group
group_name = get_shape_key_group_name(key_name)
if group_name:
if group_name in key_channel.groups:
group = key_channel.groups[group_name]
else:
group = key_channel.groups.new(group_name)
clone.group = group
# store used id's
done_keys.add(key_name)
used_ids.add(id)
done_ids.add(id)
if prefs.action_add_empty_key_channels and first_frame is not None:
# for any shape keys without fcurves that are source shape keys ...
# (i.e. shape keys from the body/tongue/eyes)
for key in obj.data.shape_keys.key_blocks:
if (key.name not in done_keys and
key.name in source_keys and
key.name not in EXCLUDE_KEYS):
data_path = f"key_blocks[\"{key.name}\"].value"
# that are not driven:
if data_path not in driver_paths:
# this action has keys for this mesh
has_keys = True
# add a zero single keyframe track
fcurve = key_channel.fcurves.new(data_path)
fcurve.keyframe_points.add(1)
fcurve.keyframe_points.foreach_set('co', [first_frame, 0.0])
reset_fcurve_interpolation(fcurve)
# add fcurve to expression group
group_name = get_shape_key_group_name(key.name)
if group_name:
if group_name in key_channel.groups:
group = key_channel.groups[group_name]
else:
group = key_channel.groups.new(group_name)
fcurve.group = group
# keep actions that have assigned keys and load onto mesh,
# remove actions that have no assigned keys
if has_keys:
keep_actions.append(key_action)
utils.safe_set_action(obj.data.shape_keys, key_action, create=True, slot=key_slot)
else:
remove_actions.append(key_action)
utils.safe_set_action(obj.data.shape_keys, None)
# determine unused shape key fcurves
unused_ids = set()
for id in slot_curves:
if id not in used_ids:
unused_ids.add(id)
if unused_ids:
# generate an action for all unused shape keys
action_name = generate_action_name(rig_id, "UK", "UNUSED", motion_id, motion_prefix)
if temp and action_name in bpy.data.actions:
key_action = bpy.data.actions[action_name]
else:
key_action = bpy.data.actions.new(action_name)
utils.force_action_name(key_action, action_name)
key_action["rl_unused_action"] = True
# add slot and motion set data
key_slot, key_channel = add_action_slot_channelbag(key_action, "Unused Keys", "KEY", reuse=True, clear=True)
add_motion_set_data(key_action, set_id, set_generation, obj_id="UNUSED", slotted=False)
key_action.use_fake_user = use_fake_user
# if this is a temporary action, store the action it replaced
if temp:
key_action["rl_temp_action"] = old_action.name if old_action else ""
# add unused shape key fcurves to action
for id in unused_ids:
fcurve = slot_curves[id]
copy_fcurve_to_channel(fcurve, key_channel)
# always keep this
keep_actions.append(key_action)
# remove database copies ...
remove_actions += database["arm_actions"]
remove_actions += database["key_actions"]
if move or not use_new_motion_set:
remove_actions += database["source_arm_actions"]
remove_actions += database["source_key_actions"]
for del_action in remove_actions:
if utils.action_exists(del_action) and del_action not in keep_actions:
bpy.data.actions.remove(del_action)
# optional: clean up action key-frames
if prefs.action_clean_actions:
for action in keep_actions:
if utils.action_exists(action):
clean_action_keyframes(action, channels=True)
return rig_action
def get_shape_key_group_name(key_name):
groups = {
"Basis": "Basis",
"Viseme": "V_",
"Brow": "Brow_",
"Eye": "Eye_",
"Eyelashes": "Eyelashes_",
"Ear": "Ear_",
"Nose": "Nose_",
"Mouth": "Mouth_",
"Jaw": "Jaw_",
"Neck": "Neck_",
"Head": "Head_",
"Tongue": "Tongue_",
"Eyelid": "Eyelid_",
"Constraint": "C_",
"Eyeball": "Eyeball_",
}
for group_name, prefix in groups.items():
if key_name.startswith(prefix):
return group_name
return "Custom"
def copy_fcurve_to_channel(from_fcurve: bpy.types.FCurve, to_channel) -> bpy.types.FCurve:
if utils.B500():
to_fcurve: bpy.types.FCurve = to_channel.fcurves.new_from_fcurve(from_fcurve)
else:
data_path = from_fcurve.data_path
index = from_fcurve.array_index
to_fcurve: bpy.types.FCurve = to_channel.fcurves.new(data_path, index=index)
to_fcurve.auto_smoothing = from_fcurve.auto_smoothing
to_fcurve.color = from_fcurve.color
to_fcurve.color_mode = from_fcurve.color_mode
to_fcurve.extrapolation = from_fcurve.extrapolation
to_fcurve.mute = from_fcurve.mute
to_fcurve.lock = from_fcurve.lock
from_keyframes, num_points = get_fcurve_keyframe_data(from_fcurve)
apply_fcurve_keyframe_data(to_fcurve, from_keyframes)
to_fcurve.update()
return to_fcurve
def refactor_to_slotted_action(objects, actions):
if not utils.B440():
return actions
combined = []
# build a database of armatures and their child mesh actions
data = {}
for obj in objects:
if obj.type == "ARMATURE":
action = utils.safe_get_action(obj)
data[obj.name] = {
"armature": obj,
"action": action,
"meshes": {},
}
for obj in objects:
if obj.type == "MESH":
action = utils.safe_get_action(obj.data.shape_keys)
if action:
if action in actions:
armature = obj.parent
if armature and action and armature.name in data:
meshes = data[armature.name]["meshes"]
meshes[obj.name] = {
"mesh": obj,
"action": action
}
else:
utils.log_error(f"Mesh action {action}, not found in actions!")
combined = []
for armature_name, armature_data in data.items():
armature = armature_data["armature"]
armature_action = armature_data["action"]
armature_channelbags = utils.get_action_channelbags(armature_action)
meshes = armature_data["meshes"]
for mesh_name, mesh_data in meshes.items():
mesh = mesh_data["mesh"]
mesh_action = mesh_data["action"]
# if already combined, ignore
if mesh_action == armature_action:
continue
# copy mesh action channels into slotted action
mesh_channelbags = utils.get_action_channelbags(mesh_action)
for i, mesh_channel in enumerate(mesh_channelbags):
slot_type = mesh_channel.slot.target_id_type
slot = armature_action.slots.new(slot_type, mesh_name)
channel = armature_channelbags.new(slot)
mesh_fcurve: bpy.types.FCurve = None
for mesh_fcurve in mesh_channel.fcurves:
copy_fcurve_to_channel(mesh_fcurve, channel)
mesh.data.shape_keys.animation_data.action = armature_action
mesh.data.shape_keys.animation_data.action_slot = slot
combined.append(armature_action)
# clean up old actions
for action in actions:
if action and action not in combined:
try:
bpy.data.actions.remove(action)
except: ...
return combined
def clean_actions(obj):
if utils.object_exists_is_camera(obj) or utils.object_exists_is_light(obj):
object_action = utils.safe_get_action(obj)
data_action = utils.safe_get_action(obj.data)
clean_action_keyframes(object_action)
clean_action_keyframes(data_action)
elif utils.object_exists_is_armature(obj):
rig_action = utils.safe_get_action(obj)
clean_action_keyframes(rig_action)
for child in obj.children:
if utils.object_exists_is_mesh(child) and utils.object_has_shape_keys(obj):
key_action = utils.safe_get_action(child)
clean_action_keyframes(key_action)
def clean_action_keyframes(action: bpy.types.Action, bone_threshold=0.0001, key_threshold=0.001, facerig_threshold=0.00001, other_threshold=0.0001, channels=True):
"""Note: bone threshold value of 0.0001 will clean bone key-frames to 1/200th of a degree 1/10th of a mm
key threshold value of 0.01 will clean shape key key-frames to 1/1000th of their range
facerig threshold value of about 0.00001 will clean key-frames on the
face rig controls to within 1/1000th on it's driven shape-key value."""
if not action:
return
fcurves = utils.get_action_fcurves(action)
bone_curves = []
key_curves = []
facerig_curves = []
other_curves = []
fcurve: bpy.types.FCurve
for fcurve in fcurves:
if fcurve.data_path.startswith("key_blocks"):
key_curves.append(fcurve)
elif fcurve.data_path.startswith("pose.bones"):
if "CTRL_" in fcurve.data_path:
facerig_curves.append(fcurve)
else:
bone_curves.append(fcurve)
else:
other_curves.append(fcurve)
groups = {}
groups["Pose Bone"] = (bone_curves, bone_threshold)
groups["Shape Keys"] = (key_curves, key_threshold)
groups["Face Rig Control"] = (facerig_curves, facerig_threshold)
groups["Other"] = (other_curves, other_threshold)
if bpy.context.screen.areas:
area = bpy.context.screen.areas[0]
area_type = area.type
area.type = "DOPESHEET_EDITOR"
if utils.B320():
with bpy.context.temp_override(area=area):
# deselect all key-frames
bpy.ops.action.select_all(action="DESELECT")
# deselect all channel groups and fcurves,
# otherwise everything gets cleaned (in channel mode) ...
for action in bpy.data.actions:
action_groups = utils.get_action_groups(action)
for group in action_groups:
group.select = False
action_fcurves = utils.get_action_fcurves(action)
for fcurve in action_fcurves:
fcurve.select = False
for group_name, (curves, threshold) in groups.items():
if curves:
curve_count = 0
keyframe_count = 0
# select the channels & groups to be cleaned
for fcurve in curves:
if utils.id_exists(fcurve):
fcurve.select = True
if utils.id_exists(fcurve.group):
fcurve.group.select = True
curve_count += 1
# if not cleaning by channel, select all the keyframes in each fcurve
if not channels:
kf: bpy.types.Keyframe
for kf in fcurve.keyframe_points:
kf.select_control_point = True
keyframe_count += 1
if channels:
utils.log_info(f"Cleaning action {group_name} key-frames: {action.name} ({curve_count} channels) Threshold: {threshold}")
else:
utils.log_info(f"Cleaning action {group_name} key-frames: {action.name} ({curve_count} channels, {keyframe_count} key-frames) Threshold: {threshold}")
# clean the selected channels / key-frames
bpy.ops.action.clean(threshold=threshold, channels=channels)
# deselect the channels we just cleaned
for fcurve in curves:
if utils.id_exists(fcurve):
fcurve.select = False
if utils.id_exists(fcurve.group) and fcurve.group.name != "":
fcurve.group.select = False
# deselect all key-frames
bpy.ops.action.select_all(action="DESELECT")
else:
utils.log_info(f"Cleaning action keyframes: {action.name} ({len(fcurves)} fcurves)")
context_override = bpy.context.copy()
context_override["area"] = area
context_override["selected_editable_fcurves"] = fcurves
context_override["selected_visible_fcurves"] = fcurves
bpy.ops.action.select_all(context_override, action="DESELECT")
bpy.ops.action.clean(context_override, threshold=threshold, channels=channels)
#except:
# utils.log_error(f"Unable to clean action keyframes: {action.name}")
area.type = area_type
def reset_fcurve_interpolation(fcurve: bpy.types.FCurve, interpolation="LINEAR"):
if interpolation != "BEZIER":
for keyframe in fcurve.keyframe_points:
keyframe.interpolation = interpolation
else:
L = len(fcurve.keyframe_points)
for i, keyframe in enumerate(fcurve.keyframe_points):
co = keyframe.co
prev: Vector = fcurve.keyframe_points[i-1].co if i > 0 else keyframe.co
next: Vector = fcurve.keyframe_points[i+1].co if i < L-1 else keyframe.co
keyframe.handle_left_type = "AUTO"
keyframe.handle_right_type = "AUTO"
keyframe.interpolation = interpolation
if i == L-1:
next = co + Vector((1, 0))
if i == 0:
prev = co + Vector((-1, 0))
forward: Vector = co * 0.5 + next * 0.5
back: Vector = co * 0.5 + prev * 0.5
foward_delta: Vector = forward - co
back_delta: Vector = co - back
if (foward_delta.y >= 0 and back_delta.y < 0) or (foward_delta.y < 0 and back_delta.y >= 0):
forward.y = keyframe.co.y
back.y = keyframe.co.y
else:
dy = (forward.y - back.y) * 0.5
forward.y = co.y + dy
back.y = co.y - dy
keyframe.handle_left[0] = back.x
keyframe.handle_left[1] = back.y
keyframe.handle_right[0] = forward.x
keyframe.handle_right[1] = forward.y
fcurve.update()
def shift_actions(action, to_frame, frame_start = 1):
if to_frame == frame_start:
return
fcurves = utils.get_action_fcurves(action)
fcurve: bpy.types.FCurve = None
for fcurve in fcurves:
num_points = len(fcurve.keyframe_points)
points_data = [0.0,0.0]*num_points
fcurve.keyframe_points.foreach_get('co', points_data)
for i in range(0, num_points):
frame = points_data[i*2]
points_data[i*2] = frame - frame_start + to_frame
fcurve.keyframe_points.foreach_set('co', points_data)
reset_fcurve_interpolation(fcurve)
def mix_actions(src_action, src_slot, dst_action, dst_slot, frame_start, frame_end):
src_channelbag = utils.get_action_channelbag(src_action, src_slot)
dst_channelbag = utils.get_action_channelbag(dst_action, dst_slot)
if not src_channelbag:
utils.log_error(f"Mix Actions: No source channels!")
return
if not dst_channelbag:
utils.log_error(f"Mix Actions: No destination channels!")
return
# determine which src curves correspond to which dst curves
fcurve_map = {}
used_dst = set()
for i, src_curve in enumerate(src_channelbag.fcurves):
for j, dst_curve in enumerate(dst_channelbag.fcurves):
if src_curve.data_path == dst_curve.data_path and src_curve.array_index == dst_curve.array_index:
fcurve_map[i] = j
used_dst.add(j)
break
# mix the src curves into the dst curve over the range
new_src = []
for i, src_curve in enumerate(src_channelbag.fcurves):
if i in fcurve_map:
j = fcurve_map[i]
dst_curve = dst_channelbag.fcurves[j]
mix_fcurve(src_curve, dst_curve, frame_start, frame_end)
else:
new_src.append(src_curve)
# these dst_curves have no corresponding curve in the src action, remove the mix keyframes?
for j, dst_curve in enumerate(dst_channelbag.fcurves):
if j not in used_dst:
mix_fcurve(None, dst_curve, frame_start, frame_end)
# for src curves not in the dst action, copy the fcurve in for that range
for src_curve in new_src:
copy_fcurve_to_channel(src_curve, dst_channelbag)
KEYFRAME_DATA_SIZE = {
"co": 2,
"type": 1,
"back": 1,
"easing": 1,
"period": 1,
"amplitude": 1,
"interpolation": 1,
"handle_left": 2,
"handle_right": 2,
"handle_left_type": 1,
"handle_right_type": 1,
}
def get_fcurve_keyframe_data(fcurve: bpy.types.FCurve):
if fcurve:
num_points = len(fcurve.keyframe_points)
else:
num_points = 0
keyframe_data = {}
for attr, size in KEYFRAME_DATA_SIZE.items():
data = [0]*size*num_points
if fcurve:
fcurve.keyframe_points.foreach_get(attr, data)
keyframe_data[attr] = data
return keyframe_data, num_points
def overwrite_fcurve_keyframe_data(src_keyframes, dst_keyframes, frame_before, frame_after):
result_keyframes = {}
for attr in src_keyframes:
src_data = src_keyframes[attr]
dst_data = dst_keyframes[attr]
size = KEYFRAME_DATA_SIZE[attr]
result_keyframes[attr] = dst_data[:(frame_before+1)*size] + src_data + dst_data[frame_after*size:]
return result_keyframes
def apply_fcurve_keyframe_data(fcurve: bpy.types.FCurve, keyframe_data):
num_points = len(keyframe_data["type"])
fcurve.keyframe_points.clear()
fcurve.keyframe_points.add(num_points)
for attr, data in keyframe_data.items():
fcurve.keyframe_points[0].back
fcurve.keyframe_points.foreach_set(attr, data)
def get_fcurve_data(fcurve: bpy.types.FCurve):
fcurve_data = {
"array_index": fcurve.array_index,
"auto_smoothing": fcurve.auto_smoothing,
"color": fcurve.color.copy(),
"color_mode": fcurve.color_mode,
"data_path": fcurve.data_path,
"extrapolation": fcurve.extrapolation,
}
return fcurve_data
def mix_fcurve(src_curve: bpy.types.FCurve, dst_curve: bpy.types.FCurve, frame_start, frame_end):
src_keyframes, num_src_points = get_fcurve_keyframe_data(src_curve)
dst_keyframes, num_dst_points = get_fcurve_keyframe_data(dst_curve)
dst_frames = dst_keyframes["co"][::2]
dst_index_before = 0
dst_index_after = num_dst_points
for i in range(0, num_dst_points):
frame = dst_frames[i]
if frame < frame_start:
dst_index_before = i
if frame > frame_end:
dst_index_after = i
break
result_keyframes = overwrite_fcurve_keyframe_data(src_keyframes, dst_keyframes, dst_index_before, dst_index_after)
apply_fcurve_keyframe_data(dst_curve, result_keyframes)
dst_curve.update()
def target_action(target):
try:
return target.animation_data.action
except: ...
return None
def target_slot(target):
try:
if utils.B440():
return target.animation_data.action_slot
except: ...
return None
def mix_motion_set(rig, action_store_id, frame_start, frame_end):
props = vars.props()
stored_main_action = props.fetch_stored_rig_action(action_store_id)
done = False
objects = [rig]
if utils.object_exists_is_armature(rig):
for child in rig.children:
if utils.object_exists_is_mesh(child) and utils.object_has_shape_keys(child):
objects.append(child)
mix_pairs = []
for obj in objects:
action_store = props.get_action_store_for(action_store_id, obj)
if utils.object_exists_is_armature(obj):
if obj.animation_data:
mix_pairs.append((obj, action_store, "OBJECT",
target_action(obj),
target_slot(obj),
action_store.object_action if action_store else None,
action_store.object_slot_id if action_store else None))
elif utils.object_exists_is_mesh(obj):
if obj.data.shape_keys.animation_data:
mix_pairs.append((obj, action_store, "KEY",
target_action(obj.data.shape_keys),
target_slot(obj.data.shape_keys),
action_store.object_action if action_store else None,
action_store.object_slot_id if action_store else None))
elif utils.object_exists_is_light(obj) or utils.object_exists_is_camera(obj):
if obj.animation_data:
mix_pairs.append((obj, action_store, "OBJECT",
target_action(obj),
target_slot(obj),
action_store.object_action if action_store else None,
action_store.object_slot_id if action_store else None))
if obj.data.animation_data:
mix_pairs.append((obj, action_store, "LIGHT" if utils.object_exists_is_light(obj) else "CAMERA",
target_action(obj.data),
target_slot(obj.data),
action_store.data_action if action_store else None,
action_store.data_slot_id if action_store else None))
for obj, action_store, slot_type, new_action, new_slot, old_action, old_slot_id in mix_pairs:
if new_action:
valid_slot = (not utils.B440() or old_slot_id)
if old_action and valid_slot:
# mix new action slot over old action slot
old_slot = utils.find_action_slot(old_action, slot_id=old_slot_id)
mix_actions(new_action, new_slot, old_action, old_slot, frame_start, frame_end)
done = True
else:
copy_channels_to_rig_motion(rig, obj, slot_type, new_action, new_slot, stored_main_action)
# invalidate the actions in the store (if there is one) to prevent it restoring an action (with the wrong slot)
if action_store:
if slot_type in ["LIGHT", "CAMERA"]:
action_store.data_action_valid = False
else:
action_store.object_action_valid = False
if done:
props.restore_actions(action_store_id)
#delete_motion_set(set_id)
def add_slot_channels_to_rig_motion(rig, obj, slot_type, action, reuse=False, clear=False):
prefs = vars.prefs()
is_rig = utils.object_exists_is_armature(rig)
if prefs.use_action_slots():
# add slot channel for src action slot channel
slot, channel = add_action_slot_channelbag(action, obj.name, slot_type, reuse=reuse, clear=clear)
else:
if is_rig:
# determine motion set info
rig_id = get_rig_id(rig)
obj_id = get_obj_id(obj)
set_id = utils.get_prop(action, "rl_set_id")
set_generation = utils.get_prop(action, "rl_set_generation")
motion_prefix = get_motion_prefix(action)
motion_id = get_motion_id(action)
use_fake_user = action.use_fake_user
# generate a slot channel for the object
if set_id:
if slot_type == "OBJECT":
action_name = make_armature_action_name(rig_id, motion_id, motion_prefix, slotted=False)
elif slot_type == "KEY":
action_name = make_key_action_name(rig_id, motion_id, obj_id, motion_prefix)
else:
set_id = None
motion_id = get_motion_id(action, f"{utils.datetimes()}")
motion_prefix = get_motion_prefix(action)
if slot_type == "OBJECT":
action_name = generate_action_name(obj.name, "O", "", motion_id, motion_prefix)
if slot_type == "LIGHT" or slot_type == "CAMERA":
action_name = generate_action_name(obj.name, slot_type[0], "", motion_id, motion_prefix)
# make a new dst_action for this object
if reuse and action_name in bpy.data.actions:
action = bpy.data.actions[action_name]
else:
action = bpy.data.actions.new(action_name)
utils.force_action_name(action, action_name)
if clear:
utils.clear_action(action)
action.use_fake_user = use_fake_user
if set_id:
add_motion_set_data(action, set_id, set_generation, obj_id=obj_id, slotted=False)
# add slot and motion set data
if slot_type == "OBJECT":
slot, channel = add_action_ob_slot_channelbag(action, rig, reuse=True, clear=True)
elif slot_type == "KEY":
slot, channel = add_action_key_slot_channelbag(action, obj, reuse=True, clear=True)
elif slot_type == "LIGHT" or slot_type == "CAMERA":
slot, channel = add_action_slot_channelbag(action, obj.name, slot_type, reuse=True, clear=True)
return action, slot, channel
def copy_channels_to_rig_motion(rig, obj, slot_type, src_action, src_slot, dst_action):
src_channelbag = utils.get_action_channelbag(src_action, src_slot)
dst_action, dst_slot, dst_channel = add_slot_channels_to_rig_motion(rig, obj, slot_type, dst_action, reuse=True, clear=True)
# copy the source fcurves into the dst_channel
for fcurve in src_channelbag.fcurves:
copy_fcurve_to_channel(fcurve, dst_channel)
if slot_type == "KEY":
utils.safe_set_action(obj.data.shape_keys, dst_action, slot=dst_slot)
elif slot_type == "OBJECT":
utils.safe_set_action(obj, dst_action, slot=dst_slot)
elif slot_type == "LIGHT" or slot_type == "CAMERA":
utils.safe_set_action(obj.data, dst_action, slot=dst_slot)
else:
utils.log_error(f"Unknown slot target for {dst_action} {dst_slot} {dst_channel}")
dst_action = None
dst_slot = None
return dst_action, dst_slot
def finalize_rlx_import(obj, actions, action_store_id, action_mode, frame_start=None, frame_end=None):
props = vars.props()
motion_action = actions[0] if actions else None
motion_start_frame, motion_end_frame = get_actions_frame_range(actions)
if frame_start is None:
frame_start = motion_start_frame
if frame_end is None:
frame_end = motion_end_frame
utils.log_info("Finalize RLX import:")
utils.log_info(f"motion actions: {[a.name for a in actions]}")
utils.log_info(f"start frame: {frame_start}")
utils.log_info(f"end frame: {frame_end}")
if frame_start is None or frame_end is None:
utils.log_error(f"Unable to fetch frame range from actions!: {actions}")
props.restore_actions(action_store_id)
props.delete_action_store(action_store_id)
return
if actions:
stored_actions = props.fetch_stored_actions(action_store_id)
# now decide what to do with the actions based on the action_mode and frame_mode
if action_mode == "NEW":
# add new, do nothing else
utils.log_info(f"Action Mode NEW: Loaded new motion set: {motion_action.name}")
elif not stored_actions:
# no existing actions to replace or blend, do nothing else
utils.log_info(f"No current motion: Loaded new motion set: {motion_action.name}")
elif action_mode == "REPLACE":
# get the stored motion set data (and name) and apply it to the new motion_action
old_action = stored_actions[0]
utils.log_info(f"Action Mode REPLACE: updating motion set to: {old_action.name}")
stored_actions = props.fetch_stored_actions(action_store_id)
utils.delete_actions(stored_actions)
elif action_mode == "BLEND":
old_action = stored_actions[0]
utils.log_info(f"Action Mode BLEND: blending motion set: {motion_action.name} over existing motion: {old_action.name}")
mix_motion_set(obj, action_store_id, frame_start, frame_end)
utils.delete_actions(actions)
props.delete_action_store(action_store_id)
def finalize_motion_import(rig, motion_action, action_store_id, action_mode, frame_start=None, frame_end=None):
props = vars.props()
motion_start_frame, motion_end_frame = get_motion_set_frame_range(motion_action)
if frame_start is None:
frame_start = motion_start_frame
if frame_end is None:
frame_end = motion_end_frame
utils.log_info("Finalize motion import:")
utils.log_info(f"motion action: {motion_action.name}")
utils.log_info(f"start frame: {frame_start}")
utils.log_info(f"end frame: {frame_end}")
if frame_start is None or frame_end is None:
utils.log_error(f"Unable to fetch frame range from action!: {motion_action}")
props.restore_actions(action_store_id)
props.delete_action_store(action_store_id)
return
if motion_action:
set_id = get_motion_set_ids(motion_action)[0]
stored_actions = props.fetch_stored_actions(action_store_id)
# now decide what to do with the actions based on the action_mode and frame_mode
if action_mode == "NEW":
# already loaded, do nothing else
utils.log_info(f"Action Mode NEW: Loaded new motion set: {motion_action.name} / ({set_id})")
elif not stored_actions:
# already loaded, do nothing else
utils.log_info(f"No current motion: Loaded new motion set: {motion_action.name} / ({set_id})")
elif action_mode == "REPLACE":
# get the stored motion set data (and name) and apply it to the new motion_action
old_action = stored_actions[0]
old_set_id = get_motion_set_ids(old_action)[0]
utils.log_info(f"Action Mode REPLACE: deleting old motion set: {old_action.name} / ({old_set_id})")
#replace_motion_set(set_id, old_set_id)
delete_motion_set(old_set_id)
elif action_mode == "BLEND":
old_action = stored_actions[0]
old_set_id = get_motion_set_ids(old_action)[0]
utils.log_info(f"Action Mode BLEND: blending motion set: {motion_action.name} / ({set_id}) over existing motion: {old_action.name} / ({old_set_id})")
mix_motion_set(rig, action_store_id, frame_start, frame_end)
delete_motion_set(set_id)
props.delete_action_store(action_store_id)
Reference in New Issue View Git Blame Copy Permalink