def maya_move(angular_velocity, time_step):
objects = cmds.ls(sl=True)
if objects == []:
print('* Please select at least an object.')
return
trajectory = cmds.ls('trajectory')
for i, o in enumerate(objects):
x = cmds.getAttr(o + '.translateX')
y = cmds.getAttr(o + '.translateY')
z = cmds.getAttr(o + '.translateZ')
loc = [x, y, z]
state = make_state(loc)
state = simulate_circle(state, angular_velocity, time_step)
old_loc = loc
loc = get_location(state)
cmds.select(o)
cmds.move(loc[0], loc[1], loc[2])
# draw trajectory for the first object
if i == 0:
if trajectory == []:
cv = cmds.curve(point=[old_loc, loc], degree=1)
cmds.rename(cv, 'trajectory')
else:
cmds.curve('trajectory', point=[loc], degree=1, append=True)
# keep all objects selected
cmds.select(objects)
def createCurveaBasedOnLocator( prevLoc, loc, baseName, hrsSys ): leastSquaresMod = mn.createNode( 'leastSquaresModifier' ) origCurv = crv.Curve( mc.curve( d = 1, ep = [prevLoc.worldPosition, loc.worldPosition] ) ) index = mm.eval( 'getNextFreeMultiIndex( "'+ hrsSys.name +'.inputHair", 0 )' ) origCurv.name = 'spiderWeb_base_'+ baseName + '_' + str( index ) + '_CRV' mc.rebuildCurve( origCurv.name, rpo = 1, rt = 0, end = 1, kr = 0, kcp = 1, kep = 1, kt =0, s= 4, d = 1, tol = 0.01 ) origCurv.a.intermediateObject.v = 1 controledCurv = origCurv.duplicate() origCurv.shape.attr( 'worldSpace[0]' ) >> leastSquaresMod.a.inputNurbsObject prevLoc.attr( 'worldPosition[0]') >> leastSquaresMod.attr( 'pointConstraint[0].pointPositionXYZ' ) leastSquaresMod.attr( 'pointConstraint[0].pointConstraintU' ).v = 0 loc.attr( 'worldPosition[0]') >> leastSquaresMod.attr( 'pointConstraint[1].pointPositionXYZ' ) leastSquaresMod.attr( 'pointConstraint[1].pointConstraintU' ).v = 1 leastSquaresMod.a.outputNurbsObject >> controledCurv.shape.a.create controledCurv.shape.attr( 'worldMatrix[0]' ) >> leastSquaresMod.a.worldSpaceToObjectSpace fol = mn.createNode( 'follicle' ) fol.a.restPose.v = 1 fol.a.startDirection.v = 1 fol.a.pointLock.v = 3 fol.a.degree.v = 3 fol.a.sampleDensity.v = 3 fol.a.outHair >> hrsSys.attr( 'inputHair[' + str( index ) + ']' ) hrsSys.attr( 'outputHair[' + str( index ) + ']' ) >> fol.a.currentPosition controledCurv.shape.attr( 'worldSpace[0]' ) >> fol.a.startPosition curv = crv.Curve( mc.curve( d = 3, ep = [prevLoc.worldPosition, loc.worldPosition] ) ) curv.name = 'spiderWeb_' + baseName + '_' + str( index ) + '_CRV' fol.a.outCurve >> curv.a.create folPar = fol.parent folPar.name = 'spiderWeb_' + baseName + '_' + str( index ) + '_FOL' return curv, folPar
def createCurve(ptList,start,end,group=''): ''' ''' # Initialize Curves crvList = [] for pt in ptList: pos = mc.pointPosition(pt) curve = mc.curve(p=[pos,pos],d=1) curve = mc.rename(curve,pt+'_curve') crvList.append(curve) # Track Curves for i in range(start,end+1): mc.currentTime(i) for n in range(len(ptList)): pos = mc.pointPosition(ptList[n]) mc.curve(crvList[n],a=True,p=pos) # Remove Initial CV and Rebuild for crv in crvList: mc.delete(crv+'.cv[0]') mc.rebuildCurve(crv,ch=False,rpo=True,rt=0,end=1,kr=2,kcp=True,kep=True) # Group Curves if group: # Check Group if not mc.objExists(group): group = mc.group(em=True,n=group) # Parent Curves to Group mc.parent(crvList,group) # Return Result if group: return [group] else: return crvList
def createCurveOnTargetPoints( targets, degrees=3 ):
trObjs = []
curvePoints = []
for taregt in targets:
if cmds.nodeType( taregt ) in ['joint', 'transform']:
trObjs.append( taregt )
curvePoints.append( [0,0,0] )
if len( targets ) == 2:
crv = cmds.curve( p=curvePoints, d=1 )
elif len( targets ) ==3:
crv = cmds.curve( p=curvePoints, d=2 )
else:
crv = cmds.curve( p=curvePoints, d=degrees )
crvShape= cmds.listRelatives( crv, s=1 )[0]
for trObj in trObjs:
i = trObjs.index( trObj )
mmdc = cmds.createNode( 'multMatrixDecompose' )
cmds.connectAttr( trObj+'.wm', mmdc+'.i[0]' )
cmds.connectAttr( crvShape+'.pim', mmdc+'.i[1]' )
cmds.connectAttr( mmdc+'.ot', crvShape+'.controlPoints[%d]' % i )
return crv
def corners(self):
"""
Create corners control
"""
ctrl = cmds.createNode('transform')
pts = [(0.9, 0.0, 1.0), (1.0, 0.0, 1.0), (1.0, 0.0, 0.9)]
cnr = cmds.curve(d=1, p=pts, k=range(3))
cnrShape = cmds.listRelatives(cnr, s=True, ni=True)[0]
cmds.parent(cnrShape, ctrl, s=True, r=True)
pts = [(-0.9, 0.0, 1.0), (-1.0, 0.0, 1.0), (-1.0, 0.0, 0.9)]
cnr = cmds.curve(d=1, p=pts, k=range(3))
cnrShape = cmds.listRelatives(cnr, s=True, ni=True)[0]
cmds.parent(cnrShape, ctrl, s=True, r=True)
pts = [(0.9, 0.0, -1.0), (1.0, 0.0, -1.0), (1.0, 0.0, -0.9)]
cnr = cmds.curve(d=1, p=pts, k=range(3))
cnrShape = cmds.listRelatives(cnr, s=True, ni=True)[0]
cmds.parent(cnrShape, ctrl, s=True, r=True)
pts = [(-0.9, 0.0, -1.0), (-1.0, 0.0, -1.0), (-1.0, 0.0, -0.9)]
cnr = cmds.curve(d=1, p=pts, k=range(3))
cnrShape = cmds.listRelatives(cnr, s=True, ni=True)[0]
cmds.parent(cnrShape, ctrl, s=True, r=True)
return ctrl
def lollipopController(name, color = 0, size = [1, 1, 1], lockAttr = ['tr', 'ro', 'sc', 'vi'], lock = True):
#cmds.createNode('transform', n = '%s_grp' %name)
cmds.curve(n = name, d = 1, p = [ (0, 0, 0), (0, 3, 0),(0, 4, 1),(0, 5, 0), (0, 4, -1),(0, 3, 0),(0, 4, 1),(0, 4, -1)], k = [1,2,3,4,5,6,7,8])
cmds.scale(size[0],size[1],size[2])
for attr in lockAttr:
if attr == 'tr':
cmds.setAttr('%s.translateX' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.translateY' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.translateZ' %name, lock = lock, keyable = False, channelBox = False)
elif attr == 'ro':
cmds.setAttr('%s.rotateX' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.rotateY' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.rotateZ' %name, lock = lock, keyable = False, channelBox = False)
elif attr == 'sc':
cmds.setAttr('%s.scaleX' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.scaleY' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.scaleZ' %name, lock = lock, keyable = False, channelBox = False)
elif attr == 'vi':
cmds.setAttr('%s.visibility' %name, lock = True, keyable = False, channelBox = False)
shapeNode = cmds.listRelatives(name)
cmds.setAttr('%s.overrideEnabled' %shapeNode[0], 1)
cmds.setAttr('%s.overrideColor' %shapeNode[0], color)
util.group(name, '%s_grp' %name)
return name
def obj_single_rotate ():
ctrl_shapes = []
ctrl_shapes.append( mc.curve( p = [( -7.105427357601002e-15, -0.3358735290035888, 0.7361468691490706 ), ( -0.030221345939771993, -0.43042515285533867, 0.6908148502394227 ), ( -0.072472769789524, -0.5107046042608161, 0.6274377144647979 ), ( -0.12400997464880703, -0.5684975545498503, 0.5501319071758723 ), ( -0.12400997464880703, -0.5684975545498503, 0.5501319071758723 ), ( -0.12400997464880703, -0.5684975545498503, 0.5501319071758723 ), ( -0.12400997464880703, -0.5819931861859402, 0.5346306603447717 ), ( -0.12400997464880703, -0.5819931861859402, 0.5346306603447717 ), ( -0.12400997464880703, -0.5819931861859402, 0.5346306603447717 ), ( -0.12400997464880703, -0.5819931861859402, 0.5346306603447717 ), ( -0.08197748359885537, -0.540253001036092, 0.5946770761304137 ), ( -0.04551343522386375, -0.48527382262420815, 0.6467685738089758 ), ( -0.015501246831107096, -0.4192182992656619, 0.6896431286557706 ), ( -0.015501246831107096, -0.4192182992656619, 0.6896431286557706 ), ( -0.015501246831107096, -0.4192182992656619, 0.6896431286557706 ), ( -0.015501246831107096, -0.7077292503941806, 0.43808875481816606 ), ( -0.015501246831107096, -0.80800092168273, -0.016811817720621902 ), ( -0.015501246831107096, -0.6943482219457593, -0.34108941639861884 ), ( -0.015501246831107096, -0.5527220271320061, -0.5148315398676033 ), ( -0.015501246831107096, -0.3348935247151239, -0.6771644412642893 ), ( -0.015501246831107096, -0.1758560186022855, -0.7361468691392242 ), ( -0.015501246831107096, -7.844604263429887e-05, -0.7361468691392242 )], per = False, d = 3, k = [0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 19, 19] ) )
ctrl_shapes.append( mc.curve( p = [( 3.552713678800501e-15, -0.3358735290035959, 0.7361468691490706 ), ( 0.03022134593976844, -0.43042515285534577, 0.6908148502394227 ), ( 0.07247276978952044, -0.5107046042608232, 0.6274377144647979 ), ( 0.12400997464880348, -0.5684975545498574, 0.5501319071758723 ), ( 0.12400997464880348, -0.5684975545498574, 0.5501319071758723 ), ( 0.12400997464880348, -0.5684975545498574, 0.5501319071758723 ), ( 0.12400997464880348, -0.5819931861859473, 0.5346306603447717 ), ( 0.12400997464880348, -0.5819931861859473, 0.5346306603447717 ), ( 0.12400997464880348, -0.5819931861859473, 0.5346306603447717 ), ( 0.12400997464880348, -0.5819931861859473, 0.5346306603447717 ), ( 0.08197748359885182, -0.5402530010360991, 0.5946770761304137 ), ( 0.0455134352238602, -0.48527382262421526, 0.6467685738089758 ), ( 0.015501246831103543, -0.419218299265669, 0.6896431286557706 ), ( 0.015501246831103543, -0.419218299265669, 0.6896431286557706 ), ( 0.015501246831103543, -0.419218299265669, 0.6896431286557706 ), ( 0.015501246831103543, -0.7077292503941877, 0.43808875481816606 ), ( 0.015501246831103543, -0.8080009216827371, -0.016811817720621902 ), ( 0.015501246831103543, -0.6943482219457664, -0.34108941639861884 ), ( 0.015501246831103543, -0.5527220271320132, -0.5148315398676033 ), ( 0.015501246831103543, -0.334893524715131, -0.6771644412642893 ), ( 0.015501246831103543, -0.1758560186022926, -0.7361468691392242 ), ( 0.015501246831103543, -7.844604263433487e-05, -0.7361468691392242 )], per = False, d = 3, k = [0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 19, 19] ) )
ctrl_shapes.append( mc.curve( p = [( 0.0, 0.33587352900359235, 0.7361468691490706 ), ( -0.030221345939764888, 0.4304251528553422, 0.6908148502394227 ), ( -0.07247276978951689, 0.5107046042608197, 0.6274377144647979 ), ( -0.12400997464879993, 0.5684975545498538, 0.5501319071758723 ), ( -0.12400997464879993, 0.5684975545498538, 0.5501319071758723 ), ( -0.12400997464879993, 0.5684975545498538, 0.5501319071758723 ), ( -0.12400997464879993, 0.5819931861859438, 0.5346306603447717 ), ( -0.12400997464879993, 0.5819931861859438, 0.5346306603447717 ), ( -0.12400997464879993, 0.5819931861859438, 0.5346306603447717 ), ( -0.12400997464879993, 0.5819931861859438, 0.5346306603447717 ), ( -0.08197748359884827, 0.5402530010360955, 0.5946770761304137 ), ( -0.045513435223856646, 0.4852738226242117, 0.6467685738089758 ), ( -0.01550124683109999, 0.41921829926566545, 0.6896431286557706 ), ( -0.01550124683109999, 0.41921829926566545, 0.6896431286557706 ), ( -0.01550124683109999, 0.41921829926566545, 0.6896431286557706 ), ( -0.01550124683109999, 0.7077292503941841, 0.43808875481816606 ), ( -0.01550124683109999, 0.8080009216827335, -0.016811817720621902 ), ( -0.01550124683109999, 0.6943482219457628, -0.34108941639861884 ), ( -0.01550124683109999, 0.5527220271320097, -0.5148315398676033 ), ( -0.01550124683109999, 0.33489352471512746, -0.6771644412642893 ), ( -0.01550124683109999, 0.17585601860228905, -0.7361468691392242 ), ( -0.01550124683109999, 7.844604263078215e-05, -0.7361468691392242 )], per = False, d = 3, k = [0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 19, 19] ) )
ctrl_shapes.append( mc.curve( p = [( 3.552713678800501e-15, 0.33587352900359235, 0.7361468691490706 ), ( 0.03022134593976844, 0.4304251528553422, 0.6908148502394227 ), ( 0.07247276978952044, 0.5107046042608197, 0.6274377144647979 ), ( 0.12400997464880348, 0.5684975545498538, 0.5501319071758723 ), ( 0.12400997464880348, 0.5684975545498538, 0.5501319071758723 ), ( 0.12400997464880348, 0.5684975545498538, 0.5501319071758723 ), ( 0.12400997464880348, 0.5819931861859438, 0.5346306603447717 ), ( 0.12400997464880348, 0.5819931861859438, 0.5346306603447717 ), ( 0.12400997464880348, 0.5819931861859438, 0.5346306603447717 ), ( 0.12400997464880348, 0.5819931861859438, 0.5346306603447717 ), ( 0.08197748359885182, 0.5402530010360955, 0.5946770761304137 ), ( 0.0455134352238602, 0.4852738226242117, 0.6467685738089758 ), ( 0.015501246831103543, 0.41921829926566545, 0.6896431286557706 ), ( 0.015501246831103543, 0.41921829926566545, 0.6896431286557706 ), ( 0.015501246831103543, 0.41921829926566545, 0.6896431286557706 ), ( 0.015501246831103543, 0.7077292503941841, 0.43808875481816606 ), ( 0.015501246831103543, 0.8080009216827335, -0.016811817720621902 ), ( 0.015501246831103543, 0.6943482219457628, -0.34108941639861884 ), ( 0.015501246831103543, 0.5527220271320097, -0.5148315398676033 ), ( 0.015501246831103543, 0.33489352471512746, -0.6771644412642893 ), ( 0.015501246831103543, 0.17585601860228905, -0.7361468691392242 ), ( 0.015501246831103543, 7.844604263078215e-05, -0.7361468691392242 )], per = False, d = 3, k = [0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 19, 19] ) )
return ctrl_shapes
def arrowController(name, color = 0, lockAttr = ['sc', 'vi'], lock = True):
cmds.curve(n = name , d = 1, p = [(0, 2, 1),(0, 3, 1),(0, 0, 3), (0, -3, 1), (0, -2, 1), (0, -2, -2), (0, 2, -2), (0, 2, 1), (0, -2, -2), (0, 2, -2), (0, -2, 1)], k = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
cmds.createNode('transform', n = '%s_grp' %name)
#lock Attribute
for attr in lockAttr:
if attr == 'tr':
cmds.setAttr('%s.translateX' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.translateY' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.translateZ' %name, lock = lock, keyable = False, channelBox = False)
elif attr == 'ro':
cmds.setAttr('%s.rotateX' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.rotateY' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.rotateZ' %name, lock = lock, keyable = False, channelBox = False)
elif attr == 'sc':
cmds.setAttr('%s.scaleX' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.scaleY' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.scaleZ' %name, lock = lock, keyable = False, channelBox = False)
elif attr == 'vi':
cmds.setAttr('%s.visibility' %name, lock = lock, keyable = False, channelBox = False)
#color change
shapeNode = cmds.listRelatives(name)
cmds.rename(shapeNode, name + 'Shape')
cmds.setAttr(name + 'Shape.overrideEnabled', 1)
cmds.setAttr(name + 'Shape.overrideColor', color)
cmds.select(name, r = True)
cmds.select('%s_grp' %name, tgl = True)
cmds.parent()
return name
def buildNurbsRibbon(self): if self.guideSpline: guideDeg = cmds.getAttr(self.guideSpline + '.degree' ) guideSpan = cmds.getAttr(self.guideSpline + '.spans' ) oneCurvePoints = [] otherCurvePoints = [] for i in xrange(guideDeg + guideSpan): cvPos = cmds.pointPosition(self.guideSpline + '.cv[' + str(i) + "]", w=True ) newPara = cmds.closestPointOnCurve(self.guideSpline, ip=cvPos, paramU=True) #Find the parameter Value newParaVal = cmds.getAttr(newPara + ".paramU") cmds.delete(newPara) infoNode = cmds.pointOnCurve(self.guideSpline, ch=True, pr=newParaVal) #Now find the Position and tangent! posy = (cmds.getAttr(infoNode + ".position"))[0] # returns the position posy = MVector(posy[0],posy[1],posy[2]) normy = (cmds.getAttr(infoNode + ".tangent"))[0] normy = MVector(normy[0],normy[1],normy[2]) #Use MVector from maya.openMaya normy = normy.normal() vertVect = MVector(0,1,0) sideMove = normy^vertVect #This is the notation for a cross product. Pretty cool. Should be a normal movement sideMove = sideMove.normal() * 0.5 sideMovePos = posy + sideMove otherSideMovePos = posy - sideMove oneCurvePoints.append([sideMovePos[0],sideMovePos[1],sideMovePos[2]]) otherCurvePoints.append([otherSideMovePos[0],otherSideMovePos[1],otherSideMovePos[2]]) oneSideCurve = cmds.curve(editPoint = oneCurvePoints, degree=3) OtherSideCurve = cmds.curve(editPoint = otherCurvePoints, degree=3) self.tempConstructionParts.append(oneSideCurve) self.tempConstructionParts.append(OtherSideCurve) #Now we loft the surface between the two Curves! nameStart = nameBase(self.totalMarkerList[0].getName(), self.searchString, "loc", "nbs") nameStart += "ribbonSurface" self.guideNurbsRibbon = cmds.loft(oneSideCurve, OtherSideCurve, name = nameStart, constructionHistory = True, uniform = True, close = False, autoReverse = True, degree = 3, sectionSpans = 1, range = False, polygon = 0, reverseSurfaceNormals = True) self.guideNurbsRibbon = self.guideNurbsRibbon[0] self.ribbonParts.append(self.guideNurbsRibbon)
def createCurve(self,*args):
"""
Create curve on locators
"""
prefix = mc.textFieldGrp(self.prefixFld,query=True,text=True)
locators = mc.ls(sl=True,fl=True)
rotations = mc.intFieldGrp(self.rotFld,query=True,v1=True)
#Error checking here: Are locators selected?
if len(locators) == 0:
print '\nSelection is empty. Please select locators.\n'
#create splineIK curve
curve = " "
x = 0
while x < rotations:
for each in locators:
try: #Try to append to existing curve
x_loc = mc.getAttr('%s.localPositionX'%each)
y_loc = mc.getAttr('%s.localPositionY'%each)
z_loc = mc.getAttr('%s.localPositionZ'%each)
mc.curve(curve,a=True,p=(x_loc,y_loc,z_loc) )
except: #If appending fails, means a new curve needs to be created
x_loc = mc.getAttr('%s.localPositionX'%each)
y_loc = mc.getAttr('%s.localPositionY'%each)
z_loc = mc.getAttr('%s.localPositionZ'%each)
curve = mc.curve( p=(x_loc,y_loc,z_loc), n='%s_ikCurve'%prefix )
x = x + 1
def createLine(_parents, _sceneData = False, _layer = False):
nodes = []
lineCurve = ""
firstTime = True
for obj in _parents:
pos = cmds.xform(obj, q=1, t=1, ws=1)
if firstTime:
lineCurve = cmds.curve(d=1, p=[pos])
nodes.append(lineCurve)
cmds.setAttr(lineCurve+".overrideEnabled", 1)
cmds.setAttr(lineCurve+".overrideDisplayType", 2)
cmds.setAttr(lineCurve+".inheritsTransform", 0)
firstTime = False
else:
cmds.curve(lineCurve, a=True, p=pos)
#Clusters must be added after all the cvs are created.
#Don't ask me why!
for j in range(len(_parents)):
clusterName = _parents[j]+"_CLUSTER"
clusterPoint = cmds.cluster(lineCurve+".cv["+str(j)+"]", n=clusterName)
nodes.append(clusterPoint[1])
#cmds.setAttr(clusterPoint[1]+".visibility", 0)
cmds.parent(clusterPoint[1], _parents[j], a=1)
if(_sceneData):
addToLayer(_sceneData, "hidden", nodes)
if _layer:
addToLayer(_sceneData, _layer, lineCurve)
return nodes
def createPoleVector(self, prefix=None, distanceScale=2, verbose=False):
print 'Building pole vector...'
if prefix is None:
prefix = self.prefix
# Create Joint Vectors
shoulderIkPos = cmds.xform(self.shoulder, q=True, ws=True, t=True)
shoulderIkVec = OpenMaya.MVector(shoulderIkPos[0], shoulderIkPos[1], shoulderIkPos[2])
elbowIkPos = cmds.xform(self.elbow, q=True, ws=True, t=True)
elbowIkVec = OpenMaya.MVector(elbowIkPos[0], elbowIkPos[1], elbowIkPos[2])
wristIkPos = cmds.xform(self.wrist, q=True, ws=True, t=True)
wristIkVec = OpenMaya.MVector(wristIkPos[0], wristIkPos[1], wristIkPos[2])
# Transpose vectors to correct pole vector translation point
bisectorVec = (shoulderIkVec * 0.5) + (wristIkVec * 0.5)
transposedVec = (elbowIkVec * distanceScale) - (bisectorVec * distanceScale)
ikChainPoleVec = bisectorVec + transposedVec
# Create a pole vector
poleVecCon = self.utils.createBoxControl('%selbowPV' % self.prefix, 0.125)
poleVecPos = [ikChainPoleVec.x, ikChainPoleVec.y, ikChainPoleVec.z]
cmds.xform(poleVecCon, t=poleVecPos)
self.utils.orientSnap(self.elbow, poleVecCon)
# Visualize Vectors and End Points
if verbose:
for vector, letter in zip([bisectorVec, transposedVec, ikChainPoleVec,
shoulderIkVec, elbowIkVec, wristIkVec],
['bisectorVec', 'transposedVec', 'ikChainPoleVec',
'shoulderIk', 'elbowIk', 'wristIk']):
cmds.spaceLocator(n='%sVecLoc' % letter, p=[vector.x, vector.y, vector.z])
cmds.curve(n='%sVecCurve' % letter, degree=1, p=[(0, 0, 0), (vector.x, vector.y, vector.z)])
return poleVecCon
def createSquare(*args):
cmds.curve(d=1,p=[(0.5,0,0.5), (-0.5,0,0.5),
(-0.5,0,-0.5),(0.5,0,-0.5),(0.5,0,0.5)],
k=[0,1,2,3,4],per=True)
cmds.scale(2.458224,2.459224,2.459224,r=True)
cmds.select(cl=True)
print 'Created a Nurbs Square'
def createTemplate(self , eyeMesh):
# create eye jnt
eyeJnt=[]
if 'L_' in str(eyeMesh):
helpClu = mc.cluster(eyeMesh)[0]
LeyeJnt = mc.joint(p=(0,0,0),name=eyeMesh+'_skin_jnt')
self.fromAtoB(eyeJnt,helpClu,1)
ReyeJnt = mc.mirrorJoint(mirrorYZ=True,mirrorBehavior=False,searchReplace=('L_', 'R_')
eyeJnt.append(LeyeJnt)
eyeJnt.append(ReyeJnt)
else:
self.mayaError('Please select the left eye.')
return eyeJnt
def createEyeRig(self):
if mc.objExists(self.eyeGlobalCtrl) == False:
EyesGlobalCtrl = mc.curve(d=1,p=[(-1.069806, 1.027703, 0),(-1.651954,1.89895,0),(-2.523201,2.481098,0),(-3.550904,2.68552,0),(-4.578607,2.481098,0),(-5.449854,1.89895,0),(-6.032002,1.027703,0),(-6.236424,0,0),(-6.032002,-1.027703,0),(-5.449854 ,-1.89895, 0),(-4.578607,-2.481098,0), (-3.550904,-2.68552,0),(-2.523201, -2.481098, 0),(-1.651954,-1.89895,0),(-1.069806,-1.027703,0),(1.058138,-1.032345,0),(1.642915, -1.907527,0),(2.518098,-2.492305,0),( 3.550443,-2.69765,0),(4.582788,-2.492305,0),(5.45797,-1.907527,0),( 6.042748,-1.032345,0),(6.248093,0,0),(6.042748,1.032345,0),( 5.45797,1.907527,0 ),(4.582788,2.492305,0),( 3.550443,2.69765,0),(2.518098,2.492305,0 ),(1.642915,1.907527,0),(1.058138,1.032345,0),( -1.069806,1.027703,0)],k=[0,1,2,3,4,5,6,7,8,9,10,11,12 ,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],n=self.eyeGlobalCtrl)
L_EyeAimCtrl = mc.curve(d=1,p=[(3.653116 ,0.946994,0), (3.653116 ,0 ,0),( 2.706122, 0, 0) , (3.653116 ,0, 0),(4.600109, 0 ,0) , (3.653116 ,0, 0) , (3.653116 ,-0.946994, 0) ],k=[0, 1, 2 ,3 ,4 ,5 , 6 ],n='L_'+self.eyeAimCtrl)
R_EyeAimCtrl = mc.curve(d=1,p=[(3.653116 ,0.946994,0), (3.653116 ,0 ,0),( 2.706122, 0, 0) , (3.653116 ,0, 0),(4.600109, 0 ,0) , (3.653116 ,0, 0) , (3.653116 ,-0.946994, 0) ],k=[0, 1, 2 ,3 ,4 ,5 , 6 ],n='R_'+self.eyeAimCtrl)
mc.parent(L_EyeAimCtrl , EyesGlobalCtrl)
mc.parent(R_EyeAimCtrl , EyesGlobalCtrl)
self.fastGrp('On' , ['zero','con','sdk'],L_EyeAimCtrl)
self.fastGrp'On' , ['zero','con','sdk'],R_EyeAimCtrl)
zeroGrp = self.fastGrp('On' , ['zero','con','sdk'],EyesGlobalCtrl)[2]
def extraController(name, color = 0, lockAttr = ['sc', 'vi'], lock = True):
cmds.createNode('transform', n = '%s_grp' %name)
cmds.curve(n = name, d = 1, p =[(-4, 0, -3),(-1, 0, -3),(-1, 0, -2),(-3, 0, -2),(-3, 0, -1), (-1, 0, -1),(-1, 0, 0),(-3, 0, 0),(-3, 0, 1),(-1, 0, 1),(-1, 0, 2),(-4, 0, 2),(-4, 0, -3),(3, 0, -3),(2, 0, -1),(2, 0, 0),(3, 0, 2),(2, 0, 2),(1, 0, 0),(0, 0, 2),(-1, 0, 2),(0, 0, 0),(0, 0, -1),(-1, 0, -3),(0, 0, -3),(1, 0, -1),(2, 0, -3),(3, 0, -3),(3, 0, 2),(-4, 0, 2)], k= [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29])
cmds.scale(0.2,0.2,0.2)
for attr in lockAttr:
if attr == 'tr':
cmds.setAttr('%s.translateX' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.translateY' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.translateZ' %name, lock = lock, keyable = False, channelBox = False)
elif attr == 'ro':
cmds.setAttr('%s.rotateX' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.rotateY' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.rotateZ' %name, lock = lock, keyable = False, channelBox = False)
elif attr == 'sc':
cmds.setAttr('%s.scaleX' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.scaleY' %name, lock = lock, keyable = False, channelBox = False)
cmds.setAttr('%s.scaleZ' %name, lock = lock, keyable = False, channelBox = False)
elif attr == 'vi':
cmds.setAttr('%s.visibility' %name, lock = lock, keyable = False, channelBox = False)
shapeNode = cmds.listRelatives(name)
cmds.setAttr('%s.overrideEnabled' %shapeNode[0], 1)
cmds.setAttr('%s.overrideColor' %shapeNode[0], color)
return name
def archimedes(loops,spiralIn,gaps,height):
'''
Creates a Archimedes spiral
loops : Number of complete turns the spiral should have
spiralIn : Direction of the generated curve
gaps : Distance between successive turnings
height : Vertical height of the spiral
The curve is created and the required number of control vertices is calculated
along with the fraction of the height each CV needs to be placed. The polar
equation of a Archimedes spiral is r=a+b*theta where a rotates the spiral
and b controls distance between successive turnings. The polar coordinates
are converted to Cartesian form by x=r*math.cos(theta) and y=r*math.sin(theta).
The direction of the curve can be reversed based on the spiralInwards flag.
'''
curve=cmds.curve(p=[(0,0,0)],n='curve_01')
cvNo=loops*8
heightFrac = float(height)/cvNo
for i in range(1,cvNo+1):
theta=i*(0.25*math.pi)
r=(gaps/(1.8*math.pi))*theta
x=r*math.cos(theta)
y=r*math.sin(theta)
cmds.curve(curve,a=True,p=[(x,i*heightFrac,y)])
if spiralIn==True:
cmds.reverseCurve(curve,ch=0,rpo=1)
def logarithmic(loops,spiralIn,growth,height):
'''
Creates a logarithmic spiral
loops : Number of complete turns the spiral should have
spiralIn : Direction of the generated curve
growth : Growth factor
height : Vertical height of the spiral
The curve is created and the required number of control vertices is calculated
along with the fraction of the height each CV needs to be placed. The polar
equation of a logarithmic spiral is r=a*e^(b*theta) where a scales the spiral
and b controls how tightly it winds. The polar coordinates are converted to
Cartesian form by x=r*math.cos(theta) and y=r*math.sin(theta). The direction
of the curve can be reversed based on the spiralInwards flag.
'''
curve=cmds.curve(p=[(0,0,0)],n='curve_01')
cvNo=loops*8
heightFrac = float(height)/cvNo
for i in range(1,cvNo+1):
theta=i*(0.25*math.pi)
r=0.1*(1/(1.8*math.pi))*math.e**(growth*theta)
x=r*math.cos(theta)
y=r*math.sin(theta)
cmds.curve(curve,a=True,p=[(x,i*heightFrac,y)])
if spiralIn==True:
cmds.reverseCurve(curve,ch=0,rpo=1)
def hyperbolic(loops,spiralIn,height):
'''
Creates a hyperbolic spiral
loops : Number of complete turns the spiral should have
spiralIn : Direction of the generated curve
height : Vertical height of the spiral
The curve is created and the required number of control vertices is calculated
along with the fraction of the height each CV needs to be placed. The polar
equation of a hyperbolic spiral is r=a/theta where a scales the spiral. The
polar coordinates are converted to Cartesian form by x=r*math.cos(theta) and
y=r*math.sin(theta). The direction of the curve can be reversed based on the
spiralInwards flag.
'''
curve=cmds.curve(p=[(0,0,0)],n='curve_01')
cvNo=loops*8
heightFrac = float(height)/cvNo
for i in range(1,cvNo+2):
theta=i*(0.25*math.pi)
r=theta**(-1)
x=r*math.cos(theta)
y=r*math.sin(theta)
cmds.curve(curve,a=True,p=[(x,i*heightFrac,y)])
cmds.delete(curve+'.cv[0]')
if spiralIn==False:
cmds.reverseCurve(curve,ch=0,rpo=1)
def archimedesDouble(loops,spiralDown,gaps,height):
'''
Creates a Archimedes spiral that spirals out then in again
loops : Number of complete turns the spiral should have
spiralDown : Direction of the generated curve
growth : Growth factor
height : Vertical height of the spiral
The curve is created and the required number of control vertices is calculated
along with the fraction of the height each CV needs to be placed. The polar
equation of a Archimedes spiral is r=a+b*theta where a rotates the spiral
and b controls distance between successive turnings. The polar coordinates
are converted to Cartesian form by x=r*math.cos(theta) and y=r*math.sin(theta).
After half the CVs, I reverse the equation to wind the spiral back in. The
direction of the curve can be reversed based on the spiralDown flag.
'''
curve=cmds.curve(p=[(0,0,0)],n='curve_01')
cvNo=int(loops*8)
heightFrac = float(height)/cvNo
for i in range(1,(cvNo/2)+1):
theta=i*(0.25*math.pi)
r=(gaps/(1.8*math.pi))*theta
x=r*math.cos(theta)
y=r*math.sin(theta)
cmds.curve(curve,a=True,p=[(x,i*heightFrac,y)])
for i in reversed(range(0,cvNo/2)):
theta=i*(0.25*math.pi)
r=(gaps/(1.8*math.pi))*theta
x=(r*math.cos(theta))
y=-(r*math.sin(theta))
cmds.curve(curve,a=True,p=[(x,height-i*heightFrac,y)])
if spiralDown==True:
cmds.reverseCurve(curve,ch=0,rpo=1)
def sqGenerateCurves(self, *args):
self.edgeList = cmds.ls(selection=True, flatten=True)
if not self.edgeList == None and not self.edgeList == [] and not self.edgeList == "":
self.baseCurve = cmds.polyToCurve(name="baseCurve", form=2, degree=1)[0]
cmds.select(self.baseCurve+".ep[*]")
cmds.insertKnotCurve(cmds.ls(selection=True, flatten=True), constructionHistory=True, curveOnSurface=True, numberOfKnots=1, addKnots=False, insertBetween=True, replaceOriginal=True)
pointListA, pointListB, sideA, sideB = self.sqGetPointLists()
toDeleteList = []
p = 2
for k in range((sideA+2), (sideB-1)):
if p%2 == 0:
toDeleteList.append(self.baseCurve+".cv["+str(k)+"]")
toDeleteList.append(self.baseCurve+".cv["+str(k+len(pointListA)-1)+"]")
p = p+1
q = 2
m = sideA-2
if m >= 0:
while m >= 0:
if not m == sideA and not m == sideB:
if q%2 == 0:
toDeleteList.append(self.baseCurve+".cv["+str(m)+"]")
m = m-1
q = q+1
cmds.delete(toDeleteList)
cmds.insertKnotCurve([self.baseCurve+".u["+str(len(pointListA)-1)+"]", self.baseCurve+".ep["+str(len(pointListA)-1)+"]"], constructionHistory=True, curveOnSurface=True, numberOfKnots=1, addKnots=False, insertBetween=True, replaceOriginal=True)
pointListA, pointListB, sideA, sideB = self.sqGetPointLists()
posListA, posListB = [], []
for i in range(0, len(pointListA)-1):
posListA.append(cmds.xform(pointListA[i], query=True, worldSpace=True, translation=True))
posListB.append(cmds.xform(pointListB[i], query=True, worldSpace=True, translation=True))
self.mainCurveA = cmds.curve(name="StickyLips_Main_A_Crv", degree=1, point=posListA)
self.mainCurveB = cmds.curve(name="StickyLips_Main_B_Crv", degree=1, point=posListB)
cmds.rename(cmds.listRelatives(self.mainCurveA, children=True, shapes=True)[0], self.mainCurveA+"Shape")
cmds.rename(cmds.listRelatives(self.mainCurveB, children=True, shapes=True)[0], self.mainCurveB+"Shape")
cmds.select(self.mainCurveA+".cv[*]")
self.curveLenght = len(cmds.ls(selection=True, flatten=True))
cmds.select(clear=True)
self.sqCheckCurveDirection(self.mainCurveA)
self.sqCheckCurveDirection(self.mainCurveB)
self.baseCurveA = cmds.duplicate(self.mainCurveA, name=self.mainCurveA.replace("_Main_", "_Base_"))[0]
self.baseCurveB = cmds.duplicate(self.mainCurveB, name=self.mainCurveB.replace("_Main_", "_Base_"))[0]
cmds.delete(self.baseCurve)
self.maxIter = len(posListA)
cmds.group(self.mainCurveA, self.mainCurveB, self.baseCurveA, self.baseCurveB, name="StickyLips_StaticData_Grp")
else:
mel.eval("warning \"Please, select an closed edgeLoop.\";")
def square_curve( self ): cmds.curve( d = 1, p = [( 0.5, 0, -0.5 ), ( 0.5, 0, 0.5 ), ( -0.5, 0, 0.5 ), ( -0.5, 0, -0.5 ), ( 0.5, 0, -0.5 )], k = [0, 1, 2, 3, 4] ) self.controller_dag = maya_dag.DAG_Node()
def rebuildCurveWithKnotData(knots, crvs):
for crv in crvs:
cvPositions = mc.getAttr('%s.cv[*]'%crv)
degree = mc.getAttr('%s.degree'%crv)
numOfCV = len(cvPositions)
if numOfCV + degree - 1 == len(knots):
mc.curve(crv, r=1, os=1, p=cvPositions, k=knots)
else:
mc.error('Knot values do not match number of CVs')
def testStaticNurbsCurvePropReadWrite(self):
nodeName = 'nCurve'
shapeName = 'curveShape1'
MayaCmds.curve(p=[(0, 0, 0), (3, 5, 6), (5, 6, 7), (9, 9, 9)],
name=nodeName)
self.setProps(shapeName)
self.__files.append(util.expandFileName('staticPropCurve.abc'))
MayaCmds.AbcExport(j='-atp SPT_ -root %s -f %s' % (nodeName, self.__files[-1]))
self.verifyProps(shapeName, self.__files[-1])
def diamond_curve( self ): cmds.curve( d = 1, p = [( 0.5, 0, 0 ), ( 0, 0, -0.5 ), ( -0.5, 0, 0 ), ( 0, 0, 0.5, ), ( 0, -0.5, 0 ), ( 0, 0, -0.5 ), ( 0, 0.5, 0 ), ( -0.5, 0, 0 ), ( 0, -0.5, 0 ), ( 0.5, 0, 0 ), ( 0, 0.5, 0 ), ( 0, 0, 0.5 ), ( 0.5, 0, 0 )], k = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] ) self.controller_dag = maya_dag.DAG_Node()
def createCube(*args):
cmds.curve(d=1, p=[ (0.5, 0.126219, -0.5), (0.5, 0.126219, 0.5) ,(0.5, 1.126219, 0.5), (0.5, 1.126219, -0.5),
(0.5, 0.126219, -0.5) ,(-0.5, 0.126219, -0.5) ,(-0.5, 1.126219, -0.5) ,(0.5, 1.126219, -0.5),
(-0.5, 1.126219, -0.5) ,(-0.5, 1.126219, 0.5) ,(-0.5, 0.126219, 0.5) ,(-0.5, 0.126219, -0.5),
(-0.5, 1.126219, -0.5), (-0.5, 1.126219, 0.5) ,(0.5, 1.126219, 0.5) ,(0.5, 0.126219, 0.5),
(-0.5, 0.126219, 0.5)], k=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16])
cmds.CenterPivot()
cmds.select(cl=True)
print 'Created a Solid Nurbs Cube'
def box_curve( self ): cmds.curve( d = 1, p = [( 0.5, 0.5, 0.5 ), ( 0.5, 0.5, -0.5 ), ( -0.5, 0.5, -0.5 ), ( -0.5, 0.5, 0.5 ), ( 0.5, 0.5, 0.5 ), ( 0.5, -0.5, 0.5 ), ( -0.5, -0.5, 0.5 ), ( -0.5, 0.5, 0.5 ), ( 0.5, 0.5, 0.5 ), ( 0.5, 0.5, -0.5 ), ( 0.5, -0.5, -0.5 ), ( 0.5, -0.5, 0.5 ), ( -0.5, -0.5, 0.5 ), ( -0.5, 0.5, 0.5 ), ( -0.5, 0.5, -0.5 ), ( -0.5, -0.5, -0.5 ), ( -0.5, -0.5, 0.5 ), ( 0.5, -0.5, 0.5 ), ( 0.5, -0.5, -0.5 ), ( -0.5, -0.5, -0.5 )] ) self.controller_dag = maya_dag.DAG_Node()
def curveOnEdgeLoop(self):
"""
first two edge selection are important( it determines the first vertex)
create curve based on the ordered vertices list
"""
myList = cmds.ls(os=1, fl=1)
allVerts = self.orderedVertsEdgeLoop(myList)
vertsPos = []
for v in allVerts:
pos = cmds.xform(v, q =1, ws =1, t =1)
vertsPos.append(pos)
cmds.curve(n= 'loftCurve01', d =1, per =1, p = vertsPos)
def createPathCurve(*arg):
pathNodes = cmds.ls('pathNode*',type='transform')
print pathNodes
pathCurve = 'pathCurve'
i=0
for node in pathNodes:
if i==0:
nodePos = cmds.xform(node, q=True,a=True,t=True)
pathCurve = cmds.curve(n=pathCurve,p=[nodePos])
i+=1
else:
nodePos = cmds.xform(node, q=True,a=True,t=True)
cmds.curve(pathCurve,a=True,p=[nodePos])
def drawCurve( target,start,end,colour,samples ):
# print target,start,end,samples,colour
# make locator, constrain to target
cmds.spaceLocator( name="myLocator" )
cmds.select( target )
cmds.select( "myLocator", add=True )
cmds.pointConstraint()
# make a new render layer with locator, and change display colour
cmds.select( "myLocator" )
exists = cmds.objExists( "AnimationCurves" )
if ( exists==False ):
cmds.createDisplayLayer( name="AnimationCurves", number=1, nr=True )
cmds.createDisplayLayer( name="Spheres", number=1, nr=True )
cmds.setAttr( "AnimationCurves.color", colour )
cmds.setAttr( "Spheres.color", 16 )
# make a list of all the frames where points for the curve will be created
frameList = []
frameList.append( start )
length = end - start
samples = cmds.intField( samplesField, q=1, v=1 )
interval = int( length / (samples-1) ) # using int() to ensure integer frame numbers
for i in range( 1,samples ):
frameList.append( start+interval*i )
frameList.append( end )
# make a list of tuples containing the locations of the target/locator for every frame needed
xFormList = []
n = 0
for frame in ( frameList ):
x = cmds.getAttr( "myLocator.tx",time=frame )
y = cmds.getAttr( "myLocator.ty",time=frame )
z = cmds.getAttr( "myLocator.tz",time=frame )
currentXForm = ( x,y,z )
xFormList.append( currentXForm )
cmds.sphere( n="sphere"+str(n), r=0.2 )
cmds.move( x,y,z, "sphere"+str(n), a=True )
n+=1
# print frame, "= ", x,y,z
cmds.editDisplayLayerMembers( "Spheres", "sphere*", nr=True )
# create curve using list of tuples
cmds.curve( p=xFormList, d=1, ws=True )
cmds.rename( target+"_animation_curve" )
cmds.group( target+"_animation_curve", "sphere*", n="curve" )
# add curve to animation curves layer
cmds.editDisplayLayerMembers( "AnimationCurves", "curve", nr=True )
cmds.delete("myLocator")
cmds.button( ccButton, e=1, en=0 )
cmds.frameLayout( buttonGroup, e=1, l="Delete curve before creating another" )
def clock():
c1 = cmds.circle(nr=(0,1,0), c=(0,0,0))
sp = (0,0,0)
ep = (0,0,-1)
hours = cmds.curve(p=[sp, ep])
minutes = cmds.curve(p=[sp, ep])
seconds = cmds.curve(p=[sp, ep])
# scale = 100
hour_degrees = -90
minute_degrees = 12 * hour_degrees
second_degrees = 60 * minute_degrees
def TDPyramid(self, name):
return cmds.curve(d=1,
n=name,
p=[(0, 2, 0), (1, 0, -1), (-1, 0, -1), (0, 2, 0),
(-1, 0, 1), (1, 0, 1), (0, 2, 0), (1, 0, -1),
(1, 0, 1), (-1, 0, 1), (-1, 0, -1)])
def Leg_R():
Scale_Guide=cmds.xform('Guide_Ctrl_Master',ws=True, q=True, s=True )[0]
##Joints Leg_R##
#J_Leg_R#
trans_Guide_Leg_R = cmds.xform ('Loc_Guide_Leg_R', ws=True, q=True, t=True)
translate_Guide_ForeLeg_R = cmds.xform ('Loc_Guide_ForeLeg_R', ws=True, q=True, t=True)
translate_Guide_Foot_R = cmds.xform ('Loc_Guide_Foot_R', ws=True, q=True, t=True)
Joint_Leg_Neutral_R=cmds.joint(n='J_Leg_Neutral_R',p=trans_Guide_Leg_R,rad=1*Scale_Guide)
Joint_ForeLeg_Neutral_R=cmds.joint(n='J_ForeLeg_Neutral_R',p=translate_Guide_ForeLeg_R,rad=1*Scale_Guide)
Joint_Ankle_Neutral_R=cmds.joint(n='J_Ankle_Neutral_R',p=translate_Guide_Foot_R,rad=1*Scale_Guide)
OJ_Joint_Leg_Neutral_R=cmds.joint('J_Leg_Neutral_R', e=True, zso=True, oj='xzy',sao='zup')
OJ_Joint_ForeLeg_Neutral_R=cmds.joint('J_ForeLeg_Neutral_R', e=True, zso=True, oj='xzy',sao='zup')
OJ_Joint_Ankle_Neutral_R=cmds.joint('J_Ankle_Neutral_R', e=True, zso=True, oj='xzy',sao='zup')
joX_Ankle_R=cmds.setAttr("J_Ankle_Neutral_R.jointOrientX",0)
joY_Ankle_R=cmds.setAttr("J_Ankle_Neutral_R.jointOrientY",0)
joZ_Ankle_R=cmds.setAttr("J_Ankle_Neutral_R.jointOrientZ",0)
cmds.select(d=True)
#J_Ankle_R#
trans_Guide_Foot_R = cmds.xform ('Guide_Foot_R', ws=True, q=True, t=True)
translate_Guide_Toe_R = cmds.xform ('Loc_Guide_Toe_R', ws=True, q=True, t=True)
translate_Guide_Tip_R = cmds.xform ('Loc_Guide_Tip_R', ws=True, q=True, t=True)
Joint_Toe_Neutral_R=cmds.joint(n='J_Toe_Neutral_R',p=translate_Guide_Toe_R,rad=1*Scale_Guide)
Joint_Tip_Neutral_R=cmds.joint(n='J_Tip_Neutral_R',p=translate_Guide_Tip_R,rad=1*Scale_Guide)
OJ_Joint_Leg_Neutral_R=cmds.joint('J_Toe_Neutral_R', e=True, zso=True, oj='xzy',sao='yup')
OJ_Joint_ForeLeg_Neutral_R=cmds.joint('J_Tip_Neutral_R', e=True, zso=True, oj='xzy',sao='yup')
rot_Ankle_R = cmds.xform ('J_Ankle_Neutral_R', ws=True, q=True, ro=True)
cmds.select( d=True )
cmds.parent('J_Toe_Neutral_R','J_Ankle_Neutral_R')
cmds.select(d=True)
cmds.select(Joint_Leg_Neutral_R)
cmds.mirrorJoint (myz=True, mb=True)
cmds.delete('J_Leg_Neutral_R')
Rename_FK= mel.eval('searchReplaceNames("_R1","_R","all")')
cmds.select(d=True)
rot_Guide_Leg_R = cmds.xform ('J_Leg_Neutral_R', ws=True, q=True, ro=True)
trans_Guide_Leg_R = cmds.xform ('J_Leg_Neutral_R', ws=True, q=True, t=True)
Z_J_Leg=cmds.group(n='Z_J_Leg_Neutral_R',em=True)
P_J_Leg=cmds.group(n='P_J_Leg_Neutral_R')
emparentarTrans = cmds.xform ('P_J_Leg_Neutral_R', ws=True, t=trans_Guide_Leg_R)
emparentarRot = cmds.xform ('P_J_Leg_Neutral_R', ws=True, ro=rot_Guide_Leg_R)
P_J_Leg_Neutral_R_Z_J_Leg_Neutral_R=cmds.parent('J_Leg_Neutral_R','Z_J_Leg_Neutral_R')
Activar_color= cmds.setAttr('P_J_Leg_Neutral_R.overrideEnabled', 1)
Blanco= cmds.setAttr('P_J_Leg_Neutral_R.overrideColor', 16)
cmds.select( d=True )
#Duplicate the original chain
Duplicar_a_FK= cmds.duplicate(P_J_Leg, rc=True)
Duplicar_a_IK= cmds.duplicate(P_J_Leg, rc=True)
#rename the chain
Rename_FK= mel.eval('searchReplaceNames("_Neutral_R1","_FK_R","all")')
Rename_IK= mel.eval('searchReplaceNames("_Neutral_R2","_IK_R","all")')
#Change Color Herarchy FK_IK
Activar_Color= cmds.setAttr(('P_J_Leg_FK_R.overrideEnabled'), 1)
Azul= cmds.setAttr('P_J_Leg_FK_R.overrideColor', 6)
Activar_Color= cmds.setAttr('P_J_Leg_IK_R.overrideEnabled', 1)
Amarillo= cmds.setAttr('P_J_Leg_IK_R.overrideColor', 17)
def J(Joints,nombre,radio):
for Elemento in Joints:
Change_Radius_Tip_FK= cmds.setAttr(Elemento+'_'+nombre+'_R'+'.radius',radio*Scale_Guide)
J(['J_Leg','J_ForeLeg','J_Ankle','J_Toe','J_Tip'],"FK",.5)
J(['J_Leg','J_ForeLeg','J_Ankle','J_Toe','J_Tip'],"IK",.3)
#########Create_Ctrls_FK_R#############
#Create_Ctrl_Leg_FK_R
translate = cmds.xform ('J_Leg_FK_R', ws=True, q=True, t=True)
rot = cmds.xform ('J_Leg_FK_R', ws=True, q=True, ro=True)
#Emparentar R_FK_Leg_CTL
emparentarTrans_R = cmds.xform ('P_R_FK_Leg_CTL', ws=True, t=translate)
emparentarRot_R = cmds.xform ('P_R_FK_Leg_CTL', ws=True, ro=rot)
cmds.parentConstraint ('R_FK_Leg_CTL', 'J_Leg_FK_R',mo=True)
#Create_Ctrl_ForeLeg_FK_R
translate = cmds.xform ('J_ForeLeg_FK_R', ws=True, q=True, t=True)
rot = cmds.xform ('J_ForeLeg_FK_R', ws=True, q=True, ro=True)
#Emparentar R_FK_Leg_CTL
emparentarTrans_R = cmds.xform ('P_R_FK_ForeLeg_CTL', ws=True, t=translate)
emparentarRot_R = cmds.xform ('P_R_FK_ForeLeg_CTL', ws=True, ro=rot)
cmds.parentConstraint ('R_FK_ForeLeg_CTL', 'J_ForeLeg_FK_R',mo=True)
P_ForeLeg_R_Ctrl_Leg_R= cmds.parent(("P_R_FK_ForeLeg_CTL","R_FK_Leg_CTL"))
#Create_IKAnklele_Leg_R
Ik_Ankle_Leg_R=cmds.ikHandle(n='Ik_Ankle_Leg_R', sj='J_Leg_IK_R', ee='J_Ankle_IK_R')
Hidde_Ik_Ankle_Leg_R=cmds.hide('Ik_Ankle_Leg_R')
#Create_Ctrl_PV_Leg_R
pos_Leg_IK_R = cmds.xform ('Guide_Leg_R', ws=True, q=True, t=True)
pos_ForeLeg_IK_R = cmds.xform ('Guide_ForeLeg_R', ws=True, q=True, t=True)
pos_Ankle_IK_R = cmds.xform ('Guide_Foot_R', ws=True, q=True, t=True)
Cv_Polevector_Leg_R=cmds.curve(n='Cv_PV_Guide_Leg_R',d=1,p=[(pos_Leg_IK_R ),(pos_ForeLeg_IK_R),(pos_Ankle_IK_R)],k=(0,1,2))
Move_Cv_Guide=cmds.moveVertexAlongDirection ('Cv_PV_Guide_Leg_R.cv[1]', n= 4.8*Scale_Guide)
pos_Cv= cmds.pointPosition ('Cv_PV_Guide_Leg_R.cv[1]')
emparentarTrans_R_PV_Leg_R = cmds.xform ('P_R_PolevectorLeg_CTL', ws=True, t=pos_Cv)
delete_Cv_Polevector_Leg_R=cmds.delete(Cv_Polevector_Leg_R)
Cons_PV_Leg_R= cmds.poleVectorConstraint('R_PolevectorLeg_CTL', 'Ik_Ankle_Leg_R' )
#R_IK_Leg_CTL
translate_Ctrl_IK_R = cmds.xform ('J_Ankle_IK_R', ws=True, q=True, t=True)
emparentarTrans_IK_Leg_R = cmds.xform ('P_R_IK_Leg_CTL', ws=True, t=translate_Ctrl_IK_R)
#Herarchy_IkH_Ctrl_Leg_IK_R
IkH_Leg_R_Ctrl_Leg_IK_R=cmds.parent('Ik_Ankle_Leg_R','R_IK_Leg_CTL')
#Create_Ctrl_Switch_Leg_R
translate_Switch_Leg_R = cmds.xform ('Guide_Ctrl_Switch_Leg_R', ws=True, q=True, t=True)
rot_Switch_Leg_R = cmds.xform ('Guide_Ctrl_Switch_Leg_R', ws=True, q=True, ro=True)
emparentarTrans_R_Switch_Leg_R = cmds.xform ("P_R_SwitchLeg_CTL", ws=True, t=translate_Switch_Leg_R)
emparentarRot_R_Switch_Leg_R = cmds.xform ("P_R_SwitchLeg_CTL", ws=True, ro=rot_Switch_Leg_R)
#Add_Attrs_Switch_Leg_R
Atributo_Switch= cmds.addAttr("R_SwitchLeg_CTL",longName='Switch_FK_IK',attributeType='float', defaultValue=10, minValue=0, maxValue=10 )
agregarAttr= cmds.setAttr ("R_SwitchLeg_CTL.Switch_FK_IK", k=True)
Atributo_Stretch= cmds.addAttr("R_SwitchLeg_CTL",longName='Stretch',attributeType='float', defaultValue=1, minValue=0, maxValue=1)
AgregarAttrStretch= cmds.setAttr ("R_SwitchLeg_CTL.Stretch", k=True)
#Switch_FK_IK_Leg_R
Select_Leg=cmds.select('J_Leg_Neutral_R','J_ForeLeg_Neutral_R','J_Ankle_Neutral_R')
sel = cmds.ls (sl=True)
def Clear_Select():
cmds.select (cl=True)
Clear_Select()
MD_switch_fk_ik = cmds.shadingNode ("multiplyDivide", asUtility=True, n="MD_Leg_Switch_FK_IK_R")
cmds.setAttr(MD_switch_fk_ik+'.operation',2)
cmds.setAttr(MD_switch_fk_ik+'.input2X',10)
cmds.connectAttr ('R_SwitchLeg_CTL.Switch_FK_IK', MD_switch_fk_ik + ".input1X")
for J in sel:
N = J.split("_Neutral_R")[0]
print N
New_N=N.split("J_")[1]
BC_rotate = cmds.shadingNode ("blendColors", asUtility=True, n="BC_" + New_N+"_rotate_R")
BC_translate = cmds.shadingNode ("blendColors", asUtility=True, n="BC_" + New_N+"_translate_R")
cmds.connectAttr (BC_rotate + ".output", J + ".rotate")
cmds.connectAttr (MD_switch_fk_ik + ".outputX", BC_rotate + ".blender")
cmds.connectAttr (BC_translate + ".output", J + ".translate")
cmds.connectAttr (MD_switch_fk_ik + ".outputX", BC_translate + ".blender")
j_Leg_neutral=('J_Leg_Neutral_R')
j_foreLeg_neutral=('J_ForeLeg_Neutral_R')
jnt_Ankle_neutral_R=('J_Ankle_Neutral_R')
JN1 = j_Leg_neutral.split("_Neutral_R")[0]
JN2 = j_foreLeg_neutral.split("_Neutral_R")[0]
JN3 = jnt_Ankle_neutral_R.split("_Neutral_R")[0]
Milista=[]
list.append(Milista,JN1)
list.append(Milista,JN2)
list.append(Milista,JN3)
def fun1(Var1):
list.append (Milista, Milista[0] + Var1)
list.append (Milista, Milista[1] + Var1)
list.append (Milista, Milista[2] + Var1)
fun1('_FK_R')
fun1('_IK_R')
def fun(Var):
cmds.connectAttr (Milista[3]+ "."+Var, "BC_Leg_"+Var+"_R.color2")
cmds.connectAttr (Milista[6]+ "."+Var, "BC_Leg_"+Var+"_R.color1")
cmds.connectAttr (Milista[4]+ "."+Var, "BC_ForeLeg_"+Var+"_R.color2")
cmds.connectAttr (Milista[7]+ "."+Var, "BC_ForeLeg_"+Var+"_R.color1")
cmds.connectAttr (Milista[5]+ "."+Var, "BC_Ankle_"+Var+"_R.color2")
cmds.connectAttr (Milista[8]+ "."+Var, "BC_Ankle_"+Var+"_R.color1")
fun('rotate')
fun('translate')
#Cons_Orient_Ik_Ankle_J_Ankle_R
Parent_Cons_FK_Ctrl_J_Ik_Leg=cmds.parentConstraint('R_FK_Leg_CTL','J_Leg_IK_R',mo=True)
Herarchy_Switch_Leg_R_J_Ankle_Neutral_R=cmds.parent('P_R_SwitchLeg_CTL','J_Ankle_Neutral_R')
translate_J_ForeLeg_Ik_R = cmds.xform ('J_ForeLeg_IK_R', ws=True, q=True, t=True)
translate_Ctrl_Polevector_Leg_R = cmds.xform ('R_PolevectorLeg_CTL', ws=True, q=True, t=True)
#CVPv_IK_R#
Cv_Polevector_Leg_R=cmds.curve(n='Cv_Polevector_Leg_R',d=1,p=[(translate_J_ForeLeg_Ik_R),(translate_Ctrl_Polevector_Leg_R)],k=(0,1))
Z_Cvv_Polevector_Leg_R= cmds.group (n=("Z_Cv_Polevector_Leg_R"),em=True)
Herarchy_CV_Grp=cmds.parent('Cv_Polevector_Leg_R',"Z_Cv_Polevector_Leg_R")
lineWidth_Cv_Polevector_Leg_R=cmds.setAttr (Cv_Polevector_Leg_R+".lineWidth",2)
OvE_Cv_Polevector_Leg_R=cmds.setAttr(Cv_Polevector_Leg_R+".overrideEnabled",1)
OvDT_Cv_Polevector_Leg_R=cmds.setAttr(Cv_Polevector_Leg_R+".overrideDisplayType",2)
cmds.select(d=True)
J_CV_0_Leg_R=cmds.joint(p=translate_J_ForeLeg_Ik_R,n="J_Cv_0_Leg_R")
Grp_J_CV_0_Leg_R=cmds.group(n='Z_J_Cv_0_Leg_R')
cmds.select(d=True)
J_CV_1_Leg_R=cmds.joint(p=translate_Ctrl_Polevector_Leg_R,n="J_Cv_1_Leg_R")
Grp_J_CV_1_Leg_R=cmds.group(n='Z_J_Cv_1_Leg_R')
cmds.select(d=True)
Skin_J_Cvs=cmds.skinCluster('J_Cv_0_Leg_R','J_Cv_1_Leg_R','Cv_Polevector_Leg_R',dr=4)
Parent_J_CV_Leg_R_J_ForeLeg_IK_R=cmds.parent(Grp_J_CV_0_Leg_R,'J_ForeLeg_IK_R')
Parent_J_CV_Leg_R_J_ForeLeg_IK_R=cmds.parent(Grp_J_CV_1_Leg_R,'R_PolevectorLeg_CTL')
cmds.select(d=True)
#Create Node_Vis_Leg_R#
Node_Reverse_Vis_Leg_R=cmds.shadingNode('reverse',au=True, n='R_Vis_Leg_R')
Node_MD_Vis_Leg_R=cmds.shadingNode('multiplyDivide',au=True, n='MD_Vis_Leg_R')
Operation_MD_Vis_Leg_R= cmds.setAttr (Node_MD_Vis_Leg_R+'.operation',2, k=True)
Set_2X_Node_MD_Vis_Leg_R= cmds.setAttr (Node_MD_Vis_Leg_R+'.input2X',10, k=True)
#Conect Vis_Leg_R#
Switch_MD_Leg_R=cmds.connectAttr('R_SwitchLeg_CTL.Switch_FK_IK',Node_MD_Vis_Leg_R+'.input1X')
MD_R_Leg_R=cmds.connectAttr(Node_MD_Vis_Leg_R+'.outputX',Node_Reverse_Vis_Leg_R+'.inputX')
R_Ctrl_FK_Leg_R=cmds.connectAttr(Node_Reverse_Vis_Leg_R+'.outputX','P_R_FK_ForeLeg_CTL.visibility')
R_J_FK_Leg_R=cmds.connectAttr(Node_Reverse_Vis_Leg_R+'.outputX','P_J_Leg_FK_R.visibility')
MD_Ctrl_IK_Leg_R=cmds.connectAttr(Node_MD_Vis_Leg_R+'.outputX','P_R_IK_Leg_CTL.visibility')
MD_PV_IK_Leg_R=cmds.connectAttr(Node_MD_Vis_Leg_R+'.outputX','R_PolevectorLeg_CTL.visibility')
MD_CV_PV_IK_Leg_R=cmds.connectAttr(Node_MD_Vis_Leg_R+'.outputX','Z_Cv_Polevector_Leg_R.visibility')
MD_J_IK_Leg_R=cmds.connectAttr(Node_MD_Vis_Leg_R+'.outputX','P_J_Leg_IK_R.visibility')
def TDDirSingleFat(self, name):
return cmds.curve(d=1,
n=name,
p=[(0, 0, -0.99), (-0.66, 0, 0), (-0.33, 0, 0),
(-0.33, 0, 0.66), (0.33, 0, 0.66), (0.33, 0, 0),
(0.66, 0, 0), (0, 0, -0.99)])
def generateTeeth():
stacks = ['up', 'dn']
sides = ['L', 'R']
baseName = 'teeth'
MainGuideSuff = 'jnt_GUIDE'
noXformGrp = 'teeth_noXformGrp'
mouthCtrl = 'mouth_ctrl'
gumsMesh = 'gum_hi'
gumsMeshAlt = 'gums_hi'
teethGuidesGrp = '%s_guides_grp' % baseName
# --- creating noXformGrp for later use
mc.group(n=noXformGrp, em=True)
mc.parent(noXformGrp, 'facial_fGrp')
mc.hide(noXformGrp)
# --- creating hold_jnt for further use
mc.select(cl=True)
holdJnt = mc.joint(n='%s_hold_jnt' % baseName)
mc.parent(holdJnt, noXformGrp)
for stack in stacks:
mainTeethParent = '%s_%s_SKN' % (baseName, stack)
mainBaseGuide = '%s_%s_%s' % (baseName, stack, MainGuideSuff)
crvGuidesGrp = '%s_%s_guides_grp' % (baseName, stack)
# --- get all teeth guides from template groups
mainGuides = mc.listRelatives(mainBaseGuide, c=True, type='joint')
# --- tweak and realign jawGen generated controls
allGuides = mainGuides
mainGuides.append(mainBaseGuide)
allOrient = []
for guide in allGuides:
parent = mc.listRelatives(guide, p=True)[0]
mc.parent(guide, w=True)
RO = mc.getAttr('%s.rotate' % guide)[0]
JO = mc.getAttr('%s.jointOrient' % guide)[0]
orient = (RO[0] + JO[0], RO[1] + JO[1], RO[2] + JO[2])
allOrient.append(orient)
mc.parent(guide, parent)
parentList = []
for g, guide in enumerate(allGuides):
ctrl = guide.replace('GUIDE', 'orig')
parent = mc.listRelatives(ctrl, p=True)[0]
parentList.append(parent)
mc.parent(ctrl, w=True)
mc.setAttr('%s.jointOrient' % ctrl, 0, 0, 0)
mc.setAttr('%s.rotate' % ctrl, allOrient[g][0], allOrient[g][1],
allOrient[g][2])
for g, guide in enumerate(reversed(allGuides)):
ctrl = guide.replace('GUIDE', 'orig')
parent = parentList[-1 - g]
mc.parent(ctrl, parent)
if g > 0:
mc.setAttr('%s.jointOrientX' % ctrl, 0)
mc.setAttr('%s.jointOrientZ' % ctrl, 0)
mc.setAttr('%s.rotateX' % ctrl, 0)
mc.setAttr('%s.rotateZ' % ctrl, 0)
## --- create midCtrls symmetry
midCtrls = []
for g, guide in enumerate(allGuides):
ctrl = guide.replace('GUIDE', 'orig')
splitName = ctrl.rsplit('_', 3)[1]
if splitName == 'mid':
midCtrls.append(ctrl)
RCtrls = mc.duplicate(ctrl, n=ctrl.replace('L_', 'R_'))
midCtrls.append(RCtrls[0])
### --- rename childs of dupilcated control
RCtrlChilds = mc.listRelatives(RCtrls[0], ad=True, f=True)
for c, child in enumerate(RCtrlChilds):
if c > 0:
strippedName = child.rsplit('|', 1)[1]
newName = mc.rename(child,
strippedName.replace('L_', 'R_'))
### --- reconnect control to SKN of duplicated mid Ctrl
renamedChilds = mc.listRelatives(RCtrls[0], ad=True)
for child in renamedChilds:
splitName = child.rsplit('_', 1)[1]
if splitName == 'ctrl':
if not mc.objectType(child) == 'nurbsCurve':
patchLib.smartcopyAttr(
child, child.replace('_ctrl', '_SKN'))
patchLib.smartConnect(
child, child.replace('_ctrl', '_SKN'))
### --- position RCtrl on symmetry
#print ctrl
mc.setAttr('%s.translateX' % RCtrls[0],
-(mc.getAttr('%s.translateX' % ctrl)))
mc.setAttr('%s.scaleX' % RCtrls[0], -1)
## --- create new parent placed at origin for midCtrls
midParent = mc.group(n='%s_%s_mids_orig' % (stack, baseName), em=True)
mc.parent(midParent, mainTeethParent)
mc.parent(midCtrls, midParent)
# --- create world rigs from jawGen generated controls
## --- get all the objects that need a world duplicate
mainTeethChilds = mc.listRelatives(mainTeethParent,
c=True,
ad=True,
s=False)
worldTargets = []
for child in mainTeethChilds:
if not mc.objectType(child) == 'nurbsCurve':
worldTargets.append(child)
## --- create duplicated world objects and connects them to the actual controls
### --- create duplicate for main node
worldParent = mc.duplicate(mainTeethParent,
po=True,
n='%s_world' % mainTeethParent)[0]
mc.parent(worldParent, noXformGrp)
### --- create duplicates for every childNode of main node. Connect local Rig to world Rig
worldParentdict = dict()
worldNodes = []
for target in worldTargets:
splitName = target.split('_')
parent = mc.listRelatives(target, p=True)[0]
if not 'ctrl' in splitName:
if not splitName[0] == 'C':
#### --- create world node
worldNode = mc.duplicate(target,
po=True,
n='%s_world' % target)[0]
mc.parent(worldNode, noXformGrp)
worldNodes.append(worldNode)
worldParentdict[worldNode] = (parent)
#### --- do the conection
if not 'mid' in splitName:
if not 'mids' in splitName:
patchLib.smartcopyAttr(target, worldNode)
patchLib.smartConnect(target, worldNode)
elif 'mids' in splitName:
pass
elif 'mid' in splitName:
if not 'orig' in splitName:
patchLib.smartcopyAttr(target, worldNode)
patchLib.smartConnect(target, worldNode)
else:
ROCon = mc.listConnections('%s.rotateOrder' %
target,
s=True,
p=True)
if ROCon:
mc.disconnectAttr(ROCon[0],
'%s.rotateOrder' % target)
patchLib.smartcopyAttr(worldNode, target)
patchLib.smartConnect(worldNode, target)
elif splitName[0] == 'C':
#### --- create world node
LWorldNode = mc.duplicate(target,
po=True,
n='L%s_world' % target)[0]
RWorldNode = mc.duplicate(target,
po=True,
n='R%s_world' % target)[0]
mc.parent(LWorldNode, RWorldNode, noXformGrp)
worldNodes.append(LWorldNode)
worldNodes.append(RWorldNode)
parentSplit = parent.split('_', 1)[0]
if not parentSplit == 'C':
worldParentdict[LWorldNode] = (parent)
worldParentdict[RWorldNode] = (parent)
elif parentSplit == 'C':
worldParentdict[LWorldNode] = ('L%s' % parent)
worldParentdict[RWorldNode] = ('R%s' % parent)
#### --- do the conection
patchLib.smartcopyAttr(target, LWorldNode)
patchLib.smartcopyAttr(target, RWorldNode)
patchLib.smartConnect(target, LWorldNode)
patchLib.smartConnect(target, RWorldNode)
### --- reparent world nodes to recreate local hierarchy
for node in worldNodes:
localParent = worldParentdict.get(node)
mc.parent(node, '%s_world' % localParent)
# --- get all curve teeth guides from template groups
allCrvGuides = mc.listRelatives(crvGuidesGrp, c=True)
## --- separate the loft guides from the rest
popIndex = 0
crvLoftGuide = ''
for g, guide in enumerate(allCrvGuides):
splitName = guide.rsplit('_crv_')[-1]
if splitName == 'GUIDE':
popIndex = g
crvLoftGuide = allCrvGuides.pop(g)
# --- lofts from curves and symmetrise them to create n0 surfaces
## --- create left loft curves
LdnCrv = mc.duplicate(crvLoftGuide,
n=crvLoftGuide.replace('GUIDE', 'Loft_00'))[0]
LupCrv = mc.duplicate(crvLoftGuide,
n=crvLoftGuide.replace('GUIDE', 'Loft_01'))[0]
patchLib.locksSwitch(LdnCrv,
T=True,
R=True,
S=True,
V=True,
lockdo='unlock',
keydo=True)
patchLib.locksSwitch(LupCrv,
T=True,
R=True,
S=True,
V=True,
lockdo='unlock',
keydo=True)
mc.parent(LdnCrv, LupCrv, mainTeethParent)
mc.makeIdentity(LdnCrv, a=True)
mc.makeIdentity(LupCrv, a=True)
mc.makeIdentity(LdnCrv, a=False)
mc.makeIdentity(LupCrv, a=False)
offsetVal = 0.01
mc.setAttr('%s.translateY' % LdnCrv, (-offsetVal))
mc.setAttr('%s.translateY' % LupCrv, offsetVal)
mc.parent(LdnCrv, LupCrv, w=True)
mc.makeIdentity(LdnCrv, a=True)
mc.makeIdentity(LupCrv, a=True)
mc.makeIdentity(LdnCrv, a=False)
mc.makeIdentity(LupCrv, a=False)
## --- create right loft curves
RdnCrv = mc.duplicate(LdnCrv, n=LdnCrv.replace('L_', 'R_'))[0]
RupCrv = mc.duplicate(LupCrv, n=LupCrv.replace('L_', 'R_'))[0]
mc.setAttr('%s.scaleX' % RdnCrv, -1)
mc.setAttr('%s.scaleX' % RupCrv, -1)
mc.makeIdentity(RdnCrv, a=True)
mc.makeIdentity(RupCrv, a=True)
mc.makeIdentity(RdnCrv, a=False)
mc.makeIdentity(RupCrv, a=False)
## --- create loft surfaces
LLoftSurf = mc.loft(LdnCrv,
LupCrv,
n='L_%s_%s_surf_n0' % (stack, baseName),
ch=False)[0]
RLoftSurf = mc.loft(RdnCrv,
RupCrv,
n='R_%s_%s_surf_n0' % (stack, baseName),
ch=False)[0]
loftSurfsN0 = [LLoftSurf, RLoftSurf]
loftSurfsN1 = mc.duplicate(loftSurfsN0)
loftSurfsN2 = mc.duplicate(loftSurfsN0)
loftSurfsAll = [loftSurfsN0, loftSurfsN1, loftSurfsN2]
mc.delete(LdnCrv, LupCrv, RdnCrv, RupCrv)
mc.parent(loftSurfsAll[0], loftSurfsAll[1], loftSurfsAll[2],
noXformGrp)
## --- disconnect unwanted ctrl to joints connections
for target in worldNodes:
splitName = target.split('_')
if not 'gumsBase' in splitName:
if 'SKN' in splitName:
scaleCons = mc.listConnections('%s.scale' % target,
s=True,
p=True)
if scaleCons:
for con in scaleCons:
mc.disconnectAttr(con, '%s.scale' % target)
if 'mid' in splitName:
mc.connectAttr('%sX' % con,
'%s.scaleX' % target)
if not 'mid' in splitName:
if 'LC' in splitName or 'RC' in splitName:
mc.connectAttr('%sX' % con,
'%s.scaleX' % target)
if 'L' in splitName or 'R' in splitName:
mc.connectAttr('%sZ' % con,
'%s.scaleZ' % target)
## --- symmetrise teeth guides and creates final teeth hierarchy
LCtrlList = []
RCtrlList = []
ctrlLists = [LCtrlList, RCtrlList]
for guide in allCrvGuides:
guideChild = mc.listRelatives(guide, c=True, type='transform')[0]
mainCtrl = createTeethCtrl(guide, mouthCtrl, stack)
tipCtrl = createTeethCtrl(guideChild, mouthCtrl, stack)
mc.parent(tipCtrl[1], mainCtrl[0])
mc.parent(mainCtrl[1], '%s_%s_SKN_world' % (baseName, stack))
skelLib.jointOrientToRotate(mainCtrl[1])
LCtrlList.append(mainCtrl[1])
splitName = guide.split('ibt_01')
if not len(splitName) > 1:
getTx = mc.getAttr('%s.translateX' % mainCtrl[1])
getRy = mc.getAttr('%s.rotateY' % mainCtrl[1])
symOrig = mc.duplicate(mainCtrl[1],
ic=True,
n=mainCtrl[1].replace('L_', 'R_'))[0]
skelLib.jointOrientToRotate(symOrig)
mc.setAttr('%s.translateX' % symOrig, -getTx)
mc.setAttr('%s.rotateY' % symOrig, -getRy)
symChilds = mc.listRelatives(symOrig, c=True, ad=True, f=True)
for child in symChilds:
splitName = child.rsplit('|', 1)[1]
mc.rename(child, splitName.replace('L_', 'R_'))
RCtrlList.append(symOrig)
teethGroup = '%s_%s_allCtrls_orig' % (baseName, stack)
mc.group(n=teethGroup, em=True)
mc.parent(teethGroup, mainTeethParent)
mc.parent(LCtrlList, RCtrlList, teethGroup)
## --- generating surfaces deformers and connections
for s, side in enumerate(sides):
## --- weighting n0 surface
n0SKC = mc.skinCluster(
'%sC_%s_%s_SKN_world' % (side, baseName, stack),
'%s_%s_%s_SKN_world' % (side, baseName, stack),
loftSurfsN0[s],
n='%s_SKC' % loftSurfsN0[s],
mi=2,
tsb=True)[0]
### --- create skinWeights anime Curve and reskin Surf from that curve
skinCurveDef = {
'tangentsVal': [
0.0, 47.702933224999114, 53.989547386085576,
55.545989790698755
],
'keyCount':
4,
'keysValues':
[0.0, 0.1322238293848932, 0.6123709362161491, 1.0],
'keysAtFrame': [0.0, 0.404, 0.696, 1.0]
}
skinCurve = patchLib.createAnimCurveFromDef(
skinCurveDef, 'temp_teeth_skinCurve')
## --- weighting n1 surfaces and connect n0 outShape to n1 orig
n1SKC = mc.skinCluster('%s_%s_%s_mid_SKN_world' %
(side, baseName, stack),
holdJnt,
loftSurfsN1[s],
n='%s_SKC' % loftSurfsN1[s],
mi=2,
dr=2,
tsb=True)[0]
patchLib.sineWeightsOnSurf(loftSurfsN1[s], 'u', False)
patchLib.basicBPMOnNurbs(SKC=n1SKC, holdJnt=holdJnt)
n0OutShape = mc.listConnections('%s.outputGeometry' % n0SKC,
sh=True)[0]
n1ShapeOrig = dagLib.findShapeOrig(loftSurfsN1[s])
mc.connectAttr('%s.worldSpace[0]' % n0OutShape,
'%s.create' % n1ShapeOrig)
## --- attache midCtrls to surf n0 with XRivet
for node in worldNodes:
splitName = node.split('_')
if side in splitName:
if stack in splitName:
if 'mid' in splitName:
if 'orig' in splitName:
if side == 'L':
offset = getOffsetFromXrivet('x', 'y')
elif side == 'R':
offset = getOffsetFromXrivet('-x', '-y')
mc.setAttr('%s.rotateOrder' % node, 0)
mc.setAttr('%s.jointOrient' % node, 0, 0, 0)
midXrivet = xrivetTrOnNurbs(
node,
loftSurfsN0[s],
mainDirection=1,
out='worldSpace[0]',
u=None,
v=None,
offsetOrient=offset,
min=False)
#print '%s is beeing xrivetted !!! ' %node
## --- create node based final n2 surfaces
### --- extract new curves from isoParms
dnCfsi = mc.createNode('curveFromSurfaceIso',
n='%s_dn_cfsi' % loftSurfsN1[s])
upCfsi = mc.createNode('curveFromSurfaceIso',
n='%s_up_cfsi' % loftSurfsN1[s])
mc.setAttr('%s.isoparmDirection' % dnCfsi, 1)
mc.setAttr('%s.isoparmDirection' % upCfsi, 1)
mc.setAttr('%s.isoparmValue' % dnCfsi, 0)
mc.setAttr('%s.isoparmValue' % upCfsi, 1)
mc.connectAttr('%s.worldSpace[0]' % loftSurfsN1[s],
'%s.inputSurface' % dnCfsi)
mc.connectAttr('%s.worldSpace[0]' % loftSurfsN1[s],
'%s.inputSurface' % upCfsi)
### --- create sliding from rebuild on curves
dnRc = mc.createNode('rebuildCurve', n='%s_dn_rc' % loftSurfsN1[s])
upRc = mc.createNode('rebuildCurve', n='%s_up_rc' % loftSurfsN1[s])
surfSpans = mc.getAttr('%s.spansV' % loftSurfsN1[s])
mc.setAttr('%s.spans' % dnRc, surfSpans)
mc.setAttr('%s.spans' % upRc, surfSpans)
mc.connectAttr('%s.outputCurve' % dnCfsi, '%s.inputCurve' % dnRc)
mc.connectAttr('%s.outputCurve' % upCfsi, '%s.inputCurve' % upRc)
### --- create finalLoft and connect to surf n2
loft = mc.createNode('loft', n='%s_loft' % loftSurfsN2[s])
mc.setAttr('%s.uniform' % loft, 1)
mc.connectAttr('%s.outputCurve' % dnRc, '%s.inputCurve[0]' % loft)
mc.connectAttr('%s.outputCurve' % upRc, '%s.inputCurve[1]' % loft)
mc.connectAttr('%s.outputSurface' % loft,
'%s.create' % loftSurfsN2[s])
## --- attach teeth on n2 surface
for control in ctrlLists[s]:
endXrivet = xrivetTrOnNurbs(control,
loftSurfsN2[s],
mainDirection=1,
out='worldSpace[0]',
u=None,
v=None,
offsetOrient=offset,
min=False)
mc.setAttr('%s.jointOrient' % control, 0, 0, 0)
## --- connect teeth ctrl joits to teeth scales
endsCtrls = [
'C_%s_%s_ctrl' % (baseName, stack),
'%s_%s_%s_ctrl' % (side, baseName, stack)
]
midCtrl = '%s_%s_%s_mid_ctrl' % (side, baseName, stack)
for i, each in enumerate(ctrlLists[s]):
# getting position percentage from position on surface
## getVpos from joints, it will be used in the 'curveFromSurfaceUV' node
surfShape = dagLib.getFirstShape(loftSurfsN2[s])
cpos = mc.createNode('closestPointOnSurface', n='temp_cpos')
mc.connectAttr('%s.worldSpace[0]' % surfShape,
'%s.inputSurface' % cpos)
pointPos = mc.xform(each, q=True, ws=True, t=True)
mc.setAttr('%s.inPosition' % cpos, pointPos[0], pointPos[1],
pointPos[2])
paramV = mc.getAttr('%s.parameterV' % cpos)
mc.delete(cpos)
## creates curve from node and get position percentage of joint from it
tempCrv = mc.curve(d=3,
p=[(0, 0, 0), (1, 1, 1), (2, 2, 2),
(3, 3, 3)])
tempCfsi = mc.createNode('curveFromSurfaceIso', n='temp_cfsi')
mc.setAttr('%s.isoparmValue' % tempCfsi, paramV)
mc.setAttr('%s.isoparmDirection' % tempCfsi, 1)
mc.connectAttr('%s.worldSpace[0]' % surfShape,
'%s.inputSurface' % tempCfsi)
mc.connectAttr('%s.outputCurve' % tempCfsi,
'%s.create' % tempCrv)
paramOnCrv = curveLib.getClosestPointOnCurve(tempCrv,
pointPos,
space='world')[1]
percent = curveLib.findPercentFromParam(tempCrv, paramOnCrv)
mc.delete(tempCfsi, tempCrv)
#print '%s is %s percent' %(each,percent)
# get soft fallof from percent and sine function
sideSine = ((math.sin((percent * math.pi) -
(math.pi / 2))) + 1) / 2
midSine = math.sin(percent * math.pi)
#print '%s is %s sideSine' %(each,sideSine)
PMA = mc.createNode('plusMinusAverage',
n='%s_scale_pma' % each)
centerPMA = mc.createNode('plusMinusAverage',
n='%s_scale_center_pma' % each)
sidePMA = mc.createNode('plusMinusAverage',
n='%s_scale_center_side_pma' % each)
midPMA = mc.createNode('plusMinusAverage',
n='%s_scale_center_mid_pma' % each)
mc.setAttr('%s.operation' % centerPMA, 2)
mc.setAttr('%s.input3D[1]' % centerPMA, 1, 1, 1)
mc.setAttr('%s.operation' % sidePMA, 2)
mc.setAttr('%s.input3D[1]' % sidePMA, 1, 1, 1)
mc.setAttr('%s.operation' % midPMA, 2)
mc.setAttr('%s.input3D[1]' % midPMA, 1, 1, 1)
mc.connectAttr('%s.scale' % endsCtrls[0],
'%s.input3D[0]' % centerPMA)
mc.connectAttr('%s.scale' % endsCtrls[1],
'%s.input3D[0]' % sidePMA)
mc.connectAttr('%s.scale' % midCtrl, '%s.input3D[0]' % midPMA)
centerMD = mc.createNode('multiplyDivide',
n='%s_center_scale_MD' % each)
sideMD = mc.createNode('multiplyDivide',
n='%s_side_scale_MD' % each)
midMD = mc.createNode('multiplyDivide',
n='%s_mid_scale_MD' % each)
mc.connectAttr('%s.output3D' % centerPMA,
'%s.input1' % centerMD)
mc.connectAttr('%s.output3D' % sidePMA, '%s.input1' % sideMD)
mc.connectAttr('%s.output3D' % midPMA, '%s.input1' % midMD)
mc.setAttr('%s.input2' % centerMD, 1 - sideSine, 1 - sideSine,
1 - sideSine)
mc.setAttr('%s.input2' % sideMD, sideSine, sideSine, sideSine)
mc.setAttr('%s.input2' % midMD, midSine, midSine, midSine)
mc.setAttr('%s.input2D[0]' % PMA, 1, 1)
mc.connectAttr('%s.outputZ' % centerMD,
'%s.input2D[1].input2Dx' % PMA)
mc.connectAttr('%s.outputY' % centerMD,
'%s.input2D[1].input2Dy' % PMA)
mc.connectAttr('%s.outputX' % sideMD,
'%s.input2D[2].input2Dx' % PMA)
mc.connectAttr('%s.outputY' % sideMD,
'%s.input2D[2].input2Dy' % PMA)
mc.connectAttr('%s.outputZ' % midMD,
'%s.input2D[3].input2Dx' % PMA)
mc.connectAttr('%s.outputY' % midMD,
'%s.input2D[3].input2Dy' % PMA)
mc.connectAttr('%s.output2Dx' % PMA, '%s.scaleZ' % each)
mc.connectAttr('%s.output2Dy' % PMA, '%s.scaleY' % each)
# --- add bpm cluster to top and bottom teeth
for ctrl in worldTargets:
splitName = ctrl.split('_')
if 'gumsBase' in splitName:
if 'SKN' in splitName:
parent = mc.listRelatives(ctrl, p=True)[0]
mc.select(cl=True)
newClstr = mc.cluster(n='%s_%s_cluster' %
(splitName[0], splitName[1]),
bs=True,
wn=(ctrl, ctrl))[0]
mc.connectAttr('%s.parentInverseMatrix[0]' % ctrl,
'%s.bindPreMatrix' % newClstr)
if mc.objExists(gumsMesh):
clstrSet = mc.listConnections(newClstr,
type="objectSet")[0]
mc.sets(gumsMesh, add=clstrSet)
elif mc.objExists(gumsMeshAlt):
clstrSet = mc.listConnections(newClstr,
type="objectSet")[0]
mc.sets(gumsMeshAlt, add=clstrSet)
# --- tweak shapes and colors of base ctrls
for ctrl in worldTargets:
splitName = ctrl.split('_')
if 'gumsBase' in splitName:
if 'ctrl' in splitName:
shapes.create(ctrl,
shape='circleLowHalf',
size=0.2,
scale=[1, 1, 1],
axis='y',
twist=90,
offset=[0, 0, -0.06],
color=[1, 0, 0],
colorDegradeTo=None,
replace=True,
middle=False)
if 'L' in splitName:
if 'ctrl' in splitName:
if not 'mid' in splitName:
shapes.create(ctrl,
shape='pyramid',
size=0.15,
scale=[1, 1, 1],
axis='x',
twist=0,
offset=[0.05, 0, 0],
color=[0, 0, 1],
colorDegradeTo=None,
replace=True,
middle=False)
if 'mid' in splitName:
shapes.create(ctrl,
shape='pyramid',
size=0.1,
scale=[1, 1, 1],
axis='z',
twist=0,
offset=[0, 0, 0.05],
color=[0.5, 0.5, 1],
colorDegradeTo=None,
replace=True,
middle=False)
if 'R' in splitName:
if 'ctrl' in splitName:
if not 'mid' in splitName:
shapes.create(ctrl,
shape='pyramid',
size=0.15,
scale=[1, 1, 1],
axis='-x',
twist=0,
offset=[-0.05, 0, 0],
color=[1, 0, 0],
colorDegradeTo=None,
replace=True,
middle=False)
if 'mid' in splitName:
shapes.create(ctrl,
shape='pyramid',
size=0.1,
scale=[1, 1, 1],
axis='z',
twist=0,
offset=[0, 0, 0.05],
color=[1, 0.5, 0.5],
colorDegradeTo=None,
replace=True,
middle=False)
if 'C' in splitName:
if 'ctrl' in splitName:
shapes.create(ctrl,
shape='pyramid',
size=0.15,
scale=[1, 1, 1],
axis='z',
twist=0,
offset=[0, 0, 0.05],
color=[1, 1, 0],
colorDegradeTo=None,
replace=True,
middle=False)
# --- cleanup , sets and stuff
trashNodes = mc.ls('transform?', type='transform')
mc.delete(trashNodes)
mc.parent(teethGuidesGrp, 'head_%s' % MainGuideSuff)
addToSetList = [
'L_teeth_up_ctrl', 'R_teeth_up_ctrl', 'C_teeth_up_ctrl',
'L_teeth_dn_ctrl', 'R_teeth_dn_ctrl', 'C_teeth_dn_ctrl',
'gumsBase_up_ctrl', 'gumsBase_dn_ctrl', 'L_teeth_up_mid_ctrl',
'L_teeth_dn_mid_ctrl', 'R_teeth_up_mid_ctrl', 'R_teeth_dn_mid_ctrl'
]
if mc.objExists('anim_set'):
mc.sets(addToSetList, add='anim_set')
except Exception, error:
pprint.pprint(vars())
raise ValueError, "Cast fail | {0}".format(error)
try:
if not l_pos:
log.warning("Cast return: %s" % d_castReturn)
raise StandardError, "createMeshSliceCurve>> Not hits found. Nothing to do"
if len(l_pos) >= 3:
if closedCurve:
l_pos.extend(l_pos[:curveDegree])
knot_len = len(l_pos) + curveDegree - 1
curveBuffer = mc.curve(d=curveDegree,
periodic=True,
p=l_pos,
k=[i for i in range(0, knot_len)],
os=True)
for i, ep in enumerate(
mc.ls("{0}.ep[*]".format(curveBuffer), flatten=True)):
#Second loop to put ep's where we want them. Necessary only because I couldn't get curve create to work right closed
POS.set(ep, l_pos[i])
else:
knot_len = len(l_pos) + curveDegree - 1
curveBuffer = mc.curve(d=curveDegree,
ep=l_pos,
k=[i for i in range(0, knot_len)],
os=True)
if returnDict:
return {
def stretchy(self, obj_start, obj_end, name, side, scale_obj_first,
scale_obj_second, stretchy_joint, ik_fk_control):
obj_start_pos = cmds.xform(obj_start, t=True, ws=True, q=True)
obj_end_pos = cmds.xform(obj_end, t=True, ws=True, q=True)
stretchy_curve = cmds.curve(d=1,
p=[obj_start_pos, obj_end_pos],
k=(0, 1),
n=name)
cmds.parent(stretchy_curve, 'extra')
cmds.skinCluster(obj_start, stretchy_joint, stretchy_curve, tsb=True)
shape = cmds.listRelatives(stretchy_curve)[0]
curve_info_node = cmds.shadingNode('curveInfo',
asUtility=True,
n=stretchy_curve + '_' +
'side_curve_info')
MD_node = cmds.shadingNode('multiplyDivide',
asUtility=True,
n=stretchy_curve + '_' + side + '_MD')
condition_node = cmds.shadingNode('condition',
asUtility=True,
n=stretchy_curve + '_' + side +
'_condition')
cmds.connectAttr(shape + '.worldSpace[0]',
curve_info_node + '.inputCurve')
cmds.connectAttr(curve_info_node + '.arcLength', MD_node + '.input1X')
arc_length = cmds.getAttr(curve_info_node + '.arcLength')
cmds.setAttr(MD_node + '.input2X', arc_length)
cmds.setAttr(MD_node + '.operation', 2)
cmds.connectAttr(curve_info_node + '.arcLength',
condition_node + '.firstTerm')
cmds.setAttr(condition_node + '.secondTerm', arc_length)
cmds.setAttr(condition_node + '.operation', 4)
cmds.setAttr(condition_node + '.colorIfTrueR', 1)
#glooal scale
global_scale_MD = cmds.shadingNode('multiplyDivide',
asUtility=True,
n='global_scale_MD')
cmds.setAttr(global_scale_MD + '.operation', 2)
cmds.connectAttr(MD_node + '.outputX', global_scale_MD + '.input1X')
cmds.connectAttr('main_control.sx', global_scale_MD + '.input2X')
cmds.connectAttr(global_scale_MD + '.outputX',
condition_node + '.colorIfFalseR')
# connect condition node for fk mode as well
condition_fk = cmds.shadingNode('condition',
asUtility=True,
n=stretchy_curve + '_' + side +
'_condition_fk')
cmds.connectAttr(ik_fk_control + '.ikfk', condition_fk + '.firstTerm')
cmds.setAttr(condition_fk + '.secondTerm', 0)
cmds.setAttr(condition_fk + '.operation', 0)
cmds.connectAttr(condition_node + '.outColorR',
condition_fk + '.colorIfTrueR')
cmds.setAttr(condition_fk + '.colorIfFalseR', 1)
# set another condition node for stretch on and off
condition_stretch = cmds.shadingNode('condition',
asUtility=True,
n=stretchy_curve + '_' + side +
'condition_stretch')
cmds.connectAttr(ik_fk_control + '.stretch',
condition_stretch + '.firstTerm')
cmds.setAttr(condition_stretch + '.secondTerm', 0)
cmds.setAttr(condition_stretch + '.operation', 1)
cmds.connectAttr(condition_fk + '.outColorR',
condition_stretch + '.colorIfTrueR')
cmds.setAttr(condition_stretch + '.colorIfFalseR', 1)
cmds.connectAttr(condition_stretch + '.outColorR',
scale_obj_first + '.sx')
cmds.connectAttr(condition_stretch + '.outColorR',
scale_obj_second + '.sx')
# volume preservation
MD_volume_node = cmds.shadingNode('multiplyDivide',
asUtility=True,
n="MD_volume_" + side)
cmds.connectAttr(condition_stretch + '.outColorR',
MD_volume_node + '.input1Y')
cmds.connectAttr(condition_stretch + '.outColorR',
MD_volume_node + '.input2Y')
MD_volume_node_2 = cmds.shadingNode('multiplyDivide',
asUtility=True,
n="MD_volume_" + side)
cmds.setAttr(MD_volume_node_2 + '.input1Y', 1)
cmds.setAttr(MD_volume_node_2 + '.operation', 2)
cmds.connectAttr(MD_volume_node + '.outputY',
MD_volume_node_2 + '.input2Y')
cmds.connectAttr(MD_volume_node_2 + '.outputY',
scale_obj_first + '.sy')
cmds.connectAttr(MD_volume_node_2 + '.outputY',
scale_obj_first + '.sz')
cmds.connectAttr(MD_volume_node_2 + '.outputY',
scale_obj_second + '.sy')
cmds.connectAttr(MD_volume_node_2 + '.outputY',
scale_obj_second + '.sz')
def createCurveFromPoints(points,
degree=3,
name='curve',
transformType="transform",
form="Open"):
'''
:param points: Points you wish to use to create a curve
:type points: list
:param degree: The degree of the curve you want to create
:type degree: int
:param name: the name of the curve.
:type name: str
:param form: The form of the curve. i.e (Open, Closed, Periodic). If the form is Closed or
Periodic we will use a nurbs circle.
:type form: str
:return: The name of the curve that was created.
:rtype: str
'''
knotList = [0]
if degree == 1:
knotList.extend(range(len(points))[1:])
elif degree == 2:
knotList.extend(range(len(points) - 1))
knotList.append(knotList[-1])
elif degree == 3:
knotList.append(0)
knotList.extend(range(len(points) - 2))
knotList.extend([knotList[-1], knotList[-1]])
# if the form is closed, we will use a circle to create the control
if form not in ['Closed', 'Periodic']:
curve = mc.curve(name=name, p=points, k=knotList, degree=degree)
else:
curve = mc.circle(name=name,
c=(0, 0, 0),
nr=(0, 1, 0),
sw=360,
r=1,
d=degree,
ut=0,
tol=0.01,
s=len(points),
ch=False)[0]
for i, position in enumerate(points):
mc.setAttr("{}.controlPoints[{}]".format(curve, i), *position)
# rename all of the shapes that are children of the curve. In this instance, there should
# only be one.
for shape in mc.listRelatives(curve, c=True, type="shape"):
if transformType == "joint":
trsTypeName = mc.createNode("joint", name="{}_jtn".format(name))
mc.parent(shape, trsTypeName, r=True, shape=True)
mc.delete(curve)
mc.rename(trsTypeName, curve)
mc.setAttr("{}.drawStyle".format(curve), 2)
mc.rename(shape, "{}Shape".format(curve))
return curve
def Controllers():
charName = cmds.textFieldGrp(NameInput, q=True, text=True)
lengthY = locXYZ[1][1] - locXYZ[0][1]
lengthZ = abs(locXYZ[0][2]) + abs(locXYZ[1][2])
legY = locXYZ[0][1] - locXYZ[5][1]
side = ['_L_', '_R_']
nb = [1, -1]
for i in range(len(side)):
cmds.ikHandle(n='Leg' + side[i] + 'ikHandle',
sj=charName + side[i] + 'thigh_Jnt_01',
ee=charName + side[i] + 'ankie_Jnt_01')
cmds.spaceLocator(n='poleVector' + side[i] + 'leg',
p=(nb[i] * locXYZ[4][0] - legY * 0.005,
locXYZ[4][1] + legY * 0.05, locXYZ[4][2]))
cmds.xform(centerPivots=1)
# aims the pole vector of 1 at 2.
cmds.poleVectorConstraint('poleVector' + side[i] + 'leg',
'Leg' + side[i] + 'ikHandle')
cmds.move(nb[i] * lengthY * 0.75,
-lengthY * 0.75,
'poleVector' + side[i] + 'leg',
moveXY=True)
cmds.setAttr('Leg' + side[i] + 'ikHandle.twist', nb[i] * 90)
cmds.ParentConstraint('controllerfoot', 'poleVector' + side[i] + 'leg')
cmds.parent('poleVector' + side[i] + 'leg',
'Leg' + side[i] + 'ikHandle',
relative=True)
cmds.ikHandle(n='Foot' + side[i] + 'ball_ikHandle',
sj=charName + side[i] + 'ankie' + '_Jnt_01',
ee=charName + side[i] + 'ball' + '_Jnt_01')
cmds.ikHandle(n='Foot' + side[i] + 'toe_ikHandle',
sj=charName + side[i] + 'ball' + '_Jnt_01',
ee=charName + side[i] + 'toe' + '_Jnt_01')
cmds.group('Leg' + side[i] + 'ikHandle',
n='Foot' + side[i] + 'heelPeel')
#change pivot position
Xpos = cmds.getAttr('Foot' + side[i] + 'ball_ikHandle.translateX')
Ypos = cmds.getAttr('Foot' + side[i] + 'ball_ikHandle.translateY')
Zpos = cmds.getAttr('Foot' + side[i] + 'ball_ikHandle.translateZ')
cmds.move(Xpos,
Ypos,
Zpos,
'Foot' + side[i] + 'heelPeel.scalePivot',
'Foot' + side[i] + 'heelPeel.rotatePivot',
absolute=True)
cmds.group('Foot' + side[i] + 'ball_ikHandle',
'Foot' + side[i] + 'toe_ikHandle',
n='Foot' + side[i] + 'toeTap')
cmds.move(Xpos,
Ypos,
Zpos,
'Foot' + side[i] + 'toeTap.scalePivot',
'Foot' + side[i] + 'toeTap.rotatePivot',
absolute=True)
cmds.group('Foot' + side[i] + 'ball_ikHandle',
'Foot' + side[i] + 'toeTap',
n='Foot' + side[i] + 'TipToe')
cmds.group(n='Foot' + side[i] + '1', em=True)
cmds.parent('Foot' + side[i] + 'heelPeel',
'Foot' + side[i] + 'TipToe',
'Foot' + side[i] + '1',
relative=True)
cmds.move(Xpos,
Ypos,
Zpos,
'Foot' + side[i] + '1.scalePivot',
'Foot' + side[i] + '1.rotatePivot',
absolute=True)
Xpos = cmds.getAttr('Foot' + side[i] + 'ball_ikHandle.translateX')
Ypos = cmds.getAttr('Foot' + side[i] + 'ball_ikHandle.translateY')
Zpos = cmds.getAttr('Foot' + side[i] + 'ball_ikHandle.translateZ')
CreateCtr('Foot' + side[i] + 'Crl', 'Foot' + side[i] + '1',
(Xpos, Ypos, Zpos),
(lengthY / 60 * 10, lengthY / 60 * 10, lengthY / 60 * 16),
(0, 0, 0))
#left Arm
for i in range(len(side)):
cmds.ikHandle(n='Arm' + str(side[i]) + 'ikHandle',
sj=charName + str(side[i]) + 'shoulder' + '_Jnt_02',
ee=charName + str(side[i]) + 'wrist' + '_Jnt_01')
cmds.CreateNURBSCircle()
cmds.rename('nurbsCircle1', 'Elbow' + str(side[i]) + 'Crl')
cmds.move(nb[i] * locXYZ[2][0], locXYZ[2][1], locXYZ[2][2] * 30)
cmds.scale(2, 2, 3)
cmds.rotate(90, 0, 0)
cmds.move(nb[i] * locXYZ[2][0],
locXYZ[2][1],
locXYZ[2][2],
'Elbow' + str(side[i]) + 'Crl.scalePivot',
'Elbow' + str(side[i]) + 'Crl.rotatePivot',
absolute=True)
cmds.makeIdentity(apply=True)
cmds.xform(centerPivots=1)
cmds.poleVectorConstraint('Elbow' + str(side[i]) + 'Crl',
'Arm' + str(side[i]) + 'ikHandle')
#left Arm controller
CreateCtr('Arm' + side[i] + 'Crl', 'Arm' + side[i] + 'ikHandle',
(nb[i] * locXYZ[3][0], locXYZ[3][1], locXYZ[3][2]),
(lengthY / 60 * 5, lengthY / 60 * 5, lengthY / 60 * 8),
(0, 0, nb[i] * 30))
#spline
cmds.parent(charName + '_R_shoulder_Jnt_01', w=True)
cmds.parent(charName + '_L_shoulder_Jnt_01', w=True)
cmds.select(d=True)
cmds.select(charName + '_spline_Jnt_03')
cmds.DisconnectJoint(charName + '_spline_Jnt_03')
cmds.rename(charName + '_spline_Jnt_03', charName + '_neck_Jnt_00')
cmds.rename('joint1', charName + '_spline_Jnt_03')
cmds.rename(charName + '_root' + '_Jnt_01', charName + '_spline_Jnt_00')
cmds.parent(charName + '_R_hip_Jnt_01', w=True)
cmds.parent(charName + '_L_hip_Jnt_01', w=True)
cmds.select(d=True)
cmds.joint(p=(locXYZ[0][0], locXYZ[0][1], locXYZ[0][2]),
n=charName + '_root' + '_Jnt_01')
cmds.parent(charName + '_L_hip_Jnt_01')
cmds.select(charName + '_root' + '_Jnt_01')
cmds.parent(charName + '_R_hip_Jnt_01')
cmds.curve(n=charName + '_SplineIK_Crv_01',
p=[(locXYZ[0][0], locXYZ[0][1], locXYZ[0][2]),
(0.0, locXYZ[0][1] + lengthY * 0.43,
locXYZ[0][2] + lengthZ * 0.43),
(0.0, locXYZ[0][1] + lengthY * 0.8,
locXYZ[0][2] + lengthZ * 0.18),
(locXYZ[1][0], locXYZ[1][1], locXYZ[1][2])])
cmds.ikHandle(n=charName + 'SplineIK_01',
sj=charName + '_spline_Jnt_00',
ee=charName + '_spline_Jnt_03',
curve=charName + '_SplineIK_Crv_01',
sol='ikSplineSolver',
createCurve=False,
parentCurve=False)
for i in range(4):
cmds.select(charName + '_SplineIK_Crv_01' + '.cv[' + str(i) + ']')
cmds.cluster(n='cluster_' + str(i + 1))
CreateCtr(charName + '_Spline_Ctrl_01', 'cluster_1Handle',
(0, locXYZ[0][1] * 1.05, 0),
(lengthY / 60 * 25, lengthY / 60 * 25, lengthY / 60 * 25),
(0, 0, 0))
cmds.parentConstraint(charName + '_Spline_Ctrl_01',
charName + '_root_Jnt_01',
maintainOffset=True)
CreateCtr(charName + '_Chest_Ctrl_01', 'cluster_4Handle',
(0, locXYZ[1][1], 0),
(lengthY / 60 * 25, lengthY / 60 * 25, lengthY / 60 * 25),
(0, 0, 0))
for i in range(len(side)):
cmds.parentConstraint(charName + '_Chest_Ctrl_01',
charName + side[i] + 'shoulder_Jnt_01',
maintainOffset=True)
cmds.parent('Arm' + side[i] + 'Crl_grp', charName + '_Chest_Ctrl_01')
cmds.parent('Elbow' + side[i] + 'Crl', charName + '_Chest_Ctrl_01')
CreateCtr(charName + '_Chest_Ctrl_02', 'cluster_2Handle',
(0, (locXYZ[0][1] + locXYZ[1][1]) / 2, 0),
(lengthY / 60 * 20, lengthY / 60 * 20, lengthY / 60 * 20),
(0, 0, 0))
cmds.parentConstraint(charName + '_Chest_Ctrl_01',
charName + '_neck_Jnt_00',
maintainOffset=True,
w=1)
cmds.parentConstraint(charName + '_Chest_Ctrl_01',
'cluster_3Handle',
maintainOffset=True,
weight=0.5)
cmds.parentConstraint(charName + '_Chest_Ctrl_01',
charName + '_Chest_Ctrl_02_grp',
maintainOffset=True,
weight=0.5)
cmds.parentConstraint(charName + '_Spline_Ctrl_01',
charName + '_Chest_Ctrl_02_grp',
maintainOffset=True,
weight=0.5)
cmds.CreateNURBSCircle()
cmds.rename('nurbsCircle1', charName + '_Hip_Ctrl_01')
cmds.move(0, locXYZ[0][1], 0)
cmds.scale(lengthY / 60 * 30, lengthY / 60 * 30, lengthY / 60 * 30)
cmds.makeIdentity(apply=True)
cmds.parentConstraint(charName + '_Hip_Ctrl_01',
charName + '_Spline_Ctrl_01',
maintainOffset=True,
weight=0.5)
cmds.parentConstraint(charName + '_Hip_Ctrl_01',
charName + '_Chest_Ctrl_01',
maintainOffset=True,
weight=0.5)
#clean
for i in range(len(side)):
cmds.parent(charName + side[i] + 'shoulder_Jnt_01',
charName + '_Joints_01')
cmds.parent(charName + '_Chest_Ctrl_0' + str(i + 1) + '_grp',
charName + '_Controls_01')
cmds.parent('Foot' + side[i] + '1', charName + '_Controls_01')
cmds.parent('Foot' + side[i] + 'Crl_grp', charName + '_Controls_01')
cmds.parent('Arm' + side[i] + 'ikHandle', charName + '_ikHandle_01')
cmds.parent('cluster_' + str(i + 1) + 'Handle',
charName + '_ikHandle_01')
cmds.parent('cluster_' + str(i + 3) + 'Handle',
charName + '_ikHandle_01')
cmds.parent(charName + 'SplineIK_01', charName + '_ikHandle_01')
cmds.parent(charName + '_SplineIK_Crv_01', charName + '_ikHandle_01')
cmds.parent(charName + '_neck_Jnt_00', charName + '_Joints_01')
cmds.parent(charName + '_root_Jnt_01', charName + '_Joints_01')
cmds.parent(charName + '_spline_Jnt_00', charName + '_Joints_01')
cmds.parent(charName + '_Spline_Ctrl_01_grp', charName + '_Controls_01')
cmds.parent(charName + '_Hip_Ctrl_01', charName + '_Controls_01')
def make_ik_joint_chain(self, side, thigh, knee, knee_end, ankle, toe,
toe_end, heel, color):
# make ik handle and control
ik_leg = cmds.ikHandle(n='ik_leg_' + side,
sj=thigh,
ee=knee_end,
sol='ikRPsolver')
c = custom_controls.create_custom_controls()
self.leg_control = c.cube_curve('ANIM_leg_' + side)
self.override_colors(self.leg_control, color)
cmds.setAttr(self.leg_control + '.lineWidth', 2)
cmds.xform(self.leg_control, cp=True)
self.leg_control_grp = cmds.group(self.leg_control,
n='grp_ANIM_leg_' + side)
cmds.matchTransform(self.leg_control_grp, ik_leg, pos=True)
self.controls.append(self.leg_control_grp)
cmds.parent(self.leg_control_grp, 'controls')
#create a pole vector
self.create_pole_vector(side, thigh, knee, knee_end, 'leg',
'ik_leg_' + side, color)
#create toe roll joint
jDrv_foot = cmds.duplicate(toe, name='jDrv_bind_foot_' + side)
temp = cmds.pickWalk(jDrv_foot[0], d='down')
cmds.delete(temp)
cmds.parent(jDrv_foot, toe)
# creating locators
#
loc_ankle = cmds.spaceLocator(n='locDrv_ankle_' + side)[0]
loc_ankle_grp = cmds.group(loc_ankle,
n='locDrv_ankle_' + side + '_Null')
cmds.matchTransform(loc_ankle_grp, ankle)
##
loc_toe_grp = cmds.duplicate(loc_ankle_grp,
n='locDrv_foot_' + side + '_Null')[0]
temp = cmds.pickWalk(loc_toe_grp, d='down')
loc_toe = cmds.rename(temp, 'locDrv_foot_' + side)
cmds.matchTransform(loc_toe_grp, toe, pos=True)
cmds.matchTransform(loc_toe_grp, ankle, rot=True)
###
loc_toe_end_grp = cmds.duplicate(loc_toe_grp,
n='locDrv_toe_' + side + '_Null')[0]
temp = cmds.pickWalk(loc_toe_end_grp, d='down')
loc_toe_end = cmds.rename(temp, 'locDrv_toe_' + side)
cmds.matchTransform(loc_toe_end_grp, toe_end)
####
loc_heel = cmds.spaceLocator(n='locDrv_heel_' + side)[0]
loc_heel_grp = cmds.group(loc_heel, n='locDrv_heel_' + side + '_Null')
cmds.matchTransform(loc_heel_grp, heel)
##parenting
cmds.parent(loc_ankle, loc_toe)
cmds.parent(loc_toe_grp, loc_toe_end)
cmds.parent(loc_toe_end_grp, loc_heel)
cmds.delete(loc_ankle_grp)
cmds.parent(loc_heel_grp, self.leg_control)
##constraints
cmds.pointConstraint(loc_ankle, 'ik_leg_' + side)
cmds.orientConstraint(loc_toe, ankle, mo=True)
cmds.orientConstraint(loc_toe_end, toe, mo=True)
#creating controls for foot system
toe_Ctl = cmds.curve(n='ANIM_toe_' + side,
d=1,
p=[(-1, 0, -1), (1, 0, -1), (1, 0, 1), (-1, 0, 1),
(-1, 0, -1)],
k=[0, 1, 2, 3, 4])
toe_end_Ctl = cmds.curve(n='ANIM_toe_end_' + side,
d=1,
p=[(0, 1, 1), (0, 1, -1), (0, -1, -1),
(0, -1, 1), (0, 1, 1)],
k=[0, 1, 2, 3, 4])
heel_Ctl = cmds.curve(n='ANIM_heel_' + side,
d=1,
p=[(-1, 1, 0), (1, 1, 0), (1, -1, 0),
(-1, -1, 0), (-1, 1, 0)],
k=[0, 1, 2, 3, 4])
self.controls.extend((toe_Ctl, toe_end_Ctl, heel_Ctl))
self.foot_controls = [toe_Ctl, toe_end_Ctl, heel_Ctl]
grp_foot_controls = self.group_foot_controls(self.foot_controls)
grp_grp_foot_controls = self.group_foot_controls(grp_foot_controls)
cmds.parent('ANIM_heel_' + side + '_grp_grp', loc_heel_grp)
cmds.parent('ANIM_toe_' + side + '_grp_grp', loc_toe_grp)
cmds.parent('ANIM_toe_end_' + side + '_grp_grp', loc_toe_end_grp)
self.alignObjs(grp_grp_foot_controls)
# orientConstraint
cmds.orientConstraint(toe_Ctl, loc_toe, mo=True)
cmds.orientConstraint(heel_Ctl, loc_heel)
cmds.orientConstraint(toe_end_Ctl, loc_toe_end)
# create an attribute for toe roll and foot roll
cmds.select(self.leg_control)
cmds.addAttr(shortName='tr',
longName='toe_roll',
defaultValue=0,
k=True)
cmds.addAttr(shortName='fr',
longName='foot_roll',
defaultValue=0,
minValue=-10,
maxValue=10,
k=True)
cmds.connectAttr(self.leg_control + '.toe_roll', jDrv_foot[0] + '.rz')
cmds.setDrivenKeyframe('ANIM_toe_end_' + side + '_grp.rz',
cd=self.leg_control + '.fr',
v=0,
dv=0)
cmds.setDrivenKeyframe('ANIM_toe_' + side + '_grp.rz',
cd=self.leg_control + '.fr',
v=0,
dv=0)
cmds.setDrivenKeyframe('ANIM_heel_' + side + '_grp.rx',
cd=self.leg_control + '.fr',
v=0,
dv=0)
cmds.setDrivenKeyframe('ANIM_toe_end_' + side + '_grp.rz',
cd=self.leg_control + '.fr',
v=0,
dv=4)
cmds.setDrivenKeyframe('ANIM_toe_' + side + '_grp.rz',
cd=self.leg_control + '.fr',
v=-45,
dv=5)
cmds.setDrivenKeyframe('ANIM_toe_end_' + side + '_grp.rz',
cd=self.leg_control + '.fr',
v=-70,
dv=10)
cmds.setDrivenKeyframe('ANIM_toe_' + side + '_grp.rz',
cd=self.leg_control + '.fr',
v=40,
dv=10)
cmds.setDrivenKeyframe('ANIM_toe_end_' + side + '_grp.rz',
cd=self.leg_control + '.fr',
v=0,
dv=-10)
cmds.setDrivenKeyframe('ANIM_toe_' + side + '_grp.rz',
cd=self.leg_control + '.fr',
v=-0,
dv=-10)
cmds.setDrivenKeyframe('ANIM_heel_' + side + '_grp.rx',
cd=self.leg_control + '.fr',
v=-40,
dv=-10)
# hide locators
self.hideShape([loc_toe_end, loc_toe, loc_heel, loc_ankle])
cmds.parent('ik_leg_' + side, 'IKs')
condition = cmds.shadingNode('condition',
asUtility=True,
n='condition_node' +
self.leg_control_grp[0])
cmds.setAttr(condition + '.secondTerm', 1)
cmds.connectAttr(self.ik_fk_control + '.ikfk',
condition + '.firstTerm')
cmds.connectAttr(condition + '.outColorR',
self.leg_control_grp + '.visibility')
cmds.connectAttr(condition + '.outColorR',
'PV_ik_leg_' + side + '_Null' + '.visibility')
for obj in self.foot_controls:
cmds.connectAttr(condition + '.outColorR', obj + '.visibility')
#point Constraint ankle
cmds.pointConstraint('ik_leg_' + side, ankle, mo=True)
cmds.pointConstraint(knee_end, ankle, mo=True)
#make a joint for stretching
self.stretchy_joint = cmds.joint()
cmds.setAttr(self.stretchy_joint + '.drawStyle', 2)
cmds.matchTransform(self.stretchy_joint, self.leg_control)
cmds.parent(self.stretchy_joint, self.leg_control)
import maya.cmds as cmds
def buildRibbonSurface(locators,
name='',
close=False,
vector=[1, 0, 0],
width=10):
lineCrvs = []
for locator in locators:
pos = cmds.xform(locator, q=True, ws=True, rp=True)
posVector = om.MVector(pos[0], pos[1], pos[2])
inverseWidth = width * -1
translateVectorForward = om.MVector(vector[0] * width,
vector[1] * width,
vector[2] * width)
translateVectorBackward = om.MVector((vector[0] * inverseWidth),
(vector[1] * inverseWidth),
(vector[2] * inverseWidth))
startTransformationMatrix = om.MTransformationMatrix()
startTransformationMatrix.setTranslation(posVector, om.MSpace.kWorld)
startTransformationMatrix.addTranslation(translateVectorForward,
om.MSpace.kObject)
startPosVector = startTransformationMatrix.getTranslation(
om.MSpace.kWorld)
endTransformationMatrix = om.MTransformationMatrix()
endTransformationMatrix.setTranslation(posVector, om.MSpace.kWorld)
endTransformationMatrix.addTranslation(translateVectorBackward,
om.MSpace.kObject)
endPosVector = endTransformationMatrix.getTranslation(om.MSpace.kWorld)
startPos = [startPosVector.x, startPosVector.y, startPosVector.z]
endPos = [endPosVector.x, endPosVector.y, endPosVector.z]
lineCrv = cmds.curve(d=1, p=(startPos, endPos))
lineCrvs.append(lineCrv)
ribbonOrig = cmds.loft(lineCrvs,
ch=1,
u=1,
c=close,
ar=1,
d=3,
ss=1,
rn=0,
po=0,
rsn=True,
n='%s_Surface' % name)
ribbonRebuild = cmds.rebuildSurface(ribbonOrig[0],
ch=1,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=1,
kc=0,
su=8,
du=1,
sv=2,
dv=3,
tol=0.01,
fr=0,
dir=2)
ribbon = []
shape = cmds.listRelatives(ribbonRebuild[0], type='shape')[0]
ribbon.append(ribbonRebuild[0])
ribbon.append(shape)
cmds.delete(ribbonOrig[0], ch=True)
cmds.delete(lineCrvs)
return ribbon
def TDTransform(self, name):
self.attr = [
".tx", ".ty", ".tz", ".rx", ".ry", ".rz", ".sx", ".sy", ".sz", ".v"
]
self.arrows = []
self.circleHelper = cmds.circle(c=[0, 0, 0],
nr=[0, 1, 0],
sw=360,
r=1.5,
d=3,
ut=0,
tol=0.01,
s=8,
ch=0,
n=name)
self.arrows1 = cmds.curve(d=1,
n="helperArrow1",
p=[(1.75625, 0, 0.115973),
(1.75625, 0, -0.170979),
(2.114939, 0, -0.170979),
(2.114939, 0, -0.314454),
(2.473628, 0, -0.0275029),
(2.114939, 0, 0.259448),
(2.114939, 0, 0.115973),
(1.75625, 0, 0.115973)])
self.arrows2 = cmds.curve(d=1,
n="helperArrow2",
p=[(0.143476, 0, -1.783753),
(0.143476, 0, -2.142442),
(0.286951, 0, -2.142442),
(0, 0, -2.501131),
(-0.286951, 0, -2.142442),
(-0.143476, 0, -2.142442),
(-0.143476, 0, -1.783753),
(0.143476, 0, -1.783753)])
self.arrows3 = cmds.curve(d=1,
n="helperArrow3",
p=[(-1.75625, 0, -0.170979),
(-2.114939, 0, -0.170979),
(-2.114939, 0, -0.314454),
(-2.473628, 0, -0.0275029),
(-2.114939, 0, 0.259448),
(-2.114939, 0, 0.115973),
(-1.75625, 0, 0.115973),
(-1.75625, 0, -0.170979)])
self.arrows4 = cmds.curve(d=1,
n="helperArrow4",
p=[(-0.143476, 0, 1.728747),
(-0.143476, 0, 2.087436),
(-0.286951, 0, 2.087436),
(0, 0, 2.446125), (0.286951, 0, 2.087436),
(0.143476, 0, 2.087436),
(0.143476, 0, 1.728747),
(-0.143476, 0, 1.728747)])
self.arrowGRP = cmds.group(self.arrows1,
self.arrows2,
self.arrows3,
self.arrows4,
n="helperArrows_GP",
p="%s" % self.circleHelper[0])
cmds.setAttr(self.arrowGRP + ".template", 1)
"""
for attrs in self.attr:
cmds.setAttr(self.arrowGRP+attrs,k=False,cb=False)
"""
cmds.select(self.circleHelper)
return self.circleHelper[0]
def TDDirSingleNormal(self, name):
return cmds.curve(d=1,
n=name,
p=[(0, 0, -1.32), (-0.99, 0, 0), (-0.33, 0, 0),
(-0.33, 0, 0.99), (0.33, 0, 0.99), (0.33, 0, 0),
(0.99, 0, 0), (0, 0, -1.32)])
import maya.cmds as cmds
import math
import random as rnd
cmds.file(f=True, new=True)
# clear up the scene
cmds.select(all=True)
cmds.delete()
# Create a set of simple objects for the motion path animation
# create a path, e,g, a curve
path = cmds.curve(d=3,
p=[(-10, 0, 0), (-6, 0, 10), (-3, 0, -10), (10, 0, 0)],
k=[0, 0, 0, 1, 1, 1])
# create an object, e.g. a sphere
leader = cmds.sphere()
cmds.group(leader[0], n='group1')
for i in range(2, 10):
follower = cmds.instance(leader[0], smartTransform=True)
x = rnd.randint(1, 3)
y = rnd.randint(1, 3)
z = rnd.randint(1, 3)
cmds.select(cl=True)
cmds.select(follower[0])
print follower[0]
cmds.move(x, y, z)
cmds.scale(0.1, 0.1, 0.1)
cmds.pathAnimation('group1', stu=0, etu=30, follow=True, c=path)
def ControllerForAttr(Attr, Type, PosDir, nameIndex, List):
if len(List):
controllerToUse = List[nameIndex - 1]
print "using selected controller:", controllerToUse
CtrlCurrentLimit = mc.transformLimits(controllerToUse, q=True, ty=True)
if PosDir:
mc.transformLimits(controllerToUse,
ety=(1, 1),
ty=(CtrlCurrentLimit[0], 1))
mc.connectAttr(controllerToUse + ".Pos_Y", Attr)
else:
mc.transformLimits(controllerToUse,
ety=(1, 1),
ty=(-1, CtrlCurrentLimit[1]))
mc.connectAttr(controllerToUse + ".Neg_Y", Attr)
#figure the new limits:
newLimit = mc.transformLimits(controllerToUse, q=True, ty=True)
range = controllerToUse + "_range"
if mc.objExists(range):
minLimitCV = range + ".cv[0]"
maxLimitCV = range + ".cv[1]"
mc.xform(minLimitCV, ws=False, t=(0, newLimit[0], 0))
mc.xform(maxLimitCV, ws=False, t=(0, newLimit[1], 0))
else:
controllerNameBase = mc.textFieldGrp("ControllerTextFieldID",
q=True,
tx=True)
controllerName = "ac_" + controllerNameBase + "_" + str(nameIndex)
mc.circle(n=controllerName, nr=(0, 0, 1), ch=False, r=0.15)
#hide un nessary controlls
mc.setAttr(controllerName + ".tx",
lock=True,
keyable=False,
channelBox=False)
mc.setAttr(controllerName + ".tz",
lock=True,
keyable=False,
channelBox=False)
mc.setAttr(controllerName + ".sx",
lock=True,
keyable=False,
channelBox=False)
mc.setAttr(controllerName + ".sy",
lock=True,
keyable=False,
channelBox=False)
mc.setAttr(controllerName + ".sz",
lock=True,
keyable=False,
channelBox=False)
mc.setAttr(controllerName + ".rx",
lock=True,
keyable=False,
channelBox=False)
mc.setAttr(controllerName + ".ry",
lock=True,
keyable=False,
channelBox=False)
mc.setAttr(controllerName + ".rz",
lock=True,
keyable=False,
channelBox=False)
mc.setAttr(controllerName + ".v",
lock=True,
keyable=False,
channelBox=False)
#create clamp nodes to extract positive and nagative value:
clampPosNode = mc.createNode('clamp', n=controllerName + "clamp_Pos")
clampNegNode = mc.createNode('clamp', n=controllerName + "clamp_Neg")
NegReverseMD = mc.createNode('multiplyDivide',
n=controllerName + "_NegReverseMD")
mc.setAttr(clampPosNode + ".maxG", 1)
mc.setAttr(clampNegNode + ".minG", -1)
mc.setAttr(NegReverseMD + ".input2X", -1)
mc.setAttr(NegReverseMD + ".input2Y", -1)
mc.setAttr(NegReverseMD + ".input2Z", -1)
mc.connectAttr(controllerName + ".translate", clampPosNode + ".input")
mc.connectAttr(controllerName + ".translate", clampNegNode + ".input")
mc.connectAttr(clampNegNode + ".output", NegReverseMD + ".input1")
#add attribute to controller for furture useage:
mc.addAttr(controllerName, ln="Pos_Y", at="double")
mc.addAttr(controllerName, ln="Neg_Y", at="double")
#connect clamp result to new attribute:
mc.connectAttr(clampPosNode + ".outputG", controllerName + ".Pos_Y")
mc.connectAttr(NegReverseMD + ".output.outputY",
controllerName + ".Neg_Y")
#set Limitations:
if PosDir:
mc.transformLimits(controllerName, ety=(1, 1), ty=(0, 1))
mc.connectAttr(controllerName + ".Pos_Y", Attr)
else:
mc.transformLimits(controllerName, ety=(1, 1), ty=(-1, 0))
mc.connectAttr(controllerName + ".Neg_Y", Attr)
#create nessary hierachy:
controllerGrpName = controllerName + "_grp"
mc.group(controllerName, n=controllerGrpName)
if Type == "Slider":
rangeCurve = controllerName + "_range"
mc.curve(d=1, p=[(0, 0, 0), (0, 1, 0)], n=rangeCurve)
mc.setAttr(rangeCurve + ".template", 1)
mc.parent(rangeCurve, controllerGrpName)
mc.setAttr(controllerGrpName + ".tx", nameIndex / 2.0)
def __init__(self, name, jointNum=3, driverJointNum=2, primaryAxis="X"):
mt.Rivet.__init__(self, mo=True)
self.name = name
self.jointNum = jointNum
self.driverJointNum = driverJointNum
self.primaryAxis = primaryAxis
self.spans = ((jointNum - 1) * (driverJointNum - 1))
self.ribbon = []
self.lenCurves = []
self.joints = []
self.driverJoints = []
self.deformers = []
self.proxies = []
if jointNum < 3 or driverJointNum < 2:
return mc.error("Rig needs a minimum of 2 drivers and 3 joints")
ptPosList = []
attrs = [POS_ATTR, SCL_ATTR]
prxyGrp = mc.createNode("transform", n="{}_prxy{}".format(name, GRP))
prevPrxy = "{}_base_prxy".format(name)
for i in range(driverJointNum):
# Create a set of locators to be used as proxies for your ribbon's driver joints
# Set position based on rig's primary axis
if primaryAxis == "Z":
ptPos = (0, 0, i * 10)
elif primaryAxis == "Y":
ptPos = (0, i * 10, 0)
else:
ptPos = (i * 10, 0, 0)
ptPosList.append(ptPos)
# Name the proxy based on its order in the chain
if i == 0:
prxy = "{}_base_prxy".format(name)
elif i == driverJointNum - 1:
prxy = "{}_tip_prxy".format(name)
elif i >= 1 and driverJointNum >= 4:
prxy = "{}_mid{}_prxy".format(name, str(i).zfill(2))
else:
prxy = "{}_mid_prxy".format(name)
# Create the locator
mc.spaceLocator(n=prxy)
mc.setAttr("{}.translate{}".format(prxy, primaryAxis), i * 10)
# Lock attributes you don't want to be changed so the rig is buit properly
if i == 0:
# As the root, the first proxy will have the freest range of motion
for v in VECTORS:
mc.setAttr("{}.scale{}".format(prxy, v),
lock=True, keyable=False, channelBox=False)
# Parent to the appropriate group
mc.parent(prxy, prxyGrp)
if i > 0:
# Child proxies will have a more limited range of movement
for attr in attrs:
for v in VECTORS:
if attr == SCL_ATTR or v != primaryAxis:
mc.setAttr("{}{}{}".format(prxy, attr, v),
lock=True, keyable=False, channelBox=False)
# Parent to the appropriate group
mc.parent(prxy, prevPrxy)
self.proxies.append(prxy)
prevPrxy = prxy
# We also want to create a curve whose arclen will create the width of your ribbon
self.proxieCrv = mc.curve(
d=1, p=ptPosList, n="{}_prxyCrv".format(name))
mc.parent(self.proxieCrv, prxyGrp)
mc.setAttr("{}.inheritsTransform".format(self.proxieCrv))
for i, prxy in enumerate(self.proxies):
clstr = mc.cluster("{}.cv[{}]".format(self.proxieCrv, i))[1]
mc.setAttr("{}.visibility".format(clstr), 0)
mc.parent(clstr, prxy)
def arc_tool(cv_count=30):
''' Arc Visualizer Tool
Args:
cv_count(int): the number of frames that the user would like to
visualize. The curve will show half way forward and backward on a
curve the arc of the movement
'''
global sel
sel = cmds.ls(selection=True)[0]
if not sel:
cmds.warning('Could not find selection!')
return
starting_time = cmds.currentTime(query=True)
backward_timeline = starting_time - (cv_count / 2)
forward_timeline = starting_time + (cv_count / 2)
position_list = []
for i in range(cv_count):
point = [i, 0, 0]
position_list.append(point)
points = tuple(position_list)
global path_curve, position_frame_values_list, time_slider_max
path_curve = cmds.curve(point=points, degree=1, name='arc_CRV')
cmds.setAttr(path_curve + '.dispCV', 1)
# get list of attributes that are keyed
# query the all values of the attribute at each frame
# append all values into a list
# assign these values based on cmds.currentTime() to cv's on a curve
position_frame_values_list = []
time_slider_min = cmds.playbackOptions(query=True, minTime=True)
time_slider_max = cmds.playbackOptions(query=True, maxTime=True)
time_slider_range = time_slider_max - time_slider_min + 1
frame_displacement = 1
i = 0
for frame in range(int(time_slider_range)):
cmds.currentTime(time_slider_min + i)
trans = cmds.xform(sel, query=True, translation=True, ws=True)
position_frame_values_list.append(trans)
frame_displacement = frame_displacement + 1
i = i + 1
frame_range = []
a = (cv_count / 2)
while backward_timeline <= forward_timeline:
list_frame = starting_time - a
frame_range.append(list_frame)
backward_timeline = backward_timeline + 1
a = a - 1
for cv in range(cv_count):
# in list frame_range, we have the frame number to assign to the cv
# then pulls from the position_frame_values_list to get the values for
# the object at that frame
list_index_value = int(frame_range[cv] + 1)
if list_index_value >= time_slider_max:
cv_position = position_frame_values_list[int(time_slider_max - 1)]
else:
cv_position = position_frame_values_list[list_index_value]
cmds.xform(path_curve + '.cv[' + str(cv) + ']',
translation=(cv_position[0], cv_position[1],
cv_position[2]),
worldSpace=True)
cmds.currentTime(starting_time)
# setup the refresh condition
global time_change, new_cv_count
new_cv_count = cv_count
time_change = cmds.scriptJob(
event=['timeChanged', 'cv_refresh(path_curve, new_cv_count)'])
curve_list.append(path_curve)
def createShape(prefix='', scale=1.0):
List = []
List.append(
cmds.curve(n=prefix,
p=[(0.5698271508338371, 4.091121663662989e-09,
-2.132883735050939e-05),
(0.4208952391731131, 0.1488873944517639,
-1.5755096100633637e-05),
(0.2720931419242101, 4.073556049855043e-05,
-1.0184545420344193e-05),
(0.4209398007112384, -0.1487613617926744,
-1.5755096101521815e-05),
(0.5698271508338371, 4.091121663662989e-09,
-2.132883735050939e-05),
(0.42091194939155674, 6.301549556786412e-05,
-0.1488401347819135),
(0.2720931419242101, 4.073556049855043e-05,
-1.0184545420344193e-05),
(0.42092309049279564, 6.301716352297149e-05,
0.14880862458971134),
(0.5698271508338371, 4.091121663662989e-09,
-2.132883735050939e-05),
(0.4208952391731131, 0.1488873944517639,
-1.5755096100633637e-05),
(0.2720931419242101, 4.073556049855043e-05,
-1.0184545420344193e-05),
(-0.2720931291529265, -0.0001260413294232876,
1.0184545417679658e-05),
(-0.4209971894939688, -6.30282570215357e-05,
0.14884013797247952),
(-0.5698271380625544, -8.530986004595675e-05,
2.1328837348733032e-05),
(-0.4210083305952077, -6.302992497664306e-05,
-0.1488086213991462),
(-0.2720931291529265, -0.0001260413294232876,
1.0184545417679658e-05),
(-0.42085456057731463, 0.14876116408473417,
1.5751905531047328e-05),
(-0.5698271380625544, -8.530986004595675e-05,
2.1328837348733032e-05),
(-0.4209804792755252, -0.14888740721321847,
1.575828666666723e-05),
(-0.2720931291529265, -0.0001260413294232876,
1.0184545417679658e-05),
(-0.2720931291529265, -0.0001260413294232876,
1.0184545417679658e-05),
(0.0, -1.3322676295501878e-15, 0.0),
(-1.1141101238898443e-05, -1.6679564396326896e-09,
0.2721144031802565),
(0.00014271626145045957, 0.14882419235483146,
0.42093877648166433),
(0.0, -1.3322676295501878e-15, 0.569763162551884),
(1.671021844362741e-05, -0.14882437895619827,
0.42093878286606934),
(-1.1141101238898443e-05, -1.6679564396326896e-09,
0.2721144031802565),
(-0.14882987953462568, -2.2281592690021057e-05,
0.4209443534141677),
(0.0, -1.3322676295501878e-15, 0.569763162551884),
(0.14890412937122033, -6.29878057401001e-05,
0.42093320912223664),
(-1.1141101238898443e-05, -1.6679564396326896e-09,
0.2721144031802565),
(-3.151178319171777e-05, -4.717688018018862e-09,
-0.2721144015837451),
(-5.935678879254169e-05, 0.14882437257149927,
-0.4209387812697942),
(-4.265288443061621e-05, -6.385641793116292e-09,
-0.5697631609553717),
(-1.4801564748090357e-05, -0.1488243836738845,
-0.42093878126955797),
(-3.151178319171777e-05, -4.717688018018862e-09,
-0.2721144015837451),
(-0.1488613913178174, -2.2286310378039076e-05,
-0.4209332107214614),
(-4.265288443061621e-05, -6.385641793116292e-09,
-0.5697631609553717),
(0.1488726175880286, -6.299252342767403e-05,
-0.42094435501339156),
(-3.151178319171777e-05, -4.717688018018862e-09,
-0.2721144015837451)],
per=False,
d=1,
k=[
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39
]))
for x in range(len(List) - 1):
cmds.makeIdentity(List[x + 1], apply=True, t=1, r=1, s=1, n=0)
shapeNode = cmds.ListRelatives(List[x + 1], shapes=True)
cmds.parent(shapeNode, List[0], add=True, s=True)
cmds.delete(List[x + 1])
sel = List[0]
cmds.setAttr(sel + '.s', scale, scale, scale)
cmds.makeIdentity(sel, apply=1, t=1, r=1, s=1, n=0)
return sel
def createShape(prefix='', scale=1.0):
List = []
List.append(
cmds.curve(
n=prefix + '_ctl',
p=[(-7.105427357601002e-15, -0.3358735290035888,
0.7361468691490706),
(-0.030221345939771993, -0.43042515285533867,
0.6908148502394227),
(-0.072472769789524, -0.5107046042608161, 0.6274377144647979),
(-0.12400997464880703, -0.5684975545498503, 0.5501319071758723),
(-0.12400997464880703, -0.5684975545498503, 0.5501319071758723),
(-0.12400997464880703, -0.5684975545498503, 0.5501319071758723),
(-0.12400997464880703, -0.5819931861859402, 0.5346306603447717),
(-0.12400997464880703, -0.5819931861859402, 0.5346306603447717),
(-0.12400997464880703, -0.5819931861859402, 0.5346306603447717),
(-0.12400997464880703, -0.5819931861859402, 0.5346306603447717),
(-0.08197748359885537, -0.540253001036092, 0.5946770761304137),
(-0.04551343522386375, -0.48527382262420815,
0.6467685738089758),
(-0.015501246831107096, -0.4192182992656619,
0.6896431286557706),
(-0.015501246831107096, -0.4192182992656619,
0.6896431286557706),
(-0.015501246831107096, -0.4192182992656619,
0.6896431286557706),
(-0.015501246831107096, -0.7077292503941806,
0.43808875481816606),
(-0.015501246831107096, -0.80800092168273,
-0.016811817720621902),
(-0.015501246831107096, -0.6943482219457593,
-0.34108941639861884),
(-0.015501246831107096, -0.5527220271320061,
-0.5148315398676033),
(-0.015501246831107096, -0.3348935247151239,
-0.6771644412642893),
(-0.015501246831107096, -0.1758560186022855,
-0.7361468691392242),
(-0.015501246831107096, -7.844604263429887e-05,
-0.7361468691392242)],
per=False,
d=3,
k=[
0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 19, 19
]))
List.append(
cmds.curve(p=[
(3.552713678800501e-15, -0.3358735290035959, 0.7361468691490706),
(0.03022134593976844, -0.43042515285534577, 0.6908148502394227),
(0.07247276978952044, -0.5107046042608232, 0.6274377144647979),
(0.12400997464880348, -0.5684975545498574, 0.5501319071758723),
(0.12400997464880348, -0.5684975545498574, 0.5501319071758723),
(0.12400997464880348, -0.5684975545498574, 0.5501319071758723),
(0.12400997464880348, -0.5819931861859473, 0.5346306603447717),
(0.12400997464880348, -0.5819931861859473, 0.5346306603447717),
(0.12400997464880348, -0.5819931861859473, 0.5346306603447717),
(0.12400997464880348, -0.5819931861859473, 0.5346306603447717),
(0.08197748359885182, -0.5402530010360991, 0.5946770761304137),
(0.0455134352238602, -0.48527382262421526, 0.6467685738089758),
(0.015501246831103543, -0.419218299265669, 0.6896431286557706),
(0.015501246831103543, -0.419218299265669, 0.6896431286557706),
(0.015501246831103543, -0.419218299265669, 0.6896431286557706),
(0.015501246831103543, -0.7077292503941877, 0.43808875481816606),
(0.015501246831103543, -0.8080009216827371, -0.016811817720621902),
(0.015501246831103543, -0.6943482219457664, -0.34108941639861884),
(0.015501246831103543, -0.5527220271320132, -0.5148315398676033),
(0.015501246831103543, -0.334893524715131, -0.6771644412642893),
(0.015501246831103543, -0.1758560186022926, -0.7361468691392242),
(0.015501246831103543, -7.844604263433487e-05, -0.7361468691392242)
],
per=False,
d=3,
k=[
0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 19, 19
]))
List.append(
cmds.curve(p=[
(0.0, 0.33587352900359235, 0.7361468691490706),
(-0.030221345939764888, 0.4304251528553422, 0.6908148502394227),
(-0.07247276978951689, 0.5107046042608197, 0.6274377144647979),
(-0.12400997464879993, 0.5684975545498538, 0.5501319071758723),
(-0.12400997464879993, 0.5684975545498538, 0.5501319071758723),
(-0.12400997464879993, 0.5684975545498538, 0.5501319071758723),
(-0.12400997464879993, 0.5819931861859438, 0.5346306603447717),
(-0.12400997464879993, 0.5819931861859438, 0.5346306603447717),
(-0.12400997464879993, 0.5819931861859438, 0.5346306603447717),
(-0.12400997464879993, 0.5819931861859438, 0.5346306603447717),
(-0.08197748359884827, 0.5402530010360955, 0.5946770761304137),
(-0.045513435223856646, 0.4852738226242117, 0.6467685738089758),
(-0.01550124683109999, 0.41921829926566545, 0.6896431286557706),
(-0.01550124683109999, 0.41921829926566545, 0.6896431286557706),
(-0.01550124683109999, 0.41921829926566545, 0.6896431286557706),
(-0.01550124683109999, 0.7077292503941841, 0.43808875481816606),
(-0.01550124683109999, 0.8080009216827335, -0.016811817720621902),
(-0.01550124683109999, 0.6943482219457628, -0.34108941639861884),
(-0.01550124683109999, 0.5527220271320097, -0.5148315398676033),
(-0.01550124683109999, 0.33489352471512746, -0.6771644412642893),
(-0.01550124683109999, 0.17585601860228905, -0.7361468691392242),
(-0.01550124683109999, 7.844604263078215e-05, -0.7361468691392242)
],
per=False,
d=3,
k=[
0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 19, 19
]))
List.append(
cmds.curve(p=[
(3.552713678800501e-15, 0.33587352900359235, 0.7361468691490706),
(0.03022134593976844, 0.4304251528553422, 0.6908148502394227),
(0.07247276978952044, 0.5107046042608197, 0.6274377144647979),
(0.12400997464880348, 0.5684975545498538, 0.5501319071758723),
(0.12400997464880348, 0.5684975545498538, 0.5501319071758723),
(0.12400997464880348, 0.5684975545498538, 0.5501319071758723),
(0.12400997464880348, 0.5819931861859438, 0.5346306603447717),
(0.12400997464880348, 0.5819931861859438, 0.5346306603447717),
(0.12400997464880348, 0.5819931861859438, 0.5346306603447717),
(0.12400997464880348, 0.5819931861859438, 0.5346306603447717),
(0.08197748359885182, 0.5402530010360955, 0.5946770761304137),
(0.0455134352238602, 0.4852738226242117, 0.6467685738089758),
(0.015501246831103543, 0.41921829926566545, 0.6896431286557706),
(0.015501246831103543, 0.41921829926566545, 0.6896431286557706),
(0.015501246831103543, 0.41921829926566545, 0.6896431286557706),
(0.015501246831103543, 0.7077292503941841, 0.43808875481816606),
(0.015501246831103543, 0.8080009216827335, -0.016811817720621902),
(0.015501246831103543, 0.6943482219457628, -0.34108941639861884),
(0.015501246831103543, 0.5527220271320097, -0.5148315398676033),
(0.015501246831103543, 0.33489352471512746, -0.6771644412642893),
(0.015501246831103543, 0.17585601860228905, -0.7361468691392242),
(0.015501246831103543, 7.844604263078215e-05, -0.7361468691392242)
],
per=False,
d=3,
k=[
0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 19, 19
]))
for x in range(len(List) - 1):
cmds.makeIdentity(List[x + 1], apply=True, t=1, r=1, s=1, n=0)
shapeNode = cmds.listRelatives(List[x + 1], shapes=True)
cmds.parent(shapeNode, List[0], add=True, s=True)
cmds.delete(List[x + 1])
sel = List[0]
cmds.setAttr(sel + '.s', scale, scale, scale)
cmds.makeIdentity(sel, apply=1, t=1, r=1, s=1, n=0)
return sel
def TD12Pyramid(self, name):
return cmds.curve(d=1,
n=name,
p=[(-1, 0, 0), (0, 0, 1), (0, 1, 0), (-1, 0, 0),
(1, 0, 0), (0, 1, 0), (1, 0, 0), (0, 0, 1),
(0, 1, 0)])
def createWrapControlShape(
targetObjects,
targetGeo=None,
latheAxis='z',
aimAxis='y+',
objectUp='y+',
points=8,
curveDegree=1,
insetMult=None, #Inset multiplier
minRotate=None,
maxRotate=None,
posOffset=[],
rootOffset=[], #offset root before cast
rootRotate=None,
joinMode=False,
extendMode=None,
closedCurve=True,
l_specifiedRotates=None,
maxDistance=1000,
closestInRange=True,
vectorOffset=None,
midMeshCast=False,
subSize=None, #For ball on loli for example
rotateBank=None,
joinHits=None, #keys to processed hits to see what to join
axisToCheck=['x', 'y'],
**kws): #'segment,radial,disc'
"""
This function lathes an axis of an object, shoot rays out the aim axis at the provided mesh and returning hits.
it then uses this information to build a curve shape.
:parameters:
mesh(string) | Surface to cast at
mi_obj(string/mObj) | our casting object
latheAxis(str) | axis of the objec to lathe TODO: add validation
aimAxis(str) | axis to shoot out of
points(int) | how many points you want in the curve
curveDegree(int) | specified degree
minRotate(float) | let's you specify a valid range to shoot
maxRotate(float) | let's you specify a valid range to shoot
posOffset(vector) | transformational offset for the hit from a normalized locator at the hit. Oriented to the surface
markHits(bool) | whether to keep the hit markers
returnDict(bool) | whether you want all the infomation from the process.
rotateBank (float) | let's you add a bank to the rotation object
l_specifiedRotates(list of values) | specify where to shoot relative to an object. Ignores some other settings
maxDistance(float) | max distance to cast rays
closestInRange(bool) | True by default. If True, takes first hit. Else take the furthest away hit in range.
:returns:
Dict ------------------------------------------------------------------
'source'(double3) | point from which we cast
'hit'(double3) | world space points | active during single return
'hits'(list) | world space points | active during multi return
'uv'(double2) | uv on surface of hit | only works for mesh surfaces
:raises:
Exception | if reached
"""
_str_func = "createWrapControlShape"
log.debug(">> %s >> " % (_str_func) + "=" * 75)
_joinModes = []
_extendMode = []
if type(targetObjects) not in [list, tuple]:
targetObjects = [targetObjects]
targetGeo = VALID.objStringList(targetGeo, calledFrom=_str_func)
assert type(points) is int, "Points must be int: %s" % points
assert type(curveDegree) is int, "Points must be int: %s" % points
assert curveDegree > 0, "Curve degree must be greater than 1: %s" % curveDegree
if posOffset is not None and len(posOffset) and len(posOffset) != 3:
raise StandardError, "posOffset must be len(3): %s | len: %s" % (
posOffset, len(posOffset))
if rootOffset is not None and len(rootOffset) and len(rootOffset) != 3:
raise StandardError, "rootOffset must be len(3): %s | len: %s" % (
rootOffset, len(rootOffset))
if rootRotate is not None and len(rootRotate) and len(rootRotate) != 3:
raise StandardError, "rootRotate must be len(3): %s | len: %s" % (
rootRotate, len(rootRotate))
if extendMode in ['loliwrap', 'cylinder', 'disc'] and insetMult is None:
insetMult = 1
for axis in ['x', 'y', 'z']:
if axis in latheAxis.lower(): latheAxis = axis
log.debug("targetObjects: %s" % targetObjects)
if len(aimAxis) == 2: single_aimAxis = aimAxis[0]
else: single_aimAxis = aimAxis
mAxis_aim = VALID.simpleAxis(aimAxis)
log.debug("Single aim: %s" % single_aimAxis)
log.debug("createWrapControlShape>> midMeshCast: %s" % midMeshCast)
log.debug("|{0}| >> extendMode: {1}".format(_str_func, extendMode))
#>> Info
l_groupsBuffer = []
il_curvesToCombine = []
l_sliceReturns = []
#Need to do more to get a better size
#>> Build curves
#=================================================================
#> Root curve #
log.debug("RootRotate: %s" % rootRotate)
mi_rootLoc = cgmMeta.cgmNode(targetObjects[0]).doLoc()
if rootOffset:
log.debug("rootOffset: %s" % rootOffset)
mc.move(rootOffset[0],
rootOffset[1],
rootOffset[2], [mi_rootLoc.mNode],
r=True,
rpr=True,
os=True,
wd=True)
if rootRotate is not None and len(rootRotate):
log.debug("rootRotate: %s" % rootRotate)
mc.rotate(rootRotate[0],
rootRotate[1],
rootRotate[2], [mi_rootLoc.mNode],
os=True,
r=True)
#>> Root
mi_rootLoc.doGroup() #Group to zero
if extendMode == 'segment':
log.debug("segment mode. Target len: %s" % len(targetObjects[1:]))
if len(targetObjects) < 2:
log.warning(
"Segment build mode only works with two objects or more")
else:
if insetMult is not None:
rootDistanceToMove = distance.returnDistanceBetweenObjects(
targetObjects[0], targetObjects[1])
log.debug("rootDistanceToMove: %s" % rootDistanceToMove)
mi_rootLoc.__setattr__('t%s' % latheAxis,
rootDistanceToMove * insetMult)
#mi_rootLoc.tz = (rootDistanceToMove*insetMult)#Offset it
#Notes -- may need to play with up object for aim snapping
#mi_upLoc = cgmMeta.cgmNode(targetObjects[0]).doLoc()
#mi_upLoc.doGroup()#To zero
objectUpVector = dictionary.returnStringToVectors(objectUp)
log.debug("objectUpVector: %s" % objectUpVector)
#mi_uploc
for i, obj in enumerate(targetObjects[1:]):
log.debug("i: %s" % i)
#> End Curve
mi_endLoc = cgmMeta.cgmNode(obj).doLoc()
aimVector = dictionary.returnStringToVectors(latheAxis + '-')
log.debug("segment aimback: %s" % aimVector)
#Snap.go(mi_endLoc.mNode,mi_rootLoc.mNode,move=False,aim=True,aimVector=aimVector,upVector=objectUpVector)
#Snap.go(mi_endLoc.mNode,mi_rootLoc.mNode,move=False,orient=True)
SNAP.go(mi_endLoc.mNode,
mi_rootLoc.mNode,
position=False,
rotation=True)
mi_endLoc.doGroup()
if i == len(targetObjects[1:]) - 1:
if insetMult is not None:
log.debug("segment insetMult: %s" % insetMult)
distanceToMove = distance.returnDistanceBetweenObjects(
targetObjects[-1], targetObjects[0])
log.debug("distanceToMove: %s" % distanceToMove)
#mi_endLoc.tz = -(distanceToMove*insetMult)#Offset it
mi_endLoc.__setattr__('t%s' % latheAxis,
-(distanceToMove * insetMult))
log.debug("segment lathe: %s" % latheAxis)
log.debug("segment aim: %s" % aimAxis)
log.debug("segment rotateBank: %s" % rotateBank)
d_endCastInfo = createMeshSliceCurve(
targetGeo,
mi_endLoc,
midMeshCast=midMeshCast,
curveDegree=curveDegree,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=posOffset,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
l_sliceReturns.append(d_endCastInfo)
mi_end = cgmMeta.cgmObject(d_endCastInfo['curve'])
il_curvesToCombine.append(mi_end)
mc.delete(mi_endLoc.parent) #delete the loc
elif extendMode == 'radial':
log.debug("|{0}| >> radial...".format(_str_func))
d_handleInner = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
midMeshCast=midMeshCast,
curveDegree=curveDegree,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=0,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
mi_buffer = cgmMeta.cgmObject(d_handleInner['curve']) #instance curve
l_sliceReturns.append(d_handleInner)
il_curvesToCombine.append(mi_buffer)
elif extendMode == 'disc':
log.debug("|{0}| >> disc...".format(_str_func))
d_size = returnBaseControlSize(mi_rootLoc, targetGeo,
axis=[aimAxis]) #Get size
#discOffset = d_size[ d_size.keys()[0]]*insetMult
size = False
l_absSize = [abs(i) for i in posOffset]
if l_absSize: size = max(l_absSize)
if not size:
d_size = returnBaseControlSize(mi_rootLoc,
targetGeo,
axis=[aimAxis]) #Get size
log.debug("d_size: %s" % d_size)
size = d_size[d_size.keys()[0]] * insetMult
discOffset = size
log.debug("d_size: %s" % d_size)
log.debug("discOffset is: %s" % discOffset)
mi_rootLoc.__setattr__('t%s' % latheAxis, discOffset)
if posOffset:
tmp_posOffset = [
posOffset[0] * .5, posOffset[1] * .5, posOffset[2] * .5
]
d_handleInnerUp = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
curveDegree=curveDegree,
midMeshCast=midMeshCast,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=tmp_posOffset,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
mi_buffer = cgmMeta.cgmObject(
d_handleInnerUp['curve']) #instance curve
l_sliceReturns.append(d_handleInnerUp)
il_curvesToCombine.append(mi_buffer)
mi_rootLoc.__setattr__('t%s' % latheAxis, -discOffset)
d_handleInnerDown = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
curveDegree=curveDegree,
midMeshCast=midMeshCast,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=tmp_posOffset,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
mi_buffer = cgmMeta.cgmObject(
d_handleInnerDown['curve']) #instance curve
l_sliceReturns.append(d_handleInnerDown)
il_curvesToCombine.append(mi_buffer)
mi_rootLoc.tz = 0
elif extendMode == 'cylinder':
log.debug("|{0}| >> cylinder...".format(_str_func))
d_size = returnBaseControlSize(mi_rootLoc, targetGeo,
axis=[aimAxis]) #Get size
discOffset = d_size[d_size.keys()[0]] * insetMult
log.debug("d_size: %s" % d_size)
log.debug("discOffset is: %s" % discOffset)
mi_rootLoc.__setattr__('t%s' % latheAxis, discOffset)
d_handleInnerUp = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
curveDegree=curveDegree,
midMeshCast=midMeshCast,
latheAxis=latheAxis,
aimAxis=aimAxis,
posOffset=posOffset,
points=points,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
mi_buffer = cgmMeta.cgmObject(
d_handleInnerUp['curve']) #instance curve
l_sliceReturns.append(d_handleInnerUp)
il_curvesToCombine.append(mi_buffer)
mi_rootLoc.__setattr__('t%s' % latheAxis, 0)
elif extendMode == 'loliwrap':
log.debug("|{0}| >> lolipop...".format(_str_func))
#l_absSize = [abs(i) for i in posOffset]
size = False
#if l_absSize:
#log.debug("l_absSize: %s"%l_absSize)
#size = max(l_absSize)*1.25
if subSize is not None:
size = subSize
if not size:
d_size = returnBaseControlSize(mi_rootLoc,
targetGeo,
axis=[aimAxis]) #Get size
log.info("d_size: %s" % d_size)
l_size = d_size[single_aimAxis]
size = l_size / 3
log.info("loli size: %s" % size)
i_ball = cgmMeta.cgmObject(
curves.createControlCurve('sphere', size=size))
elif extendMode == 'endCap':
log.debug("|{0}| >> endCap...".format(_str_func))
returnBuffer1 = createMeshSliceCurve(
targetGeo,
mi_rootLoc.mNode,
aimAxis='{0}+'.format(latheAxis),
latheAxis=objectUp[0],
curveDegree=curveDegree,
maxDistance=maxDistance,
closestInRange=closestInRange,
closedCurve=False,
l_specifiedRotates=[-90, -60, -30, 0, 30, 60, 90],
posOffset=posOffset)
mi_rootLoc.rotate = [0, 0, 0]
mi_rootLoc.__setattr__('r%s' % latheAxis, 90)
returnBuffer2 = createMeshSliceCurve(
targetGeo,
mi_rootLoc.mNode,
aimAxis='{0}+'.format(latheAxis),
latheAxis=objectUp[0],
curveDegree=curveDegree,
maxDistance=maxDistance,
closedCurve=False,
closestInRange=closestInRange,
l_specifiedRotates=[-90, -60, -30, 0, 30, 60, 90],
posOffset=posOffset)
l_sliceReturns.extend([returnBuffer1, returnBuffer2])
il_curvesToCombine.append(cgmMeta.cgmObject(returnBuffer1))
il_curvesToCombine.append(cgmMeta.cgmObject(returnBuffer2))
mi_rootLoc.rotate = [0, 0, 0]
#Now cast our root since we needed to move it with segment mode before casting
if extendMode == 'cylinder':
log.debug("|{0}| >> cylinder move...".format(_str_func))
mi_rootLoc.__setattr__('t%s' % latheAxis, -discOffset)
log.debug("|{0}| >> Rootcast...".format(_str_func))
d_rootCastInfo = createMeshSliceCurve(
targetGeo,
mi_rootLoc,
curveDegree=curveDegree,
minRotate=minRotate,
maxRotate=maxRotate,
latheAxis=latheAxis,
midMeshCast=midMeshCast,
aimAxis=aimAxis,
posOffset=posOffset,
points=points,
vectorOffset=vectorOffset,
returnDict=True,
closedCurve=closedCurve,
maxDistance=maxDistance,
closestInRange=closestInRange,
rotateBank=rotateBank,
l_specifiedRotates=l_specifiedRotates,
axisToCheck=axisToCheck)
#d_rootCastInfo = createMeshSliceCurve(targetGeo,mi_rootLoc,**kws)
log.debug("|{0}| >> Rootcast done".format(_str_func) + cgmGEN._str_subLine)
if extendMode == 'disc':
l_sliceReturns.insert(1, d_rootCastInfo)
else:
l_sliceReturns.insert(0, d_rootCastInfo)
#Special loli stuff
if extendMode == 'loliwrap':
SNAP.go(i_ball.mNode, mi_rootLoc.mNode, True,
True) #Snap to main object
#log.debug("hitReturns: %s"%d_rootCastInfo['hitReturns'])
#cgmGEN.walk_dat(d_rootCastInfo['hitReturns'],'hitReturns')
mi_crv = cgmMeta.cgmObject(d_rootCastInfo['curve'])
"""
d_return = RayCast.findMeshIntersectionFromObjectAxis(targetGeo,mi_rootLoc.mNode,mAxis_aim.p_string) or {}
if not d_return.get('hit'):
log.info(d_return)
raise ValueError,"No hit on loli check"
pos = d_return.get('hit')
dist = distance.returnDistanceBetweenPoints(i_ball.getPosition(),pos) * 2"""
if vectorOffset is not None:
dist = vectorOffset + subSize * 4
else:
dist = max(posOffset) + subSize * 4
if '-' in aimAxis:
distM = -dist
else:
distM = dist
log.debug("distM: %s" % distM)
#Move the ball
pBuffer = i_ball.doGroup()
i_ball.__setattr__('t%s' % single_aimAxis, distM)
i_ball.parent = False
mc.delete(pBuffer)
uPos = distance.returnClosestUPosition(i_ball.mNode, mi_crv.mNode)
SNAP.aim(i_ball.mNode, mi_rootLoc.mNode, aimAxis='z-')
#if posOffset:
#mc.move(posOffset[0]*3,posOffset[1]*3,posOffset[2]*3, [i_ball.mNode], r = True, rpr = True, os = True, wd = True)
#Make the curve between the two
mi_traceCrv = cgmMeta.cgmObject(
mc.curve(degree=1, ep=[uPos, i_ball.getPosition()]))
#Combine
il_curvesToCombine.extend([i_ball, mi_traceCrv])
mi_root = cgmMeta.cgmObject(d_rootCastInfo['curve']) #instance curve
il_curvesToCombine.append(mi_root)
mc.delete(mi_rootLoc.parent) #delete the loc
l_curvesToCombine = [mi_obj.mNode for mi_obj in il_curvesToCombine
] #Build our combine list before adding connectors
log.debug("|{0}| >> processed: {1}".format(
_str_func, d_rootCastInfo['processedHits']))
if joinMode and extendMode not in ['loliwrap', 'endCap'
] and len(l_sliceReturns) > 1:
if joinHits:
keys = d_rootCastInfo['processedHits'].keys()
keys.sort()
#goodDegrees = []
#for i,key in enumerate(keys):
#if i in joinHits:
#goodDegrees.append(key)
goodDegrees = [key for i, key in enumerate(keys) if i in joinHits]
log.debug("joinHits: %s" % joinHits)
log.debug("goodDegrees: %s" % goodDegrees)
else:
goodDegrees = [
key for key in d_rootCastInfo['processedHits'].keys()
]
#> Side Curves
for degree in goodDegrees:
l_pos = []
for d in l_sliceReturns:
l_pos.append(d['processedHits'].get(degree) or False)
while False in l_pos:
l_pos.remove(False)
log.debug("l_pos: %s" % l_pos)
if len(l_pos) >= 2:
try:
l_curvesToCombine.append(
mc.curve(d=curveDegree, ep=l_pos,
os=True)) #Make the curve
except:
log.debug(
"createWrapControlShape>>> skipping curve fail: %s" %
(degree))
#>>Combine the curves
newCurve = curves.combineCurves(l_curvesToCombine)
mi_crv = cgmMeta.cgmObject(rigging.groupMeObject(targetObjects[0], False))
curves.parentShapeInPlace(mi_crv.mNode, newCurve) #Parent shape
mc.delete(newCurve)
#>>Copy tags and name
mi_crv.doCopyNameTagsFromObject(targetObjects[0],
ignore=['cgmType', 'cgmTypeModifier'])
mi_crv.addAttr('cgmType',
attrType='string',
value='controlCurve',
lock=True)
mi_crv.doName()
#Store for return
return {'curve': mi_crv.mNode, 'instance': mi_crv}
def TDDirSingleThin(self, name):
return cmds.curve(d=1,
n=name,
p=[(0, 0, 1), (0, 0, -1), (-1, 0, 0), (0, 0, -1),
(1, 0, 0)])
def TDAngle(self, name):
return cmds.curve(d=1,
n=name,
p=[(-1, 0, -3), (1, 0, -3), (1, 0, 1), (-3, 0, 1),
(-3, 0, -1), (-1, 0, -1), (-1, 0, -3)])
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 TD12Spear(self, name):
return cmds.curve(d=1,
n=name,
p=[(0, 2, 0), (0, 0, 2), (0, 0, -2), (0, 2, 0),
(-2, 0, 0), (2, 0, 0), (0, 2, 0)])
def TDdial1(self, name):
self.temp1 = cmds.curve(d=1,
n=name,
p=[[0.364972, 0, -2.473302],
[-0.323287, 0, -2.473302],
[-0.477698, 0, -1.961019],
[-0.671003, 0, -1.912512],
[-0.853523, 0, -1.83603],
[-1.020817, 0, -1.736603],
[-1.486974, 0, -1.9923],
[-1.977452, 0, -1.50523],
[-1.726133, 0, -1.036491],
[-1.826798, 0, -0.869888],
[-1.904727, 0, -0.687918],
[-1.95492, 0, -0.494751],
[-2.467584, 0, -0.344098],
[-2.473302, 0, 0.344405],
[-1.963327, 0, 0.495231],
[-1.91592, 0, 0.68819],
[-1.841198, 0, 0.870093],
[-1.743355, 0, 1.036558],
[-2.002876, 0, 1.505576],
[-1.520597, 0, 1.992572],
[-1.050066, 0, 1.736639],
[-0.884391, 0, 1.836305],
[-0.703282, 0, 1.912784],
[-0.510771, 0, 1.961534],
[-0.364527, 0, 2.473302],
[0.323323, 0, 2.473302],
[0.477765, 0, 1.961534],
[0.671274, 0, 1.912784],
[0.853488, 0, 1.836305],
[1.020711, 0, 1.736639],
[1.487041, 0, 1.992572],
[1.977416, 0, 1.505576],
[1.725717, 0, 1.036766],
[1.8269, 0, 0.870093],
[1.904794, 0, 0.68819],
[1.954712, 0, 0.495231],
[2.467481, 0, 0.344405],
[2.473302, 0, -0.344098],
[1.963016, 0, -0.494751],
[1.916231, 0, -0.687918],
[1.841368, 0, -0.869888],
[1.743528, 0, -1.036491],
[2.002841, 0, -1.50523],
[1.520594, 0, -1.9923],
[1.050133, 0, -1.736603],
[0.88456, 0, -1.83603],
[0.703419, 0, -1.912512],
[0.510905, 0, -1.961019],
[0.364972, 0, -2.473302]],
k=[
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
46, 47, 48
])
self.temp2 = cmds.curve(
d=1,
n=name,
p=[[0, 0, -1.593544], [-0.609823, 0, -1.472242],
[-1.126805, 0, -1.126805], [-1.472242, 0, -0.609823],
[-1.593544, 0, 0], [-1.472242, 0, 0.609823],
[-1.126805, 0, 1.126805], [-0.609823, 0, 1.472242],
[0, 0, 1.593544], [0.609823, 0, 1.472242],
[1.126805, 0, 1.126805], [1.472242,
0, 0.609823], [1.593544, 0, 0],
[1.472242, 0, -0.609823], [1.126805, 0,
-1.126805], [0.609823, 0, -1.472242],
[0, 0, -1.593544]],
k=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])
self.tempShape = cmds.listRelatives(self.temp2, s=True)
cmds.parent(self.tempShape, self.temp1, r=True, s=True)
cmds.delete(self.temp2)
cmds.select(self.temp1)
return self.temp1
particleDictionary[currentFrame] = particlesPosition
allParticleDictionary[str(particleName[0])] = particleDictionary
for curveParticleId in allParticleDictionary.keys():
#print sorted(allParticleDictionary[curveParticleId].keys())
#print curveParticleId
pointList = []
sortedKeyFrameList = sorted(allParticleDictionary[curveParticleId].keys())
if len(sortedKeyFrameList) > 1:
for keyFrame in sortedKeyFrameList:
pointList.append(allParticleDictionary[curveParticleId][keyFrame])
curveName = "partiCurve" + str(curveParticleId)
curveObj = mc.curve(name=curveName, p=pointList)
#For every locator we create, make a bubble and attach that to the locator in worldspace and parent in underneath
getCurvLen = mc.arclen(curveObj)
makeCvrLenInt = math.ceil(
getCurvLen * .5
) #reduces the amount of spans the curve has, this is useful on very long extrusions
makeCircle = mc.circle(n="newCircle", d=1, s=12)
aCircle = mc.planarSrf(makeCircle[0],
n="extruTube",
ch=1,
d=1,
ko=0,
rn=0,
po=1,
def TDDirDoubleThin(self, name):
return cmds.curve(d=1,
n=name,
p=[(1, 0, 1), (0, 0, 2), (-1, 0, 1), (0, 0, 2),
(0, 0, -2), (-1, 0, -1), (0, 0, -2), (1, 0, -1)])
def onDrag(self): # modifier self.mod = cmds.getModifiers() # positions currentPos = cmds.draggerContext(self.dragCtx, query=True, dragPoint=True) # camera far clip currentView = omui.M3dView().active3dView() camDP = om.MDagPath() currentView.getCamera(camDP) camFn = om.MFnCamera(camDP) farclip = camFn.farClippingPlane() # screen to world conversion worldPos, worldDir = utils().viewToWorld(currentPos[0],currentPos[1]) closestHit = None closestObj = None for obj in self.targetObj: state, hit, fnMesh, facePtr, triPtr = utils().intersect(obj, worldPos, worldDir, farclip) if state is True: dif = [hit.x - worldPos[0],hit.y - worldPos[1],hit.z - worldPos[2]] distToCam = math.sqrt(math.pow(float(dif[0]),2) + math.pow(float(dif[1]),2) + math.pow(float(dif[2]),2)) if closestHit == None: closestHit = distToCam closestObj = [state, hit, fnMesh, facePtr, triPtr] elif distToCam < closestHit: closestHit = distToCam closestObj = [state, hit, fnMesh, facePtr, triPtr] if closestObj is not None: state, hit, fnMesh, facePtr, triPtr = closestObj mHit = om.MPoint(hit) # get smooth normal normal = om.MVector() fnMesh.getClosestNormal(mHit, normal, om.MSpace.kWorld, None) tangent = utils().crossProduct(normal,self.worldUp) upAxis = utils().crossProduct(normal,tangent) # define transformation matrix matrix = [tangent.x,tangent.y,tangent.z,0,upAxis.x,upAxis.y,upAxis.z,0,normal.x,normal.y,normal.z,0,hit.x,hit.y,hit.z,0] # apply matrix dist = om.MVector( (hit.x - self.prevHit.x),(hit.y - self.prevHit.y),(hit.z - self.prevHit.z) ) if utils().magnitude(dist) > self.step: if self.mod == 0: cmds.curve(self.loc,append=True,p=(hit.x,hit.y,hit.z)) else: hit = self.prevHit if self.mesh is True: v1 = cmds.pointPosition(self.loc + '.cv[0]',w=True) v2 = cmds.pointPosition(self.loc + '.cv[1]',w=True) v = om.MVector(v2[0] - v1[0],v2[1] - v1[1],v2[2] - v1[2]) v.normalize() cmds.setAttr(self.circle[1] + '.normalX',v.x) cmds.setAttr(self.circle[1] + '.normalY',v.y) cmds.setAttr(self.circle[1] + '.normalZ',v.z) if self.mod == 1: mag = utils().magnitude(dist) * self.bMult if dist.y < 0: mag = -mag currentValue = cmds.getAttr(self.circle[1] + '.radius') compVal = sorted((0.0001,currentValue + mag))[1] self.bRad = compVal cmds.setAttr(self.circle[1] + '.radius',compVal) if self.mod == 4: mag = utils().magnitude(dist) * self.bMult if dist.y < 0: mag = -mag currentValue = cmds.getAttr(self.extrude[1] + '.scale') compVal = sorted((0.0001,currentValue + mag))[1] self.taper = compVal cmds.setAttr(self.extrude[1] + '.scale',compVal) self.prevHit = hit # print cmds.timerX(st=self.timer) # refresh viewport currentView.refresh(False,True,False)
def onPress(self): """ execute on press """ # modifier self.mod = cmds.getModifiers() # button self.btn = cmds.draggerContext(self.dragCtx, query=True, button=True) # timer self.timer = cmds.timerX() initPos = cmds.draggerContext(self.dragCtx, query=True, anchorPoint=True) # camera far clip currentView = omui.M3dView().active3dView() camDP = om.MDagPath() currentView.getCamera(camDP) camFn = om.MFnCamera(camDP) farclip = camFn.farClippingPlane() # screen to world conversion worldPos, worldDir = utils().viewToWorld(initPos[0],initPos[1]) if self.btn is not 2: closestHit = None closestObj = None for obj in self.targetObj: if cmds.objExists(obj): state, hit, fnMesh, facePtr, triPtr = utils().intersect(obj, worldPos, worldDir, farclip) if state is True: dif = [hit.x - worldPos[0],hit.y - worldPos[1],hit.z - worldPos[2]] distToCam = math.sqrt(math.pow(float(dif[0]),2) + math.pow(float(dif[1]),2) + math.pow(float(dif[2]),2)) if closestHit == None: closestHit = distToCam closestObj = [state, hit, fnMesh, facePtr, triPtr] elif distToCam < closestHit: closestHit = distToCam closestObj = [state, hit, fnMesh, facePtr, triPtr] else: self.targetObj.remove(obj) if closestObj is not None: state, hit, fnMesh, facePtr, triPtr = closestObj mHit = om.MPoint(hit) # get smooth normal normal = om.MVector() fnMesh.getClosestNormal(mHit, normal, om.MSpace.kWorld, None) # get smooth normal normal = om.MVector() fnMesh.getClosestNormal(mHit, normal, om.MSpace.kWorld, None) tangent = utils().crossProduct(normal,self.worldUp) upAxis = utils().crossProduct(normal,tangent) # define transformation matrix matrix = [tangent.x,tangent.y,tangent.z,0,upAxis.x,upAxis.y,upAxis.z,0,normal.x,normal.y,normal.z,0,hit.x,hit.y,hit.z,0] # create object if self.mod == 0: self.loc = cmds.curve(p = (hit.x,hit.y,hit.z)) # cmds.toggle(self.loc, localAxis=True) # store values self.prevHit = hit print self.prevHit self.screenPoint = initPos self.angle = 0 # draw Mesh if self.mesh is True and self.mod == 0: self.circle = cmds.circle(center = (hit.x,hit.y,hit.z),radius = self.bRad,d=3) self.extrude = cmds.extrude(self.circle[0],self.loc,po=1, ch=True,rn=False,et=2,ucp=0,fpt=0,upn=0,rotation=0,scale=1,rsp=1) self.nbTes = cmds.listConnections(self.extrude[1] + '.outputSurface')[0] cmds.setAttr(self.nbTes + '.polygonType',1) cmds.setAttr(self.nbTes + '.format',2) cmds.setAttr(self.nbTes + '.polygonCount',200) cmds.setAttr(self.nbTes + '.uType',3) cmds.setAttr(self.nbTes + '.uNumber',1) cmds.setAttr(self.nbTes + '.vType',3) cmds.setAttr(self.nbTes + '.vNumber',1) cmds.setAttr(self.extrude[1] + '.scale',self.taper) if self.autoAdd is True and self.extrude[0] not in self.targetObj: self.targetObj.append(self.extrude[0]) # refresh viewport cmds.refresh(cv=True)
