def MakePointOnSurfaceNd(surface):
mc.select ("mesh_*MouthLip")
lx_mesh = mc.ls(sl=1)
mc.select ("snd_mouthLip*")
lx_sndJnt = mc.ls(sl=True )
lx_node ,lx_locGrp=[],[]
for lx_i in lx_sndJnt :
lx_temp=mc.xform(lx_i,q=1,ws =1,t=1)
lx_locN= "loc_"+lx_i
mc.spaceLocator(n=lx_locN,a=1,p=(lx_temp[0],lx_temp[1],lx_temp[2]))
lx_locGrp.append(lx_locN)
lx_null = 'grp_'+lx_i+'02'
mc.group(n=lx_null,em =1)
mc.toggle (lx_null,la=1)
mc.parent (lx_null ,('grp_'+lx_i+'01'))
mc.parent (('grp_'+lx_i+'03'),lx_null)
nd=mc.pointOnSurface(lx_mesh,ch=True )
#lx_node.insert(1,nd);
ndName = "pntNd_"+lx_i
mc.rename(nd,ndName )
mc.connectAttr ((ndName +".position"),('grp_'+lx_i+'02.translate'))
mc.setAttr (('grp_'+lx_i+'01.translate'),0,0,0,type ="double3")
mc.setAttr (('grp_'+lx_i+'03.translate'),0,0,0,type="double3")
mc.xform (('grp_'+lx_i+'01'),cp=True)
mc.select(cl=1)
mc.select(lx_locGrp )
mc.group (n="grp_locMouthLip01")
def splitJoint ():
_newBoneNum = cmds.intSlider ('boneNum', query = 1, value = 1)
_bone = cmds.ls (selection = 1, long = 1)
_childJoint = cmds.listRelatives (children = 1)
if (len (_bone) > 0) and (type(_childJoint) is not NoneType) \
and (cmds.nodeType(_bone[0]) == 'joint') and (cmds.nodeType(_childJoint) == 'joint'):
_childTranslateX = cmds.getAttr ( _childJoint[0] + '.translateX' )
_childTranslateY = cmds.getAttr ( _childJoint[0] + '.translateY' )
_childTranslateZ = cmds.getAttr ( _childJoint[0] + '.translateZ' )
_newX = _childTranslateX / ( _newBoneNum + 1.0 )
_newY = _childTranslateY / ( _newBoneNum + 1.0 )
_newZ = _childTranslateZ / ( _newBoneNum + 1.0 )
for _k in range ( _newBoneNum):
_bone = cmds.insertJoint ( _bone )
cmds.toggle (localAxis =1)
cmds.xform (_bone + '.scalePivot', _bone + '.rotatePivot',
relative = 1, objectSpace = 1, translation = ( _newX, _newY, _newZ ) )
for _k in range ( _newBoneNum ): cmds.pickWalk ( direction = 'up' )
else: raiseWarning ( 'select a bone! You can do it!' )
def splitJoint (): _newBoneNum = cmds.intSlider ( 'boneNum', query = 1, value = 1 ) _bone = cmds.ls ( selection = 1, long = 1 ) _childJoint = cmds.listRelatives ( children = 1 ) if len(_bone) > 0: if type(_childJoint) is not NoneType: # print; print; print '>>> SO FAR SO GOOD'; print # <<< DEBUG ONLY LINE, CAN BE DELETED <<< ########## _bone = _bone[0] _childJoint = _childJoint[0] _childTranslateX = cmds.getAttr ( _childJoint + '.translateX' ) _childTranslateY = cmds.getAttr ( _childJoint + '.translateY' ) _childTranslateZ = cmds.getAttr ( _childJoint + '.translateZ' ) _newX = _childTranslateX / ( _newBoneNum + 1.0 ) _newY = _childTranslateY / ( _newBoneNum + 1.0 ) _newZ = _childTranslateZ / ( _newBoneNum + 1.0 ) for _k in range ( _newBoneNum ): _bone = cmds.insertJoint ( _bone ) cmds.toggle ( localAxis = 1 ) cmds.xform ( _bone + '.scalePivot', _bone + '.rotatePivot', relative = 1, objectSpace = 1, translation = ( _newX, _newY, _newZ ) ) for _k in range ( _newBoneNum ): cmds.pickWalk ( direction = 'up' ) else: raiseWarning ( 'select the bone, not a single joint' ) else: raiseWarning ( 'select the bone' )
def createDebugVisualizerPlane(plane, position = None, name = None):
if(plane is None):
return None
#TODO: for now this creates a plane that ends up affecting the scene history, so undo/redo actions end up recreating the plane
#figure out how to draw this plane without this happening
debugPlane = cmds.polyPlane(name = name if name else "debugPlane", width=100, height=100, axis=[plane.normal().x, plane.normal().y, plane.normal().z], constructionHistory=False)
cmds.toggle(debugPlane, state=True, template=True) #make plane unselectable and undeletable so users can't accidentally delete it and break things
createPos = om.MVector()
if(position is None):
if(plane.normal().x != 0):
#automatically compute a position where we find x for if y and z were 0
createPos = om.MVector(-plane.distance() / plane.normal().x, 0, 0)
elif(plane.normal().y != 0):
#automatically compute a position where we find y for if x and z were 0
createPos = om.MVector(0, -plane.distance() / plane.normal().y, 0)
elif(plane.normal().z != 0):
#automatically compute a position where we find z for if x and y were 0
createPos = om.MVector(0, 0, -plane.distance() / plane.normal().z)
else:
print("Invalid plane normal, all components are 0")
else:
createPos = position
cmds.xform(debugPlane, absolute=True, worldSpace=True, translation=[createPos.x, createPos.y, createPos.z])
return debugPlane
def postProcessControl ( _control, _function, _controlled ): # <<< string, string, list
lockHideAttributes ( _control )
if (cmds.objExists('anim_control_set') == False): cmds.createNode('objectSet',name='anim_control_set',skipSelect=True)
cmds.sets ( _control, addElement = 'anim_control_set' )
cmds.toggle ( localAxis = 1 )
if len ( _controlled ) == 0:
_control = cmds.rename ( '_' + _function + '_control' )
_control = cmds.group ( world = 1, name = '_' + _function + '_control_offSet' )
cmds.move ( 0, 0, 0, _control + '.rotatePivot', _control + '.scalePivot' )
lockHideAttributes ( _control )
else:
_k = _controlled[0].rfind ( '|' )
_control = _controlled[0][_k+1:]
cmds.rename ( _control + '_' + _function + '_control' )
_control = cmds.group ( world = 1, name = _control + '_' + _function + '_control_offSet' )
cmds.move ( 0, 0, 0, _control + '.rotatePivot', _control + '.scalePivot' )
lockHideAttributes ( _control )
cmds.select ( _controlled[0], toggle = True )
cmds.parent ()
cmds.xform ( translation = ( 0, 0, 0 ), rotation = ( 0, 0, 0 ) )
cmds.parent ( world = 1 )
cmds.pickWalk ( direction = "down" )
def transformFromOutputMatrix(curveMatrix=None,
transformType='locator',
showLocalAxis=True):
"""create a connected transform for each output.outputMatrix"""
curveMatrix = (mc.ls(curveMatrix, type='prCurveMatrix')
or mc.ls(sl=True, type='prCurveMatrix') or [None])[0]
transforms = []
for index in getConnectedInputIndices(curveMatrix):
for x in range(mc.getAttr('{0}.counter'.format(curveMatrix))):
decomposeMat = mc.createNode('decomposeMatrix')
decomposeMat = mc.rename(
decomposeMat, '{0}_output{1}_matrix{2}_decomposeMatrix'.format(
curveMatrix, index, x))
mc.connectAttr(
'{0}.output[{1}].outputMatrix[{2}]'.format(
curveMatrix, index, x),
'{0}.inputMatrix'.format(decomposeMat))
if transformType:
transform = mc.createNode(transformType)
if mc.ls(transform, type='shape'):
transform = mc.listRelatives(transform, parent=True)[0]
mc.connectAttr('{0}.outputTranslate'.format(decomposeMat),
'{0}.translate'.format(transform))
mc.connectAttr('{0}.outputRotate'.format(decomposeMat),
'{0}.rotate'.format(transform))
transform = mc.rename(
transform, '{0}_output{1}_matrix{2}_{3}'.format(
curveMatrix, index, x, transformType))
transforms.append(transform)
mc.toggle(transforms, localAxis=showLocalAxis)
return transforms
def startUpLocator_cmd(*args):
makeRoot = cmds.spaceLocator(n='rootJoint_loc')
cmds.toggle(la=True)
cmds.move(1, 0, 0)
makeEnd = cmds.spaceLocator(n='endJoint_loc')
cmds.toggle(la=True)
cmds.move(-1, 0, 0)
def createLoc_cmd(*args):
locatorList = []
updatedJntName = cmds.textFieldGrp('inputName_grp', q=True, tx=True)
updatedInptVal = (cmds.intFieldGrp('inputValue_grp', q=True,
value1=True)) - 2
facingQuery = cmds.radioButtonGrp('inputFacing_grp', q=True, sl=True)
#determines facing angle from radiobox
if facingQuery == 1:
boxValue = [1, 0, 0]
invertBoxVal = [-1, 0, 0]
elif facingQuery == 2:
boxValue = [0, 1, 0]
invertBoxVal = [0, -1, 0]
elif facingQuery == 3:
boxValue = [0, 0, 1]
invertBoxVal = [0, 0, -1]
#create inbetween locators and turn on local rotation axis
renameRoot = cmds.rename('rootJoint_loc', updatedJntName + '_loc01')
locatorList.append(renameRoot)
renameEnd = cmds.rename('endJoint_loc',
updatedJntName + '_loc%02i' % (updatedInptVal + 2))
for i in range(updatedInptVal):
locTransOffset = i * 2
makeLoc = cmds.spaceLocator(n=updatedJntName + '_loc%02i' % (i + 2),
a=True)
locatorList.append(cmds.ls(sl=True)[0])
cmds.select(makeLoc)
cmds.toggle(la=True)
locatorList.append(renameEnd)
#simple math formula to determine the weighting to be used during the point constraint process
weightOffset = []
for i in range(updatedInptVal + 2):
calc = i / (updatedInptVal + 1.0)
weightOffset.append(calc)
#aim and point constraint creation, we will remove the point constraint after we create it
for i in range(updatedInptVal + 1):
try:
cmds.pointConstraint(locatorList[-1],
updatedJntName + '_loc%02i' % (i + 1),
mo=False,
w=weightOffset[i])
cmds.pointConstraint(locatorList[0],
updatedJntName + '_loc%02i' % (i + 1),
mo=False,
w=(1 - weightOffset[i]))
cmds.pointConstraint(locatorList[0],
locatorList[-1],
updatedJntName + '_loc%02i' % (i + 1),
e=True,
rm=True)
cmds.aimConstraint(updatedJntName + '_loc%02i' % (i + 2),
updatedJntName + '_loc%02i' % (i + 1),
aim=boxValue)
except ValueError as ve:
print ve
except RuntimeError as re:
print re
cmds.aimConstraint(locatorList[-2], locatorList[-1], aim=invertBoxVal)
cmds.aimConstraint(locatorList[1], locatorList[0], aim=boxValue)
stdout.write("Place locators then click 'create joint chain'\n")
def createLoc_cmd(*args):
locatorList = []
updatedJntName = cmds.textFieldGrp('inputName_grp', q=True, tx=True)
updatedInptVal = cmds.intFieldGrp('inputValue_grp', q=True, value1=True)
facingQuery = cmds.radioButtonGrp('inputFacing_grp', q=True, sl=True)
#determines facing angle from radiobox
if facingQuery == 1:
boxValue = [1, 0, 0]
invertBoxVal = [-1, 0, 0]
elif facingQuery == 2:
boxValue = [0, 1, 0]
invertBoxVal = [0, -1, 0]
elif facingQuery == 3:
boxValue = [0, 0, 1]
invertBoxVal = [0, 0, -1]
#create locators and turn on local rotation axis
for i in range(updatedInptVal):
locTransOffset = i * 2
makeLoc = cmds.spaceLocator(n=updatedJntName + '_loc%02i' % (i + 1),
a=True)
locatorList.append(cmds.ls(sl=True)[0])
cmds.move(locTransOffset, 0, 0, r=True)
cmds.select(makeLoc)
cmds.toggle(la=True)
#aim constraint creation
for i in range(updatedInptVal):
try:
cmds.aimConstraint(updatedJntName + '_loc%02i' % (i + 2),
updatedJntName + '_loc%02i' % (i + 1),
aim=boxValue)
except ValueError as ve:
print ve
cmds.aimConstraint(locatorList[-2], locatorList[-1], aim=invertBoxVal)
stdout.write("Place locators then click 'create joint chain'")
def create_ik(self):
"""Ik spline"""
# Create curve
tmp_curve = curve.create_from_nodes(self.joints, name=name.set_suffix(self.name, 'ikCrv'), degree=3)
self.curve = curve.rebuild_curve(tmp_curve, 3)[0]
start_joint, end_joint = self.ik_joints[0], self.ik_joints[-1]
logger.info("Creating Ik using nodes: %s" % self.joints)
self.ik, self.effector = cmds.ikHandle(name=name.set_suffix(self.name, 'ikh'), sj=start_joint, ee=end_joint, curve=self.curve, createCurve=False, sol="ikSplineSolver", ns=3)
# Add to setups
self.setups.extend([self.ik, self.curve])
# Set attrs
cmds.setAttr("%s.dTwistControlEnable" % self.ik, 1)
cmds.setAttr("%s.dWorldUpAxis" % self.ik, 1)
cmds.setAttr("%s.dWorldUpType" % self.ik, 4)
cmds.setAttr("%s.dWorldUpVector" % self.ik, 1.0, 0.0, 0.0, type="float3")
cmds.setAttr("%s.dWorldUpVectorEnd" % self.ik, 1.0, 0.0, 0.0, type="float3")
# Turn on cvs
cmds.select(self.curve, r=True)
cmds.toggle(cv=True)
# Create clusters
clusters = OrderedDict()
clusters['bot'] = cmds.cluster(["%s.cv[0]" % self.curve, "%s.cv[1]" % self.curve])[1]
clusters['mid'] = cmds.cluster(["%s.cv[2]" % self.curve, "%s.cv[3]" % self.curve])[1]
clusters['top'] = cmds.cluster(["%s.cv[4]" % self.curve, "%s.cv[5]" % self.curve])[1]
xform.match_pivot(start_joint, clusters['bot'])
xform.match_pivot(end_joint, clusters['top'])
self.clusters = clusters
def AxisOn(self, *_):
sels = cmds.ls(sl=True)
selsNum = len(sels)
for i in range(selsNum):
cmds.toggle(sels[i], localAxis=True)
cmds.setAttr(sels[i] + ".displayLocalAxis", k=True)
cmds.setAttr(sels[i] + ".jointOrientX", k=True)
cmds.setAttr(sels[i] + ".jointOrientY", k=True)
cmds.setAttr(sels[i] + ".jointOrientZ", k=True)
def Toggled(self):
sels = cmds.ls(selection=True)
cmds.toggle(la=True)
for s in sels:
cmds.setAttr(s + ".jointOrientX", cb=True)
cmds.setAttr(s + ".jointOrientY", cb=True)
cmds.setAttr(s + ".jointOrientZ", cb=True)
cmds.setAttr(s + ".displayLocalAxis", cb=True)
def toggle_attr():
sels = cmds.ls(sl=True)
for i in sels:
cmds.setAttr(i + ".displayLocalAxis", k=True)
cmds.setAttr(i + ".jointOrientX", k=True)
cmds.setAttr(i + ".jointOrientY", k=True)
cmds.setAttr(i + ".jointOrientZ", k=True)
cmds.toggle(i, la=True)
def upVecVisCurveSet(self,startName,endName): # make upVec vis curve
crvName = cmds.curve( d=1, p=[(0,0,0),(0,0,0)], name = startName.replace( startName.split('_')[-1], 'CRV' ) )
self.upVecVisCrv.append(crvName)
curveShape = cmds.listRelatives( crvName, s=True )[0]
curveShapeName = cmds.rename( curveShape, '%sShape' % crvName )
cvNum = cmds.getAttr( '%s.spans' % curveShapeName ) + cmds.getAttr( '%s.degree' % curveShapeName )
# Connection Node
cmds.connectAttr( '%s.worldPosition[0]' % startName, '%s.controlPoints[0]' % crvName )
cmds.connectAttr( '%s.worldPosition[0]' % endName, '%s.controlPoints[1]' % crvName )
cmds.connectAttr( 'C_IK_body_upVec_CON.upVecVis' , '%s.visibility' %crvName)
cmds.toggle(crvName,template=True)
return crvName
def doToggleLocalAxis(objs, showOrHide):
operateOn = cmds.checkBox("chbAllOrSelected", q=True, v=True)
if operateOn == 1:
# Hierarchy
cmds.select(hi=True)
objs = cmds.ls(sl=1)
else:
# Selected
objs = cmds.ls(sl=1)
for obj in objs:
cmds.toggle(obj, localAxis=True, state=showOrHide)
cmds.select(objs)
def toggleLRAVisibility():
"""Toggle the visibility of local rotation axes.
Args:
None.
Returns:
None.
Raises:
Logs warning if nothing is selected.
"""
sel = cmds.ls(sl=1)
if len(sel) < 1:
LOG.warning('Nothing is selected.')
return
for jnt in sel:
cmds.toggle(jnt, localAxis=1)
def createDecomposeMatrixFromOutputMatrix(curveFrame=None, createTransformType='locator', toggleLocalAxis=True):
mc.getAttr('{0}.outputMatrix[0]'.format(curveFrame))
sel_list = om.MSelectionList()
sel_list.add('{0}.outputMatrix'.format(curveFrame))
transforms = []
for x in range(sel_list.getPlug(0).numElements()):
decomposeMatrix = mc.createNode('decomposeMatrix')
decomposeMatrix = mc.rename(decomposeMatrix, '{0}_{1}_decomposeMatrix'.format(curveFrame, x))
mc.connectAttr('{0}.outputMatrix[{1}]'.format(curveFrame, x), '{0}.inputMatrix'.format(decomposeMatrix))
if createTransformType:
node = mc.createNode(createTransformType)
if mc.ls(node, type='shape'):
node = mc.listRelatives(node, parent=True)[0]
mc.connectAttr('{0}.outputTranslate'.format(decomposeMatrix), '{0}.translate'.format(node))
mc.connectAttr('{0}.outputRotate'.format(decomposeMatrix), '{0}.rotate'.format(node))
transforms.append(node)
if toggleLocalAxis:
mc.toggle(transforms, localAxis=True)
return transforms
def toggleAxisDisplay():
sel = cmds.ls(sl= True)[0]
toggleList = cmds.listRelatives(sel, ad = True, typ = "joint")
if toggleList:
toggleList.append(sel)
else:
toggleList = sel
query = cmds.toggle(sel, query = True, localAxis = True)
if query == False:
for item in toggleList:
cmds.setAttr('%s.jointOrientX'%item, lock = False, keyable = True)
cmds.setAttr('%s.jointOrientY'%item, lock = False, keyable = True)
cmds.setAttr('%s.jointOrientZ'%item, lock = False, keyable = True)
cmds.toggle(item, localAxis = True, state = True)
else:
for item in toggleList:
cmds.setAttr('%s.jointOrientX'%item, keyable = False)
cmds.setAttr('%s.jointOrientY'%item, keyable = False)
cmds.setAttr('%s.jointOrientZ'%item, keyable = False)
cmds.toggle(item, localAxis = True, state = False)
def createDebugVisualizerPlane(plane, position=None, name=None):
if (plane is None):
return None
#TODO: for now this creates a plane that ends up affecting the scene history, so undo/redo actions end up recreating the plane
#figure out how to draw this plane without this happening
debugPlane = cmds.polyPlane(
name=name if name else "debugPlane",
width=100,
height=100,
axis=[plane.normal().x,
plane.normal().y,
plane.normal().z],
constructionHistory=False)
cmds.toggle(
debugPlane, state=True, template=True
) #make plane unselectable and undeletable so users can't accidentally delete it and break things
createPos = om.MVector()
if (position is None):
if (plane.normal().x != 0):
#automatically compute a position where we find x for if y and z were 0
createPos = om.MVector(-plane.distance() / plane.normal().x, 0, 0)
elif (plane.normal().y != 0):
#automatically compute a position where we find y for if x and z were 0
createPos = om.MVector(0, -plane.distance() / plane.normal().y, 0)
elif (plane.normal().z != 0):
#automatically compute a position where we find z for if x and y were 0
createPos = om.MVector(0, 0, -plane.distance() / plane.normal().z)
else:
print("Invalid plane normal, all components are 0")
else:
createPos = position
cmds.xform(debugPlane,
absolute=True,
worldSpace=True,
translation=[createPos.x, createPos.y, createPos.z])
return debugPlane
def createLoc_cmd(*args):
updatedJntName=cmds.textFieldGrp('inputName_grp',q=True,tx=True)
updatedInptVal=cmds.intFieldGrp('inputValue_grp',q=True,value1=True)
facingQuery=cmds.radioButtonGrp('inputFacing_grp',q=True,sl=True)
#determines facing angle from radiobox
if facingQuery==1:
boxValue=[1,0,0]
elif facingQuery==2:
boxValue=[0,1,0]
elif facingQuery==3:
boxValue=[0,0,1]
#create locators and turn on local rotation axis
for i in range(updatedInptVal):
locTransOffset=i*2
makeLoc=cmds.spaceLocator(n=updatedJntName+'_loc%02i'%(i+1),a=True)
cmds.move(locTransOffset,0,0,r=True)
cmds.select(makeLoc)
cmds.toggle(la=True)
#aim constraint creation
for i in range (updatedInptVal):
try:
cmds.aimConstraint(updatedJntName+'_loc%02i'%(i+2),updatedJntName+'_loc%02i'%(i+1),aim=boxValue)
except ValueError as ve:
print ve
def toggle_display_cvs(*args):
cmds.toggle(cv=True)
import maya.cmds as cmds
sels = cmds.ls(sl=True)
for i in sels:
cmds.toggle(i, la=True)
cmds.setAttr(i + '.displayLocalAxis', k=True)
cmds.setAttr(i + '.jointOrientX', k=True)
cmds.setAttr(i + '.jointOrientY', k=True)
cmds.setAttr(i + '.jointOrientZ', k=True)
def setupRibbon ():
# >>> get ribbon plane, plane shape, V spans, follicle position distance
_planeShape = cmds.listRelatives(shapes=True)[0] # <<< get ribbon NURBS plane Shape
_k = _planeShape.rfind('|')
_planeShape = _planeShape[_k+1:] # <<< get ribbon NURBS plane nice name
_spansV=cmds.getAttr(_planeShape+'.spansV') # <<< get ribbon NURBS plane V spans
_posV = (1.0/_spansV)/2 # <<< follicle start position on plane in V
_spineJoint_ = [] # <<< spine joint list
_folli_ = [] # <<< follicle list
# >>> create & position follicle/Vspan, create & position parented-joint/follicle
for _k in range(_spansV):
_follicleShape = cmds.createNode ('follicle')
_follicle = cmds.listRelatives(parent=True)
_follicle = _follicle[0]
_folli_.append(_follicle)
_spineJoint_.append (cmds.createNode('joint', parent=_follicle))
cmds.toggle (localAxis=True)
cmds.connectAttr(_planeShape+'.worldMatrix[0]', _follicleShape+'.inputWorldMatrix', force=True)
cmds.connectAttr(_planeShape+'.local', _follicleShape+'.inputSurface', force=True)
cmds.connectAttr(_follicle+'.outTranslate', _follicle+'.translate', force=True)
cmds.connectAttr(_follicle+'.outRotate', _follicle+'.rotate', force=True)
cmds.setAttr(_follicleShape+'.parameterU', 0.5)
cmds.setAttr(_follicleShape+'.parameterV', _posV)
_posV = _posV+(1.0/_spansV) # <<< follicle position
# >>> create plane skin joints
_skinJoint_=[] # <<< plane skin joints list
_joint=cmds.createNode('joint')
_skinJoint_.append(_joint)
cmds.xform(translation=(2,3,0))
cmds.setAttr(_joint+'.jointOrient', 0,0,-90)
cmds.toggle (localAxis=True)
_joint=cmds.createNode('joint', parent=_joint)
cmds.xform(translation=(0.5,0,0))
cmds.setAttr(_joint+'.jointOrient', 0,0,90)
cmds.toggle (localAxis=True)
_joint=cmds.createNode('joint')
_skinJoint_.append(_joint)
cmds.xform(translation=(2,-3,0))
cmds.setAttr(_joint+'.jointOrient', 0,0,90)
cmds.toggle (localAxis=True)
_joint=cmds.createNode('joint', parent=_joint)
cmds.xform(translation=(0.5,0,0))
cmds.setAttr(_joint+'.jointOrient', 0,0,-90)
cmds.toggle (localAxis=True)
_joint=cmds.createNode('joint')
_skinJoint_.append(_joint)
cmds.xform(translation=(2,0,0))
cmds.toggle (localAxis=True)
# >>> create & parent locator-groups - position, aim, upVector + 1 offSet
_locatorPos_ = [] # <<< position locator list
_locatorAim_ = [] # <<< aim locator list
_locatorUp_ = [] # <<< upVector locator list
print _joint
_joint = 0 # <<< position locator list start, middle, end joint ID in _spineJoint_
_step = len(_spineJoint_)/2
for _l in range(3): # <<< create position locators
_locator=cmds.createNode('locator')
cmds.setAttr(_locator+'.localScaleX', 0.35)
cmds.setAttr(_locator+'.localScaleY', 0.35)
cmds.setAttr(_locator+'.localScaleZ', 0.35)
_locator=cmds.listRelatives(parent=True)
_locatorPos_.append(_locator[0])
cmds.toggle (_locator[0], localAxis=True)
_pos=cmds.xform (_spineJoint_[_joint], query=True, worldSpace=True, translation=True)
print _spineJoint_
cmds.xform (_locatorPos_[_l], absolute=True, worldSpace=True, translation=_pos)
_joint = _joint+_step
for _k in range(2):
_locator=cmds.createNode('locator')# <<< create aim & up locators
cmds.setAttr(_locator+'.localScaleX', 0.2)
cmds.setAttr(_locator+'.localScaleY', 0.2)
cmds.setAttr(_locator+'.localScaleZ', 0.2)
_locatorTrans=cmds.listRelatives(parent=True)
cmds.toggle (_locatorTrans[0], localAxis=True)
if _k == 0:
_locatorAim_.append(_locatorTrans[0])
else:
_locatorUp_.append(_locatorTrans[0])
cmds.pickWalk(direction='up')
cmds.select(_locatorPos_[_l], add=True)
cmds.parent()
cmds.select (_locator, replace=True)
cmds.pickWalk (direction='up')
if _k==1:
cmds.xform (objectSpace=True, translation=(2,0,0))
else:
cmds.xform (objectSpace=True, translation=(0,0,0))
# >>> create middle offset locator
cmds.select (_locatorPos_[1], replace=True)
cmds.pickWalk(direction='down')
_locator=cmds.pickWalk(direction='right')
_locator=_locator[0]
cmds.createNode('locator') # <<< create middle offset locator
_midOffSet=cmds.pickWalk(direction='up')
_midOffSet=_midOffSet[0]
cmds.setAttr('.localScaleX', 0.2)
cmds.setAttr('.localScaleY', 0.2)
cmds.setAttr('.localScaleZ', 0.2)
cmds.pickWalk(direction='up')
cmds.toggle (localAxis=True)
cmds.select (_locator, add=True)
cmds.parent ()
cmds.xform (translation=(0,0,0))
# >>> constrain locators
cmds.pointConstraint (_locatorPos_[0], _locatorPos_[2], _locatorPos_[1]) # <<< middle pos constrain
cmds.aimConstraint (_locatorPos_[2], _locatorAim_[0], aimVector=(0,1,0),
upVector=(1,0,0), worldUpType='object', worldUpObject=_locatorUp_[0])
cmds.aimConstraint (_locatorPos_[0], _locatorAim_[2], aimVector=(0,-1,0),
upVector=(1,0,0), worldUpType='object', worldUpObject=_locatorUp_[2])
cmds.aimConstraint (_locatorPos_[2], _locatorAim_[1], aimVector=(0,1,0),
upVector=(1,0,0), worldUpType='object', worldUpObject=_locatorUp_[1])
cmds.pointConstraint (_locatorUp_[0], _locatorUp_[2], _locatorUp_[1])
# >>> parent & position skin-joints, position locators
cmds.parent(_skinJoint_[0], _locatorAim_[2])
cmds.xform(translation=(0,0,0))
cmds.parent(_skinJoint_[1], _locatorAim_[0])
cmds.xform(translation=(0,0,0))
cmds.parent(_skinJoint_[2], _midOffSet)
cmds.xform(translation=(0,0,0))
_posV = cmds.xform (_folli_[0], query=True, translation=True)
_k = cmds.xform (_folli_[1], query=True, translation=True)
_step = _posV[1]-_k[1]
_step = _step/2
cmds.xform(_locatorPos_[0], relative=True, translation=(0,_step,0))
cmds.xform(_locatorPos_[2], relative=True, translation=(0,-_step,0))
# >>> select palne & skinJoint for skinning
cmds.select(_skinJoint_)
cmds.select(_planeShape, add=True)
mm.eval('warning "..:: u can bind skin now ::..";')
def toggleDispl(*args):
cmds.toggle(cv=True)
# #############################################################################
def _release(self):
# In timeslider is not selected, use the full frame range
self.delete_curve(curve=constants.SKETCH_CURVE)
self.curve = curves.create_curve_from_positions(
constants.SKETCH_CURVE, self.points_list)
# No need to recalculate if only using one frame. Also may cause problems if the curve is too small
steps = len(self.nodes)
if not steps == 1:
cmds.smoothCurve("{}.cv[*]".format(self.curve), s=100)
cmds.smoothCurve("{}.cv[*]".format(self.curve), s=100)
cmds.smoothCurve("{}.cv[*]".format(self.curve), s=100)
dag = maya_api_utils.get_dag_path(self.curve)
dag.extendToShape()
# TODO: Remove self
self.fn_curve = om.MFnNurbsCurve(dag)
# TODO: Smooth slider
# TODO: Blend slider
# debug
locs = cmds.ls("locator*")
if locs:
try:
cmds.delete(locs)
except:
pass
locs = []
## Apply positions along frames
# if self.translate_follow:
point_list = curves.get_points_along_curve(self.fn_curve,
samples=steps)
for i, point in enumerate(point_list):
if self.translate_follow:
cmds.xform(self.nodes[i],
translation=(point.x, point.y, point.z))
# Debug
locs.append(cmds.spaceLocator())
cmds.xform(locs[i], translation=(point.x, point.y, point.z))
cmds.toggle(locs[i], localAxis=True)
if self.orient_follow:
# TODO: Sample rotateOrder per node
rotate_order = cmds.getAttr("{}.rotateOrder".format(self.nodes[0]))
camera_aim = self._get_camera_vector(self.fn_curve)
rotation_list = curves.get_orient_along_curve(
self.fn_curve,
samples=steps,
temp_normal=camera_aim,
rotate_order=rotate_order)
for i, rotation in enumerate(rotation_list):
rotation_degrees = [
math.degrees(axis)
for axis in (rotation.x, rotation.y, rotation.z)
]
# cmds.xform(self.nodes[i], rotation=rotation_degrees)
# Debug
cmds.xform(locs[i], rotation=rotation_degrees)
cmds.setAttr("{}.localScaleX".format(locs[i][0]), 0.1)
cmds.setAttr("{}.localScaleY".format(locs[i][0]), 0.1)
cmds.setAttr("{}.localScaleZ".format(locs[i][0]), 0.1)
# Testy
cmds.xform(self.nodes[i], rotation=[0, 0, 0])
cmds.parent(locs[i], self.nodes[i])
loc_rot = cmds.xform(locs[i], q=True, rotation=True, os=True)
cmds.parent(locs[i], world=True)
cmds.xform(self.nodes[i], rotation=loc_rot)
cmds.delete(locs[i])
# loc_mat = om2.MMatrix(cmds.xform(locs[i], q=True,ws=True, matrix=True))
# inverse_mat = om2.MMatrix(cmds.xform(self.nodes[i], q=True,ws=True, matrix=True)).inverse()
# final_mat = om2.MTransformationMatrix(loc_mat*inverse_mat)
# rotation = final_mat.rotation()
# rotation_degrees = [math.degrees(axis) for axis in (rotation.x, rotation.y, rotation.z)]
# cmds.xform(self.nodes[i], rotation=rotation_degrees)
#
self.delete_curve()
# Go to the last frame
cmds.select(self.nodes)
def VK_system(num_ctr=1,num_jt=10,fk=True):
"""
final assembly of the entire system
"""
lock_attr = lambda node,b:[cmds.setAttr('%s.%s%s' %(node,a,aa),l=b) for a in 'trs' for aa in 'xyz']
fk_hide_attr = lambda node,b:[cmds.setAttr('%s.%s%s' %(node,a,aa),l=b,k=not b) for a in 'ts' for aa in 'xyz']
ik_hide_attr = lambda node,b:[cmds.setAttr('%s.%s%s' %(node,a,aa),l=b,k=not b) for a in 'trs' for aa in 'xyz' if '%s%s' %(a,aa) != 'rx']
cu=get_curve()[0]
jts = chain(cu,num_jt,'vks_orig_joint')
d_jts = chain(cu,num_jt,'vks_skin_joint')
parameter_attr(jts)
#loft,skin
surf = create_loft(jts,'vks_lofted_mesh')
surf_s=cmds.listRelatives(surf,c=1)[0]
#hierarchical groups
vks_grp=cmds.group(surf, name='VariableKinematicsSystem#')
flc_grp=cmds.group(em=True,parent=vks_grp,name='vks_follice_grp#')
mov_grp=cmds.group(em=True,parent=vks_grp,name='vks_move_grp#')
ctr_grp=cmds.group(em=True,parent=mov_grp,name='vks_control_grp#')
lock_attr(flc_grp,1)
lock_attr(ctr_grp,1)
#create vks control
vks_ctr=[]
for i in range(num_ctr):
#create follice
vPos= linstep(0., num_ctr-1, i)
flc = create_follicle(surf_s,0.5,vPos,'vks_follice')
flc_tr = cmds.listRelatives(flc,p=1)[0]
cmds.parent(flc_tr,flc_grp)
#create control
vkss = create_control(flc,'vks_parametric')
cmds.parent(vkss[0],ctr_grp)
vks_ctr.append(vkss[-1])
#ikspline
ikhnd=cmds.ikHandle(sj=jts[0], ee=jts[-1], c=cu, ccv=False, sol='ikSplineSolver')
#create joint orig group
org_grp = cmds.group(jts[0],parent=vks_grp,n='vks_orig_grp#')
rot=cmds.xform(jts[0],q=True,ws=True,ro=True)
cmds.xform(org_grp,ws=True,ro=(rot[0],rot[1],rot[2]),piv=(0,0,0))
cmds.hide(flc_grp,org_grp)
#building explicit control
m_ctr=cube_curve('vks_explicit#')
cmds.parent(m_ctr,vks_grp)
tr=cmds.xform(jts[0],q=True,ws=True,t=True)
cmds.xform(m_ctr,ws=True,t=tr)
cmds.makeIdentity(m_ctr,apply=1,t=1,r=1,s=1,n=0)
cmds.parentConstraint(m_ctr,org_grp,mo=1)
cmds.parentConstraint(m_ctr,mov_grp,mo=1)
cmds.scaleConstraint(m_ctr,mov_grp)
if fk:#FK module
for c in vks_ctr:
fk_hide_attr(c,1)
for j in jts:
jgroup = cmds.group(j,n='%s_%s' %(j,c))
piv=cmds.xform(j,q=True,ws=True,piv=True)
cmds.xform(jgroup,ws=True,piv=(piv[0],piv[1],piv[2]))
connection(c,j,jgroup)
for n,j in enumerate(jts):
cmds.parentConstraint(j,d_jts[n])
cmds.scaleConstraint(m_ctr,org_grp)
cmds.parent(d_jts[0],mov_grp)
cmds.delete(ikhnd)
else:#IK module
cmds.hide(surf)
cmds.toggle(d_jts,localAxis=True)
jj=[j for j in jts]
for c in vks_ctr:
ik_hide_attr(c,1)
for n,j in enumerate(jts):
jgroup=cmds.group( em=True, n='%s_%s' %(j,c), parent=jj[n])
jj[n]=jgroup
connection(c,j,jgroup)
for n in range(num_jt):
cmds.parentConstraint(jj[n],d_jts[n])
cu_sc = ik_stretch(ikhnd[0])
cls_grp=cmds.group(em=True,name='vks_cluster_grp#')
ik_cls=cluster_on_curve(cu)
cmds.parent(ik_cls,cls_grp)
cmds.parent(d_jts[0],cls_grp,cu_sc,mov_grp)
cmds.parent(cu,ikhnd[0],vks_grp)
cmds.select(cl=True)
def CreatePVControl(self, Prefix, Suffix, PVPush, ControlSize):
#create polygon at hip knee ankle
#set pivot to average of hip ankle
hipPos = cmds.xform(self.hipJnt, q=1, ws=1, rp=1)
kneePos = cmds.xform(self.kneeJnt, q=1, ws=1, rp=1)
anklePos = cmds.xform(self.ankleJnt, q=1, ws=1, rp=1)
point_list = [hipPos, kneePos, anklePos]
point_list_2 = [hipPos, anklePos]
legPVCurve = cmds.curve(degree=1, point=point_list)
kneePivotCurve = cmds.curve(degree=1, point=point_list_2)
#create node
nearestPOCNode = cmds.createNode("nearestPointOnCurve")
cmds.connectAttr(kneePivotCurve + ".worldSpace",
nearestPOCNode + ".inputCurve")
cmds.setAttr(nearestPOCNode + ".inPosition",
kneePos[0],
kneePos[1],
kneePos[2],
type="double3")
halfwayPos = cmds.getAttr(nearestPOCNode + ".position")[0]
#adjust the pivot so that it gives us a nice approximation of the knee
cmds.move(halfwayPos[0],
halfwayPos[1],
halfwayPos[2],
legPVCurve + ".scalePivot",
legPVCurve + ".rotatePivot",
absolute=True)
#scale the curve to project our knee pv point forward
cmds.select(legPVCurve)
cmds.scale(PVPush, PVPush, PVPush)
#get position of knee from curve (hip = 0, knee = 1, ankle = 2)
controlPos = cmds.pointPosition(legPVCurve + '.cv[1]')
controlPoint = (controlPos[0], controlPos[1], controlPos[2])
#create diamond shape at pos
#name with assigned prefix and suffix, size will match joint radius as a base
control = cmds.curve(name=Prefix + self.LEG_JNT_NAMES[1] + Suffix,
degree=1,
point=ShapeUtils.diamondControlPath())
cmds.select(control)
cmds.move(controlPos[0], controlPos[1], controlPos[2])
cmds.scale(ControlSize, ControlSize, ControlSize)
cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0)
#create null annotation at diamond pointing to child locator
cmds.select(clear=True)
locator = cmds.spaceLocator(n=Prefix + self.LEG_JNT_NAMES[1] +
"PVGuide_LOC")[0]
group = cmds.group(em=True,
name=Prefix + self.LEG_JNT_NAMES[1] +
"PVOffset_GRP")
annotation = cmds.annotate(locator, tx='')
anno_transfrom = cmds.listRelatives(annotation, allParents=True)[0]
anno_transfrom = cmds.rename(
anno_transfrom, Prefix + self.LEG_JNT_NAMES[1] + "PVGuide_ANT")
annotation = cmds.listRelatives(anno_transfrom)[0]
#point constrain the annotation to the knee
cmds.pointConstraint(self.kneeJnt, anno_transfrom)
#move locator to position and parent
cmds.parent(locator, control)
cmds.move(controlPos[0],
controlPos[1],
controlPos[2],
locator,
absolute=True)
cmds.parent(anno_transfrom, locator)
cmds.move(controlPos[0],
controlPos[1],
controlPos[2],
group,
absolute=True)
cmds.parent(control, group)
#pole vector the ikh and the diamond
cmds.poleVectorConstraint(control, self.legIKHandle)
#cleanup
cmds.delete(nearestPOCNode)
cmds.delete(legPVCurve)
cmds.delete(kneePivotCurve)
cmds.setAttr(locator + ".localScaleX", 0)
cmds.setAttr(locator + ".localScaleY", 0)
cmds.setAttr(locator + ".localScaleZ", 0)
cmds.select(annotation)
cmds.toggle(template=True)
def flexi_plane(self, *args):
# create nurbs plane w/ x attrs
# nurbsPlane -p 0 0 0 -ax 0 1 0 -w 5 -lr 0.2 -d 3 -u 5 -v 1 -ch 1;
nurbs_plane = cmds.nurbsPlane(ax=(0, 1, 0),
w=10,
lengthRatio=0.2,
d=3,
u=5,
v=1,
ch=0,
n='flexi_surface_01')
attrs = [
'castsShadows', 'receiveShadows', 'motionBlur',
'primaryVisibility', 'smoothShading', 'visibleInReflections',
'visibleInRefractions'
]
for attr in attrs:
cmds.setAttr('flexi_surface_01Shape.{0}'.format(attr), 0)
# create new material
# cmds.shadingNode('lambert',asShader=1,n='flexi_surface_mat_01')
# make material light blue and lower transparency
# asign material to nurbs plane
if cmds.checkBox(self.matCheckBox, q=1, v=1) == True:
flexi_mat = cmds.shadingNode('lambert',
asShader=1,
n='flexi_surface_mat_01')
cmds.setAttr(flexi_mat + '.color', 0.0, 1.0, 1.0, type='double3')
cmds.setAttr(flexi_mat + '.transparency',
0.75,
0.75,
0.75,
type='double3')
cmds.select(nurbs_plane)
cmds.hyperShade(assign=flexi_mat)
elif cmds.checkBox(self.matCheckBox, q=1, v=1) == False:
print 'no surface material created'
# create follicle system
# create 5 flcs
flc_a01 = cmds.createNode('follicle', skipSelect=1)
cmds.rename('follicle1', 'flexi_flcs_a01')
flc_b01 = cmds.createNode('follicle', skipSelect=1)
cmds.rename('follicle1', 'flexi_flcs_b01')
flc_c01 = cmds.createNode('follicle', skipSelect=1)
cmds.rename('follicle1', 'flexi_flcs_c01')
flc_d01 = cmds.createNode('follicle', skipSelect=1)
cmds.rename('follicle1', 'flexi_flcs_d01')
flc_e01 = cmds.createNode('follicle', skipSelect=1)
cmds.rename('follicle1', 'flexi_flcs_e01')
# hide flcs shape vis and set up node network
shapeNodes = cmds.listRelatives('flexi_flcs_a01',
'flexi_flcs_b01',
'flexi_flcs_c01',
'flexi_flcs_d01',
'flexi_flcs_e01',
shapes=1)
for shape in shapeNodes:
cmds.setAttr("{0}.visibility".format(shape), 0)
cmds.connectAttr('flexi_surface_01Shape.local',
'{0}.inputSurface'.format(shape),
f=1)
cmds.connectAttr('flexi_surface_01Shape.worldMatrix[0]',
'{0}.inputWorldMatrix'.format(shape),
f=1)
# node network cont.
sel_shape = cmds.listRelatives('flexi_flcs_a01',
'flexi_flcs_b01',
'flexi_flcs_c01',
'flexi_flcs_d01',
'flexi_flcs_e01',
shapes=1)
sel = cmds.ls('flexi_flcs_a01', 'flexi_flcs_b01', 'flexi_flcs_c01',
'flexi_flcs_d01', 'flexi_flcs_e01')
count = -1
for shape in sel_shape:
count = count + 1
cmds.connectAttr('{0}.outRotate'.format(sel_shape[count]),
'{0}.rotate'.format(sel[count]),
f=1)
cmds.connectAttr('{0}.outTranslate'.format(sel_shape[count]),
'{0}.translate'.format(sel[count]),
f=1)
# move the U & V parameters for each flc
sel = cmds.ls('flexi_flcs_a01', 'flexi_flcs_b01', 'flexi_flcs_c01',
'flexi_flcs_d01', 'flexi_flcs_e01')
count = -0.1
for each in sel:
count = count + 0.2
cmds.setAttr('{0}.parameterU'.format(each), count)
cmds.setAttr('{0}.parameterV'.format(each), 0.5)
# lock trans and rot on flcs
sel = cmds.ls('flexi_flcs_a01', 'flexi_flcs_b01', 'flexi_flcs_c01',
'flexi_flcs_d01', 'flexi_flcs_e01')
attrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz']
for each in sel:
for attr in attrs:
cmds.setAttr('{0}.{1}'.format(each, attr), l=1)
# group flcs w/ name flexi_flcs_grp_01
cmds.group('flexi_flcs_a01',
'flexi_flcs_b01',
'flexi_flcs_c01',
'flexi_flcs_d01',
'flexi_flcs_e01',
n='flexi_flcs_grp_01')
# create square CV , CP , end of plane, name flexi_icon_a01, change color to yellow, repeat for other end
# curve -d 1 -p -6 0 -1 -p -6 0 1 -p -4 0 1 -p -4 0 -1 -p -6 0 -1 -k 0 -k 1 -k 2 -k 3 -k 4 ;
ctrl_a01 = cmds.curve(d=1,
p=[(-5.6, 0, -0.6), (-4.4, 0, -0.6),
(-4.4, 0, 0.6), (-5.6, 0, 0.6),
(-5.6, 0, -0.6)],
k=[0, 1, 2, 3, 4],
n='flexi_icon_a01')
cmds.xform(ctrl_a01, cp=1)
cmds.select(cl=1)
ctrl_b01 = cmds.curve(d=1,
p=[(4.4, 0, -0.6), (5.6, 0, -0.6), (5.6, 0, 0.6),
(4.4, 0, 0.6), (4.4, 0, -0.6)],
k=[0, 1, 2, 3, 4],
n='flexi_icon_b01')
cmds.xform(ctrl_b01, cp=1)
shapeNodes = cmds.listRelatives(ctrl_a01, ctrl_b01, shapes=1)
for shape in shapeNodes:
cmds.setAttr("{0}.overrideEnabled".format(shape), 1)
cmds.setAttr("{0}.overrideColor".format(shape), 17)
cmds.select(cl=1)
# duplicate plane, translate Z axis -5, reanme to flexi_bShp_surface_01
bShp_surface = cmds.duplicate(nurbs_plane, n='flexi_bShp_surface_01')
cmds.select(bShp_surface)
cmds.xform(t=[0, 0, -5])
# create blendshape w/ default settings, name flexi_bShpNode_surface_01
cmds.blendShape(bShp_surface,
nurbs_plane,
n='flexi_bShpNode_surface_01')
# output settings to always on = 1
cmds.setAttr('flexi_bShpNode_surface_01.flexi_bShp_surface_01', 1)
# CV w/ 3 pts on dup plane, degree-2, rename to flexi_wire_surface_01
wire_surface = cmds.curve(d=2,
p=[(-5, 0, -5), (0, 0, -5), (5, 0, -5)],
k=[0, 0, 1, 1],
n='flexi_wire_surface_01')
# create cluster w/ relative=ON, on left and mid cv points, rename to flexi_cl_a01
cmds.select(cl=1)
clus = cmds.cluster(['flexi_wire_surface_01.cv[0:1]'],
rel=1,
n='flexi_clus_')
clus_sel = cmds.select('flexi_clus_Handle')
clus_1 = cmds.rename(clus_sel, 'flexi_cl_a01')
# set cluster origin=-6
cmds.setAttr('|flexi_cl_a01|flexi_cl_a01Shape.originX', -6)
# move pivot to end of dup plane
cmds.xform(piv=[-5, 0, -5])
# repeat previous steps for other side
cmds.select(cl=1)
clus = cmds.cluster(['flexi_wire_surface_01.cv[1:2]'],
rel=1,
n='flexi_clus_')
clus_sel = cmds.select('flexi_clus_Handle')
clus_2 = cmds.rename(clus_sel, 'flexi_cl_b01')
cmds.setAttr('|flexi_cl_b01|flexi_cl_b01Shape.originX', 6)
cmds.xform(piv=[5, 0, -5])
# repeat for middle
cmds.select(cl=1)
clus = cmds.cluster(['flexi_wire_surface_01.cv[1]'],
rel=1,
n='flexi_clus_')
clus_sel = cmds.select('flexi_clus_Handle')
clus_3 = cmds.rename(clus_sel, 'flexi_cl_mid01')
# select mid CV point, component editor, weighted deformer tab, a & b node set to 0.5
# select -r flexi_wire_surface_01.cv[1] ;
# percent -v 0.5 flexi_cl_a01Cluster flexi_wire_surface_01.cv[1] ;
# percent -v 0.5 flexi_cl_b01Cluster flexi_wire_surface_01.cv[1] ;
cmds.select(cl=1)
cmds.select('flexi_wire_surface_01.cv[1]')
cmds.percent('flexi_cl_a01Cluster', v=0.5)
cmds.percent('flexi_cl_b01Cluster', v=0.5)
cmds.select(cl=1)
# wire deformer, select CV then the dup plane and press enter, dropoff distance to 20
# mel.eval('wire -gw false -dds 0 20 -en 1.000000 -ce 0.000000 -li 0.000000 -w flexi_wire_surface_01 flexi_bShp_surface_01;')
cmds.wire('flexi_bShp_surface_01',
groupWithBase=0,
dropoffDistance=(0, 20),
envelope=1.0,
crossingEffect=0.0,
localInfluence=0.0,
wire=wire_surface,
n='flexi_wireAttrs_surface_01')
cmds.select(cl=1)
# select start control, start cluster, open conection editor, connect translate to translate
# connectAttr -f flexi_icon_a01.translate flexi_cl_a01.translate;
cmds.connectAttr('flexi_icon_a01.translate',
'flexi_cl_a01.translate',
f=1)
# repeat for other end
cmds.connectAttr('flexi_icon_b01.translate',
'flexi_cl_b01.translate',
f=1)
# group the 3 clusters together, name it flexi_cls_01
cmds.group(clus_1, clus_2, clus_3, n='flexi_cls_01')
# create group for 2 current controls, name it flexi_icons_01
cmds.group('flexi_icon_a01', 'flexi_icon_b01', n='flexi_icons_01')
# lock and hide transform channels of groups
attrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz']
for attr in attrs:
cmds.setAttr('flexi_cls_01.{0}'.format(attr), l=1, k=0)
cmds.setAttr('flexi_icons_01.{0}'.format(attr), l=1, k=0)
# create center control, name it flexi_midBend_01
# sphere -p 0 0 0 -ax 0 1 0 -ssw 0 -esw 360 -r 1 -d 3 -ut 0 -tol 0.01 -s 8 -nsp 4 -ch 1;
mid_ctrl = cmds.sphere(pivot=[0, 0, 0],
ax=[0, 1, 0],
startSweep=0,
endSweep=360,
ch=0,
r=0.3,
d=3,
useTolerance=0,
tol=0.8,
spans=4,
n='flexi_midBend_01')
attrs = [
'castsShadows', 'receiveShadows', 'motionBlur',
'primaryVisibility', 'smoothShading', 'visibleInReflections',
'visibleInRefractions'
]
for attr in attrs:
cmds.setAttr('flexi_midBend_01Shape.{0}'.format(attr), 0)
# new material, surface shader, yellow color, name flexi_ss_midBend_01
if cmds.checkBox(self.matCheckBox, q=1, v=1) == True:
flexi_mat_2 = cmds.shadingNode('surfaceShader',
asShader=1,
n='flexi_mid_mat_01')
cmds.setAttr(flexi_mat_2 + '.outColor',
1.0,
1.0,
0.0,
type='double3')
cmds.select(mid_ctrl)
cmds.hyperShade(assign=flexi_mat_2)
elif cmds.checkBox(self.matCheckBox, q=1, v=1) == False:
print 'no mid ctrl material created'
# connect translates for new mid control to mid cluster
cmds.connectAttr('flexi_midBend_01.translate',
'flexi_cl_mid01.translate',
f=1)
# create group for mid control, name flexi_grp_midBend_01
cmds.group('flexi_midBend_01', n='flexi_grp_midBend_01')
# point constraint, select 2 outside controls, then ctrl click mid control, point constraint
cmds.pointConstraint('flexi_icon_a01',
'flexi_icon_b01',
'flexi_grp_midBend_01',
mo=1)
# parent midBend grp under icons grp
cmds.parent('flexi_grp_midBend_01', 'flexi_icons_01')
# group all nodes under single group, name flexiPlane_rig_01
cmds.group('flexi_surface_01',
'flexi_flcs_grp_01',
'flexi_bShp_surface_01',
'flexi_wire_surface_01',
'flexi_wire_surface_01BaseWire',
'flexi_cls_01',
'flexi_icons_01',
n='flexiPlane_rig_01')
# lock and hide group transforms
attrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz']
for attr in attrs:
cmds.setAttr('flexiPlane_rig_01.{0}'.format(attr), l=1, k=0)
# group flexi surface and icons grp, name flexi_globalMove_01
cmds.group('flexi_surface_01',
'flexi_icons_01',
n='flexi_globalMove_01')
# group all but global, name flexi_extraNodes_01
cmds.group('flexi_flcs_grp_01',
'flexi_bShp_surface_01',
'flexi_wire_surface_01',
'flexi_wire_surface_01BaseWire',
'flexi_cls_01',
n='flexi_extraNodes_01')
cmds.select(cl=1)
# scale constrain each follicle to the global move grp
sel = cmds.ls('flexi_flcs_a01', 'flexi_flcs_b01', 'flexi_flcs_c01',
'flexi_flcs_d01', 'flexi_flcs_e01')
for each in sel:
cmds.scaleConstraint('flexi_globalMove_01',
'{0}'.format(each),
mo=0)
# build global control
ctrl_global = cmds.curve(d=1,
p=[(0, 0, -1.667542), (-0.332458, 0, -2),
(0.332458, 0, -2), (0, 0, -1.667542),
(0, 0, 1.667542), (0.332458, 0, 2),
(-0.332458, 0, 2), (0, 0, 1.667542)],
k=[0, 1, 2, 3, 4, 5, 6, 7],
n='flexi_icon_global_01')
cmds.xform(ctrl_global, cp=1)
shapeNodes = cmds.listRelatives(ctrl_global, shapes=1)
for shape in shapeNodes:
cmds.setAttr("{0}.overrideEnabled".format(shape), 1)
cmds.setAttr("{0}.overrideColor".format(shape), 17)
cmds.select(cl=1)
# parent global ctrl under main flexi grp
cmds.parent('flexi_icon_global_01', 'flexiPlane_rig_01')
# parent global grp under ctrl
cmds.parent('flexi_globalMove_01', 'flexi_icon_global_01')
cmds.select(cl=1)
# create 5 joints, positioned at each follicle, w/ name of flexi_bind_a01 ... e01
cmds.joint(p=[-4, 0, 0], n='flexi_bind_a01')
cmds.select(cl=1)
cmds.joint(p=[-2, 0, 0], n='flexi_bind_b01')
cmds.select(cl=1)
cmds.joint(p=[0, 0, 0], n='flexi_bind_c01')
cmds.select(cl=1)
cmds.joint(p=[2, 0, 0], n='flexi_bind_d01')
cmds.select(cl=1)
cmds.joint(p=[4, 0, 0], n='flexi_bind_e01')
cmds.select(cl=1)
# turn on local rotation axis for 5 joints
sel = cmds.ls('flexi_bind_a01', 'flexi_bind_b01', 'flexi_bind_c01',
'flexi_bind_d01', 'flexi_bind_e01')
for obj in sel:
# mel.eval('ToggleLocalRotationAxes')
cmds.toggle(sel, localAxis=1)
cmds.select(cl=1)
# parent each joint under its respective follicle
sel_parent = cmds.ls('flexi_flcs_a01', 'flexi_flcs_b01',
'flexi_flcs_c01', 'flexi_flcs_d01',
'flexi_flcs_e01')
sel_child = cmds.ls('flexi_bind_a01', 'flexi_bind_b01',
'flexi_bind_c01', 'flexi_bind_d01',
'flexi_bind_e01')
count = -1
for each in sel_parent:
count = count + 1
cmds.parent('{0}'.format(sel_child[count]),
'{0}'.format(sel_parent[count]))
cmds.select(cl=1)
# select bShp surface and create twist deformer
# nonLinear -type twist -lowBound -1 -highBound 1 -startAngle 0 -endAngle 0;
cmds.nonLinear('flexi_bShp_surface_01', typ='twist')
# rotate twist node 90 degrees in z axis
cmds.xform('twist*Handle', ro=(0, 0, 90))
# rename twist to flexi_twist_surface_01
cmds.rename('twist*Handle', 'flexi_twist_surface_01')
# cmds.rename('twist1','flexi_twistAttrs_surface_01')
twist_list = cmds.ls(exactType='nonLinear')
refined_list = cmds.select(twist_list[-1])
cmds.rename(refined_list, 'flexi_twistAttrs_surface_01')
# parent twist under the extra grp
cmds.parent('flexi_twist_surface_01', 'flexi_extraNodes_01')
# connect rotate x of start/end ctrls to start/end angles of twist deformer via direct connections
# select deformer input node, then the controls
# connect b01 control to the start angle and vice versa
cmds.connectAttr('flexi_icon_b01.rotateX',
'flexi_twistAttrs_surface_01.startAngle')
cmds.connectAttr('flexi_icon_a01.rotateX',
'flexi_twistAttrs_surface_01.endAngle')
# change rotate order for ctrls to XZY
cmds.xform('flexi_icon_a01', 'flexi_icon_b01', roo='xzy')
# select bShp surface and change input order, twist between wire & tweak
# reorderDeformers "flexi_wireAttrs_surface_01" "flexi_twistAttrs_surface_01"
# "flexiPlane_rig_01|flexi_extraNodes_01|flexi_bShp_surface_01";
cmds.reorderDeformers(
'flexi_wireAttrs_surface_01', 'flexi_twistAttrs_surface_01',
'flexiPlane_rig_01|flexi_extraNodes_01|flexi_bShp_surface_01')
# remove tranforms on flexi plane surface
attrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz']
for attr in attrs:
cmds.setAttr('flexi_surface_01.{0}'.format(attr), l=1, k=0)
# hide bshp surface, cls grp, twist surface
obj = cmds.ls('flexi_bShp_surface_01', 'flexi_cls_01',
'flexi_twist_surface_01')
for each in obj:
cmds.setAttr("{0}.visibility".format(each), 0)
# turn off objecy display - visibility for follicles
shapeNodes = cmds.listRelatives('flexi_flcs_a01',
'flexi_flcs_b01',
'flexi_flcs_c01',
'flexi_flcs_d01',
'flexi_flcs_e01',
shapes=1)
for shape in shapeNodes:
cmds.setAttr("{0}.visibility".format(shape), 0)
cmds.select(cl=1)
# create volume attr on global ctrl
cmds.addAttr('flexi_icon_global_01',
longName='VOLUME',
attributeType='enum',
enumName='--------:',
k=1)
cmds.addAttr('flexi_icon_global_01',
longName='Enable',
k=1,
attributeType='enum',
enumName='OFF:ON:')
cmds.select(cl=1)
# set up node editor
# select -r flexi_wire_surface_01 ;
# mel.eval('arclen -ch 1;')
cmds.arclen('flexi_wire_surface_01', ch=1)
cmds.rename('curveInfo1', 'flexi_curveInfo_01')
# shadingNode -asUtility multiplyDivide;
# // multiplyDivide1 //
cmds.shadingNode('multiplyDivide',
asUtility=1,
n='flexi_div_squashStretch_length_01')
# setAttr "multiplyDivide1.operation" 2;
cmds.setAttr('flexi_div_squashStretch_length_01.operation', 2)
# connectAttr -f flexi_curveInfo_01.arcLength flexi_div_squashStretch_length_01.input1X;
cmds.connectAttr('flexi_curveInfo_01.arcLength',
'flexi_div_squashStretch_length_01.input1X',
f=1)
# setAttr "flexi_div_squashStretch_length_01.input2X" 10;
cmds.setAttr('flexi_div_squashStretch_length_01.input2X', 10)
# duplicate -rr;setAttr "flexi_div_volume_01.input1X" 1;
cmds.shadingNode('multiplyDivide',
asUtility=1,
n='flexi_div_volume_01')
cmds.setAttr('flexi_div_volume_01.operation', 2)
cmds.setAttr('flexi_div_volume_01.input1X', 1)
# connectAttr -f flexi_div_squashStretch_length_01.outputX flexi_div_volume_01.input2X;
cmds.connectAttr('flexi_div_squashStretch_length_01.outputX',
'flexi_div_volume_01.input2X',
f=1)
# shadingNode -asUtility condition;
# // condition1 //
cmds.shadingNode('condition', asUtility=1, n='flexi_con_volume_01')
# setAttr "flexi_con_volume_01.secondTerm" 1;
cmds.setAttr('flexi_con_volume_01.secondTerm', 1)
# connectAttr -f flexi_icon_global_01.Enable flexi_con_volume_01.firstTerm;
cmds.connectAttr('flexi_icon_global_01.Enable',
'flexi_con_volume_01.firstTerm',
f=1)
# connectAttr -f flexi_div_volume_01.outputX flexi_con_volume_01.colorIfTrueR;
cmds.connectAttr('flexi_div_volume_01.outputX',
'flexi_con_volume_01.colorIfTrueR',
f=1)
# connect volume condition out color r to joints a-e scale y & z
# connectAttr -f flexi_con_volume_01.outColorR flexi_bind_a01.scaleY;
# connectAttr -f flexi_con_volume_01.outColorR flexi_bind_a01.scaleZ;
sel = cmds.ls('flexi_bind_a01', 'flexi_bind_b01', 'flexi_bind_c01',
'flexi_bind_d01', 'flexi_bind_e01')
for each in sel:
cmds.connectAttr('flexi_con_volume_01.outColorR',
'{0}.scaleY'.format(each),
f=1)
cmds.connectAttr('flexi_con_volume_01.outColorR',
'{0}.scaleZ'.format(each),
f=1)
# hide wire
cmds.setAttr('flexi_wire_surface_01.visibility', 0)
cmds.select(cl=1)
# create indy controls for joints
indy_1 = cmds.circle(normal=[1, 0, 0],
r=0.8,
d=3,
sections=8,
ch=0,
n='flexi_indy_icon_a01')
cmds.xform(t=[-4, 0, 0])
cmds.parent('flexi_indy_icon_a01', 'flexi_flcs_a01')
cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0)
cmds.parent('flexi_bind_a01', 'flexi_indy_icon_a01')
indy_2 = cmds.circle(normal=[1, 0, 0],
r=0.8,
d=3,
sections=8,
ch=0,
n='flexi_indy_icon_b01')
cmds.xform(t=[-2, 0, 0])
cmds.parent('flexi_indy_icon_b01', 'flexi_flcs_b01')
cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0)
cmds.parent('flexi_bind_b01', 'flexi_indy_icon_b01')
indy_3 = cmds.circle(normal=[1, 0, 0],
r=0.8,
d=3,
sections=8,
ch=0,
n='flexi_indy_icon_c01')
cmds.xform(t=[0, 0, 0])
cmds.parent('flexi_indy_icon_c01', 'flexi_flcs_c01')
cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0)
cmds.parent('flexi_bind_c01', 'flexi_indy_icon_c01')
indy_4 = cmds.circle(normal=[1, 0, 0],
r=0.8,
d=3,
sections=8,
ch=0,
n='flexi_indy_icon_d01')
cmds.xform(t=[2, 0, 0])
cmds.parent('flexi_indy_icon_d01', 'flexi_flcs_d01')
cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0)
cmds.parent('flexi_bind_d01', 'flexi_indy_icon_d01')
indy_5 = cmds.circle(normal=[1, 0, 0],
r=0.8,
d=3,
sections=8,
ch=0,
n='flexi_indy_icon_e01')
cmds.xform(t=[4, 0, 0])
cmds.parent('flexi_indy_icon_e01', 'flexi_flcs_e01')
cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0)
cmds.parent('flexi_bind_e01', 'flexi_indy_icon_e01')
cmds.select(cl=1)
# recolor indy controls to magenta
shapeNodes = cmds.listRelatives(indy_1,
indy_2,
indy_3,
indy_4,
indy_5,
shapes=1)
for shape in shapeNodes:
cmds.setAttr("{0}.overrideEnabled".format(shape), 1)
cmds.setAttr("{0}.overrideColor".format(shape), 31)
cmds.select(cl=1)
# visibility control for indy controls
cmds.addAttr('flexi_midBend_01',
longName='VIS',
attributeType='enum',
enumName='--------:',
k=1)
cmds.addAttr('flexi_midBend_01',
longName='Indy_Ctrls',
k=1,
attributeType='enum',
enumName='OFF:ON:')
cmds.setAttr('flexi_midBend_01.Indy_Ctrls', 1)
# connect indy ctrl vis to on/off switch
# flexi_indy_icon_c01Shape.visibility
sel = cmds.ls('flexi_indy_icon_a01Shape', 'flexi_indy_icon_b01Shape',
'flexi_indy_icon_c01Shape', 'flexi_indy_icon_d01Shape',
'flexi_indy_icon_e01Shape')
for each in sel:
cmds.connectAttr('flexi_midBend_01.Indy_Ctrls',
'{0}.visibility'.format(each),
f=1)
cmds.select(cl=1)
# select all created objects
orig_names = cmds.select(
'flexi_surface_01', 'flexi_flcs_grp_01', 'flexi_flcs_a01',
'flexi_flcs_b01', 'flexi_flcs_c01', 'flexi_flcs_d01',
'flexi_flcs_e01', 'flexi_icon_a01', 'flexi_icon_b01',
'flexi_bShp_surface_01', 'flexi_bShpNode_surface_01',
'flexi_wire_surface_01', 'flexi_cl_a01', 'flexi_cl_b01',
'flexi_cl_mid01', 'flexi_wireAttrs_surface_01', 'flexi_cls_01',
'flexi_wire_surface_01BaseWire', 'flexi_icons_01',
'flexi_midBend_01', 'flexi_grp_midBend_01', 'flexiPlane_rig_01',
'flexi_globalMove_01', 'flexi_extraNodes_01',
'flexi_icon_global_01', 'flexi_bind_a01', 'flexi_bind_b01',
'flexi_bind_c01', 'flexi_bind_d01', 'flexi_bind_e01',
'flexi_twist_surface_01', 'flexi_twistAttrs_surface_01',
'flexi_curveInfo_01', 'flexi_div_squashStretch_length_01',
'flexi_div_volume_01', 'flexi_con_volume_01',
'flexi_indy_icon_a01', 'flexi_indy_icon_b01',
'flexi_indy_icon_c01', 'flexi_indy_icon_d01',
'flexi_indy_icon_e01')
if cmds.checkBox(self.matCheckBox, q=1, v=1) == True:
cmds.select('flexi_surface_mat_01', 'flexi_mid_mat_01', add=1)
elif cmds.checkBox(self.matCheckBox, q=1, v=1) == False:
print 'no materials added to rig'
sel = cmds.ls(sl=1, o=1)
prefix = cmds.textFieldGrp(self.prefixText, q=1, text=1)
for each in sel:
cmds.select(each)
cmds.rename(each, prefix + '_' + each)
cmds.select(cl=1)
import maya.cmds as mc
#根据骨骼点的数量在mesh上生成相应数量pointOnSurface node
# 在生成的同时，生成对应数量的空组，并显示局部坐标
lx_mesh = mc.ls(sl=1);
lx_jnt = mc.ls(sl=1);
lx_node=[];
for lx_temp in lx_jnt :
nd=mc.pointOnSurface(lx_mesh,ch=True );
lx_node.insert(1,nd);
mc.rename(nd,"pntNd_"+lx_temp);
mc.group(empty=1,n=("nl_"+lx_temp));
mc.connectAttr(("pntNd_"+lx_temp +".position"),("nl_"+lx_temp+".translate"));
mc.toggle (("nl_"+lx_temp),localAxis=1);
import maya.cmds as mc
# 合并上一步生成的空组和之前生成的次级骨骼的组。
lx_jntgrp = mc.ls(sl=1);
lx_nlgrp =mc.ls("nl_*");
for lx_i in lx_jntgrp :
lx_chr = "grp_" + lx_i + "01";
lx_pnt = "nl_" + lx_i ;
mc.parent(lx_chr ,lx_pnt )
mc.toggle (("grp_" + lx_i + "02"),localAxis=1);
mc.setAttr(("grp_" + lx_i + "01.translate") ,0,0,0,type ="double3");
def removeLocalAxis():
for each in mc.ls(sl=True):
if mc.toggle(each, q=True, la=True):
mc.toggle(each, la=True)
from maya import cmds cmds.toggle (localAxis = True) print 'toggle Axis'
def VK_system(num_ctr=1, num_jt=20, fk=True):
"""
final assembly of the entire system
"""
fk_hide_attr = lambda node, b: [cmds.setAttr('%s.%s' % (node, a), l=b, k=not b) for a in 'tx,ty,tz,sx,sy,sz,v'.split(',')]
ik_hide_attr = lambda node, b: [cmds.setAttr('%s.%s' % (node, a), l=b, k=not b) for a in 'tx,ty,tz,ry,rz,sx,sy,sz,v'.split(',')]
ctrl_hide_attr = lambda node, b: [cmds.setAttr('%s.%s' % (node, a), l=b, k=not b) for a in 'rx,ry,rz,sx,sy,sz,v'.split(',')]
orig_cu = setup.get_curve()[0]
cu = cmds.duplicate(orig_cu, n='vks_curve#')[0]
jts = setup.chain(cu, num_jt, 'vks_orig_joint')
d_jts = setup.chain(cu, num_jt, 'vks_skin_joint')
cmds.toggle(d_jts, localAxis=True)
parameter_attr(jts)
# loft,skin
surf = create_loft(jts, 'vks_lofted_mesh')
surf_s = cmds.listRelatives(surf, c=1)[0]
# hierarchical groups
vks_grp = cmds.group(surf, name='VariableKinematicsSystem#')
mov_grp = cmds.group(em=True, parent=vks_grp, name='vks_move_grp#')
rig_grp = cmds.group(em=True, parent=vks_grp, name='vks_rig_grp#')
flc_grp = cmds.group(em=True, parent=rig_grp, name='vks_follice_grp#')
setup.lock_attr(flc_grp, 1)
setup.off_vis(rig_grp)
# create vks controls
vks_ctr = []
vks_ctr_grp = []
for i in range(num_ctr):
# create follice
vPos = setup.linstep(0., num_ctr - 1, i)
flc = setup.create_follicle(surf_s, 0.5, vPos, 'vks_follice')
flc_tr = cmds.listRelatives(flc, p=1)[0]
cmds.parent(flc_tr, flc_grp)
# create control
vkss = create_control(flc, 'vks_parametric')
vks_ctr_grp.append(vkss[0])
vks_ctr.append(vkss[-1])
# ikspline
ikhnd = cmds.ikHandle(sj=jts[0], ee=jts[-1], c=cu, ccv=False, sol='ikSplineSolver')
# create joint orig group
org_grp = cmds.group(jts[0], parent=rig_grp, n='vks_orig_grp#')
rot = cmds.xform(jts[0], q=True, ws=True, ro=True)
cmds.xform(org_grp, ws=True, ro=(rot[0], rot[1], rot[2]), piv=(0, 0, 0))
cmds.parent(cu, ikhnd[0], rig_grp)
# building explicit control
m_ctr = setup.ctrl_cube('vks_explicit#', sz=2)
cmds.parent(m_ctr, vks_grp)
tr = cmds.xform(jts[0], q=True, ws=True, t=True)
cmds.xform(m_ctr, ws=True, t=tr)
cmds.makeIdentity(m_ctr, apply=1, t=1, r=1, s=1, n=0)
cmds.parent(vks_ctr_grp, m_ctr)
cmds.parentConstraint(m_ctr, org_grp, mo=1)
cmds.parentConstraint(m_ctr, mov_grp, mo=1)
cmds.scaleConstraint(m_ctr, mov_grp)
if fk: # FK module
for c in vks_ctr:
fk_hide_attr(c, 1)
for j in jts:
jgroup = cmds.group(j, n='%s_%s' % (j, c))
piv = cmds.xform(j, q=True, ws=True, piv=True)
cmds.xform(jgroup, ws=True, piv=(piv[0], piv[1], piv[2]))
connection(c, j, jgroup)
for n, j in enumerate(jts):
cmds.parentConstraint(j, d_jts[n])
# fk length
cmds.addAttr(m_ctr, ln='length', at='double', k=1, min=0, max=10, dv=1)
v_tx = cmds.getAttr('%s.tx' % jts[1])
pma = cmds.createNode('plusMinusAverage', n='vfk_lengthConversion_%s' % m_ctr)
cmds.setAttr("%s.input1D[0]" % pma, -1)
cmds.setAttr("%s.input1D[1]" % pma, v_tx)
cmds.connectAttr('%s.length' % m_ctr, '%s.input1D[2]' % pma)
for j in jts[1:-1]:
cmds.connectAttr('%s.output1D' % pma, '%s.tx' % j)
cmds.scaleConstraint(m_ctr, org_grp)
cmds.parent(d_jts[0], mov_grp)
cmds.delete(ikhnd)
if not fk: # IK module
jj = [j for j in jts]
for c in vks_ctr:
ik_hide_attr(c, 1)
for n, j in enumerate(jts):
jgroup = cmds.group(em=True, n='%s_%s' % (j, c), parent=jj[n])
jj[n] = jgroup
connection(c, j, jgroup)
for n in range(num_jt):
cmds.parentConstraint(jj[n], d_jts[n])
# ik stretch
cu_sc = ik_stretch(ikhnd[0])
cmds.addAttr(m_ctr, ln="stretch", at='double', k=1, min=0, max=10, dv=10)
ucn = setup.onetenthNode(m_ctr, 'stretch')
cmds.connectAttr('%s.output' % ucn, '%s.ik_stretch' % ikhnd[0])
cls_grp = cmds.group(em=True, name='vks_cluster_grp#')
setup.off_vis(cls_grp)
ik_cls = cluster_on_curve(cu)
for ik_cl in ik_cls:
l_ctrl, l_null = setup.local_cluster_control2(ik_cl)
ctrl_hide_attr(l_ctrl, 1)
cmds.parent(l_ctrl, m_ctr)
cmds.parent(ik_cl, l_null, cls_grp)
cmds.parent(d_jts[0], cls_grp, cu_sc, mov_grp)
cmds.select(cl=True)
onc=ParentOn_cmd,
ofc=ParentOff_cmd)
cmds.textFieldGrp('parentChain_grp',
label='Parent chain under',
pht="ex: ROOT_jnt",
ed=False)
cmds.button('makeJnts', label='create joint chain', c=createJnt_cmd)
cmds.floatSliderGrp('jointScaleSlider',
field=True,
label='joint radius',
minValue=0,
maxValue=50,
fieldMinValue=-100,
fieldMaxValue=100,
value=1,
cc=jointScale_cmd,
en=False)
#makes the initial locators to be the start and end joints
makeRoot = cmds.spaceLocator(n='rootJoint_loc')
cmds.toggle(la=True)
cmds.move(1, 0, 0)
makeEnd = cmds.spaceLocator(n='endJoint_loc')
cmds.toggle(la=True)
cmds.move(-1, 0, 0)
#spawns the hell beast.
cmds.showWindow('jointCreator')
stdout.write(
"joint chain creator by Wesley Wilson. Manipulate locators to beginning and end points, then specify parameters. \n"
)
import maya.cmds as mc
#根据骨骼点的数量在mesh上生成相应数量pointOnSurface node
# 在生成的同时，生成对应数量的空组，并显示局部坐标
lx_mesh = mc.ls(sl=1)
lx_jnt = mc.ls(sl=1)
lx_node = []
for lx_temp in lx_jnt:
nd = mc.pointOnSurface(lx_mesh, ch=True)
lx_node.insert(1, nd)
mc.rename(nd, "pntNd_" + lx_temp)
mc.group(empty=1, n=("nl_" + lx_temp))
mc.connectAttr(("pntNd_" + lx_temp + ".position"),
("nl_" + lx_temp + ".translate"))
mc.toggle(("nl_" + lx_temp), localAxis=1)
import maya.cmds as mc
# 合并上一步生成的空组和之前生成的次级骨骼的组。
lx_jntgrp = mc.ls(sl=1)
lx_nlgrp = mc.ls("nl_*")
for lx_i in lx_jntgrp:
lx_chr = "grp_" + lx_i + "01"
lx_pnt = "nl_" + lx_i
mc.parent(lx_chr, lx_pnt)
mc.toggle(("grp_" + lx_i + "02"), localAxis=1)
mc.setAttr(("grp_" + lx_i + "01.translate"), 0, 0, 0, type="double3")
import maya.cmds as mc
lx_pntNod = mc.ls("pntNd_*")
def _toggle_local_axis(self):
"""
Toggles the local axis of selected joints.
"""
cmds.toggle(la=True)
def LocalAxis():
cmds.toggle(localAxis=True)
def VK_system(num_ctr=1, num_jt=10, fk=True):
"""
final assembly of the entire system
"""
lock_attr = lambda node, b: [
cmds.setAttr('%s.%s%s' % (node, a, aa), l=b) for a in 'trs'
for aa in 'xyz'
]
fk_hide_attr = lambda node, b: [
cmds.setAttr('%s.%s%s' % (node, a, aa), l=b, k=not b) for a in 'ts'
for aa in 'xyz'
]
ik_hide_attr = lambda node, b: [
cmds.setAttr('%s.%s%s' % (node, a, aa), l=b, k=not b) for a in 'trs'
for aa in 'xyz' if '%s%s' % (a, aa) != 'rx'
]
cu = get_curve()[0]
jts = chain(cu, num_jt, 'vks_orig_joint')
d_jts = chain(cu, num_jt, 'vks_skin_joint')
parameter_attr(jts)
#loft,skin
surf = create_loft(jts, 'vks_lofted_mesh')
surf_s = cmds.listRelatives(surf, c=1)[0]
#hierarchical groups
vks_grp = cmds.group(surf, name='VariableKinematicsSystem#')
flc_grp = cmds.group(em=True, parent=vks_grp, name='vks_follice_grp#')
mov_grp = cmds.group(em=True, parent=vks_grp, name='vks_move_grp#')
ctr_grp = cmds.group(em=True, parent=mov_grp, name='vks_control_grp#')
lock_attr(flc_grp, 1)
lock_attr(ctr_grp, 1)
#create vks control
vks_ctr = []
for i in range(num_ctr):
#create follice
vPos = linstep(0., num_ctr - 1, i)
flc = create_follicle(surf_s, 0.5, vPos, 'vks_follice')
flc_tr = cmds.listRelatives(flc, p=1)[0]
cmds.parent(flc_tr, flc_grp)
#create control
vkss = create_control(flc, 'vks_parametric')
cmds.parent(vkss[0], ctr_grp)
vks_ctr.append(vkss[-1])
#ikspline
ikhnd = cmds.ikHandle(sj=jts[0],
ee=jts[-1],
c=cu,
ccv=False,
sol='ikSplineSolver')
#create joint orig group
org_grp = cmds.group(jts[0], parent=vks_grp, n='vks_orig_grp#')
rot = cmds.xform(jts[0], q=True, ws=True, ro=True)
cmds.xform(org_grp, ws=True, ro=(rot[0], rot[1], rot[2]), piv=(0, 0, 0))
cmds.hide(flc_grp, org_grp)
#building explicit control
m_ctr = cube_curve('vks_explicit#')
cmds.parent(m_ctr, vks_grp)
tr = cmds.xform(jts[0], q=True, ws=True, t=True)
cmds.xform(m_ctr, ws=True, t=tr)
cmds.makeIdentity(m_ctr, apply=1, t=1, r=1, s=1, n=0)
cmds.parentConstraint(m_ctr, org_grp, mo=1)
cmds.parentConstraint(m_ctr, mov_grp, mo=1)
cmds.scaleConstraint(m_ctr, mov_grp)
if fk: #FK module
for c in vks_ctr:
fk_hide_attr(c, 1)
for j in jts:
jgroup = cmds.group(j, n='%s_%s' % (j, c))
piv = cmds.xform(j, q=True, ws=True, piv=True)
cmds.xform(jgroup, ws=True, piv=(piv[0], piv[1], piv[2]))
connection(c, j, jgroup)
for n, j in enumerate(jts):
cmds.parentConstraint(j, d_jts[n])
cmds.scaleConstraint(m_ctr, org_grp)
cmds.parent(d_jts[0], mov_grp)
cmds.delete(ikhnd)
else: #IK module
cmds.hide(surf)
cmds.toggle(d_jts, localAxis=True)
jj = [j for j in jts]
for c in vks_ctr:
ik_hide_attr(c, 1)
for n, j in enumerate(jts):
jgroup = cmds.group(em=True, n='%s_%s' % (j, c), parent=jj[n])
jj[n] = jgroup
connection(c, j, jgroup)
for n in range(num_jt):
cmds.parentConstraint(jj[n], d_jts[n])
cu_sc = ik_stretch(ikhnd[0])
cls_grp = cmds.group(em=True, name='vks_cluster_grp#')
ik_cls = cluster_on_curve(cu)
cmds.parent(ik_cls, cls_grp)
cmds.parent(d_jts[0], cls_grp, cu_sc, mov_grp)
cmds.parent(cu, ikhnd[0], vks_grp)
cmds.select(cl=True)
def pathCurveSet(self, plusLength):
self.nearParam_list = list()
self.getLength_list = list()
self.pathCrv_attLoc_list = list()
self.upPathLoc_list = list()
cmds.addAttr('root_CON', ln='run', at='double', dv=0)
cmds.setAttr('root_CON.run', e=True, k=True)
cmds.createNode('transform', n='pathSet_GRP', p='noneTransform_GRP')
cvStartPos = self.customBodyJointsPos[0]
setLength = self.disDMS + plusLength
curvePos = [0, cvStartPos[1], setLength]
pathSet_crv = cmds.curve(p=[cvStartPos, curvePos], d=1)
cmds.rebuildCurve(pathSet_crv, d=3, s=10)
self.pathSet_crv = cmds.rename(pathSet_crv, 'pathSet_CRV')
self.pathSet_crvShp = cmds.listRelatives(self.pathSet_crv, s=1)[0]
pathSet_CIF = cmds.createNode('curveInfo', n='pathSet_CIF')
for i in self.FKNull:
nearDCM = cmds.createNode('decomposeMatrix')
nearestNode = cmds.createNode('nearestPointOnCurve')
arcLengthDMS = cmds.arcLengthDimension('%s.u[0]' %
self.pathSet_crv)
curveShape = cmds.listRelatives(self.pathSet_crv, s=1)[0]
cmds.connectAttr('%s.worldMatrix[0]' % i,
'%s.inputMatrix' % nearDCM)
cmds.connectAttr('%s.worldSpace[0]' % curveShape,
'%s.inputCurve' % nearestNode)
cmds.connectAttr('%s.outputTranslate' % nearDCM,
'%s.inPosition' % nearestNode)
nearParam = cmds.getAttr('%s.parameter' % nearestNode)
self.nearParam_list.append(nearParam)
cmds.setAttr('%s.uParamValue' % arcLengthDMS, nearParam)
getLength = cmds.getAttr('%s.arcLength' % arcLengthDMS)
self.getLength_list.append(getLength)
cmds.delete(nearDCM, nearestNode, arcLengthDMS)
#return getLength
print '%s.param = "%s"' % (i, nearParam)
print '%s.length = "%s"' % (i, getLength)
#return getLength,nearParam
pathCrv_attLoc = cmds.spaceLocator(
n=self.FKNull[self.FKNull.index(i)] + '_attatch_LOC')[0]
self.pathCrv_attLoc_list.append(pathCrv_attLoc)
cmds.setAttr('%s.template' % pathCrv_attLoc, 1)
cmds.hide(pathCrv_attLoc)
adl = cmds.createNode('addDoubleLinear',
n=pathCrv_attLoc.replace(
pathCrv_attLoc.split('_')[-1], 'ADL'))
clp = cmds.createNode('curveLength2ParamU',
n=pathCrv_attLoc.replace(
pathCrv_attLoc.split('_')[-1], 'CLP'))
poci = cmds.createNode('pointOnCurveInfo',
n=pathCrv_attLoc.replace(
pathCrv_attLoc.split('_')[-1], 'POCI'))
cmds.connectAttr('root_CON.run', '%s.input2' % adl)
cmds.setAttr('%s.input1' % adl, getLength)
cmds.connectAttr('%s.output' % adl, '%s.inputLength' % clp)
cmds.connectAttr('%s.worldSpace[0]' % self.pathSet_crvShp,
'%s.inputCurve' % clp)
cmds.connectAttr('%s.worldSpace[0]' % self.pathSet_crvShp,
'%s.inputCurve' % poci)
cmds.connectAttr('%s.outputParamU' % clp, '%s.parameter' % poci)
cmds.connectAttr('%s.position' % poci,
'%s.translate' % pathCrv_attLoc)
# reverse variable
pathCrv_attLoc_list_rev_range = list()
self.pathCrv_attLoc_list_rev = list(
) # pathCurve attatch Locator list reverse variable
FKNull_rev_range = list()
self.FKNull_rev = list() # fk null reverse variable
for j in self.pathCrv_attLoc_list:
pathCrv_attLoc_list_rev_range.append(
self.pathCrv_attLoc_list.index(j))
pathCrv_attLoc_list_rev_range.reverse()
for i in pathCrv_attLoc_list_rev_range:
self.pathCrv_attLoc_list_rev.append(self.pathCrv_attLoc_list[i])
for j in self.FKNull:
FKNull_rev_range.append(self.FKNull.index(j))
FKNull_rev_range.reverse()
for i in FKNull_rev_range:
self.FKNull_rev.append(self.FKNull[i])
for k in self.pathCrv_attLoc_list_rev: # controller upVec set and < pathCrv_attLoc connect to FKNull >
locXform = cmds.xform(k, ws=True, q=True, t=True)
upPathLoc = cmds.spaceLocator(
n=k.replace(k.split('_')[-1], 'upVec_LOC'),
p=(locXform[0], locXform[1], locXform[2]))[0]
self.upPathLoc_list.append(upPathLoc)
cmds.CenterPivot(upPathLoc)
cmds.setAttr('%s.template' % upPathLoc, 1)
cmds.setAttr('%s.ty' % upPathLoc, 20)
temp_MMX = cmds.createNode('multMatrix',
n=k.replace(k.split('_')[-1], 'MMX'))
temp_DCM = cmds.createNode('decomposeMatrix',
n=k.replace(k.split('_')[-1], 'DCM'))
if self.pathCrv_attLoc_list_rev.index(k) is 0:
cmds.connectAttr('%s.worldMatrix[0]' % k,
'%s.matrixIn[0]' % temp_MMX)
cmds.connectAttr('root_CON.worldInverseMatrix[0]',
'%s.matrixIn[1]' % temp_MMX)
cmds.connectAttr('%s.matrixSum' % temp_MMX,
'%s.inputMatrix' % temp_DCM)
cmds.connectAttr(
'%s.outputTranslate' % temp_DCM, '%s.translate' %
self.FKNull_rev[self.pathCrv_attLoc_list_rev.index(k)])
cmds.connectAttr(
'%s.outputRotate' % temp_DCM, '%s.rotate' %
self.FKNull_rev[self.pathCrv_attLoc_list_rev.index(k)])
elif self.pathCrv_attLoc_list_rev.index(k) is not 0:
cmds.connectAttr('%s.worldMatrix[0]' % k,
'%s.matrixIn[0]' % temp_MMX)
cmds.connectAttr(
'%s.worldInverseMatrix[0]' % self.pathCrv_attLoc_list_rev[
self.pathCrv_attLoc_list_rev.index(k) - 1],
'%s.matrixIn[1]' % temp_MMX)
cmds.connectAttr('%s.matrixSum' % temp_MMX,
'%s.inputMatrix' % temp_DCM)
cmds.connectAttr(
'%s.outputTranslate' % temp_DCM, '%s.translate' %
self.FKNull_rev[self.pathCrv_attLoc_list_rev.index(k)])
cmds.connectAttr(
'%s.outputRotate' % temp_DCM, '%s.rotate' %
self.FKNull_rev[self.pathCrv_attLoc_list_rev.index(k)])
# IKSub_loc_list , for curveVis locator
self.IKSub_loc_list = list()
for i in self.IKSubCon:
IKSub_loc = cmds.spaceLocator(
n=i.replace(i.split('_')[-1], 'LOC'))[0]
cmds.parentConstraint(i, IKSub_loc, mo=0)
self.IKSub_loc_list.append(IKSub_loc)
cmds.parent(IKSub_loc, 'upVecVisCurve_GRP')
cmds.toggle(IKSub_loc, template=True)
cmds.hide(IKSub_loc)
self.IKSub_loc_list.reverse()
# set upvec con
self.upVecPathLocControlSet()
# tangent constraint
for i in self.pathCrv_attLoc_list:
cmds.tangentConstraint(
self.pathSet_crv,
i,
aim=[0.0, 0.0, 1.0],
u=[0.0, 1.0, 0.0],
wut='object',
wuo='%s' %
self.upPathLoc_list[self.pathCrv_attLoc_list_rev.index(i)])
# set root matrix
self.addRootMatrix()
# set node hierachy structure
self.setNodeHierachy_second()
def VK_system(num_ctr=1, num_jt=20, fk=True):
"""
final assembly of the entire system
"""
fk_hide_attr = lambda node, b: [
cmds.setAttr('%s.%s' % (node, a), l=b, k=not b)
for a in 'tx,ty,tz,sx,sy,sz,v'.split(',')
]
ik_hide_attr = lambda node, b: [
cmds.setAttr('%s.%s' % (node, a), l=b, k=not b)
for a in 'tx,ty,tz,ry,rz,sx,sy,sz,v'.split(',')
]
ctrl_hide_attr = lambda node, b: [
cmds.setAttr('%s.%s' % (node, a), l=b, k=not b)
for a in 'rx,ry,rz,sx,sy,sz,v'.split(',')
]
orig_cu = setup.get_curve()[0]
cu = cmds.duplicate(orig_cu, n='vks_curve#')[0]
jts = setup.chain(cu, num_jt, 'vks_orig_joint')
d_jts = setup.chain(cu, num_jt, 'vks_skin_joint')
cmds.toggle(d_jts, localAxis=True)
parameter_attr(jts)
# loft,skin
surf = create_loft(jts, 'vks_lofted_mesh')
surf_s = cmds.listRelatives(surf, c=1)[0]
# hierarchical groups
vks_grp = cmds.group(surf, name='VariableKinematicsSystem#')
mov_grp = cmds.group(em=True, parent=vks_grp, name='vks_move_grp#')
rig_grp = cmds.group(em=True, parent=vks_grp, name='vks_rig_grp#')
flc_grp = cmds.group(em=True, parent=rig_grp, name='vks_follice_grp#')
setup.lock_attr(flc_grp, 1)
setup.off_vis(rig_grp)
# create vks controls
vks_ctr = []
vks_ctr_grp = []
for i in range(num_ctr):
# create follice
vPos = setup.linstep(0., num_ctr - 1, i)
flc = setup.create_follicle(surf_s, 0.5, vPos, 'vks_follice')
flc_tr = cmds.listRelatives(flc, p=1)[0]
cmds.parent(flc_tr, flc_grp)
# create control
vkss = create_control(flc, 'vks_parametric')
vks_ctr_grp.append(vkss[0])
vks_ctr.append(vkss[-1])
# ikspline
ikhnd = cmds.ikHandle(sj=jts[0],
ee=jts[-1],
c=cu,
ccv=False,
sol='ikSplineSolver')
# create joint orig group
org_grp = cmds.group(jts[0], parent=rig_grp, n='vks_orig_grp#')
rot = cmds.xform(jts[0], q=True, ws=True, ro=True)
cmds.xform(org_grp, ws=True, ro=(rot[0], rot[1], rot[2]), piv=(0, 0, 0))
cmds.parent(cu, ikhnd[0], rig_grp)
# building explicit control
m_ctr = setup.ctrl_cube('vks_explicit#', sz=2)
cmds.parent(m_ctr, vks_grp)
tr = cmds.xform(jts[0], q=True, ws=True, t=True)
cmds.xform(m_ctr, ws=True, t=tr)
cmds.makeIdentity(m_ctr, apply=1, t=1, r=1, s=1, n=0)
cmds.parent(vks_ctr_grp, m_ctr)
cmds.parentConstraint(m_ctr, org_grp, mo=1)
cmds.parentConstraint(m_ctr, mov_grp, mo=1)
cmds.scaleConstraint(m_ctr, mov_grp)
if fk: # FK module
for c in vks_ctr:
fk_hide_attr(c, 1)
for j in jts:
jgroup = cmds.group(j, n='%s_%s' % (j, c))
piv = cmds.xform(j, q=True, ws=True, piv=True)
cmds.xform(jgroup, ws=True, piv=(piv[0], piv[1], piv[2]))
connection(c, j, jgroup)
for n, j in enumerate(jts):
cmds.parentConstraint(j, d_jts[n])
# fk length
cmds.addAttr(m_ctr, ln='length', at='double', k=1, min=0, max=10, dv=1)
v_tx = cmds.getAttr('%s.tx' % jts[1])
pma = cmds.createNode('plusMinusAverage',
n='vfk_lengthConversion_%s' % m_ctr)
cmds.setAttr("%s.input1D[0]" % pma, -1)
cmds.setAttr("%s.input1D[1]" % pma, v_tx)
cmds.connectAttr('%s.length' % m_ctr, '%s.input1D[2]' % pma)
for j in jts[1:-1]:
cmds.connectAttr('%s.output1D' % pma, '%s.tx' % j)
cmds.scaleConstraint(m_ctr, org_grp)
cmds.parent(d_jts[0], mov_grp)
cmds.delete(ikhnd)
if not fk: # IK module
jj = [j for j in jts]
for c in vks_ctr:
ik_hide_attr(c, 1)
for n, j in enumerate(jts):
jgroup = cmds.group(em=True, n='%s_%s' % (j, c), parent=jj[n])
jj[n] = jgroup
connection(c, j, jgroup)
for n in range(num_jt):
cmds.parentConstraint(jj[n], d_jts[n])
# ik stretch
cu_sc = ik_stretch(ikhnd[0])
cmds.addAttr(m_ctr,
ln="stretch",
at='double',
k=1,
min=0,
max=10,
dv=10)
ucn = setup.onetenthNode(m_ctr, 'stretch')
cmds.connectAttr('%s.output' % ucn, '%s.ik_stretch' % ikhnd[0])
cls_grp = cmds.group(em=True, name='vks_cluster_grp#')
setup.off_vis(cls_grp)
ik_cls = cluster_on_curve(cu)
for ik_cl in ik_cls:
l_ctrl, l_null = setup.local_cluster_control2(ik_cl)
ctrl_hide_attr(l_ctrl, 1)
cmds.parent(l_ctrl, m_ctr)
cmds.parent(ik_cl, l_null, cls_grp)
cmds.parent(d_jts[0], cls_grp, cu_sc, mov_grp)
cmds.select(cl=True)
