def createLocalBlendTwoMatrixObject( first, second, target = None ):
import sgBFunction_attribute
blMtx = cmds.createNode( 'blendTwoMatrixDecompose' )
cmds.connectAttr( first+'.m', blMtx+'.inMatrix1' )
cmds.connectAttr( second+'.m', blMtx+'.inMatrix2' )
if not target: target = cmds.createNode( 'transform' )
sgBFunction_attribute.addAttr( target, ln='blend', min=0, max=1, dv=0.5, k=1 )
cmds.connectAttr( target+'.blend', blMtx+'.attributeBlender' )
if cmds.nodeType( target ) == 'joint':
try:cmds.setAttr( target+'.jo', 0,0,0 )
except:pass
if not cmds.isConnected( blMtx+'.ot', target+'.t' ):
cmds.connectAttr( blMtx+'.ot', target+'.t', f=1 )
if not cmds.isConnected( blMtx+'.or', target+'.r' ):
cmds.connectAttr( blMtx+'.or', target+'.r', f=1 )
if not cmds.isConnected( blMtx+'.os', target+'.s' ):
cmds.connectAttr( blMtx+'.os', target+'.s', f=1 )
if not cmds.isConnected( blMtx+'.osh', target+'.sh' ):
cmds.connectAttr( blMtx+'.osh', target+'.sh', f=1 )
cmds.select( blMtx, target )
return blMtx, target
def getReverse(self):
reverseName = RemapConnectInfo._reverseName
reverseAttr = RemapConnectInfo._reverseAttr
reverses = cmds.ls( type='reverse' )
vrayRemapReverse = None
if not reverses: reverses = []
for reverse in reverses:
if cmds.attributeQuery( reverseAttr, node=reverse, ex=1 ):
vrayRemapReverse = reverse
break
if not vrayRemapReverse:
vrayRemapReverse = cmds.shadingNode( 'reverse', n=reverseName, asUtility=1 )
cmds.addAttr( vrayRemapReverse, ln=reverseAttr, at='message' )
samplerInfos = cmds.listConnections( vrayRemapReverse, s=1, d=0, type='samplerInfo' )
if not samplerInfos:
samplerInfo = self.getSamplerInfo()
if not cmds.isConnected( samplerInfo+'.facingRatio', vrayRemapReverse+'.inputX' ):
cmds.connectAttr( samplerInfo+'.facingRatio', vrayRemapReverse+'.inputX', f=1 )
if not cmds.isConnected( samplerInfo+'.facingRatio', vrayRemapReverse+'.inputY' ):
cmds.connectAttr( samplerInfo+'.facingRatio', vrayRemapReverse+'.inputY', f=1 )
if not cmds.isConnected( samplerInfo+'.facingRatio', vrayRemapReverse+'.inputZ' ):
cmds.connectAttr( samplerInfo+'.facingRatio', vrayRemapReverse+'.inputZ', f=1 )
return vrayRemapReverse
def createWorldBlendTwoMatrixObject( first, second, target = None ):
import sgBFunction_attribute
blMtx = cmds.createNode( 'blendTwoMatrix' )
mmdc = cmds.createNode( 'multMatrixDecompose' )
cmds.connectAttr( first+'.wm', blMtx+'.inMatrix1' )
cmds.connectAttr( second+'.wm', blMtx+'.inMatrix2' )
cmds.connectAttr( blMtx+'.outMatrix', mmdc+'.i[0]' )
if not target: target = cmds.createNode( 'transform' )
cmds.connectAttr( target+'.pim', mmdc+'.i[1]' )
sgBFunction_attribute.addAttr( target, ln='blend', min=0, max=1, dv=0.5, k=1 )
cmds.connectAttr( target+'.blend', blMtx+'.attributeBlender' )
if not cmds.isConnected( mmdc+'.ot', target+'.t' ):
cmds.connectAttr( mmdc+'.ot', target+'.t', f=1 )
if not cmds.isConnected( mmdc+'.or', target+'.r' ):
cmds.connectAttr( mmdc+'.or', target+'.r', f=1 )
if not cmds.isConnected( mmdc+'.os', target+'.s' ):
cmds.connectAttr( mmdc+'.os', target+'.s', f=1 )
if not cmds.isConnected( mmdc+'.osh', target+'.sh' ):
cmds.connectAttr( mmdc+'.osh', target+'.sh', f=1 )
cmds.select( blMtx, target )
return blMtx, target
def reverseCheck(self, remapNode, reverseCheck ):
if reverseCheck:
revNode = self.getReverse()
if not cmds.isConnected( revNode+'.output', remapNode+'.color' ):
cmds.connectAttr( revNode+'.output', remapNode+'.color', f=1 )
colorRCons = cmds.listConnections( remapNode+'.colorR', s=1, d=0, c=1, p=1 )
if colorRCons: cmds.disconnectAttr( colorRCons[1], colorRCons[0] )
colorGCons = cmds.listConnections( remapNode+'.colorG', s=1, d=0, c=1, p=1 )
if colorGCons: cmds.disconnectAttr( colorGCons[1], colorGCons[0] )
colorBCons = cmds.listConnections( remapNode+'.colorB', s=1, d=0, c=1, p=1 )
if colorBCons: cmds.disconnectAttr( colorBCons[1], colorBCons[0] )
else:
sampler = self.getSamplerInfo()
if not cmds.isConnected( sampler+'.facingRatio', remapNode+'.colorR' ):
cmds.connectAttr( sampler+'.facingRatio', remapNode+'.colorR' )
if not cmds.isConnected( sampler+'.facingRatio', remapNode+'.colorG' ):
cmds.connectAttr( sampler+'.facingRatio', remapNode+'.colorG' )
if not cmds.isConnected( sampler+'.facingRatio', remapNode+'.colorB' ):
cmds.connectAttr( sampler+'.facingRatio', remapNode+'.colorB' )
colorCons = cmds.listConnections( remapNode+'.color', s=1, d=0, c=1, p=1 )
if colorCons:
cmds.disconnectAttr( colorCons[1], colorCons[0] )
def addAngleDriverAttribute( sel ):
import sgBFunction_attribute
sgBFunction_attribute.addAttr( sel, ln='angleRate0', cb=1 )
sgBFunction_attribute.addAttr( sel, ln='angleRate1', cb=1 )
sgBFunction_attribute.addAttr( sel, ln='angleRate2', cb=1 )
if cmds.listConnections( sel, s=1, d=0, type='angleDriver' ): return None
selP = cmds.listRelatives( sel, p=1, f=1 )[0]
selName = sel.split( '|' )[-1]
targetDriver = cmds.createNode( 'angleDriver', n= 'angleDriver_' + selName )
mm = cmds.createNode( 'multMatrix', n='mm_' + selName )
base = cmds.createNode( 'transform', n= 'angleBase_' + selName )
base = cmds.parent( base, selP )[0]
cmds.xform( base, ws=1, matrix= cmds.getAttr( sel+'.wm' ) )
cmds.connectAttr( sel+'.wm', mm+'.i[0]' )
cmds.connectAttr( base+'.wim', mm+'.i[1]' )
cmds.connectAttr( mm+'.matrixSum', targetDriver+'.angleMatrix' )
sgBFunction_attribute.addAttr( sel, ln='angleRate0', cb=1 )
sgBFunction_attribute.addAttr( sel, ln='angleRate1', cb=1 )
sgBFunction_attribute.addAttr( sel, ln='angleRate2', cb=1 )
if not cmds.isConnected( targetDriver+'.outDriver0', sel+'.angleRate0' ):
cmds.connectAttr( targetDriver+'.outDriver0', sel+'.angleRate0' )
if not cmds.isConnected( targetDriver+'.outDriver1', sel+'.angleRate1' ):
cmds.connectAttr( targetDriver+'.outDriver1', sel+'.angleRate1' )
if not cmds.isConnected( targetDriver+'.outDriver2', sel+'.angleRate2' ):
cmds.connectAttr( targetDriver+'.outDriver2', sel+'.angleRate2' )
def tryConnect( srcAttr, dstAttr ):
if not cmds.isConnected( srcAttr, dstAttr ):
try:
cmds.connectAttr( srcAttr, dstAttr, f=1 )
except:
pymelAttr = pymel.core.ls( srcAttr )[0]
if not cmds.isConnected( pymelAttr.name(), dstAttr ):
try:cmds.connectAttr( pymelAttr.name(), dstAttr, f=1 )
except:pass
def isConnected(self, other, inOrder = True ): """:param other: other AttributeNode :returns: if the attributes are connected""" if not self.exists: raise AttributeNotFound( self._node.name, self._attribute ) if not other.exists: raise AttributeNotFound( self._node.name, self._attribute ) if inOrder: return mc.isConnected( self.fullname, other.fullname ) else: return mc.isConnected( other.fullname, self.fullname )
def getInstanceObject():
instObjName = 'sgPutObjectAtGround_instObj'
selItem = Functions.getSelectedObject()
selItemShape = cmds.listRelatives( selItem, s=1, f=1 )
if not selItemShape: return None
selItemShape = selItemShape[0]
if cmds.objExists( instObjName ):
instObjShape = cmds.listRelatives( instObjName, s=1, f=1 )[0]
if not cmds.isConnected( selItemShape + '.outMesh', instObjShape + '.inMesh' ):
cmds.connectAttr( selItemShape + '.outMesh', instObjShape + '.inMesh', f=1 )
dagPath = getDagPath( instObjShape )
fnMesh = OpenMaya.MFnMesh( dagPath )
fnMesh.getPoints( Tool_global.instancePoints )
return instObjName
shapeType = cmds.nodeType( selItemShape )
instObjShape = cmds.createNode( shapeType )
instObj = cmds.listRelatives( instObjShape, p=1, f=1 )[0]
instObj = cmds.rename( instObj, instObjName )
instObjShape = cmds.listRelatives( instObj, s=1, f=1 )[0]
Tool_global.instShape = instObjShape
if shapeType in ['nurbsSurface', 'nurbsCurve']:
inputAttr = 'create'
outputAttr = 'local'
elif shapeType == 'mesh':
inputAttr = 'inMesh'
outputAttr = 'outMesh'
if not cmds.isConnected( selItemShape + '.' + outputAttr, Tool_global.instShape + '.' + inputAttr ):
cmds.connectAttr( selItemShape + '.' + outputAttr, Tool_global.instShape + '.' + inputAttr, f=1 )
dagPath = getDagPath( instObjShape )
fnMesh = OpenMaya.MFnMesh( dagPath )
fnMesh.getPoints( Tool_global.instancePoints )
shadingEngine = cmds.listConnections( selItemShape, s=0, d=1, type='shadingEngine' )
if not shadingEngine:
cmds.sets( instObjShape, e=1, forceElement='initialShadingGroup' )
else:
cmds.sets( instObjShape, e=1, forceElement=shadingEngine[0] )
dagPath = getDagPath( instObjShape )
fnMesh = OpenMaya.MFnMesh( dagPath )
fnMesh.getPoints( Tool_global.instancePoints )
return instObj
def _setUpIBL():
if not c.objExists('myIbl') and not c.objExists('myIblShape'):
mel.eval('miCreateDefaultNodes()');
c.select(cl=True);
mel.eval('setCurrentRenderer mentalRay;');
ibl = c.createNode( 'mentalrayIblShape', n='myIbl' );
c.rename('mentalrayIbl1', 'myIblShape');
if(c.isConnected( 'myIbl.message', 'mentalrayGlobals.imageBasedLighting' ) != '0'):
c.evalDeferred( "c.connectAttr( 'myIbl.message', 'mentalrayGlobals.imageBasedLighting', f=True)", lp=True);
mel.eval('$path = `optionVar -q WeatherViz_HDR_Path`');
#mel.eval('$path = optionVar -q "WeatherViz_HDR_Path"');
mel.eval('AEassignFilenameCB myIbl.texture $path "image"');
c.setAttr('myIbl.colorGain', 14, 14, 14, type='double3');
#sets render stats
c.setAttr('myIbl.visibleInEnvironment', 1);
c.setAttr('myIbl.visibleInReflections', 1);
c.setAttr('myIbl.visibleInRefractions', 1);
c.setAttr('myIbl.visibleInFinalGather', 1);
c.setAttr('myIblShape.scaleX', 80);
c.setAttr('myIblShape.scaleY', 80);
c.setAttr('myIblShape.scaleZ', 80);
c.select(cl=True);
else:
mel.eval('$path = `optionVar -q WeatherViz_HDR_Path`');
mel.eval('AEassignFilenameCB myIbl.texture $path "image"');
def breakReferencePlaceholderConnections(shape):
"""
Break all reference placeholder connections to the shape.instObjGroups plug.
@param shape: Shape to break reference placeholder connections from.
@type shape: str
"""
# Get Shape Connections
placeHolderConn = cmds.listConnections(shape, s=True, d=True, p=True, c=True) or []
# For Each Connection Pair
for i in range(0, len(placeHolderConn), 2):
# Check Reference Connection
placeHolderNode = cmds.ls(placeHolderConn[i + 1], o=True)[0]
if glTools.utils.reference.isReference(placeHolderNode):
# Disconnect PlaceHolder
if cmds.isConnected(placeHolderConn[i], placeHolderConn[i + 1]):
try:
cmds.disconnectAttr(placeHolderConn[i], placeHolderConn[i + 1])
except:
print('FAILED: ' + placeHolderConn[i] + ' >X< ' + placeHolderConn[i + 1] + '!')
else:
print('Disconnected: ' + placeHolderConn[i] + ' >X< ' + placeHolderConn[i + 1] + '...')
else:
try:
cmds.disconnectAttr(placeHolderConn[i + 1], placeHolderConn[i])
except:
print('FAILED: ' + placeHolderConn[i + 1] + ' >X< ' + placeHolderConn[i] + '!')
else:
print('Disconnected: ' + placeHolderConn[i + 1] + ' >X< ' + placeHolderConn[i] + '...')
def uiCmd_connectBindPreMatrix( *args ):
selections = cmds.ls( sl=1 )
firsts = selections[:-1][::2]
seconds = selections[:-1][1::2]
last = selections[-1]
for i in range( len( firsts ) ):
first = firsts[i]
second = seconds[i]
cons = cmds.listConnections( first, type='skinCluster', d=1, s=0, c=1, p=1 )
outputs = cons[0::2]
inputs = cons[1::2]
for ii in range( len( outputs ) ):
if inputs[ii].find( 'matrix' ) == -1: continue
outputAttr = outputs[ii].replace( first, second ).replace( 'worldMatrix', 'worldInverseMatrix' )
inputAttr = inputs[ii].replace( 'matrix', 'bindPreMatrix' )
if inputAttr.find( last ) == -1: continue
if not cmds.isConnected( outputAttr, inputAttr ):
cmds.connectAttr( outputAttr, inputAttr, f=1 )
def checkExistingItp( self, mainBlendShape, targetGeoms, indies ):
neadIndies = []
for i in range( len( indies ) ):
index = indies[i]
targetGeomShape = cmds.listRelatives( targetGeoms[i+1], s=1 )[0]
if cmds.attributeQuery( 'isFixEditMesh', node=targetGeomShape, ex=1 ): continue
neadIndies.append( index )
itpNodes = cmds.listConnections( mainBlendShape, type='vectorInterpolation' )
if not itpNodes: return None
itpNodes = list( set( itpNodes ) )
for itpNode in itpNodes:
inputs = cmds.listConnections( itpNode, s=1, d=0, c=1, type='blendShape' )[::2]
if len( inputs ) != len( neadIndies ):
continue
inputConnected = True
for inputValue in inputs:
connected = False
for index in indies:
if cmds.isConnected( mainBlendShape+'.w[%d]' % index, inputValue ): connected=True
if not connected:
inputConnected = False
if inputConnected: return itpNode
return None
def duplicateOnlyCurve( curves ):
import sgBFunction_dag
curves = sgBFunction_dag.getChildrenCurveExists( curves )
newCurves = []
for curve in curves:
curveP = sgBFunction_dag.getParent( curve )
if curveP:
newCurveParent = sgBFunction_dag.makeCloneObject( curveP )
else:
newCurveParent = None
newCurveShape = cmds.createNode( 'nurbsCurve' )
curveShape = sgBFunction_dag.getShape( curve )
cmds.connectAttr( curveShape+'.local', newCurveShape+'.create' )
newCurve = sgBFunction_dag.getTransform( newCurveShape )
newCurve = cmds.rename( newCurve, 'du_' + curve.split( '|' )[-1] )
if newCurveParent:
newCurve = cmds.parent( newCurve, newCurveParent )[0]
newCurves.append( newCurve )
cmds.refresh()
for i in range( len( newCurves ) ):
curveShape = sgBFunction_dag.getShape( curves[i] )
newCurveShape = sgBFunction_dag.getShape( newCurves[i] )
if cmds.isConnected( curveShape+'.local', newCurveShape+'.create' ):
cmds.disconnectAttr( curveShape+'.local', newCurveShape+'.create' )
return newCurves
def connectOutput(self, dstAttr):
"""
Connect remapValue node output to destination plug.
@param dstAttr: Destination plug for remapValue node output.
@type dstAttr: str
"""
# Checks
if not glTools.utils.attribute.isAttr(dstAttr):
raise Exception(
'Destination attribute "'
+ dstAttr
+ '" is not a valid attribute! Unable to establish output connection...'
)
# Connect Output
outAttr = self._name + ".outValue"
if not mc.isConnected(outAttr, dstAttr):
try:
mc.connectAttr(outAttr, dstAttr, f=True)
except:
raise Exception('Error connecting remapValue output ("' + outAttr + '" >> "' + dstAttr + '")!')
else:
print(
'RemapValue node output "'
+ outAttr
+ '" already connected to destination plug "'
+ dstAttr
+ '"! Skipping...'
)
def mirrorConnect( target ):
import sgBFunction_attribute
if cmds.nodeType( target ) in [ 'transform', 'joint' ]:
mirrorTarget = mirrorTransform( target )
else:
mirrorTarget = mirrorNode( target )
srcCons = cmds.listConnections( target, s=1, d=0, p=1, c=1 )
outCons = srcCons[1::2]
inCons = srcCons[::2]
for i in range( len( outCons ) ):
outputNode, outputAttr = outCons[i].split( '.' )
inputAttr = inCons[i].split( '.' )[-1]
if cmds.nodeType( outputNode ) in [ 'transform', 'joint' ]:
mirrorOutputNode = mirrorTransform( outputNode )
else:
mirrorOutputNode = mirrorNode( outputNode )
if not cmds.attributeQuery( outputAttr, node=mirrorOutputNode, ex=1 ):
sgBFunction_attribute.copyAttribute( outputNode+'.'+outputAttr, mirrorOutputNode )
if not cmds.attributeQuery( inputAttr, node=mirrorTarget, ex=1 ):
sgBFunction_attribute.copyAttribute( target+'.'+inputAttr, mirrorTarget )
if not cmds.isConnected( mirrorOutputNode+'.'+outputAttr, mirrorTarget+'.'+inputAttr ):
cmds.connectAttr( mirrorOutputNode+'.'+outputAttr, mirrorTarget+'.'+inputAttr )
return mirrorTarget
def ctlVisConnection( ctl, targets, attrName = 'ctlVis' ):
import sgBFunction_attribute
sgBFunction_attribute.addAttr( ctl, ln=attrName, min=0, max=1, at='long', k=1 )
for target in targets:
targetP = cmds.listRelatives( target, p=1, f=1 )[0]
if not cmds.isConnected( ctl+'.'+attrName, target+'.v' ):
try:
cmds.connectAttr( ctl+'.'+attrName, target+'.v' )
except:
if not cmds.isConnected( ctl+'.'+attrName, targetP+'.v' ):
try:cmds.connectAttr( ctl+'.'+attrName, targetP+'.v' )
except:pass
def cmdCreate(self, *args ):
import sgBFunction_dag
controller = self.popupController.getFieldText()
curves = self.popupCurves.getFieldTexts()
curves = sgBFunction_dag.getChildrenShapeExists( curves )
copyAttrs = [ 'globalEnvelope', 'globalWave1', 'globalTimeMult1', 'globalOffset1', 'globalLength1', 'globalWave2', 'globalTimeMult2', 'globalOffset2', 'globalLength2' ]
targetCrvs = []
aimMatrixs = []
targetCrvGrps = cmds.createNode( 'transform', n= 'WobbleCurveGrp' )
aimMatrixGrps = cmds.createNode( 'transform', n= 'aimMatrixGrp' )
createNewCurve = cmds.checkBox( self.check, q=1, v=1 )
for curve in curves:
targetCrv, aimMatrix = sgRigCurve.createSgWobbleCurve( curve, True, createNewCurve, '_wobble' )
targetCrvs.append( targetCrv )
aimMatrixs.append( aimMatrix )
for copyAttr in copyAttrs:
sgRigAttribute.copyAttribute( targetCrv+'.'+copyAttr, controller )
if cmds.isConnected( controller+'.'+copyAttr, targetCrv+'.'+copyAttr ): continue
cmds.connectAttr( controller+'.'+copyAttr, targetCrv+'.'+copyAttr )
if createNewCurve : cmds.parent( targetCrvs, targetCrvGrps )
cmds.parent( aimMatrixs, aimMatrixGrps )
def displayModCombine( sels ):
import sgBFunction_dag
targetMeshObjs = []
sels = cmds.listRelatives( sels, s=1, f=1 )
for sel in sels:
if cmds.getAttr( sel+'.io' ): continue
selP = cmds.listRelatives( sel, p=1, f=1 )[0]
if selP.find( 'display_' ) == -1: continue
targetMeshObjs.append( selP )
targetMeshObjs = list( set( targetMeshObjs ) )
cmds.select( targetMeshObjs )
for targetMesh in targetMeshObjs:
displayMod = cmds.ls( targetMesh )[0]
realMod = displayMod.replace( 'display_', '' )
if not cmds.objExists( realMod ): continue
displayModShape = sgBFunction_dag.getShape( displayMod )
realModShape = sgBFunction_dag.getShape( realMod )
displayOrig = sgBFunction_dag.getOrigShape( displayModShape )
if not cmds.isConnected( realModShape+'.outMesh', displayOrig+'.inMesh' ):
cmds.connectAttr( realModShape+'.outMesh', displayOrig+'.inMesh', f=1 )
def rebuildConnections(self):
if not self.connectionStorage:
raise Exception('No connection data stored to connect attributes with.')
for node in self.connectionStorage:
print "Node :: %s" % node
for connectionPair in self.connectionStorage[node]:
if connectionPair[0] == 'parent':
try:
cmds.parent(node, connectionPair[1])
except:
print "Could not connect :: %s To :: %s" % (node, connectionPair[1])
if not cmds.objExists(connectionPair[0]) or not cmds.objExists(connectionPair[1]):
print '%s or %s are not valid objects, skipping to the next connection' % (
connectionPair[0], connectionPair[1])
continue
print "Connecting :: %s To :: %s" % (connectionPair[0], connectionPair[1])
if not cmds.isConnected(connectionPair[0], connectionPair[1]):
try:
cmds.connectAttr(connectionPair[0], connectionPair[1], f=True)
except:
print "Could not connect :: %s To :: %s" % (connectionPair[0], connectionPair[1])
def connectattributes(self):
"""Connect everything."""
for i in self.connections:
try:
if not cmds.isConnected(eval(i[0]), eval(i[1])):
cmds.connectAttr(eval(i[0]), eval(i[1]), force=True)
except RuntimeError as e:
logger.info(e)
def __connect_sculpt_control(self):
#--- this method connects the attributes of the sculpt group and control
#--- sculpt group
if '|' in self.mesh:
if not cmds.isConnected(self.sf_mesh_ctl_grp + '.' +
self.mesh.split('|')[-1],
self.mesh + '.v'):
cmds.connectAttr(self.sf_mesh_ctl_grp + '.' +
self.mesh.split('|')[-1],
self.mesh + '.v', force = True)
else:
if ':' in self.mesh:
if not cmds.isConnected(self.sf_mesh_ctl_grp + '.' +
self.mesh.split(':')[-1],
self.mesh + '.v'):
cmds.connectAttr(self.sf_mesh_ctl_grp + '.' +
self.mesh.split(':')[-1],
self.mesh + '.v', force = True)
else:
if not cmds.isConnected(self.sf_mesh_ctl_grp + '.' + self.mesh,
self.mesh + '.v'):
cmds.connectAttr(self.sf_mesh_ctl_grp + '.' + self.mesh,
self.mesh + '.v', force = True)
#--- sculpt control
cmds.connectAttr(self.sf_mesh_ctl + '.sculpt',
self.mesh_sculpt + '.v')
if cmds.objExists(self.mesh_bsp + '.' + self.mesh_result):
cmds.connectAttr(self.sf_mesh_ctl + '.blendValue',
self.mesh_bsp + '.' + self.mesh_result)
#--- check if the envelope of the blendShapes is connected
#--- with the sculpt_tool envelope attribute
if not cmds.isConnected(self.sf_mesh_ctl_grp + '.ENVELOPE',
self.sculpt_bsp + '.envelope'):
#--- connect the envelope of the blendShapes
#--- with the sf_mesh_ctl envelope attribute
cmds.connectAttr(self.sf_mesh_ctl_grp + '.ENVELOPE',
self.sculpt_bsp + '.envelope')
if '|' in self.mesh:
cmds.setAttr(self.sf_mesh_ctl_grp + '.' + self.mesh.split('|')[-1], 0)
else:
if ':' in self.mesh:
cmds.setAttr(self.sf_mesh_ctl_grp + '.' +
self.mesh.split(':')[-1], 0)
else:
cmds.setAttr(self.sf_mesh_ctl_grp + '.' + self.mesh, 0)
cmds.setAttr(self.sf_mesh_ctl_grp + '.ENVELOPE', 1)
def legTwistRepairSet():
blMts = cmds.ls( '*Leg_*_Ik2_blendMtx' )
ankleJnts = cmds.ls( '*Ankle_*_FootIk_JNT' )
for i in range( len( blMts ) ):
if not cmds.isConnected( ankleJnts[i]+'.wm', blMts[i]+'.inMatrix1' ):
cmds.connectAttr( ankleJnts[i]+'.wm', blMts[i]+'.inMatrix1', f=1 )
def tryConnect( sourceAttr, destAttr ):
try:
if not cmds.isConnected( sourceAttr, destAttr ):
try:
cmds.connectAttr( sourceAttr, destAttr, f=1 )
except:
cmds.warning( "Can't not Connect %s to %s." %( sourceAttr, destAttr ) )
except:
cmds.warning( "Can't not Connect %s to %s." %( sourceAttr, destAttr ) )
def doIt( self ):
targetCtls = cmds.ls( topInfo.targetNS+'*_CTL', tr=1 )
for ctl in targetCtls:
originName = ctl.replace( topInfo.targetNS, '' )
retargetBlenderCons = cmds.listConnections( ctl, type='retargetBlender', s=1, d=0 )
if retargetBlenderCons:
retargetBlender = retargetBlenderCons[0]
fnc.clearArrayElement( retargetBlender+'.input' )
inputLen = fnc.getLastIndex( retargetBlender+'.input' )+1
for i in range( inputLen ):
RTTrans = cmds.listConnections( retargetBlender+'.input[%d].transMatrix' % i )
if not RTTrans: continue
RTTrans = RTTrans[0].split( '_RTTrans' )[0]
RTNamespace = RTTrans.replace( originName, '' )
if RTNamespace != topInfo.sourceNS: continue
if not cmds.isConnected( self._timeControl+'.outWeight', retargetBlender+'.input[%d].weight' % i ):
cmds.connectAttr( self._timeControl+'.outWeight', retargetBlender+'.input[%d].weight' % i, f=1 )
udAttrBlenderCons = cmds.listConnections( ctl, type='udAttrBlender', s=1, d=0 )
if udAttrBlenderCons:
udAttrBlender = udAttrBlenderCons[0]
fnc.clearArrayElement( udAttrBlender+'.input' )
inputLen = fnc.getLastIndex( udAttrBlender+'.input' )+1
for i in range( inputLen ):
outputNodes = cmds.listConnections( udAttrBlender+'.input[%d].udAttr' % i, s=1, d=0 )
if not outputNodes: continue
if outputNodes[0].find( topInfo.sourceNS.replace( 'DGTR_','') ) == 0:
if not cmds.isConnected( self._timeControl+'.outWeight', udAttrBlender+'.input[%d].weight' % i ):
cmds.connectAttr( self._timeControl+'.outWeight', udAttrBlender+'.input[%d].weight' % i, f=1 )
def setKeyCurveMatrixObjects( curves, mtxObj ):
import sgBFunction_attribute
sgBFunction_attribute.addAttr( mtxObj, ln='keyCurveTarget', at='message' )
for curve in curves:
sgBFunction_attribute.addAttr( curve, ln='mtxObj_forKeyCurve', at='message' )
if cmds.isConnected( mtxObj + '.keyCurveTarget', curve + '.mtxObj_forKeyCurve' ): continue
cmds.connectAttr( mtxObj + '.keyCurveTarget', curve + '.mtxObj_forKeyCurve', f=1 )
def __add_scale_to_meshes(self):
#--- add the globalScale setup to the specified mesh offset groups
if self._addScaleToMeshes:
for mesh in self._addScaleToMeshes:
attribute.lock_all(mesh, True)
for axis in 'xyz':
main = self.baseNodes["mainControl"] + '.globalScale'
if not cmds.isConnected(main, mesh + '.s' + axis):
cmds.connectAttr(main, mesh + '.s' + axis)
attribute.lock_all(mesh)
def legTwistRepairSet():
blMts = cmds.ls('*Leg_*_Ik2_blendMtx')
ankleJnts = cmds.ls('*Ankle_*_FootIk_JNT')
for i in range(len(blMts)):
if not cmds.isConnected(ankleJnts[i] + '.wm', blMts[i] + '.inMatrix1'):
cmds.connectAttr(ankleJnts[i] + '.wm',
blMts[i] + '.inMatrix1',
f=1)
def setKeyCurve( keyCurve, targetCurve, objBaseMatrix = None ):
import sgBFunction_dag
import sgBFunction_base
sgBFunction_base.autoLoadPlugin( 'sgHair' )
nodes = sgBFunction_dag.getNodeFromHistory( targetCurve, 'sgHair_keyCurve' )
if not nodes:
node = cmds.deformer( targetCurve, type= 'sgHair_keyCurve' )[0]
cmds.connectAttr( 'time1.outTime', node+'.time' )
if objBaseMatrix:
mm = cmds.createNode( 'multMatrix' )
cmds.connectAttr( objBaseMatrix+'.wm', mm+'.i[0]' )
cmds.connectAttr( targetCurve+'.wim', mm+'.i[1]' )
cmds.connectAttr( mm+'.o', node+'.baseLocalMatrix' )
else:
node = nodes[0]
fnNode = om.MFnDependencyNode( sgBFunction_dag.getMObject( node ) )
cuTime = cmds.currentTime( q=1 )
plugKeys = fnNode.findPlug( 'keys' )
targetIndex = 0
for i in range( plugKeys.numElements() ):
plugKey = plugKeys[i]
plugFrame = plugKey.child( 0 )
timeValue = plugFrame.asMTime().value()
if cuTime == timeValue:
targetIndex = plugKey.logicalIndex()
break
if plugKey.logicalIndex() >= targetIndex:
targetIndex = plugKey.logicalIndex() + 1
if objBaseMatrix:
import sgBFunction_convert
mtxObj = cmds.getAttr( objBaseMatrix+'.wm' )
mtxInvCurve = cmds.getAttr( keyCurve+'.wim' )
mMtxObj = sgBFunction_convert.convertMatrixToMMatrix( mtxObj )
mMtxInvCurve = sgBFunction_convert.convertMatrixToMMatrix( mtxInvCurve )
mMtxLocal = mMtxObj * mMtxInvCurve
mtxLocal = sgBFunction_convert.convertMMatrixToMatrix( mMtxLocal )
cmds.setAttr( node+'.keys[%d].baseMatrix' % targetIndex, mtxLocal, type='matrix' )
cmds.setAttr( node+'.keys[%d].keyframe' % targetIndex, cuTime )
keyCurveShape = sgBFunction_dag.getShape( keyCurve )
if not cmds.isConnected( keyCurveShape+'.local', node+'.keys[%d].inputCurve' % targetIndex ):
cmds.connectAttr( keyCurveShape+'.local', node+'.keys[%d].inputCurve' % targetIndex, f=1 )
'''
def validateReferenceState( rfn ):
"""
Validate reference loaded state.
"""
isLoad = False
if cmds.objExists( rfn ) and cmds.nodeType( rfn ) == "reference":
rfn = rfn
if cmds.referenceQuery( rfn, isLoaded=True ):
pm = cmds.listConnections( rfn, type="proxyManager" )
if pm:
mlist = cmds.listConnections( "%s.proxyList" % pm[0], type="reference" )
active = cmds.listConnections( "%s.activeProxy" % pm[0], plugs=True )
if mlist:
for n in range( 0, len( mlist )):
#Validate load state.
if mlist[n] != rfn and cmds.referenceQuery( mlist[n], isLoaded=True ):
isLoad = True
break
#Validate active state.
if mlist[n] != rfn:
for a in range( 0, len( active )):
if cmds.isConnected( active[a], "%s.proxyMsg" % mlist[n] ):
isLoad = True
break
else:
for a in range( 0, len( active )):
if not cmds.isConnected( active[a], "%s.proxyMsg" % mlist[n] ):
isLoad = True
break
if isLoad is True:
break
#Validate attribute state.
if mlist[n] == rfn and not cmds.isConnected( "%s.proxyMsg" % mlist[n], "%s.sharedEditsOwner" % pm[0] ):
isLoad = True
break
else:
isLoad=True
else:
isLoad=True
if isLoad is False:
print "\n%s is not valid reference" % rfn
return isLoad
def pointOnCurveInfoDistanceReconnect( targetCurve, worldCtl ):
infos = cmds.listConnections( targetCurve, d=1, s=0, type='pointOnCurveInfo' )
trGeo = cmds.createNode( 'transformGeometry' )
cmds.connectAttr( targetCurve+'.local', trGeo+'.inputGeometry' )
cmds.connectAttr( worldCtl+'.wim', trGeo+'.transform' )
for info in infos:
if cmds.isConnected( trGeo+'.outputGeometry', info+'.inputCurve' ): continue
cmds.connectAttr( trGeo+'.outputGeometry', info+'.inputCurve', f=1 )
def bubbleShader(self, particleShapeName = []):
if not cmds.objExists(self.BUBBLE_SHADER_NAME):
anisotropic = cmds.shadingNode('anisotropic', asShader = True, name = self.BUBBLE_SHADER_NAME)
if not cmds.objExists(self.BUBBLE_SHADER_SG_NAME):
anisotropicSG = cmds.sets(renderable = True, noSurfaceShader = True, empty = True, name = self.BUBBLE_SHADER_SG_NAME)
if not cmds.objExists(self.BUBBLE_SHADER_RAMP_NAME):
ramp = cmds.createNode('ramp', name = self.BUBBLE_SHADER_RAMP_NAME)
if not cmds.objExists(self.BUBBLE_SHADER_SI_NAME):
samplerInfo = cmds.createNode('samplerInfo', name = self.BUBBLE_SHADER_SI_NAME)
if not cmds.isConnected('%s.facingRatio' % self.BUBBLE_SHADER_SI_NAME, '%s.uCoord' % self.BUBBLE_SHADER_RAMP_NAME):
cmds.connectAttr('%s.facingRatio' % self.BUBBLE_SHADER_SI_NAME, '%s.uCoord' % self.BUBBLE_SHADER_RAMP_NAME, force = True)
if not cmds.isConnected('%s.facingRatio' % self.BUBBLE_SHADER_SI_NAME, '%s.vCoord' % self.BUBBLE_SHADER_RAMP_NAME):
cmds.connectAttr('%s.facingRatio' % self.BUBBLE_SHADER_SI_NAME, '%s.vCoord' % self.BUBBLE_SHADER_RAMP_NAME, force = True)
if not cmds.isConnected('%s.outColor' % self.BUBBLE_SHADER_RAMP_NAME, '%s.incandescence' % self.BUBBLE_SHADER_NAME):
cmds.connectAttr('%s.outColor' % self.BUBBLE_SHADER_RAMP_NAME, '%s.incandescence' % self.BUBBLE_SHADER_NAME, force = True)
if not cmds.isConnected('%s.outColor' % self.BUBBLE_SHADER_NAME, '%s.surfaceShader' % self.BUBBLE_SHADER_SG_NAME):
cmds.connectAttr('%s.outColor' % self.BUBBLE_SHADER_NAME, '%s.surfaceShader' % self.BUBBLE_SHADER_SG_NAME, force = True)
cmds.setAttr("%s.colorEntryList[0].color" % self.BUBBLE_SHADER_RAMP_NAME, 0, 0, 0, type = 'double3')
cmds.setAttr("%s.colorEntryList[0].position" % self.BUBBLE_SHADER_RAMP_NAME, 0.96)
cmds.setAttr("%s.colorEntryList[1].color" % self.BUBBLE_SHADER_RAMP_NAME, 0.108, 0.108, 0.108, type = 'double3')
cmds.setAttr("%s.colorEntryList[1].position" % self.BUBBLE_SHADER_RAMP_NAME, 0.025)
cmds.setAttr("%s.colorEntryList[2].color" % self.BUBBLE_SHADER_RAMP_NAME, 1, 1, 1, type = 'double3')
cmds.setAttr("%s.colorEntryList[2].position" % self.BUBBLE_SHADER_RAMP_NAME, 0)
cmds.setAttr("%s.color" % self.BUBBLE_SHADER_NAME, 0.5, 0.5, 0.5, type = 'double3')
cmds.setAttr("%s.transparency" % self.BUBBLE_SHADER_NAME, 1, 1, 1, type = 'double3')
cmds.setAttr("%s.ambientColor" % self.BUBBLE_SHADER_NAME, 0, 0, 0, type = 'double3')
cmds.setAttr("%s.diffuse" % self.BUBBLE_SHADER_NAME, 0.8)
cmds.setAttr("%s.angle" % self.BUBBLE_SHADER_NAME, 301.538)
cmds.setAttr("%s.spreadX" % self.BUBBLE_SHADER_NAME, 88.9)
cmds.setAttr("%s.spreadY" % self.BUBBLE_SHADER_NAME, 62.431)
cmds.setAttr("%s.roughness" % self.BUBBLE_SHADER_NAME, 1)
cmds.setAttr("%s.fresnelRefractiveIndex" % self.BUBBLE_SHADER_NAME, 20)
cmds.setAttr("%s.specularColor" % self.BUBBLE_SHADER_NAME, 0.41, 0.41, 0.41, type = 'double3')
cmds.setAttr("%s.reflectedColor" % self.BUBBLE_SHADER_NAME, 0, 0, 0, type = 'double3')
cmds.setAttr("%s.anisotropicReflectivity" % self.BUBBLE_SHADER_NAME, 1)
if cmds.objExists(self.BUBBLE_SHADER_NAME) and cmds.objExists(self.BUBBLE_SHADER_SG_NAME):
for each in particleShapeName:
cmds.sets(each, edit = True, forceElement = self.BUBBLE_SHADER_SG_NAME)
def localize(skinClusters, transform):
"""
Localize skinCluster to the given transform
:param skinCluster: skinCluster to localize
:type skinCluster: str or list
:param transform: Transform to localize against
:type transform: str
"""
if not mc.objExists(transform):
raise RuntimeError("{} doesn't exist in the current Maya session.".format(transform))
transformDescedants = mc.listRelatives(transform, ad=True, type="transform")
if isinstance(skinClusters, basestring):
skinClusters = rigrepo.libs.common.toList(skinClusters)
for skinCluster in skinClusters:
infs = mc.skinCluster(skinCluster, q=True, inf=True)
geoTransform = mc.listRelatives(mc.skinCluster(skinCluster, q=True, geometry=True)[0], p=True)[0]
if geoTransform not in transformDescedants:
transform = geoTransform
if not infs:
return()
for inf in infs:
connection = mc.listConnections(inf+'.worldMatrix[0]', p=1, type='skinCluster')
for con in connection:
if skinCluster == con.split('.')[0]:
index = con.split('[')[1].split(']')[0]
# Nothing needs to be done if the bindPreMatrix is hooked up
if mc.listConnections('{0}.bindPreMatrix[{1}]'.format(skinCluster, index)):
continue
multMatrix = '{}__{}_localizeMatrix'.format(inf, skinCluster)
if not mc.objExists(multMatrix):
multMatrix = mc.createNode('multMatrix', n=multMatrix)
mc.setAttr(multMatrix+'.isHistoricallyInteresting', 0)
if not mc.isConnected(inf+'.worldMatrix[0]', multMatrix+'.matrixIn[1]'):
mc.connectAttr(inf+'.worldMatrix[0]', multMatrix+'.matrixIn[1]', f=1)
if not mc.isConnected(transform+'.worldInverseMatrix[0]', multMatrix+'.matrixIn[2]'):
mc.connectAttr(transform+'.worldInverseMatrix[0]', multMatrix+'.matrixIn[2]', f=1)
if not mc.isConnected(multMatrix+'.matrixSum', con):
mc.connectAttr(multMatrix+'.matrixSum', con, f=1)
def __init__(self):
timeControlNode = cmds.ls( topInfo.sourceNS[:-5]+'*', type='timeControl' )
if not timeControlNode: return None
timeControlNode = timeControlNode[0]
if not cmds.isConnected( 'time1.outTime', timeControlNode+'.inTime' ):
cmds.connectAttr( 'time1.outTime', timeControlNode+'.inTime' )
self._timeControlNode = timeControlNode
def __setup_scale_attribute(self):
if not self._addSpaceSwitch:
return
for ctl in self._addScaleToControl:
attribute.lock_n_hide(ctl, ['s'], True)
for axis in 'xyz':
if not cmds.listConnections(ctl + '.s' + axis):
if not cmds.isConnected(ctl + '.globalScale',
ctl + '.s' + axis):
cmds.connectAttr(ctl + '.globalScale',
ctl + '.s' + axis)
attribute.lock_n_hide(ctl, ['s'], False)
def connect_shader_set(shader_name, shader_sg):
"""
connects the shader name outColor to the shader set name.
:param shader_name: shader name to connect from.
:param shader_sg: shader SG set to connect to.
:return: <bool> True for success.
"""
out_attr = '{}.outColor'.format(shader_name)
in_attr = '{}.surfaceShader'.format(shader_sg)
if not cmds.isConnected(out_attr, in_attr):
cmds.connectAttr(out_attr, in_attr)
return True
def _setOceanLocation():
"""
Exposing a tool to help push the ocean into the right location based off the FX published fluid containers fluids_hrc
"""
## If the fluids_hrc exists
if cmds.objExists('fluids_hrc'):
if cmds.objExists('oceanPreviewPlane_prv'):
cmds.setAttr( 'oceanPreviewPlane_prv.translateX', cmds.getAttr('fluids_hrc.translateX') )
cmds.setAttr( 'oceanPreviewPlane_prv.translateZ', cmds.getAttr('fluids_hrc.translateZ') )
else:
cmds.warning('MISSING oceanPreviewPlane_prv node from scene....')
if cmds.objExists('ocean_srf'):
if not cmds.isConnected('oceanPreviewPlane_prv.translateX', 'ocean_srf.translateX'):
cmds.connectAttr('oceanPreviewPlane_prv.translateX', 'ocean_srf.translateX', f = True)
if not cmds.isConnected('oceanPreviewPlane_prv.translateZ', 'ocean_srf.translateZ'):
cmds.connectAttr('oceanPreviewPlane_prv.translateZ', 'ocean_srf.translateZ', f = True)
else:
cmds.warning('MISSING ocean_srf node from scene....')
else:
cmds.warning('NO fluids_hrc FOUND! Can not move the ocean into final position. PLEASE CHECK FX PUBLISH NOW!')
def coneccionEspejada():
objs = mc.ls(sl=1, type='transform')
if len(objs) >= 2:
NMDTRF = str(objs[0]) + '_COPY_TRF__NMD'
NMDROT = str(objs[0]) + '_COPY_ROT__NMD'
if not mc.objExists(NMDTRF):
NMDTRF = mc.createNode('multiplyDivide', n=NMDTRF)
mc.setAttr(NMDTRF + '.input2X', -1)
mc.setAttr(NMDTRF + '.input2Y', 1)
mc.setAttr(NMDTRF + '.input2Z', 1)
if not mc.isConnected(
str(objs[0]) + '.translate', NMDTRF + '.input1'):
mc.connectAttr(str(objs[0]) + '.translate',
NMDTRF + '.input1',
f=1)
mc.connectAttr(NMDTRF + '.output',
str(objs[1]) + '.translate',
f=1)
else:
print 'Ya existe el nodo' + NMDTRF
if not mc.objExists(NMDROT):
NMDROT = mc.createNode('multiplyDivide', n=NMDROT)
mc.setAttr(NMDROT + '.input2X', 1)
mc.setAttr(NMDROT + '.input2Y', -1)
mc.setAttr(NMDROT + '.input2Z', -1)
if not mc.isConnected(
str(objs[0]) + '.rotate', NMDROT + '.input1'):
mc.connectAttr(str(objs[0]) + '.rotate',
NMDROT + '.input1',
f=1)
mc.connectAttr(NMDROT + '.output',
str(objs[1]) + '.rotate',
f=1)
else:
print 'Ya existe el nodo' + NMDROT
else:
mc.warning(
'OJO: Selecciona dos transforms. El segundo copiara al primero\nFunciona para espejar.'
)
def cmd_connect(self):
controllerName = self.w_controller.lineEdit.text()
attributeType = self.w_connectionType.comboBox.currentText()
enumAttrName = self.w_connectionType.lineEdit.text()
targetObjects = []
targetAttrs = []
for i in range(self.w_objectList.treeWidget.topLevelItemCount()):
targetObjects.append(
self.w_objectList.treeWidget.topLevelItem(i).text(0))
targetAttrs.append(
self.w_objectList.treeWidget.topLevelItem(i).text(1))
from maya import cmds
cmds.undoInfo(ock=1)
sgCmds.addAttr(controllerName,
ln='_____',
at='enum',
en='visible_control',
cb=1)
if attributeType == 'Long Type':
for i in range(len(targetObjects)):
sgCmds.addAttr(controllerName,
ln=targetAttrs[i],
k=1,
min=0,
max=1,
at='long')
if cmds.isConnected(controllerName + '.' + targetAttrs[i],
targetObjects[i] + '.v'):
continue
pymel.core.connectAttr(controllerName + '.' + targetAttrs[i],
targetObjects[i] + '.v',
f=1)
elif attributeType == 'Enum Type':
sgCmds.addAttr(controllerName,
ln=enumAttrName,
at='enum',
en=":".join(targetAttrs) + ':',
k=1)
for i in range(len(targetObjects)):
conNode = pymel.core.createNode('condition')
pymel.core.connectAttr(controllerName + '.' + enumAttrName,
conNode + '.firstTerm')
conNode.attr('secondTerm').set(i)
conNode.attr('colorIfTrueR').set(1)
conNode.attr('colorIfFalseR').set(0)
pymel.core.connectAttr(conNode.attr('outColorR'),
targetObjects[i] + '.v',
f=1)
cmds.undoInfo(cck=1)
def _create_input_layer_connections(self, input_info):
for source, destination in input_info.iteritems():
source_deformer = cmds.listConnections("{}.inMesh".format(source),
plugs=True)
if source_deformer:
# cycle fix, this was fun.
if (source_deformer[0].rpartition(".")[0]
in cmds.listRelatives(self.root_node, ad=True)):
continue
dest_plug = "{}.inMesh".format(destination)
if cmds.isConnected(source_deformer[0], dest_plug):
continue
cmds.connectAttr(source_deformer[0], dest_plug, f=True)
def testCreateStageWithNewLayer(self):
# Create a proxy shape with empty stage to start with.
import mayaUsd_createStageWithNewLayer
shapeNode = mayaUsd_createStageWithNewLayer.createStageWithNewLayer()
# Verify that we got a proxy shape object.
mayaSel = cmds.ls(sl=True)
self.assertEqual(1, len(mayaSel))
nt = cmds.nodeType(shapeNode)
self.assertEqual('mayaUsdProxyShape', nt)
# Verify that the shape node is connected to time.
self.assertTrue(cmds.isConnected('time1.outTime', shapeNode + '.time'))
def reconnect_p2d(file, p2d):
f = file
p = p2d
#Reconnect file nodes to p2d node
for i in range(len(f)):
#To avoid error that already connected p2d to file node
if mc.isConnected(str(p[0] + '.' + p2dAttrs[0]),
str(f[i] + '.' + fileAttrs[0])) == False:
#connect every attribute
for attrIndex in range(len(fileAttrs)):
mc.connectAttr(p[0] + '.' + p2dAttrs[attrIndex],
f[i] + '.' + fileAttrs[attrIndex],
f=True)
def ctlVisConnection(ctl, targets, attrName='ctlVis'):
import sgBFunction_attribute
sgBFunction_attribute.addAttr(ctl,
ln=attrName,
min=0,
max=1,
at='long',
k=1)
for target in targets:
targetP = cmds.listRelatives(target, p=1, f=1)[0]
if not cmds.isConnected(ctl + '.' + attrName, target + '.v'):
try:
cmds.connectAttr(ctl + '.' + attrName, target + '.v')
except:
if not cmds.isConnected(ctl + '.' + attrName, targetP + '.v'):
try:
cmds.connectAttr(ctl + '.' + attrName, targetP + '.v')
except:
pass
def matdj():
k_sels=cmds.ls(sl=1)
if not cmds.objExists('kMskSG_b'):
cmds.sets(n='kMskSG_b',empty=1,renderable=1,noSurfaceShader=1)
if not cmds.objExists('kMskShader_b'):
cmds.shadingNode('surfaceShader',asShader=1,n='kMskShader_b')
cmds.setAttr('kMskShader_b.outColor',0,0,1,type='double3')
if not cmds.isConnected('kMskShader_b.outColor','kMskSG_b.surfaceShader'):
cmds.connectAttr('kMskShader_b.outColor','kMskSG_b.surfaceShader',f=1)
cmds.sets(k_sels,e=1,fe='kMskSG_b')
def connectSpareFiltersIndice(fromAttr,toAttr):
tempIndices = list()
if cmds.getAttr(toAttr,mi=True) is None:
cmds.connectAttr(fromAttr,toAttr+'[0]')
for index in cmds.getAttr(toAttr,mi=True):
if cmds.isConnected(fromAttr,toAttr+'['+str(index)+']'):
return
if len(cmds.connectionInfo(toAttr+'['+str(index)+']',sfd=True))==0:
cmds.connectAttr(fromAttr,toAttr+'['+str(index)+']')
return
tempIndices.append(index)
tempIndices = sorted(tempIndices)
cmds.connectAttr(fromAttr,toAttr+'['+str(len(tempIndices))+']')
def matqz():
k_sels=cc.ls(sl=1)
if not cc.objExists('kMskSG_p'):
cc.sets(n='kMskSG_p',empty=1,renderable=1,noSurfaceShader=1)
if not cc.objExists('kMskShader_p'):
cc.shadingNode('surfaceShader',asShader=1,n='kMskShader_p')
cc.setAttr('kMskShader_p.outColor',.2,0,.3,type='double3')
if not cc.isConnected('kMskShader_p.outColor','kMskSG_p.surfaceShader'):
cc.connectAttr('kMskShader_p.outColor','kMskSG_p.surfaceShader',f=1)
cc.sets(k_sels,e=1,fe='kMskSG_p')
def setAttribute(self, attr, value):
'''
Set remapValue node value or source plug.
@param attrName: RemapValue attribute name to set value or source plug for.
@type attrName: float or str
@param value: RemapValue attribute value or source plug.
@type value: int or float or str or None
'''
# Check None
if (value == None): return
# Check Numeric Input
if isinstance(value, (types.IntType, types.FloatType)):
# Set Numeric Attribute Value
try:
mc.setAttr(attr, value)
except:
raise Exception('Error setting remapValue attribute "' + attr +
'" value!')
return
# Check String Input
elif isinstance(value, types.StringTypes):
# Connect External Plug
if glTools.utils.attribute.isAttr(value):
if not mc.isConnected(value, attr):
try:
mc.connectAttr(value, attr, f=True)
except:
raise Exception(
'Error connecting remapValue attribute ("' +
value + '" >> "' + attr + '")!')
return
else:
print('RemapValue node attribute "' + attr +
'" already connected to source plug "' + inputValue +
'"! Skipping...')
return
else:
raise Exception(
'Source plug value is not a valid attribute! ("' + value +
'")')
# Invlaid Type
raise Exception(
'Invalid value type specified for remapValue attribute "' + attr +
'"! (' + str(type(value)) + ')!')
def getSourceConnection( src, trg ):
src = pymel.core.ls( src )[0]
trg = pymel.core.ls( trg )[0]
cons = src.listConnections( s=1, d=0, p=1, c=1 )
if not cons: return None
for destCon, srcCon in cons:
srcCon = srcCon.name()
destCon = destCon.name().replace( src, trg )
if cmds.nodeType( src ) == 'joint' and cmds.nodeType( trg ) =='transform':
destCon = destCon.replace( 'jointOrient', 'rotate' )
if not cmds.ls( destCon ): continue
if not cmds.isConnected( srcCon, destCon ):
cmds.connectAttr( srcCon, destCon, f=1 )
def mirrorTempControls(obj, plug=True):
attributes = []
#
allAttrs = cmds.listAttr(obj)
cbAttrs = cmds.listAnimatable(obj)
if allAttrs and cbAttrs:
orderedAttrs = [
attr for attr in allAttrs for cb in cbAttrs if cb.endswith(attr)
]
if u'visibility' in orderedAttrs:
orderedAttrs.remove(u'visibility')
orderedAttrs.append(u'visibility')
attributes.extend(orderedAttrs)
# print attributes
node = obj.replace('_L_', '_R_')
for attr in attributes:
#
if plug:
if cmds.objExists(obj +
'.%s' % attr) and cmds.objExists(node +
'.%s' % attr):
if not cmds.isConnected(obj + '.%s' % attr,
node + '.%s' % attr):
cmds.connectAttr(obj + '.%s' % attr,
node + '.%s' % attr,
f=True)
else:
if cmds.objExists(obj +
'.%s' % attr) and cmds.objExists(node +
'.%s' % attr):
if cmds.isConnected(obj + '.%s' % attr, node + '.%s' % attr):
cmds.disconnectAttr(obj + '.%s' % attr,
node + '.%s' % attr)
def __create_mat(self): # If the shader doesn't exist, create it if not cmds.objExists(self.mat_name): self.mat_name = cmds.shadingNode(self.mat_type, name=self.mat_name, asShader=True) # Set the properties of the shader cmds.setAttr(self.mat_name + '.color', self.mat_color[0], self.mat_color[1], self.mat_color[2], self.mat_color[3]) cmds.setAttr(self.mat_name + '.transparency', self.mat_trans[0], self.mat_trans[1], self.mat_trans[2], self.mat_trans[3]) # If the shading group doesn't exist, create it if not cmds.objExists(self.mat_sg_name): self.mat_sg_name = cmds.sets(renderable=True, noSurfaceShader=True, empty=True, name=self.mat_sg_name) # If not already connected, connect the shader and the shading group if not cmds.isConnected(self.mat_name + '.outColor', self.mat_sg_name + '.surfaceShader'): cmds.connectAttr(self.mat_name + '.outColor', self.mat_sg_name + '.surfaceShader')
def myDoIt(self, txt1, txt2, check):
source = cmds.textField(txt1, q=1, tx=1)
target = cmds.textField(txt2, q=1, tx=1)
target = target.strip().split(' ')
for i in target:
if cmds.isConnected(source + '.outMesh', i + '.inMesh'):
cmds.warning(i + u'已经关联')
else:
try:
cmds.connectAttr(source + '.outMesh',
i + '.inMesh',
f=check)
except RuntimeError as e:
cmds.warning(str(e))
def createLink(source, target, attr):
"""
:param str source:
:param str target:
:param str attr:
"""
# create tags
createTag(source, attr)
createTag(target, attr)
# connect tags
sourcePlug = getPlug(source, attr)
targetPlug = getPlug(target, attr)
if not cmds.isConnected(sourcePlug, targetPlug):
cmds.connectAttr(sourcePlug, targetPlug, force=True)
def setKeyCurveMatrixObjects(curves, mtxObj):
import sgBFunction_attribute
sgBFunction_attribute.addAttr(mtxObj, ln='keyCurveTarget', at='message')
for curve in curves:
sgBFunction_attribute.addAttr(curve,
ln='mtxObj_forKeyCurve',
at='message')
if cmds.isConnected(mtxObj + '.keyCurveTarget',
curve + '.mtxObj_forKeyCurve'):
continue
cmds.connectAttr(mtxObj + '.keyCurveTarget',
curve + '.mtxObj_forKeyCurve',
f=1)
def connect_reftrack_scenenode(self, refobj, scenenode):
"""Connect the given reftrack node with the given scene node
:param refobj: the reftrack node to connect
:type refobj: str
:param scenenode: the jb_sceneNode to connect
:type scenenode: str
:returns: None
:rtype: None
:raises: None
"""
conns = [("%s.scenenode" % refobj, "%s.reftrack" % scenenode),
("%s.taskfile_id" % scenenode, "%s.taskfile_id" % refobj)]
for src, dst in conns:
if not cmds.isConnected(src, dst):
cmds.connectAttr(src, dst, force=True)
def disConnectedFacialRig():
loc = 'facialCtrl_loc'
if mc.objExists(loc):
nodes = mc.listConnections(loc, s=True, d=False, p=True)
if nodes:
for each in nodes:
src = each
dsts = mc.listConnections(src, s=False, d=True, p=True)
if dsts:
for dst in dsts:
if mc.isConnected(src, dst):
mc.disconnectAttr(src, dst)
mc.parent(loc, w=True)
def setMultiObjectCombine(models):
first = models[0]
others = models[1:]
firstOrigShape = sgModelDag.getOrigShape(first)
for other in others:
if not cmds.objExists(other): continue
otherOrigShape = sgModelDag.getOrigShape(other)
if firstOrigShape == otherOrigShape: continue
if cmds.isConnected(firstOrigShape + '.outMesh',
otherOrigShape + '.inMesh'):
continue
cmds.connectAttr(firstOrigShape + '.outMesh',
otherOrigShape + '.inMesh',
f=1)
def addScaleControlObjectToSkined(ctl, target):
import sgModelDag
def getMultMtx(ctl, outputAttr):
ctlP = cmds.listRelatives(ctl, p=1)[0]
jntMms = cmds.listConnections(outputAttr, type='multMatrix')
ctlPMms = cmds.listConnections(ctlP + '.wim', type='multMatrix')
ctlMms = cmds.listConnections(ctl + '.wm', type='multMatrix')
if not jntMms: jntMms = []
if not ctlPMms: ctlPMms = []
if not ctlMms: ctlMms = []
targetMms = []
for jntMm in jntMms:
if jntMm in ctlMms and jntMm in ctlPMms:
targetMms.append(jntMm)
if targetMms: return targetMms[0]
mm = cmds.createNode('multMatrix')
cmds.connectAttr(outputAttr, mm + '.i[0]')
cmds.connectAttr(ctlP + '.wim', mm + '.i[1]')
cmds.connectAttr(ctl + '.wm', mm + '.i[2]')
return mm
skinClusters = sgModelDag.getNodeFromHistory(target, 'skinCluster')
if not skinClusters: return None
targetSkinCluster = skinClusters[0]
cons = cmds.listConnections(targetSkinCluster + '.matrix',
s=1,
d=0,
p=1,
c=1)
for i in range(0, len(cons), 2):
outputAttr = cons[i + 1]
mmNode = getMultMtx(ctl, outputAttr)
if not cmds.isConnected(mmNode + '.matrixSum', cons[i]):
cmds.connectAttr(mmNode + '.matrixSum', cons[i], f=1)
def removeLink(source, target, attr):
"""
:param str source:
:param str target:
:param str attr:
"""
# disconnect tags
sourcePlug = getPlug(source, attr)
targetPlug = getPlug(target, attr)
if cmds.isConnected(sourcePlug, targetPlug):
cmds.disconnectAttr(sourcePlug, targetPlug)
if cmds.objExists(sourcePlug):
cmds.deleteAttr(sourcePlug)
if cmds.objExists(targetPlug):
cmds.deleteAttr(targetPlug)
def setBindPreMatrix(joint, bindPreObj, targetMesh):
skinNodes = sgBFunction_dag.getNodeFromHistory(targetMesh, 'skinCluster')
if not skinNodes: return None
cons = cmds.listConnections(joint + '.wm', type='skinCluster', p=1, c=1)
for con in cons[1::2]:
skinCluster = con.split('.')[0]
if skinCluster != skinNodes[0]: continue
index = int(con.split('[')[-1].replace(']', ''))
if not cmds.isConnected(bindPreObj + '.wim',
skinCluster + '.bindPreMatrix[%d]' % index):
cmds.connectAttr(bindPreObj + '.wim',
skinCluster + '.bindPreMatrix[%d]' % index,
f=1)
def disconnected_attributes(settings, members):
members = cmds.ls(members, long=True)
original_connections = []
try:
for input in settings["inputs"]:
# Get source shapes
source_nodes = lib.lsattr("cbId", input["sourceID"])
sources = [i for i in source_nodes if
not cmds.referenceQuery(i, isNodeReferenced=True)
and i in members]
try:
source = sources[0]
except IndexError:
print("source_id:", input["sourceID"])
continue
# Get destination shapes (the shapes used as hook up)
destination_nodes = lib.lsattr("cbId", input["destinationID"])
destinations = [i for i in destination_nodes if i not in members
and i not in sources]
destination = destinations[0]
# Break connection
connections = input["connections"]
src_attribute = "%s.%s" % (source, connections[0])
dst_attribute = "%s.%s" % (destination, connections[1])
# store connection pair
if not cmds.isConnected(src_attribute, dst_attribute):
continue
cmds.disconnectAttr(src_attribute, dst_attribute)
original_connections.append([src_attribute, dst_attribute])
yield
finally:
# restore connections
for connection in original_connections:
try:
cmds.connectAttr(connection[0], connection[1])
except Exception as e:
print(e)
continue
def fix_animation():
sel_controller = cmds.ls(sl=True)
if len(sel_controller) < 1:
cmds.error(u'请选择一个控制器或物体')
else:
for item_controller in sel_controller:
list_attrs = cmds.listAttr(item_controller, k=True)
for item_attr in list_attrs:
attr_node = item_controller + '_' + item_attr
output_attr = attr_node + '.output'
input_attr = item_controller + '.' + item_attr
#print output_attr
#print input_attr
if cmds.objExists(attr_node):
if not cmds.isConnected(output_attr, input_attr):
cmds.connectAttr(output_attr, input_attr, f=True)
