Nathan
240 lines
8.3 KiB
Python
240 lines
8.3 KiB
Python
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
"""FK rotations: copy visible rotations from original to replacement using constraints."""
|
|
|
|
import bpy
|
|
|
|
# Arm FK bone name patterns to check (Rigify and common alternatives)
|
|
ARM_FK_PATTERNS = (
|
|
# Rigify style
|
|
("upper_arm_fk.L", "upper_arm_fk.R"),
|
|
("forearm_fk.L", "forearm_fk.R"),
|
|
("hand_fk.L", "hand_fk.R"),
|
|
# Common alternatives
|
|
("upper_arm.L", "upper_arm.R"),
|
|
("forearm.L", "forearm.R"),
|
|
("hand.L", "hand.R"),
|
|
("arm_fk.L", "arm_fk.R"),
|
|
("lower_arm_fk.L", "lower_arm_fk.R"),
|
|
# Short forms
|
|
("arm.L", "arm.R"),
|
|
("elbow.L", "elbow.R"),
|
|
)
|
|
|
|
# Finger bone name patterns (will match with .01, .02, .03, etc.)
|
|
FINGER_PREFIXES = (
|
|
"thumb", "f_index", "f_middle", "f_ring", "f_pinky",
|
|
"finger1", "finger2", "finger3", "finger4", "finger5",
|
|
)
|
|
|
|
|
|
def _get_matching_arm_fk_bones(armature):
|
|
"""Return list of arm FK bone names that exist on armature."""
|
|
if not armature or armature.type != "ARMATURE" or not armature.pose:
|
|
return []
|
|
bones = armature.pose.bones
|
|
found = []
|
|
for pattern in ARM_FK_PATTERNS:
|
|
for name in pattern:
|
|
if name in bones:
|
|
found.append(name)
|
|
return found
|
|
|
|
|
|
def _get_finger_fk_bones(armature):
|
|
"""Return list of FK finger bone names that exist on armature. Only control bones (no ORG-/DEF-/MCH- prefix)."""
|
|
if not armature or armature.type != "ARMATURE" or not armature.pose:
|
|
return []
|
|
bones = armature.pose.bones
|
|
finger_bones = []
|
|
for bone_name in bones.keys():
|
|
if bone_name.startswith("ORG-") or bone_name.startswith("DEF-") or bone_name.startswith("MCH-"):
|
|
continue
|
|
lower_name = bone_name.lower()
|
|
for prefix in FINGER_PREFIXES:
|
|
if prefix in lower_name and ("_fk." in bone_name or bone_name.endswith(".L") or bone_name.endswith(".R")):
|
|
if "." in bone_name and any(d in bone_name for d in "0123456789"):
|
|
finger_bones.append(bone_name)
|
|
break
|
|
return finger_bones
|
|
|
|
|
|
def _get_fk_bones(armature):
|
|
"""Return list of all FK arm and finger bone names that exist on armature."""
|
|
arm_bones = _get_matching_arm_fk_bones(armature)
|
|
finger_bones = _get_finger_fk_bones(armature)
|
|
return list(dict.fromkeys(arm_bones + finger_bones))
|
|
|
|
|
|
def copy_fk_rotations(context, orig, rep):
|
|
"""
|
|
Copy visual rotations from orig to rep using temporary COPY_TRANSFORMS constraints.
|
|
This properly handles all coordinate space conversions.
|
|
Returns (True, message) or (False, error_message).
|
|
"""
|
|
fk_names = _get_fk_bones(rep)
|
|
|
|
print(f"[DLM MigFKRot] Found {len(fk_names)} FK bones on {rep.name}")
|
|
|
|
if not fk_names:
|
|
return False, "No FK arm or finger bones found on replacement armature"
|
|
|
|
# Filter to bones that exist on both
|
|
common_bones = [n for n in fk_names if n in orig.pose.bones and n in rep.pose.bones]
|
|
if not common_bones:
|
|
return False, "No matching FK bones found on both armatures"
|
|
|
|
print(f"[DLM MigFKRot] Will copy {len(common_bones)} bones using constraints")
|
|
|
|
original_active = context.view_layer.objects.active
|
|
constraints_added = []
|
|
|
|
try:
|
|
# Ensure rep is active and in pose mode
|
|
bpy.context.view_layer.objects.active = rep
|
|
if rep.mode != 'POSE':
|
|
bpy.ops.object.mode_set(mode='POSE')
|
|
|
|
# Step 1: Add COPY_TRANSFORMS constraints to each rep bone
|
|
for bone_name in common_bones:
|
|
try:
|
|
rep_bone = rep.pose.bones[bone_name]
|
|
|
|
# Check if bone already has this constraint
|
|
existing = [c for c in rep_bone.constraints if c.type == 'COPY_TRANSFORMS' and getattr(c, 'target', None) == orig]
|
|
if existing:
|
|
continue
|
|
|
|
# Add constraint
|
|
c = rep_bone.constraints.new(type='COPY_TRANSFORMS')
|
|
c.name = "MigFKRot_Temp"
|
|
c.target = orig
|
|
c.subtarget = bone_name
|
|
c.target_space = 'POSE'
|
|
c.owner_space = 'POSE'
|
|
|
|
constraints_added.append((rep_bone, c))
|
|
except Exception as e:
|
|
print(f"[DLM MigFKRot] Failed to add constraint for {bone_name}: {e}")
|
|
|
|
# Step 2: Update scene to evaluate constraints
|
|
context.view_layer.update()
|
|
|
|
# Step 3: Apply visual transform (bake constraint result into pose)
|
|
bpy.ops.pose.select_all(action='DESELECT')
|
|
for rep_bone, _ in constraints_added:
|
|
rep_bone.bone.select = True
|
|
|
|
# Apply visual transform - this bakes the constraint result
|
|
bpy.ops.pose.visual_transform_apply()
|
|
|
|
# Step 4: Remove constraints
|
|
for rep_bone, c in constraints_added:
|
|
try:
|
|
rep_bone.constraints.remove(c)
|
|
except:
|
|
pass
|
|
|
|
print(f"[DLM MigFKRot] Copied {len(constraints_added)} bones")
|
|
return True, f"Copied FK rotations for {len(constraints_added)} bones"
|
|
|
|
except Exception as e:
|
|
print(f"[DLM MigFKRot] Error: {e}")
|
|
return False, str(e)
|
|
|
|
finally:
|
|
# Cleanup any remaining constraints
|
|
for rep_bone, c in constraints_added:
|
|
try:
|
|
if c in rep_bone.constraints:
|
|
rep_bone.constraints.remove(c)
|
|
except:
|
|
pass
|
|
|
|
if original_active:
|
|
context.view_layer.objects.active = original_active
|
|
|
|
|
|
def bake_fk_rotations(context, rep, track_name=None, post_clean=False):
|
|
"""
|
|
Bake FK arm/finger rotations to keyframes.
|
|
Similar to tweak_tools.bake_tweak_constraints but for FK bones.
|
|
Returns (True, message) or (False, error_message).
|
|
"""
|
|
fk_names = _get_fk_bones(rep)
|
|
if not fk_names:
|
|
return False, f"No FK bones found on {rep.name}"
|
|
|
|
scene = context.scene
|
|
|
|
# Get frame range from track or scene
|
|
frame_range = None
|
|
if track_name and rep.animation_data and rep.animation_data.nla_tracks:
|
|
track = rep.animation_data.nla_tracks.get(track_name)
|
|
if track and track.strips:
|
|
start = min(s.frame_start for s in track.strips)
|
|
end = max(s.frame_end for s in track.strips)
|
|
frame_range = (int(start), int(end))
|
|
|
|
if not frame_range:
|
|
frame_range = (scene.frame_start, scene.frame_end)
|
|
|
|
frame_start, frame_end = frame_range
|
|
|
|
# Ensure rep is active and in pose mode
|
|
if context.view_layer.objects.active != rep:
|
|
context.view_layer.objects.active = rep
|
|
if rep.mode != "POSE":
|
|
bpy.ops.object.mode_set(mode="POSE")
|
|
|
|
# Select only FK bones
|
|
bpy.ops.pose.select_all(action="DESELECT")
|
|
for name in fk_names:
|
|
if name in rep.pose.bones:
|
|
rep.pose.bones[name].bone.select = True
|
|
|
|
# Bake
|
|
try:
|
|
bpy.ops.nla.bake(
|
|
frame_start=frame_start,
|
|
frame_end=frame_end,
|
|
step=1,
|
|
only_selected=True,
|
|
visual_keying=True,
|
|
clear_constraints=False,
|
|
clear_parents=False,
|
|
use_current_action=False, # Create new action
|
|
clean_curves=False,
|
|
bake_types={"POSE"},
|
|
channel_types={"ROTATION"},
|
|
)
|
|
except Exception as e:
|
|
return False, str(e)
|
|
|
|
if not post_clean:
|
|
return True, f"Baked {len(fk_names)} FK bones ({frame_start}-{frame_end})."
|
|
|
|
# Post-clean
|
|
win = context.window
|
|
for area in win.screen.areas:
|
|
if area.type == "DOPESHEET_EDITOR":
|
|
with context.temp_override(window=win, area=area):
|
|
try:
|
|
bpy.ops.action.clean_keyframes()
|
|
except Exception:
|
|
pass
|
|
break
|
|
for area in win.screen.areas:
|
|
if area.type == "GRAPH_EDITOR":
|
|
with context.temp_override(window=win, area=area):
|
|
try:
|
|
bpy.ops.graph.decimate(mode="ERROR", error=0.001)
|
|
except Exception:
|
|
pass
|
|
break
|
|
|
|
return True, f"Baked and cleaned {len(fk_names)} FK bones ({frame_start}-{frame_end})."
|