def generateShape(self, *args):
sel = pm.ls(sl=1)
if len(sel) != 4:
pm.mel.warning(
'Must select: Neutral, TargetA, TargetB, TargetC meshes')
return
meshN = sel[0]
meshA = sel[1]
meshB = sel[2]
meshC = sel[3]
# Create new mesh
new = pm.duplicate(meshN, n='Corrective')[0]
# Per vertex, translate in world space: C-(A+B)
for vtx in new.vtx:
vert = vtx.split('.')[1]
n_pos = pmd.Point(pm.xform(vtx, query=True, ws=True, t=True))
a_pos = pmd.Point(
pm.xform(meshA + '.' + vert, query=True, ws=True, t=True))
b_pos = pmd.Point(
pm.xform(meshB + '.' + vert, query=True, ws=True, t=True))
c_pos = pmd.Point(
pm.xform(meshC + '.' + vert, query=True, ws=True, t=True))
aVec = a_pos - n_pos
bVec = b_pos - n_pos
cVec = c_pos - n_pos
delta = cVec - (aVec + bVec)
pm.move(vtx, delta, r=1)
def replaceController2Cube():
for origin in pm.ls(sl=1, v=1, ni=1):
origin_shape = origin.getShape(type="nurbsCurve")
if not origin_shape:
pm.warning(u"找不到曲线 %s" % origin)
pm.headsUpMessage(u"找不到曲线 %s" % origin)
continue
jnt_list = []
for constraint in set(origin.listConnections(type="constraint")):
if constraint.type() in [
"aimConstraint", "tangentConstraint", "normalConstraint"
]:
continue
for jnt in constraint.listConnections(type='joint'):
if jnt not in jnt_list:
jnt_list.append(jnt)
if not jnt_list:
pm.warning(u"找不到骨骼 %s" % origin)
pm.headsUpMessage(u"找不到骨骼 %s" % origin)
continue
start_jnt = jnt_list[0]
child_list = pm.ls(start_jnt, dag=1, type="joint")
if len(child_list) >= 2:
# NOTE 获取层级之下的骨骼（0是自己）
end_jnt = child_list[1]
start_pt = dt.Point(*pm.xform(start_jnt, q=1, ws=1, t=1))
end_pt = dt.Point(*pm.xform(end_jnt, q=1, ws=1, t=1))
crv = generateCubeFromVector(start_pt, end_pt, origin)
shape = crv.getShape()
# NOTE 设置颜色
if origin_shape.overrideEnabled.get():
shape.overrideEnabled.set(1)
if origin_shape.overrideRGBColors.get():
color = origin_shape.overrideColorRGB.get()
shape.overrideColorRGB.set(color)
else:
color = origin_shape.overrideColor.get()
shape.overrideColor.set(color)
pm.parent(shape, origin, r=1, s=1)
pm.delete(crv)
name = origin_shape.name()
pm.delete(origin_shape)
shape.rename(name)
else:
# NOTE 说明层之下没有骨骼了
pm.warning(u"找不到下层级骨骼 %s" % origin)
pm.headsUpMessage(u"找不到下层级骨骼 %s" % origin)
def replaceController2Cube(distant=3):
for origin in pm.ls(sl=1,v=1,ni=1):
origin_shape = origin.getShape(type="nurbsCurve")
if not origin_shape:
pm.warning(u"找不到曲线 %s" % origin)
pm.headsUpMessage(u"找不到曲线 %s" % origin)
continue
jnt_list = []
for constraint in set(origin.listConnections(type="constraint")):
if constraint.type() in ["aimConstraint","tangentConstraint","normalConstraint"]:
continue
for jnt in constraint.listConnections(type='joint'):
if jnt not in jnt_list:
jnt_list.append(jnt)
try:
start_jnt = jnt_list[0]
start_pt = dt.Point(*pm.xform(start_jnt,q=1,ws=1,t=1))
origin_pt = dt.Point(*pm.xform(origin,q=1,ws=1,t=1))
if (start_pt - origin_pt).length() > 0.01:
raise RuntimeError()
child_list = pm.ls(start_jnt,dag=1,type="joint")
end_jnt = child_list[1]
end_pt = dt.Point(*pm.xform(end_jnt,q=1,ws=1,t=1))
crv = generateCubeFromVector(start_pt,end_pt,origin,distant=distant)
except:
start_pt = dt.Point(-distant,0,0)
end_pt = dt.Point(distant,0,0)
crv = generateCubeFromVector(start_pt,end_pt,distant=distant)
shape = crv.getShape()
# NOTE 设置颜色
if origin_shape.overrideEnabled.get():
shape.overrideEnabled.set(1)
if origin_shape.overrideRGBColors.get():
color = origin_shape.overrideColorRGB.get()
shape.overrideColorRGB.set(color)
else:
color = origin_shape.overrideColor.get()
shape.overrideColor.set(color)
pm.parent(shape,origin,r=1,s=1)
pm.delete(crv)
name = origin_shape.name()
pm.delete(origin_shape)
shape.rename(name)
def bdMirrorCtrlPymel():
selection = pm.ls(sl=True)
if selection:
try:
source, target = pm.ls(sl=True)
except:
pm.warning('Select source and target controller')
return
sourceShape = source.getShape()
if sourceShape.type() != 'nurbsCurve':
pm.error('Selected source is not nurbs curve')
return
targetCvsPos = [(dt.Point(-x.x, x.y, x.z))
for x in sourceShape.getCVs(space='world')]
targetShape = target.getShape()
if targetShape.type() != 'nurbsCurve':
pm.error('Selected target is not nurbs curve')
return
targetShape.setCVs(targetCvsPos, space='world')
targetShape.updateCurve()
else:
print 'Select source and target controller'
def connect_leg_2jnt_01(self):
"""Connector for leg 2jnt"""
# If the parent component hasn't been generated we skip the connection
if self.parent_comp is None:
return
pm.connectAttr(self.parent_comp.blend_att, self.blend_att)
pm.parent(self.root, self.parent_comp.ik_ctl)
pm.parent(self.parent_comp.ik_ref, self.bk_loc[-1])
pm.parentConstraint(self.parent_comp.tws2_rot, self.fk_ref, maintainOffset=True)
pm.parent(self.parent_comp.match_fk2, self.fk_ref)
heel_t = transform.getTranslation(self.heel_ctl)
ik_t = transform.getTranslation(self.parent_comp.ik_ctl)
offset_y = heel_t.y - ik_t.y
ik_shapes = self.parent_comp.ik_ctl.getShapes()
for shape in ik_shapes:
points = []
for cv in shape.getCVs():
x = cv[0] * 2.
y = cv[1] * 0.4 + offset_y
z = cv[2] * 3.
points.append(datatypes.Point((x, y, z)))
shape.setCVs(points)
shape.updateCurve()
def addObjects(self):
"""Add all the objects needed to create the component."""
t = self.guide.tra["root"]
if self.settings["mirrorBehaviour"] and self.negate:
scl = [1, 1, -1]
else:
scl = [1, 1, 1]
t = transform.setMatrixScale(t, scl)
# The border needs to fit the ctl range of motion
size = self.settings["ctlSize"]
minX = -1 if self.settings["tx_negative"] else 0
maxX = 1 if self.settings["tx_positive"] else 0
minY = -1 if self.settings["ty_negative"] else 0
maxY = 1 if self.settings["ty_positive"] else 0
margin = 0.1 * self.size
border_offset = dt.Point(minX + maxX, minY + maxY) * 0.5
self.border = self.addCtl(self.root,
"border",
t,
self.color_ik,
"square",
w=size + (maxX - minX) + margin,
d=size + (maxY - minY) + margin,
tp=self.parentCtlTag,
po=border_offset,
ro=dt.Vector(math.radians(90), 0, 0))
border_shape = self.border.getShape()
border_shape.overrideDisplayType.set(2) # Set display to reference
self.ctl = self.addCtl(self.border,
"ctl",
t,
self.color_ik,
self.settings["icon"],
d=size,
h=size,
w=size,
tp=self.parentCtlTag,
ro=dt.Vector(math.radians(90), 0, 0))
self.border.scale.set([self.size, self.size, self.size])
params = [
s for s in ["tx", "ty"]
if self.settings[s + "_negative"] or self.settings[s + "_positive"]
]
attribute.setKeyableAttributes(self.ctl, params)
attribute.setKeyableAttributes(self.border, [])
tx_limit = [minX, maxX]
ty_limit = [minY, maxY]
pm.transformLimits(self.ctl, tx=tx_limit, etx=[1, 1])
pm.transformLimits(self.ctl, ty=ty_limit, ety=[1, 1])
def geoGroupPivotZeroed(*args):
geoGrps = pm.ls('geo_group', r=True)
if geoGrps:
geoGrp = geoGrps[0]
else:
logger.debug('geo_group doesnt exist on this scene')
return True
rp = geoGrp.getRotatePivot()
sp = geoGrp.getScalePivot()
zeroPoint = dt.Point()
if rp != zeroPoint or sp != zeroPoint:
return True
def getPosTable(mesh, **kwargs):
'''
returns dictionary
{vertId : dt.Point(x,y,z)}
'''
vertCount = mc.polyEvaluate(mesh, v=True)
retDict = {}
for vertId in range(vertCount):
retDict[vertId] = dt.Point(
*mc.pointPosition('%s.vtx[%d]' % (mesh, vertId), **kwargs))
return retDict
def main(thersold = 0.01):
# NOTE 选择模型
pm.pickWalk(d="down")
for sel in pm.ls(sl=1,type="mesh"):
bbox = pm.exactWorldBoundingBox(sel)
x = (bbox[0] + bbox[3])/2
y = (bbox[1] + bbox[4])/2
z = (bbox[2] + bbox[5])/2
pt = OpenMaya.MPoint(x, y, z)
node = sel.node()
itr = OpenMaya.MItMeshVertex(node.__apimdagpath__())
l_dict = {}
c_dict = {}
r_dict = {}
while not itr.isDone():
pt_pos = itr.position(OpenMaya.MSpace.kWorld)
pt_idx = itr.index()
pt_x = pt_pos.x
if pt_x - x > 0 :
l_dict[pt_idx] = pt_pos
elif abs(pt_x - x) < thersold:
c_dict[pt_idx] = pt_pos
else:
r_dict[pt_idx] = pt_pos
itr.next()
match_dict = {}
for l_idx,l_pos in l_dict.items():
l_len = (pt - l_pos).length()
l_len_x = abs(l_pos.x - x)
for r_idx,r_pos in r_dict.items():
r_len = (pt - r_pos).length()
r_len_x = abs(r_pos.x - x)
if abs(l_len - r_len) < thersold and abs(l_len_x - r_len_x) < thersold :
match_dict[l_idx] = r_idx
break
for l,r in match_dict.items():
l_pos = sel.vtx[l].getPosition()
sel.vtx[r].setPosition(dt.Point(-l_pos.x , l_pos.y , l_pos.z))
class LocatorCurve(ControlCurve):
_shapeID = 'LocatorCurve'
_data = [{
'knots': [0.0, 1.0],
'cvs': [dt.Point([0.0, 0.0, -25.0]),
dt.Point([0.0, 0.0, 25.0])],
'degree': 1
}, {
'knots': [0.0, 1.0],
'cvs': [dt.Point([0.0, 25.0, 0.0]),
dt.Point([0.0, -25.0, 0.0])],
'degree': 1
}, {
'knots': [0.0, 1.0],
'cvs': [dt.Point([25.0, 0.0, 0.0]),
dt.Point([-25.0, 0.0, 0.0])],
'degree': 1
}]
def replaceController2Cube():
for origin in pm.ls(sl=1, v=1, ni=1):
origin_shape = origin.getShape(type="nurbsCurve")
if not origin_shape:
pm.warning(u"找不到曲线 %s" % origin)
pm.headsUpMessage(u"找不到曲线 %s" % origin)
continue
jnt_list = []
for constraint in set(origin.listConnections(type="constraint")):
if constraint.type() in [
"aimConstraint", "tangentConstraint", "normalConstraint"
]:
continue
for jnt in constraint.listConnections(type='joint'):
if jnt not in jnt_list:
jnt_list.append(jnt)
if not jnt_list:
pm.warning(u"找不到骨骼 %s" % origin)
pm.headsUpMessage(u"找不到骨骼 %s" % origin)
continue
start_jnt = jnt_list[0]
child_list = pm.ls(start_jnt, dag=1, type="joint")
if len(child_list) >= 2:
# NOTE 获取层级之下的骨骼（0是自己）
end_jnt = child_list[1]
start_pt = dt.Point(*pm.xform(start_jnt, q=1, ws=1, t=1))
end_pt = dt.Point(*pm.xform(end_jnt, q=1, ws=1, t=1))
crv = generateCubeFromVector(start_pt, end_pt)
origin.getParent().addChild(crv)
x, y, z = start_pt
# NOTE 移动轴心
pm.move(x, y, z, crv.scalePivot, crv.rotatePivot, r=1)
# NOTE 冻结变换
pm.makeIdentity(a=1, t=1, r=1, s=1, n=0, pn=1)
shape = crv.getShape()
# NOTE 设置颜色
if origin_shape.overrideEnabled.get():
shape.overrideEnabled.set(1)
if origin_shape.overrideRGBColors.get():
color = origin_shape.overrideColorRGB.get()
shape.overrideColorRGB.set(color)
else:
color = origin_shape.overrideColor.get()
shape.overrideColor.set(color)
for src, des in origin.listConnections(c=1, p=1,
type="constraint"):
_, attr = src.split(".")
src = pm.Attribute(crv + "." + attr)
src.connect(des, f=1)
for child in origin.getChildren():
if child == origin.getShape():
continue
crv.addChild(child)
name = str(origin)
pm.delete(origin)
crv.rename(name)
else:
# NOTE 说明层之下没有骨骼了
pm.warning(u"找不到下层级骨骼 %s" % origin)
pm.headsUpMessage(u"找不到下层级骨骼 %s" % origin)
def createLatticeControls():
'''
assume lattice is already created and xformed
xform for mathilda:
dt.Matrix([[1.08819833575, 0.0, 0.0, 0.0],
[0.0, 0.800333468787, 0.0, 0.0],
[0.0, 0.0, 1.08819833575, 0.0],
[0.0, 23.1879695956, -0.00324741491951, 1.0]])
'''
lat = nt.Transform(u'CT_headLattice_dfmLattice')
# defining lattice points
deformPoints = {'CT_headUpperA': [lat.pt[0:1][8][0:1], lat.pt[0:1][9:10][0:1]],
'CT_headUpperB': [lat.pt[0:1][11][0:1], lat.pt[0:1][12:15][0:1]],
'CT_headLowerA': [lat.pt[0:1][7][0:1], lat.pt[0:1][6][0:1]],
'CT_headLowerB': [lat.pt[0:1][5][0:1], lat.pt[0:1][0:4][0:1]]}
# create clusters
clusters = {}
dfg = pm.group(em=True, n='CT_headLatticeClusters_dfg')
for name, components in deformPoints.items():
dfm, hdl = pm.cluster(components[0], n=name+'_cluster_dfm', relative=True)
# above: use relative - the cluster handles will be parented with the face/head control
# so parentConstraint will only drive offset values to the handles
# so we'll make sure to only use the local offset values
for component in components[1]:
dfm.setGeometry(component)
dfg | hdl
clusters[name] = dfm, hdl
# create controls
controlZOffset = 0
childEyeShapers = []
localReadersGrp = pm.group(em=True, n='CT_headLatticeClusters_localReadersGrp')
for name, (dfm, hdl) in clusters.items():
pt = hdl.getRotatePivot(space='world')
pt = dt.Point(pt + (0, 0, controlZOffset))
ctl = pm.circle(n=name+'_headShaper_ctl')
ctg = pm.group(ctl, n=name+'_headShaper_ctg')
cth = pm.group(ctg, n=name+'_headShaper_cth')
cth.setTranslation(pt)
# shape ctl
ctl[1].radius.set(0.5)
ctl[1].sweep.set(359)
ctl[1].centerZ.set(0)
ctl[1].normal.set((0,1,0))
pm.delete(ctl, ch=True)
# scale transform
pm.makeIdentity(ctl[0], s=True, a=True)
# color shape
'''
if 'LT_' in name:
controls.setColor(ctl[0], 18)
elif 'RT_' in name:
controls.setColor(ctl[0], 20)
else:
pm.warning('unknown side %s' % name)'''
# parent constraint cluster (using matrices)
reader = localReader.create(hdl, localReadersGrp)
pm.parentConstraint(ctl[0], reader, mo=True)
childEyeShapers.append(cth)
# group both controls and clusters under the CTG,
# so cluster will only use local offsets
headShaperCtg = pm.group(childEyeShapers, localReadersGrp, n='CT_headLatticeControls_ctg')
# headShaperCtg can then be parented under face_ctrl
return headShaperCtg
[
-1.0,
0.0,
-1.0
],
[
1.0,
0.0,
-1.0
],
[
0.0,
0.0,
1.0
]
],
"degree": 1
}
],
'Locator': [
{'cvs': [dt.Point([0.0, 0.0, -25.0]), dt.Point([0.0, 0.0, 25.0])],
'degree': 1,
'knots': [0.0, 1.0]},
{'cvs': [dt.Point([0.0, 25.0, 0.0]), dt.Point([0.0, -25.0, 0.0])],
'degree': 1,
'knots': [0.0, 1.0]},
{'cvs': [dt.Point([25.0, 0.0, 0.0]), dt.Point([-25.0, 0.0, 0.0])],
'degree': 1,
'knots': [0.0, 1.0]}
]
}
def createLatticeControls():
'''
assume lattice is already created and xformed
'''
lat = nt.Transform(u'CT_eyeLattice_dfmLattice')
# defining lattice points
lf_in_col = 5
lf_mid_col = 6
lf_out_col = 7
rt_out_col = 1
rt_mid_col = 2
rt_in_col = 3
up_row = 3
dn_row = 2
deformPoints = {
'LT_eyeUpIn':
[lat.pt[lf_in_col][up_row][0], lat.pt[lf_in_col][up_row][1]],
'LT_eyeUpMid':
[lat.pt[lf_mid_col][up_row][0], lat.pt[lf_mid_col][up_row][1]],
'LT_eyeUpOut':
[lat.pt[lf_out_col][up_row][0], lat.pt[lf_out_col][up_row][1]],
'LT_eyeDnIn':
[lat.pt[lf_in_col][dn_row][0], lat.pt[lf_in_col][dn_row][1]],
'LT_eyeDnMid':
[lat.pt[lf_mid_col][dn_row][0], lat.pt[lf_mid_col][dn_row][1]],
'LT_eyeDnOut':
[lat.pt[lf_out_col][dn_row][0], lat.pt[lf_out_col][dn_row][1]],
'RT_eyeUpIn':
[lat.pt[rt_in_col][up_row][0], lat.pt[rt_in_col][up_row][1]],
'RT_eyeUpMid':
[lat.pt[rt_mid_col][up_row][0], lat.pt[rt_mid_col][up_row][1]],
'RT_eyeUpOut':
[lat.pt[rt_out_col][up_row][0], lat.pt[rt_out_col][up_row][1]],
'RT_eyeDnIn':
[lat.pt[rt_in_col][dn_row][0], lat.pt[rt_in_col][dn_row][1]],
'RT_eyeDnMid':
[lat.pt[rt_mid_col][dn_row][0], lat.pt[rt_mid_col][dn_row][1]],
'RT_eyeDnOut':
[lat.pt[rt_out_col][dn_row][0], lat.pt[rt_out_col][dn_row][1]]
}
# create clusters
clusters = {}
dfg = pm.group(em=True, n='CT_eyeLatticeClusters_dfg')
for name, components in deformPoints.items():
dfm, hdl = pm.cluster(components[1],
n=name + '_cluster_dfm',
relative=True)
# above: use relative - the cluster handles will be parented with the face/head control
# so parentConstraint will only drive offset values to the handles
# so we'll make sure to only use the local offset values
dfm.setGeometry(components[0])
dfg | hdl
clusters[name] = dfm, hdl
# create controls
controlZOffset = 0
childEyeShapers = []
localReadersGrp = pm.group(em=True,
n='CT_eyeLatticeClusters_localReadersGrp')
for name, (dfm, hdl) in clusters.items():
pt = hdl.getRotatePivot(space='world')
pt = dt.Point(pt + (0, 0, controlZOffset))
ctl = pm.circle(n=name + '_eyeShaper_ctl')
ctg = pm.group(ctl, n=name + '_eyeShaper_ctg')
cth = pm.group(ctg, n=name + '_eyeShaper_cth')
cth.setTranslation(pt)
# shape ctl
ctl[1].radius.set(0.5)
ctl[1].sweep.set(359)
ctl[1].centerZ.set(0)
pm.delete(ctl, ch=True)
# scale transform
ctl[0].sy.set(0.333)
pm.makeIdentity(ctl[0], s=True, a=True)
# color shape
if 'LT_' in name:
controls.setColor(ctl[0], 18)
elif 'RT_' in name:
controls.setColor(ctl[0], 20)
else:
pm.warning('unknown side %s' % name)
# parent constraint cluster (using matrices)
reader = localReader.create(hdl, localReadersGrp)
pm.parentConstraint(ctl[0], reader, mo=True)
childEyeShapers.append(cth)
# control parents
parentEyeShapers = []
for parentCtlName in ('RT_eyeUp', 'RT_eyeDn', 'LT_eyeUp', 'LT_eyeDn'):
# create parent control at cluster location
clusHdl = clusters[parentCtlName + 'Mid'][1]
pt = clusHdl.getRotatePivot(space='world')
pt = pt + (0, 0, controlZOffset)
ctl = pm.circle(n=parentCtlName + '_eyeShaper_ctl')
ctg = pm.group(ctl, n=parentCtlName + '_eyeShaper_ctg')
cth = pm.group(ctg, n=parentCtlName + '_eyeShaper_cth')
cth.setTranslation(pt)
# shape ctl
ctl[1].radius.set(2.5)
ctl[1].sweep.set(359)
ctl[1].centerZ.set(0)
pm.delete(ctl, ch=True)
# scale transform
ctl[0].sy.set(0.1)
pm.makeIdentity(ctl[0], s=True, a=True)
# color shape
if 'LT_' in parentCtlName:
controls.setColor(ctl[0], 18)
elif 'RT_' in parentCtlName:
controls.setColor(ctl[0], 20)
else:
pm.warning('unknown side %s' % name)
# parent other controls
children = [n for n in childEyeShapers if parentCtlName in n.name()]
pm.parent(children, ctl[0])
parentEyeShapers.append(cth)
# group both controls and clusters under the CTG,
# so cluster will only use local offsets
eyeShaperCtg = pm.group(parentEyeShapers,
localReadersGrp,
n='CT_eyeLatticeControls_ctg')
return eyeShaperCtg
