def B_BtoC(*args):
getSelect=mc.ls(sl=True)
for each in getSelect:
#mc.select(each)
#mc.ConvertSelectionToEdgePerimeter()
#sel = mc.ls(sl= True)
#selA = mc.select(sel[1])
#mc.SelectEdgeLoopSp()
#mc.CreateCluster()
#mc.rename("ClusterTps")
#selClu = mc.ls(sl= True)
mc.select(each)
mc.ConvertSelectionToEdgePerimeter()
mc.ConvertSelectionToFaces()
mc.ConvertSelectionToContainedEdges()
sel = mc.ls(sl= True)
selO = mc.ls(os= True)
selA = mc.select(selO[1])
mc.SelectEdgeLoopSp()
mc.polyToCurve(form= 2,degree= 1,conformToSmoothMeshPreview= 0)
mc.CenterPivot()
mc.DeleteHistory()
mc.rename("Curve_0")
selCurv = mc.ls(sl= True)
posX = mc.getAttr(selCurv[0]+".controlPoints[0].xValue")
posY = mc.getAttr(selCurv[0]+".controlPoints[0].yValue")
posZ = mc.getAttr(selCurv[0]+".controlPoints[0].zValue")
mc.move(posX, posY, posZ, selCurv[0] + ".scalePivot", selCurv[0] + ".rotatePivot", absolute=True)
def preparecurve(crv, crvtrm, frac):
cmds.polyToCurve(f=3, dg=3, n='tmpcrv')
cmds.duplicate('tmpcrv', n=crvtrm)
cmds.delete('tmpcrv')
cmds.rebuildCurve(crv,
s=frac,
kr=2,
d=3,
tol=0.01,
rt=0,
kep=1,
kt=0,
kcp=0,
end=1)
def edgeLoopCrv(meshEdgeList,rebuild=False,rebuildSpans=0,form=2,keepHistory=True,prefix=''):
'''
Generate a curve from a mesh edge loop.
@param meshEdgeList: List of mesh edges to generate curve from
@type meshEdgeList: list
@param rebuild: Rebuild curve to degree 3
@type rebuild: bool
@param rebuildSpans: Number of spans to rebuild the resulting curve to
@type rebuildSpans: int
@param form: Form of the resulting curve. 0 = Open, 1 = Periodic, 2 = Best Guess.
@type form: str
@param keepHistory: Maintain construction history
@type keepHistory: bool
@param prefix: Name prefix for newly created nodes
@type prefix: str
'''
# Check edge list
if not meshEdgeList:
raise Exception('Invalid mesh edge list provided!!')
meshEdgeList = mc.ls(meshEdgeList,fl=True)
# Check prefix
if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(meshEdgeList[0].split('.')[0])
# Convert edge selection to nurbs curve
crvDegree = 1
if rebuild: crvDegree = 3
curve = mc.polyToCurve(ch=keepHistory,form=form,degree=crvDegree)[0]
# Rebuild as degree 3
if rebuild and rebuildSpans:
curve = mc.rebuildCurve(curve,ch=keepHistory,rpo=1,rt=0,end=1,kr=0,kcp=1,kep=1,kt=1,s=rebuildSpans,d=3,tol=0.01)[0]
# Rename curve
curve = mc.rename(curve,prefix+'_curve')
# Return result
return curve
def make_curve(): new_curve = cmds.polyToCurve(degree=1, form=2, conformToSmoothMeshPreview=1)[0] spans = num_spans(new_curve) *2 cmds.rebuildCurve(new_curve, rt=0, ch=1, end=1, d=3, kr=2, s=spans, kcp=0, tol=0.01, kt=0, rpo=1, kep=1) first_cv = new_curve + '.cv[0]' cmds.move(0.0001, 0.0001, 0.0001, first_cv ,r=True, ) return new_curve
def buildEdgeCurves(edges,name,color=None):
'''
Build poly edge curves.
Group, name and color resulting curves.
@param edges: List of poly edges to extract as curves.
@type edges: str
@param name: Curve and group name prefix.
@type name: str
@param color: Color to apply to the edge curve (group).
@type color: int or str or None
'''
# Get Edges
edges = mc.filterExpand(ex=True,sm=32) # Poly Edges
if not edges: raise Exception('Invalid or empty edge list!')
# Get Master Group
masterGrp = buildMasterCurveGroup('edgeCurveGroup')
# Get Curve Group
curveGrp = buildCurveGroup(name,color)
try: mc.parent(curveGrp,masterGrp)
except: pass
# Build Edge Curves
crvList = []
for edge in edges:
crv = mc.polyToCurve(edge,form=2,degree=1)[0]
for at in 'trs': mc.setAttr(crv+'.'+at,l=True,cb=False)
mc.parent(crv,curveGrp)
# Return Result
return curveGrp
def dpCreateCurveFromEdge(self, zipperId, *args):
""" Create curve from selected polygon edges.
"""
self.dpGetCurveDirection()
# declaring names:
thisName = self.firstName
if zipperId == "c115_second":
thisName = self.secondName
curveName = self.zipperName + "_" + thisName + "_Crv"
pecName = self.zipperName + "_" + thisName + "_PEC"
# get selected edges:
edgeList = cmds.ls(selection=True, flatten=True)
if not edgeList == None and not edgeList == [] and not edgeList == "":
# delete old curve:
self.dpDeleteOldCurve(zipperId)
# create curve:
baseCurve = cmds.polyToCurve(name=curveName,
form=2,
degree=3,
conformToSmoothMeshPreview=0)[0]
# rename polyEdgeToCurve node:
cmds.rename(
cmds.listConnections(baseCurve + ".create")[0], pecName)
# add attributes:
cmds.addAttr(baseCurve, longName=ZIPPER_ATTR, attributeType='bool')
cmds.addAttr(baseCurve, longName=ZIPPER_ID, dataType='string')
cmds.setAttr(baseCurve + "." + ZIPPER_ATTR, 1)
cmds.setAttr(baseCurve + "." + ZIPPER_ID, zipperId, type="string")
# load curve data:
self.dpLoadData(baseCurve)
else:
mel.eval('warning \"' +
self.langDic[self.langName]['i188_selectEdges'] + '\";')
def edgeLoopsToCurve(edgeList,form=2,degree=1):
'''
Generate edge loop curves from the specified list of edges.
@param edgeList: The list of mesh edges to generate edge loop curves from.
@type edgeList: list
@param form: NURBS curve form. 0 = Periodic, 1 = Open, 2 = Best Guess.
@type form: str
@param degree: NURBS curve degree.
@type degree: str
'''
# Filter/Check Edge List
edgeList = mc.filterExpand(edgeList,ex=True,sm=32)
if not edgeList: raise Exception('Invalid edge list!')
# For Each Edge
edgeCurveList = []
for edge in edgeList:
# Get Mesh
edgeId = glTools.utils.component.index(edge)
meshShape = mc.ls(edge,o=True)[0]
mesh = mc.listRelatives(meshShape,p=True)[0]
prefix = mesh.split(':')[-1]
# To Edge Loop
mc.polySelect(mesh,edgeLoop=edgeId)
# Edge Loop to Curve
edgeCurve = mc.polyToCurve(ch=False,form=form,degree=degree)[0]
# Append List
edgeCurveList.append(edgeCurve)
# Return Result
return edgeCurveList
def createCurveToEdgeLoop( edge ):
cmds.select( edge )
cmds.SelectEdgeLoopSp()
curve = cmds.polyToCurve( form=0, degree=3 )[0]
return curve
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 edgeLoopsToCurve(edgeList,form=2,degree=1):
'''
Generate edge loop curves from the specified list of edges.
@param edgeList: The list of mesh edges to generate edge loop curves from.
@type edgeList: list
@param form: NURBS curve form. 0 = Periodic, 1 = Open, 2 = Best Guess.
@type form: str
@param degree: NURBS curve degree.
@type degree: str
'''
# Filter/Check Edge List
edgeList = mc.filterExpand(edgeList,ex=True,sm=32)
if not edgeList: raise Exception('Invalid edge list!')
# For Each Edge
edgeCurveList = []
for edge in edgeList:
# Get Mesh
edgeId = glTools.utils.component.index(edge)
meshShape = mc.ls(edge,o=True)[0]
mesh = mc.listRelatives(meshShape,p=True)[0]
prefix = mesh.split(':')[-1]
# To Edge Loop
mc.polySelect(mesh,edgeLoop=edgeId)
# Edge Loop to Curve
edgeCurve = mc.polyToCurve(ch=False,form=form,degree=degree)[0]
# Append List
edgeCurveList.append(edgeCurve)
# Return Result
return edgeCurveList
def buildEdgeCurves(edges, name, color=None):
"""
Build poly edge curves.
Group, name and color resulting curves.
@param edges: List of poly edges to extract as curves.
@type edges: str
@param name: Curve and group name prefix.
@type name: str
@param color: Color to apply to the edge curve (group).
@type color: int or str or None
"""
# Get Edges
edges = cmds.filterExpand(ex=True, sm=32) # Poly Edges
if not edges: raise Exception('Invalid or empty edge list!')
# Get Master Group
masterGrp = buildMasterCurveGroup('edgeCurveGroup')
# Get Curve Group
curveGrp = buildCurveGroup(name, color)
try:
cmds.parent(curveGrp, masterGrp)
except:
pass
# Build Edge Curves
crvList = []
for edge in edges:
crv = cmds.polyToCurve(edge, form=2, degree=1)[0]
for at in 'trs':
cmds.setAttr(crv + '.' + at, l=True, cb=False)
cmds.parent(crv, curveGrp)
# Return Result
return curveGrp
def extractEdgeCurves(edgeList, form=2, degree=1, keepHistory=True):
"""
Extract mesh edges as nurbs curves.
@param edgeList: Geometry to get shading group from
@type edgeList: list
@param form: Curve form. 0=Open, 1=Periodic, 2=Best Guess
@type form: int
@param degree: Curve degree
@type degree: int
@param keepHistory: Maintain polyToCurve construction nodes
@type keepHistory: bool
"""
# Check Edge List
if not edgeList:
raise Exception('Invalid or empty edge list! Unable to extract edge curves...')
# Partition Connected Edges
connectedEdges = getConnectedEdges(edgeList)
# Get Mesh from Edges
mesh = cmds.ls(edgeList, o=True)[0]
# Extract Edge Curves
crvList = []
nodeList = []
for connectedEdgeList in connectedEdges:
edgeLine = [mesh + '.e[' + str(i) + ']' for i in connectedEdgeList]
cmds.select(edgeLine)
polyToCurve = cmds.polyToCurve(form=form, degree=degree, ch=keepHistory)
crvList.append(polyToCurve[0])
if keepHistory: nodeList.append(polyToCurve[1])
# Return Result
cmds.select(crvList)
return crvList
def createNewCurveShapes(obj):
newCurves = []
d = findAllShapes(obj)
for one in d:
loc = []
borderEdges = {}
borderEdges = set()
edges = cmd.polyListComponentConversion(d[one], fv=True, te=True)
cmd.select(edges)
mel.eval('polyConvertToShellBorder')
borders = cmd.ls(sl=True, fl=True)
for b in borders:
borderEdges.add(b)
h = 0
while len(borderEdges) > 0:
if h > 100:
break
start = (borderEdges.pop())
borderEdges.add(start)
cmd.select(start)
firstEdge = int(start[start.find('[') + 1:start.find(']')])
cmd.polySelect(obj, eb=firstEdge)
borderEdge = cmd.ls(sl=True, fl=True)
newCurve = cmd.polyToCurve(form=1, degree=1, ch=False)[0]
newCurves.append(newCurve)
for this in borderEdge:
borderEdges.remove(this)
h += 1
return newCurves
def edgeLoopCrv(meshEdgeList,
rebuild=False,
rebuildSpans=0,
form=2,
keepHistory=True,
prefix=''):
'''
INPUT:
meshEdgeList (TIPO: list, DESCROPCION: edges seleccionados)
rebuild (TIPO: bool, DESCROPCION: rebuild de la curva)
rebuildSpans (TIPO: int, DESCROPCION: rebuild cantidad de spans)
form (TIPO: int, DESCROPCION: cantidad de suavisado)
keepHistory (TIPO: bool, DESCROPCION: keepHistory colapce)
prefix (TIPO: string, DESCROPCION: nombre de la curva )
OUPUT:
curve (TIPO: string, DESCROPCION: nombre de la curva )
EJEMPLO:
Crear curva segun edge con joints
tambien podras aderir algun modificador.
seleccion=cmds.ls(sl=1,o=True)
seleccionEdge=cmds.ls(sl=1)
cosas={}
crv=ere.edgeLoopCrv(seleccionEdge)
cosas[0]=ere.creaLocWithJointsInPositionVertexOfCurve([crv],step=2)
ere.aimConsecutiveList(cosas[0][0],'coco')
lowCRV=ere.crearLowCrvControl([crv])
ere.nonlinearDeformer([lowCRV[0]],'twist',rotate=(0,0,90))
ere.nonlinearDeformer([lowCRV[0]],'sine',rotate=(0,0,90))
'''
# Nombro igual al objeto
if prefix == '': prefix = str(meshEdgeList[0]).split('.')[0]
#obtengo los edge seleccionados
meshEdgeList = cmds.ls(meshEdgeList, fl=True)
rebuldSpans = len(meshEdgeList)
# Convert edge selection to nurbs curve
crvDegree = 1
if rebuild:
crvDegree = 3
curve = cmds.polyToCurve(ch=keepHistory, form=form, degree=crvDegree)[0]
# Rebuild as degree 3
if rebuild and rebuildSpans:
curve = cmds.rebuildCurve(curve,
ch=keepHistory,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=1,
kep=1,
kt=1,
s=rebuildSpans,
d=3,
tol=0.01)[0]
# Rename curve
curve = cmds.rename(curve, prefix + '_CRV')
# Return result
return curve
def getCenterCurve():
edges=mc.ls(sl=1)
loftCurves=[]
for i in edges:
obj=i.split('.')[0]
edgeID=int(i.split('.')[1].split('[')[1].split(']')[0])
edgeLoop=mc.polySelect(obj,el=edgeID)
loftCurves.append(mc.polyToCurve(form=2,degree=1)[0])
mc.loft(loftCurves[0],loftCurves[1],ch=0,u=1,c=0,ar=1,d=1,ss=2,rn=0,po=0,rsn=1,n='NLoftPlane')
loftPlane=mc.nurbsToPoly('NLoftPlane',mnd=1,ch=0,f=3,pt=0,pc=200,chr=0.1,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)[0]
edgeLoop=mc.polySelect(loftPlane,el=2)
centerCurve=mc.polyToCurve(form=2,degree=1)[0]
mc.rebuildCurve(centerCurve,ch=0,rpo=1,rt=0,end=1,kr=0,kcp=1,kep=0,kt=0,s=16,d=3,tol=0.01);mc.DeleteHistory(centerCurve)
mc.delete('NLoftPlane',loftPlane,loftCurves)
mc.setAttr(centerCurve+'.overrideEnabled',1)
mc.setAttr(centerCurve+'.overrideColor',16)
loftCurves=[]
def sqGenerateCurves(self, *args):
self.edgeList = cmds.ls(selection=True, flatten=True)
if not self.edgeList == None and not self.edgeList == [] and not self.edgeList == "":
self.baseCurve = cmds.polyToCurve(name="baseCurve", form=2, degree=1)[0]
cmds.select(self.baseCurve+".ep[*]")
cmds.insertKnotCurve(cmds.ls(selection=True, flatten=True), constructionHistory=True, curveOnSurface=True, numberOfKnots=1, addKnots=False, insertBetween=True, replaceOriginal=True)
pointListA, pointListB, sideA, sideB = self.sqGetPointLists()
toDeleteList = []
p = 2
for k in range((sideA+2), (sideB-1)):
if p%2 == 0:
toDeleteList.append(self.baseCurve+".cv["+str(k)+"]")
toDeleteList.append(self.baseCurve+".cv["+str(k+len(pointListA)-1)+"]")
p = p+1
q = 2
m = sideA-2
if m >= 0:
while m >= 0:
if not m == sideA and not m == sideB:
if q%2 == 0:
toDeleteList.append(self.baseCurve+".cv["+str(m)+"]")
m = m-1
q = q+1
cmds.delete(toDeleteList)
cmds.insertKnotCurve([self.baseCurve+".u["+str(len(pointListA)-1)+"]", self.baseCurve+".ep["+str(len(pointListA)-1)+"]"], constructionHistory=True, curveOnSurface=True, numberOfKnots=1, addKnots=False, insertBetween=True, replaceOriginal=True)
pointListA, pointListB, sideA, sideB = self.sqGetPointLists()
posListA, posListB = [], []
for i in range(0, len(pointListA)-1):
posListA.append(cmds.xform(pointListA[i], query=True, worldSpace=True, translation=True))
posListB.append(cmds.xform(pointListB[i], query=True, worldSpace=True, translation=True))
self.mainCurveA = cmds.curve(name="StickyLips_Main_A_Crv", degree=1, point=posListA)
self.mainCurveB = cmds.curve(name="StickyLips_Main_B_Crv", degree=1, point=posListB)
cmds.rename(cmds.listRelatives(self.mainCurveA, children=True, shapes=True)[0], self.mainCurveA+"Shape")
cmds.rename(cmds.listRelatives(self.mainCurveB, children=True, shapes=True)[0], self.mainCurveB+"Shape")
cmds.select(self.mainCurveA+".cv[*]")
self.curveLenght = len(cmds.ls(selection=True, flatten=True))
cmds.select(clear=True)
self.sqCheckCurveDirection(self.mainCurveA)
self.sqCheckCurveDirection(self.mainCurveB)
self.baseCurveA = cmds.duplicate(self.mainCurveA, name=self.mainCurveA.replace("_Main_", "_Base_"))[0]
self.baseCurveB = cmds.duplicate(self.mainCurveB, name=self.mainCurveB.replace("_Main_", "_Base_"))[0]
cmds.delete(self.baseCurve)
self.maxIter = len(posListA)
cmds.group(self.mainCurveA, self.mainCurveB, self.baseCurveA, self.baseCurveB, name="StickyLips_StaticData_Grp")
else:
mel.eval("warning \"Please, select an closed edgeLoop.\";")
def cici():
import maya.cmds as lj
import maya.mel as mm
sele = cmds.ls(sl=1)
pipei = cmds.radioButtonGrp('pipei',q=1,sl=1)
maya=cmds.textFieldButtonGrp('zong',q=1,tx=1)
name = cmds.textField('w',q=1,tx=1)
for i in sele:
a = []
a =i.split('.')
c=a[1][2:-1]
curve1 = cmds.polyToCurve(i,form=2,degree=3)
cmds.DeleteHistory(curve1)
edge =cmds.createNode("curveFromMeshEdge",n='new_CFME_#')
poc =cmds.createNode("pointOnCurveInfo",n='new_poc_#')
joint_t =cmds.createNode("joint",n=name+'_Jt_#')
jt_grp = cmds.group(joint_t,n=name+'_Jt_Gp_#')
cmds.setAttr(poc+'.turnOnPercentage',1)
cmds.setAttr(poc+'.parameter',1)
MD =cmds.createNode("multiplyDivide",n='new_MD_#')
cmds.setAttr(MD+'.input2Z',-1)
cmds.setAttr(MD+'.input2X',-1)
cmds.setAttr(MD+'.input2Y',-1)
shape = cmds.listRelatives(a[0],s=1)
shape1 = cmds.listRelatives(curve1[0],s=1)
cmds.setAttr(edge+'.edgeIndex[0]',int(c))
kong = cmds.curve(n=name,d=1,p=[(0,0,1),(0,0.5,0.866025),(0,0.866025,0.5),(0,1,0),(0,0.866025,-0.5),(0,0.5,-0.866025),(0,0,-1),(0,-0.5,-0.866025),(0,-0.866025,-0.5),(0,-1,0),(0,-0.866025,0.5),(0,-0.5,0.866025),(0,0,1),(0.707107,0,0.707107),(1,0,0),(0.707107,0,-0.707107),(0,0,-1),(-0.707107,0,-0.707107),(-1,0,0),(-0.866025,0.5,0),(-0.5,0.866025,0),(0,1,0),(0.5,0.866025,0),(0.866025,0.5,0),(1,0,0),(0.866025,-0.5,0),(0.5,-0.866025,0),(0,-1,0),(-0.5,-0.866025,0),(-0.866025,-0.5,0),(-1,0,0),(-0.707107,0,0.707107),(0,0,1)],k=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32])
grp0 = cmds.group(kong,n=name+'_Subtract')
grp1 = cmds.group(grp0,n=name+'_Offset')
grp2 = cmds.group(grp1,n=name+'_Attach')
cmds.connectAttr(shape[0]+'.worldMesh[0]',edge+'.inputMesh')
cmds.connectAttr(edge+'.outputCurve',shape1[0]+'.create')
cmds.connectAttr(shape1[0]+'.worldSpace[0]',poc+'.inputCurve')
cmds.connectAttr(poc+'.position',grp2+'.translate')
cmds.connectAttr(kong+'.translate',MD+'.input1')
cmds.connectAttr(MD+'.output',grp0+'.translate')
cmds.delete(cmds.parentConstraint(kong,jt_grp,w=1))
cmds.connectAttr(kong+'.translate',joint_t+'.translate')
cmds.connectAttr(kong+'.rotate',joint_t+'.rotate')
cmds.connectAttr(kong+'.scale',joint_t+'.scale')
cmds.select(kong+'.cv[0:32]')
cmds.scale(0.01,0.01,0.01)
se = cmds.listRelatives(kong,shapes=True)
cmds.setAttr(se[0]+'.overrideEnabled',1)
cmds.setAttr(se[0]+'.overrideColor',17)
cmds.select(cl=1)
if (pipei == 1):
cmds.connectAttr('Brs.rotate',grp2+'.rotate')
cmds.connectAttr('Brs.scale',grp2+'.scale')
cmds.parent(curve1[0],'ClusterSetup')
cmds.parent(jt_grp,'FaceAttachToHead')
cmds.setAttr(curve1[0]+'.v',0)
if (pipei == 2):
cmds.connectAttr(maya+'.rotate',grp2+'.rotate')
cmds.connectAttr(maya+'.scale',grp2+'.scale')
def polyCenterCurves(self, *args):
cmd.select(self.curve1)
cur1 = cmd.polyToCurve(f=2, dg=3)
cmd.DeleteHistory(cur1[0])
cmd.select(self.curve2)
cur2 = cmd.polyToCurve(f=2, dg=3)
cmd.DeleteHistory(cur2[0])
self.point = []
self.pointOnCur(cur1[0], cur2[0])
cmd.delete(cur1[0], cur2[0])
int_i = len(self.point)
for pi in range(0, int_i):
if pi == 0:
centerCur = cmd.curve(d=3, p=self.point[pi], k=[0, 0, 0])
else:
cmd.curve(centerCur, a=1, p=self.point[pi])
cmd.select(cl=1)
print "////生成完毕" + "\n",
def createEyelidsCrv (self, eyePrefix, upperLidVtx, lowerLidVtx, rigGrp): '''Creates nurbsCurve out of each lid vertices. Called by 'buildRig' function. Call functions: None ''' cmds.select (cl = 1) # Organize rig hierarchy self.hierarchyCrvGrp = cmds.group (n = (eyePrefix + "_Eyelids_curves_GRP"), em = 1) self.hierarchyUpCrvGrp = cmds.group (n = (eyePrefix + "_UpEyelid_curves_GRP"), em = 1) self.hierarchyLowCrvGrp = cmds.group (n = (eyePrefix + "_LowEyelid_curves_GRP"), em = 1) cmds.parent (self.hierarchyUpCrvGrp, self.hierarchyCrvGrp) cmds.parent (self.hierarchyLowCrvGrp, self.hierarchyCrvGrp) cmds.parent (self.hierarchyCrvGrp, rigGrp) # Upper eyelid cmds.select (upperLidVtx) edgeUpLid = cmds.polyListComponentConversion (fv = 1, te = 1, internal = 1) cmds.select (edgeUpLid) tempCrvUp = cmds.polyToCurve (form = 0, degree = 1) [0] cmds.select (tempCrvUp) cmds.delete (ch = 1) upLidCrvName = eyePrefix + "_UpEyelid_BASE_curve" self.upLidCrv = cmds.rename (tempCrvUp, upLidCrvName) cmds.parent (self.upLidCrv, self.hierarchyUpCrvGrp) # Lower eyelid cmds.select (lowerLidVtx) edgeLowLid = cmds.polyListComponentConversion (fv = 1, te = 1, internal = 1) cmds.select (edgeLowLid) tempCrvLow = cmds.polyToCurve (form = 0, degree = 1) [0] cmds.select (tempCrvLow) cmds.delete (ch = 1) lowLidCrvName = eyePrefix + "_LowEyelid_BASE_curve" self.lowLidCrv = cmds.rename (tempCrvLow, lowLidCrvName) cmds.parent (self.lowLidCrv, self.hierarchyLowCrvGrp)
def createCurveFromEdge( value, degree=3 ):
print "degree : ", degree
sels = cmds.ls( sl=1 )
if not sels: return None
if cmds.nodeType( sels[0] ) == 'transform':
sels[0] = cmds.listRelatives( sels[0], s=1 )[0]
if cmds.nodeType( sels[0] ) == 'nurbsCurve':
if not value: return None
cmds.rebuildCurve( sels[0], ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=0, kt=0, s=value, tol=0.01 )
else:
curveObject, node = cmds.polyToCurve( form=0, degree=degree )
crvShape= cmds.listRelatives( curveObject, s=1 )[0]
cmds.setAttr( crvShape+'.dispCV', 1 )
if value:
cmds.rebuildCurve( curveObject, ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=0, kt=0, s=value, tol=0.01 )
def createCurve(edgeList,
rebuild=True,
spans=4):
"""
Create a fine curve from selection
:param edgeList: list(str), flattened edge list to created new curve.
:param rebuild: bool, whether rebuild the created line or not.
:param spans: int, if rebuild the created line, spans of the rebuilded curve.
:return: str, new curve.
"""
# check the edge list
for i in edgeList:
if getComponentType(i) != 'e':
cmds.error('Please select edges')
return
# create each line
curves = []
if edgeList and len(edgeList) >= 2:
for crv in edgeList:
curve = cmds.polyToCurve(crv, form=0, degree=1, ch=0)[0]
curves.append(curve)
else:
cmds.error('Please select at least 2 lines!')
return
# attach each line and clean the trash lines
outputCurve = []
if curves:
outputCurve = cmds.attachCurve(curves[:], ch=0, method=0, kmk=0)
trashGrp = cmds.group(em=1)
for i in xrange(len(outputCurve) - 1):
cmds.parent(outputCurve[i+1], trashGrp)
cmds.delete(trashGrp)
# if needed, rebuild the attached line
finalCurve = None
if rebuild and spans:
finalCurve = cmds.rebuildCurve(outputCurve[0], ch=0, degree=3, spans=spans, end=1, rebuildType=0)
else:
finalCurve = outputCurve[0]
return finalCurve
def createCurveToEdgeLoop():
sels = cmds.ls(sl=1, fl=1)
selObject = cmds.ls(sl=1, o=1)[0]
selObject = cmds.listRelatives(selObject, p=1)[0]
excutedEdges = []
curves = []
for sel in sels:
if sel in excutedEdges: continue
cmds.select(sel)
cmds.SelectEdgeLoopSp()
excutedEdges += cmds.ls(sl=1, fl=1)
curves.append(cmds.polyToCurve(form=0, degree=3)[0])
cmds.select(curves)
cmds.DeleteHistory()
return cmds.ls(sl=1)
def createCurveToEdgeLoop():
sels = cmds.ls( sl=1, fl=1 )
selObject = cmds.ls( sl=1, o=1 )[0]
selObject = cmds.listRelatives( selObject, p=1 )[0]
excutedEdges = []
curves = []
for sel in sels:
if sel in excutedEdges: continue
cmds.select( sel )
cmds.SelectEdgeLoopSp()
excutedEdges += cmds.ls(sl=1, fl=1 )
curves.append( cmds.polyToCurve( form=0, degree=3 )[0] )
cmds.select( curves )
cmds.DeleteHistory()
return cmds.ls( sl=1 )
def ctrlFromEdges(cls, *args):
'''
This function create control from selected polygon for selected joint.
First select a joint and select polygons.
'''
jnt = cmds.textFieldButtonGrp(UI.widgets['jntTxtFldBtnGrp'],
q=True,
text=True)
edges = cmds.textScrollList(UI.widgets['edgeTxtScrLs'],
q=True,
allItems=True)
jntSrchStr = cmds.textFieldGrp(UI.widgets['jntsrchTxtFldGrp'],
q=True,
text=True)
jntRplcStr = cmds.textFieldGrp(UI.widgets['jntrplcTxtFldGrp'],
q=True,
text=True)
# Convert selected faces to control shape
cmds.select(edges, r=True)
ctrlCrv = cmds.polyToCurve(form=2, degree=1)[0]
cmds.delete(ctrlCrv, ch=True)
# Match control transform node to the joint
ctrlName = re.sub(jntSrchStr, jntRplcStr, jnt)
trnsf = cmds.createNode('transform', n=ctrlName)
cnst = cmds.parentConstraint(jnt, trnsf, mo=False)
cmds.delete(cnst)
# Parent control shape to the control transform node in place
tak_lib.parentShpInPlace(ctrlCrv, trnsf)
# Match shape name to transform name
shapName = cmds.listRelatives(trnsf, s=True)[0]
if shapName != '%sShape' % trnsf:
cmds.rename(shapName, '%sShape' % trnsf)
# tak_misc.doGroup(trnsf, '_zero')
# Connect joint to the control
cmds.parentConstraint(trnsf, jnt, mo=False)
cmds.delete(ctrlCrv)
def edge_loop_to_curve(edge_name, delete_edges=False):
cmds.select(edge_name)
cmds.pickWalk(edge_name, type="edgeloop", d="right")
curve_name, shape_name = cmds.polyToCurve(form=2, degree=3)
cvs = cmds.getAttr("{}.spans".format(curve_name))
curve_points = []
for cv_id in range(cvs):
cv_name = "{}.cv[{}]".format(curve_name, cv_id)
pos = get_position(cv_name)
curve_points.append(Component(cv_name, *pos))
if delete_edges:
cmds.select(edge_name)
cmds.pickWalk(edge_name, type="edgeloop", d="right")
cmds.polyDelEdge(cv=True)
cmds.select(curve_name)
cmds.Delete()
return curve_points
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 distribute(edgeLoop):
edgeSel = cmds.ls(edgeLoop, fl=True)
vertList = cmds.ls(cmds.polyListComponentConversion(edgeSel,
toVertex=True),
fl=True)
tempCurveName = uniqueNameGenerator()
if cmds.radioCollection('interpolation_radioCollection2',
select=True,
q=True) == 'curved_radioButton':
cmds.polyToCurve(n=tempCurveName, form=2, degree=3, ch=False)
else:
cmds.polyToCurve(n=tempCurveName, form=2, degree=1, ch=False)
CVtoDelete = []
for i in range(1, len(vertList) - 1):
CVtoDelete.append(tempCurveName + '.cv[' + str(i) + ']')
cmds.delete(CVtoDelete)
cmds.rebuildCurve(tempCurveName,
ch=False,
replaceOriginal=True,
rt=0,
end=1,
kr=0,
kep=1,
kt=0,
s=len(vertList) - 1,
d=3,
tol=0.01)
accuracy = 4
firstEPPos = [
round(elem, accuracy)
for elem in cmds.pointPosition(tempCurveName + '.ep[0]')
]
vertListOrdered = []
for edge in edgeSel:
edgeVert = cmds.ls(cmds.polyListComponentConversion(edge,
toVertex=True),
fl=True)
for v in edgeVert:
vPos = [round(elem, accuracy) for elem in cmds.pointPosition(v)]
if vPos == firstEPPos:
vertListOrdered.append(v)
while len(vertListOrdered) < len(vertList):
for edge in edgeSel:
vertEdge = cmds.ls(cmds.polyListComponentConversion(edge,
toVertex=True),
fl=True)
counter = []
for v in vertEdge:
if v not in vertListOrdered:
counter.append(v)
else:
pass
if len(counter) == 1:
vertListOrdered.append(counter[0])
else:
pass
for v in vertListOrdered:
epPos = cmds.pointPosition(tempCurveName + '.ep[' +
str(vertListOrdered.index(v)) + ']')
cmds.move(epPos[0], epPos[1], epPos[2], v, absolute=True)
cmds.delete(tempCurveName)
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 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 )
extrudeFaces = []
for i in range(0, div):
curFace = rail[0] + '.f[' + str(2 + div + i) + ']' # left side faces
extrudeFaces.append(curFace)
for i in range(0, div):
curFace = rail[0] + '.f[' + str(2 + (div * 3) + i) + ']' # right side faces
extrudeFaces.append(curFace)
mc.polyExtrudeFacet(extrudeFaces, thickness=1.6)
edgeForCurveLeft = []
for i in range(0, div):
curFace = rail[0] + '.e[' + str(10 + (div * 6) + (i * 5)) + ']' # left side faces
edgeForCurveLeft.append(curFace)
mc.select(edgeForCurveLeft)
leftCurve = mc.polyToCurve()
pos = mc.pointOnCurve(leftCurve[0], pr=0, top=True)
tan = mc.pointOnCurve(leftCurve[0], pr=0, t=True, top=True)
rot = math.degrees(math.atan2(tan[0], tan[2]))
leftRail = mc.polyPlane(sx=1, sy=1)
mc.move(pos[0], pos[1], pos[2])
mc.rotate(90, rot, 0)
mc.select(leftRail[0] + '.f[0]', leftCurve[0])
div = numSleepers * 2
mc.polyExtrudeFacet(leftRail[0] + '.f[0]', inputCurve=leftCurve[0], divisions=div)
edgeForCurveRight = []
for i in range(0, div):
curFace = rail[0] + '.e[' + str(16 + (div * 11) + (i * 5)) + ']' # right side faces
edgeForCurveRight.append(curFace)
def createCrvDriverSys(nodeName, ctlNum, form=0, attachGeo=None):
'''
Create driver system based on edge loop selection in viewport
nodeName [string]
ctlNum [int] - number of controls to add along curve
form - [int] 0 = open, 1 = periodic
Returns drvSysGrp, and a list of locators that can be used to drive offset controls
'''
# select edge loop in UI
drvCrv, p2cNode = mc.polyToCurve(form=form, degree=1, n=nodeName+'_wireOffset_crv')
p2cNode = mc.rename(p2cNode, nodeName+'_wireOffset_p2c')
crvSpans = mc.getAttr(drvCrv+'.spans')
# create control placement locators on drvCrv
drvLocs = []
for ctlId in range(ctlNum):
loc = mc.spaceLocator(n=nodeName+'_wireOffset_drvLoc%d'%ctlId)[0]
param = float(ctlId) / ctlNum * crvSpans
rt.attachToMotionPath(drvCrv, param, loc, False)
drvLocs.append(loc)
# if curve is open, we will create an extra ctl, where param = crvSpans
if mc.getAttr(drvCrv+'.form') != 2:
loc = mc.spaceLocator(n=nodeName+'_wireOffset_drvLoc%d'%ctlNum)[0]
param = crvSpans
rt.attachToMotionPath(drvCrv, param, loc, False)
drvLocs.append(loc)
drvLocGrp = mc.group(drvLocs, n=nodeName+'_wireOffset_drvLocs_grp')
drvSysGrp = mc.group(drvCrv, drvLocGrp, n=nodeName+'_wireOffset_drvSys_grp')
rt.connectVisibilityToggle(drvLocs, drvSysGrp, 'drvLocsVis', False)
rt.connectVisibilityToggle(drvCrv, drvSysGrp, 'drvCrvVis', False)
mc.addAttr(drvSysGrp, ln='enabled', at='bool', k=True, dv=True)
rt.connectSDK(drvSysGrp+'.enabled', p2cNode+'.nodeState', {1:0, 0:2})
# if attachGeo is defined, use attachGeo to drive polyToCurve
if attachGeo:
# make an origLoc for each driverLoc to preserve orig positions
origLocs = []
for eachLoc in drvLocs:
origLoc = mc.group(n=eachLoc.replace('_drvLoc', '_drvLocOrig'), em=True)
rt.parentSnap(origLoc, eachLoc)
mc.parent(origLoc, w=True)
origLocs.append(origLoc)
# switch the input mesh for polyToCurve -> this will move drvLocs
mc.connectAttr(attachGeo, p2cNode+'.inputPolymesh', f=True)
# parent orig loc back under driver loc, preserving transforms
for drv, orig in zip(drvLocs, origLocs):
mc.parent(orig, drv)
return drvSysGrp, origLocs
return drvSysGrp, drvLocs
def Brow():
Info = cm.textFieldGrp(TfbGrp, q=True, tx=True)
Sec = cm.intSliderGrp(IsGrp01, q=True, v=True)
Tw = cm.intSliderGrp(IsGrp02, q=True, v=True)
cm.select(Info.split(","))
Cbr = cm.polyToCurve(form=2,
degree=1,
conformToSmoothMeshPreview=1,
n="Brow_L_Cv")
Lbr = cm.rebuildCurve(Cbr[0],
ch=1,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=0,
s=Tw - 1,
d=1,
tol=0.01)
Rbr = cm.duplicate(Lbr[0], rr=True, n="Brow_R_Cv")
cm.setAttr(Rbr[0] + ".sx", -1)
cm.makeIdentity(apply=True, t=0, r=0, s=1, n=0, pn=1)
# Sp=cm.getAttr(Br[0]+"Shape.s")
cm.select(cl=True)
for i in range(0, Tw):
Lwt = cm.xform(Lbr[0] + ".cv[" + str(i) + "]", ws=True, q=True, t=True)
Rwt = cm.xform(Rbr[0] + ".cv[" + str(i) + "]", ws=True, q=True, t=True)
Ljnt = cm.joint(n="brow_L0" + str(i) + "_fur_jnt",
p=(Lwt[0], Lwt[1], Lwt[2]),
a=True)
select(cl=True)
Rjnt = cm.joint(n="brow_R0" + str(i) + "_fur_jnt",
p=(Rwt[0], Rwt[1], Rwt[2]),
a=True)
select(cl=True)
if (i % 2 == 0) and (Sec):
Lsc = cm.circle(c=(0, 0, 0),
nr=(0, 0, 1),
sw=360,
r=1,
d=3,
ut=0,
tol=0.01,
s=8,
ch=1,
n="brow_L_sec_0" + str(i) + "_ctl")
Lscj = cm.joint(n="brow_L_sec_0" + str(i) + "_jnt")
Lbnpo = cm.group(Lsc[0], n="brow_L_sec_0" + str(i) + "_bufferNpo")
Lnpo = cm.group(Lsc[0], n="brow_L_sec_0" + str(i) + "_npo")
cm.setAttr(Lbnpo + ".t", Lwt[0], Lwt[1], Lwt[2])
Rsc = cm.circle(c=(0, 0, 0),
nr=(0, 0, 1),
sw=360,
r=1,
d=3,
ut=0,
tol=0.01,
s=8,
ch=1,
n="brow_R_sec_0" + str(i) + "_ctl")
Rscj = cm.joint(n="brow_R_sec_0" + str(i) + "_jnt")
Rbnpo = cm.group(Rsc[0], n="brow_R_sec_0" + str(i) + "_bufferNpo")
Rnpo = cm.group(Rsc[0], n="brow_R_sec_0" + str(i) + "_npo")
cm.setAttr(Rbnpo + ".t", Rwt[0], Rwt[1], Rwt[2])
select(cl=True)
Sec -= 1
cm.select(cl=True)
# Ctl=cm.curve(d=1,p=[(-0.165186, 0.165186, 0.57),(0.165186, 0.165186, 0.57),(0.165186, -0.165186, 0.57),(-0.165186, -0.165186, 0.57),(-0.165186,0.165186,0.57),(-0.165186, 0.165186, -0.43),(0.165186, 0.165186, -0.43),( 0.165186, -0.165186, -0.43),(-0.165186, -0.165186, -0.43),(-0.165186, 0.165186, -0.43),(-0.165186, 0.165186, 0.57),(0.165186, 0.165186, 0.57),(0.165186, 0.165186, -0.43),(0.165186, -0.165186, -0.43),(0.165186, -0.165186, 0.57),(-0.165186, -0.165186, 0.57),(-0.165186, -0.165186, -0.43)],k=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16],n="brow_L0"+str(i)+"_tweakBrow_ctl")
# Grp=cm.group(Ctl[0],q
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 createNurb(uNumber=5, vNumber=5, side=None, name=None, mX=0, mY=0, mZ=0):
name = '{}_{}_nurb'.format(name, side)
try:
crv = cmds.polyToCurve(n='deletableCurve',
form=2,
degree=3,
conformToSmoothMeshPreview=1)[0]
degs = cmds.getAttr('{}.degree'.format(crv))
spans = cmds.getAttr('{}.spans'.format(crv))
cvs = degs + spans
#
#crv1 = cmds.duplicate(crv, n='deletableCurve1')[0]
#cmds.select('{}.cv[0:{}]'.format(crv1, cvs))
#cmds.move(mX, mY, mZ, r=True, os=True, wd=True)
#crv2 = cmds.duplicate(crv, n='deletableCurve2')[0]
#cmds.select('{}.cv[0:{}]'.format(crv2, cvs))
#mX= mX*(-1)
#mY= mY*(-1)
#mZ= mZ*(-1)
#cmds.move(mX, mY, mZ, r=True, os=True, wd=True)
mnX = mX * (-1)
offst_curve1 = cmds.offsetCurve(crv, d=mX)[0]
offst_curve2 = cmds.offsetCurve(crv, d=mnX)[0]
surf = cmds.loft(offst_curve1,
offst_curve2,
ch=1,
u=1,
c=0,
ar=1,
d=3,
ss=1,
rn=0,
po=0,
rsn=True,
n=name)[0]
cmds.rebuildSurface(surf,
ch=1,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=0,
kc=0,
su=uNumber,
du=3,
sv=vNumber,
dv=3,
tol=0.01,
fr=0,
dir=2)
cmds.delete(surf, ch=True)
for c in [crv, offst_curve1, offst_curve2]:
cmds.delete(c)
except:
cmds.nurbsPlane(n=name,
ax=(0, 1, 0),
w=True,
lr=True,
d=3,
u=uNumber,
v=vNumber,
ch=1)
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 doLayeredFkTongue():
sides = ['L', 'R']
facialFGrp = 'facial_fGrp'
facialDriversGrp = 'facialDrivers'
tongueRoot = 'tongue_jnt_1_orig'
storeGroup = 'tongue_noXformGrp'
headSKN = 'head_SKN'
bcsNode = mc.ls(type='DPK_bcs')[0]
headMeshShape = mel.eval('DPK_bcs -q -g %s' % bcsNode)[0]
'''
#get edges Manually
getEdges = mc.ls(sl=True,fl=True)
Edges = []
for edge in getEdges:
asciiName = edge.encode('ascii','ignore')
Edges.append(asciiName)
print Edges
'''
# get list of edges to generate base tongue surf
lVertices = [
u'head_hi_bcsObj.vtx[5677]', u'head_hi_bcsObj.vtx[5678]',
u'head_hi_bcsObj.vtx[5683]', u'head_hi_bcsObj.vtx[5686]',
u'head_hi_bcsObj.vtx[5689]', u'head_hi_bcsObj.vtx[5692]',
u'head_hi_bcsObj.vtx[5693]', u'head_hi_bcsObj.vtx[5697]',
u'head_hi_bcsObj.vtx[5699]', u'head_hi_bcsObj.vtx[5700]',
u'head_hi_bcsObj.vtx[5710]', u'head_hi_bcsObj.vtx[5714]',
u'head_hi_bcsObj.vtx[5715]', u'head_hi_bcsObj.vtx[5775]',
u'head_hi_bcsObj.vtx[7369]', u'head_hi_bcsObj.vtx[7558]',
u'head_hi_bcsObj.vtx[7561]', u'head_hi_bcsObj.vtx[7564]',
u'head_hi_bcsObj.vtx[7567]', u'head_hi_bcsObj.vtx[7570]',
u'head_hi_bcsObj.vtx[7572]', u'head_hi_bcsObj.vtx[7574]',
u'head_hi_bcsObj.vtx[7576]', u'head_hi_bcsObj.vtx[7582]',
u'head_hi_bcsObj.vtx[7586]', u'head_hi_bcsObj.vtx[7590]',
u'head_hi_bcsObj.vtx[7600]', u'head_hi_bcsObj.vtx[8259]',
u'head_hi_bcsObj.vtx[8291]', u'head_hi_bcsObj.vtx[8303]'
]
rVertices = [
u'head_hi_bcsObj.vtx[1274]', u'head_hi_bcsObj.vtx[1275]',
u'head_hi_bcsObj.vtx[1280]', u'head_hi_bcsObj.vtx[1283]',
u'head_hi_bcsObj.vtx[1286]', u'head_hi_bcsObj.vtx[1289]',
u'head_hi_bcsObj.vtx[1290]', u'head_hi_bcsObj.vtx[1294]',
u'head_hi_bcsObj.vtx[1296]', u'head_hi_bcsObj.vtx[1297]',
u'head_hi_bcsObj.vtx[1307]', u'head_hi_bcsObj.vtx[1311]',
u'head_hi_bcsObj.vtx[1312]', u'head_hi_bcsObj.vtx[1372]',
u'head_hi_bcsObj.vtx[2966]', u'head_hi_bcsObj.vtx[3155]',
u'head_hi_bcsObj.vtx[3158]', u'head_hi_bcsObj.vtx[3161]',
u'head_hi_bcsObj.vtx[3164]', u'head_hi_bcsObj.vtx[3167]',
u'head_hi_bcsObj.vtx[3169]', u'head_hi_bcsObj.vtx[3171]',
u'head_hi_bcsObj.vtx[3173]', u'head_hi_bcsObj.vtx[3179]',
u'head_hi_bcsObj.vtx[3183]', u'head_hi_bcsObj.vtx[3187]',
u'head_hi_bcsObj.vtx[3197]', u'head_hi_bcsObj.vtx[3856]',
u'head_hi_bcsObj.vtx[3888]', u'head_hi_bcsObj.vtx[3900]'
]
lEdges = mc.polyListComponentConversion(lVertices,
fv=True,
te=True,
internal=True)
rEdges = mc.polyListComponentConversion(rVertices,
fv=True,
te=True,
internal=True)
edgesLists = [lEdges, rEdges]
#creates store group for futur cleanup
mc.group(n=storeGroup, em=True)
mc.setAttr('%s.inheritsTransform' % storeGroup, False)
mc.hide(storeGroup)
mc.parent(storeGroup, facialFGrp)
#create head_SKN decomposeMatrix for later use
headSKMDM = mc.createNode('decomposeMatrix', n='%s_dm' % headSKN)
mc.connectAttr('%s.worldMatrix[0]' % headSKN, '%s.inputMatrix' % headSKMDM)
#creates nodeBased surf from edges selection
baseTongueLoft = mc.createNode('loft', n='tongueBase_loft')
mc.setAttr('%s.autoReverse' % baseTongueLoft, False)
tongueBaseSurf = mc.createNode('nurbsSurface', n='tongueBase_surfShape')
mc.connectAttr('%s.outputSurface' % baseTongueLoft,
'%s.create' % tongueBaseSurf)
mc.parent(mc.listRelatives(tongueBaseSurf, p=True)[0], facialDriversGrp)
petcList = []
for i, list in enumerate(edgesLists):
mc.select(list)
baseTongueCrv = mc.polyToCurve(ch=True,
degree=3,
form=0,
n='%s_tongueBase_crv' % sides[i])
baseTonguePetc = mc.rename(baseTongueCrv[1],
'%s_tongueBase_petc' % sides[i])
petcList.append(baseTonguePetc)
curveShape = mc.listRelatives(baseTongueCrv[0], s=True)[0]
mc.connectAttr('%s.outputcurve' % baseTonguePetc,
'%s.inputCurve[%d]' % (baseTongueLoft, i))
mc.delete(baseTongueCrv[0])
#Generate FK proxy hierarchy from template tongue
## get all tongue Pose nodes
allTongueObj = mc.listRelatives(tongueRoot, ad=True, type='transform')
tonguePose = []
for obj in allTongueObj:
splitName = obj.rsplit('_', 2)
if splitName[1] == 'pose':
tonguePose.append(obj)
## create FK proxy hyerarchy
###creates proxy Nodes
tonguePoseProxy = []
for pose in tonguePose:
mc.select(cl=True)
newPose = mc.joint(n='%s_proxy' % pose)
tonguePoseProxy.append(newPose)
mc.setAttr('%s.radius' % newPose, 0.02)
newSkin = mc.duplicate(newPose, n=newPose.replace('pose', 'SKN'))
mc.parent(newSkin, newPose)
mewOrig = orig.orig(objlist=[newPose],
suffix=['_orig'],
origtype='joint',
fromsel=False,
viz=False,
get_ssc=False,
rtyp='auto')[0]
mc.rename(mewOrig, mewOrig.replace('pose', 'jnt'))
### recreates parenting
firstProxyNode = ''
for pose in tonguePose:
poseOrig = mc.listRelatives(pose, p=True)[0]
poseProxy = '%s_proxy' % pose
poseOrigProxy = mc.listRelatives(poseProxy, p=True)[0]
poseOrigParent = mc.listRelatives(poseOrig, p=True)[0]
poseOrigProxyParent = '%s_proxy' % poseOrigParent
if not poseOrigParent == 'jaw_SKN':
mc.parent(poseOrigProxy, poseOrigProxyParent)
elif poseOrigParent == 'jaw_SKN':
firstProxyNode = poseOrigProxy
### match proxy nodes on local nodes
mc.parent(firstProxyNode, 'jaw_SKN')
firstNode = firstProxyNode.replace('_proxy', '')
patchLib.smartcopyAttr(firstNode, firstProxyNode)
allProxyNodes = mc.listRelatives(firstProxyNode, ad=True)
for node in allProxyNodes:
rigNode = node.replace('_proxy', '')
patchLib.smartcopyAttr(rigNode, node)
# create cns nodes
tongueCns = []
for pose in tonguePoseProxy:
### create cns and hooks hierarchy
poseTest = int(pose.rsplit('_', 2)[1])
cnsNode = mc.group(n=pose.replace('proxy', 'cns'), em=True)
mc.parent(cnsNode, pose, r=True)
mc.parent(cnsNode, w=True)
cnsHookNode = mc.duplicate(cnsNode, n=cnsNode.replace('cns', 'hook'))
tongueCns.append(cnsNode)
### connect cns nodes to surface with Xrivet, then constraint proxy nodes to cns nodes
surf = mc.listRelatives(tongueBaseSurf, p=True)[0]
if poseTest <= (len(tonguePoseProxy) - 3):
xRivet = xrivetTrOnNurbs(cnsNode,
surf,
mainDirection=1,
out='worldSpace[0]',
u=None,
v=None,
offsetOrient=[0, 0, 0],
min=False)
mc.parentConstraint(cnsHookNode, pose, mo=True)
massConnect(pose, pose.replace('_proxy', ''))
mc.connectAttr('%s.outputScale' % headSKMDM, '%s.scale' % cnsNode)
else:
mc.parentConstraint('jaw_SKN', cnsNode, mo=True)
mc.parentConstraint(cnsHookNode, pose, mo=True)
massConnect(pose, pose.replace('_proxy', ''))
mc.parent(cnsHookNode, cnsNode)
### connect local poseNodes rotate ORders to proxy rotate ORders
source = pose.replace('_proxy', '')
mc.connectAttr('%s.rotateOrder' % source, '%s.rotateOrder' % pose)
#### cleanup
mc.parent(cnsNode, storeGroup)
def makeCurve(edgeloop): return cmds.polyToCurve(form=2, degree=1)
