def edit_in(ebone):
edit(ebone, 2.0)
if do_start_end:
ebone.parent = bone_start
else:
ebone.parent = ebones.get(get_name(bone, 'bbone_start'), bone)
(head, tail) = (ebone.head.copy(), ebone.tail.copy())
ebone.head = utils.lerp(head, tail, 0.1)
ebone.tail = utils.lerp(head, tail, 0.2)
def edit_out(ebone):
edit(ebone, 2.0)
if do_start_end:
ebone.parent = bone_end
else:
ebone.parent = ebones.get(get_name(bone, 'bbone_end'), bone)
(head, tail) = (ebone.head.copy(), ebone.tail.copy())
ebone.tail = utils.lerp(head, tail, 0.8)
ebone.head = utils.lerp(head, tail, 0.9)
ebone.align_roll(-bone.z_axis)
def edit_head(ebone):
edit(ebone, 0.5)
ebone.parent = bone_start
ebone.tail = utils.lerp(ebone.head, ebone.tail, 0.1)
ebone.translate(ebone.head - ebone.tail)
bone.bbone_custom_handle_start = ebone
self.hide_bones[rig].append(ebone.name)
def edit_start(ebone):
edit(ebone, 2.5)
if do_mch:
ebone.parent = bone_mch
else:
if Is.connected(bone):
ebone.parent = ebones.get(
get_name(bone.parent, 'bbone_end'))
if ebone.parent:
self.hide_bones[rig].append(ebone.name)
ebone.hide = True
else:
ebone.parent = bone.parent
if not do_in_out:
cbone = ebones.get(get_name(bone, 'bbone_in'))
if cbone:
cbone.parent = ebone
for cbone in bone.children_recursive:
if (bone.head != cbone.tail):
continue
cbone_end = ebones.get(get_name(cbone, 'bbone_end'))
if cbone_end:
cbone_end.parent = ebone
self.hide_bones[rig].append(cbone_end.name)
cbone_end.hide = True
ebone.tail = utils.lerp(ebone.head, ebone.tail, 0.1)
def execute(self, context):
if (self.last_iter != self.iterations) or (self.last_sample !=
self.samples):
for fc in context.editable_fcurves:
fcu = self.fcurves.get(
(fc.id_data.name, fc.data_path, fc.array_index))
if not fcu:
continue
for (index, key) in enumerate(fc.keyframe_points):
base = fcu.get(index)
if base and key.select_control_point:
key.co.y = base['base'][0]
key.handle_left.y = base['base'][1]
key.handle_right.y = base['base'][2]
self.smooth(context)
self.last_iter = self.iterations
self.last_sample = self.samples
for fc in context.editable_fcurves:
fcu = self.fcurves.get(
(fc.id_data.name, fc.data_path, fc.array_index))
if not fcu:
continue
for (index, key) in enumerate(fc.keyframe_points):
if fcu.get(index) and key.select_control_point:
base = fcu[index]['base']
smooth = fcu[index]['smooth']
key.co.y = utils.lerp(base[0],
smooth[0],
factor=self.factor / 100)
key.handle_left.y = utils.lerp(base[1],
smooth[1],
factor=self.factor / 100)
key.handle_right.y = utils.lerp(base[2],
smooth[2],
factor=self.factor / 100)
fc.update()
return {'FINISHED'}
def execute(self, context):
fac = (self.factor / 100)
selected = Get.selected(context, mirror=True)
for src in selected:
base = pose.base[repr(src)]
reset = pose.reset[repr(src)]
if src.rotation_mode in ('QUATERNION', 'AXIS_ANGLE'):
euler = 'XYZ'
else:
euler = src.rotation_mode
if Is.matrix(reset):
matrix = utils.lerp(base, reset, fac)
matrix = utils.matrix_to_transforms(matrix, euler=euler)
else:
location = base.to_translation()
rotation_quaternion = base.to_quaternion()
axis = base.to_quaternion().to_axis_angle()
rotation_axis_angle = (*axis[0], axis[1])
rotation_euler = base.to_euler(euler)
scale = base.to_scale()
matrix = type(
'matrix and transforms', (),
dict(
location=utils.lerp(location, reset.location, fac),
rotation_quaternion=utils.lerp(
rotation_quaternion, reset.rotation_quaternion,
fac),
rotation_axis_angle=utils.lerp(
rotation_axis_angle, reset.rotation_axis_angle,
fac),
rotation_euler=utils.lerp(rotation_euler,
reset.rotation_euler, fac),
scale=utils.lerp(scale, reset.scale, fac),
))
if 'loc' in self.mode:
src.location = matrix.location
if 'rot' in self.mode:
src.rotation_quaternion = matrix.rotation_quaternion
src.rotation_axis_angle = matrix.rotation_axis_angle
src.rotation_euler = matrix.rotation_euler
if 'scale' in self.mode:
src.scale = matrix.scale
keyframe.keyingset(context, selected=selected)
return {'FINISHED'}
def edit_end(ebone):
edit(ebone, 2.5)
if do_mch:
ebone.parent = bone_mch
else:
for tbone in bone.parent_recursive:
if (tbone.head != bone.tail):
continue
tobone_name = get_name(tbone, 'bbone_start')
tobone = ebones.get(tobone_name)
if tobone or ((tbone, rig) in self.selected):
self.hide_bones[rig].append(ebone.name)
ebone.hide = True
if tobone:
ebone.parent = tobone
else:
self.delayed_parenting.append(
ebones, ebone.name, tobone_name)
else:
ebone.parent = tbone
break
else:
ebone.parent = get_disconnected_parent(bone)
if not do_in_out:
cbone = ebones.get(get_name(bone, 'bbone_out'))
if cbone:
cbone.parent = ebone
for cbone in bone.children:
if Is.connected(cbone):
cbone_start = ebones.get(get_name(cbone, 'bbone_start'))
if cbone_start:
cbone_start.parent = ebone
self.hide_bones[rig].append(cbone_start.name)
cbone_start.hide = True
ebone.head = utils.lerp(ebone.head, ebone.tail, 0.9)
ebone.translate(ebone.tail - ebone.head)
bone.bbone_custom_handle_end = ebone
def edit_mirror_center(self, context):
def get_bones(rig, bbone):
ebones = rig.data.edit_bones
ebone = ebones.get(get_name(bone, bbone))
mebone = Get.mirror_bone(ebone)
return (ebone, mebone)
found = []
for (bone, rig) in self.selected:
if not (rig.pose.use_mirror_x or rig.data.use_mirror_x):
continue
mbone = Get.mirror_bone(bone)
if mbone in found:
continue
else:
found.append(bone)
(ebone, mebone) = get_bones(rig, 'bbone_start')
if not (ebone and mebone):
continue
if (ebone.parent == mebone.parent):
# Connect heads
if Is.connected(bone):
# The parent will already handle the symmetry
continue
parent = ebone.parent
else:
(ebone, mebone) = get_bones(rig, 'bbone_end')
if not (ebone and mebone):
continue
# Find a mutual parent between the two bones
parent = [
*(x for x in ebone.parent_recursive
if x in mebone.parent_recursive), None
][0]
distance = abs(sum(ebone.head) - sum(mebone.head)) / 2
margin = utils.lerp(bone.bone.length, mbone.bone.length,
0.5) / bone.bone.bbone_segments
if distance >= margin:
# Bones too far apart
continue
(prefix, replace, suffix,
number) = utils.flip_name(bone.name, only_split=True)
center_name = prefix + suffix + number
center = New.bone(context, rig, name=center_name, overwrite=True)
attributes = [
'head',
'head_radius',
'tail',
'tail_radius',
'roll',
'matrix',
'layers',
'bbone_x',
'bbone_z',
]
for atr in attributes:
if hasattr(center, atr):
setattr(
center, atr,
utils.lerp(getattr(ebone, atr), getattr(mebone, atr),
0.5))
center.use_deform = False
center.inherit_scale = 'NONE'
center.parent = parent
center.hide = True
ebone.parent = mebone.parent = center
self.hide_bones[rig].extend((ebone.name, mebone.name))
self.center_bones[rig].append(center.name)