def create(self, n=""):
if n == "":
n = self.child + "_parentSpace"
currentParent = iterable(mc.listRelatives(self.child, p=True))
if len(currentParent) > 0:
currentParent = currentParent[0]
else:
currentParent = ""
ps = mc.createNode("transform", n=n, p=self.child)
self.append(ps)
if mc.objExists(currentParent):
mc.parent(ps, currentParent)
else:
currentParent = "world"
mc.parent(ps, w=True)
if not mc.objExists(self.child + ".zenParentSpace"):
mc.addAttr(self.child, at="message", ln="zenParentSpace")
if not mc.objExists(self.child + ".zenPrevParentNum"):
mc.addAttr(self.child, at="long", ln="zenPrevParentNum", k=0, dv=0)
mc.connectAttr(ps + ".message", self.child + ".zenParentSpace")
if self.world == "":
worldTr = mc.createNode("transform", n="world")
else:
worldTr = self.world
self.addParents([worldTr], en=["world"])
mc.parent(self.child, ps)
if self.world == "":
md = mc.createNode("multiplyDivide")
mc.setAttr(md + ".i1", *mc.getAttr(self.parentConstraint + ".tg[0].tt")[0])
mc.connectAttr(md + ".o", self.parentConstraint + ".tg[0].tt", f=True)
worldMatrix = mc.createNode("fourByFourMatrix")
wm = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
for a in range(0, 4):
for b in range(0, 4):
mc.setAttr(worldMatrix + ".in" + str(a) + str(b), wm[a][b])
mc.connectAttr(worldMatrix + ".o", self.parentConstraint + ".tg[0].tpm", f=True)
disconnectNodes(worldTr)
mc.delete(worldTr)
def __init__(self,*args,**keywords):
# default options
self.name='limb'
self.stretch=20
self.squash=0
self.twist=True # performs auto detect
self.sway=True
self.switch='ik' # initial ik/fk switch state
self.handleOptions=[{'type':'doubleEllipse','spin':-180},{'type':'doubleEllipse','spin':-90},{'type':'doubleEllipse'},{'type':'locator'}]
self.tol=1.0 # angle tolerance for preferred angles
self.parent=''
self.shortNames=\
{
'n':'name',
'p':'parent',
'sp':'softParent',
'co':'controlObjects',
'ho':'handleOptions'
}
# attributes
self.controlObjects=['','','','']
self.bindPoses=[]
self.joints=[]
self.group=''
self.orientAxis=''
self.bendAxis=''
self.poleAxis=''
self.ctrlJoints=[]
self.handles=[]
self.endEffector=''
self.ikHandle=''
self.jointParent=''
self.jointParent=''
self.originalRotations={}
self.bendDirection=0
self.poleVector=[]
self.poleVectorWorld=[]
self.upVector=[]
self.aimVector=[]
self.parentSpaces=[]
for k in keywords:
if k in self.__dict__:
exec('self.'+k+'=keywords[k]')
elif k in self.shortNames:
exec('self.'+self.shortNames[k]+'=keywords[k]')
uniqueNames(re=True)
if len(args)==0:
args=mc.ls(sl=True)
sel=[]
for a in args:
sel.extend(iterable(a))
sel=hierarchyOrder(sel)
# parse options
defualtHandleOptions=[{'type':'doubleEllipse','spin':-180},{'type':'doubleEllipse','spin':-90},{'type':'doubleEllipse'},{'type':'locator'}]
i=len(self.handleOptions)
while len(self.handleOptions)<4:
self.handleOption.append(defualtHandleOptions[i])
i+=1
if isinstance(self.handleOptions,dict):
self.handleOptions=[self.handleOptions,self.handleOptions,self.handleOptions]
elif isIterable(self.handleOptions):
if len(self.handleOptions)==0:
self.handleOptions.append({})
while len(self.handleOptions)<3:
self.handleOptions.append(self.handleOptions[-1])
else:
self.handleOptions=[{},{},{}]
self.controlObjects=iterable(self.controlObjects)
self.orientAxis=self.orientAxis.lower()
self.baseTwist=''
self.hierarchy=[]
if len(sel)>2:
for j in sel[:-1]:
if len(hierarchyBetween(j,sel[-1]))>len(self.hierarchy):
self.hierarchy=hierarchyBetween(j,sel[-1])
closest=9e999
for s in removeAll([self.hierarchy[0],self.hierarchy[-1]],sel):
if\
(
len(iterable(mc.listRelatives(self.hierarchy[0],p=True)))==0 or
s in mc.listRelatives(mc.listRelatives(self.hierarchy[0],p=True)[0],c=True,type='joint')
):
dist=distanceBetween(s,self.hierarchy[0])
if dist<closest:
closest=dist
self.baseTwist=s
else:
self.hierarchy=hierarchyBetween(sel[0],sel[-1])
self.bindPoses=iterable(getBindPoses(self.hierarchy))
self.joints=['','','']
if len(self.hierarchy)<3:
raise Exception('There are no joints between your start and end joint. No IK created.')
self.joints[0]=self.hierarchy[0]
self.joints[-1]=self.hierarchy[-1]
# find the orientation axis
self.orientAxis='x'
axisLen={'x':0,'y':0,'z':0}
for j in self.hierarchy[1:]:
for a in ['x','y','z']:
axisLen[a]+=abs(mc.getAttr(j+'.t'+a))
if axisLen[a]>axisLen[self.orientAxis]:
self.orientAxis=a
# find bend joint and pole vector
self.originalRotations={}
for j in self.hierarchy[1:-1]: # check to see if any have a non-zero preferred angle
for a in removeAll(self.orientAxis,['x','y','z']):
if abs(mc.getAttr(j+'.pa'+a))>=self.tol:
self.originalRotations[j+'.r'+a]=mc.getAttr(j+'.r'+a)
mc.setAttr(j+'.r'+a,mc.getAttr(j+'.pa'+a))
greatestAngle=0
for j in self.hierarchy[1:-1]:
jPos=mc.xform(j,q=True,ws=True,rp=True)
prevJPos=mc.xform(self.hierarchy[self.hierarchy.index(j)-1],q=True,ws=True,rp=True)
nextJPos=mc.xform(self.hierarchy[self.hierarchy.index(j)+1],q=True,ws=True,rp=True)
vAngle=mc.angleBetween(v1=normalize(jPos[0]-prevJPos[0],jPos[1]-prevJPos[1],jPos[2]-prevJPos[2]),v2=normalize(nextJPos[0]-jPos[0],nextJPos[1]-jPos[1],jPos[2]-jPos[2]))[-1]
if abs(vAngle)>greatestAngle:
greatestAngle=abs(vAngle)
self.joints[1]=j
mp=midPoint\
(
self.hierarchy[0],self.hierarchy[-1],
bias=\
(
distanceBetween(self.hierarchy[0],self.joints[1])/
(distanceBetween(self.hierarchy[0],self.joints[1])+distanceBetween(self.joints[1],self.hierarchy[-1]))
)
)
bendPoint=mc.xform(self.joints[1],q=True,ws=True,rp=True)
self.poleVectorWorld=normalize\
(
bendPoint[0]-mp[0],
bendPoint[1]-mp[1],
bendPoint[2]-mp[2]
)
pmm=mc.createNode('pointMatrixMult')
mc.setAttr(pmm+'.vm',True)
mc.connectAttr(self.joints[1]+'.worldInverseMatrix',pmm+'.im')
mc.setAttr(pmm+'.ip',*self.poleVectorWorld)
self.poleVector=mc.getAttr(pmm+'.o')[0]
disconnectNodes(pmm)
mc.delete(pmm)
greatestLength=0.0
for i in [0,1,2]:
if abs(self.poleVector[i])>greatestLength and ['x','y','z'][i]!=self.orientAxis:
self.poleAxis=['x','y','z'][i]
greatestLength=abs(self.poleVector[i])
self.bendDirection=-abs(self.poleVector[i])/self.poleVector[i]
for r in self.originalRotations:
mc.setAttr(r,self.originalRotations[r])
preferredAngleWarning=False
if not mc.objExists(self.joints[1]):
preferredAngleWarning=True
mp=midPoint(self.hierarchy[0],self.hierarchy[-1])
cd=9e999
dist=0
for j in self.hierarchy[1:-1]:
dist=distanceBetween(j,mp)
if dist<cd:
cd=dist
self.joints[1]=j
self.bendAxis=removeAll(self.orientAxis,['z','y','x'])[0]
if self.poleAxis=='': self.poleAxis=removeAll([self.orientAxis,self.bendAxis],['x','y','z'])[0]
if self.bendAxis=='': self.bendAxis=removeAll([self.orientAxis,self.poleAxis],['x','y','z'])[0]
if self.orientAxis=='': self.orientAxis=removeAll([self.bendAxis,self.poleAxis],['x','y','z'])[0]
if self.poleAxis=='x': self.poleVector=[-self.bendDirection,0.0,0.0]
if self.poleAxis=='y': self.poleVector=[0.0,-self.bendDirection,0.0]
if self.poleAxis=='z': self.poleVector=[0.0,0.0,-self.bendDirection]
if self.bendAxis=='x': self.upVector=[-self.bendDirection,0.0,0.0]
if self.bendAxis=='y': self.upVector=[0.0,-self.bendDirection,0.0]
if self.bendAxis=='z': self.upVector=[0.0,0.0,-self.bendDirection]
if self.orientAxis=='x': self.aimVector=[self.bendDirection,0.0,0.0]
if self.orientAxis=='y': self.aimVector=[0.0,self.bendDirection,0.0]
if self.orientAxis=='z': self.aimVector=[0.0,0.0,self.bendDirection]
if mc.objExists(self.baseTwist):
conn=False
for a in ['.r','.rx','.ry','.rz']:
if mc.connectionInfo(self.baseTwist+a,id=True):
conn=True
if not conn:
mc.orientConstraint(self.joints[0],self.baseTwist,sk=self.orientAxis)
# load ik2Bsolver - ikRPSolver does not work well with this setup
mel.eval('ik2Bsolver')
self.create()
if preferredAngleWarning:
raise Warning('Warning: Joints are co-linear and no preferred angles were set. Results may be unpredictable.')
def create(self):
worldMatrixNode=mc.createNode('fourByFourMatrix')
wm=\
[
[1,0,0,0],
[0,1,0,0],
[0,0,1,0],
[0,0,0,1]
]
for a in range(0,4):
for b in range(0,4):
mc.setAttr( worldMatrixNode+'.in'+str(a)+str(b), wm[a][b] )
self.worldMatrix=worldMatrixNode+'.o'
wsMatrices=[]
cleanup=[]
lattices=[]
uvPos=[]
antipodes=[]
cpos=mc.createNode('closestPointOnSurface')
if 'surfaceAttr' not in self.__dict__ or len(self.surfaceAttr)==0 and len(self.edges)>0:
mc.select(self.edges)
rebuildNode,surfaceNodeTr=mel.eval('zenLoftBetweenEdgeLoopPathRings(2)')[:2]
self.surfaceAttr=rebuildNode+'.outputSurface'
children=mc.listRelatives(surfaceNodeTr,c=True,s=True,ni=True,type='nurbsSurface')
if isIterable(children) and len(children)>0:
self.uSpans=mc.getAttr(children[0]+'.spansU')
self.vSpans=mc.getAttr(children[0]+'.spansV')
mc.disconnectAttr(self.surfaceAttr,surfaceNodeTr+'.create')
mc.delete(surfaceNodeTr)
if self.uSpans<0 or self.vSpans<0:
tempTr=mc.createNode('transform')
tempCurve=mc.createNode('nurbsCurve',p=tempTr)
mc.connectAttr(self.surfaceAttr,tempCurve+'.create')
self.uSpans=mc.getAttr(tempCurve+'.spansU')
self.vSpans=mc.getAttr(tempCurve+'.spansV')
mc.disconnectAttr(self.surfaceAttr,tempCurve+'.create')
mc.delete(tempTr)
orderedTrs=[]
orderedCtrls=[]
if self.distribute not in ['u','v']: #calculate the axis of distribution
if len(self.trs)!=0:
mc.connectAttr(self.surfaceAttr,cpos+'.inputSurface')
uMin=100
vMin=100
uMax=0
vMax=0
uPosList=[]
vPosList=[]
for i in range(0,self.number):
orderedTrs.append('')
orderedCtrls.append('')
t=self.trs[i]
if mc.objExists(t): # find the closest point
if self.hasGeometry:
center=mc.objectCenter(t)
mc.setAttr(cpos+'.ip',*center)
posCenter,uCenter,vCenter=mc.getAttr(cpos+'.p')[0],mc.getAttr(cpos+'.u'),mc.getAttr(cpos+'.v')
rp=mc.xform(t,ws=True,q=True,rp=True)
mc.setAttr(cpos+'.ip',*rp)
posRP,uRP,vRP=mc.getAttr(cpos+'.p')[0],mc.getAttr(cpos+'.u'),mc.getAttr(cpos+'.v')
# see which is closer - object center or rotate pivot
if self.hasGeometry:
distCenter=distanceBetween(posCenter,center)
distRP=distanceBetween(posRP,rp)
if self.hasGeometry==False or abs(distCenter)>abs(distRP) :
uPosList.append(uRP)
vPosList.append(vRP)
if uRP<uMin: uMin=uRP
if uRP>uMax: uMax=uRP
if vRP<vMin: vMin=vRP
if vRP>vMax: vMax=vRP
else:
uPosList.append(uCenter)
vPosList.append(vCenter)
if uCenter<uMin: uMin=uCenter
if uCenter>uMax: uMax=uCenter
if vCenter<vMin: vMin=vCenter
if vCenter>vMax: vMax=vCenter
cfsi=mc.createNode('curveFromSurfaceIso')
mc.connectAttr(self.surfaceAttr,cfsi+'.is')
mc.setAttr(cfsi+'.idr',0)
mc.setAttr(cfsi+'.iv',.5)
mc.setAttr(cfsi+'.r',True)
mc.setAttr(cfsi+'.rv',True)
if len(self.trs)!=0:
mc.setAttr(cfsi+'.min',uMin)
mc.setAttr(cfsi+'.max',uMax)
ci=mc.createNode('curveInfo')
mc.connectAttr(cfsi+'.oc',ci+'.ic')
uLength=mc.getAttr(ci+'.al')
mc.setAttr(cfsi+'.idr',1)
if len(self.trs)!=0:
mc.setAttr(cfsi+'.min',vMin)
mc.setAttr(cfsi+'.max',vMax)
vLength=mc.getAttr(ci+'.al')
mc.delete(cfsi,ci)
if uLength>vLength:
self.distribute='u'
if len(self.trs)!=0:
searchList=uPosList
orderedList=uPosList[:]
orderedList.sort()
else:
self.distribute='v'
if len(self.trs)!=0:
searchList=vPosList
orderedList=vPosList[:]
orderedList.sort()
reverseTrs=False
orderIDList=[]
for n in range(0,self.number):
s=searchList[n]
for i in range(0,self.number):
if s==orderedList[i] and i not in orderIDList:
orderIDList.append(i)
orderedTrs[i]=self.trs[n]
orderedCtrls[i]=self.ctrls[n]
if n==0 and i>len(self.trs)/2:
reverseTrs=True
break
if reverseTrs:
orderedTrs.reverse()
self.trs=orderedTrs
orderedCtrls.reverse()
self.ctrls=orderedCtrls
else:
self.trs=orderedTrs
self.ctrls=orderedCtrls
if self.rebuild: # interactive rebuild, maintains even parameterization over the rivet surface, use with caution
if self.distribute=='u':
self.surfaceAttr=mel.eval('zenUniformSurfaceRebuild("'+self.surfaceAttr+'",'+str(self.uSpans*2)+',-1)')+'.outputSurface'
else:
self.surfaceAttr=mel.eval('zenUniformSurfaceRebuild("'+self.surfaceAttr+'",-1,'+str(self.vSpans*2)+')')+'.outputSurface'
if not mc.isConnected(self.surfaceAttr,cpos+'.inputSurface'):
mc.connectAttr(self.surfaceAttr,cpos+'.inputSurface',f=True)
if self.taper=='distance' or self.createAimCurve or self.closestPoint=='geometry': # find the closest points ( and antipodes )
for i in range(0,self.number):
t=self.trs[i]
cp=ClosestPoints(self.surfaceAttr,t)
self.ClosestPoints.append(cp)
if self.taper=='distance' or self.createAimCurve: # antipodes are used for lattice allignment and curve calculations
antipodes.append(cp.getAntipodes(1))
if self.taper!='none' or self.scale!='none': # measures scale with scaling
cfsiLength=mc.createNode('curveFromSurfaceIso')
ciLength=mc.createNode('curveInfo')
lengthMultiplierNode=mc.createNode('multDoubleLinear')
mc.setAttr(cfsiLength+'.relative',True)
mc.setAttr(cfsiLength+'.relativeValue',True)
if self.distribute=='u':
mc.setAttr(cfsiLength+'.isoparmDirection',0)
else:
mc.setAttr(cfsiLength+'.isoparmDirection',1)
mc.setAttr(cfsiLength+'.minValue',0)
mc.setAttr(cfsiLength+'.maxValue',1)
mc.setAttr(cfsiLength+".isoparmValue",.5)
mc.connectAttr(self.surfaceAttr,cfsiLength+'.inputSurface')
if mc.objExists(self.spaceTr):
lengthCurve=mc.createNode('nurbsCurve',p=self.spaceTr)
lengthCurveTG=mc.createNode('transformGeometry')
mc.connectAttr(self.spaceTr+'.worldMatrix[0]',lengthCurveTG+'.txf')
mc.connectAttr(cfsiLength+'.outputCurve',lengthCurveTG+'.ig')
mc.connectAttr(lengthCurveTG+'.og',lengthCurve+'.create')
mc.connectAttr(lengthCurve+'.worldSpace',ciLength+'.inputCurve')
mc.setAttr(lengthCurve+'.intermediateObject',True)
cleanup.extend([lengthCurveTG,cfsiLength])
else:
mc.connectAttr(cfsiLength+'.outputCurve',ciLength+'.inputCurve')
mc.connectAttr(ciLength+'.al',lengthMultiplierNode+'.i1')
mc.setAttr(lengthMultiplierNode+'.i2',1.0/float(mc.getAttr(ciLength+'.al')))
lengthMultiplier=lengthMultiplierNode+'.o'
uvPos=[]
closestDistanceToCenter=Decimal('infinity')
centerMostRivetID=0
closestDistancesToCenter=[Decimal('infinity'),Decimal('infinity')]
centerMostRivetIDs=[0,0]
uvMultipliers=[]
aimGroups=[]
for i in range(0,self.number):
pTrs=mc.listRelatives(self.trs[i],p=True)
parentTr=''
if len(iterable(pTrs))>0:
parentTr=pTrs[0]
t=self.trs[i]
c=self.ctrls[i]
r=mc.createNode('transform',n='Rivet#')
wsMatrices.append(mc.xform(t,q=True,ws=True,m=True))
if self.constraint: mc.setAttr(r+'.inheritsTransform',False)
if not mc.objExists(c):
c=t
if not mc.objExists(t):
c=r
if not mc.objExists(c+'.zenRivet'):
mc.addAttr(c,at='message',ln='zenRivet',sn='zriv')
mc.connectAttr(r+'.message',c+'.zriv',f=True)
if not mc.objExists(c+'.uPos'):
mc.addAttr(c,k=True,at='double',ln='uPos',dv=50)
if not mc.objExists(c+'.vPos'):
mc.addAttr(c,k=True,at='double',ln='vPos',dv=50)
if self.closestPoint=='geometry':
up,vp=self.ClosestPoints[i].uvs[0]
else:
if mc.objExists(t):
if self.hasGeometry:
center=mc.objectCenter(t)
mc.setAttr(cpos+'.ip',*center)
posCenter,uCenter,vCenter=mc.getAttr(cpos+'.p')[0],mc.getAttr(cpos+'.u'),mc.getAttr(cpos+'.v')
rp=mc.xform(t,ws=True,q=True,rp=True)
mc.setAttr(cpos+'.ip',*rp)
posRP,uRP,vRP=mc.getAttr(cpos+'.p')[0],mc.getAttr(cpos+'.u'),mc.getAttr(cpos+'.v')
if self.hasGeometry:
distCenter=distanceBetween(posCenter,center)
distRP=distanceBetween(posRP,rp)
if self.hasGeometry==False or abs(distCenter)>abs(distRP):
up=uRP
vp=vRP
else:
up=uCenter
vp=vCenter
elif len(distribute)>0:
if self.distribute=='u':
up=(i+1)/self.number
vp=.5
else:
up=.5
vp=(i+1)/self.number
if up>float(self.uSpans)-.01: up=float(self.uSpans)-.01
if vp>float(self.vSpans)-.01: vp=float(self.vSpans)-.01
if up<.01: up=.01
if vp<.01: vp=.01
uvPos.append((up,vp))
if up<.5 and self.distribute=='u' and Decimal(str(abs(.5-up)))<Decimal(str(closestDistancesToCenter[0])):
closestDistancesToCenter[0]=abs(.5-up)
centerMostRivetIDs[0]=i
if up>.5 and self.distribute=='u' and Decimal(str(abs(.5-up)))<Decimal(str(closestDistancesToCenter[1])):
closestDistancesToCenter[1]=abs(.5-up)
centerMostRivetIDs[1]=i
if up<.5 and self.distribute=='v' and Decimal(str(abs(.5-vp)))<Decimal(str(closestDistancesToCenter[0])):
closestDistancesToCenter[0]=abs(.5-vp)
centerMostRivetIDs[0]=i
if up>.5 and self.distribute=='v' and Decimal(str(abs(.5-vp)))<Decimal(str(closestDistancesToCenter[1])):
closestDistancesToCenter[1]=abs(.5-vp)
centerMostRivetIDs[1]=i
mc.setAttr(c+'.uPos',up*100)
mc.setAttr(c+'.vPos',vp*100)
posi=mc.createNode('pointOnSurfaceInfo')
mc.setAttr((posi+".caching"),True)
#mc.setAttr((posi+".top"),True)
multiplyU=mc.createNode('multDoubleLinear')
mc.connectAttr(c+".uPos",multiplyU+".i1")
mc.setAttr(multiplyU+'.i2',.01)
multiplyV=mc.createNode('multDoubleLinear')
mc.connectAttr(c+".vPos",multiplyV+".i1")
mc.setAttr(multiplyV+'.i2',.01)
uvMultipliers.append([multiplyU,multiplyV])
mc.connectAttr(self.surfaceAttr,posi+".inputSurface");
mc.connectAttr(multiplyU+".o",posi+".parameterU")
mc.connectAttr(multiplyV+".o",posi+".parameterV")
dm=mc.createNode('decomposeMatrix')
mc.setAttr(dm+'.caching',True)
fbfm=mc.createNode('fourByFourMatrix')
mc.setAttr(fbfm+'.caching',True)
mc.connectAttr(posi+'.nnx',fbfm+'.in00')
mc.connectAttr(posi+'.nny',fbfm+'.in01')
mc.connectAttr(posi+'.nnz',fbfm+'.in02')
mc.connectAttr(posi+'.nux',fbfm+'.in10')
mc.connectAttr(posi+'.nuy',fbfm+'.in11')
mc.connectAttr(posi+'.nuz',fbfm+'.in12')
mc.connectAttr(posi+'.nvx',fbfm+'.in20')
mc.connectAttr(posi+'.nvy',fbfm+'.in21')
mc.connectAttr(posi+'.nvz',fbfm+'.in22')
mc.connectAttr(posi+'.px',fbfm+'.in30')
mc.connectAttr(posi+'.py',fbfm+'.in31')
mc.connectAttr(posi+'.pz',fbfm+'.in32')
if self.constraint:# and not self.parent:
mc.connectAttr(fbfm+'.output',dm+'.inputMatrix')
else:
multMatrix=mc.createNode('multMatrix')
mc.connectAttr(r+'.parentInverseMatrix',multMatrix+'.i[1]')
mc.connectAttr(fbfm+'.output',multMatrix+'.i[0]')
mc.connectAttr(multMatrix+'.o',dm+'.inputMatrix')
mc.connectAttr(dm+'.outputTranslate',r+'.t')
mc.connectAttr(dm+'.outputRotate',r+'.r')
if t!=r:
if self.createAimCurve:
aimGroup=mc.createNode('transform',n='rivetAimGrp#')
mc.parent(aimGroup,t,r=True)
mc.parent(aimGroup,r)
if self.keepPivot or self.closestPoint=='pivot':
mc.xform(aimGroup,ws=True,piv=mc.xform(t,q=True,ws=True,rp=True))
else:
mc.xform(aimGroup,ws=True,piv=self.ClosestPoints[i][1])
self.aimGroups.append(aimGroup)
if self.constraint:
if self.parent: # parent and constraint == ParentSpace
self.parentSpaces.append(ParentSpace(t,r))
pc=self.parentSpaces[i].parentConstraint
sc=self.parentSpaces[i].scaleConstraint
skip=['x']
if\
(
(self.distribute=='v' and 'length' in self.scaleDirection) or
(self.distribute=='u' and 'width' in self.scaleDirection) or
t in self.skipScaleObjects
):
skip.append('y')
if\
(
(self.distribute=='u' and 'length' in self.scaleDirection) or
(self.distribute=='v' and 'width' in self.scaleDirection) or
t in self.skipScaleObjects
):
skip.append('z')
mc.scaleConstraint(sc,e=True,sk=skip)
if t in self.skipRotateObjects:
mc.parentConstraint(pc,e=True,sr=('x','y','z'))
if t in self.skipTranslateObjects:
mc.parentConstraint(pc,e=True,st=('x','y','z'))
else: #just constraint
if t in self.skipRotateObjects:
pc=mc.parentConstraint(r,t,sr=('x','y','z'),mo=True)[0]#
if t in self.skipTranslateObjects:
pc=mc.parentConstraint(r,t,st=('x','y','z'),mo=self.mo)[0]
if t not in self.skipRotateObjects and t not in self.skipTranslateObjects:
pc=mc.parentConstraint(r,t,mo=self.mo)[0]
pcTargets=mc.parentConstraint(pc,q=True,tl=True)
pcIDs=[]
nsc=listNodeConnections(r,pc,s=False,d=True)
for n in range(0,len(nsc)):
if len(nsc[n])==2 and mc.objExists(nsc[n][-1]):
pcID=getIDs(nsc[n][-1])
if isinstance(pcID,int):
pcIDs.append(pcID)
pcIDs=removeDuplicates(pcIDs)
for pcID in pcIDs:
mc.connectAttr(self.worldMatrix,pc+'.tg['+str(pcID)+'].tpm',f=True)
mc.connectAttr(dm+'.outputTranslate',pc+'.tg['+str(pcID)+'].tt',f=True)
mc.connectAttr(dm+'.outputRotate',pc+'.tg['+str(pcID)+'].tr',f=True)
cleanup.append(r)
if self.parent:
scTargets=mc.scaleConstraint(sc,q=True,tl=True)
scIDs=[]
nsc=listNodeConnections(r,sc,s=False,d=True)
for n in range(0,len(nsc)):
if len(nsc[n])==2 and mc.objExists(nsc[n][-1]):
scIDs.append(getIDs(nsc[n][-1]))
scIDs=removeDuplicates(scIDs)
scMD=mc.createNode('multiplyDivide')
mc.setAttr(scMD+'.i1',1,1,1)
mc.setAttr(scMD+'.i2',1,1,1)
for scID in scIDs:
mc.connectAttr(self.worldMatrix,sc+'.tg['+str(scID)+'].tpm',f=True)
#mc.connectAttr(scMD+'.o',sc+'.tg['+str(scID)+'].ts',f=True)
mc.connectAttr(scMD+'.ox',sc+'.tg['+str(scID)+'].tsx',f=True)
mc.connectAttr(scMD+'.oy',sc+'.tg['+str(scID)+'].tsy',f=True)
mc.connectAttr(scMD+'.oz',sc+'.tg['+str(scID)+'].tsz',f=True)
r=self.parentSpaces[i][0]
#xfm=mc.xform(r,q=True,ws=True,m=True)
#mc.setAttr(r+'.inheritsTransform',False)
#mc.xform(r,m=xfm)
#mc.connectAttr(self.surfaceMatrix,multMatrix+'.i[1]',f=True)#self.parentSpaces[i][0]+'.parentInverseMatrix'
elif self.createAimCurve:
mc.parent(t,w=True)
mc.setAttr(t+'.inheritsTransform',False)
mc.parent(t,r,r=True)
else:
mc.parent(t,r)
if mc.objExists(parentTr) and (self.parent or self.createAimCurve) and not self.constraint:
if not (parentTr in iterable(mc.listRelatives(r,p=True))):
if mc.getAttr(r+'.inheritsTransform')==True:
mc.parent(r,parentTr,r=True)
else:
mc.parent(r,parentTr)
if mc.getAttr(r+'.inheritsTransform')==False:
dm=mc.createNode('decomposeMatrix')
mc.connectAttr(parentTr+'.worldMatrix',dm+'.inputMatrix')
mc.connectAttr(dm+'.os',t+'.s',f=True)
if self.taper!='none' or self.scale!='none':
cfsiU=mc.createNode('curveFromSurfaceIso')
mc.setAttr(cfsiU+'.relative',True)
mc.setAttr(cfsiU+'.relativeValue',True)
mc.setAttr(cfsiU+'.isoparmDirection',0)
mc.setAttr(cfsiU+'.minValue',0)
mc.setAttr(cfsiU+'.maxValue',1)
mc.connectAttr(multiplyV+".o",cfsiU+".isoparmValue")
mc.connectAttr(self.surfaceAttr,cfsiU+'.inputSurface')
cfsiV=mc.createNode('curveFromSurfaceIso')
mc.setAttr(cfsiV+'.relative',True)
mc.setAttr(cfsiV+'.relativeValue',True)
mc.setAttr(cfsiV+'.isoparmDirection',1)
mc.setAttr(cfsiV+'.minValue',0)
mc.setAttr(cfsiV+'.maxValue',1)
mc.connectAttr(multiplyV+".o",cfsiV+".isoparmValue")
mc.connectAttr(self.surfaceAttr,cfsiV+'.inputSurface')
subtractNode=mc.createNode('addDoubleLinear')
mc.setAttr(subtractNode+'.i1',-(1/(self.number*2)))
addNode=mc.createNode('addDoubleLinear')
mc.setAttr(addNode+'.i1',1/(self.number*2))
addSubClampNode=mc.createNode('clamp')
mc.setAttr(addSubClampNode+'.min',0,0,0)
mc.setAttr(addSubClampNode+'.max',1,1,1)
mc.connectAttr(subtractNode+'.o',addSubClampNode+'.inputR')
mc.connectAttr(addNode+'.o',addSubClampNode+'.inputG')
if self.distribute=='u':
mc.connectAttr(multiplyU+".o",subtractNode+".i2")
mc.connectAttr(multiplyU+".o",addNode+".i2")
mc.connectAttr(addSubClampNode+'.outputR',cfsiU+'.minValue')
mc.connectAttr(addSubClampNode+'.outputG',cfsiU+'.maxValue')
else:
mc.connectAttr(multiplyV+".o",subtractNode+".i2")
mc.connectAttr(multiplyV+".o",addNode+".i2")
mc.connectAttr(addSubClampNode+'.outputR',cfsiV+'.minValue')
mc.connectAttr(addSubClampNode+'.outputG',cfsiV+'.maxValue')
ciU=mc.createNode('curveInfo')
mc.connectAttr(cfsiU+'.outputCurve',ciU+'.inputCurve')
ciV=mc.createNode('curveInfo')
mc.connectAttr(cfsiV+'.outputCurve',ciV+'.inputCurve')
mdlU=mc.createNode('multDoubleLinear')
mc.connectAttr(ciU+'.al',mdlU+'.i1')
mc.setAttr(mdlU+'.i2',1/float(mc.getAttr(ciU+'.al')))
mdlV=mc.createNode('multDoubleLinear')
mc.connectAttr(ciV+'.al',mdlV+'.i1')
mc.setAttr(mdlV+'.i2',1/float(mc.getAttr(ciV+'.al')))
if not mc.objExists(c+'.minScaleWidth'): mc.addAttr(c,ln='minScaleWidth',at='double',k=True,min=0,dv=self.minScaleWidth)
if not mc.objExists(c+'.maxScaleWidth'): mc.addAttr(c,ln='maxScaleWidth',at='double',k=True,min=0,dv=self.maxScaleWidth)
if not mc.objExists(c+'.minScaleLength'): mc.addAttr(c,ln='minScaleLength',at='double',k=True,min=0,dv=self.minScaleLength)
if not mc.objExists(c+'.maxScaleLength'): mc.addAttr(c,ln='maxScaleLength',at='double',k=True,min=0,dv=self.maxScaleLength)
clampNode=mc.createNode('clamp')
minScaleLengthNode=mc.createNode('multDoubleLinear')
maxScaleLengthNode=mc.createNode('multDoubleLinear')
minScaleWidthNode=mc.createNode('multDoubleLinear')
maxScaleWidthNode=mc.createNode('multDoubleLinear')
mc.connectAttr(c+'.minScaleLength',minScaleLengthNode+'.i1')
mc.connectAttr(lengthMultiplier,minScaleLengthNode+'.i2')
mc.connectAttr(c+'.maxScaleLength',maxScaleLengthNode+'.i1')
mc.connectAttr(lengthMultiplier,maxScaleLengthNode+'.i2')
mc.connectAttr(c+'.minScaleWidth',minScaleWidthNode+'.i1')
mc.connectAttr(lengthMultiplier,minScaleWidthNode+'.i2')
mc.connectAttr(c+'.maxScaleWidth',maxScaleWidthNode+'.i1')
mc.connectAttr(lengthMultiplier,maxScaleWidthNode+'.i2')
if self.distribute=='u':
mc.connectAttr(minScaleLengthNode+'.o',clampNode+'.minR')
mc.connectAttr(maxScaleLengthNode+'.o',clampNode+'.maxR')
mc.connectAttr(minScaleWidthNode+'.o',clampNode+'.minG')
mc.connectAttr(maxScaleWidthNode+'.o',clampNode+'.maxG')
else:
mc.connectAttr(minScaleWidthNode+'.o',clampNode+'.minR')
mc.connectAttr(maxScaleWidthNode+'.o',clampNode+'.maxR')
mc.connectAttr(minScaleLengthNode+'.o',clampNode+'.minG')
mc.connectAttr(maxScaleLengthNode+'.o',clampNode+'.maxG')
mc.connectAttr(mdlU+'.o',clampNode+'.ipr')
mc.connectAttr(mdlV+'.o',clampNode+'.ipg')
if self.scale=='relative' and self.parent:#or len(self.scaleDirection)<2:#
if\
(
(self.distribute=='u' and 'length' in self.scaleDirection) or
(self.distribute=='v' and 'width' in self.scaleDirection)
):
if self.constraint:
mc.connectAttr(clampNode+'.opr',scMD+'.i1y')
else:
mc.connectAttr(clampNode+'.opr',r+'.sy',f=True)
if\
(
(self.distribute=='v' and 'length' in self.scaleDirection) or
(self.distribute=='u' and 'width' in self.scaleDirection)
):
if self.constraint:
mc.connectAttr(clampNode+'.opg',scMD+'.i1z')
else:
mc.connectAttr(clampNode+'.opg',r+'.sz',f=True)
elif self.taper!='none' and self.parent:
#self.autoFlexGroups
mc.setAttr(t+'.sx',lock=True)
mc.setAttr(t+'.sy',lock=True)
mc.setAttr(t+'.sz',lock=True)
mc.setAttr(t+'.tx',lock=True)
mc.setAttr(t+'.ty',lock=True)
mc.setAttr(t+'.tz',lock=True)
mc.setAttr(t+'.rx',lock=True)
mc.setAttr(t+'.ry',lock=True)
mc.setAttr(t+'.rz',lock=True)
aimTr=mc.createNode('transform',p=t)
mc.xform(aimTr,ws=True,t=antipodes[i])
#mc.setAttr(db+'.p1',*self.ClosestPoints[i][0])
#mc.setAttr(db+'.p2',*antipodes[i])
axisLength=distanceBetween(self.ClosestPoints[i][0],antipodes[i])#mc.getAttr(db+'.d')
ffd,lattice,latticeBase=mc.lattice(t,divisions=(2,2,2),objectCentered=True,ol=1)
latticeLowEndPoints=mc.ls(lattice+'.pt[0:1][0:0][0:1]',fl=True)
latticeHighEndPoints=mc.ls(lattice+'.pt[0:1][1:1][0:1]',fl=True)
mc.parent(latticeBase,lattice)
mc.setAttr(lattice+'.sy',axisLength)
lattices.append([ffd,lattice,latticeBase])
mc.parent(lattice,t)
mc.xform(lattice,ws=True,a=True,t=mc.xform(r,q=True,ws=True,a=True,rp=True))
mc.xform(lattice,os=True,a=True,ro=(0,0,0))
mc.move(0,axisLength/2,0,lattice,r=True,os=True,wd=True)
xSum,ySum,zSum=0,0,0
for p in latticeLowEndPoints:
px,py,pz=mc.pointPosition(p,w=True)
xSum+=px
ySum+=py
zSum+=pz
mc.xform(lattice,ws=True,piv=(xSum/len(latticeLowEndPoints),ySum/len(latticeLowEndPoints),zSum/len(latticeLowEndPoints)))
mc.xform(latticeBase,ws=True,piv=(xSum/len(latticeLowEndPoints),ySum/len(latticeLowEndPoints),zSum/len(latticeLowEndPoints)))
ac=mc.aimConstraint(aimTr,lattice,aim=(0,1,0),wut='objectrotation',wuo=r,u=(0,0,1),mo=False)
mc.delete(ac)
ac=mc.aimConstraint(aimTr,aimGroup,aim=(0,1,0),wut='objectrotation',wuo=r,u=(0,0,1),mo=False)
mc.delete(ac,aimTr)
lowEndCluster,lowEndClusterHandle=mc.cluster(latticeLowEndPoints)[:2]
highEndCluster,highEndClusterHandle=mc.cluster(latticeHighEndPoints)[:2]
lowEndClusterHandleShape=mc.listRelatives(lowEndClusterHandle,c=True)[0]
highEndClusterHandleShape=mc.listRelatives(highEndClusterHandle,c=True)[0]
#mc.parent(highEndClusterHandle,t)
if mc.isConnected(lowEndClusterHandleShape+'.clusterTransforms[0]',lowEndCluster+'.clusterXforms'):
mc.disconnectAttr(lowEndClusterHandleShape+'.clusterTransforms[0]',lowEndCluster+'.clusterXforms')
if mc.isConnected(highEndClusterHandleShape+'.clusterTransforms[0]',highEndCluster+'.clusterXforms'):
mc.disconnectAttr(highEndClusterHandleShape+'.clusterTransforms[0]',highEndCluster+'.clusterXforms')
self.autoFlexGroups.append\
(
(
mc.createNode('transform',n='rivetBaseAutoFlex#',p=r),
mc.createNode('transform',n='rivetEndAutoFlex#',p=aimGroup)
)
)
self.handles.append\
(
(
mc.createNode('transform',n='rivetBaseCtrl#',p=self.autoFlexGroups[i][0]),
mc.createNode('transform',n='rivetEndCtrl#',p=self.autoFlexGroups[i][1])
)
)
self.handleShapes.append\
(
(
mc.createNode('locator',p=self.handles[i][0]),
mc.createNode('locator',p=self.handles[i][1])
)
)
mc.setAttr(self.handleShapes[i][0]+'.los',.5,.5,.5)
mc.setAttr(self.handleShapes[i][1]+'.los',.5,.5,.5)
mc.xform(self.autoFlexGroups[i][0],ws=True,a=True,t=mc.xform(t,q=True,ws=True,rp=True))
mc.xform(self.autoFlexGroups[i][0],ws=True,a=True,piv=mc.xform(t,q=True,ws=True,rp=True))
for bp in self.bindPoses: mc.dagPose((self.handles[i][0],self.handles[i][1]),a=True,n=bp)
mc.xform(self.autoFlexGroups[i][1],ws=True,t=antipodes[i])
mc.hide(lattice)
mc.connectAttr(self.handles[i][0]+'.worldInverseMatrix[0]',lowEndCluster+'.bindPreMatrix',f=True)
mc.disconnectAttr(self.handles[i][0]+'.worldInverseMatrix[0]',lowEndCluster+'.bindPreMatrix')
mc.connectAttr(self.handles[i][0]+'.worldMatrix[0]',lowEndCluster+'.matrix',f=True)
mc.connectAttr(self.handles[i][1]+'.worldInverseMatrix[0]',highEndCluster+'.bindPreMatrix',f=True)
mc.disconnectAttr(self.handles[i][1]+'.worldInverseMatrix[0]',highEndCluster+'.bindPreMatrix')
mc.connectAttr(self.handles[i][1]+'.worldMatrix[0]',highEndCluster+'.matrix',f=True)
aimGroups.append(aimGroup)
if self.distribute=='u':
mc.connectAttr(clampNode+'.opr',self.autoFlexGroups[i][0]+'.sy')
else:
mc.connectAttr(clampNode+'.opg',self.autoFlexGroups[i][0]+'.sz')
mc.delete([lowEndClusterHandle,highEndClusterHandle])
self.rivets.append(r)
if self.createAimCurve and self.parent:
pmm=mc.createNode('pointMatrixMult')
arcPoints=[]
ids=[0,centerMostRivetIDs[0],centerMostRivetIDs[1],-1]
for id in ids:
measureTr=mc.createNode('transform')
aimTr=mc.createNode('transform',p=self.trs[id])
mc.parent(measureTr,self.trs[id])
mc.xform(aimTr,ws=True,t=antipodes[id])
mc.xform(measureTr,ws=True,t=mc.xform(self.rivets[id],q=True,ws=True,a=True,rp=True))
#mc.xform(measureTr,os=True,a=True,ro=(0,0,0),s=(1,1,1))
ac=mc.aimConstraint(aimTr,measureTr,aim=(0,1,0),wut='objectrotation',wuo=self.rivets[id],u=(0,0,1),mo=False)
mc.delete(ac,aimTr)
mc.connectAttr(measureTr+'.worldInverseMatrix',pmm+'.inMatrix',f=True)
maxYID=-1
maxY=0.0
yVal=0.0
for i in range(0,self.number):
mc.setAttr(pmm+'.ip',*antipodes[i])
yVal=mc.getAttr(pmm+'.oy')
if yVal>maxY:
maxY=yVal
maxYID=i
mc.setAttr(pmm+'.ip',*antipodes[maxYID])
oy=mc.getAttr(pmm+'.oy')
mc.setAttr(pmm+'.ip',*antipodes[id])
ox=mc.getAttr(pmm+'.ox')
oz=mc.getAttr(pmm+'.oz')
mc.connectAttr(measureTr+'.worldMatrix',pmm+'.inMatrix',f=True)
mc.setAttr(pmm+'.ip',ox,oy,oz)
ap=mc.getAttr(pmm+'.o')[0]
arcPoints.append(ap)
mc.disconnectAttr(measureTr+'.worldMatrix',pmm+'.inMatrix')
mc.delete(measureTr)
mc.delete(pmm)
arcCtrlArg=arcPoints
arcCtrlKeys={'arcWeight':self.arcWeight,'p':self.parents,'sp':self.softParents}
for k in arcCtrlKeys:
if type(arcCtrlKeys[k]).__name__=='NoneType':
del(arcCtrlKeys[k])
self.ArcCtrl=ArcCtrl(*arcCtrlArg,**arcCtrlKeys)
mc.addAttr(self.ArcCtrl[0],at='bool',ln='showHandles',k=True,dv=False)
mc.setAttr(self.ArcCtrl[0]+'.showHandles',k=False,cb=True)
mc.setAttr(self.ArcCtrl[0]+'.v',k=False,cb=True)
mc.setAttr(self.ArcCtrl[1]+'.v',k=False,cb=True)
for h in self.handles:
mc.connectAttr(self.ArcCtrl[0]+'.showHandles',h[0]+'.v')
mc.connectAttr(self.ArcCtrl[0]+'.showHandles',h[1]+'.v')
for bp in self.bindPoses: mc.dagPose(self.ArcCtrl,a=True,n=bp)
cpoc=mc.createNode('closestPointOnCurve')
mc.connectAttr(self.ArcCtrl.outputCurve,cpoc+'.inCurve')
for i in range(0,self.number):
aimTr=mc.createNode('transform')
poci=mc.createNode('pointOnCurveInfo')
dm=mc.createNode('decomposeMatrix')
fbfm=mc.createNode('fourByFourMatrix')
mc.connectAttr(poci+'.nnx',fbfm+'.in00')
mc.connectAttr(poci+'.nny',fbfm+'.in01')
mc.connectAttr(poci+'.nnz',fbfm+'.in02')
mc.connectAttr(poci+'.ntx',fbfm+'.in10')
mc.connectAttr(poci+'.nty',fbfm+'.in11')
mc.connectAttr(poci+'.ntz',fbfm+'.in12')
mc.connectAttr(self.ArcCtrl.outputNormal+'X',fbfm+'.in20')
mc.connectAttr(self.ArcCtrl.outputNormal+'Y',fbfm+'.in21')
mc.connectAttr(self.ArcCtrl.outputNormal+'Z',fbfm+'.in22')
mc.connectAttr(poci+'.px',fbfm+'.in30')
mc.connectAttr(poci+'.py',fbfm+'.in31')
mc.connectAttr(poci+'.pz',fbfm+'.in32')
mc.connectAttr(fbfm+'.output',dm+'.inputMatrix')
mc.connectAttr(dm+'.outputTranslate',aimTr+'.t')
mc.connectAttr(dm+'.outputRotate',aimTr+'.r')
mc.setAttr(cpoc+'.ip',*antipodes[i])
cpu=mc.getAttr(cpoc+'.u')
mc.setAttr(poci+'.parameter',cpu)
mc.connectAttr(self.ArcCtrl.outputCurve,poci+'.inputCurve')
ac=mc.aimConstraint(aimTr,self.aimGroups[i],aim=(0,1,0),wut='objectrotation',wuo=aimTr,u=(0,0,1),mo=not(self.realign))[0]
disconnectNodes(aimTr,ac)
mc.connectAttr(fbfm+'.output',ac+'.worldUpMatrix',f=True)
mc.connectAttr(dm+'.ot',ac+'.target[0].targetTranslate',f=True)
mc.delete(aimTr)
sc=mc.createNode('subCurve')
mc.setAttr(sc+'.relative',True)
mc.setAttr(sc+'.minValue',0)
mc.setAttr(sc+'.maxValue',1)
mc.connectAttr(self.ArcCtrl.outputCurve,sc+'.ic')
if self.distribute=='u':
uMultAttr=uvMultipliers[i][0]+".o"
else:
uMultAttr=uvMultipliers[i][1]+".o"
#adjust for offset
multOffsetCalc=mc.createNode('multDoubleLinear')
mc.setAttr(multOffsetCalc+'.i1',1/mc.getAttr(uMultAttr))
mc.connectAttr(uMultAttr,multOffsetCalc+'.i2')
multOffset=mc.createNode('multDoubleLinear')
mc.setAttr(multOffset+'.i1',cpu)
mc.connectAttr(multOffsetCalc+'.o',multOffset+'.i2')
mc.connectAttr(multOffset+'.o',poci+'.parameter',f=True)
subtractNode=mc.createNode('addDoubleLinear')
mc.setAttr(subtractNode+'.i1',-(1.0/(self.number*2)))
addNode=mc.createNode('addDoubleLinear')
mc.setAttr(addNode+'.i1',1.0/(self.number*2))
addSubClampNode=mc.createNode('clamp')
mc.setAttr(addSubClampNode+'.min',0,0,0)
mc.setAttr(addSubClampNode+'.max',1,1,1)
mc.connectAttr(subtractNode+'.o',addSubClampNode+'.inputR')
mc.connectAttr(addNode+'.o',addSubClampNode+'.inputG')
mc.connectAttr(multOffset+".o",subtractNode+".i2")
mc.connectAttr(multOffset+".o",addNode+".i2")
mc.connectAttr(addSubClampNode+'.outputR',sc+'.minValue')
mc.connectAttr(addSubClampNode+'.outputG',sc+'.maxValue')
ciU=mc.createNode('curveInfo')
mc.connectAttr(sc+'.outputCurve',ciU+'.inputCurve')
mdlU=mc.createNode('multDoubleLinear')
mc.connectAttr(ciU+'.al',mdlU+'.i1')
mc.setAttr(mdlU+'.i2',1/float(mc.getAttr(ciU+'.al')))
clampNode=mc.createNode('clamp')
if not mc.objExists(c+'.minScaleEnd'): mc.addAttr(self.ctrls[i],ln='minScaleEnd',at='double',k=True,min=0,max=1,dv=0)
if not mc.objExists(c+'.maxScaleEnd'): mc.addAttr(self.ctrls[i],ln='maxScaleEnd',at='double',k=True,min=0,dv=1)
mc.connectAttr(self.ctrls[i]+'.minScaleEnd',clampNode+'.minR')
mc.connectAttr(self.ctrls[i]+'.maxScaleEnd',clampNode+'.maxR')
mc.connectAttr(mdlU+'.o',clampNode+'.ipr')
if self.distribute=='u':
mc.connectAttr(clampNode+'.opr',self.autoFlexGroups[i][1]+'.sz')
else:
mc.connectAttr(clampNode+'.opr',self.autoFlexGroups[i][1]+'.sy')
mc.delete(cpoc)
if self.parent:
self[:]=self.rivets
else:
self[:]=self.trs
#if self.mo:
# #for i in len(self.trs):
# #try: mc.xform(t,q=True,ws=True,m=wsMatrices[i]))
# #except: pass
cleanup.append(cpos)
for c in cleanup:
if mc.objExists(c):
disconnectNodes(c)
mc.delete(c)
if self.snapToSurface:
if self.createAimCurve or self.taper:
for i in range(0,self.number):
mc.xform(self.handles[i][0],ws=True,t=mc.xform(self.rivets[i],q=True,ws=True,rp=True))
mc.xform(self.trs[i],ws=True,rp=mc.xform(self.rivets[i],q=True,ws=True,rp=True))
else:
for i in range(0,self.number):
mc.xform(self.trs[i],ws=True,t=mc.xform(self.rivets[i],q=True,ws=True,rp=True))
mc.xform(self.trs[i],ws=True,ro=mc.xform(self.rivets[i],q=True,ws=True,ro=True))
def create(self):
# arguments and list options are reversed before and after creation to conform context with IK Handle creation
for lo in self.__dict__:
if isinstance(self.__dict__[lo],list):
exec('self.'+lo+'.reverse()')
self.arcCheck()
trSpaces=[]
cleanup=[]
curveShapes=[]
keep=[]
loft=''
if self.createSurface:
xs=[0,1]
else:
xs=[0]
for i in [0,1]:
self.handles.append(mc.createNode('transform',n=self.names[i]))
trSpaces.append(self.handles[-1])
mc.addAttr(self.handles[1],ln='arcNormal',at='float3')
mc.addAttr(self.handles[1],ln='arcNormalX',at='float',p='arcNormal')
mc.addAttr(self.handles[1],ln='arcNormalY',at='float',p='arcNormal')
mc.addAttr(self.handles[1],ln='arcNormalZ',at='float',p='arcNormal')
blendCurveShapes=[]
arc=[]
bs=[]
bn=[]
mdlWidth=[]
origShape=[]
ci=[]
spans=0
ext=[]
measureCurves=[]
if len(xs)>1:
mdlWidth.append(mc.createNode('multDoubleLinear'))
mc.setAttr(mdlWidth[0]+'.i2',-.5)
mdlWidth.append(mc.createNode('multDoubleLinear'))
mc.setAttr(mdlWidth[1]+'.i2',.5)
for x in xs:
#align handles
arc.append([])
arc[x].append(mc.createNode('makeThreePointCircularArc',n='arc#'))
arc[x].append(mc.createNode('makeThreePointCircularArc',n='arc#'))
#mc.setAttr(arc[x][0]+'.sections',16)
#mc.setAttr(arc[x][1]+'.sections',16)
n=0
for i in range(0,2)+[-1]:
mc.setAttr(arc[x][0]+'.point'+str(n+1),*self.arcPoints[i])
n+=1
n=0
for i in [0]+range(-2,0):
mc.setAttr(arc[x][1]+'.point'+str(n+1),*self.arcPoints[i])
n+=1
bn.append(mc.createNode('blendColors'))
mc.connectAttr(arc[x][0]+'.nr',bn[x]+'.c1')
mc.connectAttr(arc[x][1]+'.nr',bn[x]+'.c2')
if x==0:
mc.connectAttr(bn[x]+'.op',self.handles[1]+'.arcNormal')
self.outputNormal=self.handles[1]+'.arcNormal'
if x==0:
fbfm=mc.createNode('fourByFourMatrix')
dm=mc.createNode('decomposeMatrix')
cpoc=['','']
bcN=mc.createNode('blendColors')
bcT=mc.createNode('blendColors')
bcP=mc.createNode('blendColors')
mc.setAttr(bn[x]+'.b',self.arcWeight)
mc.setAttr(bcN+'.b',self.arcWeight)
mc.setAttr(bcT+'.b',self.arcWeight)
mc.setAttr(bcP+'.b',self.arcWeight)
mc.connectAttr(bcN+'.opr',fbfm+'.in00')
mc.connectAttr(bcN+'.opg',fbfm+'.in01')
mc.connectAttr(bcN+'.opb',fbfm+'.in02')
mc.connectAttr(bcT+'.opr',fbfm+'.in10')
mc.connectAttr(bcT+'.opg',fbfm+'.in11')
mc.connectAttr(bcT+'.opb',fbfm+'.in12')
mc.connectAttr(bcP+'.opr',fbfm+'.in30')
mc.connectAttr(bcP+'.opg',fbfm+'.in31')
mc.connectAttr(bcP+'.opb',fbfm+'.in32')
mc.connectAttr(bn[x]+'.opr',fbfm+'.in20')
mc.connectAttr(bn[x]+'.opg',fbfm+'.in21')
mc.connectAttr(bn[x]+'.opb',fbfm+'.in22')
mc.connectAttr(fbfm+'.output',dm+'.inputMatrix')
for i in [0,1]:
cpoc[i]=mc.createNode('closestPointOnCurve')
mc.connectAttr(arc[x][i]+'.oc',cpoc[i]+'.ic')
mc.connectAttr(cpoc[i]+'.nx',bcN+'.c'+str(i+1)+'r')
mc.connectAttr(cpoc[i]+'.ny',bcN+'.c'+str(i+1)+'g')
mc.connectAttr(cpoc[i]+'.nz',bcN+'.c'+str(i+1)+'b')
mc.connectAttr(cpoc[i]+'.tx',bcT+'.c'+str(i+1)+'r')
mc.connectAttr(cpoc[i]+'.ty',bcT+'.c'+str(i+1)+'g')
mc.connectAttr(cpoc[i]+'.tz',bcT+'.c'+str(i+1)+'b')
mc.connectAttr(cpoc[i]+'.px',bcP+'.c'+str(i+1)+'r')
mc.connectAttr(cpoc[i]+'.py',bcP+'.c'+str(i+1)+'g')
mc.connectAttr(cpoc[i]+'.pz',bcP+'.c'+str(i+1)+'b')
for i in [0,-1]:
mc.setAttr(cpoc[0]+'.ip',*self.arcPoints[i])
mc.setAttr(cpoc[1]+'.ip',*self.arcPoints[i])
mc.setAttr(trSpaces[i]+'.t',*mc.getAttr(dm+'.ot')[0])
mc.setAttr(trSpaces[i]+'.r',*mc.getAttr(dm+'.or')[0])
for i in [0,-1]:
mc.disconnectAttr(arc[x][i]+'.oc',cpoc[i]+'.ic')
mc.disconnectAttr(bn[x]+'.opr',fbfm+'.in20')
mc.disconnectAttr(bn[x]+'.opg',fbfm+'.in21')
mc.disconnectAttr(bn[x]+'.opb',fbfm+'.in22')
mc.delete(fbfm,dm,cpoc,bcN,bcT,bcP)
if len(xs)>1:
loft=mc.createNode('loft')
mc.setAttr(loft+'.autoReverse',False)
mc.setAttr(loft+'.uniform',True)
poci=mc.createNode('pointOnCurveInfo')
i=0
for f in [.01,.99]:
pmm=mc.createNode('pointMatrixMult')
if len(xs)>1:
mc.connectAttr(mdlWidth[x]+'.o',pmm+'.ipz')
mc.connectAttr(trSpaces[i]+'.wm[0]',pmm+'.im')
mc.connectAttr(pmm+'.o',arc[x][0]+'.point'+str([1,3][i]))
mc.connectAttr(pmm+'.o',arc[x][1]+'.point'+str([1,3][i]))
mc.connectAttr(arc[x][i]+'.outputCurve',poci+'.inputCurve',f=True)
mc.setAttr(poci+'.top',True)
mc.setAttr(poci+'.parameter',f)
pmm=mc.createNode('pointMatrixMult')
mc.connectAttr(trSpaces[i]+'.worldInverseMatrix',pmm+'.inMatrix')
mc.setAttr(pmm+'.ip',*mc.getAttr(poci+'.p')[0])
ap=mc.getAttr(pmm+'.o')[0]
mc.connectAttr(trSpaces[i]+'.worldMatrix',pmm+'.inMatrix',f=True)
mc.setAttr(pmm+'.ip',*ap)
if len(xs)>1: mc.connectAttr(mdlWidth[x]+'.o',pmm+'.ipz')
mc.connectAttr(pmm+'.o',arc[x][i]+'.point2',f=True)
i+=1
self.curveShapes.append(mc.createNode('nurbsCurve',p=trSpaces[1],n=self.names[1]+'Shape#'))
blendCurveShapes.append(mc.createNode('nurbsCurve',p=trSpaces[1],n=self.names[1]+'Shape#'))
mc.connectAttr(arc[x][0]+'.outputCurve',self.curveShapes[x]+'.create')
mc.connectAttr(arc[x][1]+'.outputCurve',blendCurveShapes[x]+'.create')
spans=mc.getAttr(self.curveShapes[x]+'.spans')
bs.append(mc.blendShape(blendCurveShapes[x],self.curveShapes[x],o='local',w=(0,1))[0])
origShape.append(mc.listConnections(arc[x][0]+'.outputCurve',d=True,s=False,sh=True)[0])
blendConnectAttrs=mc.listConnections(origShape[x]+'.worldSpace',p=True,sh=True)
for b in blendConnectAttrs:
mc.connectAttr(arc[x][0]+'.outputCurve',b,f=True)
mc.connectAttr(arc[x][1]+'.outputCurve',bs[x]+'.it[0].itg[0].iti[6000].igt',f=True)
rc=mc.createNode('rebuildCurve')
mc.setAttr(rc+'.kcp',False)
mc.connectAttr(arc[x][0]+'.sections',rc+'.spans',f=True)
mc.setAttr(rc+'.kr',0)
reverseCurve=mc.createNode('reverseCurve')
mc.connectAttr(rc+'.oc',reverseCurve+'.ic')
tg=mc.createNode('transformGeometry')
mc.connectAttr(tg+'.og',self.curveShapes[x]+'.create',f=True)
mc.connectAttr(reverseCurve+'.oc',tg+'.ig')
mc.connectAttr(trSpaces[1]+'.worldInverseMatrix',tg+'.transform',f=True)
if self.stretch<0 or self.squash<0:
mc.connectAttr(bs[x]+'.og[0]',rc+'.ic')
else:
rc2=mc.createNode('rebuildCurve')
mc.connectAttr(arc[x][0]+'.sections',rc2+'.spans',f=True)
mc.setAttr(rc2+'.kr',0)
mc.connectAttr(bs[x]+'.og[0]',rc2+'.ic',f=True)
sub=mc.createNode('subCurve')
mc.setAttr(sub+'.r',True)
mc.setAttr(sub+'.min',0)
mc.setAttr(sub+'.max',1)
ext=''
ext=mc.createNode('extendCurve')
mc.setAttr(ext+'.rmk',True)
mc.setAttr(ext+'.d',.00001)
mc.connectAttr(sub+'.oc',ext+'.ic1',f=True)
mc.connectAttr(ext+'.oc',rc+'.ic',f=True)
mc.connectAttr(rc2+'.oc',sub+'.ic',f=True)
if not mc.objExists(self.handles[0]+'.stretch'):
mc.addAttr(self.handles[0],ln='stretch',at='float',min=0,dv=self.stretch,k=True)
if not mc.objExists(self.handles[0]+'.squash'):
mc.addAttr(self.handles[0],ln='squash',at='float',min=0,max=100,dv=self.squash,k=True)
if not mc.objExists(self.handles[1]+'.length'):
mc.addAttr(self.handles[1],ln='length',at='float',min=0,k=True)
if not mc.objExists(self.handles[1]+'.overSquash'):
mc.addAttr(self.handles[1],ln='overSquash',at='float',min=0,dv=100,k=False)
if not mc.objExists(self.handles[1]+'.overStretch'):
mc.addAttr(self.handles[1],ln='overStretch',at='float',min=0,dv=100,k=False)
ci.append(mc.createNode('curveInfo'))
mc.connectAttr(rc+'.oc',ci[x]+'.ic',f=True)
mc.connectAttr(rc2+'.oc',ci[x]+'.ic',f=True)
measureAttr=ci[x]+'.al'
if x==0 and len(xs)>1:
pma=mc.createNode('plusMinusAverage')
mc.setAttr(pma+'.op',3)
overStretchPMA=mc.createNode('plusMinusAverage')
mc.setAttr(overStretchPMA+'.op',3)
mc.connectAttr(overStretchPMA+'.o1',self.handles[1]+'.overStretch')
overSquashPMA=mc.createNode('plusMinusAverage')
mc.setAttr(overSquashPMA+'.op',3)
mc.connectAttr(overSquashPMA+'.o1',self.handles[1]+'.overSquash')
if len(xs)>1:
mc.connectAttr(ci[x]+'.al',pma+'.i1['+str(x)+']')
measureAttr=pma+'.o1'
mc.setAttr(self.handles[1]+'.length',float(mc.getAttr(measureAttr)))
if x==0:
stretchADL=mc.createNode('plusMinusAverage')
mc.setAttr(stretchADL+'.op',2)# subtract
mc.connectAttr(measureAttr,stretchADL+'.i1[0]')
mc.connectAttr(self.handles[1]+'.length',stretchADL+'.i1[1]')
stretchMD=mc.createNode('multiplyDivide')
mc.setAttr(stretchMD+'.op',2)# divide
mc.connectAttr(stretchADL+'.o1',stretchMD+'.i1x')
mc.connectAttr(self.handles[1]+'.length',stretchMD+'.i2x')
stretch=stretchMD+'.ox'
mc.connectAttr(self.handles[0]+'.stretch',stretchMD+'.i1y')
mc.setAttr(stretchMD+'.i2y',100)
stretchMax=stretchMD+'.oy'
stretchMDClamp=mc.createNode('clamp')
mc.connectAttr(stretchMax,stretchMDClamp+'.mxr')#stretchMD+'.oy'
mc.setAttr(stretchMDClamp+'.mnr',0.0001)
mc.connectAttr(stretchMax,stretchMDClamp+'.ipr')
stretchMax=stretchMDClamp+'.opr'
mc.connectAttr(stretchMax,stretchMDClamp+'.mxg')
mc.setAttr(stretchMDClamp+'.mng',0.0001)
mc.connectAttr(stretch,stretchMDClamp+'.ipg')
stretchClamped=stretchMDClamp+'.opg'
mc.connectAttr(stretch,stretchMDClamp+'.mxb')
mc.setAttr(stretchMDClamp+'.mnb',0.0001)
mc.connectAttr(stretch,stretchMDClamp+'.ipb')
stretchClampedLo=stretchMDClamp+'.opb'
stretchGapPMA=mc.createNode('plusMinusAverage')# difference between max stretch and current stretch
mc.setAttr(stretchGapPMA+'.op',2)# subtract
mc.connectAttr(stretchMax,stretchGapPMA+'.i1[0]')
mc.connectAttr(stretchClampedLo,stretchGapPMA+'.i1[1]')
stretchGAP=stretchGapPMA+'.o1'
stretchGapPercMD=mc.createNode('multiplyDivide')# %difference between max stretch and current stretch
mc.setAttr(stretchGapPercMD+'.op',2)# divide
mc.connectAttr(stretchGAP,stretchGapPercMD+'.i1x')
mc.connectAttr(stretchMax,stretchGapPercMD+'.i2x')
stretchGapPerc=stretchGapPercMD+'.ox'
stretchPlusOneNode=mc.createNode('addDoubleLinear')
mc.connectAttr(stretchClampedLo,stretchPlusOneNode+'.i1')
mc.setAttr(stretchPlusOneNode+'.i2',1)
stretchPlusOne=stretchPlusOneNode+'.o'
overStretchSubNode=mc.createNode('plusMinusAverage')
mc.setAttr(overStretchSubNode+'.op',2)# subtract
mc.connectAttr(stretchClampedLo,overStretchSubNode+'.i1[0]')#stretchMinusFallOff
mc.connectAttr(stretchClamped,overStretchSubNode+'.i1[1]')#stretchClampedMinusFallOff
overStretchDivNode=mc.createNode('multiplyDivide')
mc.setAttr(overStretchDivNode+'.op',2)# divide
mc.connectAttr(overStretchSubNode+'.o1',overStretchDivNode+'.i1x')
mc.connectAttr(stretchPlusOne,overStretchDivNode+'.i2x')
overStretch=overStretchDivNode+'.ox'
if len(xs)>1:
mc.connectAttr(overStretch,overStretchPMA+'.i1['+str(x)+']')
#squash
squashPMA=mc.createNode('plusMinusAverage')
mc.setAttr(squashPMA+'.op',2)# subtract
mc.connectAttr(self.handles[1]+'.length',squashPMA+'.i1[0]')
mc.connectAttr(measureAttr,squashPMA+'.i1[1]')
squashDist=squashPMA+'.o1'
squashDistClamp=mc.createNode('clamp')
mc.connectAttr(squashDist,squashDistClamp+'.mxr')#stretchMD+'.oy'
mc.setAttr(squashDistClamp+'.mnr',0.00001)
mc.connectAttr(squashDist,squashDistClamp+'.ipr')
squashDistClamped=squashDistClamp+'.opr'
squashMD=mc.createNode('multiplyDivide')
mc.setAttr(squashMD+'.op',2)# divide
mc.connectAttr(squashDistClamped,squashMD+'.i1x')
mc.connectAttr(self.handles[1]+'.length',squashMD+'.i2x')
squash=squashMD+'.ox'
mc.connectAttr(self.handles[0]+'.squash',squashMD+'.i1y')
mc.setAttr(squashMD+'.i2y',100)
squashMax=squashMD+'.oy'
squashMDClamp=mc.createNode('clamp')
mc.connectAttr(squashMax,squashMDClamp+'.mxr')
mc.setAttr(squashMDClamp+'.mnr',0.00001)
mc.connectAttr(squashMax,squashMDClamp+'.ipr')
squashMax=squashMDClamp+'.opr'
mc.connectAttr(squashMax,squashMDClamp+'.mxg')
mc.setAttr(squashMDClamp+'.mng',0.0001)
mc.connectAttr(squash,squashMDClamp+'.ipg')
squashClamped=squashMDClamp+'.opg'
mc.connectAttr(squash,squashMDClamp+'.mxb')
mc.setAttr(squashMDClamp+'.mnb',0.0001)
mc.connectAttr(squash,squashMDClamp+'.ipb')
squashClampedLo=squashMDClamp+'.opb'
squashGapPMA=mc.createNode('plusMinusAverage')# difference between max squash and current squash
mc.setAttr(squashGapPMA+'.op',2)# subtract
mc.connectAttr(squashMax,squashGapPMA+'.i1[0]')
mc.connectAttr(squashClampedLo,squashGapPMA+'.i1[1]')
squashGAP=squashGapPMA+'.o1'
squashGapPercMD=mc.createNode('multiplyDivide')# %difference between max squash and current squash
mc.setAttr(squashGapPercMD+'.op',2)# divide
mc.connectAttr(squashGAP,squashGapPercMD+'.i1x')
mc.connectAttr(squashMax,squashGapPercMD+'.i2x')
squashGapPerc=squashGapPercMD+'.ox'
overSquashSubNode=mc.createNode('plusMinusAverage')
mc.setAttr(overSquashSubNode+'.op',2)# subtract
mc.connectAttr(squashClampedLo,overSquashSubNode+'.i1[0]')#squashMinusFallOff
mc.connectAttr(squashClamped,overSquashSubNode+'.i1[1]')#squashClampedMinusFallOff
overSquash=overSquashSubNode+'.o1'#overSquashDivNode+'.ox'
overSquashDistanceMDL=mc.createNode('multDoubleLinear')
mc.connectAttr(self.handles[1]+'.length',overSquashDistanceMDL+'.i1')
mc.connectAttr(overSquash,overSquashDistanceMDL+'.i2')
overSquashDistanceClamp=mc.createNode('clamp')
mc.connectAttr(overSquashDistanceMDL+'.o',overSquashDistanceClamp+'.mxr')#stretchMD+'.oy'
mc.setAttr(overSquashDistanceClamp+'.mnr',0.00001)
mc.connectAttr(overSquashDistanceMDL+'.o',overSquashDistanceClamp+'.ipr')
overSquashDistance=overSquashDistanceClamp+'.opr'
if len(xs)>1:
mc.connectAttr(overSquash,overSquashPMA+'.i1['+str(x)+']')
if mc.objExists(ext+'.d'): mc.connectAttr(overSquashDistance,ext+'.d')
mc.connectAttr(overStretch,sub+'.min')
disconnectNodes(origShape[x])
mc.delete(origShape[x])
disconnectNodes(blendCurveShapes[x])
mc.delete(blendCurveShapes[x])
if x==len(xs)-1:
if 'spans' not in mc.listAttr(self.handles[1]):
mc.addAttr(self.handles[1],ln='spans',at='long',min=0,dv=spans,k=True)
mc.connectAttr(self.handles[1]+'.spans',arc[0][0]+'.sections')
mc.connectAttr(self.handles[1]+'.spans',arc[0][1]+'.sections')
if len(xs)>1:
mc.connectAttr(tg+'.og',loft+'.ic['+str(x)+']')
disconnectNodes(self.curveShapes[x])
if x==1:
mc.delete(self.curveShapes[x])
self.outputSurface=loft+'.os'
if self.createSurface:
self.surface=mc.createNode('nurbsSurface',p=trSpaces[1])
mc.connectAttr(self.outputSurface,self.surface+'.create',f=True)
if not self.createSurface or ( self.scaleLength and mc.objExists(self.handles[1]+'.length') ):
self.curveShapes[0]=mc.createNode('nurbsCurve',p=trSpaces[1])
cfsi=mc.createNode('curveFromSurfaceIso')
mc.setAttr(cfsi+'.r',True)
mc.setAttr(cfsi+'.rv',True)
mc.setAttr(cfsi+'.min',0)
mc.setAttr(cfsi+'.max',1)
mc.setAttr(cfsi+'.idr',1)
mc.setAttr(cfsi+'.idr',1)
mc.setAttr(cfsi+'.iv',.5)
mc.connectAttr(self.outputSurface,cfsi+'.is',f=True)
mc.connectAttr(cfsi+'.oc',self.curveShapes[0]+'.create',f=True)
self.outputCurve=cfsi+'.oc'
for i in [0,-1]:
if self.handleType[i]=='none':
self.handleShapes.append([''])
else:
if 'type' not in self.handleOptions[i]: self.handleOptions[i]['type']=self.handleType[i-1]
self.handleShapes.append(Handle(self.handles[i],**self.handleOptions[i]))
keep=keep+[self.surface]+self.handleShapes[0]+self.handleShapes[-1]
if not self.createSurface or self.scaleLength: keep.append(self.curveShapes[0])
cleanup.extend\
(
removeAll\
(
keep,
(
removeDuplicates(mc.listRelatives(trSpaces[1],c=True,type='nurbsSurface'))+
removeDuplicates(mc.listRelatives(trSpaces[1],c=True,type='nurbsCurve'))
)
)
)
if self.createSurface:
self.outputSurface=self.surface+'.worldSpace'
else:
self.outputCurve=self.curveShapes[0]+'.worldSpace'
mc.addAttr(self.handles[0],ln='arcWeight',at='double',k=True,min=0,max=1,dv=self.arcWeight)
if self.createSurface:
mc.addAttr(self.handles[1],ln='width',at='double',k=True,min=.001,dv=self.width)
mc.connectAttr(self.handles[1]+'.width',mdlWidth[0]+'.i1')
mc.connectAttr(self.handles[1]+'.width',mdlWidth[1]+'.i1')
rev=mc.createNode('reverse')
mc.connectAttr(self.handles[0]+'.arcWeight',rev+'.ix')
mc.connectAttr(rev+'.ox',bn[0]+'.b')
if self.createSurface: mc.connectAttr(rev+'.ox',bn[1]+'.b')
mc.connectAttr(rev+'.ox',bs[0]+'.en')
if self.createSurface: mc.connectAttr(rev+'.ox',bs[1]+'.en')
for i in [0,-1]:
if self.parents[i]=='.':
mc.parent(self.handles[i],self.handles[[-1,0][i]])
elif mc.objExists(self.parents[i]):
mc.parent(self.handles[i],self.parents[i])
if self.softParents[i]=='.':
self.parentSpaces[i]=ParentSpace(self.handles[i],self.handles[[-1,0][i]])
elif mc.objExists(self.softParents[i]):
self.parentSpaces[i]=ParentSpace(self.handles[i],self.softParents[i])
for c in cleanup:
if mc.objExists(c):
disconnectNodes(c)
mc.delete(c)
if self.scaleLength and mc.objExists(self.handles[1]+'.length'):
measureCurve=mc.createNode('nurbsCurve',p=self.handles[1],n=self.names[1]+'Shape#')
mc.connectAttr(self.curveShapes[0]+'.local',measureCurve+'.create')
ciOrig=mc.createNode('curveInfo')
mc.connectAttr(measureCurve+'.worldSpace[0]',ciOrig+'.ic',f=True)
#mc.connectAttr(ciOrig+'.al',self.handles[1]+'.length',f=True)
divLength=mc.createNode('multiplyDivide')
mc.setAttr(divLength+'.op',2)
mc.connectAttr(self.handles[1]+'.length',divLength+'.i1x')
mc.setAttr(divLength+'.i2x',mc.getAttr(self.handles[1]+'.length'))
multLength=mc.createNode('multiplyDivide')
mc.setAttr(multLength+'.op',1)
mc.connectAttr(ciOrig+'.al',multLength+'.i1x')
mc.connectAttr(divLength+'.ox',multLength+'.i2x')
for attr in [overSquashDistanceMDL+'.i1',stretchADL+'.i1[1]',stretchMD+'.i2x',squashPMA+'.i1[0]',squashMD+'.i2x']:
mc.connectAttr(multLength+'.ox',attr,f=True)
mc.addAttr(self.handles[1],ln='globalLength',at='double')
mc.connectAttr(multLength+'.ox',self.handles[1]+'.globalLength',f=True)
mc.addAttr(self.handles[1],ln='lengthScale',at='double')
mc.connectAttr(divLength+'.ox',self.handles[1]+'.lengthScale',f=True)
mc.disconnectAttr(self.curveShapes[0]+'.local',measureCurve+'.create')
mc.setAttr(measureCurve+'.intermediateObject',True)
#mc.setAttr(self.handles[1]+'.length',k=False,cb=False)
if self.createSurface:
mc.delete(self.curveShapes[0])
# put lists back in input order
for lo in self.__dict__:
if isinstance(self.__dict__[lo],list):
exec('self.'+lo+'.reverse()')
self[:]=list(self.handles)
