def symmetrize_armature(obj=None, cutoff=.001, scale=.5):
ac = set_ac(obj)
mode = set_mode("EDIT")
ebones = obj.data.edit_bones
bones = obj
xcos = tuple(b.head[0] for b in ebones)
l = tuple(ebones[i] for i in get_side(coords=xcos))
r = tuple(ebones[i]
for i in get_side(coords=xcos, cmp_func=lambda x, y: x < y))
n_r = mirror_arm_side(bones=l, side_tag="_R", scale=scale)
n_l = mirror_arm_side(bones=r, side_tag="_L", scale=scale)
for b in r:
b.name += "_R"
for b in l:
b.name += "_L"
res_r = (tuple(b.name for b in r), tuple(b.name for b in n_r))
res_l = (tuple(b.name for b in l), tuple(b.name for b in n_l))
set_mode(mode)
set_ac(ac)
return res_r, res_l
def set_minimum_envelopes(obj = None):
ac = set_ac(obj)
mode = set_mode("EDIT")
for b in obj.data.edit_bones:
b.envelope_distance = 0
b.head_radius = .0001
b.tail_radius = .0001
set_mode(mode)
set_ac(ac)
def ordered_bone_parent(bone_names,obj = None):
ac = set_ac(obj)
mode = set_mode("EDIT")
ebones = obj.data.edit_bones
if bone_names[0] != None:
ebones[bone_names[1]].parent = ebones[bone_names[0]]
if len(bone_names) > 2:
for b in range(2,len(bone_names)):
bname,parent_name = (bone_names[b],bone_names[b-1])
ebones[bname].parent = ebones[parent_name]
set_mode(mode)
set_ac(ac)
def mirror_selector(mirror_verts, mirror_dict, obj=None):
mode = set_mode('OBJECT')
mesh = obj.data
verts = mesh.vertices
errs = []
for v in mirror_verts:
vco, vindex = v
try:
for vert in mirror_dict[vco]:
verts[vert].select = True
except Exception as e:
errs.append((e, vindex))
set_mode(mode)
return errs
def envelope_armature_settings(envelope_distance=.25,
envelope_weight=1.0,
head_radius=0,
tail_radius=0,
obj=None):
prop_dict = kwargize(head_radius=head_radius,
tail_radius=tail_radius,
envelope_distance=envelope_distance,
envelope_weight=envelope_weight)
ac = set_ac(obj)
mode = set_mode("EDIT")
ebones = obj.data.edit_bones
tmap(lambda b: prop_copy(b, prop_dict), ebones)
set_mode(mode)
set_ac(ac)
def bone_trans(matrix,obj = None,bone_names = None,scale = .5):
ac = set_ac(obj)
mode = set_mode("EDIT")
ebones = obj.data.edit_bones
if bone_names:
target_bones = tuple(ebones[bn] for bn in bone_names)
else:
target_bones = tuple(ebones)
m3 = matrix.to_3x3()
mt = matrix.to_translation()
anymap(lambda b: b.head.rotate(matrix),target_bones)
anymap(lambda b: b.tail.rotate(matrix),target_bones)
anymap(lambda b: setattr(b,"head",mt+b.head),target_bones)
anymap(lambda b: setattr(b,"tail",Vector((0,1,0))*scale+b.head),target_bones)
set_mode(mode)
set_ac(ac)
def send_mirror_weights_exec(vdata=None,
cutoff=.001,
type="both",
scale=1,
target_shape_key_index=0,
use_active_shape_key=False,
precision=4,
obj=None,
selected_only=True):
mode = set_mode('OBJECT')
if vdata == None:
vdata = find_mirror(target_shape_key_index=target_shape_key_index,
use_active_shape_key=use_active_shape_key,
obj=obj,
precision=precision,
scale=scale)
selvertsL, vcodictL, selvertsR, vcodictR = vdata
vgroups = obj.vertex_groups
tdict = {
"l>r": ((selvertsL, vcodictR), ),
"l<r": ((selvertsR, vcodictL), ),
"both": (
(selvertsL, vcodictR),
(selvertsR, vcodictL),
)
}
for vs, vdict in tdict[type]:
mirror_weights(vs,
vdict,
obj=obj,
vgroups=vgroups,
selected_only=selected_only)
set_mode(mode)
return vdata
def mirror_weights_exec(vdata=None,
precision=4,
scale=1,
target_shape_key_index=0,
use_active_shape_key=False,
obj=None,
do_clear=True,
oper=None):
locs = dict(locals())
locs.pop("vdata")
locs.pop("do_clear")
mode = set_mode('OBJECT')
if vdata == None:
match_data, selverts = find_mirror_selected(
target_shape_key_index=target_shape_key_index,
use_active_shape_key=use_active_shape_key,
obj=obj,
precision=precision,
scale=scale)
vgroups = obj.vertex_groups
no_matches = []
for vmatches, vidx in zip(match_data, selverts):
if len(vmatches) == 0:
no_matches.append(vidx)
continue
match_weight_data = vmatches[0]
weight_replace(match_weight_data, vidx, obj, do_clear)
rep_msg = "Found no match for " + str(len(no_matches)) + " verts"
oper.report({"INFO"}, rep_msg)
set_mode(mode)
return match_data, selverts, no_matches
def mirror_sel(vdata=None,
cutoff=.001,
type="both",
extend=True,
precision=4,
scale=1,
target_shape_key_index=0,
use_active_shape_key=False,
obj=None):
mode = set_mode('OBJECT')
if vdata == None:
vdata = find_mirror(cutoff=cutoff,
precision=precision,
scale=scale,
target_shape_key_index=target_shape_key_index,
use_active_shape_key=use_active_shape_key,
obj=obj)
selvertsL, vcodictL, selvertsR, vcodictR, mid = vdata
tdict = {
"l>r": ((selvertsL, vcodictR), ),
"l<r": ((selvertsR, vcodictL), ),
"both": (
(selvertsL, vcodictR),
(selvertsR, vcodictL),
)
}
if extend == False:
deselect_mesh_parts(obj=obj)
for vs, vdict in tdict[type]:
mirror_selector(vs, vdict, obj=obj)
set_mode(mode)
return vdata
def make_bone(name = "Bone",obj = None,autoswitch = True,loc = None,dir = None,scale = .05,parent = None,props = {}):
if loc == None:
loc = (0,0,0)
if dir == None:
dir = (0,1,0)
if autoswitch:
ac = set_ac(obj)
mode = set_mode("EDIT")
ebones = obj.data.edit_bones
newbone = init_new_bone(ebones)
newbone.name = name
newbone.head = loc
newbone.tail = Vector(loc) + Vector(dir)*scale
if parent != None:
newbone.parent = parent
prop_copy(newbone,props)
if autoswitch:
set_mode(mode)
set_ac(ac)
return newbone
def curve_to_armature(obj=None,
base_name="Bone",
make_new_arm=True,
arm=None,
do_armature=True,
scale=.5,
do_symmetrize=False,
obj_trans_copy=True,
bone_props=None,
root_bone=None,
use_apply_on_spline=False,
align_bones=False,
do_bone_parent=True):
if bone_props == None:
bone_props = {}
if make_new_arm:
arm = gtls.make_arm(name="arm_to_curve_" + obj.name)
else:
if arm == None:
arm = get_sel_obj()
for i in rlen(arm.layers):
arm.layers[i] = True
arm.data.draw_type = "STICK"
mods = obj.modifiers
splines = tuple(s.bezier_points if s.type == "BEZIER" else s.points
for s in obj.data.splines)
ac = set_ac(arm)
res = tuple(
map(
lambda verts: tuple(
map(
lambda v: bone_fs.make_bone(name=base_name + str(verts[0]),
scale=scale,
obj=arm,
loc=v.co[0:3],
props=bone_props), verts[1])),
enumerate(splines)))
res = unpack(res)
res = list(b.name for b in res)
res.sort()
#rootボーンが指定された場合、チュープルの前に置いとく
if root_bone == None:
bone_names = res
else:
bone_names = (root_bone, *res)
if do_armature:
mod = mods.new(name="Curve_to_Armature", type="ARMATURE")
props = {
"use_vertex_groups": not use_apply_on_spline,
"use_bone_envelopes": use_apply_on_spline,
"object": arm,
"show_in_editmode": True,
"use_apply_on_spline": use_apply_on_spline,
}
prop_copy(mod, props)
if do_symmetrize:
armature_fs.symmetrize_armature(obj=arm)
curve_fs.symmetrize_spline(obj=obj)
if obj_trans_copy:
bone_fs.bone_trans(obj.matrix_world,
bone_names=bone_names,
obj=arm,
scale=scale)
mode = set_mode("EDIT")
ebones = arm.data.edit_bones
c = 0
for s in rlen(splines):
c += 0
ls = len(splines[s])
if do_bone_parent:
bone_fs.ordered_bone_parent(bone_names[c:(c + ls)], obj=arm)
if align_bones:
for b in range(ls - 1):
b1 = ebones[bone_names[c]]
b2 = ebones[bone_names[c + 1]]
b1.tail = b2.head
c += 1
c += 1
set_mode(mode)
set_ac(ac)
return arm
