def run(self,*args):
name = mc.textFieldGrp(self.name, q=True, tx=True)
joint = mc.intSliderGrp(self.joint, q=True, v=True)
obj = mc.ls(sl=True, o=True)
if name == '':
print 'ERROR!!'
return
for i in obj:
mc.select(i)
if mc.objectType(i) == 'mesh':
mc.hilite(i)
curves = mc.polyToCurve(usm=False, f=2, dg=1)
else:
curves = mc.duplicate(rr=True)
if mc.checkBoxGrp(self.reverse, q=True, v1=True):
mc.reverseCurve()
joints = []
for j in range(joint):
mc.select(cl=True)
joints.append(mc.joint(n=name))
mc.select(mc.ls(joints, curves, tr=True))
apg.positionAlongCurve()
for j in range(joint - 1):
mc.parent(joints[j + 1], joints[j])
mc.joint(joints[j], e=True, zso=True, oj='xyz', sao='yup')
if j == joint - 2:
mc.rename(joints[j + 1], name + '_end')
mc.delete(curves)
mc.select(cl=True)
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 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 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 nurbsCurve_reverse(*args):
'''{'path':'Surfaces/EditNURBS/nurbsCurve_reverse( )',
'icon':':/reverse.png',
'usage':"""
#先选择曲线，再选择一个物体，这个命令根据曲线和物体的远近，对这些曲线进行reverse操作
$fun( )"""
}
'''
if len(args):
curvesNode = args[0]
refPos = args[1]
else:
curvesNode = cmds.ls(sl=True, l=True)[:-1]
refPos = cmds.objectCenter(cmds.ls(sl=True, l=True)[-1])
for obj in curvesNode:
try:
startPos = cmds.pointOnCurve(obj, pr=0, ch=False, p=True)
endPos = cmds.pointOnCurve(obj, pr=1, ch=False, p=True)
startLen = math.sqrt(
math.pow(refPos[0] - startPos[0], 2) +
math.pow(refPos[1] - startPos[1], 2) +
math.pow(refPos[2] - startPos[2], 2))
endLen = math.sqrt(
math.pow(refPos[0] - endPos[0], 2) +
math.pow(refPos[1] - endPos[1], 2) +
math.pow(refPos[2] - endPos[2], 2))
if startLen > endLen:
cmds.reverseCurve(obj, ch=False, rpo=True)
print 'Reversed %s' % obj
except:
print obj, " is not nurbscurve!"
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 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 __braid(self):
steps, porcent = self.__voltas()
increment = porcent
eight = self.__makeEight()
list = range(int(steps))
offset = self.ui.spin_offset.value()
offset_normalize = offset/360.0
self.ui.progress_Create.setRange(0,len(list))
scale_0 = self.ui.spin_radius.value()
scale_1 = self.ui.spin_radius_1.value()
if (scale_0 >= scale_1):
scale_maior = scale_0
scale_menor = scale_1
else:
scale_maior = scale_1
scale_menor = scale_0
diference = scale_maior-scale_menor
percent = diference/steps
scale = scale_maior
if (self.ui.btn_reverse.isChecked()):
curva = self.ui.ln_path.text()
cmds.reverseCurve(curva,ch = False, replaceOriginal = True)
for i in list:
self.ui.progress_Create.setValue(i)
self.__next(porcent,eight,scale)
porcent += increment
_pos_A = (i*0.0625)%1.0 + offset_normalize
_pos_B = (i*0.0625+0.333333)%1.0 + offset_normalize
_pos_C = (i*0.0625+0.666666666)%1.0 + offset_normalize
self.__pt_position_A.append(cmds.pointOnCurve( eight[0],top = True, pr= _pos_A, p=True ))
self.__pt_position_B.append(cmds.pointOnCurve( eight[0],top = True, pr= _pos_B, p=True ))
self.__pt_position_C.append(cmds.pointOnCurve( eight[0],top = True, pr= _pos_C, p=True ))
scale -= percent
self.ui.progress_Create.reset()
#cmds.delete(self.__circle[0])
# return self.__pt_position
self.__curve()
cmds.delete(eight[0])
def sqCheckCurveDirection(self, thisCurve, *args):
posMinX = cmds.xform(thisCurve + ".cv[0]",
query=True,
worldSpace=True,
translation=True)[0]
posMaxX = cmds.xform(thisCurve + ".cv[" + str(self.curveLenght - 1) +
"]",
query=True,
worldSpace=True,
translation=True)[0]
if posMinX > posMaxX:
cmds.reverseCurve(thisCurve,
constructionHistory=False,
replaceOriginal=True)
def reverseCurve(*args):
sel = cmds.ls(sl=True, exactType="transform")
check = False
if sel:
for x in sel:
check = curveCheck(x)
if check:
cmds.reverseCurve(x, ch=False, replaceOriginal=True)
else:
cmds.warning("Must select some curves")
return
cmds.select(sel, r=True)
def LDRibbonTools_reverseCurve():
sel = cmds.ls(sl=1, o=1)
for i in sel:
shapeNode = cmds.listRelatives(i, s=1)
nodeType = cmds.nodeType(shapeNode)
if nodeType == 'nurbsCurve':
curveName = i
cmds.reverseCurve(curveName, ch=1, rpo=1)
else:
curveWarpName = cmds.listConnections(i, t='curveWarp')
if curveWarpName != None:
curveName = cmds.listConnections(curveWarpName, t='curveShape')
curveName = curveName[0]
cmds.reverseCurve(curveName, rpo=1)
cmds.select(sel, r=1)
def createCurve_circleFourArrows(self, name=""):
"""
Creates a nurbs curve in the shape of a circle with four arrows
Args:
Returns:
"""
startCurve1 = cmds.curve(d=3,
p=[(-0.448148, 0, -0.137417),
(-0.425577, 0, -0.210319),
(-0.345762, 0, -0.345408),
(-0.210765, 0, -0.425313),
(-0.138183, 0, -0.447335)],
k=[0, 0, 0, 1, 2, 2, 2])
startCurve2 = cmds.curve(d=1,
p=[(-0.138183, 0, -0.447335),
(-0.138183, 0, -0.552734),
(-0.276367, 0, -0.552734),
(0, 0, -0.829101),
(0.276367, 0, -0.552734),
(0.138183, 0, -0.552734),
(0.138183, 0, -0.447335)],
k=[0, 1, 2, 3, 4, 5, 6])
curve1 = cmds.attachCurve(startCurve1,
startCurve2,
replaceOriginal=0,
kmk=1,
ch=0)
cmds.delete(startCurve1, startCurve2)
curve2 = cmds.duplicate(curve1)
cmds.rotate(0, 90, 0, curve1)
curve3 = cmds.duplicate(curve1)
cmds.rotate(0, 180, 0, curve3)
curve4 = cmds.duplicate(curve1)
cmds.rotate(0, 270, 0, curve4)
attachCurve1 = cmds.attachCurve(curve1,
curve2,
replaceOriginal=0,
kmk=1,
ch=0)
attachCurve2 = cmds.attachCurve(curve3,
curve4,
replaceOriginal=0,
kmk=1,
ch=0)
cmds.delete(curve1, curve2, curve3, curve4)
attachCurve2 = cmds.reverseCurve(attachCurve2[0], ch=0, rpo=1)
newCurve = cmds.attachCurve(attachCurve1[0],
attachCurve2[0],
replaceOriginal=0,
kmk=1,
ch=0)
cmds.delete(attachCurve1[0], attachCurve2[0])
cmds.makeIdentity(newCurve, apply=1, t=1, r=1, s=1, n=0)
ret = cmds.rename(newCurve, name)
return ret
def snap_root_CV_to_mesh(*args):
'''
Snap root CV of curve to closest point on mesh for selected mesh
and curves which are currently selected.
'''
initialSelection = cmds.ls(sl=True)
scalpMesh = cmds.ls(sl=True, dag=True, type='mesh')[0]
curveSet = cmds.listRelatives(cmds.ls(sl=True, dag=True, type='nurbsCurve'), parent=True)
CPOM_A = cmds.createNode('closestPointOnMesh')
CPOM_B = cmds.createNode('closestPointOnMesh')
cmds.connectAttr(scalpMesh+'.outMesh', CPOM_A+'.inMesh')
cmds.connectAttr(scalpMesh+'.outMesh', CPOM_B+'.inMesh')
for CRV in curveSet:
#CRV = curveSet[0]
curveLen = int(cmds.arclen(CRV)/3+4)
rebuildCRV = cmds.rebuildCurve(CRV, d=3, spans=curveLen)
#print CRV
CRVroot = cmds.pointPosition(CRV+'.cv[0]', world=True)
CRVvec = cmds.pointPosition(CRV+'.cv[2]', world=True)
abc = ['X', 'Y', 'Z']
for x in abc:
cmds.setAttr(CPOM_A+'.inPosition'+x, CRVroot[abc.index(x)])
cmds.setAttr(CPOM_B+'.inPosition'+x, CRVvec[abc.index(x)])
CPOM_rootPOS = cmds.getAttr(CPOM_A+'.position')[0]
CPOM_vecPOS = cmds.getAttr(CPOM_B+'.position')[0]
#print CRV, CRVroot, CPOM_POS
cmds.reverseCurve(CRV)
CRVcvs = cmds.getAttr(CRV+'.spans')
#print CRV, curveLen, CRVcvs, rebuildCRV
cmds.delete(CRV, constructionHistory=True)
CRVshape = cmds.listRelatives(CRV, children=True)
cmds.curve(CRVshape, a=True, ws=True, p=[CPOM_vecPOS, CPOM_rootPOS])#[(0,0,0) for x in range(CRVcvs/5)])
cmds.reverseCurve(CRV)
cmds.rebuildCurve(CRV, degree=3, spans=CRVcvs+2)
cmds.smoothCurve(CRV+'.cv[*]', smoothness=10)
#break
cmds.select(initialSelection)
def reverseCrv(*args):
sel = cmds.ls(sl=True)[0]
shp = cmds.listRelatives(sel, shapes=True)
if cmds.objectType(shp) != "nurbsCurve":
cmds.warning("not a nurbs curve to reverse")
else:
revCrv = cmds.reverseCurve(sel, rpo=True, ch=False)[0]
cmds.select(revCrv)
print("reversed curve: %s!" % revCrv)
def create_turntable(self):
"""Automatically creates 360 degree turntable with lights relative to object size"""
# Creates object selection which selects current object in panel view
objectSelection = cmds.ls(sl=True)
bBox = cmds.exactWorldBoundingBox(objectSelection)
objectDistance = cmds.shadingNode('distanceBetween', asUtility=True)
locator1 = cmds.spaceLocator()
locatorShape1 = cmds.listRelatives(locator1[0], shapes=True)
locator2 = cmds.spaceLocator()
locatorShape2 = cmds.listRelatives(locator2[0], shapes=True)
#Creates ground cylinder for selected object.
objectGround = cmds.polyCylinder(axis=[0, 1, 0], height=bBox[4] / 10.0, radius=bBox[3] * 2.5, subdivisionsX=30,
subdivisionsZ=1, n='turntableGround')
cmds.setAttr(objectGround[0] + '.translateY', bBox[1] - (bBox[4] / 10.0) / 2)
cmds.parent(locator2[0], objectSelection[0])
cmds.setAttr(locator1[0] + '.translateX', 0)
cmds.setAttr(locator1[0] + '.translateY', 0)
cmds.setAttr(locator1[0] + '.translateZ', 0)
cmds.setAttr(locator2[0] + '.translateX', 0)
cmds.setAttr(locator2[0] + '.translateY', 0)
cmds.setAttr(locator2[0] + '.translateZ', 0)
cmds.connectAttr(locatorShape1[0] + '.worldPosition', objectDistance + '.point1')
cmds.connectAttr(locatorShape2[0] + '.worldPosition', objectDistance + '.point2')
#Creates nurb circle for the turntable and adjusts position based on object selected.
cameraCircle = cmds.circle(radius = bBox[3] * 9, sections = 50)
cmds.setAttr(cameraCircle[0] + '.rotateX', 90)
cmds.reverseCurve(cameraCircle[0])
cmds.setAttr(cameraCircle[0] + '.translateY', bBox[1] - (bBox[4] / 10.0) / 2)
cmds.select(cameraCircle, r=True)
cmds.move(0, 5, 0)
#Creates turntable camera and groups the camera, circle, and ground.
cmds.camera(n='turntableCamera')
cmds.group('nurbsCircle1', 'turntableCamera1', 'turntableGround', n='cameraSetup')
# Creates a path animation based on the objects 'turntableCamera1' and 'cameraCircle'
cmds.pathAnimation('turntableCamera1', cameraCircle[0], fractionMode=True, follow=True, followAxis='x', upAxis='y',
worldUpType='vector', worldUpVector=[0, 1, 0], inverseUp=False, inverseFront=False,
bank=False, startTimeU=1, endTimeU=120)
cmds.delete('locator1', 'locator2')
def polytoCurve(self):
blist = cmds.ls(sl=1)
for i in blist:
vnum = cmds.polyEvaluate(i, v=1)
for v in range(vnum):
enum = cmds.ls(cmds.polyListComponentConversion(i + '.vtx[' + str(v) + ']', fv=1, ff=1, fuv=1, fvf=1, te=1), fl=1)
if len(enum) == 4:
break
arclen = []
for e in enum:
elist = cmds.polySelectSp(e, q=1, loop=1)
earclen = 0.0
for el in elist:
earclen += cmds.arclen(el)
arclen.append(earclen)
cmds.polySelectSp(enum[arclen.index(max(arclen))], loop=1)
cname = cmds.rename(cmds.polyToCurve(
ch=0, form=2, degree=3), i + '_Cur')
if cmds.xform(cname + '.cv[0]', q=1, ws=1, t=1)[1] < cmds.xform(cname + '.cv[' + str(cmds.getAttr(cname + ".controlPoints", size=1)) + ']', q=1, ws=1, t=1)[1]:
cmds.reverseCurve(cname, ch=0, rpo=1)
def dpSetCurveDirection(self, curveName, *args):
""" Check and set the curve direction.
Reverse curve direction if the first CV position is greather than last CV position by current axis.
"""
cmds.setAttr(curveName + "." + ZIPPER_ATTR, 0)
cmds.select(curveName + ".cv[*]")
curveLength = len(cmds.ls(selection=True, flatten=True))
cmds.select(clear=True)
minPos = cmds.xform(curveName + ".cv[0]",
query=True,
worldSpace=True,
translation=True)[self.curveAxis]
maxPos = cmds.xform(curveName + ".cv[" + str(curveLength - 1) + "]",
query=True,
worldSpace=True,
translation=True)[self.curveAxis]
if minPos > maxPos:
cmds.reverseCurve(curveName,
constructionHistory=True,
replaceOriginal=True)
cmds.rename(
cmds.listConnections(curveName + ".create")[0],
utils.extractSuffix(curveName) + "_" + self.curveDirection +
"_RevC")
def execute(self):
sx = self.sx
sy = self.sy
sdv = self.sdv
sdu = self.sdu
tap = self.tap
degs = self.degs
subCurve = self.subCurve
clean = self.clean
do_uvs = self.do_uvs
rbc = self.rbc
cTol = self.cTol
cSubd = self.cSubd
if cmds.checkBox(self.aUACCB, q=True, v=True):
useAltShape = True
else:
useAltShape = False
multSel = cmds.ls(sl=True,fl=True, ap=True)
if cmds.objectType(multSel[0]) == 'mesh':
thisIsAMesh = True
else:
thisIsAMesh = False
# Select curve type to extrude along - convert and store
for x in multSel:
print x
if thisIsAMesh != True:
cmds.select(x)
else:
cmds.select(multSel)
objSel = cmds.ls(sl=True,fl=True, ap=True)
if self.ko == 1:
dupObj = cmds.duplicate(objSel)
objSel = dupObj
if len(objSel) > 1:
print objSel
if degs == 0:
curveDg = cmds.promptDialog(t='Enter Degrees:', m='Enter Degrees - ie. 1 for linear, 3 for curved')
objSel = cmds.polyToCurve(f=2, dg=int(cmds.promptDialog(q=True, tx=True)))
else:
objSel = cmds.polyToCurve(f=2, dg=int(degs), n='%s_curve' %objSel[0].split('.')[0])
else:
objType = cmds.listRelatives(objSel[0], f=True)
if cmds.objectType(objType[0]) != 'nurbsCurve' and cmds.objectType(objType[0]) != 'bezierCurve':
cmds.error('Select the nurbs curve first, then the object to align')
if cmds.objectType(objType[0]) == 'bezierCurve':
mm.eval("bezierCurveToNurbs;")
# Create a nurbs curve for the extrusion
if useAltShape:
nurbsCir = self.objToUse
else:
nurbsCir = cmds.circle(n='extrudeCircle', d=3, r=1, nr=(0,0,1), sw=360, ch=True, s=8)
objCV = cmds.ls('%s.ep[*]' %objSel[0], fl=True)
noOfCV = len(objCV)
firstCV = 0
lastCV = noOfCV - 1
cvNumberToUse=firstCV
# Rebuild the curve to help with uniformity
if self.rev == 1:
cmds.reverseCurve(objSel[0], ch=0, rpo=1)
if rbc == 1:
try:
cmds.rebuildCurve(objSel[0], ch=0,rpo=1,rt=4,end=1,kr=0, kcp=0, kep=1, kt=0, s=cSubd, d=3, tol=cTol)
cmds.rebuildCurve(objSel[0], ch=0,rpo=1,rt=0,end=1,kr=0, kcp=0, kep=1, kt=0, s=cSubd, d=3, tol=cTol)
except:
cmds.warning('Tolerance for rebuild likely to low, try a higher value or turn Rebuild Curve off')
if do_uvs == 1:
objShape = cmds.listRelatives(objSel[0], c=True, type='shape')
mInfo = cmds.shadingNode('curveInfo', n='cMeasure', asUtility=True)
cmds.connectAttr('%s.local' %objShape[0], '%s.inputCurve' %mInfo)
curveLength = cmds.getAttr('%s.arcLength' %mInfo)
cmds.delete(mInfo)
self.uvRatio = float((((sx * sy)*2.0) * math.pi) / curveLength)
print "uvRatio: " + str(self.uvRatio)
# Create a tangent contraint to position nurbs circle to the first cv
cvPos = cmds.xform('%s.ep[%d]' %(objSel[0],cvNumberToUse), query=True, ws=True, t=True)
cmds.xform(nurbsCir[0], ws=True, t=(cvPos[0],cvPos[1],cvPos[2]))
fastCon = cmds.tangentConstraint(objSel[0], nurbsCir[0], aim=(0,0,1))
cmds.delete(fastCon[0])
# Extrude along curve and set attributes
pipeExt = cmds.extrude(nurbsCir[0], objSel[0], n='%s_pipe' %objSel[0], ch=True, rn=subCurve, po=1, et=2, ucp=1, fpt=1,upn=1, rotation=0, scale=1,rsp=1)
pipeTes = cmds.listConnections(pipeExt[1], type='nurbsTessellate')
if subCurve != 0:
pipeSubCurve = cmds.listConnections(pipeExt[1], type='subCurve')
cmds.setAttr('%s.format' %pipeTes[0],2)
cmds.setAttr('%s.polygonType' %pipeTes[0],1)
cmds.setAttr('%s.uType' %pipeTes[0],2)
cmds.setAttr('%s.vType' %pipeTes[0],2)
cmds.setAttr('%s.vNumber' %pipeTes[0],sdv)
cmds.setAttr('%s.uNumber' %pipeTes[0],sdu)
# Add attributes
if clean == 0:
cmds.addAttr(pipeExt[0], ln='________', k=True)
cmds.setAttr('%s.________' %pipeExt[0], l=True)
cmds.addAttr(pipeExt[0], ln='Ext_ScaleX', k=True, dv=sx)
cmds.addAttr(pipeExt[0], ln='Ext_ScaleY', k=True, dv=sy)
cmds.connectAttr('%s.Ext_ScaleX' %pipeExt[0], '%s.scaleX' %nurbsCir[0])
cmds.connectAttr('%s.Ext_ScaleY' %pipeExt[0], '%s.scaleY' %nurbsCir[0])
cmds.addAttr(pipeExt[0], ln='Ext_DivisionV', at='short', k=True, dv=sdv)
cmds.connectAttr('%s.Ext_DivisionV' %pipeExt[0], '%s.vNumber' %pipeTes[0])
cmds.addAttr(pipeExt[0], ln='Ext_DivisionU', at='short', k=True, dv=sdu)
cmds.connectAttr('%s.Ext_DivisionU' %pipeExt[0], '%s.uNumber' %pipeTes[0])
if subCurve != 0:
cmds.addAttr(pipeExt[0], ln='Ext_Length', k=True, dv=1, max=1, min=0)
cmds.connectAttr('%s.Ext_Length' %pipeExt[0], '%s.maxValue' %pipeSubCurve[1])
cmds.addAttr(pipeExt[0], ln='Ext_Taper', k=True, dv=tap, min=0)
cmds.connectAttr('%s.Ext_Taper' %pipeExt[0], '%s.scale' %pipeExt[1])
cmds.addAttr(pipeExt[0], ln='Ext_Twist', k=True, dv=1)
cmds.connectAttr('%s.Ext_Twist' %pipeExt[0], '%s.rotation' %pipeExt[1])
cmds.addAttr(pipeExt[0], ln='Ext_ComponentPivot', k=True, dv=1)
cmds.connectAttr('%s.Ext_ComponentPivot' %pipeExt[0], '%s.useComponentPivot' %pipeExt[1])
curveGrpNode = cmds.createNode('transform', n='pipeCurves')
cmds.parent(nurbsCir, curveGrpNode)
cmds.parent(objSel, curveGrpNode)
cmds.setAttr('%s.inheritsTransform' %curveGrpNode, 0)
cmds.setAttr('%s.visibility' %curveGrpNode, 1)
cmds.parent(curveGrpNode, pipeExt[0])
cmds.select(pipeExt[0])
if do_uvs == 1:
cmds.polyLayoutUV(ps=0.2)
cmds.polyEditUV(sv=1, su=self.uvRatio)
cmds.polyEditUV(sv=0.95, su=0.95)
cmds.select(pipeExt[0])
CentreUVs()
if clean == 1:
cmds.delete(ch=True)
cmds.delete(curveGrpNode)
cmds.select(pipeExt[0])
if thisIsAMesh == True:
print 'hello'
break
def cutCurve( curve, mesh, loopCheck = False ):
fnMesh = getMFnMesh( mesh )
fnCurve = getMFnCurve( curve )
meshIntersector = om.MMeshIntersector()
meshIntersector.create( fnMesh.object() )
meshMtx = fnMesh.dagPath().inclusiveMatrix()
curveMtx = fnCurve.dagPath().inclusiveMatrix()
toMeshLocalMtx = curveMtx*meshMtx.inverse()
numSpans = fnCurve.numSpans()
maxParam = fnCurve.findParamFromLength( fnCurve.length() )
paramRate = maxParam / ( numSpans-1 )
point = om.MPoint()
pointOnMesh = om.MPointOnMesh()
closestParam = 0.0
for i in range( numSpans ):
fnCurve.getPointAtParam( paramRate*i, point )
toMeshPoint = point*toMeshLocalMtx
meshIntersector.getClosestPoint( toMeshPoint, pointOnMesh )
closePoint = om.MPoint( pointOnMesh.getPoint() )
normal = om.MVector( pointOnMesh.getNormal() )
closePivVector = om.MVector( toMeshPoint )-om.MVector( closePoint )
if closePivVector*normal < 0:
closestParam = paramRate*i
else:
if i == 0:
if loopCheck: return None
cmds.reverseCurve( curve, ch=0, rpo=1 )
cutCurve( curve, mesh, True )
i = 0
addParam = 1
while i < 100:
fnCurve.getPointAtParam( closestParam, point )
toMeshPoint = point*toMeshLocalMtx
meshIntersector.getClosestPoint( toMeshPoint, pointOnMesh )
closePoint = om.MPoint( pointOnMesh.getPoint() )
cuDist = closePoint.distanceTo( toMeshPoint )
if cuDist < 0.0001: break
normal = om.MVector( pointOnMesh.getNormal() )
closePivVector = om.MVector( toMeshPoint ) - om.MVector( closePoint )
if closePivVector*normal > 0:
addParam = math.fabs( addParam ) * -0.5
else:
addParam = math.fabs( addParam ) * 0.5
closestParam += addParam
i+=1
fnCurve.getPointAtParam( closestParam, point )
first, second = cmds.detachCurve( "%s.u[%f]" %( curve, closestParam ), ch=0, cos=True, rpo=0 )
curveObj = cmds.listRelatives( curve, p=1 )[0]
cmds.delete( first, curveObj )
second = cmds.rename( second, curveObj )
cmds.select( second )
cmds.DeleteHistory()
def __func__(self):
"""
"""
_str_funcName = self._str_funcCombined
curve = self.d_kws['curve']
points = self.d_kws['points']
mi_crv = cgmMeta.validateObjArg(self.d_kws['curve'],cgmMeta.cgmObject,mayaType='nurbsCurve',noneValid=False)
int_points = cgmValid.valueArg(self.d_kws['points'],minValue=1,calledFrom = _str_funcName)
f_insetSplitFactor = cgmValid.valueArg(self.d_kws['insetSplitFactor'],calledFrom = _str_funcName)
f_startSplitFactor = cgmValid.valueArg(self.d_kws['startSplitFactor'],calledFrom = _str_funcName)
f_kwMinU = cgmValid.valueArg(self.d_kws['minU'], noneValid=True, calledFrom = _str_funcName)
f_kwMaxU = cgmValid.valueArg(self.d_kws['maxU'], noneValid=True, calledFrom = _str_funcName)
f_points = float(int_points)
int_spans = int(cgmValid.valueArg(self.d_kws['points'],minValue=5,autoClamp=True,calledFrom = _str_funcName))
b_rebuild = cgmValid.boolArg(self.d_kws['rebuildForSplit'],calledFrom = _str_funcName)
b_markPoints = cgmValid.boolArg(self.d_kws['markPoints'],calledFrom = _str_funcName)
b_reverseCurve = cgmValid.boolArg(self.d_kws['reverseCurve'],calledFrom = _str_funcName)
try:#>>> Rebuild curve
if b_rebuild:
useCurve = mc.rebuildCurve (curve, ch=0, rpo=0, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=int_spans, d=3, tol=0.001)[0]
else:
useCurve = mc.duplicate(curve)[0]
if b_reverseCurve:
useCurve = mc.reverseCurve(useCurve,rpo = True)[0]
except Exception,error:raise StandardError,"Rebuild fail | %s"%error
try:#>>> Divide stuff
#==========================
l_spanUPositions = []
str_bufferU = mc.ls("%s.u[*]"%useCurve)[0]
log.debug("%s >> u list : %s"%(_str_funcName,str_bufferU))
f_maxU = float(str_bufferU.split(':')[-1].split(']')[0])
l_uValues = [0]
if points == 1:
l_uValues = [f_maxU/2]
elif f_startSplitFactor is not False:
if points < 5:
raise StandardError,"Need at least 5 points for startSplitFactor. Points : %s"%(points)
log.debug("%s >> f_startSplitFactor : %s"%(_str_funcName,f_startSplitFactor))
#Figure out our u's
f_base = f_startSplitFactor * f_maxU
l_uValues.append( f_base )
f_len = f_maxU - (f_base *2)
int_toMake = f_points-4
f_factor = f_len/(int_toMake+1)
log.debug("%s >> f_maxU : %s"%(_str_funcName,f_maxU))
log.debug("%s >> f_len : %s"%(_str_funcName,f_len))
log.debug("%s >> int_toMake : %s"%(_str_funcName,int_toMake))
log.debug("%s >> f_base : %s"%(_str_funcName,f_base))
log.debug("%s >> f_factor : %s"%(_str_funcName,f_factor))
for i in range(1,int_points-3):
l_uValues.append(((i*f_factor + f_base)))
l_uValues.append(f_maxU - f_base)
l_uValues.append(f_maxU)
log.debug("%s >> l_uValues : %s"%(_str_funcName,l_uValues))
elif f_insetSplitFactor is not False:
log.debug("%s >> f_insetSplitFactor : %s"%(_str_funcName,f_insetSplitFactor))
#Figure out our u's
f_base = f_insetSplitFactor * f_maxU
f_len = f_maxU - (f_base *2)
f_factor = f_len/(f_points-1)
log.debug("%s >> f_maxU : %s"%(_str_funcName,f_maxU))
log.debug("%s >> f_len : %s"%(_str_funcName,f_len))
log.debug("%s >> f_base : %s"%(_str_funcName,f_base))
log.debug("%s >> f_factor : %s"%(_str_funcName,f_factor))
for i in range(1,int_points-1):
l_uValues.append((i*f_factor))
l_uValues.append(f_maxU)
log.debug("%s >> l_uValues : %s"%(_str_funcName,l_uValues))
elif f_kwMinU is not False or f_kwMaxU is not False:
log.debug("%s >> Sub mode. "%(_str_funcName))
if f_kwMinU is not False:
if f_kwMinU > f_maxU:
raise StandardError, "kw minU value(%s) cannot be greater than maxU(%s)"%(f_kwMinU,f_maxU)
f_useMinU = f_kwMinU
else:f_useMinU = 0.0
if f_kwMaxU is not False:
if f_kwMaxU > f_maxU:
raise StandardError, "kw maxU value(%s) cannot be greater than maxU(%s)"%(f_kwMaxU,f_maxU)
f_useMaxU = f_kwMaxU
else:f_useMaxU = f_maxU
if int_points == 1:
l_uValues = [(f_useMaxU - f_useMinU)/2]
elif int_points == 2:
l_uValues = [f_useMaxU,f_useMinU]
else:
l_uValues = [f_useMinU]
f_factor = (f_useMaxU - f_useMinU)/(f_points-1)
log.debug("%s >> f_maxU : %s"%(_str_funcName,f_useMaxU))
log.debug("%s >> f_factor : %s"%(_str_funcName,f_factor))
for i in range(1,int_points-1):
l_uValues.append((i*f_factor) + f_useMinU)
l_uValues.append(f_useMaxU)
else:
#Figure out our u's
log.debug("%s >> Regular mode. Points = %s "%(_str_funcName,int_points))
if int_points == 3:
l_uValues.append(f_maxU/2)
l_uValues.append(f_maxU)
else:
f_factor = f_maxU/(f_points-1)
log.debug("%s >> f_maxU : %s"%(_str_funcName,f_maxU))
log.debug("%s >> f_factor : %s"%(_str_funcName,f_factor))
for i in range(1,int_points-1):
l_uValues.append(i*f_factor)
l_uValues.append(f_maxU)
log.debug("%s >> l_uValues : %s"%(_str_funcName,l_uValues))
except Exception,error:raise StandardError,"Divide fail | %s"%error
for u in l_uValues:
try:l_spanUPositions.append(mc.pointPosition("%s.u[%f]"%(useCurve,u)))
except StandardError,error:raise StandardError,"Failed on pointPositioning: %s"%u
log.debug("%s >> l_spanUPositions | len: %s | list: %s"%(_str_funcName,len(l_spanUPositions),l_spanUPositions))
try:
if b_markPoints:
ml_built = []
for i,pos in enumerate(l_spanUPositions):
buffer = mc.spaceLocator(n = "%s_u_%f"%(useCurve,(l_uValues[i])))[0]
ml_built.append( cgmMeta.cgmObject(buffer))
log.debug("%s >> created : %s | at: %s"%(_str_funcName,ml_built[-1].p_nameShort,pos))
mc.xform(ml_built[-1].mNode, t = (pos[0],pos[1],pos[2]), ws=True)
if len(ml_built)>1:
try:f_distance = distance.returnAverageDistanceBetweenObjects([o.mNode for o in ml_built]) * .5
except StandardError,error:raise StandardError,"Average distance fail. Objects: %s| error: %s"%([o.mNode for o in ml_built],error)
try:
for o in ml_built:
o.scale = [f_distance,f_distance,f_distance]
except StandardError,error:raise StandardError,"Scale fail : %s"%error
except StandardError,error:log.error("Mark points fail. error : %s"%(error))
mc.delete(useCurve)#Delete our use curve
return l_spanUPositions
def _create(self):
mi_base = self.mi_baseCurve
mi_target = self.mi_targetCurve
self.l_baseCvPos = []
self.d_base = self.getCurveMirrorData(mi_base)
if not mi_target:#if no target, mirror self
if not self.d_base['b_oneSided']:
if self.d_base['b_even']:
log.info("%s Even mirror"%self._str_reportStart)
l_cvPos = self.d_base['l_cvPos']
l_cvs = self.d_base['l_cvs']
int_split = int(len(l_cvPos)/2)
log.info(int_split)
l_splitDriven = l_cvs[int_split:]
l_splitDriver = l_cvs[:int_split]
l_splitDriverPos = l_cvPos[:int_split]
l_splitDriverPos.reverse()
log.info("%s l_splitDriven: %s"%(self._str_reportStart,l_splitDriven))
log.info("%s l_splitDriver: %s"%(self._str_reportStart,l_splitDriver))
for i,cv in enumerate(l_splitDriven):
pos = l_splitDriverPos[i]
mc.move(-pos[0],pos[1],pos[2], cv, ws=True)
return True
else:
log.info("%s nonEven mirror"%self._str_reportStart)
l_cvPos = self.d_base['l_cvPos']
l_cvs = self.d_base['l_cvs']
int_split = int(len(l_cvPos)/2)
l_cvPos.pop(int_split)
l_cvs.pop(int_split)
l_splitDriven = l_cvs[int_split:]
l_splitDriver = l_cvs[:int_split]
l_splitDriverPos = l_cvPos[:int_split]
l_splitDriverPos.reverse()
log.info("%s l_splitDriven: %s"%(self._str_reportStart,l_splitDriven))
log.info("%s l_splitDriver: %s"%(self._str_reportStart,l_splitDriver))
for i,cv in enumerate(l_splitDriven):
pos = l_splitDriverPos[i]
mc.move(-pos[0],pos[1],pos[2], cv, ws=True)
return True
else:#it's one sided
log.info("%s Build other side. New crv"%self._str_reportStart)
l_epPos = self.d_base['l_epPos']
l_otherSide = copy.copy(l_epPos)
l_otherSide.reverse()
for i,pos in enumerate(l_otherSide):
l_otherSide[i] = [-pos[0],pos[1],pos[2]]
#l_newCurvePos = l_epPos + l_otherSide
l_newCurvePos = l_otherSide
l_newCurvePos = lists.returnListNoDuplicates(l_newCurvePos)
self.mi_created = cgmMeta.cgmObject( mc.curve(d=2,p=l_newCurvePos,os = True) )
self.mi_created.rename( mi_base.p_nameBase + '_mirrored')
#
if self.d_base['b_startInThreshold'] or self.d_base['b_endInThreshold']:
#In this case we need to combine and rebuild the curve
try:
str_attachedCurves = mc.attachCurve([self.mi_created.mNode,self.mi_baseCurve.mNode],
blendBias = self.d_kws['blendBias'])
except Exception,error:raise StandardError,"Attach curve | %s"%error
#mc.delete(self.mi_created.mNode)#delete the old one
#self.mi_created = cgmMeta.cgmObject(str_attachedCurves[0])
#int_spans = (len(l_epPos)*1.5)
int_spans = len(l_epPos)+1
try:
mc.rebuildCurve (self.mi_created.mNode, ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=int_spans, d=3, tol=0.001)
except Exception,error:raise StandardError,"Rebuild curve | %s"%error
try:
mc.reverseCurve (self.mi_created.mNode, rpo=1)
except Exception,error:raise StandardError,"Reverse curve | %s"%error
self.mi_created.rename( mi_base.p_nameBase + '_mirrored')
return self.mi_created.p_nameShort
#See if we need to make new curve to have stuff to mirror
else:#if we have a target
self.d_target = self.getCurveMirrorData(mi_target)
l_cvsBase = self.d_base['l_cvs']
l_cvsTarget = self.d_target['l_cvs']
if len(l_cvsBase) != len(l_cvsTarget):
raise NotImplementedError,"Haven't added ability to do curves of differing cv lengths yet"
for i,pos in enumerate(self.d_base['l_cvPos']):
mc.move(-pos[0],pos[1],pos[2], l_cvsTarget[i], ws=True)
return True
def createConveyerBeltSet( meshName, firstEdgeIndex, secondEdgeIndex ):
firstEdges = cmds.polySelectSp( meshName+'.e[%d]' % firstEdgeIndex, loop=1 )
secondEdges = cmds.polySelectSp( meshName+'.e[%d]' % secondEdgeIndex, loop=1 )
cmds.select( firstEdges )
firstCurve = cmds.polyToCurve( form=2, degree=3, n=meshName+'_loopCurve_First' )[0]
cmds.select( secondEdges )
secondCurve = cmds.polyToCurve( form=2, degree=3, n=meshName+'_loopCurve_Second' )[0]
firstCurveShape = sgModelDag.getShape( firstCurve )
secondCurveShape = sgModelDag.getShape( secondCurve )
firstSpans = cmds.getAttr( firstCurveShape +'.spans' )
secondSpans = cmds.getAttr( secondCurveShape+'.spans' )
firstTangent = sgModelCurve.getTangentAtParam( firstCurveShape, 0.0 )
firstParamPoint = sgModelCurve.getPointAtParam( firstCurveShape, 0.0 )
secondParam = sgModelCurve.getParamAtPoint( secondCurveShape, firstParamPoint )
secondTangent = sgModelCurve.getTangentAtParam( secondCurveShape, secondParam )
if firstTangent * secondTangent < 0:
cmds.reverseCurve( secondCurve, ch = 1, rpo = 1 )
firstPointers = sgRigCurve.createRoofPointers( firstCurve, firstSpans )
secondPointers = sgRigCurve.createRoofPointers( secondCurve, secondSpans )
fPos = cmds.xform( firstPointers[0], q=1, ws=1, t=1 )
minDistPointer = secondPointers[0]
minDist = 1000000000.0
for secondPointer in secondPointers:
sPos = cmds.xform( secondPointer, q=1, ws=1, t=1 )
dist = (fPos[0]-sPos[0])**2+(fPos[1]-sPos[1])**2+(fPos[2]-sPos[2])**2
if dist < minDist:
minDistPointer = secondPointer
minDist = dist
offset = int( minDistPointer.split( '_' )[-1] )
crvs = []
for i in range( len( firstPointers ) ):
firstPointer = firstPointers[i]
secondPointer = '_'.join( secondPointers[i].split( '_' )[:-1] ) + '_%d' %( (i + offset)%firstSpans )
crv = sgRigCurve.createCurveOnTargetPoints( [firstPointer, secondPointer] )
crv = cmds.rename( crv, meshName+'_line_%d' % i )
crvs.append( crv )
cmds.select( crvs )
loftSurf = cmds.loft( n=meshName+'_loft' )[0]
resultObject = cmds.nurbsToPoly( loftSurf ,mnd=1 ,ch=1,f=3,pt=0,pc=200,chr=0.9,ft=0.01,mel=0.001, d=0.1,
ut=1, un=3, vt=1, vn=3, uch=0, ucr=0, cht=0.2, es=0,ntr=0,mrt=0, uss=1, n=meshName+'_conveyorBelt' )
crvGrp = cmds.group( crvs, n=meshName+'_lines' )
conveyorRig = cmds.group( firstCurve, secondCurve, crvGrp, loftSurf, resultObject, meshName, n=meshName+'_conveyorRig' )
import sgRigAttribute
sgRigAttribute.addAttr( conveyorRig, ln='offset', k=1 )
cmds.connectAttr( conveyorRig+'.offset', firstCurve+'.roofValue' )
cmds.connectAttr( conveyorRig+'.offset', secondCurve+'.roofValue' )
cmds.setAttr( conveyorRig+'.v', 0 )
def execute(self):
sx = self.sx
sy = self.sy
sdv = self.sdv
sdu = self.sdu
tap = self.tap
degs = self.degs
subCurve = self.subCurve
clean = self.clean
do_uvs = self.do_uvs
rbc = self.rbc
cTol = self.cTol
cSubd = self.cSubd
if cmds.checkBox(self.aUACCB, q=True, v=True):
useAltShape = True
else:
useAltShape = False
multSel = cmds.ls(sl=True, fl=True, ap=True)
if cmds.objectType(multSel[0]) == 'mesh':
thisIsAMesh = True
else:
thisIsAMesh = False
# Select curve type to extrude along - convert and store
for x in multSel:
print x
if thisIsAMesh != True:
cmds.select(x)
else:
cmds.select(multSel)
objSel = cmds.ls(sl=True, fl=True, ap=True)
if self.ko == 1:
dupObj = cmds.duplicate(objSel)
objSel = dupObj
if len(objSel) > 1:
print objSel
if degs == 0:
curveDg = cmds.promptDialog(
t='Enter Degrees:',
m='Enter Degrees - ie. 1 for linear, 3 for curved')
objSel = cmds.polyToCurve(f=2,
dg=int(
cmds.promptDialog(q=True,
tx=True)))
else:
objSel = cmds.polyToCurve(f=2,
dg=int(degs),
n='%s_curve' %
objSel[0].split('.')[0])
else:
objType = cmds.listRelatives(objSel[0], f=True)
if cmds.objectType(
objType[0]) != 'nurbsCurve' and cmds.objectType(
objType[0]) != 'bezierCurve':
cmds.error(
'Select the nurbs curve first, then the object to align'
)
if cmds.objectType(objType[0]) == 'bezierCurve':
mm.eval("bezierCurveToNurbs;")
# Create a nurbs curve for the extrusion
if useAltShape:
nurbsCir = self.objToUse
else:
nurbsCir = cmds.circle(n='extrudeCircle',
d=3,
r=1,
nr=(0, 0, 1),
sw=360,
ch=True,
s=8)
objCV = cmds.ls('%s.ep[*]' % objSel[0], fl=True)
noOfCV = len(objCV)
firstCV = 0
lastCV = noOfCV - 1
cvNumberToUse = firstCV
# Rebuild the curve to help with uniformity
if self.rev == 1:
cmds.reverseCurve(objSel[0], ch=0, rpo=1)
if rbc == 1:
try:
cmds.rebuildCurve(objSel[0],
ch=0,
rpo=1,
rt=4,
end=1,
kr=0,
kcp=0,
kep=1,
kt=0,
s=cSubd,
d=3,
tol=cTol)
cmds.rebuildCurve(objSel[0],
ch=0,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=0,
s=cSubd,
d=3,
tol=cTol)
except:
cmds.warning(
'Tolerance for rebuild likely to low, try a higher value or turn Rebuild Curve off'
)
if do_uvs == 1:
objShape = cmds.listRelatives(objSel[0], c=True, type='shape')
mInfo = cmds.shadingNode('curveInfo',
n='cMeasure',
asUtility=True)
cmds.connectAttr('%s.local' % objShape[0],
'%s.inputCurve' % mInfo)
curveLength = cmds.getAttr('%s.arcLength' % mInfo)
cmds.delete(mInfo)
self.uvRatio = float(
(((sx * sy) * 2.0) * math.pi) / curveLength)
print "uvRatio: " + str(self.uvRatio)
# Create a tangent contraint to position nurbs circle to the first cv
cvPos = cmds.xform('%s.ep[%d]' % (objSel[0], cvNumberToUse),
query=True,
ws=True,
t=True)
cmds.xform(nurbsCir[0], ws=True, t=(cvPos[0], cvPos[1], cvPos[2]))
fastCon = cmds.tangentConstraint(objSel[0],
nurbsCir[0],
aim=(0, 0, 1))
cmds.delete(fastCon[0])
# Extrude along curve and set attributes
pipeExt = cmds.extrude(nurbsCir[0],
objSel[0],
n='%s_pipe' % objSel[0],
ch=True,
rn=subCurve,
po=1,
et=2,
ucp=1,
fpt=1,
upn=1,
rotation=0,
scale=1,
rsp=1)
pipeTes = cmds.listConnections(pipeExt[1], type='nurbsTessellate')
if subCurve != 0:
pipeSubCurve = cmds.listConnections(pipeExt[1],
type='subCurve')
cmds.setAttr('%s.format' % pipeTes[0], 2)
cmds.setAttr('%s.polygonType' % pipeTes[0], 1)
cmds.setAttr('%s.uType' % pipeTes[0], 2)
cmds.setAttr('%s.vType' % pipeTes[0], 2)
cmds.setAttr('%s.vNumber' % pipeTes[0], sdv)
cmds.setAttr('%s.uNumber' % pipeTes[0], sdu)
# Add attributes
if clean == 0:
cmds.addAttr(pipeExt[0], ln='________', k=True)
cmds.setAttr('%s.________' % pipeExt[0], l=True)
cmds.addAttr(pipeExt[0], ln='Ext_ScaleX', k=True, dv=sx)
cmds.addAttr(pipeExt[0], ln='Ext_ScaleY', k=True, dv=sy)
cmds.connectAttr('%s.Ext_ScaleX' % pipeExt[0],
'%s.scaleX' % nurbsCir[0])
cmds.connectAttr('%s.Ext_ScaleY' % pipeExt[0],
'%s.scaleY' % nurbsCir[0])
cmds.addAttr(pipeExt[0],
ln='Ext_DivisionV',
at='short',
k=True,
dv=sdv)
cmds.connectAttr('%s.Ext_DivisionV' % pipeExt[0],
'%s.vNumber' % pipeTes[0])
cmds.addAttr(pipeExt[0],
ln='Ext_DivisionU',
at='short',
k=True,
dv=sdu)
cmds.connectAttr('%s.Ext_DivisionU' % pipeExt[0],
'%s.uNumber' % pipeTes[0])
if subCurve != 0:
cmds.addAttr(pipeExt[0],
ln='Ext_Length',
k=True,
dv=1,
max=1,
min=0)
cmds.connectAttr('%s.Ext_Length' % pipeExt[0],
'%s.maxValue' % pipeSubCurve[1])
cmds.addAttr(pipeExt[0], ln='Ext_Taper', k=True, dv=tap, min=0)
cmds.connectAttr('%s.Ext_Taper' % pipeExt[0],
'%s.scale' % pipeExt[1])
cmds.addAttr(pipeExt[0], ln='Ext_Twist', k=True, dv=1)
cmds.connectAttr('%s.Ext_Twist' % pipeExt[0],
'%s.rotation' % pipeExt[1])
cmds.addAttr(pipeExt[0], ln='Ext_ComponentPivot', k=True, dv=1)
cmds.connectAttr('%s.Ext_ComponentPivot' % pipeExt[0],
'%s.useComponentPivot' % pipeExt[1])
curveGrpNode = cmds.createNode('transform', n='pipeCurves')
cmds.parent(nurbsCir, curveGrpNode)
cmds.parent(objSel, curveGrpNode)
cmds.setAttr('%s.inheritsTransform' % curveGrpNode, 0)
cmds.setAttr('%s.visibility' % curveGrpNode, 1)
cmds.parent(curveGrpNode, pipeExt[0])
cmds.select(pipeExt[0])
if do_uvs == 1:
cmds.polyLayoutUV(ps=0.2)
cmds.polyEditUV(sv=1, su=self.uvRatio)
cmds.polyEditUV(sv=0.95, su=0.95)
cmds.select(pipeExt[0])
CentreUVs()
if clean == 1:
cmds.delete(ch=True)
cmds.delete(curveGrpNode)
cmds.select(pipeExt[0])
if thisIsAMesh == True:
print 'hello'
break
def sysFromEdgeLoop(edge, surface, name=""):
# Extract curve from edge
cmds.select(edge)
anchor_curve = cmds.polyToCurve(name=name + '_Anchor_Crv',
form=2,
degree=1,
conformToSmoothMeshPreview=0)[0]
# Check curve direction and reverse
reverse_crv = xDirection_positive(anchor_curve)
if reverse_crv is False:
cmds.reverseCurve(anchor_curve, ch=0, rpo=1)
cmds.delete(anchor_curve, ch=1)
# Create locators on each anchor curve CV
locator_list = locatorOnCVs(anchor_curve, scale=0.2)
# Connect locators to CVs
loc_pci_node_list = connectLocatorToCrv(locator_list, anchor_curve)
# Duplicate -> Rebuild to low res
driver_crv = cmds.duplicate(anchor_curve, name=name + '_Driver_Crv')[0]
cmds.rebuildCurve(driver_crv,
ch=0,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=1,
s=6,
d=1,
tol=0.01)
cmds.rebuildCurve(driver_crv,
ch=0,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=1,
kep=1,
kt=1,
s=4,
d=3,
tol=0.01)
cmds.delete(driver_crv, ch=1)
# Wire high res to low res curve
driver_wire_node = cmds.wire(anchor_curve,
w=driver_crv,
gw=False,
en=1.000000,
ce=0.000000,
li=0.000000)
# Create joints on each low res CV
cv_postion = getCVAngle(driver_crv)
driver_jnt_list = []
ctrl_dict = {}
ctrl_list = []
remoteCtrl_loc_dict = {}
remoteCtrl_loc_list = []
for n, position in enumerate(cv_postion):
cmds.select(cl=1)
driver_jnt = cmds.joint(rad=0.3,
n="{}_{:02d}_Ctrl_Jnt".format(name, n))
driver_jnt_list.append(driver_jnt)
cmds.xform(driver_jnt, t=position[0], ro=[0, position[1][1], 0])
# Create controls for each joint
ctrl_data = tpu.build_ctrl(ctrl_type="cube",
name="{}_{:02d}".format(name, n),
scale=0.3,
spaced=1)
ctrl_dict.update({ctrl_data['control']: ctrl_data['group']})
ctrl_list.append(ctrl_data['control'])
cmds.xform(ctrl_data['group'],
t=position[0],
ro=[0, position[1][1], 0])
# Create remote ctrl locator
remoteCtrl_loc = cmds.spaceLocator(
n="{}_{:02d}_RemoteCtrl_Loc".format(name, n))[0]
for i in "X,Y,Z".split(","):
cmds.setAttr("{}.localScale{}".format(remoteCtrl_loc, i), 0.3)
remoteCtrl_loc_grp = cmds.group(remoteCtrl_loc,
n=remoteCtrl_loc + "_Grp")
remoteCtrl_loc_dict.update({remoteCtrl_loc: remoteCtrl_loc_grp})
remoteCtrl_loc_list.append(remoteCtrl_loc)
cmds.xform(remoteCtrl_loc_grp,
t=position[0],
ro=[0, position[1][1], 0])
# Connect control/joint transforms
cmds.parentConstraint(remoteCtrl_loc, driver_jnt, mo=1)
for attr in ".t,.rotate,.s".split(','):
cmds.connectAttr(ctrl_data['control'] + attr,
remoteCtrl_loc + attr,
f=1)
# Bind low res curve to joints
skinCluster_node = cmds.skinCluster(driver_jnt_list, driver_crv)
# Create system on surface
surface_sys_data = follicleOnClosestPoint(surface, locator_list, name)
follicle_dict = surface_sys_data[0]
# Create joints for each follicle
follicle_jnt_list = jointsOnSelection(follicle_dict.keys(),
constraint=True,
rad=0.2)
# Group and organize system on Outliner
crv_grp = cmds.group(anchor_curve,
driver_crv,
driver_crv + "BaseWire",
n="{}_Crv_Grp".format(name))
# Locator Groups
remoteCtrl_loc_grp = cmds.group(remoteCtrl_loc_dict.values(),
n="{}_RemoteCtrl_Loc_Grp".format(name))
aim_loc_grp = cmds.group(locator_list, n="{}_Aim_Loc_Grp".format(name))
locator_grp = cmds.group(remoteCtrl_loc_grp,
aim_loc_grp,
n="{}_Loc_Grp".format(name))
# Joint groups
bind_joint_grp = cmds.group(follicle_jnt_list,
n="{}_Bind_Jnt_Grp".format(name))
ctrl_joint_grp = cmds.group(driver_jnt_list,
n="{}_Ctrl_Jnt_Grp".format(name))
joint_grp = cmds.group(bind_joint_grp,
ctrl_joint_grp,
n="{}_Jnt_Grp".format(name))
# Controls group
ctrl_grp = cmds.group(ctrl_dict.values(), n="{}_Ctrl_Grp".format(name))
# Follicle group
follicle_grp = cmds.group(follicle_dict.keys(),
n="{}_Flc_Grp".format(name))
main_sys_grp = cmds.group(crv_grp,
locator_grp,
ctrl_grp,
follicle_grp,
joint_grp,
n="{}_Sys_Grp".format(name))
sys_data = {
"main_sys_grp": main_sys_grp,
"loc_pci_node_list": loc_pci_node_list,
"driver_wire_node": driver_wire_node,
"skinCluster_node": skinCluster_node,
"surface_closestPoint_node_list": surface_sys_data[1],
"surface_setRange_node_list": surface_sys_data[2],
"ctrl_list": ctrl_list,
"ctrl_dict": ctrl_dict,
"remoteCtrl_dict": remoteCtrl_loc_dict,
"remoteCtrl_list": remoteCtrl_loc_list
}
return sys_data
def sqCheckCurveDirection(self, thisCurve, *args):
posMinX = cmds.xform(thisCurve+".cv[0]", query=True, worldSpace=True, translation=True)[0]
posMaxX = cmds.xform(thisCurve+".cv["+str(self.curveLenght-1)+"]", query=True, worldSpace=True, translation=True)[0]
if posMinX > posMaxX:
cmds.reverseCurve(thisCurve, constructionHistory=False, replaceOriginal=True)
def reverseCurve(*args, **kwargs):
res = cmds.reverseCurve(*args, **kwargs)
if not kwargs.get('query', kwargs.get('q', False)):
res = _factories.maybeConvert(res, _general.PyNode)
return res
def surfRigger(objectNull,anchor,worldScale,mirror,mode,jointsPerChain,deformChains,ctrlChains):
""" Get variables"""
nullBase = names.stripSuffixObj (objectNull)
templateNull = (nullBase + '_templateNull')
moverNull = (nullBase + '_mover')
templateNullMessageData = []
templateNullMessageData = attributes.returnMessageAttrs (templateNull)
templateObjects = []
coreNamesList = []
spineJointNumber = int(mc.getAttr (objectNull+'.rollJoints'))
#spineChainList = search.returnChildrenJoints (spineChain)
spineChainList = []
spineChainList.append (anchor)
jointChains = []
for set in templateNullMessageData:
templateObjects.append (set[1])
coreNamesList.append (set[0])
#>>>>>>>>>>>>>>>>>>>>>Store skin joint data
""" check for master skin info group """
if mc.objExists ('master_skinJntList_grp'):
masterSkinJointList = ('master_skinJntList_grp')
else:
masterSkinJointList = mc.group (n= ('master_skinJntList_grp'), w=True, empty=True)
mc.parent(masterSkinJointList,'rigStuff_grp')
""" check for segment skin info group """
if mc.objExists (nullBase+'_skinJntList_grp'):
skinJointListGrp = (nullBase+'_skinJntList_grp')
else:
skinJointListGrp = mc.group (n= (nullBase+'_skinJntList_grp'), w=True, empty=True)
attributes.storeObjNameToMessage (skinJointListGrp,masterSkinJointList)
mc.parent (skinJointListGrp,masterSkinJointList)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
""" Rebuild curve - with actual curve in it!"""
mc.rebuildCurve ((templateObjects[3]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5)
mc.rebuildCurve ((templateObjects[7]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5)
mc.rebuildCurve ((templateObjects[11]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5)
""" Reverse the curve """
mc.reverseCurve ((templateObjects[3]),ch=False,rpo=True)
mc.reverseCurve ((templateObjects[7]),ch=False,rpo=True)
mc.reverseCurve ((templateObjects[11]),ch=False,rpo=True)
""" loft our surface to figure out joint positions, then delete it"""
controlSurface = mc.loft ([templateObjects[3],templateObjects[7],templateObjects[11]],name=(nullBase+'_surf'),ss=(ctrlChains-mode),ch=1,u=1,c=0,ar=1,d=3,rn=0,po=0,rsn=True)
mc.select (cl=True)
jointChains = joints.createJointChainsFromLoftSurface (nullBase,controlSurface[0],2,False)
frontChain = jointChains[0]
backChain = jointChains[-1]
""" Chain - orienting, sizing """
for chain in jointChains:
joints.orientJointChain (chain, 'xyz', 'zup')
joints.setGoodJointRadius(chain,.5)
#IF we have mode 0, gotta make a main ctrl
if mode == 0:
midChain = []
if (len(jointChains)) > 3:
midChain = jointChains[int(len(jointChains)/2)]
else:
midChain = jointChains[1]
jointChains.remove(midChain)
if ctrlChains > 2:
masterCtrlBuffer = mc.duplicate (midChain[0],parentOnly=True)
else:
masterCtrlBuffer = midChain[0]
mc.delete (midChain[1])
masterCtrl = mc.rename (masterCtrlBuffer,(nullBase+'_master_anim'))
position.movePointSnap(masterCtrl,moverNull)
""" temp parenting the master control for mirroring purposes """
spineHookJoint = distance.returnClosestObject (masterCtrl, spineChainList)
mc.parent (masterCtrl,spineHookJoint)
mc.delete (controlSurface[0])
#>>>>>>>>>>>>Parent time
""" Get closest joint """
if mode == 0:
for chain in jointChains:
mc.parent (chain[0],masterCtrl)
else:
for chain in jointChains:
tailHookJoint = distance.returnClosestObject (chain[0], spineChainList)
mc.parent (chain[0],tailHookJoint)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ctrl Joints to Ctrls
cnt = 0
for chain in jointChains:
ctrlSize = (distance.returnAverageDistanceBetweenObjects (chain)/2)
for jnt in chain[0:-1]:
rigging.makeObjCtrl (jnt,ctrlSize)
""" adds our Anim tag """
chainBuffer = []
chainBuffer = names.addSuffixList ('anim', chain)
jointChains[cnt]= chainBuffer
cnt +=1
#>>>>>>>>>>>>>>>>>>>Mirroring while getting chain info
""" If mirroring ...."""
if mirror == True:
# if we have a main control
leftSkinChains = []
rightSkinChains = []
masterCtrls = []
if mode == 0:
leftChain = []
rightChain = []
finHeirarchy = []
finHeirarchy.append (masterCtrl)
children = search.returnChildrenJoints (masterCtrl)
finHeirarchy += children
leftChain = names.addPrefixList ('left',finHeirarchy)
masterCtrl = leftChain [0]
rightChainBuffer = mc.mirrorJoint (masterCtrl,mirrorYZ=True,mirrorBehavior=True, searchReplace =['left','right'])
rightChainJointBuffer = mc.ls (rightChainBuffer,type='joint')
rightChain = rightChainJointBuffer
leftSkinChains.append(leftChain)
rightSkinChains.append(rightChain)
masterCtrls.append(leftChain[0])
masterCtrls.append(rightChain[0])
else:
for chain in jointChains:
leftChain =[]
leftChain = names.addPrefixList ('left',chain)
rightChainBuffer = (mc.mirrorJoint (leftChain[0],mirrorYZ=True,mirrorBehavior=True, searchReplace =['left','right']))
rightChainJointBuffer = mc.ls (rightChainBuffer,type='joint')
rightChain = rightChainJointBuffer
rightSkinChains.append (rightChainJointBuffer)
leftSkinChains.append (leftChain)
""" complile our chains to lists of skin joints """
leftSkinJointList=[]
rightSkinJointList=[]
for chain in leftSkinChains:
for jnt in chain:
leftSkinJointList.append (jnt)
for chain in rightSkinChains:
for jnt in chain:
rightSkinJointList.append (jnt)
"""if we're not mirroring, let's return our skin joints for the deformation surface"""
else:
skinJointList = []
skinChains = []
for chain in jointChains:
skinChains.append (chain)
for jnt in chain:
skinJointList.append (jnt)
#>>>>>>>>>>>>>>>>>>>>>>>>>>Time to make the deformation surface stuff
""" Rebuild curve - with actual curve in it!"""
#mc.rebuildCurve ((templateObjects[3]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=(3), d=1, tol=5)
#mc.rebuildCurve ((templateObjects[7]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=(3), d=1, tol=5)
""" loft our surface to figure out joint positions, then delete it"""
deformSurface = mc.loft ([templateObjects[3],templateObjects[7],templateObjects[11]],name=(nullBase+'_surf'),ss=(deformChains-1),ch=0,u=1,c=0,ar=1,d=3,rn=0,po=0,rsn=True)
if mirror == True:
deformSurfaceNameBuffer = deformSurface[0]
"""we have a surface to mirror..."""
surfaceMirrorBuffer = mc.duplicate (deformSurface[0])
mc.setAttr ((surfaceMirrorBuffer[0]+'.sx'),-1)
leftBuffer = mc.rename (deformSurface[0],('left_'+deformSurfaceNameBuffer))
rightBuffer = mc.rename (surfaceMirrorBuffer[0],('right_'+deformSurfaceNameBuffer))
deformSurface[0]=leftBuffer
deformSurface.append(rightBuffer)
leftDeformJointChains = joints.createJointChainsFromLoftSurface (('left_'+nullBase),deformSurface[0],2,False)
rightDeformJointChains = joints.createJointChainsFromLoftSurface (('right_'+nullBase),deformSurface[1],2,False)
""" Connecting to surface """
for chain in leftDeformJointChains:
attachSurfaceReturn = joints.attachJointChainToSurface (chain,deformSurface[0],'xyz','zup')
tailHookJoint = distance.returnClosestObject (chain[0], spineChainList)
""" break the connection so we can parent it"""
"""first return the original thing to follow"""
parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate'))
attributes.doBreakConnection (chain[0]+'.translate')
#mc.parent (chain[0],tailHookJoint)
""" reconstrain it to the driver"""
constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True)
mc.rename (constraintBuffer[0],(chain[0]+'_pointConst'))
""" store the skin joint data """
for jnt in chain:
attributes.storeObjNameToMessage (jnt,skinJointListGrp)
for chain in rightDeformJointChains:
attachSurfaceMirrorReturn = joints.attachJointChainToSurface (chain,deformSurface[1],'xyz','zup')
tailHookJoint = distance.returnClosestObject (chain[0], spineChainList)
""" break the connection s we can parent it"""
"""first return the original thing to follow"""
parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate'))
attributes.doBreakConnection (chain[0]+'.translate')
#mc.parent (chain[0],tailHookJoint)
""" reconstrain it to the driver"""
constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True)
mc.rename (constraintBuffer[0],(chain[0]+'_pointConst'))
""" store the skin joint data """
for jnt in chain:
attributes.storeObjNameToMessage (jnt,skinJointListGrp)
""" parent the scale stuff to rig stuff grp"""
mc.select (cl=True)
for item in attachSurfaceReturn[0]:
mc.parent(item,'rigStuff_grp')
for item in attachSurfaceMirrorReturn[0]:
mc.parent(item,'rigStuff_grp')
""" hook up world scale """
mc.connectAttr (worldScale,attachSurfaceReturn[1])
mc.connectAttr (worldScale,attachSurfaceMirrorReturn[1])
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Skin in the control joints
""" Time to set skin our surface to our control joints """
mc.skinCluster (leftSkinJointList,deformSurface[0],tsb=True, n=(deformSurface[0]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1)
mc.skinCluster (rightSkinJointList,deformSurface[1],tsb=True, n=(deformSurface[1]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1)
#>>>>>If we,re not mirrored, let's make our deform setup
else:
deformJointChains = []
deformJointChains = joints.createJointChainsFromLoftSurface (nullBase,deformSurface[0],2,False)
""" Connecting to surface """
for chain in deformJointChains:
attachSurfaceReturn = joints.attachJointChainToSurface (chain,deformSurface[0],'xyz','zup')
tailHookJoint = distance.returnClosestObject (chain[0], spineChainList)
""" break the connection so we can parent it"""
"""first return the original thing to follow"""
parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate'))
attributes.doBreakConnection (chain[0]+'.translate')
#mc.parent (chain[0],tailHookJoint)
""" reconstrain it to the driver"""
constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True)
mc.rename (constraintBuffer[0],(chain[0]+'_pointConst'))
""" store the skin joint data """
for jnt in chain:
attributes.storeObjNameToMessage (jnt,skinJointListGrp)
""" hook up world scale """
partScaleBuffer = attachSurfaceReturn[1]
mc.connectAttr (worldScale, partScaleBuffer)
""" parent the scale stuff to rig stuff grp"""
mc.select (cl=True)
for item in attachSurfaceReturn[0]:
mc.parent(item,'rigStuff_grp')
""" Time to set skin our surface to our control joints """
mc.skinCluster (skinJointList,deformSurface[0],tsb=True, n=(deformSurface[0]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1)
""" Setting up the joint starts"""
if mode == 0:
if mirror == True:
for ctrl in masterCtrls:
rigging.makeObjCtrl (ctrl,(ctrlSize*4))
masterCtrlGrp = rigging.groupMeObject (ctrl,True)
""" Get closest joint and connect the Cntrl """
spineHookJoint = distance.returnClosestObject (masterCtrlGrp, spineChainList)
mc.parent(masterCtrlGrp,spineHookJoint)
else:
rigging.makeObjCtrl (masterCtrl,(ctrlSize*4))
masterCtrlGrp = rigging.groupMeObject (masterCtrl,True)
""" Get closest joint and connect the Cntrl """
spineHookJoint = distance.returnClosestObject (masterCtrlGrp, spineChainList)
mc.parent(masterCtrlGrp,spineHookJoint)
#else we need to connect the individual chains to the spine
else:
if mirror == True:
for chain in leftSkinChains:
chainCtrlGrp = rigging.groupMeObject (chain[0],True)
spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList)
mc.parent(chainCtrlGrp,spineHookJoint)
for chain in rightSkinChains:
chainCtrlGrp = rigging.groupMeObject (chain[0],True)
spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList)
mc.parent(chainCtrlGrp,spineHookJoint)
else:
for chain in skinChains:
chainCtrlGrp = rigging.groupMeObject (chain[0],True)
spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList)
mc.parent(chainCtrlGrp,spineHookJoint)
def createFKSys(ctrl_amount,
curve,
name,
color1=(0, 1, 0),
color2=(0.5, 0.5, 0.5)):
# Declaring all function variables in dictionary
fk_data = {
'jnt_ctrl_list': [],
'jnt_ctrl_grp_list': [],
'fk_ctrl_list': [],
'fk_ctrl_grp_list': [],
'jnt_remoteCtrl_list': [],
'jnt_remoteCtrl_grp_list': [],
'fk_remoteCtrl_list': [],
'fk_remoteCtrl_grp_list': [],
'fk_ctrl_grp': "",
'fk_remoteCtrl_grp': "",
'joint_list': [],
'joint_group': "",
'curve': "",
'wire': "",
'base_wire': ""
}
# Duplicate main curve
fk_data['curve'] = cmds.duplicate(
curve, name="{}_MainCtrl_FKDriver_Crv".format(name))[0]
# Rebuild curve - Same as control amount - 1 linear - Convert curve to 3 cubic
cmds.rebuildCurve(fk_data['curve'],
rpo=1,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=1,
s=ctrl_amount,
d=1,
tol=0.01)
cmds.rebuildCurve(fk_data['curve'],
rpo=1,
rt=0,
end=1,
kr=0,
kcp=1,
kep=1,
kt=1,
s=4,
d=3,
tol=0.01)
cmds.reverseCurve(fk_data['curve'], ch=0, rpo=1)
# Freeze curve transforms, Delete history, center pivot
cmds.makeIdentity(fk_data['curve'], apply=True, t=1, r=1, s=1, n=0)
cmds.xform(fk_data['curve'], cp=1)
# Do joints on curve CV's
fk_data['joint_list'] = jointsOnCVs(fk_data['curve'], name)
# Do controls on joints
jnt_ctrl_data = placeOnEach_joint(fk_data['joint_list'],
type="cube",
scale=1,
color=color1,
name=name,
sufix="_Jnt_Ctrl")
fk_data['jnt_ctrl_list'] = jnt_ctrl_data[0]
fk_data['jnt_ctrl_grp_list'] = jnt_ctrl_data[1]
# jnt_ctrls remote - Parent ON
jnt_remoteCtrl_data = placeOnEach_joint(fk_data['joint_list'],
type="cube",
scale=1,
color=color1,
constraint=1,
name=name,
sufix="_Jnt_Remote_Ctrl")
fk_data['jnt_remoteCtrl_list'] = jnt_remoteCtrl_data[0]
fk_data['jnt_remoteCtrl_grp_list'] = jnt_remoteCtrl_data[1]
# Do FK controls on controls
fk_ctrl_data = placeOnEachSel(fk_data['jnt_ctrl_list'],
type="circle",
scale=2,
color=color2,
spaced=1,
name=name,
sufix="_FK_Ctrl")
fk_data['fk_ctrl_list'] = fk_ctrl_data[0]
fk_data['fk_ctrl_grp_list'] = fk_ctrl_data[1]
# FK controls remote
fk_remoteCtrl_data = placeOnEachSel(fk_data['jnt_ctrl_list'],
type="circle",
scale=2,
spaced=1,
name=name,
sufix="_FK_Remote_Ctrl")
fk_data['fk_remoteCtrl_list'] = fk_remoteCtrl_data[0]
fk_data['fk_remoteCtrl_grp_list'] = fk_remoteCtrl_data[1]
fk_data['fk_ctrl_grp'] = fk_data['fk_ctrl_grp_list'][-1]
fk_data['fk_remoteCtrl_grp'] = fk_data['fk_remoteCtrl_grp_list'][-1]
# Parent joint ctrls to FK controls
for grp, ctrl in zip(fk_data['jnt_ctrl_grp_list'],
fk_data['fk_ctrl_list']):
cmds.parent(grp, ctrl)
for grp, ctrl in zip(fk_data['jnt_remoteCtrl_grp_list'],
fk_data['fk_remoteCtrl_list']):
cmds.parent(grp, ctrl)
# Parent FK controls in order
parent_FkOrder(fk_data['fk_ctrl_list'], fk_data['fk_ctrl_grp_list'])
parent_FkOrder(fk_data['fk_remoteCtrl_list'],
fk_data['fk_remoteCtrl_grp_list'])
# Connect controls and remote controls
for ctrl, remote in zip(fk_data['jnt_ctrl_list'],
fk_data['jnt_remoteCtrl_list']):
connectTransform(ctrl, remote, t=1, ro=1, s=1)
for ctrl, remote in zip(fk_data['fk_ctrl_list'],
fk_data['fk_remoteCtrl_list']):
connectTransform(ctrl, remote, t=1, ro=1, s=1)
# Wire highRes curve to lowRes
fk_data['wire'] = cmds.wire(curve,
gw=False,
en=1.0,
ce=0.0,
li=0.0,
dds=(0, 100),
w=fk_data['curve'],
n="{}_FkSys_Wire_Def".format(name))[0]
fk_data['base_wire'] = fk_data['curve'] + "BaseWire"
# Bind joints to curve
cmds.skinCluster(fk_data['joint_list'], fk_data['curve'])
fk_data['joint_group'] = cmds.group(fk_data['joint_list'],
n="{}_FK_Jnt_Grp".format(name))
return fk_data
def cutCurve(curve, mesh, loopCheck=False):
fnMesh = getMFnMesh(mesh)
fnCurve = getMFnCurve(curve)
meshIntersector = om.MMeshIntersector()
meshIntersector.create(fnMesh.object())
meshMtx = fnMesh.dagPath().inclusiveMatrix()
curveMtx = fnCurve.dagPath().inclusiveMatrix()
toMeshLocalMtx = curveMtx * meshMtx.inverse()
numSpans = fnCurve.numSpans()
maxParam = fnCurve.findParamFromLength(fnCurve.length())
paramRate = maxParam / (numSpans - 1)
point = om.MPoint()
pointOnMesh = om.MPointOnMesh()
closestParam = 0.0
for i in range(numSpans):
fnCurve.getPointAtParam(paramRate * i, point)
toMeshPoint = point * toMeshLocalMtx
meshIntersector.getClosestPoint(toMeshPoint, pointOnMesh)
closePoint = om.MPoint(pointOnMesh.getPoint())
normal = om.MVector(pointOnMesh.getNormal())
closePivVector = om.MVector(toMeshPoint) - om.MVector(closePoint)
if closePivVector * normal < 0:
closestParam = paramRate * i
else:
if i == 0:
if loopCheck: return None
cmds.reverseCurve(curve, ch=0, rpo=1)
cutCurve(curve, mesh, True)
i = 0
addParam = 1
while i < 100:
fnCurve.getPointAtParam(closestParam, point)
toMeshPoint = point * toMeshLocalMtx
meshIntersector.getClosestPoint(toMeshPoint, pointOnMesh)
closePoint = om.MPoint(pointOnMesh.getPoint())
cuDist = closePoint.distanceTo(toMeshPoint)
if cuDist < 0.0001: break
normal = om.MVector(pointOnMesh.getNormal())
closePivVector = om.MVector(toMeshPoint) - om.MVector(closePoint)
if closePivVector * normal > 0:
addParam = math.fabs(addParam) * -0.5
else:
addParam = math.fabs(addParam) * 0.5
closestParam += addParam
i += 1
fnCurve.getPointAtParam(closestParam, point)
first, second = cmds.detachCurve("%s.u[%f]" % (curve, closestParam),
ch=0,
cos=True,
rpo=0)
curveObj = cmds.listRelatives(curve, p=1)[0]
cmds.delete(first, curveObj)
second = cmds.rename(second, curveObj)
cmds.select(second)
cmds.DeleteHistory()
def createSetup():
jointNumstr = rig.textField('jointNumText', q=True, tx=True)
jointName = rig.textField('jointNameText', q=True, tx=True)
jointName = jointName + '_'
orient = rig.radioButtonGrp('jointOrientGrp', q=True, sl=True)
currntCurve = rig.textField('Shap', q=True, tx=True)
jointNum = int(jointNumstr)
disdenceList = []
jointList = []
aim = ''
xyz = ''
if (orient == 1):
aim = 'xyz'
xyz = 'tx'
elif (orient == 2):
aim = 'yzx'
xyz = 'ty'
elif (orient == 3):
aim = 'zxy'
xyz = 'tz'
if (rig.checkBox('rebCurve', q=True, v=True)):
vtxNum = len(rig.ls(currntCurve + '.cv[*]', fl=True))
rig.rebuildCurve(currntCurve,
ch=1,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=0,
s=vtxNum,
d=3,
tol=0.001)
if (rig.checkBox('revCurve', q=True, v=True)):
rig.reverseCurve(currntCurve, ch=True, rpo=True)
rig.select(cl=True)
ListShape = om.MSelectionList()
ListShape.add(currntCurve)
curveNode = om.MDagPath()
ListShape.getDagPath(0, curveNode)
CurveMFn = om.MFnNurbsCurve(curveNode)
curveLength = CurveMFn.length()
averageNum = curveLength / (jointNum - 1)
pnt = om.MPoint()
deLength = 0
for x in range(jointNum):
curParam = CurveMFn.findParamFromLength(deLength)
CurveMFn.getPointAtParam(curParam, pnt, om.MSpace.kWorld)
jointN = rig.createNode('pointOnCurveInfo',
n=jointName + 'jointPos' + str(x),
ss=True)
rig.connectAttr(currntCurve + '.worldSpace', jointN + '.inputCurve')
#
# rig.setAttr(jointN+'.turnOnPercentage',1)
rig.setAttr(jointN + '.parameter', curParam)
currentJoint = rig.joint(p=(rig.getAttr(jointN + '.positionX'),
rig.getAttr(jointN + '.positionY'),
rig.getAttr(jointN + '.positionZ')),
n='Joint_' + jointName + str(x))
jointList.append(currentJoint)
deLength += averageNum
if (x):
disName = rig.createNode('distanceBetween',
n=jointName + 'Dis' + str(x),
ss=True)
rig.connectAttr(jointName + 'jointPos' + str(x - 1) + '.position',
disName + '.point1')
rig.connectAttr(jointN + '.position', disName + '.point2')
disdenceList.append(disName)
rig.joint(jointList[0],
e=True,
oj=aim,
secondaryAxisOrient='yup',
ch=True,
zso=True)
rig.joint(jointList[-1],
e=True,
oj='none',
secondaryAxisOrient='yup',
ch=True,
zso=True)
groupName = rig.group(empty=True, n=jointName + 'Group')
scaleNode = rig.scaleConstraint(jointList[0], groupName, mo=True)
for n, i in enumerate(disdenceList):
multi = rig.createNode('multiplyDivide', n='MD_' + i)
rig.setAttr(multi + '.operation', 2)
rig.connectAttr(i + '.distance', multi + '.input1.input1X')
rig.connectAttr(groupName + '.scale', multi + '.input2')
rig.connectAttr(multi + '.output.outputX',
jointList[n + 1] + '.' + xyz)
rig.ikHandle(n=jointName + 'IKSpine',
sol='ikSplineSolver',
ccv=False,
sj=jointList[0],
ee=jointList[-1],
c=currntCurve)
"""
Build middle hair section
"""
#Start with template curve
middleStrand = cmds.curve(p=[(-1,0,-0.125),(-0.9375,-0.0875,-0.1875),(-0.84375,-0.06375,-0.26),(-0.7578125,-0.0053125,-0.275),(-0.6875,0.0425,-0.26),(-0.625,0.06375,-0.234375),(-0.5625,0.0425,-0.1875),(-0.5,0,-0.125),(-0.4375,-0.0875221,-0.0625),(-0.375,-0.06375,-0.015625),(-0.3125,-0.0425,0),(-0.2421875,0.0053125,0),(-0.15625,0.06375,0),(-0.0625,0.0425,-0.0625),(0,0,-0.125),(0.0625,-0.08752214296547417,-0.1875),(0.15625,-0.06375,-0.26),(0.2421875,-0.0053125,-0.275),(0.3125,0.0425,-0.26),(0.375,0.06375,-0.234375),(0.4375,0.0425,-0.1875),(0.5,0,-0.125),(0.5625,-0.0875221,-0.0625),(0.625,-0.06375,-0.015625),(0.6875,-0.0425,0),(0.7578125,0.0053125,0),(0.84375,0.06375,0),(0.9375,0.0425,-0.0625),(1,0,-0.125)], k=[0,0,0,0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,5.5,6,6,6,6.5,7,7.5,8,8.5,9,9.5,10,10.5,11,11.5,12,12,12], name='middleStrand')
msTemplate = cmds.duplicate('middleStrand', name='msTemplate')
#Add length to top
appendMSTop = cmds.duplicate('msTemplate', name='middleStrand2')
cmds.move(-2,0,0,'middleStrand2', relative=True)
cmds.attachCurve('middleStrand', 'middleStrand2')
cmds.delete('middleStrand2')
if append == 0:
cmds.reverseCurve('middleStrand', rpo=True)
#Append length if necessary
cutbottom = 24 - 1.71725261027258 #Curve point at which to detach curve
for i in xrange(0, append):
toAppend = cmds.duplicate('msTemplate', name='middleStrand2')
cmds.move(2*(i+1),0,0,'middleStrand2', relative=True)
cmds.attachCurve('middleStrand','middleStrand2')
cmds.delete('middleStrand2')
cutbottom = (24+12*(i+1)) - 1.71725261027258 - 6*(i+1)
#Cut top of curve
cmds.detachCurve('middleStrand.u[10.2827459692]', k=(0,1), replaceOriginal=True)
cmds.delete('middleStrand')
cmds.rename('middleStranddetachedCurve2', 'middleStrand')
def createConveyerBeltSet(meshName, firstEdgeIndex, secondEdgeIndex):
firstEdges = cmds.polySelectSp(meshName + '.e[%d]' % firstEdgeIndex,
loop=1)
secondEdges = cmds.polySelectSp(meshName + '.e[%d]' % secondEdgeIndex,
loop=1)
cmds.select(firstEdges)
firstCurve = cmds.polyToCurve(form=2,
degree=3,
n=meshName + '_loopCurve_First')[0]
cmds.select(secondEdges)
secondCurve = cmds.polyToCurve(form=2,
degree=3,
n=meshName + '_loopCurve_Second')[0]
firstCurveShape = sgModelDag.getShape(firstCurve)
secondCurveShape = sgModelDag.getShape(secondCurve)
firstSpans = cmds.getAttr(firstCurveShape + '.spans')
secondSpans = cmds.getAttr(secondCurveShape + '.spans')
firstTangent = sgModelCurve.getTangentAtParam(firstCurveShape, 0.0)
firstParamPoint = sgModelCurve.getPointAtParam(firstCurveShape, 0.0)
secondParam = sgModelCurve.getParamAtPoint(secondCurveShape,
firstParamPoint)
secondTangent = sgModelCurve.getTangentAtParam(secondCurveShape,
secondParam)
if firstTangent * secondTangent < 0:
cmds.reverseCurve(secondCurve, ch=1, rpo=1)
firstPointers = sgRigCurve.createRoofPointers(firstCurve, firstSpans)
secondPointers = sgRigCurve.createRoofPointers(secondCurve, secondSpans)
fPos = cmds.xform(firstPointers[0], q=1, ws=1, t=1)
minDistPointer = secondPointers[0]
minDist = 1000000000.0
for secondPointer in secondPointers:
sPos = cmds.xform(secondPointer, q=1, ws=1, t=1)
dist = (fPos[0] - sPos[0])**2 + (fPos[1] - sPos[1])**2 + (fPos[2] -
sPos[2])**2
if dist < minDist:
minDistPointer = secondPointer
minDist = dist
offset = int(minDistPointer.split('_')[-1])
crvs = []
for i in range(len(firstPointers)):
firstPointer = firstPointers[i]
secondPointer = '_'.join(secondPointers[i].split('_')[:-1]) + '_%d' % (
(i + offset) % firstSpans)
crv = sgRigCurve.createCurveOnTargetPoints(
[firstPointer, secondPointer])
crv = cmds.rename(crv, meshName + '_line_%d' % i)
crvs.append(crv)
cmds.select(crvs)
loftSurf = cmds.loft(n=meshName + '_loft')[0]
resultObject = cmds.nurbsToPoly(loftSurf,
mnd=1,
ch=1,
f=3,
pt=0,
pc=200,
chr=0.9,
ft=0.01,
mel=0.001,
d=0.1,
ut=1,
un=3,
vt=1,
vn=3,
uch=0,
ucr=0,
cht=0.2,
es=0,
ntr=0,
mrt=0,
uss=1,
n=meshName + '_conveyorBelt')
crvGrp = cmds.group(crvs, n=meshName + '_lines')
conveyorRig = cmds.group(firstCurve,
secondCurve,
crvGrp,
loftSurf,
resultObject,
meshName,
n=meshName + '_conveyorRig')
import sgRigAttribute
sgRigAttribute.addAttr(conveyorRig, ln='offset', k=1)
cmds.connectAttr(conveyorRig + '.offset', firstCurve + '.roofValue')
cmds.connectAttr(conveyorRig + '.offset', secondCurve + '.roofValue')
cmds.setAttr(conveyorRig + '.v', 0)
