def CurveCtr(self, *args):
ctrNum = cmds.intSliderGrp('ctrNum', q=True, value=True)
selCurve = cmds.textField("curvename", q=True, text=True)
selJnt = cmds.textField("jntname", q=True, text=True)
global POCNodes
self.doNumOffset(selCurve)
print ctrNum, selCurve, selJnt
try:
if ctrNum < 1:
return
for i in range(0, ctrNum):
print "im in for circle"
jntCtrGrp = self.creatJntCtr(selCurve + "_Jnt" +
str(i + self.numOffset))
print jntCtrGrp
POCNode = self.creatPointOnCurve(selCurve, jntCtrGrp + "_poc")
self.POCNodes.append(POCNode)
print "im out poc"
print POCNode
cmds.connectAttr(POCNode + ".position",
jntCtrGrp + ".translate")
cmds.tangentConstraint(selCurve,
jntCtrGrp,
w=1,
aimVector=(1, 0, 0),
worldUpType="objectrotation",
worldUpVector=(0, 1, 0),
worldUpObject=selJnt)
cmds.scaleConstraint(selJnt + "_Ctrl", jntCtrGrp, mo=True, w=1)
self.changePosUI()
except Exception as e:
raise e
def lip_setup(upperLipCurve, lowerLipCurve, upperLocators, lowerLocators, lipUp):
upperLipCtrlCurve = utils.rebuild_to_ctrlCurve(upperLipCurve, spans=5, name='upperLipRCtrlCurve')
lowerLipCtrlCurve = utils.rebuild_to_ctrlCurve(lowerLipCurve, spans=5, name='lowerLipRCtrlCurve')
upperWireNode, upperWire, upperWireBase = utils.wire_deformer(upperLipCtrlCurve, upperLipCurve)
lowerWireNode, lowerWire, lowerWireBase = utils.wire_deformer(lowerLipCtrlCurve, lowerLipCurve)
upperWireMaster = utils.create_wires_master([upperWire, upperWireBase], name='upperLipRWireMaster_DELETE')
lowerWireMaster = utils.create_wires_master([lowerWire, lowerWireBase], name='lowerLipRWireMaster_DELETE')
#upperLocators = utils.create_locators_on_cv(upperLipCurve)
for loc in upperLocators :
utils.revit_locator_to_curve(loc, upperLipCurve)
cmds.tangentConstraint(upperLipCurve, loc, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=lipUp)
cmds.select(clear=True)
j = cmds.joint()
g = cmds.group(j)
pm.parentConstraint(loc, g, mo=False)
#lowerLocators = utils.create_locators_on_cv(lowerLipCurve)
for loc in lowerLocators :
utils.revit_locator_to_curve(loc, lowerLipCurve)
cmds.tangentConstraint(lowerLipCurve, loc, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=lipUp)
cmds.select(clear=True)
j = cmds.joint()
g = cmds.group(j)
pm.parentConstraint(loc, g, mo=False)
return upperLipCurve, lowerLipCurve, upperLipCtrlCurve, lowerLipCtrlCurve
def tangentNormalAxisSet(self): # stretch locator attatch and twist setting
# import var "self.stPOCI_list" , "stCRV_loc"
self.upLoc_list = list()
self.twistLoc_list = list()
for k in self.IKBodyJointList:
locXform = cmds.xform(k , ws=True, q=True, t=True)
upLoc = cmds.spaceLocator(n = k.replace(k.split('_')[-1], 'upVec_LOC') , p =(locXform[0],locXform[1],locXform[2]))[0]
cmds.CenterPivot(upLoc)
cmds.setAttr('%s.template' % upLoc, 1)
twistLoc = cmds.spaceLocator(n = k.replace(k.split('_')[-1], 'twist_LOC') , p =(locXform[0],locXform[1],locXform[2]))[0]
twistLocS = cmds.listRelatives(twistLoc , s=1)[0]
cmds.parent(twistLoc , self.stCRV_loc[self.IKBodyJointList.index(k)])
for j in self.XYZ:
cmds.setAttr('%s.localPosition%s' %(twistLoc,j) , 0 )
cmds.setAttr('%s.translate%s' %(twistLoc,j) , 0 )
cmds.setAttr('%s.rotate%s' %(twistLoc,j) , 0 )
cmds.setAttr('%s.template' % twistLoc, 1)
cmds.setAttr('%s.ty' %upLoc , 20)
self.upLoc_list.append(upLoc)
self.twistLoc_list.append(twistLoc)
for i in self.stCRV_loc:
cmds.tangentConstraint(self.pathBody_crv,i,wut='object',wuo='%s' %self.upLoc_list[self.stCRV_loc.index(i)])
for i in range(len(self.twistLoc_list)):
cmds.parentConstraint(self.twistLoc_list[i],self.IKBodyJointList[i],mo=1)
cmds.hide('templateJoint_GRP')
self.twistBodySet()
self.upVecLocControlSet()
def pocCon(self,name,ctrl):
#create pointOnCurve node
pocNode=mc.createNode("pointOnCurveInfo",name="POC_{0}".format(name))
#connect POC to connector curve and ctrl
mc.connectAttr(self.conCurve+".worldSpace",pocNode+".inputCurve", force=True)
mc.connectAttr(pocNode+".position", ctrl[0]+".translate", force=True)
mc.connectAttr(ctrl[0]+".position", pocNode+".parameter", force=True)
#tangent constrain to curve
mc.tangentConstraint(self.conCurve,ctrl[0], aim=(0,1,0), upVector=(0,0,1), wut="vector", wu=(0,1,0))
def targetAliasList(constraint):
'''
Return a list of targets (drivers) attribute aliases for the specified constraint node
@param constraint: The constraint node whose targets will be returned
@type constraint: str
'''
# Check Constraint
if not isConstraint(constraint):
raise Exception('Constraint "'+constraint+'" does not exist!!')
# Get Target List
targetList = []
constraintType = mc.objectType(constraint)
if constraintType == 'aimConstraint': targetList = mc.aimConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'geometryConstraint': targetList = mc.geometryConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'normalConstraint': targetList = mc.normalConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'orientConstraint': targetList = mc.orientConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'parentConstraint': targetList = mc.parentConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'pointConstraint': targetList = mc.pointConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'poleVectorConstraint': targetList = mc.poleVectorConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'scaleConstraint': targetList = mc.scaleConstraint(constraint,q=True,weightAliasList=True)
elif constraintType == 'tangentConstraint': targetList = mc.tangentConstraint(constraint,q=True,weightAliasList=True)
# Check Target List
if not targetList: targetList = []
# Return Result
return targetList
def targetAliasList(constraint):
"""
Return a list of targets (drivers) attribute aliases for the specified constraint node
@param constraint: The constraint node whose targets will be returned
@type constraint: str
"""
# Check Constraint
if not isConstraint(constraint):
raise Exception('Constraint "' + constraint + '" does not exist!!')
# Get Target List
targetList = []
constraintType = cmds.objectType(constraint)
if constraintType == 'aicmdsonstraint':
targetList = cmds.aicmdsonstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'geometryConstraint':
targetList = cmds.geometryConstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'normalConstraint':
targetList = cmds.normalConstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'orientConstraint':
targetList = cmds.orientConstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'parentConstraint':
targetList = cmds.parentConstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'pointConstraint':
targetList = cmds.pointConstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'poleVectorConstraint':
targetList = cmds.poleVectorConstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'scaleConstraint':
targetList = cmds.scaleConstraint(constraint,
q=True,
weightAliasList=True)
elif constraintType == 'tangentConstraint':
targetList = cmds.tangentConstraint(constraint,
q=True,
weightAliasList=True)
# Check Target List
if not targetList: targetList = []
# Return Result
return targetList
def CurveInfo(self,jntLable,curveSurface,curveSurfaceAim,numberGrp):
curveSpace = mc.listRelatives(curveSurface)
curveAimSpace = mc.listRelatives(curveSurfaceAim)
curveMaxValue = mc.getAttr(curveSurface+'.maxValue')
parentGrp = mc.createNode('transform',name = jntLable +'_hyperbola_grp')
aimGrp = mc.createNode('transform',name = jntLable +'_aim_grp')
pciGrp = mc.createNode('transform',name = jntLable +'_pci_grp')
mc.parent(aimGrp,pciGrp,parentGrp)
for i in range(numberGrp):
pciNode = mc.createNode('pointOnCurveInfo',name = jntLable +'_Pci' + str(i))
aimPciNode = mc.createNode('pointOnCurveInfo',name = jntLable +'_AimPci'+ str(i))
aimPciTransform = mc.createNode('transform',name = jntLable +'_AimPciGrp'+ str(i))
mc.parent(aimPciTransform,aimGrp)
pciTransform = mc.createNode('transform',name = jntLable +'_PciGrp'+ str(i))
mc.parent(pciTransform,pciGrp)
jnt = mc.joint( name =jntLable +'_Jnt'+str(i))
mc.select()
mc.addAttr(jnt ,longName = 'parameter',at = 'double')
mc.setAttr(jnt+'.parameter',edit=True,keyable = True)
mc.connectAttr(jnt+'.parameter',pciNode+'.parameter')
mc.connectAttr(jnt+'.parameter',aimPciNode+'.parameter')
mc.connectAttr(curveSpace[0]+'.worldSpace[0]',pciNode+'.inputCurve')
mc.connectAttr(pciNode+'.positionX',pciTransform+'.translateX')
mc.connectAttr(pciNode+'.positionY',pciTransform+'.translateY')
mc.connectAttr(pciNode+'.positionZ',pciTransform+'.translateZ')
mc.connectAttr(curveAimSpace[0]+'.worldSpace[0]',aimPciNode+'.inputCurve')
mc.connectAttr(aimPciNode+'.positionX',aimPciTransform+'.translateX')
mc.connectAttr(aimPciNode+'.positionY',aimPciTransform+'.translateY')
mc.connectAttr(aimPciNode+'.positionZ',aimPciTransform+'.translateZ')
if curveMaxValue > 1 :
cmd = ( int(curveMaxValue) * 0.1 * 10) / (numberGrp - 1 )
elif curveMaxValue == 1:
cmd = 1.0 / (numberGrp - 1)
mc.setAttr(jnt+'.parameter',(cmd*i))
mc.setAttr(jnt+'.parameter',(cmd*i))
mc.tangentConstraint(curveSurface,pciTransform,weight=True,aimVector=(1,0,0),upVector=(0,1,0),worldUpType='object',worldUpObject = aimPciTransform )
def pocCon(self, name, ctrl):
#create pointOnCurve node
pocNode = mc.createNode("pointOnCurveInfo",
name="POC_{0}".format(name))
#connect POC to connector curve and ctrl
mc.connectAttr(self.conCurve + ".worldSpace",
pocNode + ".inputCurve",
force=True)
mc.connectAttr(pocNode + ".position",
ctrl[0] + ".translate",
force=True)
mc.connectAttr(ctrl[0] + ".position",
pocNode + ".parameter",
force=True)
#tangent constrain to curve
mc.tangentConstraint(self.conCurve,
ctrl[0],
aim=(0, 1, 0),
upVector=(0, 0, 1),
wut="vector",
wu=(0, 1, 0))
def rotateConstraint_modify0(*objects,**option):
conObj = ''; aimObj = ''; #---------------------------------------------------------------------------
aimType = ''; wut = 'vector'; wuo = ''; name = '' # 옵션 선언
aim = [1,0,0]; u = [0,1,0]; wu = [0,1,0]#------------------------------------------------------------
if len(objects) == 0: #------------------------------------------------------------------------
conObj = cmds.ls(sl=1,tr=1)[0]
aimObj = cmds.ls(sl=1,tr=1)[1] # 에임 오브젝트와 통제할 오브젝트를 변수에 저장
else:
conObj = objects[0]; aimObj = objects[1] #----------------------------------------------------
for i in option: #---------------------------------------------------------------------------------------------------
optionType = i; val = option[i];
if optionType == 'aim' or optionType == 'aimVector':
aim[0] = float(val[0]); aim[1] = float(val[1]); aim[2] = float(val[2])
if optionType == 'u' or optionType == 'upVector':
u[0] = float(val[0]); u[1] = float(val[1]); u[2] = float(val[2]) #각종 옵션값을 사전에서 불러온다
if optionType == 'wu' or optionType == 'worldUpVector':
wu[0] = float(val[0]); wu[1] = float(val[1]); wu[2] = float(val[2])
if optionType == 'atp' or optionType == 'aimType': aimType = val
if optionType == 'wut' or optionType == 'worldUpType':wut = val;
if optionType == 'wuo' or optionType == 'worldUpObject':wuo = val
if optionType == 'n' or optionType == 'name': name = val#--------------------------------------------------------
constraint = ''#------------------------------------------------------------------------------------------------
if aimType == 'curvetangent':
if wut == '' or wut == 'vector':
constraint = cmds.tangentConstraint(conObj,aimObj,aim=aim,u=u)[0] #컨스트레인
elif wut == 'object' or wut == 'objectrotation':
constraint = cmds.tangentConstraint(conObj,aimObj,aim=aim,u=u,wu=wu,wut=wut,wuo=wuo)[0]
else:
if wut == '' or wut == 'vector':
constraint = cmds.aimConstraint(conObj,aimObj,aim=aim,u=u)[0]
elif wut == 'object' or wut == 'objectrotation':
constraint = cmds.aimConstraint(conObj,aimObj,aim=aim,u=u,wu=wu,wut=wut,wuo=wuo)[0]#-----------------------
return constraint
def targetList(constraint):
'''
Return a list of targets (drivers) for the specified constraint node
@param constraint: The constraint node whose targets will be returned
@type constraint: str
'''
# Check Constraint
if not isConstraint(constraint):
raise Exception('Constraint "' + constraint + '" does not exist!!')
# Get Target List
targetList = []
constraintType = mc.objectType(constraint)
if constraintType == 'aimConstraint':
targetList = mc.aimConstraint(constraint, q=True, tl=True)
elif constraintType == 'geometryConstraint':
targetList = mc.geometryConstraint(constraint, q=True, tl=True)
elif constraintType == 'normalConstraint':
targetList = mc.normalConstraint(constraint, q=True, tl=True)
elif constraintType == 'orientConstraint':
targetList = mc.orientConstraint(constraint, q=True, tl=True)
elif constraintType == 'parentConstraint':
targetList = mc.parentConstraint(constraint, q=True, tl=True)
elif constraintType == 'pointConstraint':
targetList = mc.pointConstraint(constraint, q=True, tl=True)
elif constraintType == 'poleVectorConstraint':
targetList = mc.poleVectorConstraint(constraint, q=True, tl=True)
elif constraintType == 'scaleConstraint':
targetList = mc.scaleConstraint(constraint, q=True, tl=True)
elif constraintType == 'tangentConstraint':
targetList = mc.tangentConstraint(constraint, q=True, tl=True)
# Check Target List
if not targetList: targetList = []
# Return Result
return targetList
def targetList(constraint):
''' Return a list of targets (drivers) for the specified constraint node
:param constraint str: The constraint node whose targets will be returned
:return: List of target drivers for specified constraint
:rtype: list
'''
# Check Constraint
if not isConstraint(constraint):
raise Exception('Constraint {0} does not exist!!'.format(constraint))
# Get Target List
targetList = []
constraintType = cmds.objectType(constraint)
if constraintType == 'aimConstraint':
targetList = cmds.aimConstraint(constraint, q=True, tl=True)
elif constraintType == 'geometryConstraint':
targetList = cmds.geometryConstraint(constraint, q=True, tl=True)
elif constraintType == 'normalConstraint':
targetList = cmds.normalConstraint(constraint, q=True, tl=True)
elif constraintType == 'orientConstraint':
targetList = cmds.orientConstraint(constraint, q=True, tl=True)
elif constraintType == 'parentConstraint':
targetList = cmds.parentConstraint(constraint, q=True, tl=True)
elif constraintType == 'pointConstraint':
targetList = cmds.pointConstraint(constraint, q=True, tl=True)
elif constraintType == 'poleVectorConstraint':
targetList = cmds.poleVectorConstraint(constraint, q=True, tl=True)
elif constraintType == 'scaleConstraint':
targetList = cmds.scaleConstraint(constraint, q=True, tl=True)
elif constraintType == 'tangentConstraint':
targetList = cmds.tangentConstraint(constraint, q=True, tl=True)
# Check Target List
if not targetList: targetList = []
# Return Result
return targetList
def targetList(constraint):
"""
Return a list of targets (drivers) for the specified constraint node
@param constraint: The constraint node whose targets will be returned
@type constraint: str
"""
# Check Constraint
if not isConstraint(constraint):
raise Exception('Constraint "' + constraint + '" does not exist!!')
# Get Target List
targetList = []
constraintType = cmds.objectType(constraint)
if constraintType == 'aicmdsonstraint':
targetList = cmds.aicmdsonstraint(constraint, q=True, tl=True)
elif constraintType == 'geometryConstraint':
targetList = cmds.geometryConstraint(constraint, q=True, tl=True)
elif constraintType == 'normalConstraint':
targetList = cmds.normalConstraint(constraint, q=True, tl=True)
elif constraintType == 'orientConstraint':
targetList = cmds.orientConstraint(constraint, q=True, tl=True)
elif constraintType == 'parentConstraint':
targetList = cmds.parentConstraint(constraint, q=True, tl=True)
elif constraintType == 'pointConstraint':
targetList = cmds.pointConstraint(constraint, q=True, tl=True)
elif constraintType == 'poleVectorConstraint':
targetList = cmds.poleVectorConstraint(constraint, q=True, tl=True)
elif constraintType == 'scaleConstraint':
targetList = cmds.scaleConstraint(constraint, q=True, tl=True)
elif constraintType == 'tangentConstraint':
targetList = cmds.tangentConstraint(constraint, q=True, tl=True)
# Check Target List
if not targetList: targetList = []
# Return Result
return targetList
def targetList(constraint):
'''
Return a list of targets (drivers) for the specified constraint node
@param constraint: The constraint node whose targets will be returned
@type constraint: str
'''
# Check constraint
if not mc.objExists(constraint): raise UserInputError('Constraint '+constraint+' does not exist!!')
constraintType = mc.objectType(constraint)
# Get target list
targetList = []
if constraintType == 'aimConstraint': targetList = mc.aimConstraint(constraint,q=True,tl=True)
elif constraintType == 'geometryConstraint': targetList = mc.geometryConstraint(constraint,q=True,tl=True)
elif constraintType == 'normalConstraint': targetList = mc.normalConstraint(constraint,q=True,tl=True)
elif constraintType == 'orientConstraint': targetList = mc.orientConstraint(constraint,q=True,tl=True)
elif constraintType == 'parentConstraint': targetList = mc.parentConstraint(constraint,q=True,tl=True)
elif constraintType == 'pointConstraint': targetList = mc.pointConstraint(constraint,q=True,tl=True)
elif constraintType == 'poleVectorConstraint': targetList = mc.poleVectorConstraint(constraint,q=True,tl=True)
elif constraintType == 'scaleConstraint': targetList = mc.scaleConstraint(constraint,q=True,tl=True)
elif constraintType == 'tangentConstraint': targetList = mc.tangentConstraint(constraint,q=True,tl=True)
# Check target list
if not targetList: targetList = []
# Return result
return targetList
def build(attachments=4, sections=9, sectionsSpans=8, minRadius=0.0, maxRadius=1.0, startPt=[0.0, 0.0, 6.0],
endPt=[0.0, 0.0, -6.0], prefix='muscle'):
"""
Build muscle primitive based on the input argument values between the start and end points
@param attachments: Number of attachments points
@type attachments: int
@param sections: Number of profile curves
@type sections: int
@param sectionSpans: Number of spans for profile curves
@type sectionSpans: int
@param minRadius: Minimum radius for muscle profile curves
@type minRadius: float
@param maxRadius: Maximum radius for muscle profile curves
@type maxRadius: float
@param startPt: Start point of the muscle
@type startPt: list
@param endPt: End point of the muscle
@type endPt: list
@param prefix: Name prefix for muscle primitive
@type prefix: str
@return: Muscle mesh
@returnType: str
"""
# Checks
# Get start, end and distance values
startPoint = glTools.utils.base.getMPoint(startPt)
endPoint = glTools.utils.base.getMPoint(endPt)
startEndOffset = endPoint - startPoint
startEndDist = startEndOffset.length()
startEndInc = startEndDist / (attachments - 1)
# Calculate attachment point positions
attachPoints = []
for i in range(attachments):
attachPoints.append(startPoint + (startEndOffset.normal() * startEndInc * i))
# Start Tangent
if not i:
attachPoints.append(startPoint + (startEndOffset.normal() * startEndInc * 0.5))
# End Tangent
if i == (attachments - 2):
attachPoints.append(startPoint + (startEndOffset.normal() * startEndInc * (i + 0.5)))
attachPts = [[pt.x, pt.y, pt.z] for pt in attachPoints]
# Resize attachments value to accomodate for tangent points
attachments = len(attachPts)
# ------------------------
# - Build base hierarchy -
# ------------------------
# Create groups
muscleGrp = cmds.createNode('transform', n=prefix + '_group')
muscleAttachGrp = cmds.createNode('transform', n=prefix + '_attachment_group')
muscleProfileGrp = cmds.createNode('transform', n=prefix + '_profile_group')
# Build hierarchy
cmds.parent(muscleAttachGrp, muscleGrp)
cmds.parent(muscleProfileGrp, muscleGrp)
# ----------------------
# - Build Muscle Curve -
# ----------------------
# Build muscle base curve
muscleCurve = cmds.rename(cmds.curve(d=1, p=attachPts, k=range(len(attachPts))), prefix + '_curve')
cmds.rebuildCurve(muscleCurve, ch=0, rpo=1, rt=0, end=1, kr=0, kcp=1, kep=1, kt=1, s=0, d=1)
muscleCurveShape = cmds.listRelatives(muscleCurve, s=True)[0]
cmds.parent(muscleCurve, muscleAttachGrp)
# Add muscle attributes
cmds.addAttr(muscleCurve, ln='muscle', at='message')
cmds.addAttr(muscleCurve, ln='muscleObjectType', dt='string')
cmds.setAttr(muscleCurve + '.muscleObjectType', 'spline', type='string', l=True)
# Connect curve to attachment locators
attachLocators = glTools.utils.curve.locatorCurve(muscleCurve, locatorScale=0.1, freeze=False, prefix=prefix)
# Rename attachment locators and add muscle attibutes
for i in range(len(attachLocators)):
# Add muscle attibutes
cmds.addAttr(attachLocators[i], ln='muscle', at='message')
cmds.addAttr(attachLocators[i], ln='muscleObjectType', dt='string')
cmds.setAttr(attachLocators[i] + '.muscleObjectType', 'attachment', type='string', l=True)
# Rename attachment locators
if not i:
attachLocators[i] = cmds.rename(attachLocators[i], prefix + '_attachStart_locator')
elif i == 1:
attachLocators[i] = cmds.rename(attachLocators[i], prefix + '_attachStartTangent_locator')
cmds.setAttr(attachLocators[i] + '.muscleObjectType', l=False)
cmds.setAttr(attachLocators[i] + '.muscleObjectType', 'attachmentTangent', type='string', l=True)
elif i == (attachments - 2):
attachLocators[i] = cmds.rename(attachLocators[i], prefix + '_attachEndTangent_locator')
cmds.setAttr(attachLocators[i] + '.muscleObjectType', l=False)
cmds.setAttr(attachLocators[i] + '.muscleObjectType', 'attachmentTangent', type='string', l=True)
elif i == (attachments - 1):
attachLocators[i] = cmds.rename(attachLocators[i], prefix + '_attachEnd_locator')
else:
attachLocators[i] = cmds.rename(attachLocators[i], prefix + '_attachMid' + str(i - 1) + '_locator')
# Group attachment locators
attachLocGroup = []
[attachLocGroup.append(glTools.utils.base.group(loc)) for loc in attachLocators]
cmds.parent(attachLocGroup, muscleAttachGrp)
# Create spline rebuild curve
splineCurve = cmds.rebuildCurve(muscleCurve, ch=1, rpo=0, rt=0, end=1, kr=0, kcp=0, kep=1, kt=1, s=5, d=3)
splineRebuild = cmds.rename(splineCurve[1], prefix + '_spline_rebuildCurve')
splineCurveShape = cmds.rename(cmds.listRelatives(splineCurve[0], s=True)[0], prefix + '_spline_curveShape')
cmds.parent(splineCurveShape, muscleCurve, s=True, r=True)
cmds.delete(splineCurve[0])
# Create tangent rebuild curve
tangentCurve = cmds.rebuildCurve(muscleCurve, ch=1, rpo=0, rt=0, end=1, kr=0, kcp=0, kep=1, kt=1, s=2, d=3)
tangentRebuild = cmds.rename(tangentCurve[1], prefix + '_tangent_rebuildCurve')
tangentCurveShape = cmds.rename(cmds.listRelatives(tangentCurve[0], s=True)[0], prefix + '_tangent_curveShape')
cmds.parent(tangentCurveShape, muscleCurve, s=True, r=True)
cmds.delete(tangentCurve[0])
# Create curve visibility attributes
cmds.addAttr(muscleCurve, ln='attachment', at='enum', en='Off:On:')
cmds.setAttr(muscleCurve + '.attachment', k=False, cb=True)
cmds.connectAttr(muscleCurve + '.attachment', muscleCurveShape + '.v')
cmds.addAttr(muscleCurve, ln='spline', at='enum', en='Off:On:')
cmds.setAttr(muscleCurve + '.spline', k=False, cb=True)
cmds.connectAttr(muscleCurve + '.spline', splineCurveShape + '.v')
cmds.addAttr(muscleCurve, ln='tangent', at='enum', en='Off:On:')
cmds.setAttr(muscleCurve + '.tangent', k=False, cb=True)
cmds.connectAttr(muscleCurve + '.tangent', tangentCurveShape + '.v')
cmds.setAttr(muscleCurve + '.attachment', 0)
cmds.setAttr(muscleCurve + '.spline', 1)
cmds.setAttr(muscleCurve + '.tangent', 1)
# Setup start tangent toggle
cmds.addAttr(attachLocators[0], ln='tangentControl', at='enum', en='Off:On:')
cmds.setAttr(attachLocators[0] + '.tangentControl', k=False, cb=True)
cmds.connectAttr(attachLocators[0] + '.tangentControl', attachLocGroup[1] + '.v', f=True)
startTangentBlend = cmds.createNode('blendColors', n=prefix + '_startTangent_blendColors')
cmds.connectAttr(attachLocators[1] + '.worldPosition[0]', startTangentBlend + '.color1', f=True)
cmds.connectAttr(attachLocators[2] + '.worldPosition[0]', startTangentBlend + '.color2', f=True)
cmds.connectAttr(attachLocators[0] + '.tangentControl', startTangentBlend + '.blender', f=True)
cmds.connectAttr(startTangentBlend + '.output', muscleCurve + '.controlPoints[1]', f=True)
# Setup end tangent toggle
cmds.addAttr(attachLocators[-1], ln='tangentControl', at='enum', en='Off:On:')
cmds.setAttr(attachLocators[-1] + '.tangentControl', k=False, cb=True)
cmds.connectAttr(attachLocators[-1] + '.tangentControl', attachLocGroup[-2] + '.v', f=True)
endTangentBlend = cmds.createNode('blendColors', n=prefix + '_endTangent_blendColors')
cmds.connectAttr(attachLocators[-2] + '.worldPosition[0]', endTangentBlend + '.color1', f=True)
cmds.connectAttr(attachLocators[-3] + '.worldPosition[0]', endTangentBlend + '.color2', f=True)
cmds.connectAttr(attachLocators[-1] + '.tangentControl', endTangentBlend + '.blender', f=True)
cmds.connectAttr(endTangentBlend + '.output', muscleCurve + '.controlPoints[' + str(attachments - 2) + ']', f=True)
# -------------------------------
# - Build Muscle Profile Curves -
# -------------------------------
# Initialize profile list
profileList = []
profileGrpList = []
profileFollowList = []
# Iterate through profiles
profileInc = 1.0 / (sections - 1)
for i in range(sections):
# Create profile curve
profile = cmds.circle(ch=0, c=(0, 0, 0), nr=(0, 0, 1), sw=360, r=1, d=3, ut=0, tol=0.01, s=sectionsSpans,
n=prefix + '_profile' + str(i + 1) + '_curve')[0]
profileList.append(profile)
# Add muscle profile attribute
cmds.addAttr(profile, ln='muscle', at='message')
cmds.addAttr(profile, ln='muscleObjectType', dt='string')
cmds.setAttr(profile + '.muscleObjectType', 'profile', type='string', l=True)
# Group profile curve
profileGrp = glTools.utils.base.group(profile)
profileGrpList.append(profileGrp)
# Skip start/end profiles
if (not i) or (i == (sections - 1)): continue
# Add curve parameter attribute
cmds.addAttr(profile, ln='uValue', min=0.0, max=1.0, dv=profileInc * i)
cmds.setAttr(profile + '.uValue', k=False, cb=True)
# Create profile pointOnCurveInfo node
profileCurveInfo = cmds.createNode('pointOnCurveInfo', n=prefix + '_profile' + str(i + 1) + '_pointOnCurveInfo')
# Attach profile group to point on muscle spline curve
cmds.connectAttr(splineCurveShape + '.worldSpace[0]', profileCurveInfo + '.inputCurve', f=True)
cmds.connectAttr(profile + '.uValue', profileCurveInfo + '.parameter', f=True)
cmds.connectAttr(profileCurveInfo + '.position', profileGrp + '.translate', f=True)
# Create profile follow group
profileFollowGrp = cmds.createNode('transform', n=prefix + '_profileFollow' + str(i + 1) + '_group')
profileFollowList.append(profileFollowGrp)
cmds.connectAttr(profileCurveInfo + '.position', profileFollowGrp + '.translate', f=True)
cmds.parent(profileGrpList, muscleProfileGrp)
cmds.parent(profileFollowList, muscleProfileGrp)
# ------------------------------------
# - Create profile orientation setup -
# ------------------------------------
oddProfile = sections % 2
intProfile = int(sections * 0.5)
midProfile = intProfile + oddProfile
intIncrement = 1.0 / intProfile
# Create mid profile orientConstraint
if oddProfile:
midPointObject = profileFollowList[midProfile - 2]
else:
midPointObject = cmds.createNode('transform', n=prefix + '_midPointFollow_group')
cmds.parent(midPointObject, muscleProfileGrp)
midOrientCon = cmds.orientConstraint([attachLocators[0], attachLocators[-1]], midPointObject,
n=prefix + '_midPoint_orientConstraint')
# Create intermediate profile orientConstraints
for i in range(intProfile):
# Skip start/end profiles
if not i: continue
# Create orientConstraints
startMidOriCon = cmds.orientConstraint([attachLocators[0], midPointObject], profileFollowList[i - 1])[0]
endMidOriCon = cmds.orientConstraint([attachLocators[-1], midPointObject], profileFollowList[-(i)])[0]
startMidOriWt = cmds.orientConstraint(startMidOriCon, q=True, weightAliasList=True)
endMidOriWt = cmds.orientConstraint(endMidOriCon, q=True, weightAliasList=True)
# Set constraint weights
cmds.setAttr(startMidOriCon + '.' + startMidOriWt[0], 1.0 - (intIncrement * i))
cmds.setAttr(startMidOriCon + '.' + startMidOriWt[1], (intIncrement * i))
cmds.setAttr(endMidOriCon + '.' + endMidOriWt[0], 1.0 - (intIncrement * i))
cmds.setAttr(endMidOriCon + '.' + endMidOriWt[1], (intIncrement * i))
# Add constraint weight attribute to profile
cmds.addAttr(profileList[i], ln='twist', min=0, max=1, dv=1.0 - (intIncrement * i), k=True)
cmds.addAttr(profileList[-(i + 1)], ln='twist', min=0, max=1, dv=1.0 - (intIncrement * i), k=True)
# Connect twist attribite to constraint weights
startMidOriRev = cmds.createNode('reverse', n=profileList[i].replace('_curve', '_reverse'))
endMidOriRev = cmds.createNode('reverse', n=profileList[-(i + 1)].replace('_curve', '_reverse'))
cmds.connectAttr(profileList[i] + '.twist', startMidOriRev + '.inputX', f=True)
cmds.connectAttr(profileList[i] + '.twist', startMidOriCon + '.' + startMidOriWt[0], f=True)
cmds.connectAttr(startMidOriRev + '.outputX', startMidOriCon + '.' + startMidOriWt[1], f=True)
cmds.connectAttr(profileList[-(i + 1)] + '.twist', endMidOriRev + '.inputX', f=True)
cmds.connectAttr(profileList[-(i + 1)] + '.twist', endMidOriCon + '.' + endMidOriWt[0], f=True)
cmds.connectAttr(endMidOriRev + '.outputX', endMidOriCon + '.' + endMidOriWt[1], f=True)
# Create Profile tangent constraints
tangentConList = []
for i in range(len(profileGrpList)):
# Determine world up object
if not i:
# start profile
worldUpObject = attachLocators[0]
elif i == (len(profileGrpList) - 1):
# end profile
worldUpObject = attachLocators[-1]
else:
worldUpObject = profileFollowList[i - 1]
# Create constraint
tangentCon = cmds.tangentConstraint(tangentCurveShape, profileGrpList[i], aim=[0, 0, -1], u=[0, 1, 0],
wu=[0, 1, 0], wut='objectrotation', wuo=worldUpObject)
tangentConList.append(tangentCon)
# -----------------------------
# - Set profile radius values -
# -----------------------------
# Set default profile radius values
radiusList = glTools.utils.mathUtils.distributeValue(midProfile, rangeStart=minRadius, rangeEnd=maxRadius)
radiusList = [glTools.utils.mathUtils.smoothStep(i, minRadius, maxRadius, 0.5) for i in radiusList]
for i in range(midProfile):
cmds.setAttr(profileList[i] + '.scale', radiusList[i], radiusList[i], radiusList[i])
cmds.setAttr(profileList[-(i + 1)] + '.scale', radiusList[i], radiusList[i], radiusList[i])
# ----------------------------
# - Generate Muscle Geometry -
# ----------------------------
# Loft mesh between profile curves
loft = cmds.loft(profileList, u=0, c=0, d=3, ch=1, po=1)
muscleMesh = cmds.rename(loft[0], prefix)
muscleLoft = cmds.rename(loft[1], prefix + '_loft')
muscleTess = cmds.listConnections(muscleLoft + '.outputSurface', s=False, d=True, type='nurbsTessellate')[0]
muscleTess = cmds.rename(muscleTess, prefix + '_nurbsTessellate')
cmds.parent(muscleMesh, muscleGrp)
# Set nurbsTessellate settings
cmds.setAttr(muscleTess + '.format', 2)
cmds.setAttr(muscleTess + '.polygonType', 1)
cmds.setAttr(muscleTess + '.uType', 1)
cmds.setAttr(muscleTess + '.vType', 1)
cmds.setAttr(muscleTess + '.uNumber', 20)
cmds.setAttr(muscleTess + '.vNumber', 10)
# Add muscle mesh attributes
cmds.addAttr(muscleMesh, ln='precision', at='long', min=1, dv=5)
cmds.setAttr(muscleMesh + '.precision', k=False, cb=True)
cmds.addAttr(muscleMesh, ln='tangentPrecision', at='long', min=1, dv=2)
cmds.setAttr(muscleMesh + '.tangentPrecision', k=False, cb=True)
cmds.addAttr(muscleMesh, ln='uDivisions', at='long', min=4, dv=20)
cmds.setAttr(muscleMesh + '.uDivisions', k=False, cb=True)
cmds.addAttr(muscleMesh, ln='vDivisions', at='long', min=3, dv=10)
cmds.setAttr(muscleMesh + '.vDivisions', k=False, cb=True)
cmds.addAttr(muscleMesh, ln='restLength', at='float', min=0, dv=startEndDist)
cmds.setAttr(muscleMesh + '.restLength', k=False, cb=True)
cmds.addAttr(muscleMesh, ln='currentLength', at='float', min=0, dv=startEndDist)
cmds.setAttr(muscleMesh + '.currentLength', k=True)
cmds.addAttr(muscleMesh, ln='lengthScale', at='float', min=0, dv=1)
cmds.setAttr(muscleMesh + '.lengthScale', k=True)
cmds.addAttr(muscleMesh, ln='muscleMessage', at='message')
cmds.addAttr(muscleMesh, ln='muscleSpline', at='message')
cmds.addAttr(muscleMesh, ln='attachment', at='message', m=True)
cmds.addAttr(muscleMesh, ln='profile', at='message', m=True)
cmds.addAttr(muscleMesh, ln='muscleObjectType', dt='string')
cmds.setAttr(muscleMesh + '.muscleObjectType', 'geo', type='string', l=True)
# Connect muscle mesh attributes
cmds.connectAttr(muscleCurve + '.message', muscleMesh + '.muscleSpline', f=True)
for i in range(len(attachLocators)):
cmds.connectAttr(attachLocators[i] + '.message', muscleMesh + '.attachment[' + str(i) + ']', f=True)
cmds.connectAttr(muscleMesh + '.message', attachLocators[i] + '.muscle', f=True)
for i in range(len(profileList)):
cmds.connectAttr(profileList[i] + '.message', muscleMesh + '.profile[' + str(i) + ']', f=True)
cmds.connectAttr(muscleMesh + '.message', profileList[i] + '.muscle', f=True)
# Connect muscle mesh attributes to curve rebuild settings
cmds.connectAttr(muscleMesh + '.precision', splineRebuild + '.spans', f=True)
musclePreCondition = cmds.createNode('condition', n=prefix + '_precision_condition')
cmds.setAttr(musclePreCondition + '.operation', 4) # Less Than
cmds.connectAttr(muscleMesh + '.precision', musclePreCondition + '.firstTerm', f=True)
cmds.connectAttr(muscleMesh + '.tangentPrecision', musclePreCondition + '.secondTerm', f=True)
cmds.connectAttr(muscleMesh + '.precision', musclePreCondition + '.colorIfTrueR', f=True)
cmds.connectAttr(muscleMesh + '.tangentPrecision', musclePreCondition + '.colorIfFalseR', f=True)
cmds.connectAttr(musclePreCondition + '.outColorR', tangentRebuild + '.spans', f=True)
# Connect musle mesh attributes to nurbsTessellate settings
cmds.connectAttr(muscleMesh + '.uDivisions', muscleTess + '.uNumber', f=True)
cmds.connectAttr(muscleMesh + '.vDivisions', muscleTess + '.vNumber', f=True)
# Setup length calculation
muscleLenCurveInfo = cmds.createNode('curveInfo', n=prefix + '_length_curveInfo')
cmds.connectAttr(splineCurveShape + '.worldSpace[0]', muscleLenCurveInfo + '.inputCurve', f=True)
cmds.connectAttr(muscleLenCurveInfo + '.arcLength', muscleMesh + '.currentLength', f=True)
muscleLenDiv = cmds.createNode('multiplyDivide', n=prefix + '_length_multiplyDivide')
cmds.setAttr(muscleLenDiv + '.operation', 2) # Divide
cmds.setAttr(muscleLenDiv + '.input1', 1, 1, 1)
cmds.setAttr(muscleLenDiv + '.input2', 1, 1, 1)
cmds.connectAttr(muscleLenCurveInfo + '.arcLength', muscleLenDiv + '.input1X', f=True)
cmds.connectAttr(muscleMesh + '.restLength', muscleLenDiv + '.input2X', f=True)
cmds.connectAttr(muscleLenDiv + '.outputX', muscleMesh + '.lengthScale', f=True)
# -----------
# - Cleanup -
# -----------
# Parent start/end tangent locators
cmds.parent(attachLocGroup[1], attachLocators[0])
cmds.parent(attachLocGroup[-2], attachLocators[-1])
# Parent start/end profiles
cmds.parent(profileGrpList[0], attachLocators[0])
cmds.setAttr(profileGrpList[0] + '.t', 0.0, 0.0, 0.0)
cmds.setAttr(profileGrpList[0] + '.r', 0.0, 0.0, 0.0)
cmds.setAttr(profileGrpList[0] + '.s', 1.0, 1.0, 1.0)
cmds.parent(profileGrpList[-1], attachLocators[-1])
cmds.setAttr(profileGrpList[-1] + '.t', 0.0, 0.0, 0.0)
cmds.setAttr(profileGrpList[-1] + '.r', 0.0, 0.0, 0.0)
cmds.setAttr(profileGrpList[-1] + '.s', 1.0, 1.0, 1.0)
# Setup start/end profile scale compensation
attachStartScaleCompNode = cmds.createNode('multiplyDivide', n=prefix + '_attachStart_multiplyDivide')
cmds.setAttr(attachStartScaleCompNode + '.input1', 1, 1, 1)
cmds.setAttr(attachStartScaleCompNode + '.operation', 2)
cmds.connectAttr(attachLocators[0] + '.scale', attachStartScaleCompNode + '.input2', f=True)
cmds.connectAttr(attachStartScaleCompNode + '.output', profileGrpList[0] + '.scale', f=True)
attachEndScaleCompNode = cmds.createNode('multiplyDivide', n=prefix + '_attachEnd_multiplyDivide')
cmds.setAttr(attachEndScaleCompNode + '.input1', 1, 1, 1)
cmds.setAttr(attachEndScaleCompNode + '.operation', 2)
cmds.connectAttr(attachLocators[-1] + '.scale', attachEndScaleCompNode + '.input2', f=True)
cmds.connectAttr(attachEndScaleCompNode + '.output', profileGrpList[-1] + '.scale', f=True)
# Lock transforms
cmds.setAttr(muscleGrp + '.inheritsTransform', 0)
cmds.setAttr(muscleGrp + '.t', l=True, cb=True)
cmds.setAttr(muscleGrp + '.r', l=True, cb=True)
cmds.setAttr(muscleGrp + '.s', l=True, cb=True)
# Return result
return muscleMesh
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 traceArc(space='camera'):
'''
The main function for creating the arc.
'''
if space != 'world' and space != 'camera':
OpenMaya.MGlobal.displayWarning('Improper space argument.')
return
global ML_TRACE_ARC_PREVIOUS_SELECTION
global ML_TRACE_ARC_PREVIOUS_SPACE
#save for reset:
origTime = mc.currentTime(query=True)
#frame range
frameRange = utl.frameRange()
start = frameRange[0]
end = frameRange[1]
#get neccesary nodes
objs = mc.ls(sl=True, type='transform')
if not objs:
OpenMaya.MGlobal.displayWarning('Select objects to trace')
return
ML_TRACE_ARC_PREVIOUS_SELECTION = objs
ML_TRACE_ARC_PREVIOUS_SPACE = space
cam = None
nearClipPlane = None
shortCam = ''
if space=='camera':
cam = utl.getCurrentCamera()
#the arc will be placed just past the clip plane distance, but no closer than 1 unit.
nearClipPlane = max(mc.getAttr(cam+'.nearClipPlane'),1)
shortCam = mc.ls(cam, shortNames=True)[0]
topGroup = 'ml_arcGroup'
worldGrp = 'ml_arcWorldGrp'
localGrp = 'ml_localGrp_'+shortCam
#create nodes
if not mc.objExists(topGroup):
topGroup = mc.group(empty=True, name=topGroup)
parentGrp = topGroup
if space=='world' and not mc.objExists(worldGrp):
worldGrp = mc.group(empty=True, name=worldGrp)
mc.setAttr(worldGrp+'.overrideEnabled',1)
mc.setAttr(worldGrp+'.overrideDisplayType',2)
mc.parent(worldGrp, topGroup)
parentGrp = mc.ls(worldGrp)[0]
if space == 'camera':
camConnections = mc.listConnections(cam+'.message', plugs=True, source=False, destination=True)
if camConnections:
for cc in camConnections:
if '.ml_parentCam' in cc:
localGrp = mc.ls(cc, o=True)[0]
if not mc.objExists(localGrp):
localGrp = mc.group(empty=True, name=localGrp)
mc.parentConstraint(cam, localGrp)
mc.setAttr(localGrp+'.overrideEnabled',1)
mc.setAttr(localGrp+'.overrideDisplayType',2)
mc.parent(localGrp, topGroup)
mc.addAttr(localGrp, at='message', longName='ml_parentCam')
mc.connectAttr(cam+'.message', localGrp+'.ml_parentCam')
parentGrp = mc.ls(localGrp)[0]
#group per object:
group = list()
points = list()
for i,obj in enumerate(objs):
sn = mc.ls(obj,shortNames=True)[0]
name = sn.replace(':','_')
points.append(list())
groupName = 'ml_%s_arcGrp' % name
if mc.objExists(groupName):
mc.delete(groupName)
group.append(mc.group(empty=True, name=groupName))
group[i] = mc.parent(group[i],parentGrp)[0]
mc.setAttr(group[i]+'.translate', 0,0,0)
mc.setAttr(group[i]+'.rotate', 0,0,0)
with utl.UndoChunk():
with utl.IsolateViews():
#helper locator
loc = mc.spaceLocator()[0]
mc.parent(loc,parentGrp)
#frame loop:
time = range(int(start),int(end+1))
for t in time:
mc.currentTime(t, edit=True)
#object loop
for i,obj in enumerate(objs):
objPnt = mc.xform(obj, query=True, worldSpace=True, rotatePivot=True)
if space=='camera':
camPnt = mc.xform(cam, query=True, worldSpace=True, rotatePivot=True)
objVec = euclid.Vector3(objPnt[0],objPnt[1],objPnt[2])
camVec = euclid.Vector3(camPnt[0],camPnt[1],camPnt[2])
vec = objVec-camVec
vec.normalize()
#multiply here to offset from camera
vec=vec*nearClipPlane*1.2
vec+=camVec
mc.xform(loc, worldSpace=True, translation=vec[:])
trans = mc.getAttr(loc+'.translate')
points[i].append(trans[0])
elif space=='world':
points[i].append(objPnt)
mc.delete(loc)
#create the curves and do paint effects
mc.ResetTemplateBrush()
brush = mc.getDefaultBrush()
mc.setAttr(brush+'.screenspaceWidth',1)
mc.setAttr(brush+'.distanceScaling',0)
mc.setAttr(brush+'.brushWidth',0.005)
for i,obj in enumerate(objs):
#setup brush for path
mc.setAttr(brush+'.screenspaceWidth',1)
mc.setAttr(brush+'.distanceScaling',0)
mc.setAttr(brush+'.brushWidth',0.003)
#color
for c in ('R','G','B'):
color = random.uniform(0.3,0.7)
mc.setAttr(brush+'.color1'+c,color)
baseCurve = mc.curve(d=3,p=points[i])
#fitBspline makes a curve that goes THROUGH the points, a more accurate path
curve = mc.fitBspline(baseCurve, constructionHistory=False, tolerance=0.001)
mc.delete(baseCurve)
#paint fx
mc.AttachBrushToCurves(curve)
stroke = mc.ls(sl=True)[0]
stroke = mc.parent(stroke,group[i])[0]
mc.setAttr(stroke+'.overrideEnabled',1)
mc.setAttr(stroke+'.overrideDisplayType',2)
mc.setAttr(stroke+'.displayPercent',92)
mc.setAttr(stroke+'.sampleDensity',0.5)
mc.setAttr(stroke+'.inheritsTransform',0)
mc.setAttr(stroke+'.translate',0,0,0)
mc.setAttr(stroke+'.rotate',0,0,0)
curve = mc.parent(curve,group[i])[0]
mc.setAttr(curve+'.translate',0,0,0)
mc.setAttr(curve+'.rotate',0,0,0)
mc.hide(curve)
#setup brush for tics
if space=='camera':
mc.setAttr(brush+'.brushWidth',0.008)
if space=='world':
mc.setAttr(brush+'.brushWidth',0.005)
mc.setAttr(brush+'.color1G',0)
mc.setAttr(brush+'.color1B',0)
for t in range(len(points[i])):
frameCurve = None
if space=='camera':
vec = euclid.Vector3(points[i][t][0],points[i][t][1],points[i][t][2])
vec*=0.98
frameCurve = mc.curve(d=1,p=[points[i][t],vec[:]])
elif space=='world':
frameCurve = mc.circle(constructionHistory=False, radius=0.0001, sections=4)[0]
mc.setAttr(frameCurve+'.translate', points[i][t][0], points[i][t][1] ,points[i][t][2])
constraint = mc.tangentConstraint(curve, frameCurve, aimVector=(0,0,1), worldUpType='scene')
#mc.delete(constraint)
#check for keyframe
colorAttribute='color1G'
if mc.keyframe(obj, time=((t+start-0.5),(t+start+0.5)), query=True):
mc.setAttr(brush+'.color1R',1)
else:
mc.setAttr(brush+'.color1R',0)
mc.AttachBrushToCurves(curve)
stroke = mc.ls(sl=True)[0]
thisBrush = mc.listConnections(stroke+'.brush', destination=False)[0]
#setup keyframes for frame highlighting
mc.setKeyframe(thisBrush, attribute='color1G', value=0, time=(start+t-1, start+t+1))
mc.setKeyframe(thisBrush, attribute='color1G', value=1, time=(start+t,))
stroke = mc.parent(stroke,group[i])[0]
mc.hide(frameCurve)
mc.setAttr(stroke+'.displayPercent',92)
mc.setAttr(stroke+'.sampleDensity',0.5)
frameCurve = mc.parent(frameCurve,group[i])[0]
if space=='camera':
mc.setAttr(stroke+'.inheritsTransform',0)
mc.setAttr(stroke+'.pressureScale[1].pressureScale_Position', 1)
mc.setAttr(stroke+'.pressureScale[1].pressureScale_FloatValue', 0)
mc.setAttr(stroke+'.translate',0,0,0)
mc.setAttr(stroke+'.rotate',0,0,0)
mc.setAttr(frameCurve+'.translate',0,0,0)
mc.setAttr(frameCurve+'.rotate',0,0,0)
mc.currentTime(origTime, edit=True)
panel = mc.getPanel(withFocus=True)
mc.modelEditor(panel, edit=True, strokes=True)
mc.select(objs,replace=True)
def completeAntenna(num_jnt,num_ctr,hairSystem,sliding,length,twist):
lenComplist = len(completeList)
for i in range(lenComplist):
del completeList[0]
num_crv = len(MakeAtna_returnV)
method = ''
createJntLst = []
#------------------ Get Hair System Type
hairSys_on = 0
if hairSystem == 'New':
hairSys_on = 1
elif hairSystem == '':
hairSys_on = 0
else:
hairSys_on = -1
for i in cmds.ls(type='hairSystem'):
if hairSystem == i or hairSystem == cmds.listRelatives(i,p=1)[0]:
hairSys_on = 2
if hairSys_on == -1:
cmds.warning("'%s'는 존제하지 않는 Object입니다." % hairSystem)
else:
for i in MakeAtna_returnV: #------choose method
if len(i) == 6:
cmds.delete(i[5])#----delete expression
method = 'avp'
else:
method = 'cv'
getPosShp = 0.0
if method == 'avp':
print MakeAtna_returnV[0][0][1], len(MakeAtna_returnV[0][1])
getPosShp = cmds.getAttr(MakeAtna_returnV[0][0][1]+'.posShp')/len(MakeAtna_returnV[0][1])
print getPosShp
for i in MakeAtna_returnV:
aim = i[4][0]
up = i[4][1]
mainName = i[1][0].partition('_')[0]
#--------Set controler joint initial setting
for j in i[1]:
cmds.setAttr(j+'.tx',l=0)
cmds.setAttr(j+'.ty',l=0)
cmds.setAttr(j+'.tz',l=0)
cmds.setAttr(j+'.rx',l=0)
cmds.setAttr(j+'.ry',l=0)
cmds.setAttr(j+'.rz',l=0)
cmds.setAttr(j+'.dla',0)
if method == 'avp':
cmds.deleteAttr(j,at='ip')
cmds.parent(j,w=1)
for j in i[2]:
cmds.delete(j) #----------------- Delete null group
#----------Set constrainted orient to current orientation
for j in range(len(i[1])-1):
tempLoc = cmds.spaceLocator()[0]
tempOri = cmds.orientConstraint(i[1][j],tempLoc)
cmds.delete(tempOri)
tempAim = cmds.aimConstraint(i[1][j+1],i[1][j],aim=aim,u=up,wu=up,wut='objectrotation',wuo=tempLoc)
cmds.delete(tempAim,tempLoc)
cmds.parent(i[1][j+1],i[1][j])
##-------- BindCurve And JointCurve Set
attachJointCurve =''
bindCurve =''
posShp = 0.0
conJoint = i[1]
if method == 'avp':
dupleObj = cmds.duplicate(i[0][1],n=mainName+'_bindCurve')[0]
cmds.deleteAttr(dupleObj+'.posShp')
posShp = cmds.getAttr(i[0][1]+'.posShp')
attachJointCurve = cmds.rebuildCurve( dupleObj, n=mainName+'_jntAtCurve', ch=1, rpo=0, rt=0 ,end=0, kr=0, kcp=1, kep=0, kt=0, s=0, d=3, tol=0.01 )[0]
cmds.delete(i[0][0],i[0][1],i[0][2])
bindCurve = dupleObj
else:
dupleObj = cmds.duplicate(i[0][0],n=mainName+'_bindCurve')[0]
spans = cmds.getAttr(cmds.listRelatives(dupleObj,s=1)[0]+'.spans')
attachJointCurve = cmds.rebuildCurve( dupleObj, n=mainName+'_jntAtCurve', ch=1, rpo=0, rt=0 ,end=1, kr=0, kcp=0, kep=0, kt=0,s=spans*3, tol=0.01 )[0]
cmds.delete(i[0][1],i[0][0])
bindCurve = dupleObj
#--------------- Create Normal Base for Normal Constraint
normalBase = cmds.polyPlane(w=1,h=1,sx=1,sy=1,n=mainName+'_normalBase')[0]
for j in range(1,len(i[1])-1):
cmds.polyExtrudeEdge(normalBase+'.e['+str(j*3)+']',lty=1)
cmds.DeleteHistory(normalBase)
def inr(a):
return (a+1)%3
def inrb(a):
return (a+2)%3
axisElse = [0,0,0] #--------- Get Third Axis
for j in range(3):
if aim[j] == 1 and up[inr(j)] == 1:
axisElse[inrb(j)] = 1;
if aim[j] == 1 and up[inr(j)] == 0:
axisElse[inr(j)] = -1;
if aim[j] == -1 and up[inr(j)] == 0:
axisElse[inr(j)] = 1;
if aim[j] == -1 and up[inr(j)] == 1:
axisElse[inrb(j)] = -1;
print j,inr(j),inrb(j)
print 'aim :',aim
print 'up :',up
print 'axisElse:',axisElse
for j in range(len(i[1])):
tmLoc = cmds.spaceLocator()
cmds.parent(tmLoc,conJoint[j])
cmds.move(axisElse[0],axisElse[1],axisElse[2],tmLoc,ls=1)
locPos = cmds.xform(tmLoc,q=1,ws=1,piv=1)
cmds.move(locPos[0],locPos[1],locPos[2],normalBase+'.vtx['+str(j*2+1)+']',ws=1)
cmds.move(-axisElse[0],-axisElse[1],-axisElse[2],tmLoc,ls=1)
locPos = cmds.xform(tmLoc,q=1,ws=1,piv=1)
cmds.move(locPos[0],locPos[1],locPos[2],normalBase+'.vtx['+str(j*2)+']',ws=1)
cmds.delete(tmLoc)
bindObj = []
bindObj.append(conJoint[0])
bindObj.append(normalBase)
cmds.skinCluster(bindObj)
bindObj = []
bindObj.append(conJoint[0])
bindObj.append(bindCurve)
cmds.skinCluster(bindObj)
cmds.setAttr(bindCurve+'.v', 0)
cmds.select(attachJointCurve)
startHair = ''
currentHair = ''
restHair = ''
if hairSys_on != 0:
if hairSys_on == 1:
beforeHair = cmds.ls(type='hairSystem')
createHair('')
afterHair = cmds.ls(type='hairSystem')
for k in beforeHair:
afterHair.remove(k)
hairSystem = afterHair[0]
hairSys_on = 2
elif hairSys_on == 2:
createHair(hairSystem)
cmds.select(attachJointCurve); import maya.mel as mel ;mel.eval('setSelectedHairCurves "start" "rest"')
cmds.select(attachJointCurve); mel.eval('convertHairSelection "currentCurves"'); currentHair = cmds.ls(sl=1)[0]
mel.eval('convertHairSelection "restCurves"'); restHair = cmds.ls(sl=1)[0]
mel.eval('convertHairSelection "startCurves"'); startHair = cmds.ls(sl=1)[0]; attachJointCurve = currentHair
mel.eval('displayHairCurves "all" 1'); blendShape1 = cmds.blendShape(startHair,restHair,tc=0)[0]
cmds.setAttr(blendShape1+'.'+startHair,1)
#---------------- Create Current Joint
jntPntL = []; jntPntChildL = []; subLocL = []; jntL = []; jntGL = []
infoL = []; pntInfoL = []; pntRotL = []
if hairSys_on == 0:
for j in range(num_jnt):
cmds.select(d=1)
jnt = cmds.joint(rad = 2, n=mainName+'_cuJoint'+str(j))
cmds.setAttr(jnt+'.dla',1)
cmds.addAttr(jnt,ln='infoPos',sn='ip',at='double',min=0,max=num_jnt-1,dv=j)
cmds.setAttr(jnt+'.ip',e=1,k=1)
jntG = cmds.group(jnt,n=jnt+'_p')
info = cmds.createNode('pointOnCurveInfo', n=mainName+'_info'+str(j))
subLoc = cmds.spaceLocator(n=mainName+'_subLoc'+str(j))[0]
cmds.scale(.1,.1,.1,subLoc)
subLocL.append(subLoc); jntL.append(jnt); jntGL.append(jntG); infoL.append(info)
cmds.connectAttr(attachJointCurve+'.worldSpace[0]', info+'.inputCurve')
cmds.pointConstraint(subLoc,jntG)
normalCon = cmds.normalConstraint(normalBase,jntG,aim=up,u=aim,wut='vector')[0]
cmds.connectAttr(info+'.tangent',normalCon+'.wu')
cmds.connectAttr(info+'.position',subLoc+'.translate')
prRt = 0; sRt = 0; editP = 0
if posShp >= 0:
sRt = posShp/num_jnt + 1
editP = (j/float(num_jnt-1))**sRt
else:
sRt = 1-posShp/num_jnt
editP = 1-abs(j/float(num_jnt-1)-1)**sRt
import maya.mel as mel
prRt = mel.eval( 'linstep(0,1,%s)' % editP ) * (num_jnt-1)
cmds.setAttr(info+'.parameter', prRt/(num_jnt-1))
else:
for j in range(num_jnt):
cmds.select(d=1)
jnt = cmds.joint(rad = 2, n=mainName+'_cuJoint'+str(j))
cmds.setAttr(jnt+'.dla',1)
cmds.addAttr(jnt,ln='infoPos',sn='ip',at='double',min=0,max=num_jnt-1,dv=j)
cmds.setAttr(jnt+'.ip',e=1,k=1)
jntG = cmds.group(jnt,n=jnt+'_p')
info = cmds.createNode('pointOnCurveInfo', n=mainName+'_info'+str(j))
pntInfo = cmds.createNode('pointOnCurveInfo', n=mainName+'_pntInfo'+str(j))
cmds.setAttr(info+'.top', 1)
subLoc = cmds.spaceLocator(n=mainName+'_subLoc'+str(j))[0]; cmds.scale(.1,.1,.1,subLoc)
jntPntChild = cmds.spaceLocator(n=mainName+'_pntChild'+str(j))[0]
jntPnt = cmds.group(n=mainName+'_jntPnt'+str(j));
pntRot= cmds.createNode('plusMinusAverage', n=mainName+'_pntRot'+str(j))
cmds.connectAttr(jntPntChild+'.rotate', pntRot+'.input3D[0]')
subLocL.append(subLoc); jntL.append(jnt); jntGL.append(jntG); infoL.append(info)
jntPntChildL.append(jntPntChild); jntPntL.append(jntPnt); pntInfoL.append(pntInfo); pntRotL.append(pntRot)
cmds.connectAttr(startHair+'.worldSpace[0]', pntInfo+'.inputCurve')
cmds.connectAttr(attachJointCurve+'.worldSpace[0]', info+'.inputCurve')
cmds.pointConstraint(subLoc,jntG)
normalCon = cmds.normalConstraint(normalBase,jntPntChild,aim=up,u=aim,wut='vector')[0]
cmds.connectAttr(pntInfo+'.tangent',normalCon+'.wu')
cmds.connectAttr(info+'.position',subLoc+'.translate')
cmds.connectAttr(pntInfo+'.position', jntPnt+'.translate')
prRt = 0; sRt = 0; editP = 0
if posShp >= 0:
sRt = posShp/num_jnt + 1
editP = (j/float(num_jnt-1))**sRt
else:
sRt = 1-posShp/num_jnt
editP = 1-abs(j/float(num_jnt-1)-1)**sRt
import maya.mel as mel
prRt = mel.eval( 'linstep(0,1,%s)' % editP ) * (num_jnt-1)
cmds.setAttr(info+'.parameter', prRt/(num_jnt-1))
cmds.setAttr(pntInfo+'.parameter', prRt/(num_jnt-1))
normalCon = cmds.normalConstraint(normalBase,jntGL[0],aim=up,u=aim,wut='vector')[0]
jntPntNormalCon = cmds.normalConstraint(normalBase,jntPntL[0],aim=up,u=aim,wut='vector')[0]
cmds.connectAttr(infoL[0]+'.tangent',normalCon+'.wu')
cmds.connectAttr(pntInfoL[0]+'.tangent',jntPntNormalCon+'.wu')
for j in range(1,num_jnt):
cmds.tangentConstraint(attachJointCurve,jntGL[j],aim=aim,u=up,wu=up,wut='objectrotation',wuo=jntGL[j-1])
cmds.tangentConstraint(startHair,jntPntL[j],aim=aim,u=up,wu=up,wut='objectrotation',wuo=jntPntL[j-1])
if len(completeList) < len(jntL)*num_crv: completeList.extend(jntL) #------------- Out joint list
#--------------- Grouping
subLocG = cmds.group(subLocL,n=subLocL[0])
deformGrp = cmds.group(attachJointCurve,bindCurve,normalBase,subLocG, n=mainName+'_deformGrp')
cmds.setAttr(deformGrp+'.v', 0 )
transformGrp = cmds.group(em=1, n=mainName+'_trGrp')
parentCon = cmds.parentConstraint(conJoint[0],transformGrp )[0]
cmds.delete(parentCon)
cmds.parent(jntGL,conJoint[0],transformGrp)
#------------ Grouping in hairSystem
if hairSys_on != 0:
print hairSystem
jntPntG = cmds.group(jntPntL, n=mainName+'_jntPntG')
cmds.parent(jntPntG,deformGrp)
#-------------- Attribute Setting
conJointFirst = conJoint[0]
conJointSecond = conJoint[1]; cmds.setAttr(conJointSecond+'.template', 1)
conJointFirst_sliding = conJointFirst + '.sliding'
conJointFirst_length = conJointFirst + '.scale_length'
if sliding == 1:
cmds.addAttr(conJointFirst,ln='sliding',at='double')
cmds.setAttr(conJointFirst_sliding,e=1,k=1)
if length == 1:
cmds.addAttr(conJointFirst,ln='scale_length',at='double',min=0,max=num_jnt,dv=num_jnt)
cmds.setAttr(conJointFirst_length,e=1,k=1)
#----------- Set Expression String
exString = 'float $ip[];\n\n'
for k in range(num_jnt):
exString += '$ip[%s] = %s/%s;\n' % (k, jntL[k]+'.infoPos',num_jnt-1)
exString += '\n'
if length == 1:
exString += 'float $numJnt = %s;\n' % num_jnt
exString += 'float $length = %s/%s;\n\n' % (conJointFirst_length, num_jnt)
if sliding == 1:
exString += 'float $ep[];\n'
exString += 'float $sliding = %s;\n' % conJointFirst_sliding
exString += 'float $sRate;\n\n'
exString += 'if($sliding >= 0)\n{\n'
exString += '$sRate=$sliding/%s+1;\n' % num_jnt
for k in range(num_jnt):
exString += '$ep[%s] = pow($ip[%s],$sRate);\n' % (k,k)
exString += '}\nelse\n{\n'
exString += '$sRate= 1 - $sliding/%s;\n' % num_jnt
for k in range(num_jnt):
exString += '$ep[%s] = 1-pow(1-$ip[%s],$sRate);\n' % (k,k)
exString += '}\n\n'
if length == 1 and sliding == 1:
for k in range(num_jnt):
exString += '%s.parameter = linstep(0,1,$ep[%s])*$length;\n' % (infoL[k], k)
elif length == 1:
for k in range(num_jnt):
exString += '%s.parameter = $ip[%s]*$length;\n' % (infoL[k], k)
elif sliding == 1:
for k in range(num_jnt):
exString += '%s.parameter = linstep(0,1,$ep[%s]);\n' % (infoL[k], k)
else:
for k in range(num_jnt):
exString += '%s.parameter = $ip[%s];\n' % (infoL[k], k)
cmds.expression(s=exString,n=mainName+'_ex') #--------- expression
#-------------- Twist Attr Adding
if hairSys_on != 0:
if twist == 0:
for j in range(num_jnt):
cmds.connectAttr(pntRotL[j]+'.output3D', jntL[j]+'.jo')
if twist == 1:
cmds.addAttr(conJointFirst,ln='twist',at='double')
cmds.setAttr(conJointFirst+'.twist',e=1,k=1)
for j in range(num_jnt):
cmds.addAttr(jntL[j],ln='twistDetail',at='double',dv=j/float(num_jnt-1)*10)
cmds.setAttr(jntL[j]+'.twistDetail',e=1,k=1)
twistMult = cmds.createNode('multiplyDivide',n= jntL[j]+'_twistMult')
cmds.connectAttr(conJointFirst+'.twist', twistMult+'.input1X')
cmds.connectAttr(jntL[j]+'.twistDetail', twistMult+'.input2X')
rAxis = '.jo'
if aim[0] == 1 or aim[0] == -1:rAxis += 'x'
if aim[1] == 1 or aim[1] == -1:rAxis += 'y'
if aim[2] == 1 or aim[2] == -1:rAxis += 'z'
if hairSys_on == 0:
cmds.connectAttr(twistMult+'.outputX', jntL[j]+rAxis)
else:
cmds.connectAttr(twistMult+'.outputX', pntRotL[j]+'.input3D[1].input3D%s' % (rAxis.replace('.jo','')) )
cmds.connectAttr(pntRotL[j]+'.output3D', jntL[j]+'.jo')
#-------------- Add Controler
ctrer = []; ctrGG = []; ctrSubLocG = []; getPosShp = ''
curveSh = cmds.listRelatives(bindCurve,s=1)[0]
exString_in =''
for j in range(num_ctr):
ctrer.append( cmds.circle(n=mainName+'_ctr'+str(j),normal=aim)[0] )
cmds.addAttr( ctrer[j], ln='rollS', at='double', min=0,max=num_jnt,dv= num_jnt/2.0)
cmds.setAttr( ctrer[j]+'.rollS', e=1,k=1)
cmds.addAttr( ctrer[j], ln='rollE', at='double', min=0,max=num_jnt,dv=j*num_jnt/float(num_ctr))
cmds.setAttr( ctrer[j]+'.rollE', e=1,k=1)
ctrG = cmds.group( ctrer[j], n = mainName+'ctrG'+str(j) )
info = cmds.createNode('pointOnCurveInfo', n=bindCurve+'_info'+str(j))
cmds.setAttr(info+'.top',1)
cmds.connectAttr( curveSh+'.worldSpace[0]', info+'.inputCurve')
cmds.connectAttr( info+'.position', ctrG+'.translate')
mult = cmds.createNode( 'multiplyDivide', n= mainName+'_ctr_posMult'+str(j) )
cmds.connectAttr( ctrer[j]+'.rollE', mult+'.input1X')
cmds.setAttr( mult+'.input2X', 1.0/len(conJoint) )
cmds.connectAttr( mult+'.outputX',info+'.parameter' )
subLoc = cmds.spaceLocator( n=mainName+'_ctr_subLoc'+str(j) )[0]
cmds.connectAttr( info+'.position', subLoc+'.translate' )
cmds.pointConstraint( subLoc, ctrG )
normalCon = cmds.normalConstraint( normalBase,ctrG,aim=up,u=aim,wut='vector' )[0]
cmds.connectAttr( info+'.tangent', normalCon+'.wu')
ctrGG.append(ctrG); ctrSubLocG.append(subLoc)
if len(ctrGG) != 0: cmds.parent(ctrGG,transformGrp)
if len(ctrSubLocG) != 0: cmds.parent(ctrSubLocG,deformGrp)
exString = ''
rotDirection = ''
for j in range(3):
if aim[j] == -1:
rotDirection = '-1*'
for j in range(len(ctrer)):
exString += 'float $rollE%s = %s.rollE;\n' % (j, ctrer[j])
exString += 'float $rollS%s = %s.rollS + $rollE%s;\n' % (j, ctrer[j], j)
exString += 'int $irolE%s = $rollE%s;\n' % (j,j)
exString += 'int $irolS%s = $rollS%s;\n' % (j,j)
exString += 'float $rolev%s = $rollE%s - $irolE%s;\n' % (j,j,j)
exString += 'float $rolsv%s = $rollS%s - $irolS%s;\n\n' % (j,j,j)
exString += 'float $rx%s = %s%s.rotateX;\n' % (j, rotDirection, ctrer[j])
exString += 'float $ry%s = %s%s.rotateY;\n' % (j, rotDirection, ctrer[j])
exString += 'float $rz%s = %s%s.rotateZ;\n\n' % (j, rotDirection, ctrer[j])
exString += 'float $outRate%s[];\n\n' % j
exString += 'int $num_jnt%s = %s;\n\n' % (j,len(conJoint))
exString += 'for($i = 0; $i < $num_jnt%s; $i++)\n{\n' % j
exString += ' if($rollE%s > $i)\n $outRate%s[$i] = 0;' % (j,j)
exString += ' if($rollE%s > $i && $rollE%s < $i+1)\n $outRate%s[$i] = 1-$rolev%s;\n' % (j,j,j,j)
exString += ' if($rollE%s <= $i)\n $outRate%s[$i] = 1;\n\n' % (j,j)
exString += ' if($rollS%s > $i)\n $outRate%s[$i] *= 1;\n' % (j,j)
exString += ' if($rollS%s > $i && $rollS%s < $i+1)\n $outRate%s[$i] *= $rolsv%s;\n' % (j,j,j,j)
exString += ' if($rollS%s <= $i)\n $outRate%s[$i] *= 0;\n}\n\n' % (j,j)
rotList = ['rx','ry','rz']
for rot in rotList:
for j in range(len(conJoint)):
ra = rot.replace('r','ra')
exString += '%s.%s = ' % (conJoint[j],ra)
for k in range(len(ctrer)):
if k == len(ctrer)-1:
exString += '%s*$outRate%s[%s]*$%s%s;\n' % (aim[0]+aim[1]+aim[2],k,j,rot,k)
else:
exString += '%s*$outRate%s[%s]*$%s%s+' % (aim[0]+aim[1]+aim[2],k,j,rot,k)
exString+= '\n'
if len(ctrer) != 0: cmds.expression(s=exString, name = mainName+'_ctrEx')
cmds.select(cl=1)
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
#from ObjectScatter import *
import ObjectScatter
reload(ObjectScatter)
import maya.cmds as cmds
import random
points = [ cmds.pointPosition('curve1.cv[%i]'%i) for i in range(cmds.getAttr('curve1.spans') + cmds.getAttr('curve1.degree')) ]
tangent = [ cmds.pointOnCurve('curve1', pr=(1.0/23)*i, t=True) for i in range(23) ]
for pos in points:
cmds.select(cmds.polyCone(r=0.2, h=0.2)[0])
cmds.move(pos[0], pos[1], pos[2])
cmds.select(['curve1', cmds.ls(sl=True)[0]])
cmds.tangentConstraint(aimVector=(0,1,0), upVector=(1,0,1), worldUpType="vector",worldUpVector=(0,1,0))
new = cmds.polyCube()[0]
cmds.rotate(0, random.uniform(0, 360), 0)
cmds.move(random.uniform(0,8), 0, 0, os=True)
# UI
winName = "Object Scatter"
if(cmds.window(winName, exists=True)):
cmds.deleteUI(winName)
window = cmds.window( title=winName, iconName=winName, widthHeight=(512, 512), maximizeButton=False )
cmds.columnLayout( adjustableColumn=True )
cmds.button( label='Vertex Paint', command=lambda x: (cmds.PaintVertexColorToolOptions(), cmds.select(all=True)) )
def build(attachments=4,
sections=9,
sectionsSpans=8,
minRadius=0.0,
maxRadius=1.0,
startPt=[0.0, 0.0, 6.0],
endPt=[0.0, 0.0, -6.0],
prefix='muscle'):
'''
Build muscle primitive based on the input argument values between the start and end points
@param attachments: Number of attachments points
@type attachments: int
@param sections: Number of profile curves
@type sections: int
@param sectionSpans: Number of spans for profile curves
@type sectionSpans: int
@param minRadius: Minimum radius for muscle profile curves
@type minRadius: float
@param maxRadius: Maximum radius for muscle profile curves
@type maxRadius: float
@param startPt: Start point of the muscle
@type startPt: list
@param endPt: End point of the muscle
@type endPt: list
@param prefix: Name prefix for muscle primitive
@type prefix: str
@return: Muscle mesh
@returnType: str
'''
# Checks
# Get start, end and distance values
startPoint = glTools.utils.base.getMPoint(startPt)
endPoint = glTools.utils.base.getMPoint(endPt)
startEndOffset = endPoint - startPoint
startEndDist = startEndOffset.length()
startEndInc = startEndDist / (attachments - 1)
# Calculate attachment point positions
attachPoints = []
for i in range(attachments):
attachPoints.append(startPoint +
(startEndOffset.normal() * startEndInc * i))
# Start Tangent
if not i:
attachPoints.append(startPoint +
(startEndOffset.normal() * startEndInc * 0.5))
# End Tangent
if i == (attachments - 2):
attachPoints.append(startPoint +
(startEndOffset.normal() * startEndInc *
(i + 0.5)))
attachPts = [[pt.x, pt.y, pt.z] for pt in attachPoints]
# Resize attachments value to accomodate for tangent points
attachments = len(attachPts)
# ------------------------
# - Build base hierarchy -
# ------------------------
# Create groups
muscleGrp = mc.createNode('transform', n=prefix + '_group')
muscleAttachGrp = mc.createNode('transform',
n=prefix + '_attachment_group')
muscleProfileGrp = mc.createNode('transform', n=prefix + '_profile_group')
# Build hierarchy
mc.parent(muscleAttachGrp, muscleGrp)
mc.parent(muscleProfileGrp, muscleGrp)
# ----------------------
# - Build Muscle Curve -
# ----------------------
# Build muscle base curve
muscleCurve = mc.rename(
mc.curve(d=1, p=attachPts, k=range(len(attachPts))), prefix + '_curve')
mc.rebuildCurve(muscleCurve,
ch=0,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=1,
kep=1,
kt=1,
s=0,
d=1)
muscleCurveShape = mc.listRelatives(muscleCurve, s=True)[0]
mc.parent(muscleCurve, muscleAttachGrp)
# Add muscle attributes
mc.addAttr(muscleCurve, ln='muscle', at='message')
mc.addAttr(muscleCurve, ln='muscleObjectType', dt='string')
mc.setAttr(muscleCurve + '.muscleObjectType',
'spline',
type='string',
l=True)
# Connect curve to attachment locators
attachLocators = glTools.utils.curve.locatorCurve(muscleCurve,
locatorScale=0.1,
freeze=False,
prefix=prefix)
# Rename attachment locators and add muscle attibutes
for i in range(len(attachLocators)):
# Add muscle attibutes
mc.addAttr(attachLocators[i], ln='muscle', at='message')
mc.addAttr(attachLocators[i], ln='muscleObjectType', dt='string')
mc.setAttr(attachLocators[i] + '.muscleObjectType',
'attachment',
type='string',
l=True)
# Rename attachment locators
if not i:
attachLocators[i] = mc.rename(attachLocators[i],
prefix + '_attachStart_locator')
elif i == 1:
attachLocators[i] = mc.rename(
attachLocators[i], prefix + '_attachStartTangent_locator')
mc.setAttr(attachLocators[i] + '.muscleObjectType', l=False)
mc.setAttr(attachLocators[i] + '.muscleObjectType',
'attachmentTangent',
type='string',
l=True)
elif i == (attachments - 2):
attachLocators[i] = mc.rename(attachLocators[i],
prefix + '_attachEndTangent_locator')
mc.setAttr(attachLocators[i] + '.muscleObjectType', l=False)
mc.setAttr(attachLocators[i] + '.muscleObjectType',
'attachmentTangent',
type='string',
l=True)
elif i == (attachments - 1):
attachLocators[i] = mc.rename(attachLocators[i],
prefix + '_attachEnd_locator')
else:
attachLocators[i] = mc.rename(
attachLocators[i],
prefix + '_attachMid' + str(i - 1) + '_locator')
# Group attachment locators
attachLocGroup = []
[
attachLocGroup.append(glTools.utils.base.group(loc))
for loc in attachLocators
]
mc.parent(attachLocGroup, muscleAttachGrp)
# Create spline rebuild curve
splineCurve = mc.rebuildCurve(muscleCurve,
ch=1,
rpo=0,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=1,
s=5,
d=3)
splineRebuild = mc.rename(splineCurve[1], prefix + '_spline_rebuildCurve')
splineCurveShape = mc.rename(
mc.listRelatives(splineCurve[0], s=True)[0],
prefix + '_spline_curveShape')
mc.parent(splineCurveShape, muscleCurve, s=True, r=True)
mc.delete(splineCurve[0])
# Create tangent rebuild curve
tangentCurve = mc.rebuildCurve(muscleCurve,
ch=1,
rpo=0,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=1,
s=2,
d=3)
tangentRebuild = mc.rename(tangentCurve[1],
prefix + '_tangent_rebuildCurve')
tangentCurveShape = mc.rename(
mc.listRelatives(tangentCurve[0], s=True)[0],
prefix + '_tangent_curveShape')
mc.parent(tangentCurveShape, muscleCurve, s=True, r=True)
mc.delete(tangentCurve[0])
# Create curve visibility attributes
mc.addAttr(muscleCurve, ln='attachment', at='enum', en='Off:On:')
mc.setAttr(muscleCurve + '.attachment', k=False, cb=True)
mc.connectAttr(muscleCurve + '.attachment', muscleCurveShape + '.v')
mc.addAttr(muscleCurve, ln='spline', at='enum', en='Off:On:')
mc.setAttr(muscleCurve + '.spline', k=False, cb=True)
mc.connectAttr(muscleCurve + '.spline', splineCurveShape + '.v')
mc.addAttr(muscleCurve, ln='tangent', at='enum', en='Off:On:')
mc.setAttr(muscleCurve + '.tangent', k=False, cb=True)
mc.connectAttr(muscleCurve + '.tangent', tangentCurveShape + '.v')
mc.setAttr(muscleCurve + '.attachment', 0)
mc.setAttr(muscleCurve + '.spline', 1)
mc.setAttr(muscleCurve + '.tangent', 1)
# Setup start tangent toggle
mc.addAttr(attachLocators[0], ln='tangentControl', at='enum', en='Off:On:')
mc.setAttr(attachLocators[0] + '.tangentControl', k=False, cb=True)
mc.connectAttr(attachLocators[0] + '.tangentControl',
attachLocGroup[1] + '.v',
f=True)
startTangentBlend = mc.createNode('blendColors',
n=prefix + '_startTangent_blendColors')
mc.connectAttr(attachLocators[1] + '.worldPosition[0]',
startTangentBlend + '.color1',
f=True)
mc.connectAttr(attachLocators[2] + '.worldPosition[0]',
startTangentBlend + '.color2',
f=True)
mc.connectAttr(attachLocators[0] + '.tangentControl',
startTangentBlend + '.blender',
f=True)
mc.connectAttr(startTangentBlend + '.output',
muscleCurve + '.controlPoints[1]',
f=True)
# Setup end tangent toggle
mc.addAttr(attachLocators[-1],
ln='tangentControl',
at='enum',
en='Off:On:')
mc.setAttr(attachLocators[-1] + '.tangentControl', k=False, cb=True)
mc.connectAttr(attachLocators[-1] + '.tangentControl',
attachLocGroup[-2] + '.v',
f=True)
endTangentBlend = mc.createNode('blendColors',
n=prefix + '_endTangent_blendColors')
mc.connectAttr(attachLocators[-2] + '.worldPosition[0]',
endTangentBlend + '.color1',
f=True)
mc.connectAttr(attachLocators[-3] + '.worldPosition[0]',
endTangentBlend + '.color2',
f=True)
mc.connectAttr(attachLocators[-1] + '.tangentControl',
endTangentBlend + '.blender',
f=True)
mc.connectAttr(endTangentBlend + '.output',
muscleCurve + '.controlPoints[' + str(attachments - 2) +
']',
f=True)
# -------------------------------
# - Build Muscle Profile Curves -
# -------------------------------
# Initialize profile list
profileList = []
profileGrpList = []
profileFollowList = []
# Iterate through profiles
profileInc = 1.0 / (sections - 1)
for i in range(sections):
# Create profile curve
profile = mc.circle(ch=0,
c=(0, 0, 0),
nr=(0, 0, 1),
sw=360,
r=1,
d=3,
ut=0,
tol=0.01,
s=sectionsSpans,
n=prefix + '_profile' + str(i + 1) + '_curve')[0]
profileList.append(profile)
# Add muscle profile attribute
mc.addAttr(profile, ln='muscle', at='message')
mc.addAttr(profile, ln='muscleObjectType', dt='string')
mc.setAttr(profile + '.muscleObjectType',
'profile',
type='string',
l=True)
# Group profile curve
profileGrp = glTools.utils.base.group(profile)
profileGrpList.append(profileGrp)
# Skip start/end profiles
if (not i) or (i == (sections - 1)): continue
# Add curve parameter attribute
mc.addAttr(profile, ln='uValue', min=0.0, max=1.0, dv=profileInc * i)
mc.setAttr(profile + '.uValue', k=False, cb=True)
# Create profile pointOnCurveInfo node
profileCurveInfo = mc.createNode('pointOnCurveInfo',
n=prefix + '_profile' + str(i + 1) +
'_pointOnCurveInfo')
# Attach profile group to point on muscle spline curve
mc.connectAttr(splineCurveShape + '.worldSpace[0]',
profileCurveInfo + '.inputCurve',
f=True)
mc.connectAttr(profile + '.uValue',
profileCurveInfo + '.parameter',
f=True)
mc.connectAttr(profileCurveInfo + '.position',
profileGrp + '.translate',
f=True)
# Create profile follow group
profileFollowGrp = mc.createNode('transform',
n=prefix + '_profileFollow' +
str(i + 1) + '_group')
profileFollowList.append(profileFollowGrp)
mc.connectAttr(profileCurveInfo + '.position',
profileFollowGrp + '.translate',
f=True)
mc.parent(profileGrpList, muscleProfileGrp)
mc.parent(profileFollowList, muscleProfileGrp)
# ------------------------------------
# - Create profile orientation setup -
# ------------------------------------
oddProfile = sections % 2
intProfile = int(sections * 0.5)
midProfile = intProfile + oddProfile
intIncrement = 1.0 / intProfile
# Create mid profile orientConstraint
if oddProfile:
midPointObject = profileFollowList[midProfile - 2]
else:
midPointObject = mc.createNode('transform',
n=prefix + '_midPointFollow_group')
mc.parent(midPointObject, muscleProfileGrp)
midOrientCon = mc.orientConstraint([attachLocators[0], attachLocators[-1]],
midPointObject,
n=prefix + '_midPoint_orientConstraint')
# Create intermediate profile orientConstraints
for i in range(intProfile):
# Skip start/end profiles
if not i: continue
# Create orientConstraints
startMidOriCon = mc.orientConstraint(
[attachLocators[0], midPointObject], profileFollowList[i - 1])[0]
endMidOriCon = mc.orientConstraint(
[attachLocators[-1], midPointObject], profileFollowList[-(i)])[0]
startMidOriWt = mc.orientConstraint(startMidOriCon,
q=True,
weightAliasList=True)
endMidOriWt = mc.orientConstraint(endMidOriCon,
q=True,
weightAliasList=True)
# Set constraint weights
mc.setAttr(startMidOriCon + '.' + startMidOriWt[0],
1.0 - (intIncrement * i))
mc.setAttr(startMidOriCon + '.' + startMidOriWt[1], (intIncrement * i))
mc.setAttr(endMidOriCon + '.' + endMidOriWt[0],
1.0 - (intIncrement * i))
mc.setAttr(endMidOriCon + '.' + endMidOriWt[1], (intIncrement * i))
# Add constraint weight attribute to profile
mc.addAttr(profileList[i],
ln='twist',
min=0,
max=1,
dv=1.0 - (intIncrement * i),
k=True)
mc.addAttr(profileList[-(i + 1)],
ln='twist',
min=0,
max=1,
dv=1.0 - (intIncrement * i),
k=True)
# Connect twist attribite to constraint weights
startMidOriRev = mc.createNode('reverse',
n=profileList[i].replace(
'_curve', '_reverse'))
endMidOriRev = mc.createNode('reverse',
n=profileList[-(i + 1)].replace(
'_curve', '_reverse'))
mc.connectAttr(profileList[i] + '.twist',
startMidOriRev + '.inputX',
f=True)
mc.connectAttr(profileList[i] + '.twist',
startMidOriCon + '.' + startMidOriWt[0],
f=True)
mc.connectAttr(startMidOriRev + '.outputX',
startMidOriCon + '.' + startMidOriWt[1],
f=True)
mc.connectAttr(profileList[-(i + 1)] + '.twist',
endMidOriRev + '.inputX',
f=True)
mc.connectAttr(profileList[-(i + 1)] + '.twist',
endMidOriCon + '.' + endMidOriWt[0],
f=True)
mc.connectAttr(endMidOriRev + '.outputX',
endMidOriCon + '.' + endMidOriWt[1],
f=True)
# Create Profile tangent constraints
tangentConList = []
for i in range(len(profileGrpList)):
# Determine world up object
if not i:
# start profile
worldUpObject = attachLocators[0]
elif i == (len(profileGrpList) - 1):
# end profile
worldUpObject = attachLocators[-1]
else:
worldUpObject = profileFollowList[i - 1]
# Create constraint
tangentCon = mc.tangentConstraint(tangentCurveShape,
profileGrpList[i],
aim=[0, 0, -1],
u=[0, 1, 0],
wu=[0, 1, 0],
wut='objectrotation',
wuo=worldUpObject)
tangentConList.append(tangentCon)
# -----------------------------
# - Set profile radius values -
# -----------------------------
# Set default profile radius values
radiusList = glTools.utils.mathUtils.distributeValue(midProfile,
rangeStart=minRadius,
rangeEnd=maxRadius)
radiusList = [
glTools.utils.mathUtils.smoothStep(i, minRadius, maxRadius, 0.5)
for i in radiusList
]
for i in range(midProfile):
mc.setAttr(profileList[i] + '.scale', radiusList[i], radiusList[i],
radiusList[i])
mc.setAttr(profileList[-(i + 1)] + '.scale', radiusList[i],
radiusList[i], radiusList[i])
# ----------------------------
# - Generate Muscle Geometry -
# ----------------------------
# Loft mesh between profile curves
loft = mc.loft(profileList, u=0, c=0, d=3, ch=1, po=1)
muscleMesh = mc.rename(loft[0], prefix)
muscleLoft = mc.rename(loft[1], prefix + '_loft')
muscleTess = mc.listConnections(muscleLoft + '.outputSurface',
s=False,
d=True,
type='nurbsTessellate')[0]
muscleTess = mc.rename(muscleTess, prefix + '_nurbsTessellate')
mc.parent(muscleMesh, muscleGrp)
# Set nurbsTessellate settings
mc.setAttr(muscleTess + '.format', 2)
mc.setAttr(muscleTess + '.polygonType', 1)
mc.setAttr(muscleTess + '.uType', 1)
mc.setAttr(muscleTess + '.vType', 1)
mc.setAttr(muscleTess + '.uNumber', 20)
mc.setAttr(muscleTess + '.vNumber', 10)
# Add muscle mesh attributes
mc.addAttr(muscleMesh, ln='precision', at='long', min=1, dv=5)
mc.setAttr(muscleMesh + '.precision', k=False, cb=True)
mc.addAttr(muscleMesh, ln='tangentPrecision', at='long', min=1, dv=2)
mc.setAttr(muscleMesh + '.tangentPrecision', k=False, cb=True)
mc.addAttr(muscleMesh, ln='uDivisions', at='long', min=4, dv=20)
mc.setAttr(muscleMesh + '.uDivisions', k=False, cb=True)
mc.addAttr(muscleMesh, ln='vDivisions', at='long', min=3, dv=10)
mc.setAttr(muscleMesh + '.vDivisions', k=False, cb=True)
mc.addAttr(muscleMesh, ln='restLength', at='float', min=0, dv=startEndDist)
mc.setAttr(muscleMesh + '.restLength', k=False, cb=True)
mc.addAttr(muscleMesh,
ln='currentLength',
at='float',
min=0,
dv=startEndDist)
mc.setAttr(muscleMesh + '.currentLength', k=True)
mc.addAttr(muscleMesh, ln='lengthScale', at='float', min=0, dv=1)
mc.setAttr(muscleMesh + '.lengthScale', k=True)
mc.addAttr(muscleMesh, ln='muscleMessage', at='message')
mc.addAttr(muscleMesh, ln='muscleSpline', at='message')
mc.addAttr(muscleMesh, ln='attachment', at='message', m=True)
mc.addAttr(muscleMesh, ln='profile', at='message', m=True)
mc.addAttr(muscleMesh, ln='muscleObjectType', dt='string')
mc.setAttr(muscleMesh + '.muscleObjectType', 'geo', type='string', l=True)
# Connect muscle mesh attributes
mc.connectAttr(muscleCurve + '.message',
muscleMesh + '.muscleSpline',
f=True)
for i in range(len(attachLocators)):
mc.connectAttr(attachLocators[i] + '.message',
muscleMesh + '.attachment[' + str(i) + ']',
f=True)
mc.connectAttr(muscleMesh + '.message',
attachLocators[i] + '.muscle',
f=True)
for i in range(len(profileList)):
mc.connectAttr(profileList[i] + '.message',
muscleMesh + '.profile[' + str(i) + ']',
f=True)
mc.connectAttr(muscleMesh + '.message',
profileList[i] + '.muscle',
f=True)
# Connect muscle mesh attributes to curve rebuild settings
mc.connectAttr(muscleMesh + '.precision', splineRebuild + '.spans', f=True)
musclePreCondition = mc.createNode('condition',
n=prefix + '_precision_condition')
mc.setAttr(musclePreCondition + '.operation', 4) # Less Than
mc.connectAttr(muscleMesh + '.precision',
musclePreCondition + '.firstTerm',
f=True)
mc.connectAttr(muscleMesh + '.tangentPrecision',
musclePreCondition + '.secondTerm',
f=True)
mc.connectAttr(muscleMesh + '.precision',
musclePreCondition + '.colorIfTrueR',
f=True)
mc.connectAttr(muscleMesh + '.tangentPrecision',
musclePreCondition + '.colorIfFalseR',
f=True)
mc.connectAttr(musclePreCondition + '.outColorR',
tangentRebuild + '.spans',
f=True)
# Connect musle mesh attributes to nurbsTessellate settings
mc.connectAttr(muscleMesh + '.uDivisions', muscleTess + '.uNumber', f=True)
mc.connectAttr(muscleMesh + '.vDivisions', muscleTess + '.vNumber', f=True)
# Setup length calculation
muscleLenCurveInfo = mc.createNode('curveInfo',
n=prefix + '_length_curveInfo')
mc.connectAttr(splineCurveShape + '.worldSpace[0]',
muscleLenCurveInfo + '.inputCurve',
f=True)
mc.connectAttr(muscleLenCurveInfo + '.arcLength',
muscleMesh + '.currentLength',
f=True)
muscleLenDiv = mc.createNode('multiplyDivide',
n=prefix + '_length_multiplyDivide')
mc.setAttr(muscleLenDiv + '.operation', 2) # Divide
mc.setAttr(muscleLenDiv + '.input1', 1, 1, 1)
mc.setAttr(muscleLenDiv + '.input2', 1, 1, 1)
mc.connectAttr(muscleLenCurveInfo + '.arcLength',
muscleLenDiv + '.input1X',
f=True)
mc.connectAttr(muscleMesh + '.restLength',
muscleLenDiv + '.input2X',
f=True)
mc.connectAttr(muscleLenDiv + '.outputX',
muscleMesh + '.lengthScale',
f=True)
# -----------
# - Cleanup -
# -----------
# Parent start/end tangent locators
mc.parent(attachLocGroup[1], attachLocators[0])
mc.parent(attachLocGroup[-2], attachLocators[-1])
# Parent start/end profiles
mc.parent(profileGrpList[0], attachLocators[0])
mc.setAttr(profileGrpList[0] + '.t', 0.0, 0.0, 0.0)
mc.setAttr(profileGrpList[0] + '.r', 0.0, 0.0, 0.0)
mc.setAttr(profileGrpList[0] + '.s', 1.0, 1.0, 1.0)
mc.parent(profileGrpList[-1], attachLocators[-1])
mc.setAttr(profileGrpList[-1] + '.t', 0.0, 0.0, 0.0)
mc.setAttr(profileGrpList[-1] + '.r', 0.0, 0.0, 0.0)
mc.setAttr(profileGrpList[-1] + '.s', 1.0, 1.0, 1.0)
# Setup start/end profile scale compensation
attachStartScaleCompNode = mc.createNode('multiplyDivide',
n=prefix +
'_attachStart_multiplyDivide')
mc.setAttr(attachStartScaleCompNode + '.input1', 1, 1, 1)
mc.setAttr(attachStartScaleCompNode + '.operation', 2)
mc.connectAttr(attachLocators[0] + '.scale',
attachStartScaleCompNode + '.input2',
f=True)
mc.connectAttr(attachStartScaleCompNode + '.output',
profileGrpList[0] + '.scale',
f=True)
attachEndScaleCompNode = mc.createNode('multiplyDivide',
n=prefix +
'_attachEnd_multiplyDivide')
mc.setAttr(attachEndScaleCompNode + '.input1', 1, 1, 1)
mc.setAttr(attachEndScaleCompNode + '.operation', 2)
mc.connectAttr(attachLocators[-1] + '.scale',
attachEndScaleCompNode + '.input2',
f=True)
mc.connectAttr(attachEndScaleCompNode + '.output',
profileGrpList[-1] + '.scale',
f=True)
# Lock transforms
mc.setAttr(muscleGrp + '.inheritsTransform', 0)
mc.setAttr(muscleGrp + '.t', l=True, cb=True)
mc.setAttr(muscleGrp + '.r', l=True, cb=True)
mc.setAttr(muscleGrp + '.s', l=True, cb=True)
# Return result
return muscleMesh
def traceArc(space='camera'):
'''
The main function for creating the arc.
'''
if space not in ('world','camera'):
OpenMaya.MGlobal.displayWarning('Improper space argument.')
return
global ML_TRACE_ARC_PREVIOUS_SELECTION
global ML_TRACE_ARC_PREVIOUS_SPACE
globalScale = 1
if mc.optionVar(exists='ml_arcTracer_brushGlobalScale'):
globalScale = mc.optionVar(query='ml_arcTracer_brushGlobalScale')
#save for reset:
origTime = mc.currentTime(query=True)
#frame range
frameRange = utl.frameRange()
start = frameRange[0]
end = frameRange[1]
#get neccesary nodes
objs = mc.ls(sl=True, type='transform')
if not objs:
OpenMaya.MGlobal.displayWarning('Select objects to trace')
return
ML_TRACE_ARC_PREVIOUS_SELECTION = objs
ML_TRACE_ARC_PREVIOUS_SPACE = space
cam = None
nearClipPlane = None
shortCam = ''
if space=='camera':
cam = utl.getCurrentCamera()
#the arc will be placed just past the clip plane distance, but no closer than 1 unit.
nearClipPlane = max(mc.getAttr(cam+'.nearClipPlane'),1)
shortCam = mc.ls(cam, shortNames=True)[0]
topGroup = 'ml_arcGroup'
worldGrp = 'ml_arcWorldGrp'
localGrp = 'ml_localGrp_'+shortCam
#create nodes
if not mc.objExists(topGroup):
topGroup = mc.group(empty=True, name=topGroup)
parentGrp = topGroup
if space=='world' and not mc.objExists(worldGrp):
worldGrp = mc.group(empty=True, name=worldGrp)
mc.setAttr(worldGrp+'.overrideEnabled',1)
mc.setAttr(worldGrp+'.overrideDisplayType',2)
mc.parent(worldGrp, topGroup)
parentGrp = mc.ls(worldGrp)[0]
if space == 'camera':
camConnections = mc.listConnections(cam+'.message', plugs=True, source=False, destination=True)
if camConnections:
for cc in camConnections:
if '.ml_parentCam' in cc:
localGrp = mc.ls(cc, o=True)[0]
if not mc.objExists(localGrp):
localGrp = mc.group(empty=True, name=localGrp)
mc.parentConstraint(cam, localGrp)
mc.setAttr(localGrp+'.overrideEnabled',1)
mc.setAttr(localGrp+'.overrideDisplayType',2)
mc.parent(localGrp, topGroup)
mc.addAttr(localGrp, at='message', longName='ml_parentCam')
mc.connectAttr(cam+'.message', localGrp+'.ml_parentCam')
parentGrp = mc.ls(localGrp)[0]
#group per object:
group = []
for i,obj in enumerate(objs):
sn = mc.ls(obj,shortNames=True)[0]
name = sn.replace(':','_')
groupName = 'ml_{}_arcGrp'.format(name)
if mc.objExists(groupName):
mc.delete(groupName)
group.append(mc.group(empty=True, name=groupName))
group[i] = mc.parent(group[i],parentGrp)[0]
mc.setAttr(group[i]+'.translate', 0,0,0)
mc.setAttr(group[i]+'.rotate', 0,0,0)
with utl.UndoChunk():
#determine the method to run. Test fast against accurate.
#If fast is the same, continue with fast method.
#Otherwise revert to accurate method.
mc.currentTime(start)
fastPoints = arcDataFast([objs[0]], parentGrp, start+1, start+1, space, nearClipPlane, cam)
accuratePoints = arcDataAccurate([objs[0]], parentGrp, start+1, start+1, space, nearClipPlane, cam)
points = None
#if they're equivalent, continue with fast:
if [int(x*1000000) for x in fastPoints[0][0]] == [int(x*1000000) for x in accuratePoints[0][0]]:
points = arcDataFast([objs[0]], parentGrp, start, end, space, nearClipPlane, cam)
else:
points = arcDataAccurate([objs[0]], parentGrp, start, end, space, nearClipPlane, cam)
#create the curves and do paint effects
mc.ResetTemplateBrush()
brush = mc.getDefaultBrush()
mc.setAttr(brush+'.screenspaceWidth',1)
mc.setAttr(brush+'.distanceScaling',0)
mc.setAttr(brush+'.brushWidth',0.005)
for i,obj in enumerate(objs):
#setup brush for path
globalScale
mc.setAttr(brush+'.globalScale', globalScale)
mc.setAttr(brush+'.screenspaceWidth',1)
mc.setAttr(brush+'.distanceScaling',0)
mc.setAttr(brush+'.brushWidth',0.003)
#color
for c in ('R','G','B'):
color = random.uniform(0.3,0.7)
mc.setAttr(brush+'.color1'+c,color)
baseCurve = mc.curve(d=3,p=points[i])
#fitBspline makes a curve that goes THROUGH the points, a more accurate path
curve = mc.fitBspline(baseCurve, constructionHistory=False, tolerance=0.001, name='ml_arcTracer_curve_#')
mc.delete(baseCurve)
#paint fx
mc.AttachBrushToCurves(curve)
stroke = mc.ls(sl=True)[0]
mc.rename(mc.listConnections(stroke+'.brush', destination=False)[0], 'ml_arcTracer_brush_#')
stroke = mc.parent(stroke,group[i])[0]
mc.setAttr(stroke+'.overrideEnabled',1)
mc.setAttr(stroke+'.overrideDisplayType',2)
mc.setAttr(stroke+'.displayPercent',92)
mc.setAttr(stroke+'.sampleDensity',0.5)
mc.setAttr(stroke+'.inheritsTransform',0)
mc.setAttr(stroke+'.translate',0,0,0)
mc.setAttr(stroke+'.rotate',0,0,0)
curve = mc.parent(curve,group[i])[0]
mc.setAttr(curve+'.translate',0,0,0)
mc.setAttr(curve+'.rotate',0,0,0)
mc.hide(curve)
#setup brush for tics
if space=='camera':
mc.setAttr(brush+'.brushWidth',0.008)
if space=='world':
mc.setAttr(brush+'.brushWidth',0.005)
mc.setAttr(brush+'.color1G',0)
mc.setAttr(brush+'.color1B',0)
for t in range(len(points[i])):
frameCurve = None
if space=='camera':
vec = utl.Vector(points[i][t][0],points[i][t][1],points[i][t][2])
vec*=0.98
frameCurve = mc.curve(d=1,p=[points[i][t],vec[:]])
elif space=='world':
frameCurve = mc.circle(constructionHistory=False, radius=0.0001, sections=4)[0]
mc.setAttr(frameCurve+'.translate', points[i][t][0], points[i][t][1], points[i][t][2])
constraint = mc.tangentConstraint(curve, frameCurve, aimVector=(0,0,1), worldUpType='scene')
#mc.delete(constraint)
#check for keyframe
colorAttribute='color1G'
if mc.keyframe(obj, time=((t+start-0.5),(t+start+0.5)), query=True):
mc.setAttr(brush+'.color1R',1)
else:
mc.setAttr(brush+'.color1R',0)
mc.AttachBrushToCurves(curve)
stroke = mc.ls(sl=True)[0]
thisBrush = mc.listConnections(stroke+'.brush', destination=False)[0]
thisBrush = mc.rename(thisBrush, 'ml_arcTracer_brush_#')
#setup keyframes for frame highlighting
mc.setKeyframe(thisBrush, attribute='color1G', value=0, time=(start+t-1, start+t+1))
mc.setKeyframe(thisBrush, attribute='color1G', value=1, time=(start+t,))
stroke = mc.parent(stroke,group[i])[0]
mc.hide(frameCurve)
mc.setAttr(stroke+'.displayPercent',92)
mc.setAttr(stroke+'.sampleDensity',0.5)
frameCurve = mc.parent(frameCurve,group[i])[0]
if space=='camera':
mc.setAttr(stroke+'.inheritsTransform',0)
mc.setAttr(stroke+'.pressureScale[1].pressureScale_Position', 1)
mc.setAttr(stroke+'.pressureScale[1].pressureScale_FloatValue', 0)
mc.setAttr(stroke+'.translate',0,0,0)
mc.setAttr(stroke+'.rotate',0,0,0)
mc.setAttr(frameCurve+'.translate',0,0,0)
mc.setAttr(frameCurve+'.rotate',0,0,0)
mc.currentTime(origTime, edit=True)
panel = mc.getPanel(withFocus=True)
try:
mc.modelEditor(panel, edit=True, strokes=True)
except:
pass
mc.select(objs,replace=True)
mc.refresh()
def pathCurveSet(self, plusLength):
self.nearParam_list = list()
self.getLength_list = list()
self.pathCrv_attLoc_list = list()
self.upPathLoc_list = list()
cmds.addAttr('root_CON', ln='run', at='double', dv=0)
cmds.setAttr('root_CON.run', e=True, k=True)
cmds.createNode('transform', n='pathSet_GRP', p='noneTransform_GRP')
cvStartPos = self.customBodyJointsPos[0]
setLength = self.disDMS + plusLength
curvePos = [0, cvStartPos[1], setLength]
pathSet_crv = cmds.curve(p=[cvStartPos, curvePos], d=1)
cmds.rebuildCurve(pathSet_crv, d=3, s=10)
self.pathSet_crv = cmds.rename(pathSet_crv, 'pathSet_CRV')
self.pathSet_crvShp = cmds.listRelatives(self.pathSet_crv, s=1)[0]
pathSet_CIF = cmds.createNode('curveInfo', n='pathSet_CIF')
for i in self.FKNull:
nearDCM = cmds.createNode('decomposeMatrix')
nearestNode = cmds.createNode('nearestPointOnCurve')
arcLengthDMS = cmds.arcLengthDimension('%s.u[0]' %
self.pathSet_crv)
curveShape = cmds.listRelatives(self.pathSet_crv, s=1)[0]
cmds.connectAttr('%s.worldMatrix[0]' % i,
'%s.inputMatrix' % nearDCM)
cmds.connectAttr('%s.worldSpace[0]' % curveShape,
'%s.inputCurve' % nearestNode)
cmds.connectAttr('%s.outputTranslate' % nearDCM,
'%s.inPosition' % nearestNode)
nearParam = cmds.getAttr('%s.parameter' % nearestNode)
self.nearParam_list.append(nearParam)
cmds.setAttr('%s.uParamValue' % arcLengthDMS, nearParam)
getLength = cmds.getAttr('%s.arcLength' % arcLengthDMS)
self.getLength_list.append(getLength)
cmds.delete(nearDCM, nearestNode, arcLengthDMS)
#return getLength
print '%s.param = "%s"' % (i, nearParam)
print '%s.length = "%s"' % (i, getLength)
#return getLength,nearParam
pathCrv_attLoc = cmds.spaceLocator(
n=self.FKNull[self.FKNull.index(i)] + '_attatch_LOC')[0]
self.pathCrv_attLoc_list.append(pathCrv_attLoc)
cmds.setAttr('%s.template' % pathCrv_attLoc, 1)
cmds.hide(pathCrv_attLoc)
adl = cmds.createNode('addDoubleLinear',
n=pathCrv_attLoc.replace(
pathCrv_attLoc.split('_')[-1], 'ADL'))
clp = cmds.createNode('curveLength2ParamU',
n=pathCrv_attLoc.replace(
pathCrv_attLoc.split('_')[-1], 'CLP'))
poci = cmds.createNode('pointOnCurveInfo',
n=pathCrv_attLoc.replace(
pathCrv_attLoc.split('_')[-1], 'POCI'))
cmds.connectAttr('root_CON.run', '%s.input2' % adl)
cmds.setAttr('%s.input1' % adl, getLength)
cmds.connectAttr('%s.output' % adl, '%s.inputLength' % clp)
cmds.connectAttr('%s.worldSpace[0]' % self.pathSet_crvShp,
'%s.inputCurve' % clp)
cmds.connectAttr('%s.worldSpace[0]' % self.pathSet_crvShp,
'%s.inputCurve' % poci)
cmds.connectAttr('%s.outputParamU' % clp, '%s.parameter' % poci)
cmds.connectAttr('%s.position' % poci,
'%s.translate' % pathCrv_attLoc)
# reverse variable
pathCrv_attLoc_list_rev_range = list()
self.pathCrv_attLoc_list_rev = list(
) # pathCurve attatch Locator list reverse variable
FKNull_rev_range = list()
self.FKNull_rev = list() # fk null reverse variable
for j in self.pathCrv_attLoc_list:
pathCrv_attLoc_list_rev_range.append(
self.pathCrv_attLoc_list.index(j))
pathCrv_attLoc_list_rev_range.reverse()
for i in pathCrv_attLoc_list_rev_range:
self.pathCrv_attLoc_list_rev.append(self.pathCrv_attLoc_list[i])
for j in self.FKNull:
FKNull_rev_range.append(self.FKNull.index(j))
FKNull_rev_range.reverse()
for i in FKNull_rev_range:
self.FKNull_rev.append(self.FKNull[i])
for k in self.pathCrv_attLoc_list_rev: # controller upVec set and < pathCrv_attLoc connect to FKNull >
locXform = cmds.xform(k, ws=True, q=True, t=True)
upPathLoc = cmds.spaceLocator(
n=k.replace(k.split('_')[-1], 'upVec_LOC'),
p=(locXform[0], locXform[1], locXform[2]))[0]
self.upPathLoc_list.append(upPathLoc)
cmds.CenterPivot(upPathLoc)
cmds.setAttr('%s.template' % upPathLoc, 1)
cmds.setAttr('%s.ty' % upPathLoc, 20)
temp_MMX = cmds.createNode('multMatrix',
n=k.replace(k.split('_')[-1], 'MMX'))
temp_DCM = cmds.createNode('decomposeMatrix',
n=k.replace(k.split('_')[-1], 'DCM'))
if self.pathCrv_attLoc_list_rev.index(k) is 0:
cmds.connectAttr('%s.worldMatrix[0]' % k,
'%s.matrixIn[0]' % temp_MMX)
cmds.connectAttr('root_CON.worldInverseMatrix[0]',
'%s.matrixIn[1]' % temp_MMX)
cmds.connectAttr('%s.matrixSum' % temp_MMX,
'%s.inputMatrix' % temp_DCM)
cmds.connectAttr(
'%s.outputTranslate' % temp_DCM, '%s.translate' %
self.FKNull_rev[self.pathCrv_attLoc_list_rev.index(k)])
cmds.connectAttr(
'%s.outputRotate' % temp_DCM, '%s.rotate' %
self.FKNull_rev[self.pathCrv_attLoc_list_rev.index(k)])
elif self.pathCrv_attLoc_list_rev.index(k) is not 0:
cmds.connectAttr('%s.worldMatrix[0]' % k,
'%s.matrixIn[0]' % temp_MMX)
cmds.connectAttr(
'%s.worldInverseMatrix[0]' % self.pathCrv_attLoc_list_rev[
self.pathCrv_attLoc_list_rev.index(k) - 1],
'%s.matrixIn[1]' % temp_MMX)
cmds.connectAttr('%s.matrixSum' % temp_MMX,
'%s.inputMatrix' % temp_DCM)
cmds.connectAttr(
'%s.outputTranslate' % temp_DCM, '%s.translate' %
self.FKNull_rev[self.pathCrv_attLoc_list_rev.index(k)])
cmds.connectAttr(
'%s.outputRotate' % temp_DCM, '%s.rotate' %
self.FKNull_rev[self.pathCrv_attLoc_list_rev.index(k)])
# IKSub_loc_list , for curveVis locator
self.IKSub_loc_list = list()
for i in self.IKSubCon:
IKSub_loc = cmds.spaceLocator(
n=i.replace(i.split('_')[-1], 'LOC'))[0]
cmds.parentConstraint(i, IKSub_loc, mo=0)
self.IKSub_loc_list.append(IKSub_loc)
cmds.parent(IKSub_loc, 'upVecVisCurve_GRP')
cmds.toggle(IKSub_loc, template=True)
cmds.hide(IKSub_loc)
self.IKSub_loc_list.reverse()
# set upvec con
self.upVecPathLocControlSet()
# tangent constraint
for i in self.pathCrv_attLoc_list:
cmds.tangentConstraint(
self.pathSet_crv,
i,
aim=[0.0, 0.0, 1.0],
u=[0.0, 1.0, 0.0],
wut='object',
wuo='%s' %
self.upPathLoc_list[self.pathCrv_attLoc_list_rev.index(i)])
# set root matrix
self.addRootMatrix()
# set node hierachy structure
self.setNodeHierachy_second()
def tangentConstraint( *args , **kwargs ) : # tangentConstraint command return Constraint( mc.tangentConstraint( *args , **kwargs )[0] )
def tangentConstraint(*args, **kwargs):
# tangentConstraint command
return Constraint(mc.tangentConstraint(*args, **kwargs)[0])
def creat_anntena_base( selObj, jnt_str, jntOri, jointMethod, num_of_jnt ):
objectCondition = 0
for i in range(len(MakeAtna_returnV)):
del MakeAtna_returnV[0]
for i in selObj:
shape = cmds.listRelatives(i,s=1)
for j in shape:
if cmds.objectType(j) != 'nurbsCurve':
objectCondition = 1
if objectCondition == 1:
cmds.warning('Select Only Curve Object')
else:
returnTotal = []
for i in selObj:
returni =[]
jnt_main_name = jnt_str+str(selObj.index(i))
info_name = jnt_str +str(selObj.index(i)) + '_info'
cmds.setAttr(i+'.visibility',0)
i = cmds.rebuildCurve( i, ch=0, rpo=1, rt=3 ,end=1, kr=2, kcp=1, kep=0, kt=0, tol=0.01 )[0]
rebuildBase = ''
if jointMethod==1:
rebuildBase = cmds.rebuildCurve( i, ch=0, rpo=0, rt=0 ,end=1, kr=2, kcp=1, kep=0, kt=0, d=1, tol=0.01 )[0]
num_of_jnt = cmds.getAttr(rebuildBase+'.spans') + 1
else:
rebuildBase = cmds.rebuildCurve( i, ch=0, rpo=0, rt=0 ,end=1, kr=2, kcp=0, kep=0, kt=0, s=num_of_jnt-1, d=1, tol=0.01 )[0]
cmds.delete(i)
i = cmds.rebuildCurve( rebuildBase, ch=0, rpo=0, rt=0 ,end=1, kr=1, kcp=0, kep=0, kt=0, s=0, d=3, tol=0.01 )[0]
cmds.setAttr( i+'.v', 0)
returni.append([i])
returni[0].append(rebuildBase)
jntMainLst = []
for j in range(num_of_jnt):
cmds.select(d=1)
jntMainLst.append( cmds.joint(n = (jnt_main_name+'_conJoint'+str(j))) )
returni.append(jntMainLst)
xyzDic = { 'x' : [1,0,0], 'y' : [0,1,0], 'z' : [0,0,1] }
aim = xyzDic[ jntOri[1] ]
up = xyzDic[ jntOri[2] ]
if jntOri[0] == '-':
for k in range(3):
aim[k] = aim[k]*(-1)
jntGrpLst = []
infoLst = []
crvShp = cmds.listRelatives( rebuildBase, s=1 )[0]
posLst = []
for j in jntMainLst:
index = jntMainLst.index(j)
j = cmds.group(em=1)
jntGrpLst.append(j)
cmds.parent( jntMainLst[index], j )
info = cmds.createNode( 'pointOnCurveInfo', n=info_name+str(index) )
infoLst.append(info)
cmds.connectAttr( crvShp+'.worldSpace[0]', info+'.inputCurve' )
cmds.connectAttr( info+'.position', j+'.translate' )
cmds.setAttr( info+'.parameter', jntGrpLst.index(j) )
posLst.append( cmds.xform(j,q=1,ws=1,piv=1)[:3] )
jc = cmds.listRelatives( j, c=1, type='joint' )[0]
if jointMethod == 0:
cmds.addAttr( jc, ln='infoPos', sn='ip', at='double', min=0, max=num_of_jnt-1 )
cmds.setAttr( jc+'.ip', e=1, k=1 )
cmds.setAttr( jc+'.ip', jntGrpLst.index(j) )
cmds.setAttr( info+'.parameter', jntGrpLst.index(j) )
returni.append(jntGrpLst)
ep = ''
if jointMethod == 0:
ep = cmds.curve(ep=posLst)
cmds.setAttr(ep+'.v',0)
returni[0].append(ep)
ep = cmds.rebuildCurve( ep, ch=0, rpo=1, rt=3 ,end=1, kr=2, kcp=1, kep=0, kt=0, tol=0.01 )[0]
epShape= cmds.listRelatives(ep,s=1)[0]
for j in infoLst:
cmds.connectAttr( epShape+'.worldSpace[0]', j+'.inputCurve',f=1 )
clusterObj = []
clusterObj.extend(jntMainLst)
clusterObj.append(rebuildBase)
cmds.skinCluster(clusterObj)
else:
clusterObj = []
clusterObj.extend(jntMainLst)
clusterObj.append(i)
cmds.skinCluster(clusterObj)
if jointMethod == 0:
cmds.tangentConstraint( ep, jntGrpLst[0], aim=aim, u=up, wu=up, wut='scene' )
else:
cmds.tangentConstraint( rebuildBase, jntGrpLst[0], aim=aim, u=up, wu=up, wut='scene' )
for j in range(1,num_of_jnt):
if jointMethod == 0:
cmds.tangentConstraint( ep, jntGrpLst[j], aim=aim, u=up, wu=up, wut='objectrotation', wuo=jntMainLst[j-1] )
else:
cmds.tangentConstraint( rebuildBase, jntGrpLst[j], aim=aim, u=up, wu=up, wut='objectrotation', wuo=jntMainLst[j-1] )
returni.append(infoLst)
axis = [aim,up]
returni.append(axis)
for j in jntMainLst:
cmds.setAttr( j+'.dla', 1 )
cmds.setAttr( j+'.jox', 0 )
cmds.setAttr( j+'.joy', 0 )
cmds.setAttr( j+'.joz', 0 )
cmds.setAttr( j+'.tx', lock=1 )
cmds.setAttr( j+'.ty', lock=1 )
cmds.setAttr( j+'.tz', lock=1 )
cmds.setAttr( j+'.r'+jntOri[2], lock=1 )
cmds.setAttr( j+'.r'+jntOri[3], lock=1 )
#------------------ expression ----------------#
if jointMethod == 0:
cmds.addAttr(rebuildBase,ln='posShp',at='double')
cmds.setAttr(rebuildBase+'.posShp',e=1,k=1)
sliderAttr = rebuildBase+'.posShp'
exString = 'float $sRate;\n'
exString += 'float $ep[];\n'
exString += 'if (%s >= 0)\n' % sliderAttr
exString += '{\n'
exString += '$sRate=%s/%s+1;\n' % (sliderAttr,num_of_jnt)
for j in range(num_of_jnt):
exString += '$ep[%s]=pow((%s.infoPos/%s),$sRate);\n' % (j,returni[1][j],num_of_jnt-1)
exString += '}\n'
exString += 'else\n'
exString += '{\n'
exString += '$sRate=1-%s/%s;\n' % (sliderAttr,num_of_jnt)
for j in range(num_of_jnt):
exString += '$ep[%s]=1-pow(1-(%s.infoPos/%s),$sRate);\n' % (j,returni[1][j],num_of_jnt-1)
exString += '}\n'
for j in range(num_of_jnt):
exString += '%s.parameter = linstep(0,1,$ep[%s])*%s;\n' % (returni[3][j],j,num_of_jnt-1)
exName = i+'_jointPosShape'
cmds.expression(name=exName,s=exString,ae=1,uc='all')
returni.append(exName)
returnTotal.append(returni)
MakeAtna_returnV.extend(returnTotal)
