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 location(context, src, **kargs):
"""
kargs:
frame=None, group=None, action=None, insert_key=None,
unlock=False, # keyframe locked channels
connected=False, # ignore whether or not a bone is connected
"""
insert_key = kargs.get('insert_key')
unlock = kargs.get('unlock', False)
kargs['results'] = kargs.get('results', list())
if not keyframe.poll_insert(context, insert_key, src=src):
return
if kargs.get('connected') and Is.connected(src):
return
args = (context, src, 'location')
if unlock or (True not in src.lock_location):
keyframe.manual(*args, index=-1, **kargs)
else:
for i in range(3):
if (not src.lock_location[i]):
keyframe.manual(*args, index=i, **kargs)
return kargs['results']
def pose_start(pbone):
pose(pbone)
pbone.lock_scale = (True, True, True)
if not pbone.custom_shape:
self.bone_widgets['start'].append(pbone)
if not Is.connected(bone):
con = bone.constraints.new('COPY_LOCATION')
con.target = rig
con.subtarget = pbone.name
def get_disconnected_parent(bone, first_loop=True):
if ((bone is None) or (not bone.parent)):
if first_loop:
return
else:
return bone
elif Is.connected(bone):
# Keep going up the chain until it finds a disconnected bone
return get_disconnected_parent(bone.parent, False)
else:
return bone.parent
def execute(self, context):
poll_any = False
for bone in context.selected_pose_bones:
poll_loc = (keyframe.poll_unlock(bone, 'location')
and not Is.connected(bone))
poll_rot = keyframe.poll_unlock(bone, 'rotation')
poll_scale = keyframe.poll_unlock(bone, 'scale')
polls = {
'location': poll_loc,
'rotation': poll_rot,
'scale': poll_scale
}
if not poll_any and not polls.pop(self.mode):
for poll in polls:
if polls[poll]:
self.mode = poll
break
else:
continue
polls = {
'location': poll_loc,
'rotation': poll_rot,
'scale': poll_scale
}
if polls[self.mode]:
self.bones.append(bone)
poll_any = True
if not poll_any:
self.report({'INFO'}, "All transforms locked on selected bones")
return {'CANCELLED'}
if (self.mode == 'location'):
bpy.ops.transform.translate('INVOKE_DEFAULT', True)
elif (self.mode == 'rotation'):
bpy.ops.transform.rotate('INVOKE_DEFAULT', True)
elif (self.mode == 'scale'):
bpy.ops.transform.resize('INVOKE_DEFAULT', True)
else:
"""can't use the "all" value"""
return {'CANCELLED'}
context.window_manager.modal_handler_add(self)
return {'RUNNING_MODAL'}
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 execute(self, context):
current_frame = context.scene.frame_current
poll_any = False
for bone in context.selected_pose_bones:
poll_loc = (keyframe.poll_unlock(bone, 'location')
and not Is.connected(bone))
poll_rot = keyframe.poll_unlock(bone, 'rotation')
poll_scale = keyframe.poll_unlock(bone, 'scale')
polls = {
'location': poll_loc,
'rotation': poll_rot,
'scale': poll_scale
}
if not poll_any and not polls.pop(self.mode):
for poll in polls:
if polls[poll]:
self.mode = poll
break
else:
continue
polls = {
'location': poll_loc,
'rotation': poll_rot,
'scale': poll_scale
}
if polls[self.mode]:
self.bones[bone] = type('', (), {})
poll_any = True
if not poll_any:
self.report({'INFO'}, "All transforms locked on selected bones")
return {'CANCELLED'}
for bone in self.bones:
self.bones[bone].curves = get_bone_curve(bone, self.mode)
if (self.mode == 'location'):
self.bones[
bone].current_values = bone.matrix_basis.to_translation()
elif (self.mode == 'rotation'):
self.bones[bone].current_values = get_bone_rotation(bone)
if self.bones[bone].current_values is None:
del self.bones[bone]
elif (self.mode == 'scale'):
self.bones[bone].current_values = bone.matrix_basis.to_scale()
if (self.mode == 'location'):
bpy.ops.transform.translate('INVOKE_DEFAULT')
elif (self.mode == 'rotation'):
if not self.bones:
self.report({'INFO'},
"Cancelled Rotation (can't use Axis Angle)")
return {'CANCELLED'}
bpy.ops.transform.rotate('INVOKE_DEFAULT')
elif (self.mode == 'scale'):
bpy.ops.transform.resize('INVOKE_DEFAULT')
else:
"""can't use the "all" value"""
return {'CANCELLED'}
context.window_manager.modal_handler_add(self)
return {'RUNNING_MODAL'}
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)
def execute(self, context):
# active = Get.active(context)
for rig in context.selected_editable_objects:
if not Is.armature(rig):
continue
mode = rig.mode
if not Set.mode(context, 'EDIT', rig):
Set.mode(context, mode, rig)
continue
mirror = rig.data.use_mirror_x
rig.data.use_mirror_x = False
# Set.active(context, rig)
bones = Get.selected_edit_bones(context, rig)
links = [] # empty list
for bone in bones:
if bone.parent and not Is.connected(
bone): # prevent root-error
link = rig.data.edit_bones.new(
'COR-%s<>%s' % (bone.parent.name, bone.name))
link.tail = bone.head
link.head = bone.parent.tail
link.layers = bone.layers
# link.layers = utils.layer(30)
# # layer 28 = IK
# # Layer 32 = Gap<>fillers
# if (rig.data.rigify_layers):
# link.layers = [True if index in (31,) else False for index, layer in enumerate(range(32))]
link.use_deform = False
link.parent = bone.parent
bone.parent = link
connect(link)
connect(bone)
link.use_connect = True
bone.use_connect = True
# bpy.ops.object.mode_set(mode='POSE');bpy.ops.object.mode_set(mode='EDIT');
links.append(link.name)
# bone = rig.pose.bones[link.name]
# bone.lock_ik_x = True
# bone.lock_ik_y = True
# bone.lock_ik_z = True
'''def gap(bone):
#bpy.ops.object.mode_set(mode='POSE');
bone = C.active_object.pose.bones[bone]
bone.lock_ik_x=True; bone.lock_ik_y=True; bone.lock_ik_z=True;
#bpy.ops.object.mode_set(mode='EDIT');
try:
bone.lock_ik_x=True; bone.lock_ik_y=True; bone.lock_ik_z=True;
link = link.name
except: continue
'''
elif Is.connected(bone):
bone.use_connect = True
else: # root-ctrl-bone
continue
"or this will create a parent for a 'root' bone"
link = rig.data.edit_bones.new('COR-%s<>%s' %
(bone.name, bone.name))
link.tail = bone.tail
link.head = bone.head
link.layers = utils.layer(30)
# link.layers = bone.layers
link.use_deform = False
link.show_wire = True
bone.parent = link
links.append(link.name)
rig.data.use_mirror_x = mirror
Set.mode(context, 'POSE', rig)
for link in links:
link = rig.pose.bones.get(link, None)
if link is None:
# if bone's head+tail are the same, it'll cancel itself out
continue
links = link.name.replace('COR-', '', 1).split('<>')
# linked = rig.pose.bones.get(links[1], None)
if self.lock_ik:
link.ik_stiffness_x = 1
link.ik_stiffness_y = 1
link.ik_stiffness_z = 1
if (links[0] != links[1]): # Parent <x> Child
link.lock_ik_x = True
link.lock_ik_y = True
link.lock_ik_z = True
link.lock_location = [True, True, True]
link.lock_rotation_w = True
link.lock_rotation = [True, True, True]
link.lock_scale = [True, True, True]
else: # Original bone was copied for a control bone
print("Original bone was copied for a control bone")
# try:
# linked.lock_ik_x=True; linked.lock_ik_y=True; linked.lock_ik_z=True;
# linked.ik_stiffness_x=1; linked.ik_stiffness_y=1; linked.ik_stiffness_z=1;
# if not 'WGT-hips' in bpy.data.objects:
# bpy.context.scene.quickrig.create_wgt = 'hips'
# bpy.ops.quickrig.create_widgets()
# widget = bpy.data.objects['WGT-hips']
# link.custom_shape = widget
# #have the bone follow the original #link.custom_shape_transform = rig.pose.bones[links[1]]
# link.use_custom_shape_bone_size = False
# con = widget.constraints.new('COPY_TRANSFORMS')
# con.target = rig; con.subtarget = link.name;
# widget.layers[9] = True; layers = 0
# for layer in widget.layers:
# if layers != 9: layer = False
# except: pass
...
def bgroup(name):
bgroups = rig.pose.bone_groups
if name in bgroups:
group = bgroups[name]
else:
group = bgroups.new(name=name)
group.color_set = 'CUSTOM'
black = ((0.0, 0.0, 0.0))
select = ((0.1, 0.7, 0.9))
c = group.colors
c.active, c.normal, c.select = black, black, select
return group
link.bone_group = bgroup('<>')
Set.mode(context, mode, rig)
# if active:
# Set.active(context, active)
return {'FINISHED'}
