def bdJointOnCurveFromEdge(baseName, center=0):
'''
Category: Joint
Build joints based on the selected edge.
Selected edge gets converted to a nurbs curve and the joints are built at the CVs position.
'''
if pm.ls(sl=1) > 0:
if center:
center = pm.ls('center')[0]
centerPos = pm.xform(center, q=1, ws=1, t=1)
edgeCurveAll = pm.polyToCurve(form=2, degree=1)
pm.select(cl=1)
# meshName = pm.listConnections('%s.inputPolymesh'%edgeCurveAll[1])[0]
edgeCurve = pm.ls(edgeCurveAll[0])
numCv = edgeCurve[0].getShape().numCVs()
for i in range(numCv):
pos = edgeCurve[0].getShape().getCV(i, space='world')
if center:
baseJnt = pm.joint(n=baseName + '_jntc_' + str(i), p=centerPos)
endJnt = pm.joint(n=baseName + '_jnt_' + str(i), p=pos)
pm.joint(baseJnt,
e=True,
oj='xyz',
secondaryAxisOrient='yup',
ch=True,
zso=True)
endJnt.jointOrient.set([0, 0, 0])
pm.select(cl=1)
else:
pm.joint(n=baseName + '_jnt_' + str(i), p=pos)
pm.select(cl=1)
def createCurveRig(name, numOfControls):
"""
Create curve rig with selected edge loop
Parameters:
name: Rig name
numOfControls: Number of local controls
"""
# Convert edges to curve
rawCurve = pm.PyNode(pm.polyToCurve(n=name + '_crv', form=2, degree=1)[0])
# Create joints with rawCurve
jnts = []
for cv in rawCurve.cv:
pm.select(cl=True)
jnts.append(pm.joint(p=cv.getPosition(space='world'), radius=0.1))
jnts = renameByPosition(name, jnts)
# Rebuild curve and delete history
newCrv = pm.rebuildCurve(rawCurve, spans=numOfControls - 3, degree=3)[0]
pm.delete(newCrv, ch=True)
# Attach cluster to the curve cvs
clusters = [pm.cluster(cv)[1] for cv in newCrv.cv]
clusters = renameByPosition(name, clusters, suffix='clst')
locators = []
for clst in clusters:
pm.select(clst, r=True)
locators.append(tak_misc.locGrp())
# Cleanup outliner
jntGrp = pm.group(jnts, n=name + '_jnt_grp')
locGrp = pm.group(locators, n=name + '_loc_grp')
pm.group(jntGrp, locGrp, newCrv, n=name + '_system_grp')
def previewLoop(pGrp, loopAttr):
'''
creates temporary curve
delete curve when you're done
'''
loop = [pm.PyNode(node) for node in pGrp.attr(loopAttr).get()]
pm.select(loop, r=True)
crv = pm.PyNode(pm.polyToCurve(form=1, degree=1, ch=False)[0])
def previewLoop(pGrp, loopAttr):
"""
creates temporary curve
delete curve when you're done
"""
loop = [pm.PyNode(node) for node in pGrp.attr(loopAttr).get()]
pm.select(loop, r=True)
crv = pm.PyNode(pm.polyToCurve(form=1, degree=1, ch=False)[0])
def bdJointOnCurveFromEdge():
edgeCurveAll = pm.polyToCurve (form = 2,degree=1)
pm.select(cl=1)
meshName = pm.listConnections('%s.inputPolymesh'%edgeCurveAll[1])[0]
edgeCurve = pm.ls(edgeCurveAll[0])
numCv = edgeCurve[0].getShape().numCVs()
baseJoints = []
for i in range(numCv):
pos = edgeCurve[0].getShape().getCV(i, space='world')
baseJoints.append(pm.joint(n=meshName + '_jnt_' + str(i),p=pos))
pm.joint(baseJoints[0],e=True, oj='xzy',secondaryAxisOrient='zdown',ch= True,zso=True)
def addLoopPlacements(pGrp, loopAttr, cvMapping):
'''
'''
loop = [pm.PyNode(node) for node in pGrp.attr(loopAttr).get()]
pm.select(loop, r=True)
crv = pm.PyNode(pm.polyToCurve(form=1, degree=1, ch=False)[0])
for pName, cvId in cvMapping.items():
pt = crv.cv[cvId].getPosition(space='world')
# loop placements are considered "indirect"
addPlacementLoc(pGrp, pName, pt, 1)
pm.delete(crv)
def addLoopPlacements(pGrp, loopAttr, cvMapping):
"""
"""
loop = [pm.PyNode(node) for node in pGrp.attr(loopAttr).get()]
pm.select(loop, r=True)
crv = pm.PyNode(pm.polyToCurve(form=1, degree=1, ch=False)[0])
for pName, cvId in cvMapping.items():
pt = crv.cv[cvId].getPosition(space="world")
# loop placements are considered "indirect"
addPlacementLoc(pGrp, pName, pt, 1)
pm.delete(crv)
def loop_to_joints(s=0.025):
"""Convert a mesh loop edge selection to a nurbs curve that has
joints (w/ tweak controls) at each vertex. Opens dialog for naming."""
edges = pmc.selected(flatten=True)
cage = edges[0].node()
try:
n = make_dialog("Name of this curve/region?") + "{}"
except TypeError:
pmc.warning("Aborted.")
return
c = pmc.PyNode(pmc.polyToCurve(n=n.format("_rider"))[0])
verts = set([v for e in edges for v in e.connectedVertices()])
grp = pmc.group(em=True, n=n.format("_grp"))
c.setParent(grp)
jn = ""
for i, v in enumerate(verts):
pmc.select(c)
pmc.selectMode(component=True)
pmc.select(c.u[i])
pmc.refresh()
jn = make_dialog("Name of this joint?", jn)
poci = pmc.nt.PointOnCurveInfo(n=n.format(jn + "_poci"))
c.ws >> poci.inputCurve
poci.parameter.set(i)
ctrl_grp = pmc.group(em=True, n=n.format(jn + "_offset"))
ctrl_grp.setParent(grp)
ctrl = pmc.sphere(r=s, s=1, nsp=1, ch=0,
n=n.format(jn + "_tweakCtrl"))[0]
ctrl.setParent(ctrl_grp)
j = pmc.joint(n=n.format(jn + "_rig"))
j.setParent(ctrl)
j.hide()
poci.position >> ctrl_grp.translate
nCon = pmc.normalConstraint(cage, ctrl_grp)
poci.nt >> nCon.worldUpVector
# remove graph cluster
nCon.crp.disconnect()
nCon.crt.disconnect()
nCon.cro.disconnect()
nCon.cpim.disconnect()
nCon.ct.disconnect()
poci.position >> nCon.constraintTranslate
grp.wim >> nCon.cpim
pmc.selectMode(object=True)
def bdJointOnCurveFromEdge():
edgeCurveAll = pm.polyToCurve(form=2, degree=1)
pm.select(cl=1)
meshName = pm.listConnections('%s.inputPolymesh' % edgeCurveAll[1])[0]
edgeCurve = pm.ls(edgeCurveAll[0])
numCv = edgeCurve[0].getShape().numCVs()
baseJoints = []
for i in range(numCv):
pos = edgeCurve[0].getShape().getCV(i, space='world')
baseJoints.append(pm.joint(n=meshName + '_jnt_' + str(i), p=pos))
pm.joint(baseJoints[0],
e=True,
oj='xzy',
secondaryAxisOrient='zdown',
ch=True,
zso=True)
def makeNiceCurveFromEdges(sel, symVec=None, numSpans=None):
"""Take selection of poly edges and turn into
nice nurbs curve with seam along axis of sym (if relevant)"""
# how many spans?
if not numSpans:
# clamp it to 1-8; over 8 is excessive and numSpans arg of 0 is ignored
#numSpans = max(1, min(8, (len(sel) / 8) * 2))
numSpans = max(1, min(8, len(sel) / 4))
# form 2 is "best guess", pretty reliable for
# distinguishing periodic vs open
crv = pmc.PyNode(pmc.polyToCurve(dg=3, f=2, ch=0)[0])
pmc.xform(crv, centerPivots=True)
if symVec and crv.form() != "open":
# move seam to along axis, so that
# rebuilding the curve doesn't result in unexpected asymmetry
intPt = getMirrorParam(crv, symVec)
# IF it actually crosses the axis
try:
intPt = float(intPt.split(" ")[0])
pmc.select(crv.u[intPt])
pmc.mel.eval("moveNurbsCurveSeam")
except (AttributeError, pmc.MelError):
# AttributeError means there is no good mnirror seam.
# could be intentional, so no warning.
# MelError means seam is already at the best point.
pass
# rebuilding surface instead of curve keeps weird all-0-cv bugs away
#
# try rebuild curve instead of surface to help w/ recurring asym issue
# or wait wasn't that solved by kc=0?
#
pmc.rebuildCurve(crv,
rebuildType=0,
keepRange=0,
spans=numSpans,
ch=0,
rpo=True)
return crv
def addEyeLoopPlacements(pGrp, overrideCornerCVs=None):
"""
"""
loop = [pm.PyNode(node) for node in pGrp.leftEyelidLoop.get()]
pm.select(loop, r=True)
crv = pm.PyNode(pm.polyToCurve(form=1, degree=1, ch=False, n=pGrp + "_eyeLoopCrv")[0])
crv.v.set(False)
pGrp | crv
cornerCVs = eye.returnInUpOutLowCVsOnCurve(crv) # in, up, out, low
# override cornerCVs if eyeshape is weird and does not calc properly
if overrideCornerCVs:
cornerCVs = [crv.cv[index] for index in overrideCornerCVs]
pLocsDict = {}
# add corner jnts
for cv, corner in zip(cornerCVs, ("inner", "upper", "outer", "lower")):
pos = cv.getPosition()
pLocsDict[corner] = addPlacementLoc(pGrp, "LT_" + corner + "_eyelid", pos, 1)
cv_id = cv.index()
attachPlacerToLoopCurve(pLocsDict[corner], crv, cv_id)
# add secondary eyelid jnts
cornerParams = [face.getParamFromCV(cv) for cv in cornerCVs]
totalParam = crv.spans.get()
eachSectionParam = totalParam / 8.0
# inner corner
params = [cornerParams[0] + eachSectionParam, cornerParams[0] - eachSectionParam]
params = [int(p) for p in params]
for _ in range(len(params)):
if params[_] < 0:
params[_] = totalParam + params[_]
elif params[_] > totalParam:
params[_] = params[_] - totalParam
print params
positions = [crv.getPointAtParam(p) for p in params]
# see which position-y is higher
if positions[0].y > positions[1].y:
upperPos = positions[0]
lowerPos = positions[1]
upperId = params[0]
lowerId = params[1]
else:
upperPos = positions[1]
lowerPos = positions[0]
upperId = params[1]
lowerId = params[0]
pLocsDict["innerUpper"] = addPlacementLoc(pGrp, "LT_innerUpper_eyelid", upperPos, 1)
pLocsDict["innerLower"] = addPlacementLoc(pGrp, "LT_innerLower_eyelid", lowerPos, 1)
attachPlacerToLoopCurve(pLocsDict["innerUpper"], crv, upperId)
attachPlacerToLoopCurve(pLocsDict["innerLower"], crv, lowerId)
# outer corner
params = [cornerParams[2] + eachSectionParam, cornerParams[2] - eachSectionParam]
params = [int(p) for p in params]
for _ in range(len(params)):
if params[_] < 0:
params[_] = totalParam + params[_]
elif params[_] > totalParam:
params[_] = params[_] - totalParam
print params
positions = [crv.getPointAtParam(p) for p in params]
# see which position-y is higher
if positions[0].y > positions[1].y:
upperPos = positions[0]
lowerPos = positions[1]
upperId = params[0]
lowerId = params[1]
else:
upperPos = positions[1]
lowerPos = positions[0]
upperId = params[0]
lowerId = params[1]
pLocsDict["outerUpper"] = addPlacementLoc(pGrp, "LT_outerUpper_eyelid", upperPos, 1)
pLocsDict["outerLower"] = addPlacementLoc(pGrp, "LT_outerLower_eyelid", lowerPos, 1)
attachPlacerToLoopCurve(pLocsDict["outerUpper"], crv, upperId)
attachPlacerToLoopCurve(pLocsDict["outerLower"], crv, lowerId)
orientPlacerOnLoop(pLocsDict["inner"], beforeObj=None, afterObj=pLocsDict["innerUpper"])
orientPlacerOnLoop(pLocsDict["innerUpper"], beforeObj=pLocsDict["inner"], afterObj=pLocsDict["upper"])
orientPlacerOnLoop(pLocsDict["upper"], beforeObj=pLocsDict["innerUpper"], afterObj=pLocsDict["outerUpper"])
orientPlacerOnLoop(pLocsDict["outerUpper"], beforeObj=pLocsDict["upper"], afterObj=pLocsDict["outer"])
orientPlacerOnLoop(pLocsDict["outer"], beforeObj=pLocsDict["outerUpper"], afterObj=None)
orientPlacerOnLoop(pLocsDict["innerLower"], beforeObj=pLocsDict["inner"], afterObj=pLocsDict["lower"])
orientPlacerOnLoop(pLocsDict["lower"], beforeObj=pLocsDict["innerLower"], afterObj=pLocsDict["outerLower"])
orientPlacerOnLoop(pLocsDict["outerLower"], beforeObj=pLocsDict["lower"], afterObj=pLocsDict["outer"])
def getFacePerimeterCurve(faces):
pmc.select(faces)
pmc.evalContinue("ConvertSelectionToEdgePerimeter")
return pmc.PyNode(pmc.polyToCurve()[0])
def addEyeLoopPlacements(pGrp, overrideCornerCVs=None):
'''
'''
loop = [pm.PyNode(node) for node in pGrp.leftEyelidLoop.get()]
pm.select(loop, r=True)
crv = pm.PyNode(
pm.polyToCurve(form=1, degree=1, ch=False, n=pGrp + '_eyeLoopCrv')[0])
crv.v.set(False)
pGrp | crv
cornerCVs = eye.returnInUpOutLowCVsOnCurve(crv) # in, up, out, low
# override cornerCVs if eyeshape is weird and does not calc properly
if overrideCornerCVs:
cornerCVs = [crv.cv[index] for index in overrideCornerCVs]
pLocsDict = {}
# add corner jnts
for cv, corner in zip(cornerCVs, ('inner', 'upper', 'outer', 'lower')):
pos = cv.getPosition()
pLocsDict[corner] = addPlacementLoc(pGrp, 'LT_' + corner + '_eyelid',
pos, 1)
cv_id = cv.index()
attachPlacerToLoopCurve(pLocsDict[corner], crv, cv_id)
# add secondary eyelid jnts
cornerParams = [face.getParamFromCV(cv) for cv in cornerCVs]
totalParam = crv.spans.get()
eachSectionParam = totalParam / 8.0
# inner corner
params = [
cornerParams[0] + eachSectionParam, cornerParams[0] - eachSectionParam
]
params = [int(p) for p in params]
for _ in range(len(params)):
if params[_] < 0:
params[_] = totalParam + params[_]
elif params[_] > totalParam:
params[_] = params[_] - totalParam
print params
positions = [crv.getPointAtParam(p) for p in params]
# see which position-y is higher
if positions[0].y > positions[1].y:
upperPos = positions[0]
lowerPos = positions[1]
upperId = params[0]
lowerId = params[1]
else:
upperPos = positions[1]
lowerPos = positions[0]
upperId = params[1]
lowerId = params[0]
pLocsDict['innerUpper'] = addPlacementLoc(pGrp, 'LT_innerUpper_eyelid',
upperPos, 1)
pLocsDict['innerLower'] = addPlacementLoc(pGrp, 'LT_innerLower_eyelid',
lowerPos, 1)
attachPlacerToLoopCurve(pLocsDict['innerUpper'], crv, upperId)
attachPlacerToLoopCurve(pLocsDict['innerLower'], crv, lowerId)
# outer corner
params = [
cornerParams[2] + eachSectionParam, cornerParams[2] - eachSectionParam
]
params = [int(p) for p in params]
for _ in range(len(params)):
if params[_] < 0:
params[_] = totalParam + params[_]
elif params[_] > totalParam:
params[_] = params[_] - totalParam
print params
positions = [crv.getPointAtParam(p) for p in params]
# see which position-y is higher
if positions[0].y > positions[1].y:
upperPos = positions[0]
lowerPos = positions[1]
upperId = params[0]
lowerId = params[1]
else:
upperPos = positions[1]
lowerPos = positions[0]
upperId = params[0]
lowerId = params[1]
pLocsDict['outerUpper'] = addPlacementLoc(pGrp, 'LT_outerUpper_eyelid',
upperPos, 1)
pLocsDict['outerLower'] = addPlacementLoc(pGrp, 'LT_outerLower_eyelid',
lowerPos, 1)
attachPlacerToLoopCurve(pLocsDict['outerUpper'], crv, upperId)
attachPlacerToLoopCurve(pLocsDict['outerLower'], crv, lowerId)
orientPlacerOnLoop(pLocsDict['inner'],
beforeObj=None,
afterObj=pLocsDict['innerUpper'])
orientPlacerOnLoop(pLocsDict['innerUpper'],
beforeObj=pLocsDict['inner'],
afterObj=pLocsDict['upper'])
orientPlacerOnLoop(pLocsDict['upper'],
beforeObj=pLocsDict['innerUpper'],
afterObj=pLocsDict['outerUpper'])
orientPlacerOnLoop(pLocsDict['outerUpper'],
beforeObj=pLocsDict['upper'],
afterObj=pLocsDict['outer'])
orientPlacerOnLoop(pLocsDict['outer'],
beforeObj=pLocsDict['outerUpper'],
afterObj=None)
orientPlacerOnLoop(pLocsDict['innerLower'],
beforeObj=pLocsDict['inner'],
afterObj=pLocsDict['lower'])
orientPlacerOnLoop(pLocsDict['lower'],
beforeObj=pLocsDict['innerLower'],
afterObj=pLocsDict['outerLower'])
orientPlacerOnLoop(pLocsDict['outerLower'],
beforeObj=pLocsDict['lower'],
afterObj=pLocsDict['outer'])
def doRig(self):
cnstrGrp = pm.group(em=True, n=self.name + 'EyeLid_constrained_grp')
sysGrp = pm.group(em=True, n=self.name + 'EyeLidSys_grp')
crvsGrp = pm.group(em=True, n=self.name + 'Curves_grp')
clsGrp = pm.group(em=True, n=self.name + 'Clusters_grp')
jntGrp = pm.group(em=True, n=self.name + 'Joints_grp')
locGrp = pm.group(em=True, n=self.name + 'Locators_grp')
if pm.objExists('head_contrained'):
constrained_grp = 'head_contrained'
else:
constrained_grp = pm.group(n='head_contrained', em=True)
pm.parent(crvsGrp, clsGrp, jntGrp, locGrp, sysGrp)
sysGrp.visibility.set(False)
pm.delete(self.upCtrlCrv, self.lowCtrlCrv, ch=True)
self.upEdgeLoop = selectLoopByLocators(mesh=self.mesh,
loc1=self.inCorner,
loc2=self.outCorner,
loc3=self.upCorner)
pm.select(self.upEdgeLoop)
upCrv = pm.polyToCurve(form=2,
degree=1,
n=self.name + 'UpperCrv',
ch=False)[0]
self.upCrv = pm.rebuildCurve(upCrv,
rt=3,
rpo=True,
d=3,
end=1,
kr=0,
kcp=1,
kep=0,
kt=0,
s=25,
tol=0.01,
ch=False)[0]
if not atStart(loc=self.inCorner, crvName=self.upCrv):
pm.reverseCurve(self.upCrv, ch=False, replaceOriginal=True)
self.lowEdgeLoop = selectLoopByLocators(mesh=self.mesh,
loc1=self.inCorner,
loc2=self.outCorner,
loc3=self.lowCorner)
pm.select(self.lowEdgeLoop)
lowCrv = pm.polyToCurve(form=2,
degree=1,
n=self.name + 'LowerCrv',
ch=False)[0]
self.lowCrv = pm.rebuildCurve(lowCrv,
rt=3,
rpo=True,
d=3,
end=1,
kr=0,
kcp=1,
kep=0,
kt=0,
s=25,
tol=0.01,
ch=False)[0]
if not atStart(loc=self.inCorner, crvName=self.lowCrv):
pm.reverseCurve(self.lowCrv, ch=False, replaceOriginal=True)
upBlink = pm.rebuildCurve(self.upCrv,
s=20,
rt=0,
rpo=False,
ch=False,
n=self.name + 'upBlink')[0]
lowBlink = pm.rebuildCurve(self.lowCrv,
s=20,
rt=0,
rpo=False,
ch=False,
n=self.name + 'lowBlink')[0]
upTarget = pm.rebuildCurve(self.upCrv,
s=20,
rt=0,
rpo=False,
ch=False,
n=self.name + 'upTarget')[0]
lowTarget = pm.rebuildCurve(self.lowCrv,
s=20,
rt=0,
rpo=False,
ch=False,
n=self.name + 'lowTarget')[0]
midTarget = pm.rebuildCurve(self.lowCrv,
s=20,
rt=0,
rpo=False,
ch=False,
n=self.name + 'midTarget')[0]
pm.parent(upTarget, lowTarget, midTarget, lowBlink, upBlink,
self.upCtrlCrv, self.lowCtrlCrv, self.upCrv, self.lowCrv,
crvsGrp)
w1 = pm.wire(self.upCrv, w=upBlink)[0]
w2 = pm.wire(self.lowCrv, w=lowBlink)[0]
w3 = pm.wire(upTarget, w=self.upCtrlCrv)[0]
w4 = pm.wire(lowTarget, w=self.lowCtrlCrv)[0]
bs_upBlink = pm.blendShape(upTarget,
midTarget,
upBlink,
n=self.name + "blendShapeUpBlink")
bs_lowBlink = pm.blendShape(lowTarget,
midTarget,
lowBlink,
n=self.name + "blendShapeLowBlink")
bs_mid = pm.blendShape(lowTarget,
upTarget,
midTarget,
n=self.name + "blendShapeLowBlink")
# setting blendshape reverse connections
rev_node = pm.createNode("reverse")
pm.connectAttr(bs_upBlink[0].attr(midTarget.name()),
rev_node + ".inputX")
pm.connectAttr(rev_node + ".outputX",
bs_upBlink[0].attr(upTarget.name()))
rev_node = pm.createNode("reverse")
pm.connectAttr(bs_lowBlink[0].attr(midTarget.name()),
rev_node + ".inputX")
pm.connectAttr(rev_node + ".outputX",
bs_lowBlink[0].attr(lowTarget.name()))
rev_node = pm.createNode("reverse")
pm.connectAttr(bs_mid[0].attr(upTarget.name()), rev_node + ".inputX")
pm.connectAttr(rev_node + ".outputX", bs_mid[0].attr(lowTarget.name()))
# setting default values
bs_mid[0].attr(upTarget.name()).set(.3)
cvsUp = self.upCtrlCrv.getCVs(space="world")
cvsLow = self.lowCtrlCrv.getCVs(space="world")
upCtrls = []
lowCtrls = []
cornerCtrls = []
for i in range(1, 4):
pos = cvsUp[i]
clsUp = pm.cluster(self.upCtrlCrv.cv[i],
n=self.name + 'ClsUp' + str(i))[1]
pm.group()
rp = pm.xform(clsUp, q=True, rp=True, ws=True)
grp = pm.group(em=True, n=clsUp.name() + 'off1_grp')
pm.xform(grp, t=rp, ws=True)
grp1 = pm.duplicate(grp, n=clsUp.name() + 'off2_grp')[0]
pm.parent(grp, grp1)
pm.parent(clsUp.getParent(), grp)
pm.parent(grp1, clsGrp)
ctrlUp = controlTools.cntrlCrv(name=self.name + 'EyeLidUp' +
str(i),
obj=clsUp,
connType='connection',
hasZeroGrp=True,
cntrlSulfix='_ctrl',
icone='circuloZ',
size=.1,
offsets=1)
ctrlUp.getParent().translate >> grp.translate
ctrlUp.getParent().rotate >> grp.rotate
ctrlUp.getParent().scale >> grp.scale
pm.xform(ctrlUp.getParent(2), ws=True, t=pos)
pm.parent(ctrlUp.getParent(2), cnstrGrp)
upCtrls.append(ctrlUp)
pos = cvsLow[i]
clsLow = pm.cluster(self.lowCtrlCrv.cv[i],
n=self.name + 'ClsLow' + str(i))[1]
pm.group()
rp = pm.xform(clsLow, q=True, rp=True, ws=True)
grp = pm.group(em=True, n=clsLow.name() + 'off1_grp')
pm.xform(grp, t=rp, ws=True)
grp1 = pm.duplicate(grp, n=clsLow.name() + 'off2_grp')[0]
pm.parent(grp, grp1)
pm.parent(clsLow.getParent(), grp)
pm.parent(grp1, clsGrp)
ctrlLow = controlTools.cntrlCrv(name=self.name + 'EyeLidLow' +
str(i),
obj=clsLow,
connType='connection',
hasZeroGrp=True,
cntrlSulfix='_ctrl',
icone='circuloZ',
size=.1,
offsets=1)
ctrlLow.getParent().translate >> grp.translate
ctrlLow.getParent().rotate >> grp.rotate
ctrlLow.getParent().scale >> grp.scale
pm.xform(ctrlLow.getParent(2), ws=True, t=pos)
pm.parent(ctrlLow.getParent(2), cnstrGrp)
lowCtrls.append(ctrlLow)
for i in [0, 4]:
pos = cvsUp[i]
clsCorner = pm.cluster(self.upCtrlCrv.cv[i],
self.lowCtrlCrv.cv[i],
n=self.name + 'ClsCorner' + str(i))[1]
pm.group()
rp = pm.xform(clsCorner, q=True, rp=True, ws=True)
grp = pm.group(em=True, n=clsCorner.name() + 'off1_grp')
pm.xform(grp, t=rp, ws=True)
grp1 = pm.duplicate(grp, n=clsCorner.name() + 'off2_grp')[0]
pm.parent(grp, grp1)
pm.parent(clsCorner.getParent(), grp)
pm.parent(grp1, clsGrp)
ctrlCorner = controlTools.cntrlCrv(name=self.name +
'EyeLidCorner' + str(i),
obj=clsCorner,
connType='connection',
hasZeroGrp=True,
cntrlSulfix='_ctrl',
icone='circuloZ',
size=.1,
offsets=1)
pm.xform(ctrlCorner.getParent(2), ws=True, t=pos)
pm.parent(ctrlCorner.getParent(2), cnstrGrp)
cornerCtrls.append(ctrlCorner)
upCrvNode = pm.PyNode(self.upCrv)
lowCrvNode = pm.PyNode(self.lowCrv)
centerPos = pm.xform(self.eyeCenter, q=True, ws=True, t=True)
cvs = upCrvNode.getCVs(space="world")
aimLocs = []
for i, pos in enumerate(cvs):
pm.select(cl=True)
jntBase = pm.joint(p=centerPos,
n=self.name + 'EyelidUp_' + str(i) + '_zero')
jnt = pm.joint(p=pos, n=self.name + 'EyelidUp_' + str(i) + '_jnt')
self.skinJoints.append(jnt.name())
pm.joint(jntBase, e=True, zso=True, oj='xyz', sao='yup')
pm.parent(jntBase, jntGrp)
loc = pm.spaceLocator(p=[0, 0, 0], n=jnt.name() + 'UpAim_loc')
loc.translate.set(pos)
loc.localScale.set(.01, .01, .01)
pm.aimConstraint(loc,
jntBase,
aim=(1, 0, 0),
u=(0, 1, 0),
wut='vector',
wu=(0, 1, 0))
pm.parent(loc, locGrp)
aimLocs.append(loc)
pm.select(aimLocs, self.upCrv)
attachTools.hookOnCurve(tangent=False)
cvs = lowCrvNode.getCVs(space="world")
aimLocs = []
for i, pos in enumerate(cvs):
pm.select(cl=True)
jntBase = pm.joint(p=centerPos,
n=self.name + 'EyelidLw_' + str(i) + '_zero')
jnt = pm.joint(p=pos, n=self.name + 'EyelidLw_' + str(i) + '_jnt')
self.skinJoints.append(jnt.name())
pm.joint(jntBase, e=True, zso=True, oj='xyz', sao='yup')
pm.parent(jntBase, jntGrp)
loc = pm.spaceLocator(p=[0, 0, 0], n=jnt.name() + 'LwAim_loc')
loc.translate.set(pos)
loc.localScale.set(.01, .01, .01)
pm.aimConstraint(loc,
jntBase,
aim=(1, 0, 0),
u=(0, 1, 0),
wut='vector',
wu=(0, 1, 0))
pm.parent(loc, locGrp)
aimLocs.append(loc)
pm.select(aimLocs, self.lowCrv)
attachTools.hookOnCurve(tangent=False)
pm.parentConstraint(upCtrls[1],
cornerCtrls[0],
upCtrls[0].getParent(),
mo=1)
pm.parentConstraint(upCtrls[1],
cornerCtrls[1],
upCtrls[2].getParent(),
mo=1)
pm.parentConstraint(lowCtrls[1],
cornerCtrls[0],
lowCtrls[0].getParent(),
mo=1)
pm.parentConstraint(lowCtrls[1],
cornerCtrls[1],
lowCtrls[2].getParent(),
mo=1)
up_ctl = upCtrls[1]
pm.addAttr(up_ctl,
ln="blink",
at="float",
dv=0,
minValue=0,
maxValue=1,
k=True)
pm.addAttr(up_ctl,
ln="blinkMult",
at="float",
dv=1,
minValue=1,
maxValue=2,
k=True)
pm.addAttr(up_ctl,
ln="blinkHeight",
at="float",
dv=0.3,
minValue=0,
maxValue=1,
k=True)
pm.addAttr(up_ctl,
ln="fleshyEye",
at="float",
dv=0.5,
minValue=0,
maxValue=1,
k=True)
fleshyEye_loc = pm.spaceLocator(n=self.name + 'FleshyEye_loc')
fleshyEye_loc.visibility.set(0)
pm.parent(fleshyEye_loc, cnstrGrp)
pm.xform(fleshyEye_loc, t=centerPos, ws=True)
pm.parentConstraint(fleshyEye_loc, upCtrls[1].getParent(), mo=1)
pm.parentConstraint(fleshyEye_loc, lowCtrls[1].getParent(), mo=1)
fleshyEyeMulti = pm.createNode('multiplyDivide',
name=self.name + 'multiFleshy')
fleshyEyeMulti.output.outputX >> fleshyEye_loc.rotate.rotateX
fleshyEyeMulti.output.outputY >> fleshyEye_loc.rotate.rotateY
fleshyEyeMulti.output.outputZ >> fleshyEye_loc.rotate.rotateZ
up_ctl.fleshyEye >> fleshyEyeMulti.input2.input2X
up_ctl.fleshyEye >> fleshyEyeMulti.input2.input2Y
up_ctl.fleshyEye >> fleshyEyeMulti.input2.input2Z
mult_node = pm.createNode('multDoubleLinear',
name=self.name + 'multBlink')
up_ctl.blink >> mult_node.input1
up_ctl.blinkMult >> mult_node.input2
mult_node.output >> bs_upBlink[0].attr(midTarget.name())
mult_node.output >> bs_lowBlink[0].attr(midTarget.name())
up_ctl.blinkHeight >> bs_mid[0].attr(upTarget.name())
reverse_node = pm.createNode('reverse',
name=self.name + 'blinkReverse')
up_ctl.blink >> reverse_node.inputX
reverse_node.outputX >> w1.scale[0]
reverse_node.outputX >> w2.scale[0]
reverse_node.outputX >> w3.scale[0]
reverse_node.outputX >> w4.scale[0]
self.guideMoveall.visibility.set(0)
pm.parent(cnstrGrp, constrained_grp)
def doGuide(self,
eyeball=None,
edgeLoop=None,
autoExtremes=True,
**kwargs):
self.__dict__.update(kwargs)
if pm.objExists(self.name + 'Crv_grp'):
pm.delete(self.name + 'Crv_grp')
self.guideMoveall = self.createCntrl('moveallGuide')
self.eyeCenter = self.createCntrl(setupName='eyeCenterGuide',
nameTempl=self.name + 'EyeCenter' +
self.guideSulfix)
self.inCorner = self.createCntrl(setupName='cornersGuide',
nameTempl=self.name + 'InCorner' +
self.guideSulfix)
self.outCorner = self.createCntrl(setupName='cornersGuide',
nameTempl=self.name + 'OutCorner' +
self.guideSulfix)
self.upCorner = self.createCntrl(setupName='cornersGuide',
nameTempl=self.name + 'UpCorner' +
self.guideSulfix)
self.lowCorner = self.createCntrl(setupName='cornersGuide',
nameTempl=self.name + 'LowCorner' +
self.guideSulfix)
pm.parent(self.eyeCenter, self.inCorner, self.outCorner, self.upCorner,
self.lowCorner, self.guideMoveall)
crvGrp = pm.group(n=self.name + 'Crv_grp', em=True)
clsGuideGrp = pm.group(em=True,
n=self.name + 'crvCtrlGuideClusters',
p=crvGrp)
clsGuideGrp.visibility.set(False)
ctrlGuideGrp = pm.group(em=True,
n=self.name + 'crvCtrlsGuide',
p=self.guideMoveall)
if eyeball:
bbox = eyeball.getBoundingBox(space='world')
pos = bbox.center()
self.guideDict['moveall'][0] = (pos[0], pos[1], pos[2])
else:
logger.debug('no eyeball passed')
if edgeLoop:
self.edgeLoop = edgeLoop
self.meshName = self.edgeLoop[0].name().split('.')[0]
self.mesh = pm.PyNode(self.meshName)
else:
logger.debug('no edgeloop passed')
#self.mesh = None
self.edgeLoop = None
if autoExtremes:
try:
pts = getEdgeLoopExtremesPoints(self.edgeLoop)
inPos = pm.xform(pts[0], q=True, ws=True, t=True)
outPos = pm.xform(pts[1], q=True, ws=True, t=True)
upPos = pm.xform(pts[2], q=True, ws=True, t=True)
lowPos = pm.xform(pts[3], q=True, ws=True, t=True)
self.guideDict['inCorner'] = [inPos, (0, 0, 0)]
self.guideDict['outCorner'] = [outPos, (0, 0, 0)]
self.guideDict['upCorner'] = [upPos, (0, 0, 0)]
self.guideDict['lowCorner'] = [lowPos, (0, 0, 0)]
except:
logger.debug('not possible autoextremes')
self.setCntrl(self.guideMoveall, 'moveall', space='world')
self.setCntrl(self.eyeCenter, 'eyeCenter', space='object')
self.setCntrl(self.inCorner, 'inCorner', space='world')
self.setCntrl(self.outCorner, 'outCorner', space='world')
self.setCntrl(self.upCorner, 'upCorner', space='world')
self.setCntrl(self.lowCorner, 'lowCorner', space='world')
try:
upEdgeLoop = selectLoopByLocators(mesh=self.mesh,
loc1=self.inCorner,
loc2=self.outCorner,
loc3=self.upCorner)
pm.select(cl=True)
pm.select(upEdgeLoop)
upCrv = pm.polyToCurve(form=2,
degree=3,
n=self.name + 'UpperCrv',
ch=False)[0]
if not atStart(loc=self.inCorner, crvName=upCrv):
pm.reverseCurve(upCrv, ch=False, replaceOriginal=True)
lowEdgeLoop = selectLoopByLocators(mesh=self.mesh,
loc1=self.inCorner,
loc2=self.outCorner,
loc3=self.lowCorner)
pm.select(cl=True)
pm.select(lowEdgeLoop)
lowCrv = pm.polyToCurve(form=2,
degree=3,
n=self.name + 'LowerCrv',
ch=False)[0]
if not atStart(loc=self.inCorner, crvName=lowCrv):
pm.reverseCurve(lowCrv, ch=False, replaceOriginal=True)
self.upCtrlCrv = pm.rebuildCurve(upCrv,
s=2,
rt=0,
rpo=False,
ch=False,
n=self.name + 'upCtrl')[0]
self.lowCtrlCrv = pm.rebuildCurve(lowCrv,
s=2,
rt=0,
rpo=False,
ch=False,
n=self.name + 'lowCtrl')[0]
pm.delete(upCrv, lowCrv)
except:
logger.debug(
'Found no edgeloop by locators. Using coordinates to draw')
self.upCtrlCrv = pm.curve(n=self.name + 'upCrv_guide',
d=3,
p=self.guideDict['upCtrlGrp'])
self.setCntrl(self.upCtrlCrv, 'moveall', space='world')
self.lowCtrlCrv = pm.curve(n=self.name + 'lowCrv_guide',
d=3,
p=self.guideDict['lowCtrlGrp'])
self.setCntrl(self.lowCtrlCrv, 'moveall', space='world')
self.crvGuideCtrls = {'upCtrlCrv': [], 'lowCtrlCrv': []}
for crvName in ['upCtrlCrv', 'lowCtrlCrv']:
crv = self.__dict__[crvName]
for i in range(5):
cls = pm.cluster(crv.cv[i])[1]
pm.parent(cls, clsGuideGrp)
ctrl = controlTools.cntrlCrv(name=self.name + crvName + str(i),
align='pivot',
obj=cls,
connType='pointConstraint',
hasZeroGrp=True,
cntrlSulfix='_ctrl',
icone='bola',
size=.05)
pm.parent(ctrl.getParent(), ctrlGuideGrp)
self.crvGuideCtrls[crvName].append(ctrl)
for crvName in ['upCtrlCrv', 'lowCtrlCrv']:
for i in range(5):
self.crvGuideCtrls[crvName][i].setTranslation(
self.guideDict[crvName][i], space='object')
pm.parent(self.upCtrlCrv, self.lowCtrlCrv, crvGrp, r=True)
try:
facialGrp = pm.PyNode('facial_guides_grp')
pm.parent(self.guideMoveall, crvGrp, facialGrp)
except:
pass
pm.addAttr(self.guideMoveall, ln='eyeLidDict', dt='string')
self.guideMoveall.eyeLidDict.set(json.dumps(self.exportDict()))
import pymel.core as pm
import maya.mel as mel
curSel = pm.ls(sl=1,fl=1)
for hair in curSel:
pm.select(hair + '.e[1]',r=1)
mel.eval("SelectEdgeLoopSp;")
pm.polyToCurve(form=2,degree=3)
pm.select(cl=1)
def addMouthLoopPlacements(pGrp):
'''
'''
loop = [pm.PyNode(node) for node in pGrp.mouthLipsLoop.get()]
pm.select(loop, r=True)
mel.ConvertSelectionToVertices()
lipVerts = pm.ls(sl=True, fl=True)
# lips center
centerVerts = [
vert for vert in lipVerts
if vert.getPosition().x < 0.001 and vert.getPosition().x > -0.001
]
positions = [vert.getPosition() for vert in centerVerts]
# see which position-y is higher
if positions[0].y > positions[1].y:
upperPos = positions[0]
lowerPos = positions[1]
else:
upperPos = positions[1]
lowerPos = positions[0]
pm.select(cl=True)
CT_upper_pLoc = addPlacementLoc(pGrp, 'CT_upper_lip', upperPos, 1)
CT_lower_pLoc = addPlacementLoc(pGrp, 'CT_lower_lip', lowerPos, 1)
# lips corner
# find left corner
cornerVert = max(lipVerts, key=lambda x: x.getPosition()[0])
cornerPos = cornerVert.getPosition()
LT_corner_pLoc = addPlacementLoc(pGrp, 'LT_corner_lip', cornerPos, 1)
# add secondary controls to lips
loop = [pm.PyNode(node) for node in pGrp.mouthLipsLoop.get()]
pm.select(loop, r=True)
crv = pm.PyNode(
pm.polyToCurve(form=1, degree=1, ch=False,
n=pGrp + '_mouthLipLoopCrv')[0])
crv.v.set(False)
pGrp | crv
upPt = crv.closestPoint(upperPos)
lowPt = crv.closestPoint(lowerPos)
cnrPt = crv.closestPoint(cornerPos)
upperParam = crv.getParamAtPoint(upPt)
lowerParam = crv.getParamAtPoint(lowPt)
cornerParam = crv.getParamAtPoint(cnrPt)
attachPlacerToLoopCurve(CT_upper_pLoc, crv, upperParam)
attachPlacerToLoopCurve(CT_lower_pLoc, crv, lowerParam)
attachPlacerToLoopCurve(LT_corner_pLoc, crv, cornerParam)
totalParam = crv.spans.get()
sectionParam = totalParam / 16.0
# get pinch params by +/- sectionParam
params = [cornerParam + sectionParam, cornerParam - sectionParam]
params = [int(p) for p in params]
for _ in range(len(params)):
if params[_] < 0:
params[_] = totalParam + params[_]
print params
positions = [crv.getPointAtParam(p) for p in params]
# see which position-y is higher
if positions[0].y > positions[1].y:
upperPos = positions[0]
lowerPos = positions[1]
upperId = params[0]
lowerId = params[1]
else:
upperPos = positions[1]
lowerPos = positions[0]
upperId = params[1]
lowerId = params[0]
LT_upperPinch_pLoc = addPlacementLoc(pGrp, 'LT_upperPinch_lip', upperPos,
1)
LT_lowerPinch_pLoc = addPlacementLoc(pGrp, 'LT_lowerPinch_lip', lowerPos,
1)
attachPlacerToLoopCurve(LT_upperPinch_pLoc, crv, upperId)
attachPlacerToLoopCurve(LT_lowerPinch_pLoc, crv, lowerId)
# get sneer params by +/- 2 * sectionParam
params = [cornerParam + 2 * sectionParam, cornerParam - 2 * sectionParam]
params = [int(p) for p in params]
for _ in range(len(params)):
if params[_] < 0:
params[_] = totalParam + params[_]
print params
positions = [crv.getPointAtParam(p) for p in params]
# see which position-y is higher
if positions[0].y > positions[1].y:
upperPos = positions[0]
lowerPos = positions[1]
upperId = params[0]
lowerId = params[1]
else:
upperPos = positions[1]
lowerPos = positions[0]
upperId = params[1]
lowerId = params[0]
LT_upperSneer_pLoc = addPlacementLoc(pGrp, 'LT_upperSneer_lip', upperPos,
1)
LT_lowerSneer_pLoc = addPlacementLoc(pGrp, 'LT_lowerSneer_lip', lowerPos,
1)
attachPlacerToLoopCurve(LT_upperSneer_pLoc, crv, upperId)
attachPlacerToLoopCurve(LT_lowerSneer_pLoc, crv, lowerId)
# get side params by +/- 3 * sectionParam
params = [cornerParam + 3 * sectionParam, cornerParam - 3 * sectionParam]
params = [int(p) for p in params]
for _ in range(len(params)):
if params[_] < 0:
params[_] = totalParam + params[_]
print params
positions = [crv.getPointAtParam(p) for p in params]
# see which position-y is higher
if positions[0].y > positions[1].y:
upperPos = positions[0]
lowerPos = positions[1]
upperId = params[0]
lowerId = params[1]
else:
upperPos = positions[1]
lowerPos = positions[0]
upperId = params[1]
lowerId = params[0]
LT_upperSide_pLoc = addPlacementLoc(pGrp, 'LT_upperSide_lip', upperPos, 1)
LT_lowerSide_pLoc = addPlacementLoc(pGrp, 'LT_lowerSide_lip', lowerPos, 1)
attachPlacerToLoopCurve(LT_upperSide_pLoc, crv, upperId)
attachPlacerToLoopCurve(LT_lowerSide_pLoc, crv, lowerId)
orientPlacerOnLoop(LT_upperSide_pLoc,
beforeObj=CT_upper_pLoc,
afterObj=LT_upperSneer_pLoc)
orientPlacerOnLoop(LT_upperSneer_pLoc,
beforeObj=LT_upperSide_pLoc,
afterObj=LT_upperPinch_pLoc)
orientPlacerOnLoop(LT_upperPinch_pLoc,
beforeObj=LT_upperSneer_pLoc,
afterObj=LT_corner_pLoc)
orientPlacerOnLoop(LT_corner_pLoc, beforeObj=LT_upperPinch_pLoc)
orientPlacerOnLoop(LT_lowerSide_pLoc,
beforeObj=CT_lower_pLoc,
afterObj=LT_lowerSneer_pLoc)
orientPlacerOnLoop(LT_lowerSneer_pLoc,
beforeObj=LT_lowerSide_pLoc,
afterObj=LT_lowerPinch_pLoc)
orientPlacerOnLoop(LT_lowerPinch_pLoc,
beforeObj=LT_lowerSneer_pLoc,
afterObj=LT_corner_pLoc)
def addMouthLoopPlacements(pGrp):
"""
"""
loop = [pm.PyNode(node) for node in pGrp.mouthLipsLoop.get()]
pm.select(loop, r=True)
mel.ConvertSelectionToVertices()
lipVerts = pm.ls(sl=True, fl=True)
# lips center
centerVerts = [vert for vert in lipVerts if vert.getPosition().x < 0.001 and vert.getPosition().x > -0.001]
positions = [vert.getPosition() for vert in centerVerts]
# see which position-y is higher
if positions[0].y > positions[1].y:
upperPos = positions[0]
lowerPos = positions[1]
else:
upperPos = positions[1]
lowerPos = positions[0]
pm.select(cl=True)
CT_upper_pLoc = addPlacementLoc(pGrp, "CT_upper_lip", upperPos, 1)
CT_lower_pLoc = addPlacementLoc(pGrp, "CT_lower_lip", lowerPos, 1)
# lips corner
# find left corner
cornerVert = max(lipVerts, key=lambda x: x.getPosition()[0])
cornerPos = cornerVert.getPosition()
LT_corner_pLoc = addPlacementLoc(pGrp, "LT_corner_lip", cornerPos, 1)
# add secondary controls to lips
loop = [pm.PyNode(node) for node in pGrp.mouthLipsLoop.get()]
pm.select(loop, r=True)
crv = pm.PyNode(pm.polyToCurve(form=1, degree=1, ch=False, n=pGrp + "_mouthLipLoopCrv")[0])
crv.v.set(False)
pGrp | crv
upPt = crv.closestPoint(upperPos)
lowPt = crv.closestPoint(lowerPos)
cnrPt = crv.closestPoint(cornerPos)
upperParam = crv.getParamAtPoint(upPt)
lowerParam = crv.getParamAtPoint(lowPt)
cornerParam = crv.getParamAtPoint(cnrPt)
attachPlacerToLoopCurve(CT_upper_pLoc, crv, upperParam)
attachPlacerToLoopCurve(CT_lower_pLoc, crv, lowerParam)
attachPlacerToLoopCurve(LT_corner_pLoc, crv, cornerParam)
totalParam = crv.spans.get()
sectionParam = totalParam / 16.0
# get pinch params by +/- sectionParam
params = [cornerParam + sectionParam, cornerParam - sectionParam]
params = [int(p) for p in params]
for _ in range(len(params)):
if params[_] < 0:
params[_] = totalParam + params[_]
print params
positions = [crv.getPointAtParam(p) for p in params]
# see which position-y is higher
if positions[0].y > positions[1].y:
upperPos = positions[0]
lowerPos = positions[1]
upperId = params[0]
lowerId = params[1]
else:
upperPos = positions[1]
lowerPos = positions[0]
upperId = params[1]
lowerId = params[0]
LT_upperPinch_pLoc = addPlacementLoc(pGrp, "LT_upperPinch_lip", upperPos, 1)
LT_lowerPinch_pLoc = addPlacementLoc(pGrp, "LT_lowerPinch_lip", lowerPos, 1)
attachPlacerToLoopCurve(LT_upperPinch_pLoc, crv, upperId)
attachPlacerToLoopCurve(LT_lowerPinch_pLoc, crv, lowerId)
# get sneer params by +/- 2 * sectionParam
params = [cornerParam + 2 * sectionParam, cornerParam - 2 * sectionParam]
params = [int(p) for p in params]
for _ in range(len(params)):
if params[_] < 0:
params[_] = totalParam + params[_]
print params
positions = [crv.getPointAtParam(p) for p in params]
# see which position-y is higher
if positions[0].y > positions[1].y:
upperPos = positions[0]
lowerPos = positions[1]
upperId = params[0]
lowerId = params[1]
else:
upperPos = positions[1]
lowerPos = positions[0]
upperId = params[1]
lowerId = params[0]
LT_upperSneer_pLoc = addPlacementLoc(pGrp, "LT_upperSneer_lip", upperPos, 1)
LT_lowerSneer_pLoc = addPlacementLoc(pGrp, "LT_lowerSneer_lip", lowerPos, 1)
attachPlacerToLoopCurve(LT_upperSneer_pLoc, crv, upperId)
attachPlacerToLoopCurve(LT_lowerSneer_pLoc, crv, lowerId)
# get side params by +/- 3 * sectionParam
params = [cornerParam + 3 * sectionParam, cornerParam - 3 * sectionParam]
params = [int(p) for p in params]
for _ in range(len(params)):
if params[_] < 0:
params[_] = totalParam + params[_]
print params
positions = [crv.getPointAtParam(p) for p in params]
# see which position-y is higher
if positions[0].y > positions[1].y:
upperPos = positions[0]
lowerPos = positions[1]
upperId = params[0]
lowerId = params[1]
else:
upperPos = positions[1]
lowerPos = positions[0]
upperId = params[1]
lowerId = params[0]
LT_upperSide_pLoc = addPlacementLoc(pGrp, "LT_upperSide_lip", upperPos, 1)
LT_lowerSide_pLoc = addPlacementLoc(pGrp, "LT_lowerSide_lip", lowerPos, 1)
attachPlacerToLoopCurve(LT_upperSide_pLoc, crv, upperId)
attachPlacerToLoopCurve(LT_lowerSide_pLoc, crv, lowerId)
orientPlacerOnLoop(LT_upperSide_pLoc, beforeObj=CT_upper_pLoc, afterObj=LT_upperSneer_pLoc)
orientPlacerOnLoop(LT_upperSneer_pLoc, beforeObj=LT_upperSide_pLoc, afterObj=LT_upperPinch_pLoc)
orientPlacerOnLoop(LT_upperPinch_pLoc, beforeObj=LT_upperSneer_pLoc, afterObj=LT_corner_pLoc)
orientPlacerOnLoop(LT_corner_pLoc, beforeObj=LT_upperPinch_pLoc)
orientPlacerOnLoop(LT_lowerSide_pLoc, beforeObj=CT_lower_pLoc, afterObj=LT_lowerSneer_pLoc)
orientPlacerOnLoop(LT_lowerSneer_pLoc, beforeObj=LT_lowerSide_pLoc, afterObj=LT_lowerPinch_pLoc)
orientPlacerOnLoop(LT_lowerPinch_pLoc, beforeObj=LT_lowerSneer_pLoc, afterObj=LT_corner_pLoc)
def edgeToJnt( edges=None, reverse=False, dispCV=False, dispAxis=False, createCurve=False):
'''
update : 2015-04-27
'''
if not edges:
edges = pm.filterExpand( sm=32 )
if not edges:
raise
# recast
# edges = [ pm.PyNode(edge) for edge in edges ] # 이렇게 하면 파이멜이 엣지를 제대로 처리 못함 선택한걸로 해야 할듯
pm.select(edges)
edges = pm.selected()
# 엣지 이름에서 폴리곤 이름 알아옴
mesh = pm.PyNode( edges[0].name().split('.')[0] )
# 폴리곤에서 커브 추출
crvFromPoly = pm.polyToCurve( form=0, degree=1, ch=False )[0]
curve = pm.PyNode( crvFromPoly )
curve.dispCV.set(dispCV)
# cv좌표 얻어옴.
points = curve.getCVs()
# 좌표에 조인트 생성
pm.select(cl=True)
jnts = []
for point in points:
jnt = pm.joint( p=point )
jnt.displayLocalAxis.set( dispAxis )
jnts.append( jnt )
# 뒤집기
if reverse:
# 조인트 뒤집음
pm.select( jnts[-1] )
pm.mel.RerootSkeleton()
pm.reverseCurve( curve, replaceOriginal=True, ch=False )
jnts.reverse()
# 조인트 오리엔트 조정
for jnt in jnts:
parentJnt = jnt.getParent()
if parentJnt:
# point에서 가장 가까운 Vertex의 Normal을 up으로 설정
pos = parentJnt.getTranslation( ws=True)
vtx = getClosestVertexOnMesh( mesh, pos )
pos = vtx.getPosition( space='world' )
norm = vtx.getNormal()
upPos = pos + norm
upLoc = pm.spaceLocator(n='parentJnt_upLoc#')
upLoc.t.set( upPos )
jntOrient( [parentJnt, jnt, upLoc], aimAxis='x', worldAimVector='x', upAxis='y', worldUpVector='y' )
#pm.joint( parentJnt, edit=True, zso=True, oj='xyz', sao='yup' )
pm.delete( upLoc ) # 버텍스의 위치를 확인하고 싶으면 이 구문을 주석 처리할것
pm.select( jnt )
# 끝 조인트 오리엔트 조정
pm.joint( jnts[-1], edit=True, oj='none' )
if not createCurve:
pm.delete( curve )
return jnts
import autoRig3.tools.blendShapeTools as split
sel = pm.ls(sl=True)
neutro = sel.pop(-1)
for obj in sel:
split.splitSidesAPI(obj, neutro, falloff=2)
## TRANSFER UVs
sel = pm.ls(sl=True)
UVtools.transferUVRigged(source=sel[0], target=sel[1])
#CLEAN
import autoRig3.tools.cleanerTools as cleanner
import pymel.core as pm
objs= pm.ls(sl=True)
for obj in objs:
cleanner.deleteIntermediateShapes(obj)
cleanner.freezeVertices(obj)
cleanner.deleteHistory(obj)
#CONNECT
objs = pm.ls(sl=True)
meshConnect.connectSources(source=objs[0], target=objs[1], toFinal=False)
upCrv = pm.polyToCurve(form=2, degree=1, n='UpperCrv', ch=False)[0]
x = pm.rebuildCurve(upCrv, rt=3, rpo=True, d=3, end=1, kr=0, kcp=1, kep=0, kt=0, s=25, tol=0.01, ch=False)[0]
